www/webapp/handlers.py

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