docs: def connect(self, From, to,
                  protocolName, clientFactory,
                  chooser):
          """
          Issue an INBOUND command, creating a virtual connection to the peer,
          given identifying information about the endpoint to connect to, and a
          protocol factory.
  
          @param clientFactory: a *Client* ProtocolFactory instance which will
          generate a protocol upon connect.
  
          @return: a Deferred which fires with the protocol instance that was
          connected, or fails with AttemptsFailed if the connection was not
          possible.
          """
  
          publicIP = self._determinePublicIP()
  
          A = dict(From=From,
                   to=to,
                   protocol=protocolName)
  
          if self.service.dispatcher is not None:
              # Tell them exactly where they can shove it
              A['udp_source'] = (publicIP,
                                 self.service.sharedUDPPortnum)
          else:
              # Don't tell them because we don't know
              log.msg("dispatcher unavailable when connecting")
  
          D = self.callRemote(Inbound, **A)
  
          def _connected(answer):
              listenersD = defer.maybeDeferred(chooser, answer['listeners'])
              def gotListeners(listeners):
                  allConnectionAttempts = []
                  for listener in listeners:
                      d = self.attemptConnectionMethods(
                          listener['methods'],
                          listener['id'],
                          From, to,
                          protocolName, clientFactory,
                          )
                      allConnectionAttempts.append(d)
                  return defer.DeferredList(allConnectionAttempts)
              listenersD.addCallback(gotListeners)
              def finishedAllAttempts(results):
                  succeededAny = False
                  failures = []
                  if not results:
                      return Failure(NoAttemptsMade(
                              "there was no available path for connections "
                              "(%r->%r/%s)" % (From, to, protocolName)))
                  for succeeded, result in results:
                      if succeeded:
                          succeededAny = True
                          randomConnection = result
                          break
                      else:
                          failures.append(result)
                  if not succeededAny:
                      return Failure(
                          AttemptsFailed(
                              [failure.getBriefTraceback()
                              for failure in failures]
                          )
                      )
  
                  # XXX TODO: this connection is really random; connectQ2Q should
                  # not return one of the connections it's made, put it into your
                  # protocol's connectionMade handler
  
                  return randomConnection
  
              return listenersD.addCallback(finishedAllAttempts)
          return D.addCallback(_connected)