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)