paramiko and stackless

[Linnorm]

I've written a port forwarding wrapper with paramiko for an app we use
and it works fine except that it consumes way too much processor.
(i.e. 25% +)  I'm trying to write a stackless-based server class to
replace the threading one but I can't get the tunnel the wrapper
creates to work for more than one instance of the app.  I based my
code on the example HTTP server on the stackless site.  Relevant code
follows.  The glovia variable is the result of subprocess.Popen().

<pre>
class ForwardServer (SocketServer.TCPServer):
    allow_reuse_address = True
    def __init__(self, *args, **kwargs):
        SocketServer.TCPServer.__init__(self, *args, **kwargs)
        self.socket.setblocking(0)

    def serve_forever(self, glovia):
        while glovia.poll() is None:
            verbose("Handle request")
            self.handle_request()

    def handle_request(self):
        try:
            request, client_address = self.get_request()
        except socket.error:
            return
        verbose("Adding handler tasklet")
        stackless.tasklet(self.handle_request_tasklet)(request,
client_address)

    def handle_request_tasklet(self, request, client_address):
        if self.verify_request(request, client_address):
            try:
                self.process_request(request, client_address)
            except:
                self.handle_error(request, client_address)
                self.close_request(request)


class Handler (SocketServer.BaseRequestHandler):
    def handle(self):
        verbose("Entering Handler.handle")
        peername = self.request.getpeername()
        try:
            chan = self.ssh_transport.open_channel('direct-tcpip',
                                                   (self.chain_host,
self.chain_port), peername)
        except Exception, e:
            verbose('Incoming request to %s:%d failed: %s' %
(self.chain_host, self.chain_port, repr(e)))
            return
        if chan is None:
            verbose('Incoming request to %s:%d was rejected by the SSH
server.' % (self.chain_host, self.chain_port))
            return

        verbose('Connected!  Tunnel open %r -> %r -> %r' % (peername,
 
chan.getpeername(), (self.chain_host, self.chain_port)))
        while True:
            r, w, x = select.select([self.request, chan], [], [])
            if self.request in r:
                data = self.request.recv(1024)
                if len(data) == 0:
                    break
                chan.send(data)
            if chan in r:
                data = chan.recv(1024)
                if len(data) == 0:
                    break
                self.request.send(data)
            verbose("Current Task: %s" %
(str(stackless.getcurrent()),))
            verbose("Scheduling Tasks: %s" %
(str(stackless.getruncount()),))
            stackless.schedule()
        chan.close()
        self.request.close()
        verbose("Exiting Handler.handle")
        verbose('Tunnel closed from %r' % (peername,))


def forward_tunnel(glovia, local_port, remote_host, remote_port,
transport):
    class SubHandler (Handler):
        chain_host = remote_host
        chain_port = remote_port
        ssh_transport = transport
    ForwardServer(('', local_port), SubHandler).serve_forever(glovia)

stackless.tasklet(forward_tunnel)(glovia, LOCAL_PORT, HOST,
REMOTE_PORT, client.get_transport())
stackless.run()
</pre>