def inboundConnect(self, address, password='******', protocol=EventSocket, factory=EventSocketClientFactory, subscribers=[]): self.inbound_factory = factory(password=password, notifyTarget=self) self.inbound_factory.protocol = protocol if self not in subscribers: subscribers.append(self) self.auto_subscribers = subscribers self.address = address host, port = utils.parse_host_port(address, 8021) reactor.connectTCP(host, port, self.inbound_factory)
def connect(self, server_address, service=None, protocol='tcp'): """ Connect to the given server_address. Without the 'service' keyword, the server_address can be formatted as HOST[:PORT] (if no port given, 8800 will be assumed). If 'service' is used, it must be the name of a service to look up using a DNS SRV record at the server_address (in this case, no port is expected in the server_address). The 'protocol' is also sent used in the DNS SRV lookup. The 'protocol' keyword is ignored if 'service' is not used. Examples: c = Client() # connect to example.com at port 8800 c.connect('example.com') # connect to example.com at port 45 c.connect('example.com:45') # look up the host and port using SRV, passing 'SIP' as the ## service name to the DNS SRV host at example.com c.connect('example.com', service='SIP') TODO: Twisted uses it's own lookup cache that appears to be cleared when the process terminates. I am unsure whether that cache respects SRV TTL; if not, long-living reconnecting clients *might* not get a new lookup. Further testing is needed to determine this. """ self.ip = server_address if service: connector = SRVConnector(reactor, service, server_address, self.factory, protocol=protocol) connector.connect() else: self.host, self.port = utils.parse_host_port(server_address, 8800) try: reactor.connectTCP(self.host, self.port, self.factory) except error.ConnectionRefusedError, e: logger.error(e) # wraps the error in a slightly more generic ClientError ## and reraises raise ClientError(str(e))
def connectSSL(self, server_address, cert_path, cert_chain_path=None, service=None, protocol='ssl'): """ Connect to the given server_address. See the docstring for Client.connect() for more information. """ self.ip = server_address # verify that the given key/cert files actually exist if not os.path.exists(cert_path): raise ClientError('Cert file %r does not exist!' % cert_path) if cert_chain_path and not os.path.exists(cert_chain_path): raise ClientError('Cert chain file %r does not exist!' % \ cert_chain_path) class CtxFactory(ssl.ClientContextFactory): def getContext(self): self.method = SSL.SSLv23_METHOD ctx = ssl.ClientContextFactory.getContext(self) if cert_chain_path: ctx.use_certificate_chain_file(cert_chain_path) ctx.use_certificate_file(cert_path) return ctx if service: connector = SRVConnector(reactor, service, server_address, self.factory, protocol=protocol, connectFuncName='connectSSL', connectFuncArgs=(CtxFactory(),)) connector.connect() else: self.host, self.port = utils.parse_host_port(server_address, 2220) try: reactor.connectSSL(self.host, self.port, self.factory, CtxFactory()) except error.ConnectionRefusedError, e: logger.error(e) # wraps the error in a slightly more generic ClientError ## and reraises raise ClientError(str(e))