From bdb5d3ceb2734916683557d986dfd8112475e966 Mon Sep 17 00:00:00 2001
From: Wil Tan <wil@dready.org>
Date: Thu, 24 Dec 2009 20:13:03 +1100
Subject: [PATCH] initial commit

---
 src/README.rst      |  22 ++++
 src/gt/__init__.py  |   0
 src/gt/__init__.pyc | Bin 0 -> 129 bytes
 src/gt/monkey.py    | 247 ++++++++++++++++++++++++++++++++++++++++++++
 src/gt/monkey.pyc   | Bin 0 -> 10242 bytes
 5 files changed, 269 insertions(+)
 create mode 100644 src/README.rst
 create mode 100644 src/gt/__init__.py
 create mode 100644 src/gt/__init__.pyc
 create mode 100644 src/gt/monkey.py
 create mode 100644 src/gt/monkey.pyc

diff --git a/src/README.rst b/src/README.rst
new file mode 100644
index 0000000..4b3e4eb
--- /dev/null
+++ b/src/README.rst
@@ -0,0 +1,22 @@
+gtornado = Tornado + gevent
+===========================
+
+:Author: Wil Tan
+:Version: $Revision: 
+
+
+Introduction
+------------
+
+Tornado_ is a high performance web server and framework. It operates in a non-blocking fashion,
+utilizing  Linux's epoll_ facility when available. It also comes bundled with several niceties
+such as authentication via OpenID, OAuth, secure cookies, templates, CSRF protection and UI modules.
+
+Unfortunately, some of its features ties the developer into its own asynchronous API implementation.
+
+This module is an experiment to monkey patch it just enough to make it run under gevent.
+One advantage of doing so is that one can use a coroutine-style and code in a blocking fashion
+while being able to use the tornado framework.
+
+.. _Tornado: http://www.tornadoweb.org/
+.. _epoll: http://www.kernel.org/doc/man-pages/online/pages/man4/epoll.4.html
diff --git a/src/gt/__init__.py b/src/gt/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/gt/__init__.pyc b/src/gt/__init__.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6f9255b63a1597b51c9430e5e1e085d3ec71992
GIT binary patch
literal 129
zcmdn|iI>ZCtATei0~9a<X$K%KW&si@3=F{<AQ3+eAi;n}6l(#+^h1kNi;DHjGjsHd
vi<0%zOY)2I5>xV_9R2wC%)HE!_;|g7%3=<na+}=zl+v73JCLEpK+FIDvM(A=

literal 0
HcmV?d00001

diff --git a/src/gt/monkey.py b/src/gt/monkey.py
new file mode 100644
index 0000000..cb30e8b
--- /dev/null
+++ b/src/gt/monkey.py
@@ -0,0 +1,247 @@
+import time
+import cgi
+import gevent
+import gevent.hub
+import gevent.http
+
+def patch_tornado_ioloop():
+    _tornado_iol = __import__('tornado.ioloop', fromlist=['fromlist_has_to_be_non_empty'])
+    _IOLoop = _tornado_iol.IOLoop
+
+    class IOLoop:
+        def __init__(self):
+            self._handlers = {} # by fd
+            self._events = {} # by fd
+
+        def start(self):
+            gevent.hub.get_hub().switch()
+
+        def remove_handler(self, fd):
+            self._handlers.pop(fd, None)
+            ev = self._events.pop(fd, None)
+            ev.cancel()
+
+        def update_handler(self, fd, events):
+            handler = self._handlers.pop(fd, None)
+            ev = self._events[fd]
+            self.remove_handler(fd)
+            self.add_handler(fd, handler, events)
+
+        def add_handler(self, fd, handler, events):
+            type = 0
+            if events & _IOLoop.READ:
+                type = type | gevent.core.EV_READ
+            if events & _IOLoop.WRITE:
+                type = type | gevent.core.EV_WRITE
+            if events & _IOLoop.ERROR:
+                type = type | gevent.core.EV_SIGNAL
+
+            def callback(ev, type):
+                tornado_events = 0
+                if type & gevent.core.EV_READ:
+                    tornado_events |= _IOLoop.READ
+                if type & gevent.core.EV_WRITE:
+                    tornado_events |= _IOLoop.WRITE
+                if type & gevent.core.EV_SIGNAL:
+                    tornado_events |= _IOLoop.ERROR
+                return handler(ev.fd, tornado_events)
+
+            self._events[fd] = gevent.core.event(type, fd, callback)
+            self._handlers[fd] = handler
+
+
+        def add_callback(self, callback):
+            print "adding callback"
+            gevent.spawn(callback)
+
+        def add_timeout(self, deadline, callback):
+            print "adding callback"
+            gevent.spawn_later(int(deadline - time.time()), callback)
+
+        @classmethod
+        def instance(cls):
+            print "new instance?"
+            if not hasattr(cls, "_instance"):
+                cls._instance = cls()
+            return cls._instance
+
+    #print "orig ioloop = ", dir(_tornado_iol)
+    _tornado_iol.IOLoop = IOLoop
+    #print "iol = ", id(_tornado_iol.IOLoop)
+
+
+
+def patch_tornado_httpserver():
+    from tornado.httpserver import HTTPRequest
+
+    def parse_t_http_output(buf):
+        headers, body = buf.split("\r\n\r\n", 1)
+        headers = headers.split("\r\n")
+        ver, code, msg = headers[0].split(" ", 2)
+        code = int(code)
+        chunked = False
+
+        headers_out = []
+        for h in headers[1:]:
+            k, v = h.split(":", 1)
+            if k == "Transfer-Encoding" and v == "chunked":
+                chunked = True
+            headers_out.append((k, v.lstrip()))
+
+        return code, msg, headers_out, body, chunked
+
+    def parse_post_body(req, body):
+        content_type = req.headers.get("Content-Type", "")
+        if req.method == "POST":
+            if content_type.startswith("application/x-www-form-urlencoded"):
+                arguments = cgi.parse_qs(req.body)
+                for name, values in arguments.iteritems():
+                    values = [v for v in values if v]
+                    if values:
+                        req.arguments.setdefault(name, []).extend(values)
+            elif content_type.startswith("multipart/form-data"):
+                boundary = content_type[30:]
+                if boundary:
+                    self._parse_mime_body(boundary, data)
+                    # from HTTPConnection._parse_mime_body
+                    if data.endswith("\r\n"):
+                        footer_length = len(boundary) + 6
+                    else:
+                        footer_length = len(boundary) + 4
+                    parts = data[:-footer_length].split("--" + boundary + "\r\n")
+                    for part in parts:
+                        if not part: continue
+                        eoh = part.find("\r\n\r\n")
+                        if eoh == -1:
+                            logging.warning("multipart/form-data missing headers")
+                            continue
+                        headers = HTTPHeaders.parse(part[:eoh])
+                        name_header = headers.get("Content-Disposition", "")
+                        if not name_header.startswith("form-data;") or \
+                           not part.endswith("\r\n"):
+                            logging.warning("Invalid multipart/form-data")
+                            continue
+                        value = part[eoh + 4:-2]
+
+
+                        name_values = {}
+                        for name_part in name_header[10:].split(";"):
+                            name, name_value = name_part.strip().split("=", 1)
+                            name_values[name] = name_value.strip('"').decode("utf-8")
+                        if not name_values.get("name"):
+                            logging.warning("multipart/form-data value missing name")
+                            continue
+                        name = name_values["name"]
+                        if name_values.get("filename"):
+                            ctype = headers.get("Content-Type", "application/unknown")
+                            req.files.setdefault(name, []).append(dict(
+                                filename=name_values["filename"], body=value,
+                                content_type=ctype))
+                        else:
+                            req.arguments.setdefault(name, []).append(value)
+
+
+    class FakeStream():
+        def __init__(self):
+            self._closed = False
+
+        def closed(self):
+            print "stream closed = ", self._closed
+            return self._closed
+
+
+    class FakeConnection():
+        def __init__(self, r):
+            self._r = r
+            self.xheaders = False
+            self.reply_started = False
+            self.stream = FakeStream()
+            #r.connection.set_closecb(self)
+
+        def _cb_connection_close(self, conn):
+            print "connection %r closed!!!!" % (conn,)
+            print "stream = %r" % self.stream
+            self.stream._closed = True
+            print "flagged stream as closed"
+
+        def write(self, chunk):
+            if not self.reply_started:
+                #print "starting reply..."
+                # need to parse the first line as RequestHandler actually writes the response line
+                code, msg, headers, body, chunked = parse_t_http_output(chunk)
+
+                for k, v in headers:
+                    #print "header[%s] = %s" % (k, v)
+                    self._r.add_output_header(k, v)
+
+                if chunked:
+                    self._r.send_reply_start(code, msg)
+                    self._r.send_reply_chunk(body)
+                else:
+                    self._r.send_reply(code, msg, body)
+                self.reply_started = True
+            else:
+                print "writing %s" % chunk
+                self._r.send_reply_chunk(chunk)
+
+        def finish(self):
+            print "finishing..."
+            self._r.send_reply_end()
+            print "finished"
+
+
+    class GHttpServer:
+        def __init__(self, t_app):
+            def debug_http_cb(r):
+                print "http request = ", r
+                for m in dir(r):
+                    o = eval("r." + m)
+                    if type(o) in (str, list, int, tuple):
+                        print "r.%s = %r" % (m, o)
+                r.add_output_header("X-Awesomeness", "100%")
+                r.send_reply(200, "OK", '<b>hello</b>')
+
+
+            def http_cb(r):
+                body = r.input_buffer.read()
+                treq = HTTPRequest(
+                        r.typestr, # method
+                        r.uri, # uri
+                        headers=dict(r.get_input_headers()), # need to transform from list of tuples to dict
+                        body=body,
+                        remote_ip=r.remote_host,
+                        protocol="http", # or https
+                        host=None, # 127.0.0.1?
+                        files=None, # ??
+                        connection=FakeConnection(r))
+
+                parse_post_body(treq, body)
+                
+                """
+                print "http request = ", r
+                for m in dir(r):
+                    o = eval("r." + m)
+                    if type(o) in (str, list, int, tuple):
+                        print "r.%s = %r" % (m, o)
+                """
+                t_app(treq)
+
+            self._httpserver = gevent.http.HTTPServer(http_cb)
+
+        def listen(self, port):
+            self._httpserver.serve_forever(('0.0.0.0', port), backlog=128)
+
+        @classmethod
+        def instance(cls):
+            print "new instance?"
+            if not hasattr(cls, "_instance"):
+                cls._instance = cls()
+            return cls._instance
+
+    _httpserver = __import__('tornado.httpserver', fromlist=['fromlist_has_to_be_non_empty'])
+    _httpserver.HTTPServer = GHttpServer
+
+
+def patch_tornado():
+    patch_tornado_ioloop()
+    patch_tornado_httpserver()
diff --git a/src/gt/monkey.pyc b/src/gt/monkey.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e4497e92eea90dc6afa943dd6baef793ab1df537
GIT binary patch
literal 10242
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

literal 0
HcmV?d00001