def _start(self):
"""Starts this ForeLink.
This method must be called before attempting to exchange tickets with this
object.
"""
with self._condition:
address = '[::]:%d' % (0 if self._requested_port is None else
self._requested_port)
self._completion_queue = _low.CompletionQueue()
if self._root_certificates is None and not self._key_chain_pairs:
self._server = _low.Server(self._completion_queue, None)
self._port = self._server.add_http2_addr(address)
else:
server_credentials = _low.ServerCredentials(
self._root_certificates, self._key_chain_pairs)
self._server = _low.Server(self._completion_queue,
server_credentials)
self._port = self._server.add_secure_http2_addr(address)
self._server.start()
self._server.service(None)
self._pool.submit(self._spin, self._completion_queue, self._server)
self._spinning = True
return self
def test_immediately_connectable_channel_connectivity(self):
server_completion_queue = _low.CompletionQueue()
server = _low.Server(server_completion_queue, [])
port = server.add_http2_port('[::]:0')
server.start()
server_completion_queue_thread = threading.Thread(
target=_drive_completion_queue, args=(server_completion_queue, ))
server_completion_queue_thread.start()
channel = implementations.insecure_channel('localhost', port)
callback = _Callback()
try:
ready_future = utilities.channel_ready_future(channel)
ready_future.add_done_callback(callback.accept_value)
self.assertIsNone(ready_future.result(
test_constants.SHORT_TIMEOUT))
value_passed_to_callback = callback.block_until_called()
self.assertIs(ready_future, value_passed_to_callback)
self.assertFalse(ready_future.cancelled())
self.assertTrue(ready_future.done())
self.assertFalse(ready_future.running())
# Cancellation after maturity has no effect.
ready_future.cancel()
self.assertFalse(ready_future.cancelled())
self.assertTrue(ready_future.done())
self.assertFalse(ready_future.running())
finally:
ready_future.cancel()
server.shutdown()
server_completion_queue.shutdown()
server_completion_queue_thread.join()
def test_reachable_then_unreachable_channel_connectivity(self):
server_completion_queue = _low.CompletionQueue()
server = _low.Server(server_completion_queue, [])
port = server.add_http2_port('[::]:0')
server.start()
server_completion_queue_thread = threading.Thread(
target=_drive_completion_queue, args=(server_completion_queue, ))
server_completion_queue_thread.start()
low_channel = _low.Channel('localhost:%d' % port, ())
callback = _Callback()
connectivity_channel = _connectivity_channel.ConnectivityChannel(
low_channel)
connectivity_channel.subscribe(callback.update, try_to_connect=True)
callback.block_until_connectivities_satisfy(
lambda connectivities: interfaces.ChannelConnectivity.READY in
connectivities)
# Now take down the server and confirm that channel readiness is repudiated.
server.shutdown()
callback.block_until_connectivities_satisfy(
lambda connectivities: connectivities[
-1] is not interfaces.ChannelConnectivity.READY)
connectivity_channel.unsubscribe(callback.update)
server.shutdown()
server_completion_queue.shutdown()
server_completion_queue_thread.join()
def setUp(self):
self.server_completion_queue = _low.CompletionQueue()
self.server = _low.Server(self.server_completion_queue, [])
self.port = self.server.add_http2_port('[::]:0')
self.client_completion_queue = _low.CompletionQueue()
self.client_channel = _low.Channel('localhost:%d' % self.port, [])
self.server.start()
def setUp(self):
self.host = 'localhost'
self.server_completion_queue = _low.CompletionQueue()
self.server = _low.Server(self.server_completion_queue)
port = self.server.add_http2_addr('[::]:0')
self.server.start()
self.client_completion_queue = _low.CompletionQueue()
self.channel = _low.Channel('%s:%d' % (self.host, port), None)
def test_immediately_connectable_channel_connectivity(self):
server_completion_queue = _low.CompletionQueue()
server = _low.Server(server_completion_queue, [])
port = server.add_http2_port('[::]:0')
server.start()
server_completion_queue_thread = threading.Thread(
target=_drive_completion_queue, args=(server_completion_queue, ))
server_completion_queue_thread.start()
low_channel = _low.Channel('localhost:%d' % port, ())
first_callback = _Callback()
second_callback = _Callback()
connectivity_channel = _connectivity_channel.ConnectivityChannel(
low_channel)
connectivity_channel.subscribe(first_callback.update,
try_to_connect=False)
first_connectivities = first_callback.block_until_connectivities_satisfy(
bool)
# Wait for a connection that will never happen because try_to_connect=True
# has not yet been passed.
time.sleep(test_constants.SHORT_TIMEOUT)
second_connectivities = first_callback.connectivities()
connectivity_channel.subscribe(second_callback.update,
try_to_connect=True)
third_connectivities = first_callback.block_until_connectivities_satisfy(
lambda connectivities: 2 <= len(connectivities))
fourth_connectivities = second_callback.block_until_connectivities_satisfy(
bool)
# Wait for a connection that will happen (or may already have happened).
first_callback.block_until_connectivities_satisfy(
lambda connectivities: interfaces.ChannelConnectivity.READY in
connectivities)
second_callback.block_until_connectivities_satisfy(
lambda connectivities: interfaces.ChannelConnectivity.READY in
connectivities)
connectivity_channel.unsubscribe(first_callback.update)
connectivity_channel.unsubscribe(second_callback.update)
server.shutdown()
server_completion_queue.shutdown()
server_completion_queue_thread.join()
self.assertSequenceEqual((interfaces.ChannelConnectivity.IDLE, ),
first_connectivities)
self.assertSequenceEqual((interfaces.ChannelConnectivity.IDLE, ),
second_connectivities)
self.assertNotIn(interfaces.ChannelConnectivity.TRANSIENT_FAILURE,
third_connectivities)
self.assertNotIn(interfaces.ChannelConnectivity.FATAL_FAILURE,
third_connectivities)
self.assertNotIn(interfaces.ChannelConnectivity.TRANSIENT_FAILURE,
fourth_connectivities)
self.assertNotIn(interfaces.ChannelConnectivity.FATAL_FAILURE,
fourth_connectivities)
def __init__(self, completion_queue): self._internal = _low.Server(completion_queue._internal, []) self._internal_cq = completion_queue._internal
