src/web/fireinfo.py

   1 #!/usr/bin/python
   2
   3 import datetime
   4 import hwdata
   5 import logging
   6 import re
   7 import json
   8 import tornado.web
   9
  10 from .. import fireinfo
  11
  12 from . import base
  13 from . import ui_modules
  14
  15 class BaseHandler(base.BaseHandler):
  16         @property
  17         def when(self):
  18                 return self.get_argument_date("when", None)
  19
  20
  21 MIN_PROFILE_VERSION = 0
  22 MAX_PROFILE_VERSION = 0
  23
  24 class Profile(dict):
  25         def __getattr__(self, key):
  26                 try:
  27                         return self[key]
  28                 except KeyError:
  29                         raise AttributeError(key)
  30
  31         def __setattr__(self, key, val):
  32                 self[key] = val
  33
  34
  35 class ProfileSendHandler(BaseHandler):
  36         def check_xsrf_cookie(self):
  37                 # This cookie is not required here.
  38                 pass
  39
  40         def prepare(self):
  41                 # Create an empty profile.
  42                 self.profile = Profile()
  43
  44         def __check_attributes(self, profile):
  45                 """
  46                         Check for attributes that must be provided,
  47                 """
  48                 attributes = (
  49                         "private_id",
  50                         "profile_version",
  51                         "public_id",
  52                 )
  53                 for attr in attributes:
  54                         if attr not in profile:
  55                                 raise tornado.web.HTTPError(400, "Profile lacks '%s' attribute: %s" % (attr, profile))
  56
  57         def __check_valid_ids(self, profile):
  58                 """
  59                         Check if IDs contain valid data.
  60                 """
  61                 for id in ("public_id", "private_id"):
  62                         if re.match(r"^([a-f0-9]{40})$", "%s" % profile[id]) is None:
  63                                 raise tornado.web.HTTPError(400, "ID '%s' has wrong format: %s" % (id, profile))
  64
  65         def __check_equal_ids(self, profile):
  66                 """
  67                         Check if public_id and private_id are equal.
  68                 """
  69                 if profile.public_id == profile.private_id:
  70                         raise tornado.web.HTTPError(400, "Public and private IDs are equal: %s" % profile)
  71
  72         def __check_matching_ids(self, profile):
  73                 """
  74                         Check if a profile with the given public_id is already in the
  75                         database. If so we need to check if the private_id matches.
  76                 """
  77                 p = self.profiles.find_one({ "public_id" : profile["public_id"]})
  78                 if not p:
  79                         return
  80
  81                 p = Profile(p)
  82                 if p.private_id != profile.private_id:
  83                         raise tornado.web.HTTPError(400, "Mismatch of private_id: %s" % profile)
  84
  85         def __check_profile_version(self, profile):
  86                 """
  87                         Check if this version of the server software does support the
  88                         received profile.
  89                 """
  90                 version = profile.profile_version
  91
  92                 if version < MIN_PROFILE_VERSION or version > MAX_PROFILE_VERSION:
  93                         raise tornado.web.HTTPError(400,
  94                                 "Profile version is not supported: %s" % version)
  95
  96         def check_profile_blob(self, profile):
  97                 """
  98                         This method checks if the blob is sane.
  99                 """
 100                 checks = (
 101                         self.__check_attributes,
 102                         self.__check_valid_ids,
 103                         self.__check_equal_ids,
 104                         self.__check_profile_version,
 105                         # These checks require at least one database query and should be done
 106                         # at last.
 107                         self.__check_matching_ids,
 108                 )
 109
 110                 for check in checks:
 111                         check(profile)
 112
 113                 # If we got here, everything is okay and we can go on...
 114
 115         def get_profile_blob(self):
 116                 profile = self.get_argument("profile", None)
 117
 118                 # Send "400 bad request" if no profile was provided
 119                 if not profile:
 120                         raise tornado.web.HTTPError(400, "No profile received")
 121
 122                 # Try to decode the profile.
 123                 try:
 124                         return json.loads(profile)
 125                 except json.decoder.JSONDecodeError as e:
 126                         raise tornado.web.HTTPError(400, "Profile could not be decoded: %s" % e)
 127
 128         # The GET method is only allowed in debugging mode.
 129         def get(self, public_id):
 130                 if not self.application.settings["debug"]:
 131                         raise tornado.web.HTTPError(405)
 132
 133                 return self.post(public_id)
 134
 135         def post(self, public_id):
 136                 profile_blob = self.get_profile_blob()
 137                 #self.check_profile_blob(profile_blob)
 138
 139                 # Get location
 140                 location = self.get_remote_location()
 141                 if location:
 142                         location = location.country
 143
 144                 # Handle the profile.
 145                 with self.db.transaction():
 146                         try:
 147                                 self.fireinfo.handle_profile(public_id, profile_blob, location=location)
 148
 149                         except fireinfo.ProfileParserError:
 150                                 raise tornado.web.HTTPError(400)
 151
 152                 self.finish("Your profile was successfully saved to the database.")
 153
 154
 155 class IndexHandler(BaseHandler):
 156         def _profile_not_found(self, profile_id):
 157                 self.set_status(404)
 158                 self.render("fireinfo/profile-notfound.html", profile_id=profile_id)
 159
 160         def get(self):
 161                 self.render("fireinfo/index.html")
 162
 163         def post(self):
 164                 profile_id = self.get_argument("profile_id", None)
 165                 if not profile_id:
 166                         raise tornado.web.HTTPError(400, "No profile ID was given.")
 167
 168                 if not self.fireinfo.profile_exists(profile_id):
 169                         self._profile_not_found(profile_id)
 170                         return
 171
 172                 self.redirect("/profile/%s" % profile_id)
 173
 174
 175 class ProfileDetailHandler(BaseHandler):
 176         def get(self, profile_id):
 177                 profile = self.fireinfo.get_profile(profile_id, when=self.when)
 178
 179                 if not profile or not profile.is_showable():
 180                         self._profile_not_found(profile_id)
 181                         return
 182
 183                 self.render("fireinfo/profile-detail.html", profile=profile)
 184
 185
 186 class RandomProfileHandler(BaseHandler):
 187         def get(self):
 188                 profile_id = self.fireinfo.get_random_profile(when=self.when)
 189                 if profile_id is None:
 190                         raise tornado.web.HTTPError(404)
 191
 192                 self.redirect("/profile/%s" % profile_id)
 193
 194
 195 class DeviceDriverDetail(BaseHandler):
 196         def get(self, driver):
 197                 self.render("fireinfo/driver.html", driver=driver,
 198                         driver_map=self.fireinfo.get_driver_map(driver, when=self.when))
 199
 200
 201 class DeviceVendorsHandler(BaseHandler):
 202         def get(self):
 203                 vendors = self.fireinfo.get_vendor_list(when=self.when)
 204
 205                 self.render("fireinfo/vendors.html", vendors=vendors)
 206
 207
 208 class StatsHandler(BaseHandler):
 209         def get(self):
 210                 self.render("fireinfo/stats.html")
 211
 212
 213 class StatsProcessorsHandler(BaseHandler):
 214         def get(self):
 215                 avg, stddev, min, max = self.fireinfo.get_cpu_clock_speeds(when=self.when)
 216                 arch_map = self.fireinfo.get_arch_map(when=self.when)
 217
 218                 data = {
 219                         "arch_map" : arch_map,
 220                         "cpu_vendors" : self.fireinfo.get_cpu_vendors_map(when=self.when),
 221                         "clock_speed_avg" : avg,
 222                         "clock_speed_stddev" : stddev,
 223                         "clock_speed_min" : min,
 224                         "clock_speed_max" : max,
 225                 }
 226
 227                 return self.render("fireinfo/stats-cpus.html", **data)
 228
 229
 230 class StatsProcessorDetailHandler(BaseHandler):
 231         def get(self, platform):
 232                 assert platform in ("arm", "x86")
 233
 234                 flags = self.fireinfo.get_common_cpu_flags_by_platform(platform, when=self.when)
 235
 236                 return self.render("fireinfo/stats-cpus-detail.html",
 237                         platform=platform, flags=flags)
 238
 239
 240 class StatsMemoryHandler(BaseHandler):
 241         def get(self):
 242                 avg, stddev, min, max = self.fireinfo.get_memory_amounts(when=self.when)
 243                 amounts = self.fireinfo.get_common_memory_amounts(when=self.when)
 244
 245                 data = {
 246                         "mem_avg" : avg,
 247                         "mem_stddev" : stddev,
 248                         "mem_min" : min,
 249                         "mem_max" : max,
 250                         "amounts" : amounts,
 251                 }
 252
 253                 return self.render("fireinfo/stats-memory.html", **data)
 254
 255
 256 class StatsReleasesHandler(BaseHandler):
 257         def get(self):
 258                 data = {
 259                         "releases" : self.fireinfo.get_releases_map(when=self.when),
 260                         "kernels"  : self.fireinfo.get_kernels_map(when=self.when),
 261                 }
 262                 return self.render("fireinfo/stats-oses.html", **data)
 263
 264
 265 class StatsVirtualHandler(BaseHandler):
 266         def get(self):
 267                 data = {
 268                         "hypervisors" : self.fireinfo.get_hypervisor_map(when=self.when),
 269                         "virtual"     : self.fireinfo.get_virtual_ratio(when=self.when),
 270                 }
 271
 272                 return self.render("fireinfo/stats-virtual.html", **data)
 273
 274
 275 class StatsGeoHandler(BaseHandler):
 276         def get(self):
 277                 return self.render("fireinfo/stats-geo.html",
 278                         geo_locations = self.fireinfo.get_geo_location_map(when=self.when))
 279
 280
 281 class StatsLanguagesHandler(BaseHandler):
 282         def get(self):
 283                 return self.render("fireinfo/stats-languages.html",
 284                         languages = self.fireinfo.get_language_map(when=self.when))
 285
 286
 287 class StatsNetworkingHandler(BaseHandler):
 288         def get(self):
 289                 network=self.fireinfo.get_network_zones_map(when=self.when)
 290
 291                 return self.render("fireinfo/stats-network.html", network=network)
 292
 293
 294 class DeviceVendorHandler(BaseHandler):
 295         def get(self, subsystem, vendor_id):
 296                 devices = self.fireinfo.get_devices_by_vendor(subsystem, vendor_id,
 297                         when=self.when)
 298
 299                 vendor_name = self.fireinfo.get_vendor_string(subsystem, vendor_id)
 300
 301                 self.render("fireinfo/vendor-detail.html", vendor_name=vendor_name,
 302                         devices=devices)
 303
 304
 305 class DeviceVendorCompatHandler(BaseHandler):
 306         def get(self, subsystem, vendor_id):
 307                 self.redirect("/device/%s/%s" % (subsystem, vendor_id))
 308
 309
 310 class DeviceModelHandler(BaseHandler):
 311         def get(self, subsystem, vendor, model):
 312                 percentage = self.fireinfo.get_device_percentage(subsystem, vendor,
 313                                 model, when=self.when)
 314                 percentage *= 100
 315
 316                 profiles = self.fireinfo.get_device_in_profile(subsystem, vendor,
 317                                 model, when=self.when)
 318
 319                 vendor_name = self.fireinfo.get_vendor_string(subsystem, vendor)
 320                 model_name = self.fireinfo.get_model_string(subsystem, vendor, model)
 321
 322                 self.render("fireinfo/model-detail.html", profiles=profiles,
 323                         vendor_id=vendor, vendor_name=vendor_name,
 324                         model_id=model, model_name=model_name,
 325                         percentage=percentage, subsystem=subsystem)
 326
 327
 328 class DeviceModelCompatHandler(BaseHandler):
 329         def get(self, subsystem, vendor_id, model_id):
 330                 self.redirect("/device/%s/%s/%s" % (subsystem, vendor_id, model_id))
 331
 332
 333 class AdminFireinfoHandler(BaseHandler):
 334         def get(self):
 335                 profiles_with_data, profiles_all = self.fireinfo.get_active_profiles(when=self.when)
 336
 337                 data = {
 338                         "archive_size"       : self.fireinfo.get_archive_size(when=self.when),
 339                         "total_updates"      : self.fireinfo.get_total_updates_count(when=self.when),
 340                         "profiles_with_data" : profiles_with_data,
 341                         "profiles_all"       : profiles_all,
 342                 }
 343
 344                 self.render("fireinfo/stats-admin.html", **data)
 345
 346
 347 class DeviceTableModule(ui_modules.UIModule):
 348         def render(self, devices):
 349                 return self.render_string("fireinfo/modules/table-devices.html",
 350                                 devices=devices)
 351
 352
 353 class DeviceAndGroupsTableModule(ui_modules.UIModule):
 354         def render(self, devices):
 355                 _ = self.locale.translate
 356
 357                 groups = {}
 358
 359                 for device in devices:
 360                         if device.cls not in groups:
 361                                 groups[device.cls] = []
 362
 363                         groups[device.cls].append(device)
 364
 365                 # Sort all devices
 366                 for key in list(groups.keys()):
 367                         groups[key].sort()
 368
 369                 # Order the groups by their name
 370                 groups = list(groups.items())
 371                 groups.sort()
 372
 373                 return self.render_string("fireinfo/modules/table-devices-and-groups.html",
 374                                 groups=groups)
 375
 376
 377 class GeoTableModule(ui_modules.UIModule):
 378         def render(self, items):
 379                 countries = []
 380                 other_countries = []
 381                 for code, value in items:
 382                         # Skip the satellite providers in this ranking
 383                         if code in (None, "A1", "A2"):
 384                                 continue
 385
 386                         name = self.backend.geoip.get_country_name(code)
 387
 388                         # Don't add countries with a small share on the list
 389                         if value < 0.01:
 390                                 other_countries.append(name)
 391                                 continue
 392
 393                         country = database.Row({
 394                                 "code"  : code,
 395                                 "name"  : name,
 396                                 "value" : value,
 397                         })
 398                         countries.append(country)
 399
 400                 return self.render_string("fireinfo/modules/table-geo.html",
 401                         countries=countries, other_countries=other_countries)