def parseStreamServer(self, reactor, public_port, localPort=None,
                          controlPort=None, hiddenServiceDir=None):
        ''':api:`twisted.internet.interfaces.IStreamServerEndpointStringParser`'''

        public_port = int(public_port)

        if localPort is not None:
            localPort = int(localPort)

        hsd = hiddenServiceDir
        if hsd:
            orig = hsd
            hsd = os.path.expanduser(hsd)
            hsd = os.path.realpath(hsd)
            if orig != hsd:
                log.msg('Using "%s" for hsd' % hsd)

        if controlPort:
            try:
                ep = clientFromString(reactor, "tcp:host=127.0.0.1:port=%d" % int(controlPort))
            except ValueError:
                ep = clientFromString(reactor, "unix:path=%s" % controlPort)
            return TCPHiddenServiceEndpoint.system_tor(reactor, ep,
                                                       public_port,
                                                       hidden_service_dir=hsd,
                                                       local_port=localPort)

        return TCPHiddenServiceEndpoint.global_tor(reactor, public_port,
                                                   hidden_service_dir=hsd,
                                                   local_port=localPort,
                                                   control_port=controlPort)

def run_command(config):
    c = dispatch_table[config.subCommand]()
    tub = Tub()
    try:
        from twisted.internet import reactor
        from twisted.internet.endpoints import clientFromString
        from foolscap.connections import tor
        CONTROL = os.environ.get("FOOLSCAP_TOR_CONTROL_PORT", "")
        SOCKS = os.environ.get("FOOLSCAP_TOR_SOCKS_PORT", "")
        if CONTROL:
            h = tor.control_endpoint(clientFromString(reactor, CONTROL))
            tub.addConnectionHintHandler("tor", h)
        elif SOCKS:
            h = tor.socks_endpoint(clientFromString(reactor, SOCKS))
            tub.addConnectionHintHandler("tor", h)
        #else:
        #    h = tor.default_socks()
        #    tub.addConnectionHintHandler("tor", h)
    except ImportError:
        pass
    d = defer.succeed(None)
    d.addCallback(lambda _ign: tub.startService())
    d.addCallback(lambda _ign: tub.getReference(config.furl))
    d.addCallback(c.run, config.subOptions) # might provide tub here
    d.addBoth(lambda res: tub.stopService().addCallback(lambda _ign: res))
    return d

def get(host, path):
    f = protocol.ClientFactory()
    f.protocol = HTTPGETProtocol
    f.path = path
    f.host = host
    f.deferred = defer.Deferred()
    strport = "tcp:%s:80" % host
    endpoints.clientFromString(reactor, strport).connect(f)
    return f.deferred

def start():
    """ Client Entrypoint """
    endpoints.clientFromString(reactor, "tcp:localhost:1234").connect(PrintClientFactory())

    # gui = GameWindow()

    # gui_loop = task.LoopingCall(gui.update)
    # gui_loop.start(1.0)

    reactor.run()

    def test_parse_client_basic(self):
        from twisted.plugins import autobahn_endpoints

        self.assertTrue(hasattr(autobahn_endpoints, "AutobahnClientParser"))
        from twisted.internet.endpoints import clientFromString, quoteStringArgument
        from twisted.internet import reactor

        ep_string = "autobahn:{0}:url={1}".format(
            quoteStringArgument("tcp:localhost:9000"), quoteStringArgument("ws://localhost:9000")
        )
        # we're just testing that this doesn't fail entirely
        clientFromString(reactor, ep_string)

    async def _startup(reactor):
        if cfg.connect.startswith('tcp:') or cfg.connect.startswith('unix:'):
            ep = clientFromString(reactor, cfg.connect)
        else:
            if ':' in cfg.connect:
                ep = clientFromString(reactor, 'tcp:{}'.format(cfg.connect))
            else:
                ep = clientFromString(reactor, 'tcp:localhost:{}'.format(cfg.connect))
        tor = await txtorcon.connect(reactor, ep)

        if cfg.debug_protocol:

            click.echo("Low-level protocol debugging: ", nl=False)
            click.echo(click.style("data we write to Tor, ", fg='blue'), nl=False)
            click.echo(click.style("data from Tor", fg='yellow') + ".")

            def write_wrapper(data):
                tail = data
                while len(tail):
                    head, tail = tail.split('\r\n', 1)
                    click.echo(">>> " + click.style(head, fg='blue'), nl=False)
                click.echo()
                return orig_write(data)
            orig_write = tor.protocol.transport.write
            tor.protocol.transport.write = write_wrapper

            def read_wrapper(data):
                tail = data
                while '\r\n' in tail:
                    head, tail = tail.split('\r\n', 1)
                    if not read_wrapper.write_prefix:
                        click.echo(click.style(head, fg='yellow'))
                        read_wrapper.write_prefix = True
                    else:
                        click.echo("<<< " + click.style(head, fg='yellow'))
                if len(tail):
                    click.echo("<<< " + click.style(tail, fg='yellow'), nl=False)
                    read_wrapper.write_prefix = False
                else:
                    click.echo()
                return orig_read(data)
            read_wrapper.write_prefix = True
            orig_read = tor.protocol.dataReceived
            tor.protocol.dataReceived = read_wrapper


        if cfg.info:
            info = await tor.protocol.get_info('version', 'status/version/current', 'dormant')
            click.echo(
                'Connected to a Tor version "{version}" (status: '
                '{status/version/current}).\n'.format(**info)
            )
        await cmd(reactor, cfg, tor, *args, **kwargs)

def connect(hostname, worker=None, on_connect=None):
    """
    Connect to server using GrideaProtocol, automatically retry if it is
    not yet running.

    :param hostname: `hostname:port` to connect to
    :param worker: optional gridea.GrideaWorker() to make this process a worker
    :param on_connect: optional callback after connection
    """
    class ClientFactory(ReconnectingClientFactory):
        def buildProtocol(self, addr):
            return GrideaProtocol(worker, on_connect)
    clientFromString(reactor, 'tcp:' + hostname).connect(ClientFactory())

 def _build_endpoint(cls, endpoint_string=None, encrypted=True, timeout=5, host=None, reactor=None):
     if not reactor:
         from twisted.internet import reactor
     host = host or cls.host
     if endpoint_string:
         endpoint = clientFromString(reactor, endpoint_string)
     else:
         if encrypted:
             port = 443
             proto = 'ssl'
         else:
             port = 80
             proto = 'tcp'
         endpoint = clientFromString(reactor, '{0}:host={1}:port={2}:timeout={3}'.format(proto, host, port, timeout))
     return endpoint

    def test_system_tor(self):
        from test_torconfig import FakeControlProtocol

        def boom(*args):
            # why does the new_callable thing need a callable that
            # returns a callable? Feels like I must be doing something
            # wrong somewhere...
            def bam(*args, **kw):
                return self.protocol
            return bam
        with patch('txtorcon.endpoints.launch_tor') as launch_mock:
            with patch('txtorcon.endpoints.build_tor_connection', new_callable=boom) as btc:
                client = clientFromString(
                    self.reactor,
                    "tcp:host=localhost:port=9050"
                )
                ep = yield TCPHiddenServiceEndpoint.system_tor(self.reactor,
                                                               client, 80)
                port = yield ep.listen(NoOpProtocolFactory())
                toa = port.getHost()
                self.assertTrue(hasattr(toa, 'onion_uri'))
                self.assertTrue(hasattr(toa, 'onion_port'))
                port.startListening()
                str(port)
                port.tor_config
                # system_tor should be connecting to a running one,
                # *not* launching a new one.
                self.assertFalse(launch_mock.called)

    def _make_i2p_handler(self):
        enabled = self.get_config("i2p", "enabled", True, boolean=True)
        if not enabled:
            return None
        i2p = _import_i2p()
        if not i2p:
            return None

        samport = self.get_config("i2p", "sam.port", None)
        launch = self.get_config("i2p", "launch", False, boolean=True)
        configdir = self.get_config("i2p", "i2p.configdir", None)

        if samport:
            if launch:
                raise ValueError("tahoe.cfg [i2p] must not set both "
                                 "sam.port and launch")
            ep = endpoints.clientFromString(reactor, samport)
            return i2p.sam_endpoint(ep)

        if launch:
            executable = self.get_config("i2p", "i2p.executable", None)
            return i2p.launch(i2p_configdir=configdir, i2p_binary=executable)

        if configdir:
            return i2p.local_i2p(configdir)

        return i2p.default(reactor)

 def connectionMade(self):
     # print("EndpointForwardingProtocol.connectionMade")
     self._destFactory = DestEndpointForwardingFactory(self)
     self._destEndpoint = clientFromString(
         self.factory.service._reactor, self.factory.service._destEndpointDescriptor
     )
     self._destEndpointPort = yield self._destEndpoint.connect(self._destFactory)

def makeService(config):
    s = MultiService()


    # ZipkinTracer(
    #     scribe_client,
    #     category=None,
    #     end_annotations=None,
    #     max_traces=50,
    #     max_idle_time=10,
    #     _reactor=None)
    push_tracer(
        ZipkinTracer(
            ScribeClient(clientFromString(reactor, config['scribe'])), 'zipkin', None, 10, 10, None))

    root = RootResource()

    # if config['rproxy']:
    #     root = RProxyWrapper(root)

    site = server.Site(root)
    site.displayTracebacks = False

    api_service = strports.service(config['port'], site)
    api_service.setServiceParent(s)

    return s

def main(reactor, procName, *args):
    clientEndpoints = {}
    for k, v in os.environ.iteritems():
        _, _, clientName = k.partition('client_endpoint_')
        if clientName:
            clientEndpoints[clientName] = clientFromString(reactor, v)
    if not clientEndpoints:
        raise ValueError("no client endpoints detected in the environment")

    plugins = [pluginClass(clientEndpoints)
               for pluginClass in sorted(pluginClasses, key=nameLength, reverse=True)]

    if args == ('suggest',):
        suggestions = []
        for plugin in plugins:
            suggestions.extend(plugin.name + arg for arg in plugin.suggest())
        print '\n'.join(suggestions)
        return defer.succeed(None)

    procName = os.path.basename(procName)
    for plugin in plugins:
        _, foundPluginName, arg = procName.partition(plugin.name)
        if not foundPluginName:
            continue
        command = 'fetch' if not args else args[0]
        method = getattr(plugin, 'command_' + command, None)
        if not method:
            raise ValueError("%r plugin can't handle the command %r" % (plugin.name, command))
        return defer.maybeDeferred(method, arg)

    raise ValueError("no plugin was found with the name %r" % (procName,))

    def test_startServer(self):
        """
        Should call twisted.internet.endpoints.serverFromString and hook that
        up to the factory
        """
        h = Hub()
        h.remote_echo = lambda x: x
        h.startServer(h.getPBServerFactory(), 'tcp:10999')
        
        # connect to it
        self.clientPort = None
        client = clientFromString(reactor, 'tcp:host=127.0.0.1:port=10999')
        factory = pb.PBClientFactory()
        d = client.connect(factory)
        
        def saveClient(clientPort):
            self.clientPort = clientPort

        d.addCallback(saveClient)
        d.addCallback(lambda ign: factory.getRootObject())
        d.addCallback(lambda obj: obj.callRemote('echo', 'foo'))
        d.addCallback(lambda res: self.assertEqual(res, 'foo'))
        d.addCallback(lambda ign: self.clientPort.transport.loseConnection())
        d.addCallback(lambda ign: h.stopServer('tcp:10999'))
        return d

 def _connect_to_daemon(self):
     """Connect to the daemon so that we can receive events."""
     description = 'unix:path=%s' % DAEMON_SOCKET
     client = endpoints.clientFromString(reactor, description)
     self._protocol = yield client.connect(self._factory)
     # add the user with no paths
     yield self._protocol.add_user([])

def generateDestination(reactor, keyfile, api=None, apiEndpoint=None):
    """Generate a new I2P Destination.

    The function returns a :class:`twisted.internet.defer.Deferred`; register
    callbacks to receive the return value or errors.

    Args:
        reactor: The API endpoint will be constructed with this reactor.
        keyfile (str): Path to a local file where the keypair for the new
            Destination should be stored.
        api (str): The API to use.
        apiEndpoint (str): An endpoint string that will connect to the API.
            Alternatively, the caller can directly provide an
            :class:`twisted.internet.interfaces.IStreamClientEndpoint`, and the
            ``reactor`` will be ignored.

    Returns:
        txi2p.I2PAddress: The new Destination. Once this is received via the
        Deferred callback, the ``keyfile`` will have been written.

    Raises:
        ValueError: if the API doesn't support this method.
        ValueError: if the ``keyfile`` already exists.
        IOError: if the ``keyfile`` write fails.
    """
    api, apiEndpoint = getApi(api, apiEndpoint, _apiGenerators)
    if isinstance(apiEndpoint, str):
        apiEndpoint = clientFromString(reactor, apiEndpoint)
    return _apiGenerators[api](keyfile, apiEndpoint)

 def test_socks_endpoint_real(self):
     tor_socks_endpoint = clientFromString(reactor, "tcp:socks_host:100")
     h = tor.socks_endpoint(tor_socks_endpoint)
     res = yield h.hint_to_endpoint("tcp:example.com:1234", reactor)
     ep, host = res
     self.assertIsInstance(ep, txtorcon.endpoints.TorClientEndpoint)
     self.assertEqual(host, "example.com")

    def connect(self, terminal=None, on_error=None):
        connection_string = "tcp:host={host}:port={port}".format(
            host=self.options["host"],
            port=self.options["port"]
        )

        log.msg("Connecting with connection string %s" % connection_string)

        # TODO: add port forwarding here
        ssh_connection = SSHConnection(self, terminal)

        # TODO: verify host keys
        vhk = lambda *a: defer.succeed(1)

        # Build a basic auth client. There's a Twisted implementation
        # for this, but we need something simpler that does not access
        # keys that are stored on the disk
        uao = AuthClient(self.options, ssh_connection)

        d = defer.Deferred()
        factory = direct.SSHClientFactory(d, self.options, vhk, uao)
        if on_error:
            d.addErrback(on_error)

        endpoint = endpoints.clientFromString(reactor, connection_string)

        wp = None

        try:
            wp = yield endpoint.connect(factory)
        except Exception:
            terminal.leave()

        defer.returnValue(wp)

    def _connect(self, reactor, update_status):
        # create a new Tor
        config = self.config = txtorcon.TorConfig()
        if self._data_directory:
            # The default is for launch_tor to create a tempdir itself, and
            # delete it when done. We only need to set a DataDirectory if we
            # want it to be persistent. This saves some startup time, because
            # we cache the descriptors from last time. On one of my hosts,
            # this reduces connect from 20s to 15s.
            if not os.path.exists(self._data_directory):
                # tor will mkdir this, but txtorcon wants to chdir to it
                # before spawning the tor process, so (for now) we need to
                # mkdir it ourselves. TODO: txtorcon should take
                # responsibility for this.
                os.mkdir(self._data_directory)
            config.DataDirectory = self._data_directory

        #config.ControlPort = allocate_tcp_port() # defaults to 9052
        config.SocksPort = allocate_tcp_port()
        socks_desc = "tcp:127.0.0.1:%d" % config.SocksPort
        self._socks_desc = socks_desc # stash for tests
        socks_endpoint = clientFromString(reactor, socks_desc)

        with add_context(update_status, "launching Tor"):
            tpp = yield txtorcon.launch_tor(config, reactor,
                                            tor_binary=self._tor_binary)
        #print "launched"
        # gives a TorProcessProtocol with .tor_protocol
        self._tor_protocol = tpp.tor_protocol
        returnValue(socks_endpoint)

    def test_basic(self):
        ep = clientFromString(reactor, self.transit)
        a1 = yield connectProtocol(ep, Accumulator())
        a2 = yield connectProtocol(ep, Accumulator())

        token1 = b"\x00"*32
        a1.transport.write(b"please relay " + hexlify(token1) + b"\n")
        a2.transport.write(b"please relay " + hexlify(token1) + b"\n")

        # a correct handshake yields an ack, after which we can send
        exp = b"ok\n"
        yield a1.waitForBytes(len(exp))
        self.assertEqual(a1.data, exp)
        s1 = b"data1"
        a1.transport.write(s1)

        exp = b"ok\n"
        yield a2.waitForBytes(len(exp))
        self.assertEqual(a2.data, exp)

        # all data they sent after the handshake should be given to us
        exp = b"ok\n"+s1
        yield a2.waitForBytes(len(exp))
        self.assertEqual(a2.data, exp)

        a1.transport.loseConnection()
        a2.transport.loseConnection()