Migrate to libloc

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

#!/usr/bin/python

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

from .. import fireinfo

from . import auth
from . import base
from . import ui_modules

class BaseHandler(auth.CacheMixin, 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)

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

			except fireinfo.ProfileParserError as e:
				raise tornado.web.HTTPError(400, "Could not parse profile: %s" % e)

		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),
		}

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


class DriverDetail(BaseHandler):
	def get(self, driver):
		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)

		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),
		}

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


class ProcessorsHandler(BaseHandler):
	def get(self):
		flags = {}

		for platform in ("arm", "x86"):
			flags[platform] = \
				self.fireinfo.get_common_cpu_flags_by_platform(platform, when=self.when)

		return self.render("fireinfo/processors.html", flags=flags)


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

		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)

		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 AdminIndexHandler(BaseHandler):
	@tornado.web.authenticated
	def prepare(self):
		if not self.current_user.is_staff():
			raise tornado.web.HTTPError(401)

	@tornado.web.authenticated
	def get(self):
		with_data, total = self.backend.fireinfo.get_active_profiles()

		self.render("fireinfo/admin.html", with_data=with_data, total=total)