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)