code: def connect(self):
          
          # Prefer incoming connections over outgoing connections.
          if self.connections:
              # First value is an incoming connection
              future = gen.Future()
              future.set_result(self.connections[0])
              return future
  
          if self._connecting:
              # If we're in the process of connecting to the peer, just wait
              # and re-use that connection.
              return self._connecting
  
          conn_future = self._connecting = self.connection_class.outgoing(
              hostport=self.hostport,
              process_name=self.tchannel.process_name,
              serve_hostport=self.tchannel.hostport,
              handler=self.tchannel.receive_call,
              tchannel=self.tchannel,
          )
  
          def on_connect(_):
              if not conn_future.exception():
                  # We don't actually need to handle the exception. That's on
                  # the caller.
                  connection = conn_future.result()
                  self.register_outgoing_conn(connection)
              self._connecting = None
  
          conn_future.add_done_callback(on_connect)
          return conn_future
docs: Get a connection to this peer.
  
          If an connection to the peer already exists (either incoming or
          outgoing), that's returned. Otherwise, a new outgoing connection to
          this peer is created.
  
          :return:
              A future containing a connection to this host.