src/web/handlers_base.py

   1 #!/usr/bin/python
   2
   3 import datetime
   4 import dateutil.parser
   5 import http.client
   6 import ipaddress
   7 import logging
   8 import time
   9 import tornado.locale
  10 import tornado.web
  11
  12 from .. import util
  13
  14 class BaseHandler(tornado.web.RequestHandler):
  15         def set_expires(self, seconds):
  16                 # For HTTP/1.1
  17                 self.set_header("Cache-Control", "max-age=%s, must-revalidate" % seconds)
  18
  19                 # For HTTP/1.0
  20                 expires = datetime.datetime.utcnow() + datetime.timedelta(seconds=seconds)
  21                 self.set_header("Expires", expires)
  22
  23         def write_error(self, status_code, **kwargs):
  24                 # Translate code into message
  25                 try:
  26                         message = http.client.responses[status_code]
  27                 except KeyError:
  28                         message = None
  29
  30                 self.render("error.html", status_code=status_code, message=message, **kwargs)
  31
  32         @property
  33         def hostname(self):
  34                 # Remove the development prefix
  35                 return self.request.host.replace(".dev.", ".")
  36
  37         def get_template_namespace(self):
  38                 ns = tornado.web.RequestHandler.get_template_namespace(self)
  39
  40                 now = datetime.date.today()
  41
  42                 ns.update({
  43                         "debug" : self.application.settings.get("debug", False),
  44                         "format_size" : util.format_size,
  45                         "format_time" : util.format_time,
  46                         "hostname" : self.hostname,
  47                         "now" : now,
  48                         "year" : now.year,
  49                 })
  50
  51                 return ns
  52
  53         def get_remote_ip(self):
  54                 # Fix for clients behind a proxy that sends "X-Forwarded-For".
  55                 remote_ips = self.request.remote_ip.split(", ")
  56
  57                 for remote_ip in remote_ips:
  58                         try:
  59                                 addr = ipaddress.ip_address(remote_ip)
  60                         except ValueError:
  61                                 # Skip invalid IP addresses.
  62                                 continue
  63
  64                         # Check if the given IP address is from a
  65                         # private network.
  66                         if addr.is_private:
  67                                 continue
  68
  69                         return remote_ip
  70
  71                 # Return the last IP if nothing else worked
  72                 return remote_ips.pop()
  73
  74         def get_remote_location(self):
  75                 if not hasattr(self, "__remote_location"):
  76                         remote_ip = self.get_remote_ip()
  77
  78                         self.__remote_location = self.geoip.get_location(remote_ip)
  79
  80                 return self.__remote_location
  81
  82         def get_argument_int(self, *args, **kwargs):
  83                 arg = self.get_argument(*args, **kwargs)
  84
  85                 if arg is None or arg == "":
  86                         return
  87
  88                 try:
  89                         return int(arg)
  90                 except ValueError:
  91                         raise tornado.web.HTTPError(400)
  92
  93         def get_argument_date(self, arg, *args, **kwargs):
  94                 value = self.get_argument(arg, *args, **kwargs)
  95                 if value is None:
  96                         return
  97
  98                 try:
  99                         return dateutil.parser.parse(value)
 100                 except ValueError:
 101                         raise tornado.web.HTTPError(400)
 102
 103         # Login stuff
 104
 105         def get_current_user(self):
 106                 session_id = self.get_cookie("session_id")
 107                 if not session_id:
 108                         return
 109
 110                 # Get account from the session object
 111                 account = self.backend.accounts.get_by_session(session_id, self.request.host)
 112
 113                 # If the account was not found or the session was not valid
 114                 # any more, we will remove the cookie.
 115                 if not account:
 116                         self.clear_cookie("session_id")
 117
 118                 return account
 119
 120         @property
 121         def backend(self):
 122                 return self.application.backend
 123
 124         @property
 125         def db(self):
 126                 return self.backend.db
 127
 128         @property
 129         def accounts(self):
 130                 return self.backend.accounts
 131
 132         @property
 133         def downloads(self):
 134                 return self.backend.downloads
 135
 136         @property
 137         def fireinfo(self):
 138                 return self.backend.fireinfo
 139
 140         @property
 141         def iuse(self):
 142                 return self.backend.iuse
 143
 144         @property
 145         def mirrors(self):
 146                 return self.backend.mirrors
 147
 148         @property
 149         def netboot(self):
 150                 return self.backend.netboot
 151
 152         @property
 153         def releases(self):
 154                 return self.backend.releases
 155
 156         @property
 157         def geoip(self):
 158                 return self.backend.geoip
 159
 160         @property
 161         def talk(self):
 162                 return self.backend.talk
 163
 164
 165 class NotFoundHandler(BaseHandler):
 166         def prepare(self):
 167                 # Raises 404 as soon as it is called
 168                 raise tornado.web.HTTPError(404)
 169
 170
 171 class ErrorHandler(BaseHandler):
 172         """
 173                 Raises any error we want
 174         """
 175         def get(self, code):
 176                 try:
 177                         code = int(code)
 178                 except:
 179                         raise tornado.web.HTTPError(400)
 180
 181                 raise tornado.web.HTTPError(code)