def _on_finish_event(self, event): """Handle termination of an RPC.""" call = event.tag rpc_state = self._rpc_states.pop(call, None) if rpc_state is None: return code = event.status.code if code is _low.Code.OK: return sequence_number = rpc_state.sequence_number rpc_state.sequence_number += 1 if code is _low.Code.CANCELLED: ticket = tickets.FrontToBackPacket(call, sequence_number, tickets.Kind.CANCELLATION, None, None, None, None, None) elif code is _low.Code.EXPIRED: ticket = tickets.FrontToBackPacket(call, sequence_number, tickets.Kind.EXPIRATION, None, None, None, None, None) else: # TODO(nathaniel): Better mapping of codes to ticket-categories ticket = tickets.FrontToBackPacket( call, sequence_number, tickets.Kind.TRANSMISSION_FAILURE, None, None, None, None, None) self._rear_link.accept_front_to_back_ticket(ticket)
def packetize(self, operation_id, sequence_number, payload, complete): """See _Packetizer.packetize for specification.""" if sequence_number: return packets.FrontToBackPacket( operation_id, sequence_number, packets.Kind.COMPLETION if complete else packets.Kind.CONTINUATION, self._name, self._subscription_kind, self._trace_id, payload, self._timeout) else: return packets.FrontToBackPacket( operation_id, 0, packets.Kind.ENTIRE if complete else packets.Kind.COMMENCEMENT, self._name, self._subscription_kind, self._trace_id, payload, self._timeout)
def _perform_lonely_client_test_with_ticket_kind( self, front_to_back_ticket_kind): test_operation_id = object() test_method = 'test method' fore_link = _test_links.ForeLink(None, None) rear_link = rear.RearLink('nonexistent', 54321, self.pool, {test_method: None}, {test_method: None}, False, None, None, None) rear_link.join_fore_link(fore_link) rear_link.start() front_to_back_ticket = packets.FrontToBackPacket( test_operation_id, 0, front_to_back_ticket_kind, test_method, interfaces.ServicedSubscription.Kind.FULL, None, None, _TIMEOUT) rear_link.accept_front_to_back_ticket(front_to_back_ticket) with fore_link.condition: while True: if (fore_link.tickets and fore_link.tickets[-1].kind is not packets.Kind.CONTINUATION): break fore_link.condition.wait() rear_link.stop() with fore_link.condition: self.assertIsNot(fore_link.tickets[-1].kind, packets.Kind.COMPLETION)
def _on_service_acceptance_event(self, event, server): """Handle a service invocation event.""" service_acceptance = event.service_acceptance if service_acceptance is None: return call = service_acceptance.call call.accept(self._completion_queue, call) # TODO(nathaniel): Metadata support. call.premetadata() call.read(call) method = service_acceptance.method.decode() self._rpc_states[call] = _common.CommonRPCState( _common.WriteState(_LowWrite.OPEN, _common.HighWrite.OPEN, []), 1, self._request_deserializers[method], self._response_serializers[method]) ticket = tickets.FrontToBackPacket( call, 0, tickets.Kind.COMMENCEMENT, method, interfaces.ServicedSubscription.Kind.FULL, None, None, service_acceptance.deadline - time.time()) self._rear_link.accept_front_to_back_ticket(ticket) server.service(None)
def packetize_abortion(self, operation_id, sequence_number, kind): """See _Packetizer.packetize_abortion for specification.""" if kind in _FRONT_TO_BACK_NO_TRANSMISSION_KINDS: return None else: return packets.FrontToBackPacket(operation_id, sequence_number, kind, None, None, None, None, None)
def _on_read_event(self, event): """Handle data arriving during an RPC.""" call = event.tag rpc_state = self._rpc_states.get(call, None) if rpc_state is None: return sequence_number = rpc_state.sequence_number rpc_state.sequence_number += 1 if event.bytes is None: ticket = tickets.FrontToBackPacket(call, sequence_number, tickets.Kind.COMPLETION, None, None, None, None, None) else: call.read(call) ticket = tickets.FrontToBackPacket( call, sequence_number, tickets.Kind.CONTINUATION, None, None, None, rpc_state.deserializer(event.bytes), None) self._rear_link.accept_front_to_back_ticket(ticket)
def _on_complete_event(self, event): if not event.complete_accepted: logging.error('Complete not accepted! %s', (event, )) call = event.tag rpc_state = self._rpc_states.pop(call, None) if rpc_state is None: return sequence_number = rpc_state.sequence_number rpc_state.sequence_number += 1 ticket = tickets.FrontToBackPacket( call, sequence_number, tickets.Kind.TRANSMISSION_FAILURE, None, None, None, None, None) self._rear_link.accept_front_to_back_ticket(ticket)
def testZeroMessageRoundTrip(self): test_operation_id = object() test_method = 'test method' test_fore_link = _test_links.ForeLink(None, None) def rear_action(front_to_back_ticket, fore_link): if front_to_back_ticket.kind in (tickets.Kind.COMPLETION, tickets.Kind.ENTIRE): back_to_front_ticket = tickets.BackToFrontPacket( front_to_back_ticket.operation_id, 0, tickets.Kind.COMPLETION, None) fore_link.accept_back_to_front_ticket(back_to_front_ticket) test_rear_link = _test_links.RearLink(rear_action, None) fore_link = fore.ForeLink(self.fore_link_pool, {test_method: None}, {test_method: None}, None, ()) fore_link.join_rear_link(test_rear_link) test_rear_link.join_fore_link(fore_link) fore_link.start() port = fore_link.port() rear_link = rear.RearLink('localhost', port, self.rear_link_pool, {test_method: None}, {test_method: None}) rear_link.join_fore_link(test_fore_link) test_fore_link.join_rear_link(rear_link) rear_link.start() front_to_back_ticket = tickets.FrontToBackPacket( test_operation_id, 0, tickets.Kind.ENTIRE, test_method, interfaces.ServicedSubscription.Kind.FULL, None, None, _TIMEOUT) rear_link.accept_front_to_back_ticket(front_to_back_ticket) with test_fore_link.condition: while (not test_fore_link.tickets or test_fore_link.tickets[-1].kind is tickets.Kind.CONTINUATION): test_fore_link.condition.wait() rear_link.stop() fore_link.stop() with test_fore_link.condition: self.assertIs(test_fore_link.tickets[-1].kind, tickets.Kind.COMPLETION)
def testEntireRoundTrip(self): test_operation_id = object() test_method = 'test method' test_front_to_back_datum = b'\x07' test_back_to_front_datum = b'\x08' test_fore_link = _test_links.ForeLink(None, None) rear_sequence_number = [0] def rear_action(front_to_back_ticket, fore_link): if front_to_back_ticket.payload is None: payload = None else: payload = test_back_to_front_datum terminal = front_to_back_ticket.kind in ( tickets.Kind.COMPLETION, tickets.Kind.ENTIRE) if payload is not None or terminal: back_to_front_ticket = tickets.BackToFrontPacket( front_to_back_ticket.operation_id, rear_sequence_number[0], tickets.Kind.COMPLETION if terminal else tickets.Kind.CONTINUATION, payload) rear_sequence_number[0] += 1 fore_link.accept_back_to_front_ticket(back_to_front_ticket) test_rear_link = _test_links.RearLink(rear_action, None) fore_link = fore.ForeLink( self.fore_link_pool, {test_method: _IDENTITY}, {test_method: _IDENTITY}, None, ()) fore_link.join_rear_link(test_rear_link) test_rear_link.join_fore_link(fore_link) fore_link.start() port = fore_link.port() rear_link = rear.RearLink( 'localhost', port, self.rear_link_pool, {test_method: _IDENTITY}, {test_method: _IDENTITY}, False, None, None, None) rear_link.join_fore_link(test_fore_link) test_fore_link.join_rear_link(rear_link) rear_link.start() front_to_back_ticket = tickets.FrontToBackPacket( test_operation_id, 0, tickets.Kind.ENTIRE, test_method, interfaces.ServicedSubscription.Kind.FULL, None, test_front_to_back_datum, _TIMEOUT) rear_link.accept_front_to_back_ticket(front_to_back_ticket) with test_fore_link.condition: while (not test_fore_link.tickets or test_fore_link.tickets[-1].kind is not tickets.Kind.COMPLETION): test_fore_link.condition.wait() rear_link.stop() fore_link.stop() with test_rear_link.condition: front_to_back_payloads = tuple( ticket.payload for ticket in test_rear_link.tickets if ticket.payload is not None) with test_fore_link.condition: back_to_front_payloads = tuple( ticket.payload for ticket in test_fore_link.tickets if ticket.payload is not None) self.assertTupleEqual((test_front_to_back_datum,), front_to_back_payloads) self.assertTupleEqual((test_back_to_front_datum,), back_to_front_payloads)
def _perform_scenario_test(self, scenario): test_operation_id = object() test_method = scenario.method() test_fore_link = _test_links.ForeLink(None, None) rear_lock = threading.Lock() rear_sequence_number = [0] def rear_action(front_to_back_ticket, fore_link): with rear_lock: if front_to_back_ticket.payload is not None: response = scenario.response_for_request(front_to_back_ticket.payload) else: response = None terminal = front_to_back_ticket.kind in ( tickets.Kind.COMPLETION, tickets.Kind.ENTIRE) if response is not None or terminal: back_to_front_ticket = tickets.BackToFrontPacket( front_to_back_ticket.operation_id, rear_sequence_number[0], tickets.Kind.COMPLETION if terminal else tickets.Kind.CONTINUATION, response) rear_sequence_number[0] += 1 fore_link.accept_back_to_front_ticket(back_to_front_ticket) test_rear_link = _test_links.RearLink(rear_action, None) fore_link = fore.ForeLink( self.fore_link_pool, {test_method: scenario.deserialize_request}, {test_method: scenario.serialize_response}, None, ()) fore_link.join_rear_link(test_rear_link) test_rear_link.join_fore_link(fore_link) fore_link.start() port = fore_link.port() rear_link = rear.RearLink( 'localhost', port, self.rear_link_pool, {test_method: scenario.serialize_request}, {test_method: scenario.deserialize_response}, False, None, None, None) rear_link.join_fore_link(test_fore_link) test_fore_link.join_rear_link(rear_link) rear_link.start() commencement_ticket = tickets.FrontToBackPacket( test_operation_id, 0, tickets.Kind.COMMENCEMENT, test_method, interfaces.ServicedSubscription.Kind.FULL, None, None, _TIMEOUT) fore_sequence_number = 1 rear_link.accept_front_to_back_ticket(commencement_ticket) for request in scenario.requests(): continuation_ticket = tickets.FrontToBackPacket( test_operation_id, fore_sequence_number, tickets.Kind.CONTINUATION, None, None, None, request, None) fore_sequence_number += 1 rear_link.accept_front_to_back_ticket(continuation_ticket) completion_ticket = tickets.FrontToBackPacket( test_operation_id, fore_sequence_number, tickets.Kind.COMPLETION, None, None, None, None, None) fore_sequence_number += 1 rear_link.accept_front_to_back_ticket(completion_ticket) with test_fore_link.condition: while (not test_fore_link.tickets or test_fore_link.tickets[-1].kind is not tickets.Kind.COMPLETION): test_fore_link.condition.wait() rear_link.stop() fore_link.stop() with test_rear_link.condition: requests = tuple( ticket.payload for ticket in test_rear_link.tickets if ticket.payload is not None) with test_fore_link.condition: responses = tuple( ticket.payload for ticket in test_fore_link.tickets if ticket.payload is not None) self.assertTrue(scenario.verify_requests(requests)) self.assertTrue(scenario.verify_responses(responses))