def setUpMixin(self, server_credentials, client_credentials, host_override): self.server_completion_queue = cygrpc.CompletionQueue() self.server = cygrpc.Server(cygrpc.ChannelArgs([])) self.server.register_completion_queue(self.server_completion_queue) if server_credentials: self.port = self.server.add_http2_port(b'[::]:0', server_credentials) else: self.port = self.server.add_http2_port(b'[::]:0') self.server.start() self.client_completion_queue = cygrpc.CompletionQueue() if client_credentials: client_channel_arguments = cygrpc.ChannelArgs([ cygrpc.ChannelArg(cygrpc.ChannelArgKey.ssl_target_name_override, host_override) ]) self.client_channel = cygrpc.Channel( 'localhost:{}'.format(self.port).encode(), client_channel_arguments, client_credentials) else: self.client_channel = cygrpc.Channel( 'localhost:{}'.format(self.port).encode(), cygrpc.ChannelArgs([])) if host_override: self.host_argument = None # default host self.expected_host = host_override else: # arbitrary host name necessitating no further identification self.host_argument = b'hostess' self.expected_host = self.host_argument
def setUp(self): self.server_completion_queue = cygrpc.CompletionQueue() self.server = cygrpc.Server() self.server.register_completion_queue(self.server_completion_queue) self.port = self.server.add_http2_port('[::]:0') self.server.start() self.client_completion_queue = cygrpc.CompletionQueue() self.client_channel = cygrpc.Channel('localhost:{}'.format(self.port))
def __init__(self, thread_pool, generic_handlers, options, maximum_concurrent_rpcs): completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server(_common.channel_args(options)) server.register_completion_queue(completion_queue) self._state = _ServerState(completion_queue, server, generic_handlers, thread_pool, maximum_concurrent_rpcs)
def __init__(self, config: Optional[DefaultConfig] = None): self.config = config or DefaultConfig() thread_pool = futures.ThreadPoolExecutor( max_workers=self.config.GPRC_SERVER_MAX_WORKERS) completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server(self.config.GRPC_SERVER_OPTIONS) server.register_completion_queue(completion_queue) #: gRPC Server State #: #: .. versionadded:: 0.2.1 self._state = _ServerState( completion_queue, server, (), None, thread_pool, self.config.GRPC_SERVER_MAXIMUM_CONCURRENT_RPCS, ) #: all the attached blueprints in a dictionary by name. #: #: .. versionadded:: 0.1.6 self.blueprints: Dict[str, Blueprint] = {self.service_name: self} #: init logger self.logger = logging.getLogger() self.logger.setLevel(logging.DEBUG) self.logger.addHandler(logging.StreamHandler()) super().__init__() self.current_app = self
def _blocking(self, request_iterator, timeout, metadata, credentials): deadline, deadline_timespec = _deadline(timeout) state = _RPCState(_STREAM_UNARY_INITIAL_DUE, None, None, None, None) completion_queue = cygrpc.CompletionQueue() call = self._channel.create_call(None, 0, completion_queue, self._method, None, deadline_timespec) if credentials is not None: call.set_credentials(credentials._credentials) with state.condition: call.start_client_batch( cygrpc.Operations( (cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS), )), None) operations = ( cygrpc.operation_send_initial_metadata( _common.cygrpc_metadata(metadata), _EMPTY_FLAGS), cygrpc.operation_receive_message(_EMPTY_FLAGS), cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS), ) call_error = call.start_client_batch(cygrpc.Operations(operations), None) _check_call_error(call_error, metadata) _consume_request_iterator(request_iterator, state, call, self._request_serializer) while True: event = completion_queue.poll() with state.condition: _handle_event(event, state, self._response_deserializer) state.condition.notify_all() if not state.due: break return state, deadline
def testServerStartNoExplicitShutdown(self): server = cygrpc.Server(cygrpc.ChannelArgs([])) completion_queue = cygrpc.CompletionQueue() server.register_completion_queue(completion_queue) port = server.add_http2_port(b'[::]:0') self.assertIsInstance(port, int) server.start() del server
def __init__(self, thread_pool, generic_handlers, interceptors, options, maximum_concurrent_rpcs, compression, xds): completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server(_augment_options(options, compression), xds) server.register_completion_queue(completion_queue) self._state = _ServerState(completion_queue, server, generic_handlers, _interceptor.service_pipeline(interceptors), thread_pool, maximum_concurrent_rpcs)
def __init__(self, thread_pool, generic_handlers, options, exit_grace, exit_shutdown_handler_grace): completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server(_common.channel_args(options)) server.register_completion_queue(completion_queue) self._state = _ServerState( completion_queue, server, generic_handlers, thread_pool, _DEFAULT_EXIT_GRACE if exit_grace is None else exit_grace, _DEFAULT_EXIT_SHUTDOWN_HANDLER_GRACE if exit_shutdown_handler_grace is None else exit_shutdown_handler_grace)
def testServerStartNoExplicitShutdown(self): server = cygrpc.Server([( b'grpc.so_reuseport', 0, )], False) completion_queue = cygrpc.CompletionQueue() server.register_completion_queue(completion_queue) port = server.add_http2_port(b'[::]:0') self.assertIsInstance(port, int) server.start() del server
def test_lonely_server(self): server_call_completion_queue = cygrpc.CompletionQueue() server_shutdown_completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server(None) server.register_completion_queue(server_call_completion_queue) server.register_completion_queue(server_shutdown_completion_queue) port = server.add_http2_port(b'[::]:0') server.start() server_request_call_tag = 'server_request_call_tag' server_request_call_start_batch_result = server.request_call( server_call_completion_queue, server_call_completion_queue, server_request_call_tag) time.sleep(4) server_shutdown_tag = 'server_shutdown_tag' server_shutdown_result = server.shutdown( server_shutdown_completion_queue, server_shutdown_tag) server_request_call_event = server_call_completion_queue.poll() server_shutdown_event = server_shutdown_completion_queue.poll()
def setUp(self): server_credentials = cygrpc.server_credentials_ssl( None, [ cygrpc.SslPemKeyCertPair(resources.private_key(), resources.certificate_chain()) ], False) channel_credentials = cygrpc.channel_credentials_ssl( resources.test_root_certificates(), None) self.server_completion_queue = cygrpc.CompletionQueue() self.server = cygrpc.Server() self.server.register_completion_queue(self.server_completion_queue) self.port = self.server.add_http2_port('[::]:0', server_credentials) self.server.start() self.client_completion_queue = cygrpc.CompletionQueue() client_channel_arguments = cygrpc.ChannelArgs([ cygrpc.ChannelArg(cygrpc.ChannelArgKey.ssl_target_name_override, _SSL_HOST_OVERRIDE) ]) self.client_channel = cygrpc.Channel('localhost:{}'.format(self.port), client_channel_arguments, channel_credentials)
def _serve(state, server, server_completion_queue, thread_pool): for _ in range(test_constants.RPC_CONCURRENCY): call_completion_queue = cygrpc.CompletionQueue() server.request_call(call_completion_queue, server_completion_queue, _REQUEST_CALL_TAG) rpc_event = server_completion_queue.poll() thread_pool.submit(_Handler(state, call_completion_queue, rpc_event)) with state.condition: state.handled_rpcs += 1 if test_constants.RPC_CONCURRENCY <= state.handled_rpcs: state.condition.notify_all() server_completion_queue.poll()
def setUp(self): self.server_completion_queue = cygrpc.CompletionQueue() self.server = cygrpc.Server([(b'grpc.so_reuseport', 0)]) self.server.register_completion_queue(self.server_completion_queue) port = self.server.add_http2_port(b'[::]:0') self.server.start() self.channel = cygrpc.Channel('localhost:{}'.format(port).encode(), []) self._server_shutdown_tag = 'server_shutdown_tag' self.server_condition = threading.Condition() self.server_driver = QueueDriver(self.server_condition, self.server_completion_queue) with self.server_condition: self.server_driver.add_due({ self._server_shutdown_tag, }) self.client_condition = threading.Condition() self.client_completion_queue = cygrpc.CompletionQueue() self.client_driver = QueueDriver(self.client_condition, self.client_completion_queue)
def testServerStartShutdown(self): completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server(cygrpc.ChannelArgs([])) server.add_http2_port(b'[::]:0') server.register_completion_queue(completion_queue) server.start() shutdown_tag = object() server.shutdown(completion_queue, shutdown_tag) event = completion_queue.poll() self.assertEqual(cygrpc.CompletionType.operation_complete, event.type) self.assertIs(shutdown_tag, event.tag) del server del completion_queue
def _blocking(self, request, timeout, metadata, credentials): state, operations, deadline, deadline_timespec, rendezvous = self._prepare( request, timeout, metadata) if rendezvous: raise rendezvous else: completion_queue = cygrpc.CompletionQueue() call = self._channel.create_call( None, 0, completion_queue, self._method, None, deadline_timespec) if credentials is not None: call.set_credentials(credentials._credentials) call.start_batch(cygrpc.Operations(operations), None) _handle_event(completion_queue.poll(), state, self._response_deserializer) return state, deadline
def __init__(self, config: DefaultConfig): self.config: DefaultConfig = config #: init logger self.logger = logging.getLogger(__name__) handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( self.config.GRPC_ALCHEMY_LOGGER_FORMATTER) handler.setFormatter(formatter) self.logger.setLevel(self.config.GRPC_ALCHEMY_LOGGER_LEVEL) self.logger.addHandler(handler) self.logger.info( f"workers number: {self.config.GRPC_SERVER_MAX_WORKERS}") thread_pool = futures.ThreadPoolExecutor( max_workers=self.config.GRPC_SERVER_MAX_WORKERS) completion_queue = cygrpc.CompletionQueue() self.logger.info(f"server options: {self.config.GRPC_SERVER_OPTIONS}") if tuple(map(int, GRPC_VERSION.split("."))) >= (1, 36, 0): server = cygrpc.Server(tuple(self.config.GRPC_SERVER_OPTIONS), self.config.GRPC_XDS_SUPPORT) else: server = cygrpc.Server(tuple(self.config.GRPC_SERVER_OPTIONS)) server.register_completion_queue(completion_queue) #: gRPC Server State #: #: .. versionadded:: 0.2.1 self._state = _ServerState( completion_queue, server, (), None, thread_pool, self.config.GRPC_SERVER_MAXIMUM_CONCURRENT_RPCS, ) #: all the attached blueprints in a dictionary by name. #: #: .. versionadded:: 0.1.6 self.blueprints: Dict[str, Blueprint] = { self.access_service_name(): self } super().__init__() self.current_app = self
def _poll_connectivity(state, channel, initial_try_to_connect): try_to_connect = initial_try_to_connect connectivity = channel.check_connectivity_state(try_to_connect) with state.lock: state.connectivity = ( _common. CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[connectivity]) callbacks = tuple( callback for callback, unused_but_known_to_be_none_connectivity in state.callbacks_and_connectivities) for callback_and_connectivity in state.callbacks_and_connectivities: callback_and_connectivity[1] = state.connectivity if callbacks: _spawn_delivery(state, callbacks) completion_queue = cygrpc.CompletionQueue() while True: channel.watch_connectivity_state(connectivity, cygrpc.Timespec(time.time() + 0.2), completion_queue, None) event = completion_queue.poll() with state.lock: if not state.callbacks_and_connectivities and not state.try_to_connect: state.polling = False state.connectivity = None break try_to_connect = state.try_to_connect state.try_to_connect = False if event.success or try_to_connect: connectivity = channel.check_connectivity_state(try_to_connect) with state.lock: state.connectivity = ( _common.CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[ connectivity]) if not state.delivering: # NOTE(nathaniel): The field is only ever used as a # sequence so it's fine that both lists and tuples are # assigned to it. callbacks = _deliveries(state) # pylint: disable=redefined-variable-type if callbacks: _spawn_delivery(state, callbacks)
def _poll_connectivity(state, channel, initial_try_to_connect): try_to_connect = initial_try_to_connect connectivity = channel.check_connectivity_state(try_to_connect) with state.lock: state.connectivity = ( _common. CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[connectivity]) callbacks = tuple( callback for callback, unused_but_known_to_be_none_connectivity in state.callbacks_and_connectivities) for callback_and_connectivity in state.callbacks_and_connectivities: callback_and_connectivity[1] = state.connectivity if callbacks: _spawn_delivery(state, callbacks) completion_queue = cygrpc.CompletionQueue() while True: channel.watch_connectivity_state(connectivity, cygrpc.Timespec(time.time() + 0.2), completion_queue, None) event = completion_queue.poll() with state.lock: if not state.callbacks_and_connectivities and not state.try_to_connect: state.polling = False state.connectivity = None break try_to_connect = state.try_to_connect state.try_to_connect = False if event.success or try_to_connect: connectivity = channel.check_connectivity_state(try_to_connect) with state.lock: state.connectivity = ( _common.CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[ connectivity]) if not state.delivering: callbacks = _deliveries(state) if callbacks: _spawn_delivery(state, callbacks)
def testReadSomeButNotAllResponses(self): server_completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server(cygrpc.ChannelArgs([])) server.register_completion_queue(server_completion_queue) port = server.add_http2_port(b'[::]:0') server.start() channel = cygrpc.Channel('localhost:{}'.format(port).encode(), cygrpc.ChannelArgs([])) server_shutdown_tag = 'server_shutdown_tag' server_driver = _ServerDriver(server_completion_queue, server_shutdown_tag) server_driver.start() client_condition = threading.Condition() client_due = set() client_completion_queue = cygrpc.CompletionQueue() client_driver = _QueueDriver(client_condition, client_completion_queue, client_due) client_driver.start() server_call_condition = threading.Condition() server_send_initial_metadata_tag = 'server_send_initial_metadata_tag' server_send_first_message_tag = 'server_send_first_message_tag' server_send_second_message_tag = 'server_send_second_message_tag' server_complete_rpc_tag = 'server_complete_rpc_tag' server_call_due = set( (server_send_initial_metadata_tag, server_send_first_message_tag, server_send_second_message_tag, server_complete_rpc_tag,)) server_call_completion_queue = cygrpc.CompletionQueue() server_call_driver = _QueueDriver(server_call_condition, server_call_completion_queue, server_call_due) server_call_driver.start() server_rpc_tag = 'server_rpc_tag' request_call_result = server.request_call(server_call_completion_queue, server_completion_queue, server_rpc_tag) client_call = channel.create_call(None, _EMPTY_FLAGS, client_completion_queue, b'/twinkies', None, _INFINITE_FUTURE) client_receive_initial_metadata_tag = 'client_receive_initial_metadata_tag' client_complete_rpc_tag = 'client_complete_rpc_tag' with client_condition: client_receive_initial_metadata_start_batch_result = ( client_call.start_client_batch([ cygrpc.ReceiveInitialMetadataOperation(_EMPTY_FLAGS), ], client_receive_initial_metadata_tag)) client_due.add(client_receive_initial_metadata_tag) client_complete_rpc_start_batch_result = ( client_call.start_client_batch([ cygrpc.SendInitialMetadataOperation(_EMPTY_METADATA, _EMPTY_FLAGS), cygrpc.SendCloseFromClientOperation(_EMPTY_FLAGS), cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS), ], client_complete_rpc_tag)) client_due.add(client_complete_rpc_tag) server_rpc_event = server_driver.first_event() with server_call_condition: server_send_initial_metadata_start_batch_result = ( server_rpc_event.operation_call.start_server_batch([ cygrpc.SendInitialMetadataOperation(_EMPTY_METADATA, _EMPTY_FLAGS), ], server_send_initial_metadata_tag)) server_send_first_message_start_batch_result = ( server_rpc_event.operation_call.start_server_batch([ cygrpc.SendMessageOperation(b'\x07', _EMPTY_FLAGS), ], server_send_first_message_tag)) server_send_initial_metadata_event = server_call_driver.event_with_tag( server_send_initial_metadata_tag) server_send_first_message_event = server_call_driver.event_with_tag( server_send_first_message_tag) with server_call_condition: server_send_second_message_start_batch_result = ( server_rpc_event.operation_call.start_server_batch([ cygrpc.SendMessageOperation(b'\x07', _EMPTY_FLAGS), ], server_send_second_message_tag)) server_complete_rpc_start_batch_result = ( server_rpc_event.operation_call.start_server_batch([ cygrpc.ReceiveCloseOnServerOperation(_EMPTY_FLAGS), cygrpc.SendStatusFromServerOperation( (), cygrpc.StatusCode.ok, b'test details', _EMPTY_FLAGS), ], server_complete_rpc_tag)) server_send_second_message_event = server_call_driver.event_with_tag( server_send_second_message_tag) server_complete_rpc_event = server_call_driver.event_with_tag( server_complete_rpc_tag) server_call_driver.events() with client_condition: client_receive_first_message_tag = 'client_receive_first_message_tag' client_receive_first_message_start_batch_result = ( client_call.start_client_batch([ cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS), ], client_receive_first_message_tag)) client_due.add(client_receive_first_message_tag) client_receive_first_message_event = client_driver.event_with_tag( client_receive_first_message_tag) client_call_cancel_result = client_call.cancel() client_driver.events() server.shutdown(server_completion_queue, server_shutdown_tag) server.cancel_all_calls() server_driver.events() self.assertEqual(cygrpc.CallError.ok, request_call_result) self.assertEqual(cygrpc.CallError.ok, server_send_initial_metadata_start_batch_result) self.assertEqual(cygrpc.CallError.ok, client_receive_initial_metadata_start_batch_result) self.assertEqual(cygrpc.CallError.ok, client_complete_rpc_start_batch_result) self.assertEqual(cygrpc.CallError.ok, client_call_cancel_result) self.assertIs(server_rpc_tag, server_rpc_event.tag) self.assertEqual(cygrpc.CompletionType.operation_complete, server_rpc_event.type) self.assertIsInstance(server_rpc_event.operation_call, cygrpc.Call) self.assertEqual(0, len(server_rpc_event.batch_operations))
def _do_rpcs(self): server_call_condition = threading.Condition() server_call_completion_queue = cygrpc.CompletionQueue() server_call_driver = _common.QueueDriver(server_call_condition, server_call_completion_queue) server_request_call_tag = 'server_request_call_tag' server_send_initial_metadata_tag = 'server_send_initial_metadata_tag' server_complete_rpc_tag = 'server_complete_rpc_tag' with self.server_condition: server_request_call_start_batch_result = self.server.request_call( server_call_completion_queue, self.server_completion_queue, server_request_call_tag) self.server_driver.add_due({ server_request_call_tag, }) client_receive_initial_metadata_tag = 'client_receive_initial_metadata_tag' client_complete_rpc_tag = 'client_complete_rpc_tag' client_call = self.channel.integrated_call( _common.EMPTY_FLAGS, b'/twinkies', None, None, _common.INVOCATION_METADATA, None, [( [ cygrpc.ReceiveInitialMetadataOperation(_common.EMPTY_FLAGS), ], client_receive_initial_metadata_tag, )]) client_call.operate([ cygrpc.SendInitialMetadataOperation(_common.INVOCATION_METADATA, _common.EMPTY_FLAGS), cygrpc.SendCloseFromClientOperation(_common.EMPTY_FLAGS), cygrpc.ReceiveStatusOnClientOperation(_common.EMPTY_FLAGS), ], client_complete_rpc_tag) client_events_future = test_utilities.SimpleFuture(lambda: [ self.channel.next_call_event(), self.channel.next_call_event(), ]) server_request_call_event = self.server_driver.event_with_tag( server_request_call_tag) with server_call_condition: server_send_initial_metadata_start_batch_result = ( server_request_call_event.call.start_server_batch([ cygrpc.SendInitialMetadataOperation( _common.INITIAL_METADATA, _common.EMPTY_FLAGS), ], server_send_initial_metadata_tag)) server_call_driver.add_due({ server_send_initial_metadata_tag, }) server_send_initial_metadata_event = server_call_driver.event_with_tag( server_send_initial_metadata_tag) with server_call_condition: server_complete_rpc_start_batch_result = ( server_request_call_event.call.start_server_batch([ cygrpc.ReceiveCloseOnServerOperation(_common.EMPTY_FLAGS), cygrpc.SendStatusFromServerOperation( _common.TRAILING_METADATA, cygrpc.StatusCode.ok, b'test details', _common.EMPTY_FLAGS), ], server_complete_rpc_tag)) server_call_driver.add_due({ server_complete_rpc_tag, }) server_complete_rpc_event = server_call_driver.event_with_tag( server_complete_rpc_tag) client_events = client_events_future.result() if client_events[0].tag is client_receive_initial_metadata_tag: client_receive_initial_metadata_event = client_events[0] client_complete_rpc_event = client_events[1] else: client_complete_rpc_event = client_events[0] client_receive_initial_metadata_event = client_events[1] return ( _common.OperationResult(server_request_call_start_batch_result, server_request_call_event.completion_type, server_request_call_event.success), _common.OperationResult( cygrpc.CallError.ok, client_receive_initial_metadata_event.completion_type, client_receive_initial_metadata_event.success), _common.OperationResult(cygrpc.CallError.ok, client_complete_rpc_event.completion_type, client_complete_rpc_event.success), _common.OperationResult( server_send_initial_metadata_start_batch_result, server_send_initial_metadata_event.completion_type, server_send_initial_metadata_event.success), _common.OperationResult(server_complete_rpc_start_batch_result, server_complete_rpc_event.completion_type, server_complete_rpc_event.success), )
def __init__(self, channel): self.lock = threading.Lock() self.channel = channel self.completion_queue = cygrpc.CompletionQueue() self.managed_calls = None
def _do_rpcs(self): server_call_condition = threading.Condition() server_call_completion_queue = cygrpc.CompletionQueue() server_call_driver = _common.QueueDriver(server_call_condition, server_call_completion_queue) server_request_call_tag = 'server_request_call_tag' server_send_initial_metadata_tag = 'server_send_initial_metadata_tag' server_complete_rpc_tag = 'server_complete_rpc_tag' with self.server_condition: server_request_call_start_batch_result = self.server.request_call( server_call_completion_queue, self.server_completion_queue, server_request_call_tag) self.server_driver.add_due({ server_request_call_tag, }) client_call = self.channel.create_call(None, _common.EMPTY_FLAGS, self.client_completion_queue, b'/twinkies', None, None) client_receive_initial_metadata_tag = 'client_receive_initial_metadata_tag' client_complete_rpc_tag = 'client_complete_rpc_tag' with self.client_condition: client_receive_initial_metadata_start_batch_result = ( client_call.start_client_batch([ cygrpc.ReceiveInitialMetadataOperation(_common.EMPTY_FLAGS), ], client_receive_initial_metadata_tag)) self.assertEqual(cygrpc.CallError.ok, client_receive_initial_metadata_start_batch_result) client_complete_rpc_start_batch_result = client_call.start_client_batch( [ cygrpc.SendInitialMetadataOperation( _common.INVOCATION_METADATA, _common.EMPTY_FLAGS), cygrpc.SendCloseFromClientOperation(_common.EMPTY_FLAGS), cygrpc.ReceiveStatusOnClientOperation(_common.EMPTY_FLAGS), ], client_complete_rpc_tag) self.assertEqual(cygrpc.CallError.ok, client_complete_rpc_start_batch_result) self.client_driver.add_due({ client_receive_initial_metadata_tag, client_complete_rpc_tag, }) server_request_call_event = self.server_driver.event_with_tag( server_request_call_tag) with server_call_condition: server_send_initial_metadata_start_batch_result = ( server_request_call_event.call.start_server_batch([ cygrpc.SendInitialMetadataOperation( _common.INITIAL_METADATA, _common.EMPTY_FLAGS), ], server_send_initial_metadata_tag)) server_call_driver.add_due({ server_send_initial_metadata_tag, }) server_send_initial_metadata_event = server_call_driver.event_with_tag( server_send_initial_metadata_tag) with server_call_condition: server_complete_rpc_start_batch_result = ( server_request_call_event.call.start_server_batch([ cygrpc.ReceiveCloseOnServerOperation(_common.EMPTY_FLAGS), cygrpc.SendStatusFromServerOperation( _common.TRAILING_METADATA, cygrpc.StatusCode.ok, b'test details', _common.EMPTY_FLAGS), ], server_complete_rpc_tag)) server_call_driver.add_due({ server_complete_rpc_tag, }) server_complete_rpc_event = server_call_driver.event_with_tag( server_complete_rpc_tag) client_receive_initial_metadata_event = self.client_driver.event_with_tag( client_receive_initial_metadata_tag) client_complete_rpc_event = self.client_driver.event_with_tag( client_complete_rpc_tag) return ( _common.OperationResult(server_request_call_start_batch_result, server_request_call_event.completion_type, server_request_call_event.success), _common.OperationResult( client_receive_initial_metadata_start_batch_result, client_receive_initial_metadata_event.completion_type, client_receive_initial_metadata_event.success), _common.OperationResult(client_complete_rpc_start_batch_result, client_complete_rpc_event.completion_type, client_complete_rpc_event.success), _common.OperationResult( server_send_initial_metadata_start_batch_result, server_send_initial_metadata_event.completion_type, server_send_initial_metadata_event.success), _common.OperationResult(server_complete_rpc_start_batch_result, server_complete_rpc_event.completion_type, server_complete_rpc_event.success), )
def __init__(self, thread_pool, generic_handlers): completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server() server.register_completion_queue(completion_queue) self._state = _ServerState(completion_queue, server, generic_handlers, thread_pool)
def __init__(self): self.completion_queue = cygrpc.CompletionQueue()
def _do_rpcs(self): server_call_condition = threading.Condition() server_call_completion_queue = cygrpc.CompletionQueue() server_call_driver = _common.QueueDriver(server_call_condition, server_call_completion_queue) server_request_call_tag = 'server_request_call_tag' server_send_initial_metadata_tag = 'server_send_initial_metadata_tag' server_complete_rpc_tag = 'server_complete_rpc_tag' with self.server_condition: server_request_call_start_batch_result = self.server.request_call( server_call_completion_queue, self.server_completion_queue, server_request_call_tag) self.server_driver.add_due({ server_request_call_tag, }) client_call = self.channel.create_call( None, _common.EMPTY_FLAGS, self.client_completion_queue, b'/twinkies', None, _common.INFINITE_FUTURE) client_receive_initial_metadata_tag = 'client_receive_initial_metadata_tag' client_complete_rpc_tag = 'client_complete_rpc_tag' with self.client_condition: client_receive_initial_metadata_start_batch_result = ( client_call.start_client_batch([ cygrpc.operation_receive_initial_metadata( _common.EMPTY_FLAGS), ], client_receive_initial_metadata_tag)) client_complete_rpc_start_batch_result = client_call.start_client_batch( [ cygrpc.operation_send_initial_metadata( _common.INVOCATION_METADATA, _common.EMPTY_FLAGS), cygrpc.operation_send_close_from_client( _common.EMPTY_FLAGS), cygrpc.operation_receive_status_on_client( _common.EMPTY_FLAGS), ], client_complete_rpc_tag) self.client_driver.add_due({ client_receive_initial_metadata_tag, client_complete_rpc_tag, }) server_request_call_event = self.server_driver.event_with_tag( server_request_call_tag) with server_call_condition: server_send_initial_metadata_start_batch_result = ( server_request_call_event.operation_call.start_server_batch([ cygrpc.operation_send_initial_metadata( _common.INITIAL_METADATA, _common.EMPTY_FLAGS), ], server_send_initial_metadata_tag)) server_call_driver.add_due({ server_send_initial_metadata_tag, }) server_send_initial_metadata_event = server_call_driver.event_with_tag( server_send_initial_metadata_tag) with server_call_condition: server_complete_rpc_start_batch_result = ( server_request_call_event.operation_call.start_server_batch([ cygrpc.operation_receive_close_on_server( _common.EMPTY_FLAGS), cygrpc.operation_send_status_from_server( _common.TRAILING_METADATA, cygrpc.StatusCode.ok, b'test details', _common.EMPTY_FLAGS), ], server_complete_rpc_tag)) server_call_driver.add_due({ server_complete_rpc_tag, }) server_complete_rpc_event = server_call_driver.event_with_tag( server_complete_rpc_tag) client_receive_initial_metadata_event = self.client_driver.event_with_tag( client_receive_initial_metadata_tag) client_complete_rpc_event = self.client_driver.event_with_tag( client_complete_rpc_tag) return (_common.OperationResult(server_request_call_start_batch_result, server_request_call_event.type, server_request_call_event.success), _common.OperationResult( client_receive_initial_metadata_start_batch_result, client_receive_initial_metadata_event.type, client_receive_initial_metadata_event.success), _common.OperationResult(client_complete_rpc_start_batch_result, client_complete_rpc_event.type, client_complete_rpc_event.success), _common.OperationResult( server_send_initial_metadata_start_batch_result, server_send_initial_metadata_event.type, server_send_initial_metadata_event.success), _common.OperationResult(server_complete_rpc_start_batch_result, server_complete_rpc_event.type, server_complete_rpc_event.success),)
def testCompletionQueueUpDown(self): completion_queue = cygrpc.CompletionQueue() del completion_queue
def testReadSomeButNotAllResponses(self): server_completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server([( b'grpc.so_reuseport', 0, )]) server.register_completion_queue(server_completion_queue) port = server.add_http2_port(b'[::]:0') server.start() channel = cygrpc.Channel('localhost:{}'.format(port).encode(), set(), None) server_shutdown_tag = 'server_shutdown_tag' server_driver = _ServerDriver(server_completion_queue, server_shutdown_tag) server_driver.start() client_condition = threading.Condition() client_due = set() server_call_condition = threading.Condition() server_send_initial_metadata_tag = 'server_send_initial_metadata_tag' server_send_first_message_tag = 'server_send_first_message_tag' server_send_second_message_tag = 'server_send_second_message_tag' server_complete_rpc_tag = 'server_complete_rpc_tag' server_call_due = set(( server_send_initial_metadata_tag, server_send_first_message_tag, server_send_second_message_tag, server_complete_rpc_tag, )) server_call_completion_queue = cygrpc.CompletionQueue() server_call_driver = _QueueDriver(server_call_condition, server_call_completion_queue, server_call_due) server_call_driver.start() server_rpc_tag = 'server_rpc_tag' request_call_result = server.request_call(server_call_completion_queue, server_completion_queue, server_rpc_tag) client_receive_initial_metadata_tag = 'client_receive_initial_metadata_tag' client_complete_rpc_tag = 'client_complete_rpc_tag' client_call = channel.segregated_call( _EMPTY_FLAGS, b'/twinkies', None, None, _EMPTY_METADATA, None, ( ( [ cygrpc.ReceiveInitialMetadataOperation(_EMPTY_FLAGS), ], client_receive_initial_metadata_tag, ), ( [ cygrpc.SendInitialMetadataOperation( _EMPTY_METADATA, _EMPTY_FLAGS), cygrpc.SendCloseFromClientOperation(_EMPTY_FLAGS), cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS), ], client_complete_rpc_tag, ), )) client_receive_initial_metadata_event_future = test_utilities.SimpleFuture( client_call.next_event) server_rpc_event = server_driver.first_event() with server_call_condition: server_send_initial_metadata_start_batch_result = ( server_rpc_event.call.start_server_batch([ cygrpc.SendInitialMetadataOperation( _EMPTY_METADATA, _EMPTY_FLAGS), ], server_send_initial_metadata_tag)) server_send_first_message_start_batch_result = ( server_rpc_event.call.start_server_batch([ cygrpc.SendMessageOperation(b'\x07', _EMPTY_FLAGS), ], server_send_first_message_tag)) server_send_initial_metadata_event = server_call_driver.event_with_tag( server_send_initial_metadata_tag) server_send_first_message_event = server_call_driver.event_with_tag( server_send_first_message_tag) with server_call_condition: server_send_second_message_start_batch_result = ( server_rpc_event.call.start_server_batch([ cygrpc.SendMessageOperation(b'\x07', _EMPTY_FLAGS), ], server_send_second_message_tag)) server_complete_rpc_start_batch_result = ( server_rpc_event.call.start_server_batch([ cygrpc.ReceiveCloseOnServerOperation(_EMPTY_FLAGS), cygrpc.SendStatusFromServerOperation( (), cygrpc.StatusCode.ok, b'test details', _EMPTY_FLAGS), ], server_complete_rpc_tag)) server_send_second_message_event = server_call_driver.event_with_tag( server_send_second_message_tag) server_complete_rpc_event = server_call_driver.event_with_tag( server_complete_rpc_tag) server_call_driver.events() client_recieve_initial_metadata_event = client_receive_initial_metadata_event_future.result( ) client_receive_first_message_tag = 'client_receive_first_message_tag' client_call.operate([ cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS), ], client_receive_first_message_tag) client_receive_first_message_event = client_call.next_event() client_call_cancel_result = client_call.cancel( cygrpc.StatusCode.cancelled, 'Cancelled during test!') client_complete_rpc_event = client_call.next_event() channel.close(cygrpc.StatusCode.unknown, 'Channel closed!') server.shutdown(server_completion_queue, server_shutdown_tag) server.cancel_all_calls() server_driver.events() self.assertEqual(cygrpc.CallError.ok, request_call_result) self.assertEqual(cygrpc.CallError.ok, server_send_initial_metadata_start_batch_result) self.assertIs(server_rpc_tag, server_rpc_event.tag) self.assertEqual(cygrpc.CompletionType.operation_complete, server_rpc_event.completion_type) self.assertIsInstance(server_rpc_event.call, cygrpc.Call)
def testCancelManyCalls(self): server_thread_pool = logging_pool.pool( test_constants.THREAD_CONCURRENCY) server_completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server([( b'grpc.so_reuseport', 0, )], False) server.register_completion_queue(server_completion_queue) port = server.add_http2_port(b'[::]:0') server.start() channel = cygrpc.Channel('localhost:{}'.format(port).encode(), None, None) state = _State() server_thread_args = ( state, server, server_completion_queue, server_thread_pool, ) server_thread = threading.Thread(target=_serve, args=server_thread_args) server_thread.start() client_condition = threading.Condition() client_due = set() with client_condition: client_calls = [] for index in range(test_constants.RPC_CONCURRENCY): tag = 'client_complete_call_{0:04d}_tag'.format(index) client_call = channel.integrated_call( _EMPTY_FLAGS, b'/twinkies', None, None, _EMPTY_METADATA, None, (( ( cygrpc.SendInitialMetadataOperation( _EMPTY_METADATA, _EMPTY_FLAGS), cygrpc.SendMessageOperation( b'\x45\x56', _EMPTY_FLAGS), cygrpc.SendCloseFromClientOperation(_EMPTY_FLAGS), cygrpc.ReceiveInitialMetadataOperation( _EMPTY_FLAGS), cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS), cygrpc.ReceiveStatusOnClientOperation( _EMPTY_FLAGS), ), tag, ), )) client_due.add(tag) client_calls.append(client_call) client_events_future = test_utilities.SimpleFuture(lambda: tuple( channel.next_call_event() for _ in range(_SUCCESSFUL_CALLS))) with state.condition: while True: if state.parked_handlers < test_constants.THREAD_CONCURRENCY: state.condition.wait() elif state.handled_rpcs < test_constants.RPC_CONCURRENCY: state.condition.wait() else: state.handlers_released = True state.condition.notify_all() break client_events_future.result() with client_condition: for client_call in client_calls: client_call.cancel(cygrpc.StatusCode.cancelled, 'Cancelled!') for _ in range(_UNSUCCESSFUL_CALLS): channel.next_call_event() channel.close(cygrpc.StatusCode.unknown, 'Cancelled on channel close!') with state.condition: server.shutdown(server_completion_queue, _SERVER_SHUTDOWN_TAG)
def _channel_and_completion_queue(): channel = cygrpc.Channel('localhost:54321', cygrpc.ChannelArgs(())) completion_queue = cygrpc.CompletionQueue() return channel, completion_queue
def testCancelManyCalls(self): server_thread_pool = logging_pool.pool( test_constants.THREAD_CONCURRENCY) server_completion_queue = cygrpc.CompletionQueue() server = cygrpc.Server( cygrpc.ChannelArgs([cygrpc.ChannelArg(b'grpc.so_reuseport', 0)])) server.register_completion_queue(server_completion_queue) port = server.add_http2_port(b'[::]:0') server.start() channel = cygrpc.Channel('localhost:{}'.format(port).encode(), cygrpc.ChannelArgs([])) state = _State() server_thread_args = ( state, server, server_completion_queue, server_thread_pool, ) server_thread = threading.Thread(target=_serve, args=server_thread_args) server_thread.start() client_condition = threading.Condition() client_due = set() client_completion_queue = cygrpc.CompletionQueue() client_driver = _QueueDriver(client_condition, client_completion_queue, client_due) client_driver.start() with client_condition: client_calls = [] for index in range(test_constants.RPC_CONCURRENCY): client_call = channel.create_call(None, _EMPTY_FLAGS, client_completion_queue, b'/twinkies', None, _INFINITE_FUTURE) operations = ( cygrpc.operation_send_initial_metadata( _EMPTY_METADATA, _EMPTY_FLAGS), cygrpc.operation_send_message(b'\x45\x56', _EMPTY_FLAGS), cygrpc.operation_send_close_from_client(_EMPTY_FLAGS), cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS), cygrpc.operation_receive_message(_EMPTY_FLAGS), cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS), ) tag = 'client_complete_call_{0:04d}_tag'.format(index) client_call.start_client_batch(operations, tag) client_due.add(tag) client_calls.append(client_call) with state.condition: while True: if state.parked_handlers < test_constants.THREAD_CONCURRENCY: state.condition.wait() elif state.handled_rpcs < test_constants.RPC_CONCURRENCY: state.condition.wait() else: state.handlers_released = True state.condition.notify_all() break client_driver.events(test_constants.RPC_CONCURRENCY * _SUCCESS_CALL_FRACTION) with client_condition: for client_call in client_calls: client_call.cancel() with state.condition: server.shutdown(server_completion_queue, _SERVER_SHUTDOWN_TAG)