def accept(self, host_pattern): """ Accept a pending connection request. :param str host_pattern: :func:`fnmatch.fnmatchcase` pattern against which the connection request must match. :returns: `KafkaConnection` """ host, port, protocolFactory, d = self._match(host_pattern) peerAddress = _DebugAddress(host, port) client_protocol = protocolFactory.buildProtocol(peerAddress) assert client_protocol is not None server_protocol = KafkaBrokerProtocol() client_transport = iosim.FakeTransport(client_protocol, isServer=False, peerAddress=peerAddress) server_transport = iosim.FakeTransport(server_protocol, isServer=True) pump = iosim.connect(server_protocol, server_transport, client_protocol, client_transport) self._pumps.append(pump) d.callback(client_protocol) return KafkaConnection( server=server_protocol, client=client_protocol, pump=pump, )
def request(self, method, uri, headers=None, bodyProducer=None): """ Implement IAgent.request. """ # We want to use Agent to parse the HTTP response, so let's ask it to # make a request against our in-memory reactor. response = self._realAgent.request(method, uri, headers, bodyProducer) # If the request has already finished, just propagate the result. In # reality this would only happen in failure, but if the agent ever adds # a local cache this might be a success. already_called = [] def check_already_called(r): already_called.append(r) return r response.addBoth(check_already_called) if already_called: return response # That will try to establish an HTTP connection with the reactor's # connectTCP method, and MemoryReactor will place Agent's factory into # the tcpClients list. Alternately, it will try to establish an HTTPS # connection with the reactor's connectSSL method, and MemoryReactor # will place it into the sslClients list. We'll extract that. if PY3: scheme = URLPath.fromBytes(uri).scheme else: scheme = URLPath.fromString(uri).scheme host, port, factory, timeout, bindAddress = ( self._memoryReactor.tcpClients[-1]) serverAddress = IPv4Address('TCP', '127.0.0.1', port) clientAddress = IPv4Address('TCP', '127.0.0.1', 31337) # Create the protocol and fake transport for the client and server, # using the factory that was passed to the MemoryReactor for the # client, and a Site around our rootResource for the server. serverProtocol = Site(self._rootResource).buildProtocol(None) serverTransport = iosim.FakeTransport( serverProtocol, isServer=True, hostAddress=serverAddress, peerAddress=clientAddress) clientProtocol = factory.buildProtocol(None) clientTransport = iosim.FakeTransport( clientProtocol, isServer=False, hostAddress=clientAddress, peerAddress=serverAddress) if scheme == b"https": # Provide ISSLTransport on both transports, so everyone knows that # this is HTTPS. directlyProvides(serverTransport, ISSLTransport) directlyProvides(clientTransport, ISSLTransport) # Make a pump for wiring the client and server together. pump = iosim.connect( serverProtocol, serverTransport, clientProtocol, clientTransport) self._pumps.add(pump) return response
def open(self, transport_config, options, protocol_class=None): """ Implement IWebSocketClientAgent with in-memory transports. :param transport_config: a string starting with 'wss://' or 'ws://' :param options: a dict containing options :param protocol_class: the client protocol class to instantiate (or `None` for defaults, which is to use `WebSocketClientProtocol`) """ is_secure = transport_config.startswith("wss://") # call our "real" agent real_client_protocol = self._agent.open( transport_config, options, protocol_class=protocol_class, ) if is_secure: host, port, factory, context_factory, timeout, bindAddress = self._reactor.sslClients[ -1] else: host, port, factory, timeout, bindAddress = self._reactor.tcpClients[ -1] server_address = IPv4Address('TCP', '127.0.0.1', port) client_address = IPv4Address('TCP', '127.0.0.1', 31337) server_protocol = self._server_protocol() server_protocol.factory = WebSocketServerFactory() server_transport = iosim.FakeTransport(server_protocol, isServer=True, hostAddress=server_address, peerAddress=client_address) clientProtocol = factory.buildProtocol(None) client_transport = iosim.FakeTransport(clientProtocol, isServer=False, hostAddress=client_address, peerAddress=server_address) if is_secure: directlyProvides(server_transport, ISSLTransport) directlyProvides(client_transport, ISSLTransport) pump = iosim.connect(server_protocol, server_transport, clientProtocol, client_transport) self._pumper.add(pump) def add_mapping(proto): self._servers[proto] = server_protocol return proto real_client_protocol.addCallback(add_mapping) return real_client_protocol
def connectOnCancel(deferred): log.debug('%r cancelled', deferred) protocol = protocolFactory.buildProtocol(None) transport = iosim.FakeTransport(protocol, isServer=False) cancels.append(transport) protocol.makeConnection(transport) deferred.callback(protocol)