dramatically improve eventlet worker

gunicorn/workers/async.py

@@ -40,7 +40,7 @@ class AsyncWorker(base.Worker):
                 
             except StopIteration:
                 pass
-        except socket.error, e: 
+        except socket.error, e:
             if e[0] not in (errno.EPIPE, errno.ECONNRESET):
                 self.log.exception("Socket error processing request.")
             else:

gunicorn/workers/geventlet.py

@@ -38,73 +38,37 @@ class EventletWorker(AsyncWorker):
         
     def timeout_ctx(self):
         return eventlet.Timeout(self.cfg.keepalive, False)
+
         
     def run(self):
         self.socket = GreenSocket(family_or_realsock=self.socket.sock)
-        self.socket.setblocking(1)
+        self.socket.setblocking(0)
 
-        pool = greenpool.GreenPool(self.worker_connections)
+        pool = eventlet.GreenPool(self.worker_connections)
-        acceptor = eventlet.spawn(self.acceptor, pool)
-
-        try:
-            while self.alive:
-                self.notify()
-                
-                if self.ppid != os.getppid():
-                    self.log.info("Parent changed, shutting down: %s" % self)
-                    break
-            
-                eventlet.sleep(self.timeout)            
-        except KeyboardInterrupt:
-            pass
-
-        # we stopped
-        with eventlet.Timeout(self.timeout, False):
-            eventlet.kill(acceptor, eventlet.StopServe)
-
-       
-        
-    def acceptor(self, pool):
-        acceptor_gt = greenthread.getcurrent()
         while self.alive:
 
-            # pool is full ?
+            self.notify()
-            if pool.running() > self.worker_connections:
-                continue
 
             try:
-                try:
+                client, addr = self.socket.accept()
-                    conn, addr = self.socket.accept()
+                client.setblocking(1)
-                except socket.error, e:
+                util.close_on_exec(client)
-                    if e[0] == errno.EAGAIN:
+                pool.spawn_n(self.handle, client, addr)
-                        sys.exc_clear()
+            except socket.error, e:
-                        return
+                if e[0] not in (errno.EAGAIN, errno.ECONNABORTED):
                     raise
 
-                gt = pool.spawn(self.handle, conn, addr)
+            if pool.running() > self.worker_connections:
-                gt.link(self._stop_acceptor, acceptor_gt, conn)
+                continue
-                conn, addr, gt = None, None, None
+           
-            except socket.error, e:
+            if self.ppid != os.getppid():
-                if e[0] not in (errno.EBADF, errno.EINVAL, errno.ENOTSOCK):
+                self.log.info("Parent changed, shutting down: %s" % self)
-                    self.alive = False
-                    break
-            except eventlet.StopServe:
-                if pool.waiting():
-                    pool.waitall()
                 break
-            except:
-                self.log.exception("Unexpected error in acceptor. Sepuku.")
-                os._exit(4)
 
-    def _stop_acceptor(self, t, acceptor_gt, conn):
+            self.notify()
-        try:
+            
             try:
-                t.wait()
+                hubs.trampoline(self.socket.fileno(), read=True,
-            finally:
+                    timeout=self.timeout)
-                util.close(conn)
+            except eventlet.Timeout:
-        except greenlet.GreenletExit:
+                pass
-            pass
-        except Exception:
-            greenthread.kill(acceptor_gt, *sys.exc_info())
-        
-