da66ed79e489c2b6d94f21a2c900ea8ca148b527
[~helmut/debian-dedup.git] / webapp.py
1 #!/usr/bin/python3
2
3 import argparse
4 import contextlib
5 import datetime
6 import io
7 import sqlite3
8 from wsgiref.simple_server import make_server
9
10 import jinja2
11 from werkzeug.exceptions import HTTPException, NotFound
12 from werkzeug.routing import Map, Rule
13 from werkzeug.utils import redirect
14 from werkzeug.wrappers import Request, Response
15 try:
16     from werkzeug.middleware.shared_data import SharedDataMiddleware
17 except ImportError:
18     from werkzeug.wsgi import SharedDataMiddleware
19
20 from dedup.utils import fetchiter
21
22 jinjaenv = jinja2.Environment(loader=jinja2.PackageLoader("dedup", "templates"))
23
24 def format_size(size):
25     sizef = float(size)
26     fmt = "%d B"
27     if sizef >= 1024:
28         sizef /= 1024
29         fmt = "%.1f KB"
30     if sizef >= 1024:
31         sizef /= 1024
32         fmt = "%.1f MB"
33     if sizef >= 1024:
34         sizef /= 1024
35         fmt = "%.1f GB"
36     return fmt % sizef
37
38 def function_combination(function1, function2):
39     if function1 == function2:
40         return function1
41     return "%s -> %s" % (function1, function2)
42
43 # Workaround for jinja bug #59 (broken filesizeformat)
44 jinjaenv.filters["filesizeformat"] = format_size
45
46 base_template = jinjaenv.get_template("base.html")
47 package_template = jinjaenv.get_template("binary.html")
48 detail_template = jinjaenv.get_template("compare.html")
49 hash_template = jinjaenv.get_template("hash.html")
50 index_template = jinjaenv.get_template("index.html")
51 source_template = jinjaenv.get_template("source.html")
52
53 def encode_and_buffer(stream):
54     stream.enable_buffering(16)
55     buff = io.BytesIO()
56     for elem in stream:
57         buff.write(elem.encode("utf8"))
58         if buff.tell() >= 2048:
59             yield buff.getvalue()
60             buff = io.BytesIO()
61     if buff.tell() > 0:
62         yield buff.getvalue()
63
64 def html_response(unicode_iterator, max_age=24 * 60 * 60):
65     resp = Response(encode_and_buffer(unicode_iterator), mimetype="text/html")
66     resp.cache_control.max_age = max_age
67     resp.expires = datetime.datetime.now() + datetime.timedelta(seconds=max_age)
68     return resp
69
70 class InternalRedirect(Exception):
71     def __init__(self, target, code=301):
72         Exception.__init__(self)
73         self.target = target
74         self.code = code
75
76 class Application:
77     def __init__(self, db):
78         self.db = db
79         self.routingmap = Map([
80             Rule("/", methods=("GET",), endpoint="index"),
81             Rule("/binary/<package>", methods=("GET",), endpoint="package"),
82             Rule("/compare/<package1>/<package2>", methods=("GET",), endpoint="detail"),
83             Rule("/hash/<function>/<hashvalue>", methods=("GET",), endpoint="hash"),
84             Rule("/source/<package>", methods=("GET",), endpoint="source"),
85         ])
86
87     def cursor(self):
88         return contextlib.closing(self.db.cursor())
89
90     @Request.application
91     def __call__(self, request):
92         mapadapter = self.routingmap.bind_to_environ(request.environ)
93         try:
94             endpoint, args = mapadapter.match()
95             if endpoint == "index" and not request.environ["PATH_INFO"]:
96                 raise InternalRedirect("/")
97             method = getattr(self, "show_" + endpoint, None)
98             if method is None:
99                 return NotFound()
100             return method(**args)
101         except InternalRedirect as r:
102             return redirect(request.environ["SCRIPT_NAME"] + r.target, r.code)
103         except HTTPException as e:
104             return e
105
106     def get_details(self, package):
107         with self.cursor() as cur:
108             cur.execute("SELECT id, version, architecture FROM package WHERE name = ?;",
109                         (package,))
110             row = cur.fetchone()
111             if not row:
112                 raise NotFound()
113             pid, version, architecture = row
114             details = dict(pid=pid,
115                            package=package,
116                            version=version,
117                            architecture=architecture)
118             cur.execute("SELECT count(filename), sum(size) FROM content WHERE pid = ?;",
119                         (pid,))
120             num_files, total_size = cur.fetchone()
121         if total_size is None:
122             total_size = 0
123         details.update(dict(num_files=num_files, total_size=total_size))
124         return details
125
126     def get_dependencies(self, pid):
127         with self.cursor() as cur:
128             cur.execute("SELECT required FROM dependency WHERE pid = ?;",
129                         (pid,))
130             return set(row[0] for row in fetchiter(cur))
131
132     def cached_sharedstats(self, pid):
133         sharedstats = {}
134         with self.cursor() as cur:
135             cur.execute("SELECT pid2, package.name, f1.name, f2.name, files, size FROM sharing JOIN package ON sharing.pid2 = package.id JOIN function AS f1 ON sharing.fid1 = f1.id JOIN function AS f2 ON sharing.fid2 = f2.id WHERE pid1 = ? AND f1.eqclass = f2.eqclass;",
136                         (pid,))
137             for pid2, package2, func1, func2, files, size in fetchiter(cur):
138                 curstats = sharedstats.setdefault(
139                         function_combination(func1, func2), list())
140                 if pid2 == pid:
141                     package2 = None
142                 curstats.append(dict(package=package2, duplicate=files,
143                                      savable=size))
144         return sharedstats
145
146     def show_index(self):
147         return html_response(index_template.stream(dict(urlroot="")))
148
149     def show_package(self, *, package):
150         params = self.get_details(package)
151         params["dependencies"] = self.get_dependencies(params["pid"])
152         params["shared"] = self.cached_sharedstats(params["pid"])
153         params["urlroot"] = ".."
154         with self.cursor() as cur:
155             cur.execute("SELECT content.filename, issue.issue FROM content JOIN issue ON content.id = issue.cid WHERE content.pid = ?;",
156                         (params["pid"],))
157             params["issues"] = dict(cur.fetchall())
158         return html_response(package_template.stream(params))
159
160     def compute_comparison(self, pid1, pid2):
161         """Compute a sequence of comparison objects ordered by the size of the
162         object in the first package. Each element of the sequence is a dict
163         defining the following keys:
164          * filenames: A set of filenames in package 1 (pid1) all referring to
165            the same object.
166          * size: Size of the object in bytes.
167          * matches: A mapping from filenames in package 2 (pid2) to a mapping
168            from hash function pairs to hash values.
169         """
170         with self.cursor() as cur, self.cursor() as cur2:
171             cur.execute("SELECT content.id, content.filename, content.size, hash.hash FROM content JOIN hash ON content.id = hash.cid JOIN duplicate ON content.id = duplicate.cid JOIN function ON hash.fid = function.id WHERE pid = ? AND function.name = 'sha512' ORDER BY size DESC;",
172                         (pid1,))
173             cursize = -1
174             files = dict()
175             minmatch = 2 if pid1 == pid2 else 1
176             cur2 = self.db.cursor()
177             for cid, filename, size, hashvalue in fetchiter(cur):
178                 if cursize != size:
179                     for entry in files.values():
180                         if len(entry["matches"]) >= minmatch:
181                             yield entry
182                     files.clear()
183                     cursize = size
184
185                 if hashvalue in files:
186                     files[hashvalue]["filenames"].add(filename)
187                     continue
188
189                 entry = dict(filenames=set((filename,)), size=size, matches={})
190                 files[hashvalue] = entry
191
192                 cur2.execute("SELECT fa.name, ha.hash, fb.name, filename FROM hash AS ha JOIN hash AS hb ON ha.hash = hb.hash JOIN content ON hb.cid = content.id JOIN function AS fa ON ha.fid = fa.id JOIN function AS fb ON hb.fid = fb.id WHERE ha.cid = ? AND pid = ? AND fa.eqclass = fb.eqclass;",
193                              (cid, pid2))
194                 for func1, hashvalue, func2, filename in fetchiter(cur2):
195                     entry["matches"].setdefault(filename, {})[func1, func2] = \
196                             hashvalue
197
198         for entry in files.values():
199             if len(entry["matches"]) >= minmatch:
200                 yield entry
201
202     def show_detail(self, *, package1, package2):
203         details1 = details2 = self.get_details(package1)
204         if package1 != package2:
205             details2 = self.get_details(package2)
206
207         shared = self.compute_comparison(details1["pid"], details2["pid"])
208         params = dict(
209             details1=details1,
210             details2=details2,
211             urlroot="../..",
212             shared=shared)
213         return html_response(detail_template.stream(params))
214
215     def show_hash(self, *, function, hashvalue):
216         if function == "image_sha512":
217             # backwards compatibility
218             raise InternalRedirect("/hash/png_sha512/%s" % hashvalue)
219
220         with self.cursor() as cur:
221             cur.execute("SELECT package.name, content.filename, content.size, f2.name FROM hash JOIN content ON hash.cid = content.id JOIN package ON content.pid = package.id JOIN function AS f2 ON hash.fid = f2.id JOIN function AS f1 ON f2.eqclass = f1.eqclass WHERE f1.name = ? AND hash = ?;",
222                         (function, hashvalue,))
223             entries = [dict(package=package, filename=filename, size=size,
224                             function=otherfunc)
225                        for package, filename, size, otherfunc in fetchiter(cur)]
226             if not entries:
227                 # Assumption: '~' serves as an infinite character larger than
228                 # any other character in the hash column.
229                 cur.execute("SELECT DISTINCT hash.hash FROM hash JOIN function ON hash.fid = function.id WHERE function.name = ? AND hash.hash >= ? AND hash.hash <= ? LIMIT 2;",
230                             (function, hashvalue, hashvalue + '~'))
231                 values = cur.fetchall()
232                 if len(values) == 1:
233                     raise InternalRedirect("/hash/%s/%s" %
234                                            (function, values[0][0]), 302)
235                 raise NotFound()
236         params = dict(function=function, hashvalue=hashvalue, entries=entries,
237                       urlroot="../..")
238         return html_response(hash_template.stream(params))
239
240     def show_source(self, *, package):
241         with self.cursor() as cur:
242             cur.execute("SELECT name FROM package WHERE source = ?;",
243                         (package,))
244             binpkgs = dict.fromkeys(pkg for pkg, in fetchiter(cur))
245             if not binpkgs:
246                 raise NotFound
247             cur.execute("SELECT p1.name, p2.name, f1.name, f2.name, sharing.files, sharing.size FROM sharing JOIN package AS p1 ON sharing.pid1 = p1.id JOIN package AS p2 ON sharing.pid2 = p2.id JOIN function AS f1 ON sharing.fid1 = f1.id JOIN function AS f2 ON sharing.fid2 = f2.id WHERE p1.source = ?;",
248                         (package,))
249             for binary, otherbin, func1, func2, files, size in fetchiter(cur):
250                 entry = dict(package=otherbin,
251                              funccomb=function_combination(func1, func2),
252                              duplicate=files, savable=size)
253                 oldentry = binpkgs.get(binary)
254                 if not (oldentry and oldentry["savable"] >= size):
255                     binpkgs[binary] = entry
256         params = dict(source=package, packages=binpkgs, urlroot="..")
257         return html_response(source_template.stream(params))
258
259 def main():
260     parser = argparse.ArgumentParser()
261     parser.add_argument("-d", "--database", action="store",
262                         default="test.sqlite3",
263                         help="path to the sqlite3 database file")
264     args = parser.parse_args()
265     app = Application(sqlite3.connect(args.database))
266     app = SharedDataMiddleware(app, {"/static": ("dedup", "static")})
267     make_server("0.0.0.0", 8800, app).serve_forever()
268
269 if __name__ == "__main__":
270     main()