www/webapp/handlers.py

   1 #!/usr/bin/python
   2
   3 import httplib
   4 import operator
   5 import os
   6 import simplejson
   7 import sqlite3
   8 import time
   9 import urlparse
  10
  11 import tornado.httpclient
  12 import tornado.locale
  13 import tornado.web
  14
  15 from banners import banners
  16 from helpers import size
  17 from info import info
  18 from news import news
  19 from releases import releases
  20
  21 import builds
  22 import cluster
  23 import translations
  24 #import uriel
  25
  26 class BaseHandler(tornado.web.RequestHandler):
  27         def get_user_locale(self):
  28                 uri = self.request.uri.split("/")
  29                 if len(uri) > 1:
  30                         for lang in tornado.locale.get_supported_locales(None):
  31                                 if lang[:2] == uri[1]:
  32                                         return tornado.locale.get(lang)
  33
  34         @property
  35         def render_args(self):
  36                 return {
  37                         "banner"    : banners.get(),
  38                         "lang"      : self.locale.code[:2],
  39                         "langs"     : [l[:2] for l in tornado.locale.get_supported_locales(None)],
  40                         "lang_link" : self.lang_link,
  41                         "link"      : self.link,
  42                         "title"     : "no title given",
  43                         "server"    : self.request.host.replace("ipfire", "<span>ipfire</span>"),
  44                         "uri"       : self.request.uri,
  45                         "year"      : time.strftime("%Y"),
  46                 }
  47
  48         def render(self, *args, **kwargs):
  49                 nargs = self.render_args
  50                 nargs.update(kwargs)
  51                 nargs["title"] = "%s - %s" % (self.request.host, nargs["title"])
  52                 tornado.web.RequestHandler.render(self, *args, **nargs)
  53
  54         def link(self, s):
  55                 return "/%s/%s" % (self.locale.code[:2], s)
  56
  57         def lang_link(self, lang):
  58                 return "/%s/%s" % (lang, self.request.uri[4:])
  59
  60         def get_error_html(self, status_code, **kwargs):
  61                 if status_code in (404, 500):
  62                         render_args = self.render_args
  63                         render_args.update({
  64                                 "code"      : status_code,
  65                                 "exception" : kwargs.get("exception", None),
  66                                 "message"   : httplib.responses[status_code],
  67                         })
  68                         return self.render_string("error-%s.html" % status_code, **render_args)
  69                 else:
  70                         return tornado.web.RequestHandler.get_error_html(self, status_code, **kwargs)
  71
  72
  73 class MainHandler(BaseHandler):
  74         def get(self):
  75                 lang = self.locale.code[:2]
  76                 self.redirect("/%s/index" % (lang))
  77
  78
  79 class DownloadHandler(BaseHandler):
  80         def get(self):
  81                 self.render("downloads.html", release=releases.latest)
  82
  83
  84 class DownloadAllHandler(BaseHandler):
  85         def get(self):
  86                 self.render("downloads-all.html", releases=releases)
  87
  88
  89 class DownloadDevelopmentHandler(BaseHandler):
  90         def get(self):
  91                 self.render("downloads-development.html", releases=releases)
  92
  93
  94 class DownloadTorrentHandler(BaseHandler):
  95         tracker_url = "http://tracker.ipfire.org:6969/stats?format=txt&mode=tpbs"
  96
  97         @tornado.web.asynchronous
  98         def get(self):
  99                 http = tornado.httpclient.AsyncHTTPClient()
 100                 http.fetch(self.tracker_url, callback=self.async_callback(self.on_response))
 101
 102         def on_response(self, response):
 103                 torrents = releases.torrents
 104                 hashes = {}
 105                 if response.code == 200:
 106                         for line in response.body.split("\n"):
 107                                 if not line: continue
 108                                 hash, seeds, peers = line.split(":")
 109                                 hash.lower()
 110                                 hashes[hash] = {
 111                                         "peers" : peers,
 112                                         "seeds" : seeds,
 113                                 }
 114
 115                 self.render("downloads-torrents.html",
 116                         hashes=hashes,
 117                         releases=torrents,
 118                         request_time=response.request_time,
 119                         tracker=urlparse.urlparse(response.request.url).netloc)
 120
 121
 122 class StaticHandler(BaseHandler):
 123         @property
 124         def static_path(self):
 125                 return os.path.join(self.application.settings["template_path"], "static")
 126
 127         @property
 128         def static_files(self):
 129                 ret = []
 130                 for filename in os.listdir(self.static_path):
 131                         if filename.endswith(".html"):
 132                                 ret.append(filename)
 133                 return ret
 134
 135         def get(self, name=None):
 136                 name = "%s.html" % name
 137
 138                 if not name in self.static_files:
 139                         raise tornado.web.HTTPError(404)
 140
 141                 self.render("static/%s" % name)
 142
 143
 144 class IndexHandler(BaseHandler):
 145         def get(self):
 146                 self.render("index.html", news=news)
 147
 148
 149 class NewsHandler(BaseHandler):
 150         def get(self):
 151                 self.render("news.html", news=news)
 152
 153
 154 class BuildHandler(BaseHandler):
 155         def prepare(self):
 156                 self.builds = {
 157                         "<12h" : [],
 158                         ">12h" : [],
 159                         ">24h" : [],
 160                 }
 161
 162                 for build in builds.find():
 163                         if (time.time() - float(build.get("date"))) < 12*60:
 164                                 self.builds["<12h"].append(build)
 165                         elif (time.time() - float(build.get("date"))) < 24*60:
 166                                 self.builds[">12h"].append(build)
 167                         else:
 168                                 self.builds[">24h"].append(build)
 169
 170                 for l in self.builds.values():
 171                         l.sort()
 172
 173         def get(self):
 174                 self.render("builds.html", builds=self.builds)
 175
 176
 177 class UrielBaseHandler(BaseHandler):
 178         #db = uriel.Database()
 179         pass
 180
 181 class UrielHandler(UrielBaseHandler):
 182         def get(self):
 183                 pass
 184
 185
 186 class ApiClusterInfoHandler(BaseHandler):
 187         def get(self):
 188                 id = self.get_argument("id", "null")
 189
 190                 c = cluster.Cluster(info["cluster"]["hostname"])
 191
 192                 self.write(simplejson.dumps({
 193                         "version": "1.1",
 194                         "id": id,
 195                         "result" : c.json,
 196                         "error" : "null", }))
 197                 self.finish()
 198
 199
 200 class TranslationHandler(BaseHandler):
 201         def get(self):
 202                 self.render("translations.html", projects=translations.projects)
 203
 204
 205 class SourceHandler(BaseHandler):
 206         def prepare(self):
 207                 if not hasattr(self, "db"):
 208                         self.db = sqlite3.connect("/srv/www/ipfire.org/source/hashes.db")
 209                         c = self.db.cursor()
 210                         c.execute("CREATE TABLE IF NOT EXISTS hashes(file, sha1)")
 211                         c.close()
 212
 213         def get(self):
 214                 source_path = "/srv/sources"
 215                 fileobjects = []
 216
 217                 for dir, subdirs, files in os.walk(source_path):
 218                         if not files:
 219                                 continue
 220                         for file in files:
 221                                 if file in [f["name"] for f in fileobjects]:
 222                                         continue
 223
 224                                 c = self.db.cursor()
 225                                 c.execute("SELECT sha1 FROM hashes WHERE file = '%s'" % file)
 226                                 hash = "%s" % c.fetchone()
 227
 228                                 if hash == "None":
 229                                         hash = "0000000000000000000000000000000000000000"
 230
 231                                 fileobjects.append({
 232                                         "dir"  : dir[len(source_path)+1:],
 233                                         "name" : file,
 234                                         "hash" : hash,
 235                                         "size" : size(os.path.getsize(os.path.join(source_path, dir, file))),
 236                                 })
 237
 238                                 c.close()
 239
 240                 fileobjects.sort(key=operator.itemgetter("name"))
 241
 242                 self.render("sources.html", files=fileobjects)