def processRequest(self, request, deferred, type = None):
if type == "success":
# Imitate successful completion of job step's execution on remote server
sleep(None, .3).addCallback(self.__success, request, deferred)
elif type == "failure":
# Imitate failure of job step's execution on remote server
sleep_fail(None, .3, "TEST FAILURE").addErrback(self.__failure, deferred)
def lineReceived(self, data):
data = json.loads(data)
twisted_logger.writeLog(self.logPrefix, None, "Server received request: %s" % data)
if not failFlag:
twisted_logger.writeLog(self.logPrefix, None, "Imitating long running job on the server that succeeds...")
# Imitate long running job on the server, and call back deferred
sleep(None, 3).addCallback(self._jobSuccess, data)
else:
twisted_logger.writeLog(self.logPrefix, None, "Imitating long running job on the server that fails...")
# Imitate long running job on the server, and call back deferred
sleep(None, 3).addCallback(self._jobFailure, data)
def lineReceived(self, data):
dict_data = json.loads(data)
print "DICT DATA: %s" % dict_data
if dict_data['type'] == 'REQUEST':
twisted_logger.writeLog(self.logPrefix, None, "Server received request: %s" % data)
if self.dataRcvdDeferred:
if not self.dataRcvdDeferred.called:
self.dataRcvdDeferred.callback(data)
if processRequest:
if not failFlag:
twisted_logger.writeLog(self.logPrefix, None, "Imitating long running job on the server that succeeds...")
# Imitate long running job on the server, and call back deferred
sleep(None, 3).addCallback(self._jobSuccess, data)
else:
twisted_logger.writeLog(self.logPrefix, None, "Imitating long running job on the server that fails...")
# Imitate long running job on the server, and call back deferred
sleep(None, 3).addCallback(self._jobFailure, data)
elif dict_data['type'] == 'STATUS':
if self.transport.connected:
twisted_logger.writeLog(self.logPrefix, None, "Received job STATUS request...")
if not failFlag:
# Imitate long running job on the server, and call back deferred
sleep(None, 3).addCallback(self._jobStatusRunning, data)
else:
# Imitate long running job on the server, and call back deferred
sleep(None, 3).addCallback(self._jobFailure, data)
def test_JobRequest_processResponse_JOB_FAILURE_DEFERRED_CANCELED(self):
"Test that JobRequest.processResponse() processes job failure when job step deferred's callback is canceled"
global processRequest, failFlag
self.logPrefix = "test_JobRequest_processResponse_JOB_FAILURE"
def checkResults(data, deferredCanceled):
twisted_logger.writeLog(self.logPrefix, None, "Checking test results...")
self.assertEquals(data, None)
self.assertEquals(deferredCanceled, True)
twisted_logger.writeLog(self.logPrefix, None, "Test succeeded!")
# We want to wait for a job completion event
processRequest = True
failFlag = True
self.assertNotEquals(self.jobRequest.statusRequest, None)
self.assertEquals(hasattr(self.jobRequest, 'statusRequest'), True)
self.assertEquals(hasattr(self.jobRequest, 'deferred'), True)
deferred = defer.Deferred().addErrback(checkResults, False)
self.jobRequest.deferred = deferred
# Delete job step's deferred
del self.jobRequest.deferred
self.jobRequest.processRequest()
deferred1 = sleep(None, 5).addCallback(checkResults, True)
return deferred1
def test_handleClientReconnect_GO_ONLINE_MANY_DISCONNECTED(self):
"Test that Workflow.handleClientReconnect() correctly brings Workflow ONLINE when all OFFLINE clients turn ONLINE"
self.logPrefix ="WorkflowTest.test_handleClientReconnect_GO_ONLINE_MANY_DISCONNECTED"
global reconnectHandled, reconnectCount
def handleWorkflowReconnect(result, wf):
"Handle workflow reconnect event"
twisted_logger.writeLog(self.logPrefix, None, "Workflow.handleClientReconnect() has been called back ...")
global reconnectHandled, reconnectCount
reconnectCount += 1
reconnectHandled = True
def checkResults(result, wf):
"Verify that workflow is ONLINE and that workflow reconnect is handled (only once)"
global reconnectHandled, reconnectCount
twisted_logger.writeLog(self.logPrefix, None, "Checking results...")
self.assertEquals(wf.online, True)
self.assertEquals(reconnectHandled, True)
self.assertEquals(reconnectCount, 1)
twisted_logger.writeLog(self.logPrefix, None, "Success...")
reconnectCount = 0
reconnectHandled = False
# Set 'enable' flag to True for the testWorkflow
workflowManager.workflowInfo[testWorkflow]['enabled'] = True
# Artificially enable all workflow steps
for stepRec in workflowManager.workflowInfo[testWorkflow]['steps']:
stepRec['enabled'] = True
# Artificially set online status to False = for all client instances
for client in self.clients.values():
client.online = False
# Start workflow. This should initiate Workflow instance without any 'client' step data
workflowManager.start(testWorkflow)
wf = workflowManager.getResource(testWorkflow)
# Artificially set workflow's client data
wf._setClients(self.clients.values())
# Verify that workflow's online status is False
self.assertEquals(wf.online, False)
# Add deferred (to Workflow entity) to handle workflow disconnect
wf.addOnlineDeferred(defer.Deferred().addCallback(handleWorkflowReconnect, wf))
# Imitate connectionMade() event for ALL client that are offline
for client_name in testClientNames:
self.clients[client_name].connectionMade()
# Sleep for a fraction of a second before verifying results
return sleep(None, .1).addCallback(checkResults, wf)
def test_handleClientReconnect_DONOTGO_ONLINE(self):
"Test that Workflow.handleClientReconnect() does not bring Workflow ONLINE when more than one client were disconnected"
self.logPrefix ="WorkflowTest.test_handleClientReconnect_DONOTGO_ONLINE"
global reconnectHandled, reconnectCount
def handleWorkflowReconnect(result, wf):
global reconnectHandled, reconnectCount
twisted_logger.writeLog(self.logPrefix, None, "Workflow.handleClientReconnect() has been called back ...")
reconnectCount += 1
reconnectHandled = True
err_msg = "Workflow.handleClientReconnect() resets workflow status to online when other client(s) are still offline"
raise self.failureException, err_msg
def checkResults(result, wf):
"Verify that workflow is offline and that workflow reconnect event has not occured"
global reconnectHandled, reconnectCount
twisted_logger.writeLog(self.logPrefix, None, "Checking results...")
self.assertEquals(wf.online, False)
self.assertEquals(reconnectHandled, False)
self.assertEquals(reconnectCount, 0)
twisted_logger.writeLog(self.logPrefix, None, "Success...")
reconnectCount = 0
reconnectHandled = False
# Set 'enable' flag to True for the testWorkflow
workflowManager.workflowInfo[testWorkflow]['enabled'] = True
# Artificially enable all workflow steps
for stepRec in workflowManager.workflowInfo[testWorkflow]['steps']:
stepRec['enabled'] = True
# Artificially set online status to False = for all client instances
for client in self.clients.values():
client.online = False
# Start workflow. This should initiate Workflow instance without any 'client' step data
workflowManager.start(testWorkflow)
wf = workflowManager.getResource(testWorkflow)
# Artificially set workflow's client data
wf._setClients(self.clients.values())
# Verify that workflow's online status is False
self.assertEquals(wf.online, False)
# Add deferred (to Workflow entity) to handle workflow disconnect
wf.addOnlineDeferred(defer.Deferred().addCallback(handleWorkflowReconnect, wf))
# Imitate connectionMade() event of ONLY ONE DISCONNECTED client
self.clients[testClientNames[0]].connectionMade()
# Sleep for a fraction of a second before verifying results
return sleep(None, .1).addCallback(checkResults, wf)
def test_handleClientDisconnect_OFFLINE(self):
"Test that Workflow.handleClientDisconnect() correctly handles client's disconnect when workflow is offline"
self.logPrefix ="WorkflowTest.test_handleClientDisconnect_OFFLINE"
global disconnectHandled, disconnectCount
def handleWorkflowDisconnect(result, wf):
err_msg = "Workflow.handleClientReconnect() resets workflow status to OFFLINE when one client is already OFFLINE"
raise self.failureException, err_msg
def checkResults(result, wf):
"Verify that workflow is OFFLINE and that workflow disconnect event has NOT occured"
global disconnectHandled, disconnectCount
twisted_logger.writeLog(self.logPrefix, None, "Checking results...")
self.assertEquals(wf.online, False)
self.assertEquals(disconnectHandled, False)
self.assertEquals(disconnectCount, 0)
twisted_logger.writeLog(self.logPrefix, None, "Success...")
disconnectCount = 0
disconnectHandled = False
# Set 'enable' flag to True for the testWorkflow
workflowManager.workflowInfo[testWorkflow]['enabled'] = True
# Artificially enable all workflow steps
for stepRec in workflowManager.workflowInfo[testWorkflow]['steps']:
stepRec['enabled'] = True
# Artificially set one client's online status to False
self.clients.values()[-1].online = False
# Start workflow. This should initiate Workflow instance without any 'client' step data
workflowManager.start(testWorkflow)
wf = workflowManager.getResource(testWorkflow)
# Artificially set workflow's client data
wf._setClients(self.clients.values())
self.assertEquals(wf.online, False)
# Add deferred (to Workflow entity) to handle workflow disconnect
wf.addOfflineDeferred(defer.Deferred().addCallback(handleWorkflowDisconnect, wf))
# Imitate clientConnectionLost() event of one of the clients
self.clients[testClientNames[0]].clientConnectionLost(None, "Test disconnect")
# Sleep for a fraction of a second before verifying results
return sleep(None, .1).addCallback(checkResults, wf)
def lineReceived(self, data):
data = json.loads(data)
if data['type'] == 'REQUEST':
twisted_logger.writeLog(self.logPrefix, None, "Server received request: %s" % data)
if timeoutFlag:
twisted_logger.writeLog(self.logPrefix, None, "Imitating long running job that exceeds workflow's timeout setting...")
# Imitate long running job on the server, and call back deferred
sleep(None, 10).addCallback(self._jobSuccess, data)
elif not failFlag:
twisted_logger.writeLog(self.logPrefix, None, "Imitating long running job on the server that succeeds...")
# Imitate long running job on the server, and call back deferred
sleep(None, 3).addCallback(self._jobSuccess, data)
else:
twisted_logger.writeLog(self.logPrefix, None, "Imitating long running job on the server that fails...")
# Imitate long running job on the server, and call back deferred
sleep(None, 3).addCallback(self._jobFailure, data)
elif data['type'] == 'STATUS':
response = {'type': 'STATUS', 'scs_jobid': data['scs_jobid'], 'status': None}
self.sendLine(response)
