code/test/Python/0007376_asvr.py

import os
import time
import urllib
import logging
import mimetypes
from hashlib import md5
from random import random
from cStringIO import StringIO
from Cookie import SimpleCookie

from ahttp import AHTTP
from acore import Worker, Listener, Aact, Acore, SocketClosed, AFILE

from fgdwcfpy.log import logexc


class AbstractSessionMiddleWare(Acore):
    def __init__(self, app):
        Acore.__init__(self)
        self.app = app
        self.session_id = None
        self.is_new_session_cookie = False
        self.sess_cookie_name = "YEASTSESSIONID"
        self.session_return_data = None

    def get(self, key):
        raise NotImplementedError("AbstractSessionMiddleWare.get")

    def put(self, key, value):
        raise NotImplementedError("AbstractSessionMiddleWare.put")

    def start(self):
        " from env, get Cookie, get Session ID "
        cookie = SimpleCookie(self.env.get("HTTP_COOKIE", ""))
        if self.sess_cookie_name not in cookie:
            cookie[self.sess_cookie_name] = self._build_session_id_str()
            self.is_new_session_cookie = True
        self.session_cookie = cookie[self.sess_cookie_name]
        self.session_id = self.session_cookie.value

    def _build_session_id_str(self):
        return md5("%s_%s_%s_%s_%s" % (self.env['REMOTE_ADDR'],
                                       self.env['REMOTE_PORT'],
                                       self.env['REQUEST_PATH'],
                                       time.time(), random()
                   )).hexdigest()

    def handle_start_response(self, status, headers, exc_info=None):
        # modify header to set session cookie
        if self.is_new_session_cookie:
            #logging.warn("Set-Cookie")
            headers['Set-Cookie'] = self.session_cookie.OutputString()
        # call original start_response with modifed header
        self.upper_start_response(status, headers, exc_info)

    def __call__(self, env, start_response):
        self.env = env
        #self.acc.bind_user(env['yeast.SELF'])
        env['yeast.session'] = self
        self.upper_start_response = start_response
        return self._call_(env, self.handle_start_response)

    def _call_(self, env, start_response):
        for y in self.app(env, start_response):
            yield y


class SessionInMemory(AbstractSessionMiddleWare):
    sessions_dict = {}

    def get(self, key, default=None):
        self.session_data = self.sessions_dict.get(
                            self.session_id, {}).get(key, default)
        return self.session_data

    def put(self, key, value):
        if self.session_id not in self.sessions_dict:
            self.sessions_dict[self.session_id] = {}
        self.sessions_dict[self.session_id][key] = value


def WsgiApp(env, start_response):
    start_response(200, {})
    return 'Hallo World\r\n'


class WsgiHandler(Acore):
    app = None
    env = {'SERVER_NAME': 'yeast asvr 0.1',
           #'GATEWAY_INTERFACE'] = 'CGI/1.1'
           'SERVER_PORT': '8080',
           'SCRIPT_NAME': '',
          }

    def __init__(self, sock, addr):
        Acore.__init__(self)
        self.addr = addr
        self.ahttp = AHTTP(sock, user=self)

    def setup_env(self):
        env = self.environ = self.env.copy()
        http_dict = self.ahttp.http_dict
        hs = http_dict['headers']
        env['yeast.SELF'] = self
        env['yeast.AHTTP'] = self.ahttp
        #env['HTTP_HEADERS'] = hs
        env['REMOTE_ADDR'] = self.addr[0]
        env['REMOTE_PORT'] = self.addr[1]
        if hs.typeheader is None:
            env['CONTENT_TYPE'] = hs.type
        else:
            env['CONTENT_TYPE'] = hs.typeheader
        l = hs.getheader('content-length')
        if l:
            env['CONTENT_LENGTH'] = l
        env['SERVER_PROTOCOL'] = http_dict['version']
        env['REQUEST_METHOD'] = http_dict['action']
        env['REQUEST_PATH'] = path = http_dict['path']

        pq = path.split('?', 1)
        p, q = pq[0], pq[1] if len(pq) == 2 else ''

        env['PATH_INFO'] = urllib.unquote(p)
        env['QUERY_STRING'] = q

        for k, v in hs.items():
            k = k.replace('-', '_').upper()
            v = v.strip()
            if k in env:
                continue                     # skip content length, type,etc.
            if 'HTTP_' + k in env:
                env['HTTP_' + k] += ',' + v  # comma-separate multiple headers
            else:
                env['HTTP_' + k] = v

    def wsgi_write(self, data):
        self._buf.write(data)
        self.sent_size += len(data)

    def start_response(self, status, headers, exc_info=None):
        self._buf = StringIO()
        self.sent_size = 0
        self.app_status = status
        self.app_headers = headers
        return self.wsgi_write

    def handle_error(self):
        #self.start_response()
        pass

    def get_body(self):
        #print int(self.environ.get('CONTENT_LENGTH', 0))
        if int(self.environ.get('CONTENT_LENGTH', 0)) > 0:
            for y in self.ahttp.get_body():
                yield y
        #else:
        #    self.ahttp.http_dict['body'] = StringIO()

    def _run(self):
        #assert isinstance(self.app, callable)
        try:
            for y in self.ahttp.get_head():
                yield y
        except SocketClosed:
            self.ahttp.sock.close()
            logging.debug("%s SocketClosed" % str(self.addr))
            return
        self.setup_env()

        for y in self.get_body():
            yield y

        self.result = self.app(self.environ, self.start_response)
        #print repr(self.result)
        for x in self.result:
            if isinstance(x, Aact):
                yield x
            else:
                self.wsgi_write(x)

        # process http status and headers
        msg = StringIO()
        msg.write("%s %d OK\r\n" % (
                   self.ahttp.http_dict['version'], self.app_status))

        # FIXME? is this the right way?
        self.app_headers['Content-Length'] = self.sent_size

        for h, v in self.app_headers.iteritems():
            msg.write("%s: %s\r\n" % (h, v))
        msg.write('\r\n')
        for y in self.ahttp.write_all(msg.getvalue()):
            yield y
        # http body
        for y in self.ahttp.write_all(self._buf.getvalue()):
            yield y
        # FIXME
        self.ahttp.sock.close()

    def run(self):
        try:
            for y in self._run():
                yield y
        except Exception, e:
            logging.error("self.addr = %s" % str(self.addr))
            logexc()
            #logging.error(e)


# copy from wsgiref/handlers.py
# Weekday and month names for HTTP date/time formatting; always English!
_weekdayname = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
_monthname = [None,     # Dummy so we can use 1-based month numbers
              "Jan", "Feb", "Mar", "Apr", "May", "Jun",
              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]


def format_date_time(timestamp):
    year, month, day, hh, mm, ss, wd, y, z = time.gmtime(timestamp)
    return "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
        _weekdayname[wd], day, _monthname[month], year, hh, mm, ss
    )


def static_file_info(fn):
    # Content-Type: text/css
    # Last-Modified: Mon, 07 Oct 2013 18:25:10 GMT
    logging.debug("static_file " + fn)
    try:
        ct, e = mimetypes.guess_type(fn)
        lm = format_date_time(os.path.getmtime(fn))
        fin = open(fn)
    except IOError, e:
        return (None, 404, {})
    else:
        return (fin, 200, {"Last-Modified": lm, "Content-Type": ct})


def start_server(app, handler=WsgiHandler, addr=('', 8080)):
    l = Listener(addr=addr, worker=handler)
    handler.app = staticmethod(app)
    handler.env['SERVER_PORT'] = str(l.addr[1])
    l.start()
    l.loop()