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                 today = datetime.date.today()
  41
  42                 ns.update({
  43                         "format_size" : util.format_size,
  44                         "format_time" : util.format_time,
  45                         "hostname" : self.hostname,
  46                         "year" : today.year,
  47                 })
  48
  49                 return ns
  50
  51         def get_remote_ip(self):
  52                 # Fix for clients behind a proxy that sends "X-Forwarded-For".
  53                 remote_ips = self.request.remote_ip.split(", ")
  54
  55                 for remote_ip in remote_ips:
  56                         try:
  57                                 addr = ipaddress.ip_address(remote_ip)
  58                         except ValueError:
  59                                 # Skip invalid IP addresses.
  60                                 continue
  61
  62                         # Check if the given IP address is from a
  63                         # private network.
  64                         if addr.is_private:
  65                                 continue
  66
  67                         return remote_ip
  68
  69                 # Return the last IP if nothing else worked
  70                 return remote_ips.pop()
  71
  72         def get_remote_location(self):
  73                 if not hasattr(self, "__remote_location"):
  74                         remote_ip = self.get_remote_ip()
  75
  76                         self.__remote_location = self.geoip.get_location(remote_ip)
  77
  78                 return self.__remote_location
  79
  80         def get_argument_int(self, *args, **kwargs):
  81                 arg = self.get_argument(*args, **kwargs)
  82
  83                 if arg is None or arg == "":
  84                         return
  85
  86                 try:
  87                         return int(arg)
  88                 except ValueError:
  89                         raise tornado.web.HTTPError(400)
  90
  91         def get_argument_date(self, arg, *args, **kwargs):
  92                 value = self.get_argument(arg, *args, **kwargs)
  93                 if value is None:
  94                         return
  95
  96                 try:
  97                         return dateutil.parser.parse(value)
  98                 except ValueError:
  99                         raise tornado.web.HTTPError(400)
 100
 101         # Login stuff
 102
 103         def get_current_user(self):
 104                 session_id = self.get_cookie("session_id")
 105                 if not session_id:
 106                         return
 107
 108                 # Get account from the session object
 109                 account = self.backend.accounts.get_by_session(session_id, self.request.host)
 110
 111                 # If the account was not found or the session was not valid
 112                 # any more, we will remove the cookie.
 113                 if not account:
 114                         self.clear_cookie("session_id")
 115
 116                 return account
 117
 118         @property
 119         def backend(self):
 120                 return self.application.backend
 121
 122         @property
 123         def db(self):
 124                 return self.backend.db
 125
 126         @property
 127         def accounts(self):
 128                 return self.backend.accounts
 129
 130         @property
 131         def downloads(self):
 132                 return self.backend.downloads
 133
 134         @property
 135         def fireinfo(self):
 136                 return self.backend.fireinfo
 137
 138         @property
 139         def iuse(self):
 140                 return self.backend.iuse
 141
 142         @property
 143         def mirrors(self):
 144                 return self.backend.mirrors
 145
 146         @property
 147         def netboot(self):
 148                 return self.backend.netboot
 149
 150         @property
 151         def releases(self):
 152                 return self.backend.releases
 153
 154         @property
 155         def geoip(self):
 156                 return self.backend.geoip
 157
 158         @property
 159         def talk(self):
 160                 return self.backend.talk
 161
 162
 163 class NotFoundHandler(BaseHandler):
 164         def prepare(self):
 165                 # Raises 404 as soon as it is called
 166                 raise tornado.web.HTTPError(404)
 167
 168
 169 class ErrorHandler(BaseHandler):
 170         """
 171                 Raises any error we want
 172         """
 173         def get(self, code):
 174                 try:
 175                         code = int(code)
 176                 except:
 177                         raise tornado.web.HTTPError(400)
 178
 179                 raise tornado.web.HTTPError(code)