Github user ganeshmurthy commented on a diff in the pull request:
https://github.com/apache/qpid-dispatch/pull/176#discussion_r128262784
--- Diff: tests/system_tests_three_routers.py ---
@@ -624,5 +636,151 @@ def run(self):
container.run()
+
+class ClosestTest ( MessagingHandler ):
+ """
+ Test whether distance-based message routing works in a
+ linear 3-router network.
+
+ sender -----> NEAR -----> MID -----> FAR
+ | | |
+ v v v
+ near mid far
+ rcvrs rcvrs rcvrs
+
+ With a linear network of 3 routers, set up a sender on the
+ near one, and then 2 receivers each on the near, middle, and
+ far routers.
+ After the first 10 messages have been received, close the
+ near routers and check results so far. All 10 messages should
+ have gone to the near receivers, and none to the mid or far
+ receivers.
+ After the next 10 messages have been received, close the two
+ middle routers and check again. All 10 messages should have
+ gone to the middle receivers, and none to the far ones.
+ Finally, after another 10 messages have been received, check
+ that they went to the far receivers.
+ """
+ def __init__ ( self, near_router, mid_router, far_router, addr_suffix
):
+ super ( ClosestTest, self ).__init__(prefetch=0)
+ self.error = None
+ self.near_router = near_router
+ self.mid_router = mid_router
+ self.far_router = far_router
+ self.addr_suffix = addr_suffix
+ self.dest = "closest/" + addr_suffix
+
+ # Used during development to make sure it will fail when I want it
to.
+ self.debug = False
+
+ # This n_expected is actually the minimum number of messages
+ # I will send. The real number will be higher because some
+ # will be released when I close the near and middle receivers.
+ self.n_expected = 30
+
+ # n_received -- the grand total -- is used to decide when to
+ # close the near receivers and later the middle ones.
+ self.n_received = 0
+
+ # Counters for the near, middle, and far receivers are used
+ # to determine whether there has been an error.
+ self.near_messages = 0
+ self.mid_messages = 0
+ self.far_messages = 0
+
+
+ def timeout ( self ):
+ self.check_results ( )
+ self.bail ( "Timeout Expired " )
+
+
+ def bail ( self, text ):
+ self.timer.cancel()
+ self.error = text
+ self.send_cnx.close()
+ self.near_cnx.close()
+ self.mid_cnx.close()
+ self.far_cnx.close()
+
+
+ def on_start ( self, event ):
+ self.timer = event.reactor.schedule ( TIMEOUT,
Timeout(self) )
+ self.send_cnx = event.container.connect ( self.near_router )
+ self.near_cnx = event.container.connect ( self.near_router )
+ self.mid_cnx = event.container.connect ( self.mid_router )
+ self.far_cnx = event.container.connect ( self.far_router )
+
+ self.sender = event.container.create_sender (
self.send_cnx, self.dest)
+
+ self.near_recv_1 = event.container.create_receiver (
self.near_cnx, self.dest)
+ self.near_recv_2 = event.container.create_receiver (
self.near_cnx, self.dest)
+
+ self.mid_recv_1 = event.container.create_receiver (
self.mid_cnx, self.dest)
+ self.mid_recv_2 = event.container.create_receiver (
self.mid_cnx, self.dest)
+
+ self.far_recv_1 = event.container.create_receiver (
self.far_cnx, self.dest)
+ self.far_recv_2 = event.container.create_receiver (
self.far_cnx, self.dest)
+
+ self.near_recv_1.flow ( self.n_expected )
+ self.mid_recv_1.flow ( self.n_expected )
+ self.far_recv_1.flow ( self.n_expected )
+
+
+ def on_sendable ( self, event ):
+ msg = Message ( body = "Hello, closest.",
+ address = self.dest
+ )
+ event.sender.send ( msg )
+
+
+ def on_message ( self, event ):
+
+ self.n_received += 1
+
+ if self.n_received == 10:
+ # The first ten messages should have gone exclusively
+ # to the near receivers. At this point we should have
+ # no messages in the mid or far receivers.
+ self.near_recv_1.close()
+ self.near_recv_2.close()
+ if self.debug :
+ self.mid_messages = 1
+ if self.mid_messages > 0 or self.far_messages > 0 :
+ self.bail ( "error: mid or far receivers got messages
before near were closed." )
+ elif self.n_received == 20:
+ # The next 10 messages should have gone exclusively
+ # to the mid receivers. At this point we should have
+ # no messages in the far receivers.
+ self.mid_recv_1.close()
+ self.mid_recv_2.close()
+ if self.far_messages > 0 :
+ self.bail ( "error: far receivers got messages before mid
were closed." )
+
+ # Increment the near, mid, or far counts, depending on
+ # which receiver the message came in on.
+ if event.receiver == self.near_recv_1 or event.receiver ==
self.near_recv_2:
--- End diff --
No messages are ever received by self.near_recv_2 because of lack for
credit. Same with self.mid_recv_2 and self.far_recv_2. These 3 receivers should
also send some flow so that they also receive message
---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at [email protected] or file a JIRA ticket
with INFRA.
---
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
