webapp/handlers_base.py

   1 #!/usr/bin/python
   2
   3 from __future__ import division
   4
   5 import datetime
   6 import dateutil.parser
   7 import httplib
   8 import ipaddr
   9 import logging
  10 import time
  11 import tornado.locale
  12 import tornado.web
  13
  14 import backend.util
  15
  16 class BaseHandler(tornado.web.RequestHandler):
  17         rss_url = None
  18
  19         def get_account(self, uid):
  20                 # Find the name of the author
  21                 return self.accounts.find(uid)
  22
  23         def get_user_locale(self):
  24                 # The planet is always in english.
  25                 if self.hostname == "planet.ipfire.org":
  26                         return tornado.locale.get("en_US")
  27
  28                 # Otherwise take the browser locale.
  29                 return self.get_browser_locale()
  30
  31         @property
  32         def hostname(self):
  33                 # Remove the development prefix
  34                 return self.request.host.replace(".dev.", ".")
  35
  36         @property
  37         def render_args(self):
  38                 today = datetime.date.today()
  39
  40                 return {
  41                         "format_size" : backend.util.format_size,
  42                         "format_time" : backend.util.format_time,
  43                         "hostname" : self.hostname,
  44                         "lang" : self.locale.code[:2],
  45                         "rss_url" : self.rss_url,
  46                         "year" : today.year,
  47                 }
  48
  49         def render(self, *args, **_kwargs):
  50                 kwargs = self.render_args
  51                 kwargs.update(_kwargs)
  52                 tornado.web.RequestHandler.render(self, *args, **kwargs)
  53
  54         def render_string(self, *args, **_kwargs):
  55                 kwargs = self.render_args
  56                 kwargs.update(_kwargs)
  57                 return tornado.web.RequestHandler.render_string(self, *args, **kwargs)
  58
  59         def write_error(self, status_code, **kwargs):
  60                 if status_code in (404, 500):
  61                         render_args = ({
  62                                 "code"      : status_code,
  63                                 "exception" : kwargs.get("exception", None),
  64                                 "message"   : httplib.responses[status_code],
  65                         })
  66                         self.render("error-%s.html" % status_code, **render_args)
  67                 else:
  68                         return tornado.web.RequestHandler.write_error(self, status_code, **kwargs)
  69
  70         def static_url(self, path, static=True):
  71                 ret = tornado.web.RequestHandler.static_url(self, path)
  72
  73                 if self.settings.get("debug", False):
  74                         return ret
  75
  76                 elif self.request.host == "admin.ipfire.org":
  77                         return ret
  78
  79                 elif static:
  80                         return "http://static.ipfire.org%s" % ret
  81
  82                 return ret
  83
  84         def get_remote_ip(self):
  85                 # Fix for clients behind a proxy that sends "X-Forwarded-For".
  86                 remote_ips = self.request.remote_ip.split(", ")
  87                 for remote_ip in remote_ips:
  88                         try:
  89                                 addr = ipaddr.IPAddress(remote_ip)
  90                         except ValueError:
  91                                 # Skip invalid IP addresses.
  92                                 continue
  93
  94                         # Check if the given IP address is from a
  95                         # private network.
  96                         if addr.is_private:
  97                                 continue
  98
  99                         return remote_ip
 100
 101         def get_remote_location(self):
 102                 if not hasattr(self, "__remote_location"):
 103                         remote_ip = self.get_remote_ip()
 104
 105                         self.__remote_location = self.geoip.get_location(remote_ip)
 106
 107                 return self.__remote_location
 108
 109         def get_argument_date(self, arg, *args, **kwargs):
 110                 value = self.get_argument(arg, *args, **kwargs)
 111                 if value is None:
 112                         return
 113
 114                 try:
 115                         return dateutil.parser.parse(value)
 116                 except ValueError:
 117                         raise tornado.web.HTTPError(400)
 118
 119         # Login stuff
 120
 121         def get_current_user(self):
 122                 session_id = self.get_cookie("session_id")
 123                 if not session_id:
 124                         return
 125
 126                 # Get account from the session object
 127                 account = self.backend.accounts.get_by_session(session_id, self.request.host)
 128
 129                 # If the account was not found or the session was not valid
 130                 # any more, we will remove the cookie.
 131                 if not account:
 132                         self.clear_cookie("session_id")
 133
 134                 return account
 135
 136         def login(self, username, password):
 137                 # Find account
 138                 account = self.backend.accounts.find_account(username)
 139                 if not account:
 140                         logging.warning(401, "unknown account: %s" % username)
 141                         return False
 142
 143                 # Check credentials
 144                 if not account.check_password(password):
 145                         logging.warning("invalid password for %s" % account)
 146                         return False
 147
 148                 # User has logged in, create a session
 149                 session_id, session_expires = self.backend.accounts.create_session(account,
 150                         self.request.host)
 151
 152                 # Check if a new session was created
 153                 if not session_id:
 154                         logging.warning("Could not create session")
 155                         return False
 156
 157                 # Send session cookie to the client
 158                 self.set_cookie("session_id", session_id,
 159                         domain=self.request.host, expires=session_expires)
 160
 161                 return True
 162
 163         def logout(self):
 164                 session_id = self.get_cookie("session_id")
 165
 166                 if not session_id:
 167                         return
 168
 169                 success = self.backend.accounts.destroy_session(session_id, self.request.host)
 170                 if success:
 171                         self.clear_cookie("session_id")
 172
 173         @property
 174         def backend(self):
 175                 return self.application.backend
 176
 177         @property
 178         def db(self):
 179                 return self.backend.db
 180
 181         @property
 182         def advertisements(self):
 183                 return self.backend.advertisements
 184
 185         @property
 186         def accounts(self):
 187                 return self.backend.accounts
 188
 189         @property
 190         def downloads(self):
 191                 return self.backend.downloads
 192
 193         @property
 194         def fireinfo(self):
 195                 return self.backend.fireinfo
 196
 197         @property
 198         def iuse(self):
 199                 return self.backend.iuse
 200
 201         @property
 202         def memcached(self):
 203                 return self.backend.memcache
 204
 205         @property
 206         def mirrors(self):
 207                 return self.backend.mirrors
 208
 209         @property
 210         def netboot(self):
 211                 return self.backend.netboot
 212
 213         @property
 214         def news(self):
 215                 return self.backend.news
 216
 217         @property
 218         def config(self):
 219                 return self.backend.settings
 220
 221         @property
 222         def releases(self):
 223                 return self.backend.releases
 224
 225         @property
 226         def geoip(self):
 227                 return self.backend.geoip
 228
 229         @property
 230         def talk(self):
 231                 return self.backend.talk
 232
 233         @property
 234         def tracker(self):
 235                 return self.backend.tracker
 236
 237         @property
 238         def planet(self):
 239                 return self.backend.planet
 240
 241         @property
 242         def wishlist(self):
 243                 return self.backend.wishlist
 244
 245
 246 class LoginHandler(BaseHandler):
 247         def get(self):
 248                 self.render("auth/login.html")
 249
 250         def post(self):
 251                 username = self.get_argument("username")
 252                 password = self.get_argument("password")
 253
 254                 if not self.login(username, password):
 255                         raise tornado.web.HTTPError(401)
 256
 257                 next = self.get_argument("next", "/")
 258                 return self.redirect(next)
 259
 260
 261 class LogoutHandler(BaseHandler):
 262         def get(self):
 263                 self.logout()
 264
 265                 # Get back to the start page
 266                 self.redirect("/")