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                 if self.settings.get("debug", False):
  97                         return ret
  98
  99                 elif self.request.host == "admin.ipfire.org":
 100                         return ret
 101
 102                 elif static:
 103                         return "http://static.ipfire.org%s" % ret
 104
 105                 return ret
 106
 107         def get_remote_ip(self):
 108                 # Fix for clients behind a proxy that sends "X-Forwarded-For".
 109                 ip_addr = self.request.remote_ip.split(", ")
 110
 111                 if ip_addr:
 112                         ip_addr = ip_addr[-1]
 113
 114                 return ip_addr
 115
 116         def get_remote_location(self):
 117                 if not hasattr(self, "__remote_location"):
 118                         remote_ip = self.get_remote_ip()
 119
 120                         self.__remote_location = self.geoip.get_location(remote_ip)
 121
 122                 return self.__remote_location
 123
 124         @property
 125         def backend(self):
 126                 return self.application.backend
 127
 128         @property
 129         def db(self):
 130                 return self.backend.db
 131
 132         @property
 133         def advertisements(self):
 134                 return self.backend.advertisements
 135
 136         @property
 137         def accounts(self):
 138                 return self.backend.accounts
 139
 140         @property
 141         def downloads(self):
 142                 return self.backend.downloads
 143
 144         @property
 145         def iuse(self):
 146                 return self.backend.iuse
 147
 148         @property
 149         def memcached(self):
 150                 return self.backend.memcache
 151
 152         @property
 153         def mirrors(self):
 154                 return self.backend.mirrors
 155
 156         @property
 157         def netboot(self):
 158                 return self.backend.netboot
 159
 160         @property
 161         def news(self):
 162                 return self.backend.news
 163
 164         @property
 165         def config(self):
 166                 return self.backend.settings
 167
 168         @property
 169         def releases(self):
 170                 return self.backend.releases
 171
 172         @property
 173         def geoip(self):
 174                 return self.backend.geoip
 175
 176         @property
 177         def stasy(self):
 178                 return self.backend.stasy
 179
 180         @property
 181         def tracker(self):
 182                 return self.backend.tracker
 183
 184         @property
 185         def planet(self):
 186                 return self.backend.planet
 187
 188         @property
 189         def wishlist(self):
 190                 return self.backend.wishlist