Beispiel #1
0
 def start_batch(self, ops, tag):
   translated_ops = []
   for op in ops:
     if op.type == _types.OpType.SEND_INITIAL_METADATA:
       translated_op = cygrpc.operation_send_initial_metadata(
           cygrpc.Metadata(
               cygrpc.Metadatum(key, value)
               for key, value in op.initial_metadata),
           op.flags)
     elif op.type == _types.OpType.SEND_MESSAGE:
       translated_op = cygrpc.operation_send_message(op.message, op.flags)
     elif op.type == _types.OpType.SEND_CLOSE_FROM_CLIENT:
       translated_op = cygrpc.operation_send_close_from_client(op.flags)
     elif op.type == _types.OpType.SEND_STATUS_FROM_SERVER:
       translated_op = cygrpc.operation_send_status_from_server(
           cygrpc.Metadata(
               cygrpc.Metadatum(key, value)
               for key, value in op.trailing_metadata),
           op.status.code,
           op.status.details,
           op.flags)
     elif op.type == _types.OpType.RECV_INITIAL_METADATA:
       translated_op = cygrpc.operation_receive_initial_metadata(
           op.flags)
     elif op.type == _types.OpType.RECV_MESSAGE:
       translated_op = cygrpc.operation_receive_message(op.flags)
     elif op.type == _types.OpType.RECV_STATUS_ON_CLIENT:
       translated_op = cygrpc.operation_receive_status_on_client(
           op.flags)
     elif op.type == _types.OpType.RECV_CLOSE_ON_SERVER:
       translated_op = cygrpc.operation_receive_close_on_server(op.flags)
     else:
       raise ValueError('unexpected operation type {}'.format(op.type))
     translated_ops.append(translated_op)
   return self.call.start_batch(cygrpc.Operations(translated_ops), tag)
Beispiel #2
0
    def __call__(self):
        with self._state.condition:
            self._state.parked_handlers += 1
            if self._state.parked_handlers == test_constants.THREAD_CONCURRENCY:
                self._state.condition.notify_all()
            while not self._state.handlers_released:
                self._state.condition.wait()

        with self._lock:
            self._call.start_server_batch(
                (cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS), ),
                _RECEIVE_CLOSE_ON_SERVER_TAG)
            self._call.start_server_batch(
                (cygrpc.operation_receive_message(_EMPTY_FLAGS), ),
                _RECEIVE_MESSAGE_TAG)
        first_event = self._completion_queue.poll()
        if _is_cancellation_event(first_event):
            self._completion_queue.poll()
        else:
            with self._lock:
                operations = (
                    cygrpc.operation_send_initial_metadata(
                        _EMPTY_METADATA, _EMPTY_FLAGS),
                    cygrpc.operation_send_message(b'\x79\x57', _EMPTY_FLAGS),
                    cygrpc.operation_send_status_from_server(
                        _EMPTY_METADATA, cygrpc.StatusCode.ok,
                        b'test details!', _EMPTY_FLAGS),
                )
                self._call.start_server_batch(operations,
                                              _SERVER_COMPLETE_CALL_TAG)
            self._completion_queue.poll()
            self._completion_queue.poll()
Beispiel #3
0
 def __call__(self, request, timeout=None, metadata=None, credentials=None):
     deadline, deadline_timespec, serialized_request, rendezvous = (
         _start_unary_request(request, timeout, self._request_serializer))
     if serialized_request is None:
         raise rendezvous
     else:
         state = _RPCState(_UNARY_STREAM_INITIAL_DUE, None, None, None,
                           None)
         call = self._create_managed_call(None, 0, self._method, None,
                                          deadline_timespec)
         if credentials is not None:
             call.set_credentials(credentials._credentials)
         event_handler = _event_handler(state, call,
                                        self._response_deserializer)
         with state.condition:
             call.start_client_batch(
                 cygrpc.Operations(
                     (cygrpc.operation_receive_initial_metadata(
                         _EMPTY_FLAGS), )), event_handler)
             operations = (
                 cygrpc.operation_send_initial_metadata(
                     _common.cygrpc_metadata(metadata), _EMPTY_FLAGS),
                 cygrpc.operation_send_message(serialized_request,
                                               _EMPTY_FLAGS),
                 cygrpc.operation_send_close_from_client(_EMPTY_FLAGS),
                 cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS),
             )
             call.start_client_batch(cygrpc.Operations(operations),
                                     event_handler)
         return _Rendezvous(state, call, self._response_deserializer,
                            deadline)
Beispiel #4
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
Beispiel #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.start_client_batch(cygrpc.Operations(operations), None)
     _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
Beispiel #6
0
 def __call__(self,
              request_iterator,
              timeout=None,
              metadata=None,
              credentials=None):
     deadline, deadline_timespec = _deadline(timeout)
     state = _RPCState(_STREAM_STREAM_INITIAL_DUE, None, None, None, None)
     call, drive_call = self._managed_call(None, 0, self._method, None,
                                           deadline_timespec)
     if credentials is not None:
         call.set_credentials(credentials._credentials)
     event_handler = _event_handler(state, call,
                                    self._response_deserializer)
     with state.condition:
         call.start_client_batch(
             cygrpc.Operations(
                 (cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS),
                  )), event_handler)
         operations = (
             cygrpc.operation_send_initial_metadata(
                 _common.cygrpc_metadata(metadata), _EMPTY_FLAGS),
             cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS),
         )
         call_error = call.start_client_batch(cygrpc.Operations(operations),
                                              event_handler)
         if call_error != cygrpc.CallError.ok:
             _call_error_set_RPCstate(state, call_error, metadata)
             return _Rendezvous(state, None, None, deadline)
         drive_call()
         _consume_request_iterator(request_iterator, state, call,
                                   self._request_serializer)
     return _Rendezvous(state, call, self._response_deserializer, deadline)
    def __call__(self):
        with self._state.condition:
            self._state.parked_handlers += 1
            if self._state.parked_handlers == test_constants.THREAD_CONCURRENCY:
                self._state.condition.notify_all()
            while not self._state.handlers_released:
                self._state.condition.wait()

        with self._lock:
            self._call.start_server_batch(
                cygrpc.Operations(
                    (cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS),)),
                _RECEIVE_CLOSE_ON_SERVER_TAG)
            self._call.start_server_batch(
                cygrpc.Operations(
                    (cygrpc.operation_receive_message(_EMPTY_FLAGS),)),
                _RECEIVE_MESSAGE_TAG)
        first_event = self._completion_queue.poll()
        if _is_cancellation_event(first_event):
            self._completion_queue.poll()
        else:
            with self._lock:
                operations = (
                    cygrpc.operation_send_initial_metadata(_EMPTY_METADATA,
                                                           _EMPTY_FLAGS),
                    cygrpc.operation_send_message(b'\x79\x57', _EMPTY_FLAGS),
                    cygrpc.operation_send_status_from_server(
                        _EMPTY_METADATA, cygrpc.StatusCode.ok, b'test details!',
                        _EMPTY_FLAGS),)
                self._call.start_server_batch(
                    cygrpc.Operations(operations), _SERVER_COMPLETE_CALL_TAG)
            self._completion_queue.poll()
            self._completion_queue.poll()
Beispiel #8
0
 def start_batch(self, ops, tag):
     translated_ops = []
     for op in ops:
         if op.type == _types.OpType.SEND_INITIAL_METADATA:
             translated_op = cygrpc.operation_send_initial_metadata(
                 cygrpc.Metadata(
                     cygrpc.Metadatum(key, value)
                     for key, value in op.initial_metadata))
         elif op.type == _types.OpType.SEND_MESSAGE:
             translated_op = cygrpc.operation_send_message(op.message)
         elif op.type == _types.OpType.SEND_CLOSE_FROM_CLIENT:
             translated_op = cygrpc.operation_send_close_from_client()
         elif op.type == _types.OpType.SEND_STATUS_FROM_SERVER:
             translated_op = cygrpc.operation_send_status_from_server(
                 cygrpc.Metadata(
                     cygrpc.Metadatum(key, value)
                     for key, value in op.trailing_metadata),
                 op.status.code, op.status.details)
         elif op.type == _types.OpType.RECV_INITIAL_METADATA:
             translated_op = cygrpc.operation_receive_initial_metadata()
         elif op.type == _types.OpType.RECV_MESSAGE:
             translated_op = cygrpc.operation_receive_message()
         elif op.type == _types.OpType.RECV_STATUS_ON_CLIENT:
             translated_op = cygrpc.operation_receive_status_on_client()
         elif op.type == _types.OpType.RECV_CLOSE_ON_SERVER:
             translated_op = cygrpc.operation_receive_close_on_server()
         else:
             raise ValueError('unexpected operation type {}'.format(
                 op.type))
         translated_ops.append(translated_op)
     return self.call.start_batch(cygrpc.Operations(translated_ops), tag)
Beispiel #9
0
def _send_response(rpc_event, state, serialized_response):
    with state.condition:
        if state.client is _CANCELLED or state.statused:
            return False
        else:
            if state.initial_metadata_allowed:
                operations = (
                    cygrpc.operation_send_initial_metadata(
                        _common.EMPTY_METADATA, _EMPTY_FLAGS),
                    cygrpc.operation_send_message(serialized_response,
                                                  _EMPTY_FLAGS),
                )
                state.initial_metadata_allowed = False
                token = _SEND_INITIAL_METADATA_AND_SEND_MESSAGE_TOKEN
            else:
                operations = (cygrpc.operation_send_message(
                    serialized_response, _EMPTY_FLAGS), )
                token = _SEND_MESSAGE_TOKEN
            rpc_event.operation_call.start_server_batch(
                cygrpc.Operations(operations), _send_message(state, token))
            state.due.add(token)
            while True:
                state.condition.wait()
                if token not in state.due:
                    return state.client is not _CANCELLED and not state.statused
Beispiel #10
0
 def __call__(self, request, timeout=None, metadata=None, credentials=None):
   deadline, deadline_timespec, serialized_request, rendezvous = (
       _start_unary_request(request, timeout, self._request_serializer))
   if serialized_request is None:
     raise rendezvous
   else:
     state = _RPCState(_UNARY_STREAM_INITIAL_DUE, None, None, None, None)
     call = self._create_managed_call(
         None, 0, self._method, None, deadline_timespec)
     if credentials is not None:
       call.set_credentials(credentials._credentials)
     event_handler = _event_handler(state, call, self._response_deserializer)
     with state.condition:
       call.start_client_batch(
           cygrpc.Operations(
               (cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS),)),
           event_handler)
       operations = (
           cygrpc.operation_send_initial_metadata(
               _common.cygrpc_metadata(metadata), _EMPTY_FLAGS),
           cygrpc.operation_send_message(serialized_request, _EMPTY_FLAGS),
           cygrpc.operation_send_close_from_client(_EMPTY_FLAGS),
           cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS),
       )
       call.start_client_batch(cygrpc.Operations(operations), event_handler)
     return _Rendezvous(state, call, self._response_deserializer, deadline)
Beispiel #11
0
def _status(rpc_event, state, serialized_response):
    with state.condition:
        if state.client is not _CANCELLED:
            trailing_metadata = _common.cygrpc_metadata(
                state.trailing_metadata)
            code = _completion_code(state)
            details = _details(state)
            operations = [
                cygrpc.operation_send_status_from_server(
                    trailing_metadata, code, details, _EMPTY_FLAGS),
            ]
            if state.initial_metadata_allowed:
                operations.append(
                    cygrpc.operation_send_initial_metadata(
                        _common.EMPTY_METADATA, _EMPTY_FLAGS))
            if serialized_response is not None:
                operations.append(
                    cygrpc.operation_send_message(serialized_response,
                                                  _EMPTY_FLAGS))
            rpc_event.operation_call.start_server_batch(
                cygrpc.Operations(operations),
                _send_status_from_server(state,
                                         _SEND_STATUS_FROM_SERVER_TOKEN))
            state.statused = True
            state.due.add(_SEND_STATUS_FROM_SERVER_TOKEN)
Beispiel #12
0
def _abort(state, call, code, details):
  if state.client is not _CANCELLED:
    effective_code = _abortion_code(state, code)
    effective_details = details if state.details is None else state.details
    if state.initial_metadata_allowed:
      operations = (
          cygrpc.operation_send_initial_metadata(
              _EMPTY_METADATA, _EMPTY_FLAGS),
          cygrpc.operation_send_status_from_server(
              _common.cygrpc_metadata(state.trailing_metadata), effective_code,
              effective_details, _EMPTY_FLAGS),
      )
      token = _SEND_INITIAL_METADATA_AND_SEND_STATUS_FROM_SERVER_TOKEN
    else:
      operations = (
          cygrpc.operation_send_status_from_server(
              _common.cygrpc_metadata(state.trailing_metadata), effective_code,
              effective_details, _EMPTY_FLAGS),
      )
      token = _SEND_STATUS_FROM_SERVER_TOKEN
    call.start_server_batch(
        cygrpc.Operations(operations),
        _send_status_from_server(state, token))
    state.statused = True
    state.due.add(token)
Beispiel #13
0
 def __call__(self,
              request_iterator,
              timeout=None,
              metadata=None,
              credentials=None):
     deadline, deadline_timespec = _deadline(timeout)
     state = _RPCState(_STREAM_STREAM_INITIAL_DUE, None, None, None, None)
     call, drive_call = self._managed_call(None, 0, self._method, None,
                                           deadline_timespec)
     if credentials is not None:
         call.set_credentials(credentials._credentials)
     event_handler = _event_handler(state, call, self._response_deserializer)
     with state.condition:
         call.start_client_batch(
             cygrpc.Operations(
                 (cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS),)),
             event_handler)
         operations = (
             cygrpc.operation_send_initial_metadata(
                 _common.cygrpc_metadata(metadata), _EMPTY_FLAGS),
             cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS),)
         call_error = call.start_client_batch(
             cygrpc.Operations(operations), event_handler)
         if call_error != cygrpc.CallError.ok:
             _call_error_set_RPCstate(state, call_error, metadata)
             return _Rendezvous(state, None, None, deadline)
         drive_call()
         _consume_request_iterator(request_iterator, state, call,
                                   self._request_serializer)
     return _Rendezvous(state, call, self._response_deserializer, deadline)
Beispiel #14
0
def _send_response(rpc_event, state, serialized_response):
  with state.condition:
    if state.client is _CANCELLED or state.statused:
      return False
    else:
      if state.initial_metadata_allowed:
        operations = (
            cygrpc.operation_send_initial_metadata(
                _EMPTY_METADATA, _EMPTY_FLAGS),
            cygrpc.operation_send_message(serialized_response, _EMPTY_FLAGS),
        )
        state.initial_metadata_allowed = False
        token = _SEND_INITIAL_METADATA_AND_SEND_MESSAGE_TOKEN
      else:
        operations = (
            cygrpc.operation_send_message(serialized_response, _EMPTY_FLAGS),
        )
        token = _SEND_MESSAGE_TOKEN
      rpc_event.operation_call.start_server_batch(
          cygrpc.Operations(operations), _send_message(state, token))
      state.due.add(token)
      while True:
        state.condition.wait()
        if token not in state.due:
          return state.client is not _CANCELLED and not state.statused
Beispiel #15
0
def _abort(state, call, code, details):
  if state.client is not _CANCELLED:
    effective_code = _abortion_code(state, code)
    effective_details = details if state.details is None else state.details
    if state.initial_metadata_allowed:
      operations = (
          cygrpc.operation_send_initial_metadata(
              _EMPTY_METADATA, _EMPTY_FLAGS),
          cygrpc.operation_send_status_from_server(
              _common.cygrpc_metadata(state.trailing_metadata), effective_code,
              effective_details, _EMPTY_FLAGS),
      )
      token = _SEND_INITIAL_METADATA_AND_SEND_STATUS_FROM_SERVER_TOKEN
    else:
      operations = (
          cygrpc.operation_send_status_from_server(
              _common.cygrpc_metadata(state.trailing_metadata), effective_code,
              effective_details, _EMPTY_FLAGS),
      )
      token = _SEND_STATUS_FROM_SERVER_TOKEN
    call.start_server_batch(
        cygrpc.Operations(operations),
        _send_status_from_server(state, token))
    state.statused = True
    state.due.add(token)
Beispiel #16
0
    def testCancelManyCalls(self):
        server_thread_pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY)

        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([]))

        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(cygrpc.Operations(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)
Beispiel #17
0
def _reject_rpc(rpc_event, status, details):
    operations = (cygrpc.operation_send_initial_metadata((), _EMPTY_FLAGS),
                  cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS),
                  cygrpc.operation_send_status_from_server((), status, details,
                                                           _EMPTY_FLAGS),)
    rpc_state = _RPCState()
    rpc_event.operation_call.start_server_batch(
        operations, lambda ignored_event: (rpc_state, (),))
    return rpc_state
Beispiel #18
0
def _handle_unrecognized_method(rpc_event):
  operations = (
      cygrpc.operation_send_initial_metadata(_EMPTY_METADATA, _EMPTY_FLAGS),
      cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS),
      cygrpc.operation_send_status_from_server(
          _EMPTY_METADATA, cygrpc.StatusCode.unimplemented,
          b'Method not found!', _EMPTY_FLAGS),
  )
  rpc_state = _RPCState()
  rpc_event.operation_call.start_server_batch(
      operations, lambda ignored_event: (rpc_state, (),))
  return rpc_state
Beispiel #19
0
def _handle_unrecognized_method(rpc_event):
  operations = (
      cygrpc.operation_send_initial_metadata(_EMPTY_METADATA, _EMPTY_FLAGS),
      cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS),
      cygrpc.operation_send_status_from_server(
          _EMPTY_METADATA, cygrpc.StatusCode.unimplemented,
          b'Method not found!', _EMPTY_FLAGS),
  )
  rpc_state = _RPCState()
  rpc_event.operation_call.start_server_batch(
      operations, lambda ignored_event: (rpc_state, (),))
  return rpc_state
Beispiel #20
0
 def send_initial_metadata(self, initial_metadata):
     with self._state.condition:
         if self._state.client is _CANCELLED:
             _raise_rpc_error(self._state)
         else:
             if self._state.initial_metadata_allowed:
                 operation = cygrpc.operation_send_initial_metadata(
                     initial_metadata, _EMPTY_FLAGS)
                 self._rpc_event.operation_call.start_server_batch(
                     (operation,), _send_initial_metadata(self._state))
                 self._state.initial_metadata_allowed = False
                 self._state.due.add(_SEND_INITIAL_METADATA_TOKEN)
             else:
                 raise ValueError('Initial metadata no longer allowed!')
Beispiel #21
0
 def send_initial_metadata(self, initial_metadata):
     with self._state.condition:
         if self._state.client is _CANCELLED:
             _raise_rpc_error(self._state)
         else:
             if self._state.initial_metadata_allowed:
                 operation = cygrpc.operation_send_initial_metadata(
                     initial_metadata, _EMPTY_FLAGS)
                 self._rpc_event.operation_call.start_server_batch(
                     (operation, ), _send_initial_metadata(self._state))
                 self._state.initial_metadata_allowed = False
                 self._state.due.add(_SEND_INITIAL_METADATA_TOKEN)
             else:
                 raise ValueError('Initial metadata no longer allowed!')
Beispiel #22
0
 def _prepare(self, request, timeout, metadata):
     deadline, deadline_timespec, serialized_request, rendezvous = (
         _start_unary_request(request, timeout, self._request_serializer))
     if serialized_request is None:
         return None, None, None, None, rendezvous
     else:
         state = _RPCState(_UNARY_UNARY_INITIAL_DUE, None, None, None, None)
         operations = (
             cygrpc.operation_send_initial_metadata(metadata, _EMPTY_FLAGS),
             cygrpc.operation_send_message(serialized_request, _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),)
         return state, operations, deadline, deadline_timespec, None
Beispiel #23
0
 def _prepare(self, request, timeout, metadata):
     deadline, deadline_timespec, serialized_request, rendezvous = (
         _start_unary_request(request, timeout, self._request_serializer))
     if serialized_request is None:
         return None, None, None, None, rendezvous
     else:
         state = _RPCState(_UNARY_UNARY_INITIAL_DUE, None, None, None, None)
         operations = (
             cygrpc.operation_send_initial_metadata(
                 _common.to_cygrpc_metadata(metadata), _EMPTY_FLAGS),
             cygrpc.operation_send_message(serialized_request, _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),)
         return state, operations, deadline, deadline_timespec, None
Beispiel #24
0
def _status(rpc_event, state, serialized_response):
    with state.condition:
        if state.client is not _CANCELLED:
            code = _completion_code(state)
            details = _details(state)
            operations = [
                cygrpc.operation_send_status_from_server(
                    state.trailing_metadata, code, details, _EMPTY_FLAGS),
            ]
            if state.initial_metadata_allowed:
                operations.append(
                    cygrpc.operation_send_initial_metadata((), _EMPTY_FLAGS))
            if serialized_response is not None:
                operations.append(
                    cygrpc.operation_send_message(serialized_response,
                                                  _EMPTY_FLAGS))
            rpc_event.operation_call.start_server_batch(
                operations,
                _send_status_from_server(state, _SEND_STATUS_FROM_SERVER_TOKEN))
            state.statused = True
            state.due.add(_SEND_STATUS_FROM_SERVER_TOKEN)
    def _do_rpcs(self):
        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(
                self.server_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.Operations([
                        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.Operations([
                    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 self.server_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))
            self.server_driver.add_due({
                server_send_initial_metadata_tag,
            })
        server_send_initial_metadata_event = self.server_driver.event_with_tag(
            server_send_initial_metadata_tag)

        with self.server_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))
            self.server_driver.add_due({
                server_complete_rpc_tag,
            })
        server_complete_rpc_event = self.server_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),
        )
Beispiel #26
0
    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.Operations([
                        cygrpc.operation_receive_initial_metadata(_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.Operations([
                        cygrpc.operation_send_initial_metadata(_EMPTY_METADATA,
                                                               _EMPTY_FLAGS),
                        cygrpc.operation_send_close_from_client(_EMPTY_FLAGS),
                        cygrpc.operation_receive_status_on_client(_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.operation_send_initial_metadata(_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.operation_send_message(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.operation_send_message(b'\x07', _EMPTY_FLAGS),
                ], server_send_second_message_tag))
            server_complete_rpc_start_batch_result = (
                server_rpc_event.operation_call.start_server_batch([
                    cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS),
                    cygrpc.operation_send_status_from_server(
                        cygrpc.Metadata(()), 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.Operations([
                        cygrpc.operation_receive_message(_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))
Beispiel #27
0
    def test6522(self):
        DEADLINE = time.time() + 5
        DEADLINE_TOLERANCE = 0.25
        METHOD = b'twinkies'

        cygrpc_deadline = cygrpc.Timespec(DEADLINE)
        empty_metadata = cygrpc.Metadata([])

        server_request_tag = object()
        self.server.request_call(self.server_completion_queue,
                                 self.server_completion_queue,
                                 server_request_tag)
        client_call = self.client_channel.create_call(
            None, 0, self.client_completion_queue, METHOD, self.host_argument,
            cygrpc_deadline)

        # Prologue
        def perform_client_operations(operations, description):
            return self._perform_operations(operations, client_call,
                                            self.client_completion_queue,
                                            cygrpc_deadline, description)

        client_event_future = perform_client_operations([
            cygrpc.operation_send_initial_metadata(empty_metadata,
                                                   _EMPTY_FLAGS),
            cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS),
        ], "Client prologue")

        request_event = self.server_completion_queue.poll(cygrpc_deadline)
        server_call = request_event.operation_call

        def perform_server_operations(operations, description):
            return self._perform_operations(operations, server_call,
                                            self.server_completion_queue,
                                            cygrpc_deadline, description)

        server_event_future = perform_server_operations([
            cygrpc.operation_send_initial_metadata(empty_metadata,
                                                   _EMPTY_FLAGS),
        ], "Server prologue")

        client_event_future.result()  # force completion
        server_event_future.result()

        # Messaging
        for _ in range(10):
            client_event_future = perform_client_operations([
                cygrpc.operation_send_message(b'', _EMPTY_FLAGS),
                cygrpc.operation_receive_message(_EMPTY_FLAGS),
            ], "Client message")
            server_event_future = perform_server_operations([
                cygrpc.operation_send_message(b'', _EMPTY_FLAGS),
                cygrpc.operation_receive_message(_EMPTY_FLAGS),
            ], "Server receive")

            client_event_future.result()  # force completion
            server_event_future.result()

        # Epilogue
        client_event_future = perform_client_operations([
            cygrpc.operation_send_close_from_client(_EMPTY_FLAGS),
            cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS)
        ], "Client epilogue")

        server_event_future = perform_server_operations([
            cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS),
            cygrpc.operation_send_status_from_server(
                empty_metadata, cygrpc.StatusCode.ok, b'', _EMPTY_FLAGS)
        ], "Server epilogue")

        client_event_future.result()  # force completion
        server_event_future.result()
Beispiel #28
0
    def testEcho(self):
        DEADLINE = time.time() + 5
        DEADLINE_TOLERANCE = 0.25
        CLIENT_METADATA_ASCII_KEY = b'key'
        CLIENT_METADATA_ASCII_VALUE = b'val'
        CLIENT_METADATA_BIN_KEY = b'key-bin'
        CLIENT_METADATA_BIN_VALUE = b'\0' * 1000
        SERVER_INITIAL_METADATA_KEY = b'init_me_me_me'
        SERVER_INITIAL_METADATA_VALUE = b'whodawha?'
        SERVER_TRAILING_METADATA_KEY = b'california_is_in_a_drought'
        SERVER_TRAILING_METADATA_VALUE = b'zomg it is'
        SERVER_STATUS_CODE = cygrpc.StatusCode.ok
        SERVER_STATUS_DETAILS = b'our work is never over'
        REQUEST = b'in death a member of project mayhem has a name'
        RESPONSE = b'his name is robert paulson'
        METHOD = b'twinkies'

        cygrpc_deadline = cygrpc.Timespec(DEADLINE)

        server_request_tag = object()
        request_call_result = self.server.request_call(
            self.server_completion_queue, self.server_completion_queue,
            server_request_tag)

        self.assertEqual(cygrpc.CallError.ok, request_call_result)

        client_call_tag = object()
        client_call = self.client_channel.create_call(
            None, 0, self.client_completion_queue, METHOD, self.host_argument,
            cygrpc_deadline)
        client_initial_metadata = cygrpc.Metadata([
            cygrpc.Metadatum(CLIENT_METADATA_ASCII_KEY,
                             CLIENT_METADATA_ASCII_VALUE),
            cygrpc.Metadatum(CLIENT_METADATA_BIN_KEY, CLIENT_METADATA_BIN_VALUE)
        ])
        client_start_batch_result = client_call.start_client_batch([
            cygrpc.operation_send_initial_metadata(client_initial_metadata,
                                                   _EMPTY_FLAGS),
            cygrpc.operation_send_message(REQUEST, _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)
        ], client_call_tag)
        self.assertEqual(cygrpc.CallError.ok, client_start_batch_result)
        client_event_future = test_utilities.CompletionQueuePollFuture(
            self.client_completion_queue, cygrpc_deadline)

        request_event = self.server_completion_queue.poll(cygrpc_deadline)
        self.assertEqual(cygrpc.CompletionType.operation_complete,
                         request_event.type)
        self.assertIsInstance(request_event.operation_call, cygrpc.Call)
        self.assertIs(server_request_tag, request_event.tag)
        self.assertEqual(0, len(request_event.batch_operations))
        self.assertTrue(
            test_common.metadata_transmitted(client_initial_metadata,
                                             request_event.request_metadata))
        self.assertEqual(METHOD, request_event.request_call_details.method)
        self.assertEqual(self.expected_host,
                         request_event.request_call_details.host)
        self.assertLess(
            abs(DEADLINE - float(request_event.request_call_details.deadline)),
            DEADLINE_TOLERANCE)

        server_call_tag = object()
        server_call = request_event.operation_call
        server_initial_metadata = cygrpc.Metadata([
            cygrpc.Metadatum(SERVER_INITIAL_METADATA_KEY,
                             SERVER_INITIAL_METADATA_VALUE)
        ])
        server_trailing_metadata = cygrpc.Metadata([
            cygrpc.Metadatum(SERVER_TRAILING_METADATA_KEY,
                             SERVER_TRAILING_METADATA_VALUE)
        ])
        server_start_batch_result = server_call.start_server_batch([
            cygrpc.operation_send_initial_metadata(
                server_initial_metadata,
                _EMPTY_FLAGS), cygrpc.operation_receive_message(_EMPTY_FLAGS),
            cygrpc.operation_send_message(RESPONSE, _EMPTY_FLAGS),
            cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS),
            cygrpc.operation_send_status_from_server(
                server_trailing_metadata, SERVER_STATUS_CODE,
                SERVER_STATUS_DETAILS, _EMPTY_FLAGS)
        ], server_call_tag)
        self.assertEqual(cygrpc.CallError.ok, server_start_batch_result)

        server_event = self.server_completion_queue.poll(cygrpc_deadline)
        client_event = client_event_future.result()

        self.assertEqual(6, len(client_event.batch_operations))
        found_client_op_types = set()
        for client_result in client_event.batch_operations:
            # we expect each op type to be unique
            self.assertNotIn(client_result.type, found_client_op_types)
            found_client_op_types.add(client_result.type)
            if client_result.type == cygrpc.OperationType.receive_initial_metadata:
                self.assertTrue(
                    test_common.metadata_transmitted(
                        server_initial_metadata,
                        client_result.received_metadata))
            elif client_result.type == cygrpc.OperationType.receive_message:
                self.assertEqual(RESPONSE,
                                 client_result.received_message.bytes())
            elif client_result.type == cygrpc.OperationType.receive_status_on_client:
                self.assertTrue(
                    test_common.metadata_transmitted(
                        server_trailing_metadata,
                        client_result.received_metadata))
                self.assertEqual(SERVER_STATUS_DETAILS,
                                 client_result.received_status_details)
                self.assertEqual(SERVER_STATUS_CODE,
                                 client_result.received_status_code)
        self.assertEqual(
            set([
                cygrpc.OperationType.send_initial_metadata,
                cygrpc.OperationType.send_message,
                cygrpc.OperationType.send_close_from_client,
                cygrpc.OperationType.receive_initial_metadata,
                cygrpc.OperationType.receive_message,
                cygrpc.OperationType.receive_status_on_client
            ]), found_client_op_types)

        self.assertEqual(5, len(server_event.batch_operations))
        found_server_op_types = set()
        for server_result in server_event.batch_operations:
            self.assertNotIn(client_result.type, found_server_op_types)
            found_server_op_types.add(server_result.type)
            if server_result.type == cygrpc.OperationType.receive_message:
                self.assertEqual(REQUEST,
                                 server_result.received_message.bytes())
            elif server_result.type == cygrpc.OperationType.receive_close_on_server:
                self.assertFalse(server_result.received_cancelled)
        self.assertEqual(
            set([
                cygrpc.OperationType.send_initial_metadata,
                cygrpc.OperationType.receive_message,
                cygrpc.OperationType.send_message,
                cygrpc.OperationType.receive_close_on_server,
                cygrpc.OperationType.send_status_from_server
            ]), found_server_op_types)

        del client_call
        del server_call
    def testReadSomeButNotAllResponses(self):
        server_completion_queue = cygrpc.CompletionQueue()
        server = cygrpc.Server()
        server.register_completion_queue(server_completion_queue)
        port = server.add_http2_port(b"[::]:0")
        server.start()
        channel = cygrpc.Channel("localhost:{}".format(port).encode())

        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_batch(
                cygrpc.Operations([cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS)]),
                client_receive_initial_metadata_tag,
            )
            client_due.add(client_receive_initial_metadata_tag)
            client_complete_rpc_start_batch_result = client_call.start_batch(
                cygrpc.Operations(
                    [
                        cygrpc.operation_send_initial_metadata(_EMPTY_METADATA, _EMPTY_FLAGS),
                        cygrpc.operation_send_close_from_client(_EMPTY_FLAGS),
                        cygrpc.operation_receive_status_on_client(_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_batch(
                cygrpc.Operations([cygrpc.operation_send_initial_metadata(_EMPTY_METADATA, _EMPTY_FLAGS)]),
                server_send_initial_metadata_tag,
            )
            server_send_first_message_start_batch_result = server_rpc_event.operation_call.start_batch(
                cygrpc.Operations([cygrpc.operation_send_message(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_batch(
                cygrpc.Operations([cygrpc.operation_send_message(b"\x07", _EMPTY_FLAGS)]),
                server_send_second_message_tag,
            )
            server_complete_rpc_start_batch_result = server_rpc_event.operation_call.start_batch(
                cygrpc.Operations(
                    [
                        cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS),
                        cygrpc.operation_send_status_from_server(
                            cygrpc.Metadata(()), 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_batch(
                cygrpc.Operations([cygrpc.operation_receive_message(_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_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.Operations([
                        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.Operations([
                    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),)
Beispiel #31
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)