class SocketGateway(InstallableGateway):

def __init__(self, host, port):

    """ instantiate a gateway to a process accessed

            via a host/port specified socket. 

        """

    self.host = host = str(host)

    self.port = port = int(port)

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    sock.connect((host, port))

    io = inputoutput.SocketIO(sock)

    super(SocketGateway, self).__init__(io=io)

    self.remoteaddress = '%s:%d' % (self.host, self.port)

def exit(self):

    """ Try to stop all exec and IO activity. """

    self._cleanup.unregister(self)

    self._stopexec()

    self._stopsend()

def join(self, joinexec=True):

    """ Wait for all IO (and by default all execution activity) 

            to stop. the joinexec parameter is obsolete. 

        """

    current = threading.currentThread()

    if self._receiverthread.isAlive():

        self._trace("joining receiver thread")

        self._receiverthread.join()

def new_remote(cls, gateway, hostport=None): 

    """ return a new (connected) socket gateway, instatiated

            indirectly through the given 'gateway'. 

        """ 

    if hostport is None: 

        host, port = ('', 0)  # XXX works on all platforms? 

    else:   

        host, port = hostport 

    socketserverbootstrap = py.code.Source(

        mypath.dirpath('script', 'socketserver.py').read('rU'), """

            import socket

            sock = bind_and_listen((%r, %r)) 

            port = sock.getsockname()

            channel.send(port) 

            startserver(sock)

            """ % (host, port)

    ) 

    # execute the above socketserverbootstrap on the other side

    channel = gateway.remote_exec(socketserverbootstrap)

    (realhost, realport) = channel.receive()

    #gateway._trace("new_remote received" 

    #               "port=%r, hostname = %r" %(realport, hostname))

    return py.execnet.SocketGateway(host, realport) 

def newchannel(self): 

    """ return new channel object.  """ 

    return self._channelfactory.new()

def remote_exec(self, source, stdout=None, stderr=None): 

    """ return channel object and connect it to a remote

            execution thread where the given 'source' executes

            and has the sister 'channel' object in its global 

            namespace.  The callback functions 'stdout' and 

            'stderr' get called on receival of remote 

            stdout/stderr output strings. 

        """

    try:

        source = str(Source(source))

    except NameError: 

        try: 

            import py 

            source = str(py.code.Source(source))

        except ImportError: 

            pass 

    channel = self.newchannel() 

    outid = self._newredirectchannelid(stdout) 

    errid = self._newredirectchannelid(stderr) 

    self._send(Message.CHANNEL_OPEN(

                channel.id, (source, outid, errid)))

    return channel 

def remote_init_threads(self, num=None):

    """ start up to 'num' threads for subsequent 

            remote_exec() invocations to allow concurrent

            execution. 

        """

    if hasattr(self, '_remotechannelthread'):

        raise IOError("remote threads already running")

    from py.__.thread import pool

    source = py.code.Source(pool, """

            execpool = WorkerPool(maxthreads=%r)

            gw = channel.gateway

            while 1:

                task = gw._requestqueue.get()

                if task is None:

                    gw._stopsend()

                    execpool.shutdown()

                    execpool.join()

                    raise gw._StopExecLoop

                execpool.dispatch(gw._executetask, task)

        """ % num)

    self._remotechannelthread = self.remote_exec(source)

def __repr__(self):

    """ return string representing gateway type and status. """

    addr = self.remoteaddress 

    if addr:

        addr = '[%s]' % (addr,)

    else:

        addr = ''

    try:

        r = (self._receiverthread.isAlive() and "receiving" or 

             "not receiving")

        s = "sending" # XXX

        i = len(self._channelfactory.channels())

    except AttributeError:

        r = s = "uninitialized"

        i = "no"

    return "<%s%s %s/%s (%s active channels)>" %(

            self.__class__.__name__, addr, r, s, i)