warden_server.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2011-2015 Cesnet z.s.p.o
# Use of this source is governed by a 3-clause BSD-style license, see LICENSE file.

from __future__ import print_function

import abc
import sys
import os
import io
from os import path
import logging
import logging.handlers
import json
import re
from traceback import format_tb
from collections import namedtuple
from itertools import repeat
from time import sleep
from random import randint
import M2Crypto.X509

if sys.version_info[0] >= 3:
    import configparser as ConfigParser
    from urllib.parse import parse_qs
    unicode = str

    def get_method_params(method):
        return method.__code__.co_varnames[:method.__code__.co_argcount]

else:
    import ConfigParser
    from urlparse import parse_qs

    def get_method_params(method):
        return method.func_code.co_varnames[:method.func_code.co_argcount]


# for local version of up to date jsonschema
sys.path.append(path.join(path.dirname(__file__), "..", "lib"))

from jsonschema import Draft4Validator


VERSION = "3.0-beta3"


class Encoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, Error):
            return o.to_dict()
        if isinstance(o, ErrorMessage):
            out = o.other_args.copy()
            out.pop("exc", None)
            out["error"] = o.error
            out["message"] = o.message
            if o.events:
                out["events"] = list(o.events)
            return out
        return str(o)


class ErrorMessage(Exception):

    def __init__(self, error, message, events=None, unique_id=None, **kwargs):
        super(Exception, self).__setattr__("error", error)
        super(Exception, self).__setattr__("message", message)
        super(Exception, self).__setattr__("unique_id", unique_id)
        self.events = set() if events is None else set(events)
        self.other_args = kwargs

    def __repr__(self):
        return "%s(error=%d, message=%s)" % (
            type(self).__name__, self.error, repr(self.message)
        )

    def __str__(self):
        if sys.version_info[0] < 3:
            return self.str_err().encode('ascii', 'backslashereplace')
        return self.str_err()

    def str_err(self):
        exc = self.other_args.get("exc", None)
        if exc in (None, (None, None, None)):
            exc_cause = ""
        else:
            exc_cause = " (cause was %s: %s)" % (exc[0].__name__, str(exc[1]))
        return "Error(%s) %s%s" % (self.error, self.message, exc_cause)

    def str_info(self):
        arg_copy = self.other_args.copy()
        arg_copy.pop("req_id", None)
        arg_copy.pop("method", None)
        arg_copy.pop("exc", None)
        if arg_copy:
            return "Detail: %s" % json.dumps(arg_copy, cls=Encoder)
        return ""

    def str_debug(self):
        exc = self.other_args.get("exc", None)
        if exc in (None, (None, None, None)):
            return ""
        exc_tb = exc[2]
        if not exc_tb:
            return ""

        return "Traceback:\n" + "".join(format_tb(exc_tb))

    def __getattr__(self, name):
        if name in self.other_args:
            return self.other_args[name]
        raise AttributeError

    def __setattr__(self, name, value):
        if name in ("events", "exc", "other_args"):
            super(Exception, self).__setattr__(name, value)
            return
        if name in ("error", "message", "unique_id"):
            raise AttributeError("Cannot change the attribute %s" % name)
        self.other_args[name] = value


class Error(Exception):

    def __init__(self, method=None, req_id=None, errors=None, **kwargs):
        self.method = method
        self.req_id = req_id
        if "message" in kwargs:
            kwargs.setdefault("error", 500)
            self.errors = [ErrorMessage(**kwargs)]
        else:
            self.errors = []
        if errors:
            self.errors.extend(errors)

    def append(self, _events=None, **kwargs):
        kwargs.setdefault("message", "No further information")
        kwargs.setdefault("error", 500)
        self.errors.append(ErrorMessage(**kwargs))

    def get_http_err_msg(self):
        try:
            err = self.errors[0].error
            msg = self.errors[0].message
        except (IndexError, AttributeError):
            err = 500
            msg = "There's NO self-destruction button! Ah, you've just found it..."
            return err, msg

        if not all(msg == e.message for e in self.errors):
            # messages not the same, get Multiple errors
            msg = "Multiple errors"
        if not all(err == e.error for e in self.errors):
            # errors not same, round to basic err code (400, 500)
            # and use the highest one
            err = max(e.error for e in self.errors) // 100 * 100

        msg = "".join((c if '\x20' <= c != '\x7f' else r'\x{:02x}'.format(ord(c))) for c in msg) # escape control characters

        return err, msg

    def __str__(self):
        return "\n".join(str(e) for e in self.errors)

    def log(self, logger, prio=logging.ERROR):
        for e in self.errors:
            logger.log(prio, e.str_err())
            info = e.str_info()
            if info:
                logger.info(info)
            debug = e.str_debug()
            if debug:
                logger.debug(debug)

    def to_dict(self):
        d = {
            "method": self.method,
            "req_id": self.req_id,
            "errors": self.errors
        }
        return d


def get_clean_root_logger(level=logging.INFO):
    """ Attempts to get logging module into clean slate state """

    # We want to be able to set up at least stderr logger before any
    # configuration is read, and then later get rid of it and set up
    # whatever administrator requires.
    # However, there can exist only one logger, but we want to get a clean
    # slate everytime we initialize StreamLogger or FileLogger... which
    # is not exactly supported by logging module.
    # So, we look directly inside logger class and clean up handlers/filters
    # manually.
    logger = logging.getLogger(__name__)
    logger.setLevel(level)
    while logger.handlers:
        logger.handlers[0].close()