class TestUnboundTCPPort(protocol.ServerFactory, ValidateDataMixin): protocol = TCPTestProtocol def __init__(self, timeout): ValidateDataMixin.__init__(self, timeout) self.listener = None self.port = None def start_test(self, port, remoteHost, remotePort): self.port = port #listen for responses if necessary try: self.listener = Globals.reactor.listenTCP(port, self, interface="") except CannotListenError, e: self.cancel() return defer.fail(failure.Failure(e)) #send off the request for a reply: self.outgoingProtocol = TCPTestProtocol() d = defer.Deferred() def on_connection_failed(reason): self.fail(reason) d.addErrback(on_connection_failed) outgoingFactory = protocol._InstanceFactory(Globals.reactor, self.outgoingProtocol, d) Globals.reactor.connectTCP(remoteHost, remotePort, outgoingFactory, CONNECTION_TIMEOUT) return self.get_deferred()
def connect(self, dn, overrides=None): """Connect to remote host, return Deferred of resulting protocol instance.""" d = defer.Deferred() f = protocol._InstanceFactory(self.reactor, self.protocolClass(*self.args, **self.kwargs), d) c = LDAPConnector(self.reactor, dn, f, overrides=overrides) c.connect() return d
def connect(self, host=None, port=None, spec=None, user=None, password=None, vhost=None, heartbeat=None, clientClass=None): host = host or self.host port = port or self.port spec = spec or self.spec user = user or self.user password = password or self.password vhost = vhost or self.vhost heartbeat = heartbeat or self.heartbeat clientClass = clientClass or self.clientClass delegate = TwistedDelegate() onConn = Deferred() p = clientClass(delegate, vhost, txamqp.spec.load(spec), heartbeat=heartbeat) f = protocol._InstanceFactory(reactor, p, onConn) c = reactor.connectTCP(host, port, f) def errb(thefailure): thefailure.trap(error.ConnectionRefusedError) print "failed to connect to host: %s, port: %s; These tests are designed to run against a running instance" \ " of the %s AMQP broker on the given host and port. failure: %r" % (host, port, self.broker, thefailure,) thefailure.raiseException() onConn.addErrback(errb) self.connectors.append(c) client = yield onConn yield client.authenticate(user, password) returnValue(client)
def connectSimpleProducer(self, name, timeout=30, bindName=None): """ Simple Producer """ d = defer.Deferred() f = _InstanceFactory(self.reactor, self.protocolClass(*self.args, **self.kwargs), d) self.p_reactor.connectSimpleProducer(name, f, timeout=timeout, bindAddress=bindName) return d
def connect(self, dn, overrides=None, bindAddress=None): """Connect to remote host, return Deferred of resulting protocol instance.""" d = defer.Deferred() f = protocol._InstanceFactory(self.reactor, self.protocolClass(*self.args, **self.kwargs), d) c = LDAPConnector(self.reactor, dn, f, overrides=overrides, bindAddress=bindAddress) c.connect() return d
def send_notification(s, xml): """ send a notification a subscriber return its response """ log_category = "notification_protocol" _,host_port,path,_,_ = urlsplit(s['callback']) if path == '': path = '/' if host_port.find(':') != -1: host,port = tuple(host_port.split(':')) port = int(port) else: host = host_port port = 80 def send_request(p,port_item): request = ['NOTIFY %s HTTP/1.1' % path, 'HOST: %s:%d' % (host, port), 'SEQ: %d' % s['seq'], 'CONTENT-TYPE: text/xml;charset="utf-8"', 'SID: %s' % s['sid'], 'NTS: upnp:propchange', 'NT: upnp:event', 'Content-Length: %d' % len(xml), '', xml] request = '\r\n'.join(request) log.info(log_category, "send_notification.send_request to %r %r", s['sid'], s['callback']) log.debug(log_category, "request: %r", request) s['seq'] += 1 if s['seq'] > 0xffffffff: s['seq'] = 1 p.transport.write(request) port_item.disconnect() #return p.transport.write(request) def got_error(failure,port_item): port_item.disconnect() log.info(log_category, "error sending notification to %r %r", s['sid'], s['callback']) log.debug(log_category, failure) #c = ClientCreator(reactor, NotificationProtocol) #d = c.connectTCP(host, port) d = defer.Deferred() f = _InstanceFactory(reactor, NotificationProtocol(), d) port_item = reactor.connectTCP(host, port, f, timeout=30, bindAddress=None) d.addCallback(send_request, port_item) d.addErrback(got_error, port_item) return d,port_item
def send_notification(s, xml): """ send a notification a subscriber return its response """ log_category = "notification_protocol" _, host_port, path, _, _ = urlsplit(s["callback"]) if path == "": path = "/" if host_port.find(":") != -1: host, port = tuple(host_port.split(":")) port = int(port) else: host = host_port port = 80 def send_request(p, port_item): request = [ "NOTIFY %s HTTP/1.1" % path, "HOST: %s:%d" % (host, port), "SEQ: %d" % s["seq"], 'CONTENT-TYPE: text/xml;charset="utf-8"', "SID: %s" % s["sid"], "NTS: upnp:propchange", "NT: upnp:event", "Content-Length: %d" % len(xml), "", xml, ] request = "\r\n".join(request) log.info(log_category, "send_notification.send_request to %r %r", s["sid"], s["callback"]) log.debug(log_category, "request: %r", request) s["seq"] += 1 if s["seq"] > 0xFFFFFFFF: s["seq"] = 1 p.transport.write(request) port_item.disconnect() # return p.transport.write(request) def got_error(failure, port_item): port_item.disconnect() log.info(log_category, "error sending notification to %r %r", s["sid"], s["callback"]) log.debug(log_category, failure) # c = ClientCreator(reactor, NotificationProtocol) # d = c.connectTCP(host, port) d = defer.Deferred() f = _InstanceFactory(reactor, NotificationProtocol(), d) port_item = reactor.connectTCP(host, port, f, timeout=30, bindAddress=None) d.addCallback(send_request, port_item) d.addErrback(got_error, port_item) return d, port_item
def connect(self, dn, overrides=None, bindAddress=None, timeout=5): d = defer.Deferred() # noinspection PyProtectedMember f = protocol._InstanceFactory( self.reactor, self.protocolClass(*self.args, **self.kwargs), d) c = LDAPConnector(self.reactor, dn, f, overrides=overrides, bind_address=bindAddress, timeout=timeout) c.connect() return d
def send_notification(s, xml): ''' send a notification a subscriber return its response ''' logger = log.get_logger('notification_protocol') # logger.debug('\t-send_notification s is: {}'.format(s)) # logger.debug('\t-send_notification xml is: {}'.format(xml)) _, host_port, path, _, _ = urlsplit(s['callback']) # logger.debug('\t-send_notification host_port is: {}'.format(host_port)) # logger.debug('\t-send_notification path is: {}'.format(path)) path = to_string(path) host_port = to_string(host_port) if path == '': path = '/' if host_port.find(':') != -1: host, port = tuple(host_port.split(':')) port = int(port) else: host = host_port port = 80 def send_request(p, port_item): request = [ f'NOTIFY {path} HTTP/1.1', f'HOST: {host}:{port}', f'SEQ: {s["seq"]}', 'CONTENT-TYPE: text/xml;charset="utf-8"', f'SID: {s["sid"]}', 'NTS: upnp:propchange', 'NT: upnp:event', f'Content-Length: {len(xml)}', '' ] request = [to_bytes(x) for x in request] request.append(xml) request = b'\r\n'.join(request) logger.info(f'send_notification.send_request to ' f'{s["sid"]} {s["callback"]}') logger.info(f'request: {request}') s['seq'] += 1 if s['seq'] > 0xffffffff: s['seq'] = 1 p.transport.write(request) port_item.disconnect() def got_error(failure, port_item): port_item.disconnect() logger.info( f'error sending notification to {s["sid"]} {s["callback"]}') logger.debug(failure) d = defer.Deferred() f = _InstanceFactory(reactor, NotificationProtocol(), d) port_item = reactor.connectTCP(host, port, f, timeout=30, bindAddress=None) d.addCallback(send_request, port_item) d.addErrback(got_error, port_item) return d, port_item
def connectSocks5Proxy(self,remotehost,remoteport,proxy,proxyport,id): d = defer.Deferred() f = protocol._InstanceFactory(self.reactor, self.protocolClass(*self.args, **self.kwargs),d) self.reactor.connectWith(ClientConnector, host=remotehost,port=remoteport, sockshost=proxy,socksport=proxyport, otherFactory=f, readableID=id) return d
def connectMS(self, address, timeout=30, bindAddress=None): """Connect to remote address (messaging service name), return a Deferred of resulting protocol instance. @param address 'Messaging service' remote address (name) @param bindAddress 'Messaging service' address (name) to listen on. @param timeout Error timeout, in seconds """ d = defer.Deferred() f = _InstanceFactory(self.reactor, self.protocolClass(*self.args, **self.kwargs), d) self.p_reactor.connectMS(address, f, timeout=timeout, bindAddress=bindAddress) return d
def connectWorkProducer(self, name, timeout=30, bindName=None): """ Distributed work producer client (producer end of worker-queue pattern) return a Deferred of resulting protocol instance. @param name "Exchange Point/Distributed Topic" """ d = defer.Deferred() f = _InstanceFactory(self.reactor, self.protocolClass(*self.args, **self.kwargs), d) self.p_reactor.connectWorkProducer(name, f, timeout=timeout, bindAddress=bindName) return d
def connectTCP(self, host, port, timeout=30, bindAddress=None): """Connect to remote Broker host, return a Deferred of resulting protocol instance. """ d = defer.Deferred() p = self.amqpProtocol(self.amqpDelegate(), self.vhost, self.spec) # p.factory = self f = protocol._InstanceFactory(self.reactor, p, d) self.connector = self.reactor.connectTCP(host, port, f, timeout=timeout, bindAddress=bindAddress) d.addCallback(self._broker_login) return d
def connect(self, host=None, port=None, spec=None, user=None, password=None, vhost=None): host = host or self.host port = port or self.port spec = spec or self.spec user = user or self.user password = password or self.password vhost = vhost or self.vhost delegate = TwistedDelegate() onConn = Deferred() f = protocol._InstanceFactory(reactor, AMQClient(delegate, vhost, txamqp.spec.load(spec)), onConn) c = reactor.connectTCP(host, port, f) self.connectors.append(c) client = yield onConn yield client.authenticate(user, password) returnValue(client)
def connectTCP(self, host, port, timeout=30, bindAddress=None): """Connect to remote Broker host, return a Deferred of resulting protocol instance. """ d = defer.Deferred() p = self.protocol(self.delegate, self.vhost, self.spec, heartbeat=self.heartbeat) p.factory = self f = protocol._InstanceFactory(self.reactor, p, d) self.connector = self.reactor.connectTCP(host, port, f, timeout=timeout, bindAddress=bindAddress) def auth_cb(conn): d = conn.authenticate(self.username, self.password) d.addCallback(lambda _: conn) return d d.addCallback(auth_cb) return d
def connectSocks5Proxy(self, remotehost, remoteport, proxy, proxyport, id, proxylogin=None, proxypass=None): d = defer.Deferred() f = protocol._InstanceFactory( self.reactor, self.protocolClass(*self.args, **self.kwargs), d) c = ClientConnector(host=remotehost, port=remoteport, sockshost=proxy, socksport=proxyport, otherFactory=f, reactor=self.reactor, login=proxylogin, password=proxypass) return c
def connect(self): host = self.host port = self.port spec = self.spec user = self.username password = self.password vhost = self.vhost delegate = TwistedDelegate() onConn = Deferred() p = AMQClient(delegate, vhost, txamqp.spec.load(spec), heartbeat=0) f = protocol._InstanceFactory(reactor, p, onConn) c = reactor.connectTCP(host, port, f) def errb(thefailure): thefailure.trap(error.ConnectionRefusedError) logging.error(traceback.format_exc()) onConn.addErrback(errb) client = yield onConn self.client = client yield self.authenticate(self.client, user, password) returnValue(client)
def connect(self, host=None, port=None, spec=None, user=None, password=None, vhost=None, heartbeat=None, clientClass=None): host = host or self.host port = port or self.port spec = spec or self.spec user = user or self.user password = password or self.password vhost = vhost or self.vhost heartbeat = heartbeat or self.heartbeat clientClass = clientClass or self.clientClass delegate = TwistedDelegate() onConn = Deferred() p = clientClass(delegate, vhost, txamqp.spec.load(spec), heartbeat=heartbeat) f = protocol._InstanceFactory(reactor, p, onConn) c = reactor.connectTCP(host, port, f) def errb(thefailure): thefailure.trap(error.ConnectionRefusedError) print "failed to connect to host: %s, port: %s; These tests are designed to run against a running instance" \ " of the %s AMQP broker on the given host and port. failure: %r" % (host, port, self.broker, thefailure,) thefailure.raiseException() onConn.addErrback(errb) self.connectors.append(c) client = yield onConn yield self.authenticate(client, user, password) returnValue(client)
def clientCreatorConnectUTP(self, host, port, timeout=30, bindAddress=None): """Connect to remote host, return Deferred of resulting protocol instance.""" d = defer.Deferred() f = _InstanceFactory(self.reactor, self.protocolClass(*self.args, **self.kwargs), d) self.reactor.connectUTP(host, port, f, timeout=timeout, bindAddress=bindAddress) return d
def connectSocks5Proxy(self,remotehost,remoteport,proxy,proxyport,id,proxylogin=None,proxypass=None): d = defer.Deferred() f = protocol._InstanceFactory(self.reactor,self.protocolClass(*self.args, **self.kwargs),d) c = ClientConnector(host=remotehost,port=remoteport,sockshost=proxy,socksport=proxyport,otherFactory=f,reactor=self.reactor, login=proxylogin, password=proxypass) return c