Exemple #1
0
 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
Exemple #2
0
 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))
Exemple #3
0
 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)
Exemple #4
0
    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
Exemple #5
0
 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
Exemple #6
0
 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
Exemple #7
0
 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)
Exemple #8
0
 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
Exemple #10
0
    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)
Exemple #12
0
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()
Exemple #13
0
    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)
Exemple #14
0
 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
Exemple #15
0
 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
Exemple #16
0
    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
Exemple #17
0
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)
Exemple #18
0
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))
Exemple #20
0
    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),
        )
Exemple #21
0
 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),
        )
Exemple #23
0
 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)
Exemple #24
0
 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),)
Exemple #26
0
 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)
Exemple #29
0
def _channel_and_completion_queue():
    channel = cygrpc.Channel('localhost:54321', cygrpc.ChannelArgs(()))
    completion_queue = cygrpc.CompletionQueue()
    return channel, completion_queue
Exemple #30
0
    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)