handler.py

python web programming 部分

#
# $Workfile: Handler.py $ $Revision: 8 $
# $Date: 10/05/01 12:35a $ $Author: Sholden $
#
import Cookie
import Session
import MapSite
from Params import STIMEOUT_INTERVAL, SCHECK_INTERVAL
import asynchat, cgi, rfc822, cStringIO, time, sys

lastflushtime = 0   # session flushing clock

class HTTP(asynchat.async_chat):

    def __init__(self, conn, addr, sessions):
        asynchat.async_chat.__init__(self, conn=conn)
        self.addr = addr
        self.sessions = sessions
        self.ibuffer = []
        self.obuffer = ""
        self.set_terminator("\r\n\r\n")

    def collect_incoming_data(self, data):
        """Buffer the data, removing carriage returns."""
        self.ibuffer.append(data.replace('\r', ''))

    def found_terminator(self):
        """Parse headers as rfc822, authenticate as necessary and generate content.
        
        Note that the standard input remains unread, to allow appropriate
        handling (such as CGI dictionary creation) from the page code."""

        global lastflushtime
        buffer = "".join(self.ibuffer)
        linebreak = buffer.find("\n")
        request = buffer[:linebreak]
        headers = rfc822.Message(cStringIO.StringIO(buffer[linebreak+1:]))
        cookies = Cookie.SimpleCookie()
        chdr = headers.getheader("cookie")
        if chdr:
            cookies.load(chdr)
        try:
            now = time.time()
            self.sessid = cookies["session"].value
            self.session = self.sessions[self.sessid]
            if now - self.session._atime > STIMEOUT_INTERVAL:
                del self.sessions[self.sessid]
                raise KeyError
            self.session._atime = now
        except KeyError:
            # New session required because no cookie or session timed out
            self.sessions["NEXT"] += 1
            self.sessid = str(self.sessions["NEXT"])
            self.session = self.sessions[self.sessid] = \
                            Session.Session(self.sessid)
        op, path, protocol = request.split()
        if len(path) > 1:
            path = path[1:]
        self.ibuffer = []
        if "?" not in path:
            query = ""
        else:
            path, query = path.split("?", 1)
        path = path.split("/")
        query = cgi.parse_qs(query, 1)
        # Assume argument names appear only once, so no need for lists
        for k, v in query.items():
            query[k] = v[0]
        generator = MapSite.PageSpec(op, path, query, self.session, headers)
        self.obuffer = generator.Generate()
        if now - lastflushtime > SCHECK_INTERVAL:
            lastflushtime = now
            for k in self.sessions.keys():
                if k != "NEXT" and \
                    (now - self.sessions[k]._atime) > STIMEOUT_INTERVAL:
                    del self.sessions[k]
        sys.stdout.flush()

    def writable(self):
        return len(self.obuffer) > 0

    def handle_write(self):
        sent = self.send(self.obuffer)
        self.obuffer = self.obuffer[sent:]
        if len(self.obuffer) == 0:
            self.close()