From de5490c15c90c5276f8c4e40fa55c3e1537e53df Mon Sep 17 00:00:00 2001 From: Nathaniel Manista Date: Wed, 18 Mar 2015 00:37:19 +0000 Subject: [PATCH] Change remaining "packet" names to "ticket" This renaming has been incrementally happening for the last several weeks and this change finishes it. --- src/python/src/grpc/_adapter/_links_test.py | 56 ++--- .../grpc/_adapter/_lonely_rear_link_test.py | 14 +- src/python/src/grpc/_adapter/fore.py | 32 +-- src/python/src/grpc/_adapter/rear.py | 32 +-- src/python/src/grpc/framework/base/_ends.py | 12 +- .../src/grpc/framework/base/_interfaces.py | 8 +- .../src/grpc/framework/base/_reception.py | 208 +++++++++--------- .../src/grpc/framework/base/_transmission.py | 190 ++++++++-------- .../grpc/framework/base/implementations.py | 2 +- .../src/grpc/framework/base/in_memory.py | 2 +- .../src/grpc/framework/base/interfaces.py | 26 +-- .../framework/base/interfaces_test_case.py | 24 +- 12 files changed, 303 insertions(+), 303 deletions(-) diff --git a/src/python/src/grpc/_adapter/_links_test.py b/src/python/src/grpc/_adapter/_links_test.py index dc8ad15487e..cfdcc2c4bc9 100644 --- a/src/python/src/grpc/_adapter/_links_test.py +++ b/src/python/src/grpc/_adapter/_links_test.py @@ -59,11 +59,11 @@ class RoundTripTest(unittest.TestCase): test_fore_link = _test_links.ForeLink(None, None) def rear_action(front_to_back_ticket, fore_link): if front_to_back_ticket.kind in ( - interfaces.FrontToBackPacket.Kind.COMPLETION, - interfaces.FrontToBackPacket.Kind.ENTIRE): - back_to_front_ticket = interfaces.BackToFrontPacket( + interfaces.FrontToBackTicket.Kind.COMPLETION, + interfaces.FrontToBackTicket.Kind.ENTIRE): + back_to_front_ticket = interfaces.BackToFrontTicket( front_to_back_ticket.operation_id, 0, - interfaces.BackToFrontPacket.Kind.COMPLETION, None) + interfaces.BackToFrontTicket.Kind.COMPLETION, None) fore_link.accept_back_to_front_ticket(back_to_front_ticket) test_rear_link = _test_links.RearLink(rear_action, None) @@ -81,8 +81,8 @@ class RoundTripTest(unittest.TestCase): test_fore_link.join_rear_link(rear_link) rear_link.start() - front_to_back_ticket = interfaces.FrontToBackPacket( - test_operation_id, 0, interfaces.FrontToBackPacket.Kind.ENTIRE, + front_to_back_ticket = interfaces.FrontToBackTicket( + test_operation_id, 0, interfaces.FrontToBackTicket.Kind.ENTIRE, test_method, interfaces.ServicedSubscription.Kind.FULL, None, None, _TIMEOUT) rear_link.accept_front_to_back_ticket(front_to_back_ticket) @@ -90,7 +90,7 @@ class RoundTripTest(unittest.TestCase): with test_fore_link.condition: while (not test_fore_link.tickets or test_fore_link.tickets[-1].kind is - interfaces.BackToFrontPacket.Kind.CONTINUATION): + interfaces.BackToFrontTicket.Kind.CONTINUATION): test_fore_link.condition.wait() rear_link.stop() @@ -99,7 +99,7 @@ class RoundTripTest(unittest.TestCase): with test_fore_link.condition: self.assertIs( test_fore_link.tickets[-1].kind, - interfaces.BackToFrontPacket.Kind.COMPLETION) + interfaces.BackToFrontTicket.Kind.COMPLETION) def testEntireRoundTrip(self): test_operation_id = object() @@ -114,14 +114,14 @@ class RoundTripTest(unittest.TestCase): else: payload = test_back_to_front_datum terminal = front_to_back_ticket.kind in ( - interfaces.FrontToBackPacket.Kind.COMPLETION, - interfaces.FrontToBackPacket.Kind.ENTIRE) + interfaces.FrontToBackTicket.Kind.COMPLETION, + interfaces.FrontToBackTicket.Kind.ENTIRE) if payload is not None or terminal: if terminal: - kind = interfaces.BackToFrontPacket.Kind.COMPLETION + kind = interfaces.BackToFrontTicket.Kind.COMPLETION else: - kind = interfaces.BackToFrontPacket.Kind.CONTINUATION - back_to_front_ticket = interfaces.BackToFrontPacket( + kind = interfaces.BackToFrontTicket.Kind.CONTINUATION + back_to_front_ticket = interfaces.BackToFrontTicket( front_to_back_ticket.operation_id, rear_sequence_number[0], kind, payload) rear_sequence_number[0] += 1 @@ -143,8 +143,8 @@ class RoundTripTest(unittest.TestCase): test_fore_link.join_rear_link(rear_link) rear_link.start() - front_to_back_ticket = interfaces.FrontToBackPacket( - test_operation_id, 0, interfaces.FrontToBackPacket.Kind.ENTIRE, + front_to_back_ticket = interfaces.FrontToBackTicket( + test_operation_id, 0, interfaces.FrontToBackTicket.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) @@ -152,7 +152,7 @@ class RoundTripTest(unittest.TestCase): with test_fore_link.condition: while (not test_fore_link.tickets or test_fore_link.tickets[-1].kind is not - interfaces.BackToFrontPacket.Kind.COMPLETION): + interfaces.BackToFrontTicket.Kind.COMPLETION): test_fore_link.condition.wait() rear_link.stop() @@ -182,14 +182,14 @@ class RoundTripTest(unittest.TestCase): else: response = None terminal = front_to_back_ticket.kind in ( - interfaces.FrontToBackPacket.Kind.COMPLETION, - interfaces.FrontToBackPacket.Kind.ENTIRE) + interfaces.FrontToBackTicket.Kind.COMPLETION, + interfaces.FrontToBackTicket.Kind.ENTIRE) if response is not None or terminal: if terminal: - kind = interfaces.BackToFrontPacket.Kind.COMPLETION + kind = interfaces.BackToFrontTicket.Kind.COMPLETION else: - kind = interfaces.BackToFrontPacket.Kind.CONTINUATION - back_to_front_ticket = interfaces.BackToFrontPacket( + kind = interfaces.BackToFrontTicket.Kind.CONTINUATION + back_to_front_ticket = interfaces.BackToFrontTicket( front_to_back_ticket.operation_id, rear_sequence_number[0], kind, response) rear_sequence_number[0] += 1 @@ -212,23 +212,23 @@ class RoundTripTest(unittest.TestCase): test_fore_link.join_rear_link(rear_link) rear_link.start() - commencement_ticket = interfaces.FrontToBackPacket( + commencement_ticket = interfaces.FrontToBackTicket( test_operation_id, 0, - interfaces.FrontToBackPacket.Kind.COMMENCEMENT, test_method, + interfaces.FrontToBackTicket.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 = interfaces.FrontToBackPacket( + continuation_ticket = interfaces.FrontToBackTicket( test_operation_id, fore_sequence_number, - interfaces.FrontToBackPacket.Kind.CONTINUATION, None, None, None, + interfaces.FrontToBackTicket.Kind.CONTINUATION, None, None, None, request, None) fore_sequence_number += 1 rear_link.accept_front_to_back_ticket(continuation_ticket) - completion_ticket = interfaces.FrontToBackPacket( + completion_ticket = interfaces.FrontToBackTicket( test_operation_id, fore_sequence_number, - interfaces.FrontToBackPacket.Kind.COMPLETION, None, None, None, None, + interfaces.FrontToBackTicket.Kind.COMPLETION, None, None, None, None, None) fore_sequence_number += 1 rear_link.accept_front_to_back_ticket(completion_ticket) @@ -236,7 +236,7 @@ class RoundTripTest(unittest.TestCase): with test_fore_link.condition: while (not test_fore_link.tickets or test_fore_link.tickets[-1].kind is not - interfaces.BackToFrontPacket.Kind.COMPLETION): + interfaces.BackToFrontTicket.Kind.COMPLETION): test_fore_link.condition.wait() rear_link.stop() diff --git a/src/python/src/grpc/_adapter/_lonely_rear_link_test.py b/src/python/src/grpc/_adapter/_lonely_rear_link_test.py index 4417f57e59e..25799d679c7 100644 --- a/src/python/src/grpc/_adapter/_lonely_rear_link_test.py +++ b/src/python/src/grpc/_adapter/_lonely_rear_link_test.py @@ -67,7 +67,7 @@ class LonelyRearLinkTest(unittest.TestCase): rear_link.join_fore_link(fore_link) rear_link.start() - front_to_back_ticket = interfaces.FrontToBackPacket( + front_to_back_ticket = interfaces.FrontToBackTicket( 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) @@ -76,7 +76,7 @@ class LonelyRearLinkTest(unittest.TestCase): while True: if (fore_link.tickets and fore_link.tickets[-1].kind is not - interfaces.BackToFrontPacket.Kind.CONTINUATION): + interfaces.BackToFrontTicket.Kind.CONTINUATION): break fore_link.condition.wait() @@ -85,15 +85,15 @@ class LonelyRearLinkTest(unittest.TestCase): with fore_link.condition: self.assertIsNot( fore_link.tickets[-1].kind, - interfaces.BackToFrontPacket.Kind.COMPLETION) + interfaces.BackToFrontTicket.Kind.COMPLETION) - def testLonelyClientCommencementPacket(self): + def testLonelyClientCommencementTicket(self): self._perform_lonely_client_test_with_ticket_kind( - interfaces.FrontToBackPacket.Kind.COMMENCEMENT) + interfaces.FrontToBackTicket.Kind.COMMENCEMENT) - def testLonelyClientEntirePacket(self): + def testLonelyClientEntireTicket(self): self._perform_lonely_client_test_with_ticket_kind( - interfaces.FrontToBackPacket.Kind.ENTIRE) + interfaces.FrontToBackTicket.Kind.ENTIRE) if __name__ == '__main__': diff --git a/src/python/src/grpc/_adapter/fore.py b/src/python/src/grpc/_adapter/fore.py index 85b1359e848..05016cdaf31 100644 --- a/src/python/src/grpc/_adapter/fore.py +++ b/src/python/src/grpc/_adapter/fore.py @@ -125,8 +125,8 @@ class ForeLink(base_interfaces.ForeLink, activated.Activated): self._request_deserializers[method], self._response_serializers[method]) - ticket = base_interfaces.FrontToBackPacket( - call, 0, base_interfaces.FrontToBackPacket.Kind.COMMENCEMENT, method, + ticket = base_interfaces.FrontToBackTicket( + call, 0, base_interfaces.FrontToBackTicket.Kind.COMMENCEMENT, method, base_interfaces.ServicedSubscription.Kind.FULL, None, None, service_acceptance.deadline - time.time()) self._rear_link.accept_front_to_back_ticket(ticket) @@ -143,15 +143,15 @@ class ForeLink(base_interfaces.ForeLink, activated.Activated): sequence_number = rpc_state.sequence_number rpc_state.sequence_number += 1 if event.bytes is None: - ticket = base_interfaces.FrontToBackPacket( + ticket = base_interfaces.FrontToBackTicket( call, sequence_number, - base_interfaces.FrontToBackPacket.Kind.COMPLETION, None, None, None, + base_interfaces.FrontToBackTicket.Kind.COMPLETION, None, None, None, None, None) else: call.read(call) - ticket = base_interfaces.FrontToBackPacket( + ticket = base_interfaces.FrontToBackTicket( call, sequence_number, - base_interfaces.FrontToBackPacket.Kind.CONTINUATION, None, None, + base_interfaces.FrontToBackTicket.Kind.CONTINUATION, None, None, None, rpc_state.deserializer(event.bytes), None) self._rear_link.accept_front_to_back_ticket(ticket) @@ -180,9 +180,9 @@ class ForeLink(base_interfaces.ForeLink, activated.Activated): sequence_number = rpc_state.sequence_number rpc_state.sequence_number += 1 - ticket = base_interfaces.FrontToBackPacket( + ticket = base_interfaces.FrontToBackTicket( call, sequence_number, - base_interfaces.FrontToBackPacket.Kind.TRANSMISSION_FAILURE, None, + base_interfaces.FrontToBackTicket.Kind.TRANSMISSION_FAILURE, None, None, None, None, None) self._rear_link.accept_front_to_back_ticket(ticket) @@ -200,20 +200,20 @@ class ForeLink(base_interfaces.ForeLink, activated.Activated): sequence_number = rpc_state.sequence_number rpc_state.sequence_number += 1 if code is _low.Code.CANCELLED: - ticket = base_interfaces.FrontToBackPacket( + ticket = base_interfaces.FrontToBackTicket( call, sequence_number, - base_interfaces.FrontToBackPacket.Kind.CANCELLATION, None, None, + base_interfaces.FrontToBackTicket.Kind.CANCELLATION, None, None, None, None, None) elif code is _low.Code.EXPIRED: - ticket = base_interfaces.FrontToBackPacket( + ticket = base_interfaces.FrontToBackTicket( call, sequence_number, - base_interfaces.FrontToBackPacket.Kind.EXPIRATION, None, None, None, + base_interfaces.FrontToBackTicket.Kind.EXPIRATION, None, None, None, None, None) else: # TODO(nathaniel): Better mapping of codes to ticket-categories - ticket = base_interfaces.FrontToBackPacket( + ticket = base_interfaces.FrontToBackTicket( call, sequence_number, - base_interfaces.FrontToBackPacket.Kind.TRANSMISSION_FAILURE, None, + base_interfaces.FrontToBackTicket.Kind.TRANSMISSION_FAILURE, None, None, None, None, None) self._rear_link.accept_front_to_back_ticket(ticket) @@ -355,9 +355,9 @@ class ForeLink(base_interfaces.ForeLink, activated.Activated): if self._server is None: return - if ticket.kind is base_interfaces.BackToFrontPacket.Kind.CONTINUATION: + if ticket.kind is base_interfaces.BackToFrontTicket.Kind.CONTINUATION: self._continue(ticket.operation_id, ticket.payload) - elif ticket.kind is base_interfaces.BackToFrontPacket.Kind.COMPLETION: + elif ticket.kind is base_interfaces.BackToFrontTicket.Kind.COMPLETION: self._complete(ticket.operation_id, ticket.payload) else: self._cancel(ticket.operation_id) diff --git a/src/python/src/grpc/_adapter/rear.py b/src/python/src/grpc/_adapter/rear.py index f2d9aae8ab3..f19321c4266 100644 --- a/src/python/src/grpc/_adapter/rear.py +++ b/src/python/src/grpc/_adapter/rear.py @@ -151,9 +151,9 @@ class RearLink(base_interfaces.RearLink, activated.Activated): else: logging.error('RPC write not accepted! Event: %s', (event,)) rpc_state.active = False - ticket = base_interfaces.BackToFrontPacket( + ticket = base_interfaces.BackToFrontTicket( operation_id, rpc_state.common.sequence_number, - base_interfaces.BackToFrontPacket.Kind.TRANSMISSION_FAILURE, None) + base_interfaces.BackToFrontTicket.Kind.TRANSMISSION_FAILURE, None) rpc_state.common.sequence_number += 1 self._fore_link.accept_back_to_front_ticket(ticket) @@ -162,9 +162,9 @@ class RearLink(base_interfaces.RearLink, activated.Activated): rpc_state.call.read(operation_id) rpc_state.outstanding.add(_low.Event.Kind.READ_ACCEPTED) - ticket = base_interfaces.BackToFrontPacket( + ticket = base_interfaces.BackToFrontTicket( operation_id, rpc_state.common.sequence_number, - base_interfaces.BackToFrontPacket.Kind.CONTINUATION, + base_interfaces.BackToFrontTicket.Kind.CONTINUATION, rpc_state.common.deserializer(event.bytes)) rpc_state.common.sequence_number += 1 self._fore_link.accept_back_to_front_ticket(ticket) @@ -173,9 +173,9 @@ class RearLink(base_interfaces.RearLink, activated.Activated): if not event.complete_accepted: logging.error('RPC complete not accepted! Event: %s', (event,)) rpc_state.active = False - ticket = base_interfaces.BackToFrontPacket( + ticket = base_interfaces.BackToFrontTicket( operation_id, rpc_state.common.sequence_number, - base_interfaces.BackToFrontPacket.Kind.TRANSMISSION_FAILURE, None) + base_interfaces.BackToFrontTicket.Kind.TRANSMISSION_FAILURE, None) rpc_state.common.sequence_number += 1 self._fore_link.accept_back_to_front_ticket(ticket) @@ -188,14 +188,14 @@ class RearLink(base_interfaces.RearLink, activated.Activated): """Handle termination of an RPC.""" # TODO(nathaniel): Cover all statuses. if event.status.code is _low.Code.OK: - kind = base_interfaces.BackToFrontPacket.Kind.COMPLETION + kind = base_interfaces.BackToFrontTicket.Kind.COMPLETION elif event.status.code is _low.Code.CANCELLED: - kind = base_interfaces.BackToFrontPacket.Kind.CANCELLATION + kind = base_interfaces.BackToFrontTicket.Kind.CANCELLATION elif event.status.code is _low.Code.EXPIRED: - kind = base_interfaces.BackToFrontPacket.Kind.EXPIRATION + kind = base_interfaces.BackToFrontTicket.Kind.EXPIRATION else: - kind = base_interfaces.BackToFrontPacket.Kind.TRANSMISSION_FAILURE - ticket = base_interfaces.BackToFrontPacket( + kind = base_interfaces.BackToFrontTicket.Kind.TRANSMISSION_FAILURE + ticket = base_interfaces.BackToFrontTicket( operation_id, rpc_state.common.sequence_number, kind, None) rpc_state.common.sequence_number += 1 self._fore_link.accept_back_to_front_ticket(ticket) @@ -370,17 +370,17 @@ class RearLink(base_interfaces.RearLink, activated.Activated): if self._completion_queue is None: return - if ticket.kind is base_interfaces.FrontToBackPacket.Kind.COMMENCEMENT: + if ticket.kind is base_interfaces.FrontToBackTicket.Kind.COMMENCEMENT: self._commence( ticket.operation_id, ticket.name, ticket.payload, ticket.timeout) - elif ticket.kind is base_interfaces.FrontToBackPacket.Kind.CONTINUATION: + elif ticket.kind is base_interfaces.FrontToBackTicket.Kind.CONTINUATION: self._continue(ticket.operation_id, ticket.payload) - elif ticket.kind is base_interfaces.FrontToBackPacket.Kind.COMPLETION: + elif ticket.kind is base_interfaces.FrontToBackTicket.Kind.COMPLETION: self._complete(ticket.operation_id, ticket.payload) - elif ticket.kind is base_interfaces.FrontToBackPacket.Kind.ENTIRE: + elif ticket.kind is base_interfaces.FrontToBackTicket.Kind.ENTIRE: self._entire( ticket.operation_id, ticket.name, ticket.payload, ticket.timeout) - elif ticket.kind is base_interfaces.FrontToBackPacket.Kind.CANCELLATION: + elif ticket.kind is base_interfaces.FrontToBackTicket.Kind.CANCELLATION: self._cancel(ticket.operation_id) else: # NOTE(nathaniel): All other categories are treated as cancellation. diff --git a/src/python/src/grpc/framework/base/_ends.py b/src/python/src/grpc/framework/base/_ends.py index e774b49df3a..176f3ac06e3 100644 --- a/src/python/src/grpc/framework/base/_ends.py +++ b/src/python/src/grpc/framework/base/_ends.py @@ -150,7 +150,7 @@ def _front_operate( """Constructs objects necessary for front-side operation management. Args: - callback: A callable that accepts interfaces.FrontToBackPackets and + callback: A callable that accepts interfaces.FrontToBackTickets and delivers them to the other side of the operation. Execution of this callable may take any arbitrary length of time. work_pool: A thread pool in which to execute customer code. @@ -276,7 +276,7 @@ class FrontLink(interfaces.FrontLink): with self._endlette: reception_manager = self._endlette.get_operation(ticket.operation_id) if reception_manager: - reception_manager.receive_packet(ticket) + reception_manager.receive_ticket(ticket) def _back_operate( @@ -289,7 +289,7 @@ def _back_operate( Args: servicer: An interfaces.Servicer for servicing operations. - callback: A callable that accepts interfaces.BackToFrontPackets and + callback: A callable that accepts interfaces.BackToFrontTickets and delivers them to the other side of the operation. Execution of this callable may take any arbitrary length of time. work_pool: A thread pool in which to execute customer code. @@ -298,7 +298,7 @@ def _back_operate( utility_pool: A thread pool for utility tasks. termination_action: A no-arg behavior to be called upon operation completion. - ticket: The first interfaces.FrontToBackPacket received for the operation. + ticket: The first interfaces.FrontToBackTicket received for the operation. default_timeout: A length of time in seconds to be used as the default time alloted for a single operation. maximum_timeout: A length of time in seconds to be used as the maximum @@ -338,7 +338,7 @@ def _back_operate( ingestion_manager, expiration_manager) ingestion_manager.set_expiration_manager(expiration_manager) - reception_manager.receive_packet(ticket) + reception_manager.receive_ticket(ticket) return reception_manager @@ -388,7 +388,7 @@ class BackLink(interfaces.BackLink): self._default_timeout, self._maximum_timeout) self._endlette.add_operation(ticket.operation_id, reception_manager) else: - reception_manager.receive_packet(ticket) + reception_manager.receive_ticket(ticket) def operation_stats(self): """See interfaces.End.operation_stats for specification.""" diff --git a/src/python/src/grpc/framework/base/_interfaces.py b/src/python/src/grpc/framework/base/_interfaces.py index 801420e4aca..d88cf76590e 100644 --- a/src/python/src/grpc/framework/base/_interfaces.py +++ b/src/python/src/grpc/framework/base/_interfaces.py @@ -247,15 +247,15 @@ class ExpirationManager(object): class ReceptionManager(object): - """A manager responsible for receiving packets from the other end.""" + """A manager responsible for receiving tickets from the other end.""" __metaclass__ = abc.ABCMeta @abc.abstractmethod - def receive_packet(self, packet): - """Handle a packet from the other side of the operation. + def receive_ticket(self, ticket): + """Handle a ticket from the other side of the operation. Args: - packet: An interfaces.BackToFrontPacket or interfaces.FrontToBackPacket + ticket: An interfaces.BackToFrontTicket or interfaces.FrontToBackTicket appropriate to this end of the operation and this object. """ raise NotImplementedError() diff --git a/src/python/src/grpc/framework/base/_reception.py b/src/python/src/grpc/framework/base/_reception.py index f523800d86b..dd428964f15 100644 --- a/src/python/src/grpc/framework/base/_reception.py +++ b/src/python/src/grpc/framework/base/_reception.py @@ -27,46 +27,46 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -"""State and behavior for packet reception.""" +"""State and behavior for ticket reception.""" import abc from grpc.framework.base import interfaces from grpc.framework.base import _interfaces -_INITIAL_FRONT_TO_BACK_PACKET_KINDS = ( - interfaces.FrontToBackPacket.Kind.COMMENCEMENT, - interfaces.FrontToBackPacket.Kind.ENTIRE, +_INITIAL_FRONT_TO_BACK_TICKET_KINDS = ( + interfaces.FrontToBackTicket.Kind.COMMENCEMENT, + interfaces.FrontToBackTicket.Kind.ENTIRE, ) class _Receiver(object): - """Common specification of different packet-handling behavior.""" + """Common specification of different ticket-handling behavior.""" __metaclass__ = abc.ABCMeta @abc.abstractmethod - def abort_if_abortive(self, packet): - """Aborts the operation if the packet is abortive. + def abort_if_abortive(self, ticket): + """Aborts the operation if the ticket is abortive. Args: - packet: A just-arrived packet. + ticket: A just-arrived ticket. Returns: A boolean indicating whether or not this Receiver aborted the operation - based on the packet. + based on the ticket. """ raise NotImplementedError() @abc.abstractmethod - def receive(self, packet): - """Handles a just-arrived packet. + def receive(self, ticket): + """Handles a just-arrived ticket. Args: - packet: A just-arrived packet. + ticket: A just-arrived ticket. Returns: - A boolean indicating whether or not the packet was terminal (i.e. whether - or not non-abortive packets are legal after this one). + A boolean indicating whether or not the ticket was terminal (i.e. whether + or not non-abortive tickets are legal after this one). """ raise NotImplementedError() @@ -87,13 +87,13 @@ def _abort( def _abort_if_abortive( - packet, abortive, termination_manager, transmission_manager, + ticket, abortive, termination_manager, transmission_manager, ingestion_manager, expiration_manager): - """Determines a packet's being abortive and if so aborts the operation. + """Determines a ticket's being abortive and if so aborts the operation. Args: - packet: A just-arrived packet. - abortive: A callable that takes a packet and returns an interfaces.Outcome + ticket: A just-arrived ticket. + abortive: A callable that takes a ticket and returns an interfaces.Outcome indicating that the operation should be aborted or None indicating that the operation should not be aborted. termination_manager: The operation's _interfaces.TerminationManager. @@ -104,7 +104,7 @@ def _abort_if_abortive( Returns: True if the operation was aborted; False otherwise. """ - abortion_outcome = abortive(packet) + abortion_outcome = abortive(ticket) if abortion_outcome is None: return False else: @@ -124,7 +124,7 @@ def _reception_failure( class _BackReceiver(_Receiver): - """Packet-handling specific to the back side of an operation.""" + """Ticket-handling specific to the back side of an operation.""" def __init__( self, termination_manager, transmission_manager, ingestion_manager, @@ -142,68 +142,68 @@ class _BackReceiver(_Receiver): self._ingestion_manager = ingestion_manager self._expiration_manager = expiration_manager - self._first_packet_seen = False - self._last_packet_seen = False + self._first_ticket_seen = False + self._last_ticket_seen = False - def _abortive(self, packet): - """Determines whether or not (and if so, how) a packet is abortive. + def _abortive(self, ticket): + """Determines whether or not (and if so, how) a ticket is abortive. Args: - packet: A just-arrived packet. + ticket: A just-arrived ticket. Returns: An interfaces.Outcome value describing operation abortion if the - packet is abortive or None if the packet is not abortive. + ticket is abortive or None if the ticket is not abortive. """ - if packet.kind is interfaces.FrontToBackPacket.Kind.CANCELLATION: + if ticket.kind is interfaces.FrontToBackTicket.Kind.CANCELLATION: return interfaces.Outcome.CANCELLED - elif packet.kind is interfaces.FrontToBackPacket.Kind.EXPIRATION: + elif ticket.kind is interfaces.FrontToBackTicket.Kind.EXPIRATION: return interfaces.Outcome.EXPIRED - elif packet.kind is interfaces.FrontToBackPacket.Kind.SERVICED_FAILURE: + elif ticket.kind is interfaces.FrontToBackTicket.Kind.SERVICED_FAILURE: return interfaces.Outcome.SERVICED_FAILURE - elif packet.kind is interfaces.FrontToBackPacket.Kind.RECEPTION_FAILURE: + elif ticket.kind is interfaces.FrontToBackTicket.Kind.RECEPTION_FAILURE: return interfaces.Outcome.SERVICED_FAILURE - elif (packet.kind in _INITIAL_FRONT_TO_BACK_PACKET_KINDS and - self._first_packet_seen): + elif (ticket.kind in _INITIAL_FRONT_TO_BACK_TICKET_KINDS and + self._first_ticket_seen): return interfaces.Outcome.RECEPTION_FAILURE - elif self._last_packet_seen: + elif self._last_ticket_seen: return interfaces.Outcome.RECEPTION_FAILURE else: return None - def abort_if_abortive(self, packet): + def abort_if_abortive(self, ticket): """See _Receiver.abort_if_abortive for specification.""" return _abort_if_abortive( - packet, self._abortive, self._termination_manager, + ticket, self._abortive, self._termination_manager, self._transmission_manager, self._ingestion_manager, self._expiration_manager) - def receive(self, packet): + def receive(self, ticket): """See _Receiver.receive for specification.""" - if packet.timeout is not None: - self._expiration_manager.change_timeout(packet.timeout) - - if packet.kind is interfaces.FrontToBackPacket.Kind.COMMENCEMENT: - self._first_packet_seen = True - self._ingestion_manager.start(packet.name) - if packet.payload is not None: - self._ingestion_manager.consume(packet.payload) - elif packet.kind is interfaces.FrontToBackPacket.Kind.CONTINUATION: - self._ingestion_manager.consume(packet.payload) - elif packet.kind is interfaces.FrontToBackPacket.Kind.COMPLETION: - self._last_packet_seen = True - if packet.payload is None: + if ticket.timeout is not None: + self._expiration_manager.change_timeout(ticket.timeout) + + if ticket.kind is interfaces.FrontToBackTicket.Kind.COMMENCEMENT: + self._first_ticket_seen = True + self._ingestion_manager.start(ticket.name) + if ticket.payload is not None: + self._ingestion_manager.consume(ticket.payload) + elif ticket.kind is interfaces.FrontToBackTicket.Kind.CONTINUATION: + self._ingestion_manager.consume(ticket.payload) + elif ticket.kind is interfaces.FrontToBackTicket.Kind.COMPLETION: + self._last_ticket_seen = True + if ticket.payload is None: self._ingestion_manager.terminate() else: - self._ingestion_manager.consume_and_terminate(packet.payload) + self._ingestion_manager.consume_and_terminate(ticket.payload) else: - self._first_packet_seen = True - self._last_packet_seen = True - self._ingestion_manager.start(packet.name) - if packet.payload is None: + self._first_ticket_seen = True + self._last_ticket_seen = True + self._ingestion_manager.start(ticket.name) + if ticket.payload is None: self._ingestion_manager.terminate() else: - self._ingestion_manager.consume_and_terminate(packet.payload) + self._ingestion_manager.consume_and_terminate(ticket.payload) def reception_failure(self): """See _Receiver.reception_failure for specification.""" @@ -213,7 +213,7 @@ class _BackReceiver(_Receiver): class _FrontReceiver(_Receiver): - """Packet-handling specific to the front side of an operation.""" + """Ticket-handling specific to the front side of an operation.""" def __init__( self, termination_manager, transmission_manager, ingestion_manager, @@ -231,48 +231,48 @@ class _FrontReceiver(_Receiver): self._ingestion_manager = ingestion_manager self._expiration_manager = expiration_manager - self._last_packet_seen = False + self._last_ticket_seen = False - def _abortive(self, packet): - """Determines whether or not (and if so, how) a packet is abortive. + def _abortive(self, ticket): + """Determines whether or not (and if so, how) a ticket is abortive. Args: - packet: A just-arrived packet. + ticket: A just-arrived ticket. Returns: - An interfaces.Outcome value describing operation abortion if the packet - is abortive or None if the packet is not abortive. + An interfaces.Outcome value describing operation abortion if the ticket + is abortive or None if the ticket is not abortive. """ - if packet.kind is interfaces.BackToFrontPacket.Kind.CANCELLATION: + if ticket.kind is interfaces.BackToFrontTicket.Kind.CANCELLATION: return interfaces.Outcome.CANCELLED - elif packet.kind is interfaces.BackToFrontPacket.Kind.EXPIRATION: + elif ticket.kind is interfaces.BackToFrontTicket.Kind.EXPIRATION: return interfaces.Outcome.EXPIRED - elif packet.kind is interfaces.BackToFrontPacket.Kind.SERVICER_FAILURE: + elif ticket.kind is interfaces.BackToFrontTicket.Kind.SERVICER_FAILURE: return interfaces.Outcome.SERVICER_FAILURE - elif packet.kind is interfaces.BackToFrontPacket.Kind.RECEPTION_FAILURE: + elif ticket.kind is interfaces.BackToFrontTicket.Kind.RECEPTION_FAILURE: return interfaces.Outcome.SERVICER_FAILURE - elif self._last_packet_seen: + elif self._last_ticket_seen: return interfaces.Outcome.RECEPTION_FAILURE else: return None - def abort_if_abortive(self, packet): + def abort_if_abortive(self, ticket): """See _Receiver.abort_if_abortive for specification.""" return _abort_if_abortive( - packet, self._abortive, self._termination_manager, + ticket, self._abortive, self._termination_manager, self._transmission_manager, self._ingestion_manager, self._expiration_manager) - def receive(self, packet): + def receive(self, ticket): """See _Receiver.receive for specification.""" - if packet.kind is interfaces.BackToFrontPacket.Kind.CONTINUATION: - self._ingestion_manager.consume(packet.payload) - elif packet.kind is interfaces.BackToFrontPacket.Kind.COMPLETION: - self._last_packet_seen = True - if packet.payload is None: + if ticket.kind is interfaces.BackToFrontTicket.Kind.CONTINUATION: + self._ingestion_manager.consume(ticket.payload) + elif ticket.kind is interfaces.BackToFrontTicket.Kind.COMPLETION: + self._last_ticket_seen = True + if ticket.payload is None: self._ingestion_manager.terminate() else: - self._ingestion_manager.consume_and_terminate(packet.payload) + self._ingestion_manager.consume_and_terminate(ticket.payload) def reception_failure(self): """See _Receiver.reception_failure for specification.""" @@ -289,72 +289,72 @@ class _ReceptionManager(_interfaces.ReceptionManager): Args: lock: The operation-servicing-wide lock object. - receiver: A _Receiver responsible for handling received packets. + receiver: A _Receiver responsible for handling received tickets. """ self._lock = lock self._receiver = receiver self._lowest_unseen_sequence_number = 0 - self._out_of_sequence_packets = {} + self._out_of_sequence_tickets = {} self._completed_sequence_number = None self._aborted = False - def _sequence_failure(self, packet): - """Determines a just-arrived packet's sequential legitimacy. + def _sequence_failure(self, ticket): + """Determines a just-arrived ticket's sequential legitimacy. Args: - packet: A just-arrived packet. + ticket: A just-arrived ticket. Returns: - True if the packet is sequentially legitimate; False otherwise. + True if the ticket is sequentially legitimate; False otherwise. """ - if packet.sequence_number < self._lowest_unseen_sequence_number: + if ticket.sequence_number < self._lowest_unseen_sequence_number: return True - elif packet.sequence_number in self._out_of_sequence_packets: + elif ticket.sequence_number in self._out_of_sequence_tickets: return True elif (self._completed_sequence_number is not None and - self._completed_sequence_number <= packet.sequence_number): + self._completed_sequence_number <= ticket.sequence_number): return True else: return False - def _process(self, packet): - """Process those packets ready to be processed. + def _process(self, ticket): + """Process those tickets ready to be processed. Args: - packet: A just-arrived packet the sequence number of which matches this + ticket: A just-arrived ticket the sequence number of which matches this _ReceptionManager's _lowest_unseen_sequence_number field. """ while True: - completed = self._receiver.receive(packet) + completed = self._receiver.receive(ticket) if completed: - self._out_of_sequence_packets.clear() - self._completed_sequence_number = packet.sequence_number - self._lowest_unseen_sequence_number = packet.sequence_number + 1 + self._out_of_sequence_tickets.clear() + self._completed_sequence_number = ticket.sequence_number + self._lowest_unseen_sequence_number = ticket.sequence_number + 1 return else: - next_packet = self._out_of_sequence_packets.pop( - packet.sequence_number + 1, None) - if next_packet is None: - self._lowest_unseen_sequence_number = packet.sequence_number + 1 + next_ticket = self._out_of_sequence_tickets.pop( + ticket.sequence_number + 1, None) + if next_ticket is None: + self._lowest_unseen_sequence_number = ticket.sequence_number + 1 return else: - packet = next_packet + ticket = next_ticket - def receive_packet(self, packet): - """See _interfaces.ReceptionManager.receive_packet for specification.""" + def receive_ticket(self, ticket): + """See _interfaces.ReceptionManager.receive_ticket for specification.""" with self._lock: if self._aborted: return - elif self._sequence_failure(packet): + elif self._sequence_failure(ticket): self._receiver.reception_failure() self._aborted = True - elif self._receiver.abort_if_abortive(packet): + elif self._receiver.abort_if_abortive(ticket): self._aborted = True - elif packet.sequence_number == self._lowest_unseen_sequence_number: - self._process(packet) + elif ticket.sequence_number == self._lowest_unseen_sequence_number: + self._process(ticket) else: - self._out_of_sequence_packets[packet.sequence_number] = packet + self._out_of_sequence_tickets[ticket.sequence_number] = ticket def front_reception_manager( diff --git a/src/python/src/grpc/framework/base/_transmission.py b/src/python/src/grpc/framework/base/_transmission.py index 510ca11c612..68451292344 100644 --- a/src/python/src/grpc/framework/base/_transmission.py +++ b/src/python/src/grpc/framework/base/_transmission.py @@ -27,7 +27,7 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -"""State and behavior for packet transmission during an operation.""" +"""State and behavior for ticket transmission during an operation.""" import abc @@ -46,53 +46,53 @@ _BACK_TO_FRONT_NO_TRANSMISSION_OUTCOMES = ( interfaces.Outcome.SERVICED_FAILURE, ) -_ABORTION_OUTCOME_TO_FRONT_TO_BACK_PACKET_KIND = { +_ABORTION_OUTCOME_TO_FRONT_TO_BACK_TICKET_KIND = { interfaces.Outcome.CANCELLED: - interfaces.FrontToBackPacket.Kind.CANCELLATION, + interfaces.FrontToBackTicket.Kind.CANCELLATION, interfaces.Outcome.EXPIRED: - interfaces.FrontToBackPacket.Kind.EXPIRATION, + interfaces.FrontToBackTicket.Kind.EXPIRATION, interfaces.Outcome.RECEPTION_FAILURE: - interfaces.FrontToBackPacket.Kind.RECEPTION_FAILURE, + interfaces.FrontToBackTicket.Kind.RECEPTION_FAILURE, interfaces.Outcome.TRANSMISSION_FAILURE: - interfaces.FrontToBackPacket.Kind.TRANSMISSION_FAILURE, + interfaces.FrontToBackTicket.Kind.TRANSMISSION_FAILURE, interfaces.Outcome.SERVICED_FAILURE: - interfaces.FrontToBackPacket.Kind.SERVICED_FAILURE, + interfaces.FrontToBackTicket.Kind.SERVICED_FAILURE, interfaces.Outcome.SERVICER_FAILURE: - interfaces.FrontToBackPacket.Kind.SERVICER_FAILURE, + interfaces.FrontToBackTicket.Kind.SERVICER_FAILURE, } -_ABORTION_OUTCOME_TO_BACK_TO_FRONT_PACKET_KIND = { +_ABORTION_OUTCOME_TO_BACK_TO_FRONT_TICKET_KIND = { interfaces.Outcome.CANCELLED: - interfaces.BackToFrontPacket.Kind.CANCELLATION, + interfaces.BackToFrontTicket.Kind.CANCELLATION, interfaces.Outcome.EXPIRED: - interfaces.BackToFrontPacket.Kind.EXPIRATION, + interfaces.BackToFrontTicket.Kind.EXPIRATION, interfaces.Outcome.RECEPTION_FAILURE: - interfaces.BackToFrontPacket.Kind.RECEPTION_FAILURE, + interfaces.BackToFrontTicket.Kind.RECEPTION_FAILURE, interfaces.Outcome.TRANSMISSION_FAILURE: - interfaces.BackToFrontPacket.Kind.TRANSMISSION_FAILURE, + interfaces.BackToFrontTicket.Kind.TRANSMISSION_FAILURE, interfaces.Outcome.SERVICED_FAILURE: - interfaces.BackToFrontPacket.Kind.SERVICED_FAILURE, + interfaces.BackToFrontTicket.Kind.SERVICED_FAILURE, interfaces.Outcome.SERVICER_FAILURE: - interfaces.BackToFrontPacket.Kind.SERVICER_FAILURE, + interfaces.BackToFrontTicket.Kind.SERVICER_FAILURE, } -class _Packetizer(object): - """Common specification of different packet-creating behavior.""" +class _Ticketizer(object): + """Common specification of different ticket-creating behavior.""" __metaclass__ = abc.ABCMeta @abc.abstractmethod - def packetize(self, operation_id, sequence_number, payload, complete): - """Creates a packet indicating ordinary operation progress. + def ticketize(self, operation_id, sequence_number, payload, complete): + """Creates a ticket indicating ordinary operation progress. Args: operation_id: The operation ID for the current operation. - sequence_number: A sequence number for the packet. + sequence_number: A sequence number for the ticket. payload: A customer payload object. May be None if sequence_number is zero or complete is true. - complete: A boolean indicating whether or not the packet should describe + complete: A boolean indicating whether or not the ticket should describe itself as (but for a later indication of operation abortion) the last - packet to be sent. + ticket to be sent. Returns: An object of an appropriate type suitable for transmission to the other @@ -101,12 +101,12 @@ class _Packetizer(object): raise NotImplementedError() @abc.abstractmethod - def packetize_abortion(self, operation_id, sequence_number, outcome): - """Creates a packet indicating that the operation is aborted. + def ticketize_abortion(self, operation_id, sequence_number, outcome): + """Creates a ticket indicating that the operation is aborted. Args: operation_id: The operation ID for the current operation. - sequence_number: A sequence number for the packet. + sequence_number: A sequence number for the ticket. outcome: An interfaces.Outcome value describing the operation abortion. Returns: @@ -117,8 +117,8 @@ class _Packetizer(object): raise NotImplementedError() -class _FrontPacketizer(_Packetizer): - """Front-side packet-creating behavior.""" +class _FrontTicketizer(_Ticketizer): + """Front-side ticket-creating behavior.""" def __init__(self, name, subscription_kind, trace_id, timeout): """Constructor. @@ -126,7 +126,7 @@ class _FrontPacketizer(_Packetizer): Args: name: The name of the operation. subscription_kind: An interfaces.ServicedSubscription.Kind value - describing the interest the front has in packets sent from the back. + describing the interest the front has in tickets sent from the back. trace_id: A uuid.UUID identifying a set of related operations to which this operation belongs. timeout: A length of time in seconds to allow for the entire operation. @@ -136,54 +136,54 @@ class _FrontPacketizer(_Packetizer): self._trace_id = trace_id self._timeout = timeout - def packetize(self, operation_id, sequence_number, payload, complete): - """See _Packetizer.packetize for specification.""" + def ticketize(self, operation_id, sequence_number, payload, complete): + """See _Ticketizer.ticketize for specification.""" if sequence_number: if complete: - kind = interfaces.FrontToBackPacket.Kind.COMPLETION + kind = interfaces.FrontToBackTicket.Kind.COMPLETION else: - kind = interfaces.FrontToBackPacket.Kind.CONTINUATION - return interfaces.FrontToBackPacket( + kind = interfaces.FrontToBackTicket.Kind.CONTINUATION + return interfaces.FrontToBackTicket( operation_id, sequence_number, kind, self._name, self._subscription_kind, self._trace_id, payload, self._timeout) else: if complete: - kind = interfaces.FrontToBackPacket.Kind.ENTIRE + kind = interfaces.FrontToBackTicket.Kind.ENTIRE else: - kind = interfaces.FrontToBackPacket.Kind.COMMENCEMENT - return interfaces.FrontToBackPacket( + kind = interfaces.FrontToBackTicket.Kind.COMMENCEMENT + return interfaces.FrontToBackTicket( operation_id, 0, kind, self._name, self._subscription_kind, self._trace_id, payload, self._timeout) - def packetize_abortion(self, operation_id, sequence_number, outcome): - """See _Packetizer.packetize_abortion for specification.""" + def ticketize_abortion(self, operation_id, sequence_number, outcome): + """See _Ticketizer.ticketize_abortion for specification.""" if outcome in _FRONT_TO_BACK_NO_TRANSMISSION_OUTCOMES: return None else: - kind = _ABORTION_OUTCOME_TO_FRONT_TO_BACK_PACKET_KIND[outcome] - return interfaces.FrontToBackPacket( + kind = _ABORTION_OUTCOME_TO_FRONT_TO_BACK_TICKET_KIND[outcome] + return interfaces.FrontToBackTicket( operation_id, sequence_number, kind, None, None, None, None, None) -class _BackPacketizer(_Packetizer): - """Back-side packet-creating behavior.""" +class _BackTicketizer(_Ticketizer): + """Back-side ticket-creating behavior.""" - def packetize(self, operation_id, sequence_number, payload, complete): - """See _Packetizer.packetize for specification.""" + def ticketize(self, operation_id, sequence_number, payload, complete): + """See _Ticketizer.ticketize for specification.""" if complete: - kind = interfaces.BackToFrontPacket.Kind.COMPLETION + kind = interfaces.BackToFrontTicket.Kind.COMPLETION else: - kind = interfaces.BackToFrontPacket.Kind.CONTINUATION - return interfaces.BackToFrontPacket( + kind = interfaces.BackToFrontTicket.Kind.CONTINUATION + return interfaces.BackToFrontTicket( operation_id, sequence_number, kind, payload) - def packetize_abortion(self, operation_id, sequence_number, outcome): - """See _Packetizer.packetize_abortion for specification.""" + def ticketize_abortion(self, operation_id, sequence_number, outcome): + """See _Ticketizer.ticketize_abortion for specification.""" if outcome in _BACK_TO_FRONT_NO_TRANSMISSION_OUTCOMES: return None else: - kind = _ABORTION_OUTCOME_TO_BACK_TO_FRONT_PACKET_KIND[outcome] - return interfaces.BackToFrontPacket( + kind = _ABORTION_OUTCOME_TO_BACK_TO_FRONT_TICKET_KIND[outcome] + return interfaces.BackToFrontTicket( operation_id, sequence_number, kind, None) @@ -220,21 +220,21 @@ class _EmptyTransmissionManager(TransmissionManager): class _TransmittingTransmissionManager(TransmissionManager): - """A TransmissionManager implementation that sends packets.""" + """A TransmissionManager implementation that sends tickets.""" def __init__( - self, lock, pool, callback, operation_id, packetizer, + self, lock, pool, callback, operation_id, ticketizer, termination_manager): """Constructor. Args: lock: The operation-servicing-wide lock object. - pool: A thread pool in which the work of transmitting packets will be + pool: A thread pool in which the work of transmitting tickets will be performed. - callback: A callable that accepts packets and sends them to the other side + callback: A callable that accepts tickets and sends them to the other side of the operation. operation_id: The operation's ID. - packetizer: A _Packetizer for packet creation. + ticketizer: A _Ticketizer for ticket creation. termination_manager: The _interfaces.TerminationManager associated with this operation. """ @@ -242,7 +242,7 @@ class _TransmittingTransmissionManager(TransmissionManager): self._pool = pool self._callback = callback self._operation_id = operation_id - self._packetizer = packetizer + self._ticketizer = ticketizer self._termination_manager = termination_manager self._ingestion_manager = None self._expiration_manager = None @@ -259,8 +259,8 @@ class _TransmittingTransmissionManager(TransmissionManager): self._ingestion_manager = ingestion_manager self._expiration_manager = expiration_manager - def _lead_packet(self, emission, complete): - """Creates a packet suitable for leading off the transmission loop. + def _lead_ticket(self, emission, complete): + """Creates a ticket suitable for leading off the transmission loop. Args: emission: A customer payload object to be sent to the other side of the @@ -269,37 +269,37 @@ class _TransmittingTransmissionManager(TransmissionManager): the passed object. Returns: - A packet with which to lead off the transmission loop. + A ticket with which to lead off the transmission loop. """ sequence_number = self._lowest_unused_sequence_number self._lowest_unused_sequence_number += 1 - return self._packetizer.packetize( + return self._ticketizer.ticketize( self._operation_id, sequence_number, emission, complete) - def _abortive_response_packet(self, outcome): - """Creates a packet indicating operation abortion. + def _abortive_response_ticket(self, outcome): + """Creates a ticket indicating operation abortion. Args: outcome: An interfaces.Outcome value describing operation abortion. Returns: - A packet indicating operation abortion. + A ticket indicating operation abortion. """ - packet = self._packetizer.packetize_abortion( + ticket = self._ticketizer.ticketize_abortion( self._operation_id, self._lowest_unused_sequence_number, outcome) - if packet is None: + if ticket is None: return None else: self._lowest_unused_sequence_number += 1 - return packet + return ticket - def _next_packet(self): - """Creates the next packet to be sent to the other side of the operation. + def _next_ticket(self): + """Creates the next ticket to be sent to the other side of the operation. Returns: - A (completed, packet) tuple comprised of a boolean indicating whether or - not the sequence of packets has completed normally and a packet to send - to the other side if the sequence of packets hasn't completed. The tuple + A (completed, ticket) tuple comprised of a boolean indicating whether or + not the sequence of tickets has completed normally and a ticket to send + to the other side if the sequence of tickets hasn't completed. The tuple will never have both a True first element and a non-None second element. """ if self._emissions is None: @@ -310,29 +310,29 @@ class _TransmittingTransmissionManager(TransmissionManager): complete = self._emission_complete and not self._emissions sequence_number = self._lowest_unused_sequence_number self._lowest_unused_sequence_number += 1 - return complete, self._packetizer.packetize( + return complete, self._ticketizer.ticketize( self._operation_id, sequence_number, payload, complete) else: return self._emission_complete, None else: - packet = self._abortive_response_packet(self._outcome) + ticket = self._abortive_response_ticket(self._outcome) self._emissions = None - return False, None if packet is None else packet + return False, None if ticket is None else ticket - def _transmit(self, packet): - """Commences the transmission loop sending packets. + def _transmit(self, ticket): + """Commences the transmission loop sending tickets. Args: - packet: A packet to be sent to the other side of the operation. + ticket: A ticket to be sent to the other side of the operation. """ - def transmit(packet): + def transmit(ticket): while True: transmission_outcome = callable_util.call_logging_exceptions( - self._callback, _TRANSMISSION_EXCEPTION_LOG_MESSAGE, packet) + self._callback, _TRANSMISSION_EXCEPTION_LOG_MESSAGE, ticket) if transmission_outcome.exception is None: with self._lock: - complete, packet = self._next_packet() - if packet is None: + complete, ticket = self._next_ticket() + if ticket is None: if complete: self._termination_manager.transmission_complete() self._transmitting = False @@ -348,7 +348,7 @@ class _TransmittingTransmissionManager(TransmissionManager): return self._pool.submit(callable_util.with_exceptions_logged( - transmit, _constants.INTERNAL_ERROR_LOG_MESSAGE), packet) + transmit, _constants.INTERNAL_ERROR_LOG_MESSAGE), ticket) self._transmitting = True def inmit(self, emission, complete): @@ -358,17 +358,17 @@ class _TransmittingTransmissionManager(TransmissionManager): if self._transmitting: self._emissions.append(emission) else: - self._transmit(self._lead_packet(emission, complete)) + self._transmit(self._lead_ticket(emission, complete)) def abort(self, outcome): """See _interfaces.TransmissionManager.abort for specification.""" if self._emissions is not None and self._outcome is None: self._outcome = outcome if not self._transmitting: - packet = self._abortive_response_packet(outcome) + ticket = self._abortive_response_ticket(outcome) self._emissions = None - if packet is not None: - self._transmit(packet) + if ticket is not None: + self._transmit(ticket) def front_transmission_manager( @@ -378,14 +378,14 @@ def front_transmission_manager( Args: lock: The operation-servicing-wide lock object. - pool: A thread pool in which the work of transmitting packets will be + pool: A thread pool in which the work of transmitting tickets will be performed. - callback: A callable that accepts packets and sends them to the other side + callback: A callable that accepts tickets and sends them to the other side of the operation. operation_id: The operation's ID. name: The name of the operation. subscription_kind: An interfaces.ServicedSubscription.Kind value - describing the interest the front has in packets sent from the back. + describing the interest the front has in tickets sent from the back. trace_id: A uuid.UUID identifying a set of related operations to which this operation belongs. timeout: A length of time in seconds to allow for the entire operation. @@ -396,7 +396,7 @@ def front_transmission_manager( A TransmissionManager appropriate for front-side use. """ return _TransmittingTransmissionManager( - lock, pool, callback, operation_id, _FrontPacketizer( + lock, pool, callback, operation_id, _FrontTicketizer( name, subscription_kind, trace_id, timeout), termination_manager) @@ -408,15 +408,15 @@ def back_transmission_manager( Args: lock: The operation-servicing-wide lock object. - pool: A thread pool in which the work of transmitting packets will be + pool: A thread pool in which the work of transmitting tickets will be performed. - callback: A callable that accepts packets and sends them to the other side + callback: A callable that accepts tickets and sends them to the other side of the operation. operation_id: The operation's ID. termination_manager: The _interfaces.TerminationManager associated with this operation. subscription_kind: An interfaces.ServicedSubscription.Kind value - describing the interest the front has in packets sent from the back. + describing the interest the front has in tickets sent from the back. Returns: A TransmissionManager appropriate for back-side use. @@ -425,5 +425,5 @@ def back_transmission_manager( return _EmptyTransmissionManager() else: return _TransmittingTransmissionManager( - lock, pool, callback, operation_id, _BackPacketizer(), + lock, pool, callback, operation_id, _BackTicketizer(), termination_manager) diff --git a/src/python/src/grpc/framework/base/implementations.py b/src/python/src/grpc/framework/base/implementations.py index 70fb9942b24..5656f9f9812 100644 --- a/src/python/src/grpc/framework/base/implementations.py +++ b/src/python/src/grpc/framework/base/implementations.py @@ -27,7 +27,7 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -"""Entry points into the packet-exchange-based implementation the base layer.""" +"""Entry points into the ticket-exchange-based base layer implementation.""" # interfaces is referenced from specification in this module. from grpc.framework.base import _ends diff --git a/src/python/src/grpc/framework/base/in_memory.py b/src/python/src/grpc/framework/base/in_memory.py index 9ed62f8e0a8..c92d0bc663c 100644 --- a/src/python/src/grpc/framework/base/in_memory.py +++ b/src/python/src/grpc/framework/base/in_memory.py @@ -27,7 +27,7 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -"""Entry points into the packet-exchange-based implementation the base layer.""" +"""In-memory implementations of base layer interfaces.""" import threading diff --git a/src/python/src/grpc/framework/base/interfaces.py b/src/python/src/grpc/framework/base/interfaces.py index 7be13b3f45d..e22c10d9750 100644 --- a/src/python/src/grpc/framework/base/interfaces.py +++ b/src/python/src/grpc/framework/base/interfaces.py @@ -233,9 +233,9 @@ class Back(End): __metaclass__ = abc.ABCMeta -class FrontToBackPacket( +class FrontToBackTicket( collections.namedtuple( - 'FrontToBackPacket', + 'FrontToBackTicket', ['operation_id', 'sequence_number', 'kind', 'name', 'subscription', 'trace_id', 'payload', 'timeout'])): """A sum type for all values sent from a front to a back. @@ -244,14 +244,14 @@ class FrontToBackPacket( operation_id: A unique-with-respect-to-equality hashable object identifying a particular operation. sequence_number: A zero-indexed integer sequence number identifying the - packet's place among all the packets sent from front to back for this + ticket's place among all the tickets sent from front to back for this particular operation. Must be zero if kind is Kind.COMMENCEMENT or Kind.ENTIRE. Must be positive for any other kind. kind: A Kind value describing the overall kind of ticket. name: The name of an operation. Must be present if kind is Kind.COMMENCEMENT or Kind.ENTIRE. Must be None for any other kind. subscription: An ServicedSubscription.Kind value describing the interest - the front has in packets sent from the back. Must be present if + the front has in tickets sent from the back. Must be present if kind is Kind.COMMENCEMENT or Kind.ENTIRE. Must be None for any other kind. trace_id: A uuid.UUID identifying a set of related operations to which this operation belongs. May be None. @@ -269,7 +269,7 @@ class FrontToBackPacket( @enum.unique class Kind(enum.Enum): - """Identifies the overall kind of a FrontToBackPacket.""" + """Identifies the overall kind of a FrontToBackTicket.""" COMMENCEMENT = 'commencement' CONTINUATION = 'continuation' @@ -283,9 +283,9 @@ class FrontToBackPacket( TRANSMISSION_FAILURE = 'transmission failure' -class BackToFrontPacket( +class BackToFrontTicket( collections.namedtuple( - 'BackToFrontPacket', + 'BackToFrontTicket', ['operation_id', 'sequence_number', 'kind', 'payload'])): """A sum type for all values sent from a back to a front. @@ -293,7 +293,7 @@ class BackToFrontPacket( operation_id: A unique-with-respect-to-equality hashable object identifying a particular operation. sequence_number: A zero-indexed integer sequence number identifying the - packet's place among all the packets sent from back to front for this + ticket's place among all the tickets sent from back to front for this particular operation. kind: A Kind value describing the overall kind of ticket. payload: A customer payload object. Must be present if kind is @@ -303,7 +303,7 @@ class BackToFrontPacket( @enum.unique class Kind(enum.Enum): - """Identifies the overall kind of a BackToFrontPacket.""" + """Identifies the overall kind of a BackToFrontTicket.""" CONTINUATION = 'continuation' COMPLETION = 'completion' @@ -321,10 +321,10 @@ class ForeLink(object): @abc.abstractmethod def accept_back_to_front_ticket(self, ticket): - """Accept a BackToFrontPacket. + """Accept a BackToFrontTicket. Args: - ticket: Any BackToFrontPacket. + ticket: Any BackToFrontTicket. """ raise NotImplementedError() @@ -340,10 +340,10 @@ class RearLink(object): @abc.abstractmethod def accept_front_to_back_ticket(self, ticket): - """Accepts a FrontToBackPacket. + """Accepts a FrontToBackTicket. Args: - ticket: Any FrontToBackPacket. + ticket: Any FrontToBackTicket. """ raise NotImplementedError() diff --git a/src/python/src/grpc/framework/base/interfaces_test_case.py b/src/python/src/grpc/framework/base/interfaces_test_case.py index b86011c449e..dec10c2924d 100644 --- a/src/python/src/grpc/framework/base/interfaces_test_case.py +++ b/src/python/src/grpc/framework/base/interfaces_test_case.py @@ -164,7 +164,7 @@ class FrontAndBackTest(object): # pylint: disable=invalid-name def testSimplestCall(self): - """Tests the absolute simplest call - a one-packet fire-and-forget.""" + """Tests the absolute simplest call - a one-ticket fire-and-forget.""" self.front.operate( SYNCHRONOUS_ECHO, None, True, SMALL_TIMEOUT, util.none_serviced_subscription(), 'test trace ID') @@ -175,25 +175,25 @@ class FrontAndBackTest(object): # Assuming nothing really pathological (such as pauses on the order of # SMALL_TIMEOUT interfering with this test) there are a two different ways # the back could have experienced execution up to this point: - # (1) The packet is still either in the front waiting to be transmitted + # (1) The ticket is still either in the front waiting to be transmitted # or is somewhere on the link between the front and the back. The back has # no idea that this test is even happening. Calling wait_for_idle on it # would do no good because in this case the back is idle and the call would - # return with the packet bound for it still in the front or on the link. + # return with the ticket bound for it still in the front or on the link. back_operation_stats = self.back.operation_stats() first_back_possibility = EMPTY_OUTCOME_DICT - # (2) The packet arrived at the back and the back completed the operation. + # (2) The ticket arrived at the back and the back completed the operation. second_back_possibility = dict(EMPTY_OUTCOME_DICT) second_back_possibility[interfaces.Outcome.COMPLETED] = 1 self.assertIn( back_operation_stats, (first_back_possibility, second_back_possibility)) - # It's true that if the packet had arrived at the back and the back had + # It's true that if the ticket had arrived at the back and the back had # begun processing that wait_for_idle could hold test execution until the # back completed the operation, but that doesn't really collapse the # possibility space down to one solution. def testEntireEcho(self): - """Tests a very simple one-packet-each-way round-trip.""" + """Tests a very simple one-ticket-each-way round-trip.""" test_payload = 'test payload' test_consumer = stream_testing.TestConsumer() subscription = util.full_serviced_subscription( @@ -212,7 +212,7 @@ class FrontAndBackTest(object): self.assertListEqual([(test_payload, True)], test_consumer.calls) def testBidirectionalStreamingEcho(self): - """Tests sending multiple packets each way.""" + """Tests sending multiple tickets each way.""" test_payload_template = 'test_payload: %03d' test_payloads = [test_payload_template % i for i in range(STREAM_LENGTH)] test_consumer = stream_testing.TestConsumer() @@ -255,16 +255,16 @@ class FrontAndBackTest(object): # Assuming nothing really pathological (such as pauses on the order of # SMALL_TIMEOUT interfering with this test) there are a two different ways # the back could have experienced execution up to this point: - # (1) Both packets are still either in the front waiting to be transmitted + # (1) Both tickets are still either in the front waiting to be transmitted # or are somewhere on the link between the front and the back. The back has # no idea that this test is even happening. Calling wait_for_idle on it # would do no good because in this case the back is idle and the call would - # return with the packets bound for it still in the front or on the link. + # return with the tickets bound for it still in the front or on the link. back_operation_stats = self.back.operation_stats() first_back_possibility = EMPTY_OUTCOME_DICT - # (2) Both packets arrived within SMALL_TIMEOUT of one another at the back. - # The back started processing based on the first packet and then stopped - # upon receiving the cancellation packet. + # (2) Both tickets arrived within SMALL_TIMEOUT of one another at the back. + # The back started processing based on the first ticket and then stopped + # upon receiving the cancellation ticket. second_back_possibility = dict(EMPTY_OUTCOME_DICT) second_back_possibility[interfaces.Outcome.CANCELLED] = 1 self.assertIn(