python: Converted ashd-wsgi3 as well to use ashd.serve.

diff --git a/python3/ashd-wsgi3 b/python3/ashd-wsgi3
index 8944b5c..40a3722 100755 (executable)
--- a/python3/ashd-wsgi3
+++ b/python3/ashd-wsgi3
@@ -1,7 +1,7 @@
 #!/usr/bin/python3
 
 import sys, os, getopt, threading, logging, time, locale, collections
-import ashd.proto, ashd.util, ashd.perf
+import ashd.proto, ashd.util, ashd.perf, ashd.serve
 try:
     import pdm.srv
 except:
@@ -52,10 +52,6 @@ else:
         sys.exit(1)
     handler = handlermod.application
 
-class closed(IOError):
-    def __init__(self):
-        super().__init__("The client has closed the connection.")
-
 cwd = os.getcwd()
 def absolutify(path):
     if path[0] != '/':
@@ -95,7 +91,7 @@ def unquoteurl(url):
             buf.append(c)
     return buf
 
-def dowsgi(req):
+def mkenv(req):
     env = {}
     env["wsgi.version"] = 1, 0
     for key, val in req.headers:
@@ -147,98 +143,55 @@ def dowsgi(req):
     env["wsgi.multithread"] = True
     env["wsgi.multiprocess"] = False
     env["wsgi.run_once"] = False
+    return env
 
-    resp = []
-    respsent = []
+if reqlimit != 0:
+    guard = ashd.serve.calllimiter(reqlimit).call
+else:
+    guard = lambda fun: fun()
 
-    def recode(thing):
-        if isinstance(thing, collections.ByteString):
-            return thing
-        else:
-            return str(thing).encode("latin-1")
+def recode(thing):
+    if isinstance(thing, collections.ByteString):
+        return thing
+    else:
+        return str(thing).encode("latin-1")
+
+class reqthread(ashd.serve.wsgithread):
+    def __init__(self, req):
+        super().__init__(name = "Request handler")
+        self.req = req.dup()
 
-    def flushreq():
-        if not respsent:
-            if not resp:
-                raise Exception("Trying to write data before starting response.")
-            status, headers = resp
-            respsent[:] = [True]
-            buf = bytearray()
-            buf += b"HTTP/1.1 " + recode(status) + b"\n"
-            for nm, val in headers:
-                buf += recode(nm) + b": " + recode(val) + b"\n"
-            buf += b"\n"
-            try:
-                req.sk.write(buf)
-            except IOError:
-                raise closed()
+    def handlewsgi(self):
+        return handler(self.env, self.startreq)
 
-    def write(data):
-        if not data:
-            return
-        flushreq()
+    def writehead(self, status, headers):
+        buf = bytearray()
+        buf += b"HTTP/1.1 " + recode(status) + b"\n"
+        for nm, val in headers:
+            buf += recode(nm) + b": " + recode(val) + b"\n"
+        buf += b"\n"
         try:
-            req.sk.write(data)
-            req.sk.flush()
+            self.req.sk.write(buf)
         except IOError:
-            raise closed()
+            raise ashd.serve.closed()
 
-    def startreq(status, headers, exc_info = None):
-        if resp:
-            if exc_info:                # Interesting, this...
-                try:
-                    if respsent:
-                        raise exc_info[1]
-                finally:
-                    exc_info = None     # CPython GC bug?
-            else:
-                raise Exception("Can only start responding once.")
-        resp[:] = status, headers
-        return write
-
-    with ashd.perf.request(env) as reqevent:
+    def writedata(self, data):
         try:
-            respiter = handler(env, startreq)
-            try:
-                for data in respiter:
-                    write(data)
-                if resp:
-                    flushreq()
-            finally:
-                if hasattr(respiter, "close"):
-                    respiter.close()
-        except closed:
-            pass
-        if resp:
-            reqevent.response(resp)
-
-flightlock = threading.Condition()
-inflight = 0
-
-class reqthread(threading.Thread):
-    def __init__(self, req):
-        super().__init__(name = "Request handler")
-        self.req = req.dup()
+            self.req.sk.write(data)
+            self.req.sk.flush()
+        except IOError:
+            raise ashd.serve.closed()
+
+    def handle(self):
+        self.env = mkenv(self.req)
+        with ashd.perf.request(self.env) as reqevent:
+            super().handle()
+            if self.status:
+                reqevent.response([self.status, self.headers])
     
     def run(self):
-        global inflight
         try:
-            with flightlock:
-                if reqlimit != 0:
-                    start = time.time()
-                    while inflight >= reqlimit:
-                        flightlock.wait(10)
-                        if time.time() - start > 10:
-                            os.abort()
-                inflight += 1
-            try:
-                dowsgi(self.req)
-            finally:
-                with flightlock:
-                    inflight -= 1
-                    flightlock.notify()
-        except:
-            log.error("exception occurred in handler thread", exc_info=True)
+            guard(super().run)
         finally:
             self.req.close()
             sys.stderr.flush()