fireinfo: Add page for all information about releases

[ipfire.org.git] / src / web / fireinfo.py

#!/usr/bin/python

import datetime
import hwdata
import logging
import re
import json
import tornado.web

from .. import fireinfo

from . import base
from . import ui_modules

class BaseHandler(base.BaseHandler):
	@property
	def when(self):
		return self.get_argument_date("when", None)


MIN_PROFILE_VERSION = 0
MAX_PROFILE_VERSION = 0

class Profile(dict):
	def __getattr__(self, key):
		try:
			return self[key]
		except KeyError:
			raise AttributeError(key)

	def __setattr__(self, key, val):
		self[key] = val


class ProfileSendHandler(BaseHandler):
	def check_xsrf_cookie(self):
		# This cookie is not required here.
		pass

	def prepare(self):
		# Create an empty profile.
		self.profile = Profile()

	def __check_attributes(self, profile):
		"""
			Check for attributes that must be provided,
		"""
		attributes = (
			"private_id",
			"profile_version",
			"public_id",
		)
		for attr in attributes:
			if attr not in profile:
				raise tornado.web.HTTPError(400, "Profile lacks '%s' attribute: %s" % (attr, profile))

	def __check_valid_ids(self, profile):
		"""
			Check if IDs contain valid data.
		"""
		for id in ("public_id", "private_id"):
			if re.match(r"^([a-f0-9]{40})$", "%s" % profile[id]) is None:
				raise tornado.web.HTTPError(400, "ID '%s' has wrong format: %s" % (id, profile))

	def __check_equal_ids(self, profile):
		"""
			Check if public_id and private_id are equal.
		"""
		if profile.public_id == profile.private_id:
			raise tornado.web.HTTPError(400, "Public and private IDs are equal: %s" % profile)

	def __check_matching_ids(self, profile):
		"""
			Check if a profile with the given public_id is already in the
			database. If so we need to check if the private_id matches.
		"""
		p = self.profiles.find_one({ "public_id" : profile["public_id"]})
		if not p:
			return

		p = Profile(p)
		if p.private_id != profile.private_id:
			raise tornado.web.HTTPError(400, "Mismatch of private_id: %s" % profile)

	def __check_profile_version(self, profile):
		"""
			Check if this version of the server software does support the
			received profile.
		"""
		version = profile.profile_version

		if version < MIN_PROFILE_VERSION or version > MAX_PROFILE_VERSION:
			raise tornado.web.HTTPError(400,
				"Profile version is not supported: %s" % version)

	def check_profile_blob(self, profile):
		"""
			This method checks if the blob is sane.
		"""
		checks = (
			self.__check_attributes,
			self.__check_valid_ids,
			self.__check_equal_ids,
			self.__check_profile_version,
			# These checks require at least one database query and should be done
			# at last.
			self.__check_matching_ids,
		)

		for check in checks:
			check(profile)

		# If we got here, everything is okay and we can go on...

	def get_profile_blob(self):
		profile = self.get_argument("profile", None)

		# Send "400 bad request" if no profile was provided
		if not profile:
			raise tornado.web.HTTPError(400, "No profile received")

		# Try to decode the profile.
		try:
			return json.loads(profile)
		except json.decoder.JSONDecodeError as e:
			raise tornado.web.HTTPError(400, "Profile could not be decoded: %s" % e)

	# The GET method is only allowed in debugging mode.
	def get(self, public_id):
		if not self.application.settings["debug"]:
			raise tornado.web.HTTPError(405)

		return self.post(public_id)

	def post(self, public_id):
		profile_blob = self.get_profile_blob()
		#self.check_profile_blob(profile_blob)

		# Get location
		location = self.get_remote_location()
		if location:
			location = location.country

		# Handle the profile.
		with self.db.transaction():
			try:
				self.fireinfo.handle_profile(public_id, profile_blob, location=location)

			except fireinfo.ProfileParserError:
				raise tornado.web.HTTPError(400)

		self.finish("Your profile was successfully saved to the database.")


class IndexHandler(BaseHandler):
	def get(self):
		data = {
			# Release
			"latest_release" : self.backend.releases.get_latest(),

			# Hardware
			"arches"         : self.fireinfo.get_arch_map(when=self.when),
			"cpu_vendors"    : self.fireinfo.get_cpu_vendors_map(when=self.when),
			"memory_avg"     : self.backend.fireinfo.get_average_memory_amount(when=self.when),

			# Virtualization
			"hypervisors"    : self.fireinfo.get_hypervisor_map(when=self.when),
			"virtual_ratio"  : self.fireinfo.get_virtual_ratio(when=self.when),

			# Location
			"locations"      : self.fireinfo.get_geo_location_map(when=self.when),
		}

		# Cache for 1h
		self.set_expires(3600)

		self.render("fireinfo/index.html", **data)


class DriverDetail(BaseHandler):
	def get(self, driver):
		# Cache for 1h
		self.set_expires(3600)

		self.render("fireinfo/driver.html", driver=driver,
			driver_map=self.fireinfo.get_driver_map(driver, when=self.when))


class ProfileHandler(BaseHandler):
	def get(self, profile_id):
		profile = self.fireinfo.get_profile(profile_id, when=self.when)

		if not profile or not profile.is_showable():
			raise tornado.web.HTTPError(404)

		# Cache for 1h
		self.set_expires(3600)

		self.render("fireinfo/profile.html", profile=profile)


class RandomProfileHandler(BaseHandler):
	def get(self):
		profile_id = self.fireinfo.get_random_profile(when=self.when)
		if profile_id is None:
			raise tornado.web.HTTPError(404)

		self.redirect("/profile/%s" % profile_id)


class ReleasesHandler(BaseHandler):
	def get(self):
		data = {
			"releases" : self.fireinfo.get_releases_map(when=self.when),
			"kernels"  : self.fireinfo.get_kernels_map(when=self.when),
		}

		# Cache for 1h
		self.set_expires(3600)

		return self.render("fireinfo/releases.html", **data)


class StatsHandler(BaseHandler):
	def get(self):
		self.render("fireinfo/stats.html")


class StatsProcessorsHandler(BaseHandler):
	def get(self):
		avg, stddev, min, max = self.fireinfo.get_cpu_clock_speeds(when=self.when)
		arch_map = self.fireinfo.get_arch_map(when=self.when)

		data = {
			"arch_map" : arch_map,
			"cpu_vendors" : self.fireinfo.get_cpu_vendors_map(when=self.when),
			"clock_speed_avg" : avg,
			"clock_speed_stddev" : stddev,
			"clock_speed_min" : min,
			"clock_speed_max" : max,
		}

		return self.render("fireinfo/stats-cpus.html", **data)


class StatsProcessorDetailHandler(BaseHandler):
	def get(self, platform):
		assert platform in ("arm", "x86")

		flags = self.fireinfo.get_common_cpu_flags_by_platform(platform, when=self.when)

		return self.render("fireinfo/stats-cpus-detail.html",
			platform=platform, flags=flags)


class VendorsHandler(BaseHandler):
	def get(self):
		vendors = self.fireinfo.get_vendor_list(when=self.when)

		# Cache for 1h
		self.set_expires(3600)

		self.render("fireinfo/vendors.html", vendors=vendors)


class VendorHandler(BaseHandler):
	def get(self, subsystem, vendor_id):
		devices = self.fireinfo.get_devices_by_vendor(subsystem, vendor_id, when=self.when)
		if not devices:
			raise tornado.web.HTTPError(404)

		vendor_name = self.fireinfo.get_vendor_string(subsystem, vendor_id)

		# Cache for 1h
		self.set_expires(3600)

		self.render("fireinfo/vendor.html", vendor_name=vendor_name, devices=devices)


class DeviceTableModule(ui_modules.UIModule):
	def render(self, devices, show_group=True, embedded=False):
		return self.render_string("fireinfo/modules/table-devices.html",
				devices=devices, show_group=show_group, embedded=embedded)


class DeviceAndGroupsTableModule(ui_modules.UIModule):
	def render(self, devices):
		_ = self.locale.translate

		groups = {}

		for device in devices:
			if device.cls not in groups:
				groups[device.cls] = []

			groups[device.cls].append(device)

		# Sort all devices
		for key in list(groups.keys()):
			groups[key].sort()

		# Order the groups by their name
		groups = list(groups.items())
		groups.sort()

		return self.render_string("fireinfo/modules/table-devices-and-groups.html",
				groups=groups)


class GeoTableModule(ui_modules.UIModule):
	def render(self, items):
		countries = []
		other_countries = []
		for code, value in items:
			# Skip the satellite providers in this ranking
			if code in (None, "A1", "A2"):
				continue

			name = self.backend.geoip.get_country_name(code)

			# Don't add countries with a small share on the list
			if value < 0.01:
				other_countries.append(name)
				continue

			country = database.Row({
				"code"  : code,
				"name"  : name,
				"value" : value,
			})
			countries.append(country)

		return self.render_string("fireinfo/modules/table-geo.html",
			countries=countries, other_countries=other_countries)