webapp/handlers_base.py

   1 #!/usr/bin/python
   2
   3 from __future__ import division
   4
   5 import httplib
   6 import datetime
   7 import time
   8 import tornado.locale
   9 import tornado.web
  10
  11 def format_size(b):
  12         units = ["B", "k", "M", "G"]
  13         unit_pointer = 0
  14
  15         while b >= 1024 and unit_pointer < len(units):
  16                 b /= 1024
  17                 unit_pointer += 1
  18
  19         return "%.1f%s" % (b, units[unit_pointer])
  20
  21
  22 class BaseHandler(tornado.web.RequestHandler):
  23         rss_url = None
  24
  25         def get_account(self, uid):
  26                 # Find the name of the author
  27                 return self.accounts.find(uid)
  28
  29         def get_user_locale(self):
  30                 # The planet is always in english.
  31                 if self.request.host == "planet.ipfire.org":
  32                         return tornado.locale.get("en_US")
  33
  34                 # Otherwise take the browser locale.
  35                 return self.get_browser_locale()
  36
  37         @property
  38         def render_args(self):
  39                 today = datetime.date.today()
  40
  41                 return {
  42                         "format_size" : format_size,
  43                         "hostname" : self.request.host,
  44                         "lang" : self.locale.code[:2],
  45                         "rss_url" : self.rss_url,
  46                         "year" : today.year,
  47                 }
  48
  49         def render(self, *args, **_kwargs):
  50                 kwargs = self.render_args
  51                 kwargs.update(_kwargs)
  52                 tornado.web.RequestHandler.render(self, *args, **kwargs)
  53
  54         def render_string(self, *args, **_kwargs):
  55                 kwargs = self.render_args
  56                 kwargs.update(_kwargs)
  57                 return tornado.web.RequestHandler.render_string(self, *args, **kwargs)
  58
  59         def write_error(self, status_code, **kwargs):
  60                 if status_code in (404, 500):
  61                         render_args = ({
  62                                 "code"      : status_code,
  63                                 "exception" : kwargs.get("exception", None),
  64                                 "message"   : httplib.responses[status_code],
  65                         })
  66                         self.render("error-%s.html" % status_code, **render_args)
  67                 else:
  68                         return tornado.web.RequestHandler.write_error(self, status_code, **kwargs)
  69
  70         def static_url(self, path, static=True):
  71                 ret = tornado.web.RequestHandler.static_url(self, path)
  72
  73                 if self.settings.get("debug", False):
  74                         return ret
  75
  76                 elif self.request.host == "admin.ipfire.org":
  77                         return ret
  78
  79                 elif static:
  80                         return "http://static.ipfire.org%s" % ret
  81
  82                 return ret
  83
  84         def get_remote_ip(self):
  85                 # Fix for clients behind a proxy that sends "X-Forwarded-For".
  86                 ip_addr = self.request.remote_ip.split(", ")
  87
  88                 if ip_addr:
  89                         ip_addr = ip_addr[-1]
  90
  91                 return ip_addr
  92
  93         def get_remote_location(self):
  94                 if not hasattr(self, "__remote_location"):
  95                         remote_ip = self.get_remote_ip()
  96
  97                         self.__remote_location = self.geoip.get_location(remote_ip)
  98
  99                 return self.__remote_location
 100
 101         @property
 102         def backend(self):
 103                 return self.application.backend
 104
 105         @property
 106         def db(self):
 107                 return self.backend.db
 108
 109         @property
 110         def advertisements(self):
 111                 return self.backend.advertisements
 112
 113         @property
 114         def accounts(self):
 115                 return self.backend.accounts
 116
 117         @property
 118         def downloads(self):
 119                 return self.backend.downloads
 120
 121         @property
 122         def iuse(self):
 123                 return self.backend.iuse
 124
 125         @property
 126         def memcached(self):
 127                 return self.backend.memcache
 128
 129         @property
 130         def mirrors(self):
 131                 return self.backend.mirrors
 132
 133         @property
 134         def netboot(self):
 135                 return self.backend.netboot
 136
 137         @property
 138         def news(self):
 139                 return self.backend.news
 140
 141         @property
 142         def config(self):
 143                 return self.backend.settings
 144
 145         @property
 146         def releases(self):
 147                 return self.backend.releases
 148
 149         @property
 150         def geoip(self):
 151                 return self.backend.geoip
 152
 153         @property
 154         def stasy(self):
 155                 return self.backend.stasy
 156
 157         @property
 158         def tracker(self):
 159                 return self.backend.tracker
 160
 161         @property
 162         def planet(self):
 163                 return self.backend.planet
 164
 165         @property
 166         def wishlist(self):
 167                 return self.backend.wishlist