def doMath(): destination = TCP4ClientEndpoint(reactor, "127.0.0.1", 1234) sumDeferred = connectProtocol(destination, AMP()) def connected(ampProto): return ampProto.callRemote(Sum, a=13, b=81) sumDeferred.addCallback(connected) def summed(result): return result["total"] sumDeferred.addCallback(summed) divideDeferred = connectProtocol(destination, AMP()) def connected(ampProto): return ampProto.callRemote(Divide, numerator=1234, denominator=0) divideDeferred.addCallback(connected) def trapZero(result): result.trap(ZeroDivisionError) print "Divided by zero: returning INF" return 1e1000 divideDeferred.addErrback(trapZero) def done(result): print "Done with math:", result reactor.stop() defer.DeferredList([sumDeferred, divideDeferred]).addCallback(done)
def range_check(self, firstbyte, lastbyte, setset=False): test_deferred = Deferred() self._logger.debug("range_test: %s %s %s setset %s", firstbyte, lastbyte, self.sourcesize, setset) if firstbyte is not None and lastbyte is None: exp_byte_range = (firstbyte, self.sourcesize - 1) elif firstbyte is None and lastbyte is not None: exp_byte_range = (self.sourcesize - lastbyte, self.sourcesize - 1) else: exp_byte_range = (firstbyte, lastbyte) # the amount of bytes actually requested. (Content-length) self.expsize = exp_byte_range[1] - exp_byte_range[0] + 1 f = open(self.sourcefn, "rb") f.seek(exp_byte_range[0]) expdata = f.read(self.expsize) f.close() def on_connected(p): p.sendMessage(self.get_header(firstbyte, lastbyte, setset)) endpoint = TCP4ClientEndpoint(reactor, "localhost", self.port) connectProtocol(endpoint, VideoServerProtocol(test_deferred, self.sourcesize, expdata, setset, exp_byte_range))\ .addCallback(on_connected) return test_deferred
def process(self): parsed = urllib_parse.urlparse(self.uri) protocol = parsed[0] host = parsed[1].decode('ascii') if protocol in self.ports: port = self.ports[protocol] else: # handle pass if ':' in host: host, port = host.split(':') port = int(port) rest = urllib_parse.urlunparse((b'', b'') + parsed[2:]) if not rest: rest = rest + b'/' if protocol in self.protocols: factory = self.protocols[protocol] headers = self.getAllHeaders().copy() if b'host' not in headers: headers[b'host'] = host.encode('ascii') headers.pop(b'user-agent', None) headers[b'user-agent'] = b'I2P' self.content.seek(0, 0) s = self.content.read() client = factory(self.method, rest, self.clientproto, headers, s, self) ep = self.endpointFactory(host, port) connectProtocol(ep, client.buildProtocol(ep))
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()
def on_deploy_start(self): now = int(time.time()) events = ("events.deploy.%s %d %d\r\n" % (component, 1, now) for component in self.components) message = "".join(events) protocol = OneShotMessageWriter(message) endpoint = endpoints.clientFromString(reactor, self.endpoint_config) endpoints.connectProtocol(endpoint, protocol)
def start_client(proto): client_endpoint = TCP4ClientEndpoint(reactor, 'localhost', 1234) nickname = 'PyClient' + str(random.getrandbits(23)) factory = PyClientProtocolFactory(nickname) proto = factory.buildProtocol(('localhost', 0)) connectProtocol(client_endpoint, proto) d = Deferred() reactor.callLater(4, d.callback, proto) d.addCallback(test_state) return d
def connectionMade(self): script_dir = os.getcwd() rel_path = "hostkeys" abs_file_path = os.path.join(script_dir, rel_path) knownHosts = KnownHostsFile.fromPath(abs_file_path) self.point = SSHCommandClientEndpoint.newConnection(reactor, 'cmd', 'user', '127.0.0.1', port=5122, password='******', knownHosts=PermissiveKnownHosts()) self.sshSide = FzSSHClient() self.sshSide.tcpSide = self connectProtocol(self.point, self.sshSide)
def perform_run(dispatcher, intent): context.bind( message_type="flocker.provision.ssh:run", command=intent.log_command_filter(intent.command), ).write() endpoint = SSHCommandClientEndpoint.existingConnection( connection, intent.command) d = Deferred() connectProtocol(endpoint, CommandProtocol( deferred=d, context=context)) return d
def onEvent(self, ev): if ev.getName() == YowNetworkLayer.EVENT_STATE_CONNECT: # self.create_socket(socket.AF_INET, socket.SOCK_STREAM) # self.out_buffer = bytearray() endpoint = self.getProp(YowNetworkLayer.PROP_ENDPOINT) point = TCP4ClientEndpoint(reactor, endpoint[0], endpoint[1]) connectProtocol(point, self) # self.connect(endpoint) return True elif ev.getName() == YowNetworkLayer.EVENT_STATE_DISCONNECT: self.handle_close(ev.getArg("reason") or "Requested") return True
def run(messagehandler): options = optionsForClientTLS( hostname=AUTHORITY, acceptableProtocols=[b'h2', b'http/1.1'], ) connectProtocol( SSL4ClientEndpoint(reactor, AUTHORITY, 443, options), H2Protocol(messagehandler) ) reactor.run(installSignalHandlers=0)
def _connectServer(self, hostname, port, server_queue, client_queue): """A helper function for connecting to (hostname, port) with the given server and client queues. :param str hostname: :param int port: :param DeferredQueue server_queue: :param DeferredQueue client_queue: """ endpoint = TCP4ClientEndpoint(reactor, hostname, port) protocol = ServerProtocol( server_queue, client_queue) connectProtocol(endpoint, protocol)
def connectServer(self, hostname, port): """Tell the proxy what the end server is and start the connection. The messages in `self.client_queue` will automatically be consumed. This method should only be called once. :param str hostname: :param int port: """ endpoint = TCP4ClientEndpoint(reactor, hostname, port) protocol = ServerProtocol( self.server_queue, self.client_queue) connectProtocol(endpoint, protocol)
def main(reactor=reactor): arguments = vars(parser.parse_args()) endpoint = clientFromString( reactor=reactor, description=arguments["endpoint"], ) lines = iter(replay_file(arguments["queries"])) client = BenchmarkClient() client.lineiterator = lines connectProtocol(endpoint, client).addCallback( lambda protocol : protocol.sendLine(lines.next()), ) reactor.run()
def zkconnected(z, reactor): val, meta = yield z.get('/brokers/topics/test/partitions/0/state') broker = json.loads(val)['isr'][0] val, meta = yield z.get('/brokers/ids/%d' % (broker, )) val = json.loads(val) host, port = val['host'], val['port'] ep = TCP4ClientEndpoint(reactor, host, port) proto = KafkaClientProtocol() yield connectProtocol(ep, proto) brokers, topics = yield proto.sender.metadataRequest(topicNames=['test']) log.debug('Brokers: {brokers!r}', brokers=brokers) test_zero_md = topics['test'][0] leader, replicas, isr = test_zero_md r = yield proto.sender.fetchRequest(replicaId=-1, maxWaitTime=10, minBytes=0, topics=[ ('test', [(0, 0, 65535)]) ]) r = yield proto.sender.produceRequest(1, 1000, [ ('test', [ (0, [ (3, Message(value='message 4')) ]) ]) ])
def send(m): point = TCP4ClientEndpoint(reactor, "localhost", 1234) g = Greeter() g.message = m d = connectProtocol(point,g) d.addCallback(gotProtocol) reactor.run()
def makeConnection(ip, port, connectCallback): connection = Connection() connection.callback = connectCallback point = TCP4ClientEndpoint(reactor, ip, port) d = connectProtocol(point, connection) thread.start_new_thread(startConnection, ()) return connection
def main(reactor, args): vhost = args.vhost user = args.user passwd_file = args.passwd_file if passwd_file is None: passwd = 'guest' else: passwd = passwd_file.read().rstrip("\n\r") passwd_file.close() spec_path = os.path.join( os.path.dirname(__file__), 'spec/amqp0-9-1.stripped.xml') spec = txamqp.spec.load(spec_path) params = { 'creds': (user, passwd), 'exchange': args.exchange, 'content': args.msg_file.read(), 'route_key': args.route_key, } endpoint_s = args.endpoint e = clientFromString(reactor, endpoint_s) delegate = TwistedDelegate() amqp_protocol = AMQClient( delegate=delegate, vhost=vhost, spec=spec) d = connectProtocol(e, amqp_protocol) d.addCallback(on_amqp_connect, params) return d
def greylistCommand(command, port='unix:/var/run/greylistd/socket', reactor=None): if not reactor: from twisted.internet import reactor deferred = Deferred() d = connectProtocol(clientFromString(reactor, port), _GreylistProtocol(deferred, command)) d.addErrback(deferred.errback) return deferred
def run(reactor, command, **kwargs): """ Run a process and kill it if the reactor stops. :param reactor: Reactor to use. :param list command: The command to run. :return Deferred: Deferred that fires when the process is ended. """ if 'env' not in kwargs: kwargs['env'] = os.environ endpoint = ProcessEndpoint(reactor, command[0], command, **kwargs) protocol_done = Deferred() protocol = CommandProtocol(deferred=protocol_done, output=sys.stdout) connected = connectProtocol(endpoint, protocol) def unregister_killer(result, trigger_id): try: reactor.removeSystemEventTrigger(trigger_id) except: # If we can't remove the trigger, presumably it has already been # removed (or run). In any case, there is nothing sensible to do # if this fails. pass return result def register_killer(_): trigger_id = reactor.addSystemEventTrigger( 'before', 'shutdown', protocol.transport.signalProcess, 'TERM') protocol_done.addBoth(unregister_killer, trigger_id) connected.addCallback(register_killer) connected.addCallback(lambda _: protocol_done) return connected
def main(reactor, args): endpoint_str = args.endpoint e = clientFromString(reactor, endpoint_str) d = connectProtocol(e, LDAPClient()) d.addCallback(onConnect, args) d.addErrback(onError) return d
def connect(self): """Connect client.""" if self.number < self.req_num: # pre-add the available connection count # will be decremented if failure occurs self.number += 1 connector = ClientConnector(self) # connect through Tor if required, direct connection otherwise if self.socksproxy: proxy = random.choice(self.socksproxy) # Further settings and check socks_point = TCP4ClientEndpoint(reactor, proxy[0], proxy[1]) point = SOCKS5Point(self.host, self.port, socks_point) elif self.obfs_level == 3: meek_point = TCP4ClientEndpoint( reactor, "127.0.0.1", self.ptproxy_local_port) point = SOCKS4Point(self.host, self.port, meek_point) else: point = TCP4ClientEndpoint(reactor, self.host, self.port) deferred = connectProtocol(point, connector) # trigger success or failure action depending on the result deferred.addCallback(self.success) deferred.addErrback(lambda ignored: self.retry())
def _handshake(self, credential): """ Run a TLS handshake between a client and server, one of which is using the validation logic and the other the given credential. :param credential: The high-level credential to use. :return ``Deferred``: Fires when handshake succeeded or failed. """ peer_context_factory = PeerContextFactory(credential.credential) port = find_free_port()[1] validating_context_factory = context_factory_fixture( port, self.good_ca) if validator_is_client: client_context_factory = validating_context_factory server_context_factory = peer_context_factory else: server_context_factory = validating_context_factory client_context_factory = peer_context_factory result = start_tls_server(self, port, server_context_factory) validating_endpoint = SSL4ClientEndpoint( reactor, "127.0.0.1", port, client_context_factory) client_protocol = ReceivingProtocol() result.addCallback(lambda _: connectProtocol(validating_endpoint, client_protocol)) result.addCallback(lambda _: client_protocol.result) return result
def connect(self, endpoint): if self.client: raise RuntimeError("Already connected to %s" % (self.client,)) if self._connecting: raise RuntimeError("Connection already in progress.") self._connecting = connectProtocol(endpoint, self._protocolClass()) self._connecting.addCallbacks(self._setClient, self._connectFailed)
def __init__(self,backend_port): self.send_queue = defer.DeferredQueue() self.backend_point = TCP4ClientEndpoint(reactor, "localhost", backend_port) self.backend = MetricLineProtocol() self.backend_defer = connectProtocol(self.backend_point,self.backend) self.backend_defer.addCallback(self.backendConnectionMade)
def connectionMade(self): print 'got connection from %s' % (self.addr, ) print 'connecting to %s:%d' % (self.host, self.port) point = TCP4ClientEndpoint(reactor, self.host, self.port) self.client = XMPPClient(self, self.domain, self.cert_file, self.pkey_file) d = connectProtocol(point, self.client) d.addCallback(self._connected)
def main(reactor): endpoint_str = "tcp:host=127.0.0.1:port=8080" e = clientFromString(reactor, endpoint_str) d = connectProtocol(e, LDAPClient()) d.addCallback(onConnect) d.addErrback(onError) return d
def main(reactor): log.startLogging(sys.stdout) endpoint_str = "tcp:host=localhost:port=8080" e = clientFromString(reactor, endpoint_str) d = connectProtocol(e, LDAPClient()) d.addCallback(onConnect) d.addErrback(onError, reactor) return d
def run_amp_command(description, command, args, reactor=None): if reactor is None: from twisted.internet import reactor endpoint = endpoints.clientFromString(reactor, description) amp = AMP() d = endpoints.connectProtocol(endpoint, amp) d.addCallback(lambda ign: amp.callRemote(command, **args)) return d
def main(): log.startLogging(stdout) log.msg("Connecting to the AMP server...") d = endpoints.connectProtocol(ampEndpoint, AMP()) d.addCallback(_connected) reactor.run()
def reconnector(self, onion): protocol = Protocol() protocol.onion = onion protocol.connectionLost = lambda failure: self.handleLostConnection(failure, onion) tor_endpoint = clientFromString(self.reactor, "tor:%s.onion:8060" % onion) self.onion_pending_map[onion] = connectProtocol(tor_endpoint, protocol) self.onion_pending_map[onion].addCallback(lambda protocol: self.connection_ready(onion, protocol)) self.onion_pending_map[onion].addErrback(lambda failure: self.connectFail(failure, onion))
def _get_protocol(self): # TODO: something smart to kickout bad servers and use ones with lower # pings if not self._endpoints: raise GRPCError('No servers configured') yield self._lock.acquire() if not self._protocol: self._protocol = yield endpoints.connectProtocol( self._endpoints[0], self.PROTOCOL_FACTORY( clock=self._reactor, authority='localhost:1234', stats=self._stats, ), ) self._lock.release() defer.returnValue(self._protocol)
def zfs_command(reactor, arguments): """Run the ``zfs`` command-line tool with the given arguments. :param reactor: A ``IReactorProcess`` provider. :param arguments: A ``list`` of ``bytes``, command-line arguments to ``zfs``. :return: A :class:`Deferred` firing with the bytes of the result (on exit code 0), or errbacking with :class:`CommandFailed` or :class:`BadArguments` depending on the exit code (1 or 2). """ endpoint = ProcessEndpoint(reactor, b"zfs", [b"zfs"] + arguments, os.environ) d = connectProtocol(endpoint, _AccumulatingProtocol()) d.addCallback(lambda protocol: protocol._result) return d
def connectionMade(self): hackedCommandHandler = CLIShell.CommandHandler( "hack", "Notify the C&C they've been hacked", self.__hack) self.registerCommand(hackedCommandHandler) networkSettings = PlaygroundNetworkSettings() networkSettings.configureNetworkStackFromPath("./ProtocolStack") networkSettings.requestSpecificAddress(self.hostaddr) playgroundEndpoint = GateClientEndpoint(reactor, self.peeraddr, 10001, networkSettings) self.__protocol = SimpleCommandAndControlProtocol() self.__protocol.factory = self self.__d = connectProtocol(playgroundEndpoint, self.__protocol) self.__d.addCallback(self.candcConnectionMade) self.deferToResponse = Deferred()
def connect(self, address, port, SessionType, establishedCallback=None, failureCallback=None, *args): print "Connecting to host {} : {}".format(address, port) from twisted.internet import reactor endpoint = TCP4ClientEndpoint(reactor, address, port) connection = SessionType.ConnectionStateType() d = connectProtocol(endpoint, connection) d.addCallback(Network.__connectionEstablished, SessionType, establishedCallback, *args) d.addErrback(Network.__connectionFailure, failureCallback, *args)
def start_client(self): self.log.info('start client') self.transport.pauseProducing() conf = ConfigManager().default proxy_host_port = conf.get('local', 'proxy_host_port') point = clientFromString(self.factory.reactor, f"tcp:{proxy_host_port}") d = connectProtocol(point, ProxyClient(self)) def error(failure): raise errors.HostUnreachable() d.addErrback(error) return d
def secureConnection(self): """ Create and return a new SSH connection which has been secured and on which authentication has already happened. @return: A L{Deferred} which fires with the ready-to-use connection or with a failure if something prevents the connection from being setup, secured, or authenticated. """ protocol = _CommandTransport(self) ready = protocol.connectionReady sshClient = TCP4ClientEndpoint(self.reactor, self.hostname, self.port) d = connectProtocol(sshClient, protocol) d.addCallback(lambda ignored: ready) return d
def connect_mqtt_tls( client_id, host, rootpath, port, client_creds=None, protocols=None, ): """Connect an MQTT Client over TLS without client auth. :param host: The hostname to connect :type host: str :param rootpath: Path to the root certificate :type rootpath: str :param port (optional): The port to use, default 8883 :type port: int :param client_creds: Client cert/key pair :type client_creds: ssl.PrivateCertificate :param protocols: List of protocols for use with ALPN :type protocols: List[bytes] """ with open(rootpath, 'rb') as rootf: rootblob = rootf.read() trust_root = ssl.trustRootFromCertificates( [ssl.Certificate.loadPEM(rootblob)]) tls_options = ssl.optionsForClientTLS(host, trustRoot=trust_root, clientCertificate=client_creds, acceptableProtocols=protocols) endpoint = endpoints.SSL4ClientEndpoint(reactor, host, port, tls_options) d = endpoints.connectProtocol(endpoint, MQTTClient(client_id)) def _socket_connected(client): return client.connect() d.addCallback(_socket_connected) return d
def ConnectToChaperone(cls, reactor, chaperoneDetails, playgroundAddress): if cls.__muxer: cls.__muxer.chaperone.connectionLost("Chaperone and/or Address Change") if cls.__muxer.chaperone.transport: cls.__muxer.chaperone.transport.loseConnection() if len(chaperoneDetails) == 2: addr, port = chaperoneDetails chaperoneEndpoint = TCP4ClientEndpoint(reactor, addr, int(port)) elif len(chaperoneDetails) == 1: chaperoneEndpoint = UNIXClientEndpoint(reactor, chaperoneDetails[0]) else: raise ValueError('expected (addr, port) or (socket,) tuple but got %s' % chaperoneDetails) cls.__muxer = BotMuxer(playgroundAddress) cls.__playgroundAddress = playgroundAddress return connectProtocol(chaperoneEndpoint, cls.__muxer.chaperone)
def new_proxy_conn(self, conn_id): """Create a connection to HTTP proxy corresponding to the given ID. Return a Deferred object of the proxy connector. """ logging.info("adding connection id " + conn_id) try: assert conn_id not in self.proxy_write_queues_dict self.proxy_write_queues_dict[conn_id] = dict() self.proxy_write_queues_index_dict[conn_id] = 100000 self.proxy_connectors_dict[conn_id] = ProxyConnector(self, conn_id) point, connector = self.proxy_point, self.proxy_connectors_dict[ conn_id] d = connectProtocol(point, connector) d.addCallback(lambda ignored: self.proxy_write(conn_id)) d.addErrback(lambda ignored: logging.error("cannot connect proxy")) except AssertionError: logging.error("duplicate id")
def test_binary_handshake(self): ep = clientFromString(reactor, self.transit) a1 = yield connectProtocol(ep, Accumulator()) binary_bad_handshake = b"\x00\x01\xe0\x0f\n\xff" # the embedded \n makes the server trigger early, before the full # expected handshake length has arrived. A non-wormhole client # writing non-ascii junk to the transit port used to trigger a # UnicodeDecodeError when it tried to coerce the incoming handshake # to unicode, due to the ("\n" in buf) check. This was fixed to use # (b"\n" in buf). This exercises the old failure. a1.transport.write(binary_bad_handshake) exp = b"bad handshake\n" yield a1.waitForBytes(len(exp)) self.assertEqual(a1.data, exp) a1.transport.loseConnection()
def SetupConnection(self, addr, endpoint=None): if len(self.Peers ) + self.peers_connecting < settings.CONNECTED_PEER_MAX: try: host, port = addr.split(':') if endpoint: point = endpoint else: point = TCP4ClientEndpoint(self.reactor, host, int(port), timeout=5) self.peers_connecting += 1 d = connectProtocol(point, NeoNode()) # type: Deferred d.addErrback(self.clientConnectionFailed, addr) return d except Exception as e: logger.error(f"Setup connection with with {e}")
def create_client(reactor, host, port): """ Start a Nats Protocol and connect it to a NATS endpoint over TCP4 which subscribes a subject with a callback that sends a response if it gets a reply_to. """ log.info("Start client.") point = TCP4ClientEndpoint(reactor, host, port) nats_protocol = txnats.io.NatsProtocol(verbose=False, on_connect=listen) # Because NatsProtocol implements the Protocol interface, Twisted's # connectProtocol knows how to connected to the endpoint. connecting = connectProtocol(point, nats_protocol) # Log if there is an error making the connection. connecting.addErrback(lambda np: log.info("{p}", p=np)) # Log what is returned by the connectProtocol. connecting.addCallback(lambda np: log.info("{p}", p=np)) return connecting
def requestSignOfToken(user_id, ballot_id, blind_token): destination_deferred = yield TCP4ClientEndpoint(reactor, accountverifier_ip, accountverifier_port) connection_deferred = yield connectProtocol(destination_deferred, AMP()) result_deferred = yield connection_deferred.callRemote( OnlineAccountVerifier_SignBlindToken, user_id=user_id, ballot_id=ballot_id, blind_token=blind_token) def format_results(pickled_result): signed_blind_token = pickle.loads(pickled_result['ok']) return signed_blind_token # Inlinecallback return value. returnValue(format_results(result_deferred))
def get_ldap_client(self): """ Returns a Deferred that fires with an asynchronous LDAP client. """ log = self.log log.debug( "{classname}: Entered `get_ldap_client()`. self.id == {instance_id}", classname=self.__class__.__name__, instance_id=id(self)) client = self.client_ if not client is None: self.clear_scheduled_unbind_() log.debug( "{classname}: Cleared scheduled UNBIND; returning existing LDAP client.", classname=self.__class__.__name__) returnValue(client) start_tls = self.start_tls endpoint_s = self.endpoint_s bind_dn = self.bind_dn bind_passwd = self.bind_passwd reactor = self.reactor ep = endpoints.clientFromString(reactor, endpoint_s) log.debug("LDAP endpoint: {endpoint}", endpoint=endpoint_s) client = yield endpoints.connectProtocol(ep, ldapclient.LDAPClient()) self.client_ = client log.debug("Client connection established to LDAP endpoint.") try: if start_tls: yield client.startTLS() log.debug("{classname}: LDAP client initiated StartTLS.", event_type='ldap_starttls', classname=self.__class__.__name__) if bind_dn and bind_passwd: yield client.bind(bind_dn, bind_passwd) log.debug("LDAP client BIND as '{bind_dn}'.", event_type='ldap_bind', bind_dn=bind_dn) except Exception: self.unbind_client_() raise self.clear_scheduled_unbind_() log.debug("'{classname}': Returning new LDAP client.", classname=self.__class__.__name__) returnValue(client)
def handle_addr(self, peers): if self.remote_nodeid is not None and self.conn_debug: reload_node_dict() print("{} EXTRACTING ADDR FROM {}".format( self.nodename, node_2_id_lookup[self.remote_nodeid])) if peers is not None: for remote_ip, remote_nodeid in peers: if ( remote_ip, remote_nodeid ) not in self.node.connected_servers and str( remote_nodeid ) != self.node.node_server_id and self.node.curr_outgoing_conns < self.node.MAX_OUTGOING_CONN: host, port = str(remote_ip).split(":") point = TCP4ClientEndpoint(reactor, str(host), int(port)) xpr = XpeerClientProtocol(None, self.node) self.node.xpeerprotocols.append(xpr) d = connectProtocol(point, xpr) d.addCallback(self.node.gotProtocol) self.node.curr_outgoing_conns += 1 self.node.Portal.update_connections_count( self.node.curr_outgoing_conns, self.node.curr_incoming_conns) elif self.node.curr_outgoing_conns >= self.node.MAX_OUTGOING_CONN: reload_node_dict() print("{} REACHED MAX OUTGOING CONNECTION.".format( self.nodename)) #after conn is complete send my server info to server i'm connected to so it can connect to my server finalize = json.dumps({ 'myserveraddr': [self.node.node_server_ip, self.node.node_server_id], 'myname': self.nodename, 'msgtype': 'finalize' }) self.transport.write(finalize + "\n") self.lc_ping.start(60 * 3) self.send_init_blockchain_request()
def handle_hello(self, data): self.remote_nodeid = data['data'] if self.remote_nodeid == self.nodeid: print("Connected to myself.") self.transport.loseConnection() else: host_ip = str(data['remote_ip']) self.lc_ping.start(60) self.send_addr() if host_ip not in self.factory.connection_list: self.factory.peers[self.remote_nodeid] = self self.factory.pair[self.remote_nodeid] = host_ip ip = host_ip.split(':')[0] port = host_ip.split(':')[1] self.factory.connection_list.add(host_ip) self.factory.host_list.add(host_ip) point = TCP4ClientEndpoint(reactor, ip, int(port)) d = connectProtocol(point, MyProtocol(factory)) d.addCallback(gotProtocol)
def main(): obj_hash = hash_broadcast_replicate() # endpoint = TCP4ServerEndpoint(reactor, 5999) # mcx = MyFactory()#peer1 initialization # endpoint.listen(mcx) PEER_LIST = [ "localhost:5999", "localhost:5998", "localhost:5997", "localhost:5996" ] #4 node p2p n/w hosted on local host having different ports for peer in PEER_LIST: endpoint = TCP4ServerEndpoint(reactor, 5999) mcx = MyFactory() # peers initialization endpoint.listen(mcx) host, port = peer.split(":") point = TCP4ClientEndpoint(reactor, host, int(port)) d = connectProtocol(point, MyProtocol(mcx, 2)) d.addCallback(gotProtocol) reactor.run()
def __listenerStarted(cls, result, reactor, gateAddr, gatePort, callbackPort, callbackProtocolFactory, point, connectD): gateKey = (gateAddr, gatePort) if cls.GATES.has_key(gateKey): cls.logger.info("Already connected.") cls.__controlConnected("Already Connected", callbackPort, cls.GATES[gateKey][1], callbackProtocolFactory, point, connectD) #d = Deferred() else: cls.logger.info("Starting outbound connection to gate.") gatePoint = TCP4ClientEndpoint(reactor, gateAddr, gatePort) gateProtocol = GateProtocol() cls.GATES[gateKey] = (gatePoint, gateProtocol) d = connectProtocol(gatePoint, gateProtocol) d.addCallback(cls.__controlConnected, callbackPort, gateProtocol, callbackProtocolFactory, point, connectD) d.addErrback(cls.__controlConnectFailed, gateKey, connectD)
def setUpClass(cls): assert (cls.channel) # set by client implementation # if channel.startswith("serial:"): # serial_device=channel[7:] # self.transport=SerialPort(RemoteTestProtocol(), serial_device, reactor) # logging.info("Connecting via {0} ...".format(serial_device)) if cls.channel.startswith("tcp:"): prefix, host, port = cls.channel.split(':') port = int(port) logging.info("Connecting via {0}:{1} ...".format(host, port)) cls.endpoint = TCP4ClientEndpoint(reactor, host, port) cls.protocol = None d = connectProtocol(cls.endpoint, RemoteTestClientProtocol()) d.addCallback(cls.gotProtocol) # start blocking reactor with event loop in separate thread Thread(target=reactor.run, args=(False, )).start()
def connect_to(self, ip, port): """This method connect to a node *'as a client'* [description] :param ip: id address :type ip: str :param port: port number :type port: int *@Override from ClientProtocol* """ def to_do(protocol): protocol.send_handshake() time.time(60) protocol.send_get_blockchain() connection_point = TCP4ClientEndpoint(reactor, ip, int(port)) d = connectProtocol(connection_point, P2Protocol(self.factory, node_type=2)) d.addCallback(to_do)
def sync_with_node(self, finalize): finalize = json.loads(finalize) sender_server_ip, sender_server_id = finalize["myserveraddr"] if self.node.curr_outgoing_conns < self.node.MAX_OUTGOING_CONN and ( sender_server_ip, sender_server_id) not in self.node.connected_servers: host, port = sender_server_ip.split(":") point = TCP4ClientEndpoint(reactor, str(host), int(port)) xpr = XpeerClientProtocol(None, self.node) self.node.xpeerprotocols.append(xpr) d = connectProtocol(point, xpr) d.addCallback(self.node.gotProtocol) self.node.curr_outgoing_conns += 1 self.node.Portal.update_connections_count( self.node.curr_outgoing_conns, self.node.curr_incoming_conns) elif self.node.curr_outgoing_conns >= self.node.MAX_OUTGOING_CONN: reload_node_dict() print("{} REACHED MAX OUTGOING CONNECTION.".format(self.nodename))
def trigger_session(src_range, dst_range, **kwargs): """ This function triggers a single session by creating an instance of the Trigger class and then calling the connectProtocol method on its deffered. It also adds an errBack so we can see if it fails in the logs.""" # Default arguements service_type = config.default_service_type bidirectional = config.default_bidirectional session_duration = config.default_session_duration traffic = config.default_traffic ditgoptarg = config.default_ditgoptarg # Generate a randomized IP if required src, dst = randomize_ip(src_range, dst_range) # Deal with any optionally supplied kwargs if kwargs.has_key('service_type'): service_type = kwargs['service_type'] if kwargs.has_key('session_duration'): session_duration = kwargs['session_duration'] if isinstance(session_duration, list): sd = random.randint(session_duration[0], session_duration[1]) print "SD = %d" % sd session_duration = float(sd) if kwargs.has_key('exponential'): session_duration = random.expovariate(1.0/session_duration) if kwargs.has_key('traffic'): traffic = kwargs['traffic'] if kwargs.has_key('bidirectional'): bidirectional = kwargs['bidirectional'] if kwargs.has_key('ditgoptarg'): ditgoptarg = kwargs['ditgoptarg'] # Create an instance of Trigger & call its connect method prot = Trigger(src, dst, service_type, session_duration, traffic, bidirectional, ditgoptarg) d = connectProtocol(config.point, prot) d.addErrback(err1)
def get_ballot_information(prev_result): destination = TCP4ClientEndpoint(reactor, self.twisted_ballotregulator_ip, self.twisted_ballotregulator_port) requestsearchuser_deferred = connectProtocol(destination, AMP()) def requestsearchuser_connected(ampProto): return ampProto.callRemote(OnlineBallotRegulator_SearchBallotsAvailableForAllBallots) requestsearchuser_deferred.addCallback(requestsearchuser_connected) def done(result): ''' Returns the record ascociated with the ballot_id :param result: :return: ''' unpickled_result = pickle.loads(result['ok']) # Transform the list results into a dictionary. record_list = [] for record in unpickled_result: mapper = {} mapper['ballot_id'] = record[0] mapper['ballot_name'] = record[1] mapper['ballot_address'] = record[2] mapper['timestamp'] = record[3] # Append each row's dictionary to a list record_list.append(mapper) # Check the available ballots for *our* ballot for record in record_list: if record['ballot_id'] == ballot_id: return record # If we reach here we havent found *our* ballot in the list available raise BallotNotAvailable(ballot_id) def done_errback(failure): raise failure.raiseException() parsed_results = requestsearchuser_deferred.addCallback(done).addErrback(done_errback) return parsed_results
def handle_peers(self, data): log("Recieved peers from node " + str(self.remotePeer) + " - Total : " + str(len(data['peers']))) # print data['peers'] for node, info in data['peers'].iteritems(): log("Trying to connect to node - " + node ) if(node == self.factory.nodeId): log("That's me in the recieved peer list - IGNORING", "warning") continue if(node in self.factory.peers): log("Already connected to this node - IGNORING", "warning") continue if info['type'] != "SERVER": log("That node is a "+ data['peers'][node]['type'] +" - IGNORING", "warning"); continue location = info['location'] host, port = location.split(":") point = TCP4ClientEndpoint(reactor, host, int(port)) d = connectProtocol(point, MyPeerServer(self.factory)) d.addCallback(gotProtocol)
async def connect(self, host, port, connect_timeout, source_address=None, socket_options=None): # HostnameEndpoint only supports setting source host, not source port if source_address is not None: raise NotImplementedError( "twisted backend doesn't support setting source_address") # factory = protocol.Factory.forProtocol(TwistedSocketProtocol) endpoint = HostnameEndpoint(self._reactor, host, port) d = connectProtocol(endpoint, TwistedSocketProtocol()) # XX d.addTimeout(...) protocol = await d if socket_options is not None: for opt in socket_options: if opt[:2] == (socket.IPPROTO_TCP, socket.TCP_NODELAY): protocol.transport.setTcpNoDelay(opt[2]) else: raise NotImplementedError( "unrecognized socket option for twisted backend") return TwistedSocket(protocol)
def requestRegisterNewBallot(ballot_name, ballot_options_array, ballot_end_date): ballot_options_array_pickled = pickle.dumps(ballot_options_array) destination_deferred = yield TCP4ClientEndpoint(reactor, ballotregulator_ip, ballotregulator_port) connection_deferred = yield connectProtocol(destination_deferred, AMP()) result_deferred = yield connection_deferred.callRemote( OnlineBallotRegulator_RegisterBallotId, ballot_name=ballot_name, ballot_options_array_pickled=ballot_options_array_pickled, ballot_end_date=ballot_end_date) def format_results(result): return result['ballot_address'] # Inlinecallback return value. returnValue(format_results(result_deferred))
def get_ldap_client_(self): """ Get an authenticated LDAP client. """ log = self.log endpoint_s = self.endpoint_s bind_dn = self.bind_dn bind_passwd = self.bind_passwd base_dn = self.base_dn reactor = self.reactor use_starttls = self.use_starttls starttls_trust_anchor = self.starttls_trust_anchor log.debug("Endpoint: {endpoint}", endpoint=endpoint_s) e = clientFromString(reactor, endpoint_s) client = yield connectProtocol(e, ldapclient.LDAPClient()) if use_starttls: log.debug("StartTLS trust anchor: {trust}", trust=starttls_trust_anchor) yield client.startTLS(starttls_trust_anchor) yield client.bind(bind_dn, bind_passwd) defer.returnValue(client)
def main(reactor): log.startLogging(sys.stdout) entry = { "dn": "gn=Jane+sn=Doe,ou=people,dc=example,dc=fr", "c": "US", "gn": "Jane", "l": "Philadelphia", "objectClass": "addressbookPerson", "postalAddress": "230", "postalCode": "314159", "sn": "Doe", "st": "PA", "street": "Mobius Strip", "userPassword": "******", } endpoint_str = "tcp:host=localhost:port=8080" e = clientFromString(reactor, endpoint_str) d = connectProtocol(e, LDAPClient()) d.addCallback(onConnect, entry) d.addErrback(onError, reactor) return d
def main(reactor): host = "demo.nats.io" port = 4222 # TODO: make a NatsClient that does this, choosing the proper endpoint point = TCP4ClientEndpoint(reactor, host, port) nats_protocol = txnats.io.NatsProtocol(verbose=False, on_msg=my_on_msg, on_connect=somePubSubbing) # Because NatsProtocol implements the Protocol interface, Twisted's # connectProtocol knows how to connected to the endpoint. connecting = connectProtocol(point, nats_protocol) # Log if there is an error making the connection. connecting.addErrback(lambda np: log.info("{p}", p=np)) # Log what is returned by the connectProtocol. connecting.addCallback(lambda np: log.info("{p}", p=np)) return connecting
def spawnNewConnection(self, dstAddr, dstPort): if self._connections.has_key((dstAddr, dstPort)): d = Deferred() self._connComponents.reactor.callLater( 0, d.errback, Failure("Already have a connection for this destination")) return d logger.info( "Port map for %d (resvId %d) spawning new connection from %s %d" % (self._portNum, self.__resvId, dstAddr, dstPort)) gConn = self._createDataProtocol(dstAddr, dstPort) point = TCP4ClientEndpoint(self._connComponents.reactor, self._connComponents.revAddr, self._connComponents.revPort) spawnD = Deferred() d = connectProtocol(point, gConn) self._connections[(dstAddr, dstPort)] = ("deferred", spawnD) d.addCallback(self.__revConnected, self.__resvId, dstAddr, dstPort, point, gConn) d.addErrback(self.__revFailed, dstAddr, dstPort) return spawnD