src/web/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.add_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.add_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         def get_file(self, name):
 104                 try:
 105                         file = self.request.files[name][0]
 106
 107                         return file["filename"], file["body"], file["content_type"]
 108                 except KeyError:
 109                         return None
 110
 111         # Login stuff
 112
 113         def get_current_user(self):
 114                 session_id = self.get_cookie("session_id")
 115                 if not session_id:
 116                         return
 117
 118                 # Get account from the session object
 119                 account = self.backend.accounts.get_by_session(session_id, self.request.host)
 120
 121                 # If the account was not found or the session was not valid
 122                 # any more, we will remove the cookie.
 123                 if not account:
 124                         self.clear_cookie("session_id")
 125
 126                 return account
 127
 128         @property
 129         def backend(self):
 130                 return self.application.backend
 131
 132         @property
 133         def db(self):
 134                 return self.backend.db
 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 fireinfo(self):
 146                 return self.backend.fireinfo
 147
 148         @property
 149         def iuse(self):
 150                 return self.backend.iuse
 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 releases(self):
 162                 return self.backend.releases
 163
 164         @property
 165         def geoip(self):
 166                 return self.backend.geoip
 167
 168         @property
 169         def talk(self):
 170                 return self.backend.talk
 171
 172
 173 class NotFoundHandler(BaseHandler):
 174         def prepare(self):
 175                 # Raises 404 as soon as it is called
 176                 raise tornado.web.HTTPError(404)
 177
 178
 179 class ErrorHandler(BaseHandler):
 180         """
 181                 Raises any error we want
 182         """
 183         def get(self, code):
 184                 try:
 185                         code = int(code)
 186                 except:
 187                         raise tornado.web.HTTPError(400)
 188
 189                 raise tornado.web.HTTPError(code)
 190
 191
 192 class BlockedHandler(BaseHandler):
 193         def get(self):
 194                 # 403 - Forbidden
 195                 self.set_status(403)
 196
 197                 self.render("static/blocked.html", address=self.get_remote_ip())