src/web/fireinfo.py

   1 #!/usr/bin/python
   2
   3 import json
   4 import tornado.web
   5
   6 from . import base
   7 from . import ui_modules
   8
   9 class BaseHandler(base.BaseHandler):
  10         @property
  11         def when(self):
  12                 return self.get_argument_date("when", None)
  13
  14
  15 class ProfileSendHandler(BaseHandler):
  16         def check_xsrf_cookie(self):
  17                 # This cookie is not required here.
  18                 pass
  19
  20         def get_profile_blob(self):
  21                 profile = self.get_argument("profile", None)
  22
  23                 # Send "400 bad request" if no profile was provided
  24                 if not profile:
  25                         raise tornado.web.HTTPError(400, "No profile received")
  26
  27                 # Try to decode the profile
  28                 try:
  29                         return json.loads(profile)
  30                 except json.decoder.JSONDecodeError as e:
  31                         raise tornado.web.HTTPError(400, "Profile could not be decoded: %s" % e)
  32
  33         def post(self, public_id):
  34                 profile_blob = self.get_profile_blob()
  35
  36                 # Handle the profile.
  37                 with self.db.transaction():
  38                         try:
  39                                 self.fireinfo.handle_profile(public_id, profile_blob,
  40                                         country_code=self.current_country_code,
  41                                         asn=self.current_address.asn if self.current_address else None)
  42
  43                         except ValueError as e:
  44                                 raise tornado.web.HTTPError(400, "Could not process profile: %s" % e)
  45
  46                 self.finish("Your profile was successfully saved to the database.")
  47
  48
  49 class IndexHandler(base.AnalyticsMixin, BaseHandler):
  50         def get(self):
  51                 data = {
  52                         "when"           : self.when,
  53
  54                         # Release
  55                         "latest_release" : self.backend.releases.get_latest(),
  56
  57                         # Hardware
  58                         "arches"         : self.fireinfo.get_arch_map(when=self.when),
  59                         "cpu_vendors"    : self.fireinfo.get_cpu_vendors_map(when=self.when),
  60
  61                         # Memory
  62                         "memory_avg"     : self.backend.fireinfo.get_average_memory_amount(when=self.when),
  63
  64                         # Virtualization
  65                         "hypervisors"    : self.fireinfo.get_hypervisor_map(when=self.when),
  66                         "virtual_ratio"  : self.fireinfo.get_virtual_ratio(when=self.when),
  67
  68                         # Location
  69                         "locations"      : self.fireinfo.get_geo_location_map(when=self.when),
  70                 }
  71
  72                 self.render("fireinfo/index.html", **data)
  73
  74
  75 class DriverDetail(base.AnalyticsMixin, BaseHandler):
  76         def get(self, driver):
  77                 devices = self.fireinfo.get_devices_by_driver(driver, when=self.when)
  78
  79                 self.render("fireinfo/driver.html", driver=driver, devices=devices)
  80
  81
  82 class ProfileHandler(base.AnalyticsMixin, BaseHandler):
  83         def get(self, profile_id):
  84                 profile = self.fireinfo.get_profile(profile_id, when=self.when)
  85
  86                 if not profile or not profile.is_showable():
  87                         raise tornado.web.HTTPError(404)
  88
  89                 self.render("fireinfo/profile.html", profile=profile)
  90
  91
  92 class RandomProfileHandler(base.AnalyticsMixin, BaseHandler):
  93         def get(self):
  94                 profile = self.fireinfo.get_random_profile(when=self.when)
  95                 if not profile:
  96                         raise tornado.web.HTTPError(404, "Could not find a random profile")
  97
  98                 self.redirect("/fireinfo/profile/%s" % profile.profile_id)
  99
 100
 101 class ReleasesHandler(base.AnalyticsMixin, BaseHandler):
 102         def get(self):
 103                 data = {
 104                         "releases" : self.fireinfo.get_releases_map(when=self.when),
 105                         "kernels"  : self.fireinfo.get_kernels_map(when=self.when),
 106                 }
 107
 108                 return self.render("fireinfo/releases.html", **data)
 109
 110
 111 class ProcessorsHandler(base.AnalyticsMixin, BaseHandler):
 112         def get(self):
 113                 return self.render("fireinfo/processors.html", when=self.when)
 114
 115
 116 class VendorsHandler(base.AnalyticsMixin, BaseHandler):
 117         def get(self):
 118                 vendors = self.fireinfo.get_vendor_list(when=self.when)
 119
 120                 self.render("fireinfo/vendors.html", vendors=vendors)
 121
 122
 123 class VendorHandler(base.AnalyticsMixin, BaseHandler):
 124         def get(self, subsystem, vendor_id):
 125                 devices = self.fireinfo.get_devices_by_vendor(subsystem, vendor_id, when=self.when)
 126                 if not devices:
 127                         raise tornado.web.HTTPError(404)
 128
 129                 vendor_name = self.fireinfo.get_vendor_string(subsystem, vendor_id)
 130
 131                 self.render("fireinfo/vendor.html", vendor_name=vendor_name, devices=devices)
 132
 133
 134 class DeviceTableModule(ui_modules.UIModule):
 135         def render(self, devices, show_group=True, embedded=False):
 136                 return self.render_string("fireinfo/modules/table-devices.html",
 137                                 devices=devices, show_group=show_group, embedded=embedded)
 138
 139
 140 class DeviceAndGroupsTableModule(ui_modules.UIModule):
 141         def render(self, devices):
 142                 _ = self.locale.translate
 143
 144                 groups = {}
 145
 146                 for device in devices:
 147                         if device.cls not in groups:
 148                                 groups[device.cls] = []
 149
 150                         groups[device.cls].append(device)
 151
 152                 # Sort all devices
 153                 for key in list(groups.keys()):
 154                         groups[key].sort()
 155
 156                 # Order the groups by their name
 157                 groups = list(groups.items())
 158                 groups.sort()
 159
 160                 return self.render_string("fireinfo/modules/table-devices-and-groups.html",
 161                                 groups=groups)
 162
 163
 164 class AdminIndexHandler(BaseHandler):
 165         @tornado.web.authenticated
 166         def prepare(self):
 167                 if not self.current_user.is_staff():
 168                         raise tornado.web.HTTPError(401)
 169
 170         @tornado.web.authenticated
 171         def get(self):
 172                 with_data, total = self.backend.fireinfo.get_active_profiles()
 173
 174                 # Fetch the ASN map
 175                 asn_map = self.backend.fireinfo.get_asn_map()
 176
 177                 self.render("fireinfo/admin.html", with_data=with_data, total=total,
 178                         asn_map=asn_map)