webapp.py

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