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_query_locale(self):
  30                 locale = self.get_argument("locale", None)
  31
  32                 if locale is None:
  33                         return
  34
  35                 return tornado.locale.get(locale)
  36
  37         def prepare(self):
  38                 locale = self.get_query_locale()
  39                 if locale:
  40                         self.set_cookie("locale", locale.code)
  41
  42         def get_user_locale(self):
  43                 # The planet is always in english.
  44                 if self.request.host == "planet.ipfire.org":
  45                         return tornado.locale.get("en_US")
  46
  47                 # Get the locale from the query.
  48                 locale = self.get_query_locale()
  49                 if locale:
  50                         return locale
  51
  52                 # Read the locale from the cookies.
  53                 locale = self.get_cookie("locale", None)
  54                 if locale:
  55                         return tornado.locale.get(locale)
  56
  57                 # Otherwise take the browser locale.
  58                 return self.get_browser_locale()
  59
  60         @property
  61         def render_args(self):
  62                 today = datetime.date.today()
  63
  64                 return {
  65                         "format_size" : format_size,
  66                         "hostname" : self.request.host,
  67                         "lang" : self.locale.code[:2],
  68                         "rss_url" : self.rss_url,
  69                         "year" : today.year,
  70                 }
  71
  72         def render(self, *args, **_kwargs):
  73                 kwargs = self.render_args
  74                 kwargs.update(_kwargs)
  75                 tornado.web.RequestHandler.render(self, *args, **kwargs)
  76
  77         def render_string(self, *args, **_kwargs):
  78                 kwargs = self.render_args
  79                 kwargs.update(_kwargs)
  80                 return tornado.web.RequestHandler.render_string(self, *args, **kwargs)
  81
  82         def write_error(self, status_code, **kwargs):
  83                 if status_code in (404, 500):
  84                         render_args = ({
  85                                 "code"      : status_code,
  86                                 "exception" : kwargs.get("exception", None),
  87                                 "message"   : httplib.responses[status_code],
  88                         })
  89                         self.render("error-%s.html" % status_code, **render_args)
  90                 else:
  91                         return tornado.web.RequestHandler.write_error(self, status_code, **kwargs)
  92
  93         def static_url(self, path, static=True):
  94                 ret = tornado.web.RequestHandler.static_url(self, path)
  95
  96
  97
  98                 return ret
  99
 100         def get_remote_ip(self):
 101                 # Fix for clients behind a proxy that sends "X-Forwarded-For".
 102                 ip_addr = self.request.remote_ip.split(", ")
 103
 104                 if ip_addr:
 105                         ip_addr = ip_addr[-1]
 106
 107                 return ip_addr
 108
 109         def get_remote_location(self):
 110                 if not hasattr(self, "__remote_location"):
 111                         remote_ip = self.get_remote_ip()
 112
 113                         self.__remote_location = self.geoip.get_location(remote_ip)
 114
 115                 return self.__remote_location
 116
 117         @property
 118         def backend(self):
 119                 return self.application.backend
 120
 121         @property
 122         def db(self):
 123                 return self.backend.db
 124
 125         @property
 126         def advertisements(self):
 127                 return self.backend.advertisements
 128
 129         @property
 130         def accounts(self):
 131                 return self.backend.accounts
 132
 133         @property
 134         def downloads(self):
 135                 return self.backend.downloads
 136
 137         @property
 138         def iuse(self):
 139                 return self.backend.iuse
 140
 141         @property
 142         def memcached(self):
 143                 return self.backend.memcache
 144
 145         @property
 146         def mirrors(self):
 147                 return self.backend.mirrors
 148
 149         @property
 150         def netboot(self):
 151                 return self.backend.netboot
 152
 153         @property
 154         def news(self):
 155                 return self.backend.news
 156
 157         @property
 158         def config(self):
 159                 return self.backend.settings
 160
 161         @property
 162         def releases(self):
 163                 return self.backend.releases
 164
 165         @property
 166         def geoip(self):
 167                 return self.backend.geoip
 168
 169         @property
 170         def stasy(self):
 171                 return self.backend.stasy
 172
 173         @property
 174         def tracker(self):
 175                 return self.backend.tracker
 176
 177         @property
 178         def planet(self):
 179                 return self.backend.planet
 180
 181         @property
 182         def wishlist(self):
 183                 return self.backend.wishlist