def test_ClientBrokerWorker( basicParameters ):
broker = plhc_api.CreateBrokerFromParameters( basicParameters.bpb.Build() )
client = plhc_api.CreateClientFromParameters( basicParameters.cpb.Build() )
clientProxy = plhc_api.CreateClientProxyFromParameters( basicParameters.cppb.Build() )
requestHandlerCallback = AggregatingRequestHandlerCallback()
requestHandler = plhc_api.SimpleRequestHandlerCB( \
[ 1, 2, 3 ], requestHandlerCallback )
worker = plhc_api.CreateWorkerFromParameters( basicParameters.wpb.Build(), requestHandler )
broker.Start()
clientProxy.Start()
worker.Start()
time.sleep( 1 )
client.Activate()
responses = plhc_ext.RequestResponseList()
numRetrieved = 0
client.SendSynchronousRequestEmpty( 1, 1 )
client.SendSynchronousRequestEmpty( 1, 10 )
client.SendSynchronousRequestEmpty( 2, 2 )
client.SendSynchronousRequestEmpty( 2, 20 )
client.SendSynchronousRequestEmpty( 3, 3 )
client.SendSynchronousRequestEmpty( 3, 30 )
numRetrieved = client.RetrieveResponsesTimeoutMS( responses, 6, plhc_ext.DelayMS( 1000 ) )
client.Deactivate()
broker.Stop()
clientProxy.Stop()
worker.Stop()
print( requestHandlerCallback.receivedRequests )
assert( 6 == len( responses ) )
assert( 6 == len( requestHandlerCallback.receivedRequests ) )
for eachRequestType in [ 1, 2, 3 ]:
reqKey1 = ( eachRequestType, eachRequestType )
reqKey2 = ( eachRequestType, 10 * eachRequestType )
req1 = requestHandlerCallback.receivedRequests.get( reqKey1, None )
req2 = requestHandlerCallback.receivedRequests.get( reqKey2, None )
assert( req1 is not None )
assert( req2 is not None )
assert( 0 == req1[ 1 ].TotalNumberOfFrames() )
assert( 0 == req2[ 1 ].TotalNumberOfFrames() )
assert( None == req1[ 1 ].NextBytes() )
assert( None == req2[ 1 ].NextBytes() )
assert( plhc_ext.MessageFlag.Nil == req1[ 0 ].flags )
assert( plhc_ext.MessageFlag.Nil == req2[ 0 ].flags )
def sendRandomSyncRequest( self ):
ret = 0
id = getRandomId()
zmsg = plhc_ext.PyZMQMessage()
zmsg.AppendBytes( bytes( getRandomUTF8ByteStr() ) )
ret = self.plhcClient.SendSynchronousRequest( self.rtype, id, zmsg )
if( ret != 0 ):
print( "NotifyClient.Error: failed to send sync request[{}]".format( ret ) )
self.numErrors = self.numErrors + 1
ret = self.plhcClient.RetrieveResponsesTimeoutMS( \
self.syncResponses, 1, plhc_ext.DelayMS( 10 ) )
if( ret != 1 ):
print( "NotifyClient.Warning: failed to retrieve response in 60ms[{}|{}]".format( self.rtype, id ) )
def run( self ):
self.plhcClient.Activate()
self.plhcClient.SendSynchronousRequestEmpty( 1, 1 )
self.plhcClient.SendSynchronousRequestEmpty( 1, 10 )
self.plhcClient.SendSynchronousRequestEmpty( 2, 2 )
self.plhcClient.SendSynchronousRequestEmpty( 2, 20 )
self.plhcClient.SendSynchronousRequestEmpty( 3, 3 )
self.plhcClient.SendSynchronousRequestEmpty( 3, 30 )
self.numRetrieved = self.plhcClient.RetrieveResponsesTimeoutMS( \
self.responses, 6, plhc_ext.DelayMS( 10 ) )
self.plhcClient.Deactivate()
self.SignalDone()
def sendRandomAsyncRequest( self ):
ret = 0
id = getRandomId()
msg = bytes( getRandomUTF8ByteStr() )
zmsg = plhc_ext.PyZMQMessage()
zmsg.AppendBytes( msg )
notifyType = "{}-{}".format( self.rtype, id )
print( "NotifyClient: subscribing[{}]".format( notifyType ) )
subscriptions = [ notifyType ]
subscriptions = plhc_api.CreateNotificationTypeListFromPyIterable( subscriptions )
ret = self.plhcSubscriber.Subscribe( subscriptions, plhc_ext.DelayMS( 50 ) )
if( ret != 0 ):
print( "NotifyClient.Error: failed to sub to {} in timeout[{}]".format( subscriptions, ret ) )
self.numErrors = self.numErrors + 1
ret = self.plhcClient.SendAsynchronousRequest( self.rtype, id, zmsg )
if( ret != 0 ):
print( "NotifyClient.Error: failed to send async request[{}]".format( ret ) )
self.numErrors = self.numErrors + 1
def run( self ):
startTimeS = 0.0
stopTimeS = 0.0
elapsedTimeMS = 0
numResponsesOutstanding = 0
self.numErrors = 0
self.plhcSubscriber.Start()
time.sleep( 1 ) # HACK wait a bit to ensure sub connected with some luck
# NOT A PROD PATTERN, NOT A GUARANTEE of connected and subbed
self.plhcClient.Activate()
numSyncRequestsLeft = self.numSyncRequests
numAsyncRequestsLeft = self.numAsyncRequests
startTime = time.perf_counter()
while( ( numSyncRequestsLeft > 0 ) and ( numAsyncRequestsLeft > 0 ) ):
sendSyncNext = random.choice( [ True, False ] )
if( sendSyncNext ):
self.sendRandomSyncRequest()
numSyncRequestsLeft = numSyncRequestsLeft - 1
else:
self.sendRandomAsyncRequest()
numAsyncRequestsLeft = numAsyncRequestsLeft - 1
for _ in range( numSyncRequestsLeft ):
self.sendRandomSyncRequest()
for _ in range( numAsyncRequestsLeft ):
self.sendRandomAsyncRequest()
endTime = time.perf_counter()
elapsedTimeMS = int( 1000.0 * ( endTime - startTime ) )
numResponsesOutstanding = self.numSyncRequests - len( self.syncResponses )
if( numResponsesOutstanding > 0 ):
numResponsesReceived = len( self.syncResponses )
timeToWaitMS = elapsedTimeMS
if( numResponsesOutstanding > numResponsesReceived ):
waitMultiplier = int( numResponsesOutstanding / numResponsesReceived )
if waitMultiplier <= 1:
waitMultiplier = 2
timeToWaitMS = timeToWaitMS * waitMultiplier
print( "NotifyClient.Info: Waiting additional {}ms for {} responses".format( \
timeToWaitMS,
numResponsesOutstanding ) )
ret = self.plhcClient.RetrieveResponsesTimeoutMS( \
self.syncResponses, numResponsesOutstanding, plhc_ext.DelayMS( timeToWaitMS ) )
if( ret != numResponsesOutstanding ):
print( "NotifyClient.Error: Did not receive expected number of responses[{}]".format( \
ret ) )
self.numErrors = self.numErrors + ( numResponsesOutstanding - ret )
endTime = time.perf_counter()
elapsedTimeMS = int( 1000.0 * ( endTime - startTime ) )
numResponsesOutstanding = self.numAsyncRequests - len( self.notificationsReceived )
if( numResponsesOutstanding > 0 ):
numResponsesReceived = len( self.notificationsReceived )
timeToWaitMS = elapsedTimeMS
if( numResponsesOutstanding > numResponsesReceived ):
waitMultiplier = int( numResponsesOutstanding / numResponsesReceived )
if waitMultiplier <= 1:
waitMultiplier = 2
timeToWaitMS = timeToWaitMS * waitMultiplier
if timeToWaitMS < 1000:
timeToWaitMS = 1000
print( "NotifyClient.Info: Waiting additional {}ms for {} notifications".format( \
timeToWaitMS,
numResponsesOutstanding ) )
time.sleep( int( timeToWaitMS / 1000 ) )
numResponsesOutstanding = self.numAsyncRequests - len( self.notificationsReceived )
if( numResponsesOutstanding > 0 ):
print( "NotifyClient.Error: some notifications still outstanding[{}]".format( \
numResponsesOutstanding ) )
self.plhcClient.Deactivate()
self.plhcSubscriber.Stop()
print( "Run Results:" )
print( "NumSyncRequests {}".format( self.numSyncRequests ) )
print( "NumSyncResponses {}".format( len( self.syncResponses ) ) )
print( "NumAsyncRequests {}".format( self.numAsyncRequests ) )
print( "NumNotifications {}".format( len( self.notificationsReceived ) ) )
print( "NumErrors {}".format( self.numErrors ) )
self.SignalDone()