many improvements
[~helmut/debian-dedup.git] / webapp.py
1 #!/usr/bin/python
2
3 import sqlite3
4 from wsgiref.simple_server import make_server
5
6 import jinja2
7 from werkzeug.debug import DebuggedApplication
8 from werkzeug.exceptions import HTTPException, NotFound
9 from werkzeug.routing import Map, Rule
10 from werkzeug.wrappers import Request, Response
11
12 jinjaenv = jinja2.Environment()
13
14 def format_size(size):
15     assert isinstance(size, int)
16     size = float(size)
17     fmt = "%d B"
18     if size >= 1024:
19         size /= 1024
20         fmt = "%.1f KB"
21     if size >= 1024:
22         size /= 1024
23         fmt = "%.1f MB"
24     if size >= 1024:
25         size /= 1024
26         fmt = "%.1f GB"
27     return fmt % size
28
29 jinjaenv.filters["format_size"] = format_size
30
31 package_template = jinjaenv.from_string(
32 """<html><head><title>duplication of {{ package|e }}</title></head>
33 <body><h1>{{ package|e }}</h1>
34 <p>Version: {{ version|e }}</p>
35 <p>Architecture: {{ architecture|e }}</p>
36 <p>Number of files: {{ num_files }}</p>
37 <p>Total size: {{ total_size|format_size }}</p>
38 {%- if shared -%}
39     {%- for function, sharing in shared.items() -%}
40         <h3>sharing with respect to {{ function }}</h3>
41         <table border='1'><tr><th>package</th><th>files shared</th><th>data shared</th></tr>
42         {%- for entry in sharing|sort(attribute="savable", reverse=true) -%}
43             <tr><td>{% if entry.package %}<a href="{{ entry.package|e }}">{{ entry.package|e }}</a>{% else %}self{% endif %}
44                 <a href="../compare/{{ package|e }}/{{ entry.package|default(package, true)|e }}">compare</a></td>
45             <td>{{ entry.duplicate }} ({{ (100 * entry.duplicate / num_files)|int }}%)</td>
46             <td>{{ entry.savable|format_size }} ({{ (100 * entry.savable / total_size)|int }}%)</td></tr>
47         {%- endfor -%}
48         </table>
49     {%- endfor -%}
50 {%- endif -%}
51 {{ content }}
52 </body></html>""")
53
54 detail_template = jinjaenv.from_string(
55 """<html><head><title>sharing between {{ details1.package|e }} and {{ details2.package|e }}</title></head>
56 <body><h1>{{ details1.package|e }} &lt;-&gt; {{ details2.package|e }}</h1>
57 {%- if shared -%}
58 <table border='1'><tr><th>size</th><th>filename in {{ details1.package|e }}</th><th>filename in {{ details2.package|e }}</th><th>hash functions</th></tr>
59     {%- for entry in shared|sort(attribute="size", reverse=true) -%}
60         <tr><td>{{ entry.size|format_size }}</td><td>{{ entry.filename1 }}</td><td>{{ entry.filename2 }}</td><td>
61         {%- for function, hashvalue in entry.functions.items() %}<a href="../../hash/{{ function|e }}/{{ hashvalue|e }}">{{ function|e }}</a> {% endfor %}</td></tr>
62     {%- endfor -%}
63 </table>
64 {%- endif -%}
65 </body></html>""")
66
67 hash_template = jinjaenv.from_string(
68 """<html><head><title>information on {{ function|e }} hash {{ hashvalue|e }}</title></head>
69 <body><h1>{{ function|e }} {{ hashvalue|e }}</h1>
70 <table border='1'><tr><th>package</th><th>filename</th><th>size</th></tr>
71 {%- for entry in entries -%}
72     <tr><td><a href="../../binary/{{ entry.package|e }}">{{ entry.package|e }}</a></td>
73     <td>{{ entry.filename|e }}</td><td>{{ entry.size|format_size }}</td></tr>
74 {%- endfor -%}
75 </table>
76 </body></html>""")
77
78 class Application(object):
79     def __init__(self):
80         self.db = sqlite3.connect("test.sqlite3")
81         self.cur = self.db.cursor()
82         self.routingmap = Map([
83             Rule("/binary/<package>", methods=("GET",), endpoint="package"),
84             Rule("/compare/<package1>/<package2>", methods=("GET",), endpoint="detail"),
85             Rule("/hash/<function>/<hashvalue>", methods=("GET",), endpoint="hash"),
86         ])
87
88     @Request.application
89     def __call__(self, request):
90         mapadapter = self.routingmap.bind_to_environ(request.environ)
91         try:
92             endpoint, args = mapadapter.match()
93             if endpoint == "package":
94                 return self.show_package(args["package"])
95             elif endpoint == "detail":
96                 return self.show_detail(args["package1"], args["package2"])
97             elif endpoint == "hash":
98                 return self.show_hash(args["function"], args["hashvalue"])
99             raise NotFound()
100         except HTTPException as e:
101             return e
102
103     def get_details(self, package):
104         self.cur.execute("SELECT version, architecture FROM package WHERE package = ?;",
105                          (package,))
106         row = self.cur.fetchone()
107         if not row:
108             raise NotFound()
109         version, architecture = row
110         details = dict(package=package,
111                        version=version,
112                        architecture=architecture)
113         self.cur.execute("SELECT count(filename), sum(size) FROM content WHERE package = ?;",
114                          (package,))
115         num_files, total_size = self.cur.fetchone()
116         details.update(dict(num_files=num_files, total_size=total_size))
117         return details
118
119     def show_package(self, package):
120         params = self.get_details(package)
121
122         shared = dict()
123         self.cur.execute("SELECT a.filename, a.function, a.hash, a.size, b.package FROM content AS a JOIN content AS b ON a.function = b.function AND a.hash = b.hash WHERE a.package = ? AND (a.filename != b.filename OR b.package != ?);",
124                          (package, package))
125         for afile, function, hashval, size, bpkg in self.cur.fetchall():
126             pkgdict = shared.setdefault(function, dict())
127             hashdict = pkgdict.setdefault(bpkg, dict())
128             fileset = hashdict.setdefault(hashval, (size, set()))[1]
129             fileset.add(afile)
130         sharedstats = {}
131         if shared:
132             for function, sharing in shared.items():
133                 sharedstats[function] = list()
134                 mapping = sharing.pop(package, dict())
135                 if mapping:
136                     duplicate = sum(len(files) for _, files in mapping.values())
137                     savable = sum(size * (len(files) - 1) for size, files in mapping.values())
138                     sharedstats[function].append(dict(package=None, duplicate=duplicate, savable=savable))
139                 for pkg, mapping in sharing.items():
140                     duplicate = sum(len(files) for _, files in mapping.values())
141                     savable = sum(size * len(files) for size, files in mapping.values())
142                     sharedstats[function].append(dict(package=pkg, duplicate=duplicate, savable=savable))
143
144         params["shared"] = sharedstats
145         return Response(package_template.render(**params).encode("utf8"),
146                         content_type="text/html")
147
148     def show_detail(self, package1, package2):
149         details1 = self.get_details(package1)
150         details2 = self.get_details(package2)
151
152         self.cur.execute("SELECT a.filename, b.filename, a.size, a.function, a.hash FROM content AS a JOIN content AS b ON a.function = b.function AND a.hash = b.hash WHERE a.package = ? AND b.package = ? AND a.filename != b.filename;",
153                         (package1, package2))
154         shared = dict()
155         for filename1, filename2, size, function, hashvalue in self.cur.fetchall():
156             shared.setdefault((filename1, filename2, size), dict())[function] = hashvalue
157         shared = [dict(filename1=filename1, filename2=filename2, size=size,
158                        functions=functions)
159                   for (filename1, filename2, size), functions in shared.items()]
160         params = dict(
161             details1=details1,
162             details2=details2,
163             shared=shared)
164         return Response(detail_template.render(**params).encode("utf8"),
165                         content_type="text/html")
166
167     def show_hash(self, function, hashvalue):
168         self.cur.execute("SELECT package, filename, size FROM content WHERE function = ? AND hash = ?;",
169                          (function, hashvalue))
170         entries = [dict(package=package, filename=filename, size=size)
171                    for package, filename, size in self.cur.fetchall()]
172         if not entries:
173             raise NotFound()
174         params = dict(function=function, hashvalue=hashvalue, entries=entries)
175         return Response(hash_template.render(**params).encode("utf8"),
176                         content_type="text/html")
177
178 def main():
179     app = Application()
180     #app = DebuggedApplication(app, evalex=True)
181     make_server("0.0.0.0", 8800, app).serve_forever()
182
183 if __name__ == "__main__":
184     main()