mandaye/mandaye/server.py

import Cookie
import json
import urllib2
import random
import re
import os
import time

from md5 import md5
from urlparse import urlparse

from mandaye import config
from mandaye.backends.default import storage_conn
from mandaye.dispatcher import Dispatcher
from mandaye.exceptions import ImproperlyConfigured
from mandaye.log import logger, UuidFilter
from mandaye.handlers.default import MandayeRedirectHandler, MandayeErrorHandler
from mandaye.http import HTTPHeader, HTTPRequest, HTTPResponse
from mandaye.response import _404, _502, _500


def get_response(env, request, url, cookiejar=None):
    """ request: Mandaye Request
    url: the target url
    """
    # Cleaning url
    if config.debug:
        opener = urllib2.build_opener(MandayeErrorHandler, MandayeRedirectHandler,
                urllib2.HTTPSHandler(debuglevel=1), urllib2.HTTPHandler(debuglevel=1))
    else:
        opener = urllib2.build_opener(MandayeErrorHandler, MandayeRedirectHandler)
    urllib2.install_opener(opener)
    url = re.sub('(?<!:)/+', '/', url)
    if not '://' in url:
        url = env['target'].geturl() + url
    if request.req_method == 'POST':
        req = urllib2.Request(url, request.msg, request.headers.getheaders())
        logger.info('Mandaye POST %s' % url)
        logger.debug('POST content %s' % request.msg)
    else:
        req = urllib2.Request(url, headers=request.headers.getheaders())
        logger.info('Mandaye GET %s' % url)
    # Load the cookies
    if request.cookies:
        req.add_header('cookie', request.cookies.output(attrs=[], sep=';', header=''))
    try:
        if cookiejar != None:
            opener.add_handler(urllib2.HTTPCookieProcessor(cookiejar))
        resp = opener.open(req)
    except Exception, e:
        logger.info("%s failed with error : %s" % (url, str(e)))
        response = _502(env['PATH_INFO'], req.get_host(), e)
    else:
        response = HTTPResponse()
        response.load_from_urllib(resp)
        if cookiejar:
            response.cookies = Cookie.BaseCookie()
            for cookie in cookiejar:
                if response.cookies.get(cookie.name) == cookie.value:
                    continue
                if response.cookies.has_key(cookie.name):
                    del response.cookies[cookie.name]
                response.cookies[cookie.name] = cookie.value
                if cookie.expires:
                    response.cookies[cookie.name]['expires'] = Cookie._getdate(cookie.expires-time.time())
                if cookie.domain.startswith('.'):
                    response.cookies[cookie.name]['domain'] = cookie.domain
                if cookie.path:
                    response.cookies[cookie.name]['path'] = cookie.path
                # TODO: add the other RFC 2109 cookie values
        resp.close()
    return response


def strize(v):
    '''Flatten unicode strings to str encoded as UTF-8'''
    if isinstance(v, unicode):
        return v.encode('utf-8')
    if isinstance(v, (list, tuple)):
        return type(v)([strize(e) for e in v])
    if isinstance(v, dict):
        return dict((strize(k), strize(e)) for k, e in v.iteritems())
    return v


class MandayeApp(object):

    def __init__(self):
        self.env = None
        self.dispatcher = None
        self.raven_client = None
        if config.raven_dsn:
            from raven import Client
            self.raven_client = Client(config.raven_dsn)

    def __call__(self, env, start_response):
        """ called by the WSGI server
        env: standard WSGI env
        start_response: stanard WSGI / CGI function
        """
        response = []
        try:
            self.env = env
            if env.has_key('HTTP_X_FORWARDED_SCHEME'):
                self.env['mandaye.scheme'] = env['HTTP_X_FORWARDED_SCHEME']
            else:
                self.env['mandaye.scheme'] = env['wsgi.url_scheme']
            self.env['mandaye.uuid'] = self._get_uuid()
            self.dispatcher = None
            local_host = env['HTTP_HOST']
            path_info = env['PATH_INFO']
            UuidFilter.uuid = self.env['mandaye.uuid']
            logger.info("Client %s - %s %s://%s%s" %\
                    (self.env['REMOTE_ADDR'], self.env['REQUEST_METHOD'],
                        self.env['wsgi.url_scheme'], self.env['HTTP_HOST'],
                        self.env['PATH_INFO']))
            for conf in os.listdir(config.config_root):
                conf_file = os.path.join(config.config_root, conf)
                if os.path.isfile(conf_file):
                    with open(conf_file, 'r') as f:
                        conf = json.loads(f.read())
                    for param in ['site_name', 'location', 'target', 'server_name', 'mapper', 'auth_type']:
                        if not conf.has_key(param):
                            error = 'you must set %s option in vhost : %s' % \
                                    (param, conf_file)
                            logger.error(error)
                            raise ImproperlyConfigured, error
                    for param in ['location', 'target', 'server_name', 'mapper', 'auth_type']:
                        if param in conf:
                            conf[param] = strize(conf[param])
                    if not config.mappers.has_key(conf['mapper']):
                        err = '%s: mapper %s not found' % \
                                (conf_file, conf['mapper'])
                        logger.error(err)
                        raise ImproperlyConfigured, err
                    if not config.authentifications.has_key(conf['auth_type']):
                        err = '%s: authentification %s not found' % \
                                (conf_file, conf['auth_type'])
                        logger.error(err)
                        raise ImproperlyConfigured, err
                    if local_host in conf['server_name'] and \
                            re.match(re.compile(conf['location']), path_info):
                        if conf.get('force_ssl'):
                            self.env['mandaye.scheme'] = 'https'
                        self.env['mandaye.config'] = conf
                        self.env['mandaye.vhost'] = conf_file
                        self.dispatcher = Dispatcher(self.env, conf['target'],
                                conf['mapper'])
                        response = self.on_request(start_response)
            if not response:
                response = self.on_response(start_response, _404(env['PATH_INFO']))
            if config.storage_backend == 'mandaye.backends.sql':
                storage_conn.commit()
        except Exception, e:
            if config.storage_backend == 'mandaye.backends.sql':
                storage_conn.rollback()
            if self.raven_client:
                self.raven_client.captureException()
            response = self.on_response(start_response, _500(env['PATH_INFO'], "Unhandled exception",
                exception=e, env=env))
        finally:
            if config.storage_backend == 'mandaye.backends.sql':
                storage_conn.close()
        return response

    def _get_uuid(self):
        id_str = "%f%s%f%s" % (
                    time.time(),
                    id({}),
                    random.random(),
                    os.getpid
                )
        return md5(md5(id_str).hexdigest()).hexdigest()


    def _get_request(self):
        """ Return a Mandaye HTTP Request
        """
        headers = HTTPHeader()
        if self.env.get('CONTENT_LENGTH'):
            headers.addheader('Content-Length', self.env['CONTENT_LENGTH'])
        if self.env.get('CONTENT_TYPE'):
            headers.addheader('Content-Type', self.env['CONTENT_TYPE'])
        for name in (name for name in self.env if name.startswith('HTTP_')):
            value = self.env[name]
            if name != "HTTP_HOST" and name != "HTTP_COOKIE":
                name = name.split('HTTP_')[1].replace('_', '-')
                headers.addheader(name, value)

        cookies = Cookie.BaseCookie()
        env_cookies = self.env.get('HTTP_COOKIE', '').split(';')
        ok_cookies = []
        for cookie in env_cookies:
            try:
                cookies.load(cookie)
                ok_cookies.append(cookie)
            except Cookie.CookieError:
                logger.warning("Can't parse cookie %r", cookie)
        self.env['HTTP_COOKIE'] = ';'.join(ok_cookies)

        if self.env['REQUEST_METHOD'] == 'POST':
            msg = self.env['wsgi.input']
        else:
            msg = None

        request = HTTPRequest(cookies, headers, self.env['REQUEST_METHOD'], msg, None)
        return self.dispatcher.set_request_target(request)


    def on_request(self, start_response):
        request = self._get_request()
        # Calling the dispatcher hook for the request
        response = self.dispatcher.mod_request(request)
        if response:
            return response
        if not request.target:
            response = self.dispatcher.get_response(request)
        elif not "://" in request.target:
            url = urlparse(request.target)
            self.env['PATH_INFO'] = url.path
            self.env['RAW_URI'] = url.path
            self.env['QUERY_STRING'] = url.query
            if self.env['QUERY_STRING']:
                self.env['RAW_URI'] += url.query
            self.env['REQUEST_METHOD'] = request.req_method
            self.env['wsgi.input'] = request.msg
            self.dispatcher = Dispatcher(self.env, self.env['target'].geturl(),
                    self.dispatcher.mapper_name)
            response = self.dispatcher.get_response(request)
        else:
            response = get_response(self.env, request, request.target)
        if response.code != 304:
            response = self.dispatcher.mod_response(request, response)
        return self.on_response(start_response, response)

    def on_response(self, start_response, response):
        """ start_response: wsgi start_response
        response: an instance of HTTPResponse """
        response.headers.addsetcookies(response.cookies)
        start_response('%d %s' % (response.code, response.reason),
                response.headers.items())
        return [response.msg]