def side_effect(*args, **kwargs):
if 'getWorkerInfo' in args:
return defer.fail(twisted_pb.RemoteError(
'twisted.spread.flavors.NoSuchMethod', None, None))
if 'getSlaveInfo' in args:
return defer.fail(twisted_pb.RemoteError(
'twisted.spread.flavors.NoSuchMethod', None, None))
if 'getCommands' in args:
return defer.succeed({'x': 1, 'y': 2})
if 'getVersion' in args:
return defer.succeed('TheVersion')
def side_effect(*args, **kwargs):
if args[0] == 'getWorkerInfo':
return defer.fail(
twisted_pb.RemoteError(
'twisted.spread.flavors.NoSuchMethod', None, None))
if args[0] == 'getSlaveInfo':
return defer.fail(
twisted_pb.RemoteError(
'twisted.spread.flavors.NoSuchMethod', None, None))
if args[0] == 'getCommands':
return defer.succeed({'x': 1, 'y': 2})
if args[0] == 'getVersion':
return defer.succeed('TheVersion')
if args[0] == 'print':
return None
raise ValueError(f"Command unknown: {args}")
def test_remote_errors(self):
worker = Mock(spec=["workerId", "run"])
exc = ValueError("boom")
errors = (
RemoteException("RemoteBoom", None),
pb.RemoteError(ValueError, exc, None),
)
for error in errors:
with subTest(error=error):
worker.run.side_effect = error
task = Mock(spec=["call", "retryable", "priority"])
task.retryable = True
self.worklist.__len__.return_value = 1
self.worklist.pop.return_value = task
self.workers.hire.return_value = worker
handler = Mock()
dfr = self.running.execute()
dfr.addErrback(handler)
handler.assert_not_called()
self.assertIsInstance(dfr, defer.Deferred)
self.worklist.pop.assert_called_once_with()
worker.run.assert_called_once_with(task.call)
self.patches["_handle_start"].assert_called_once_with(
task, worker.workerId,
)
self.patches["_handle_failure"].assert_called_once_with(
task, error,
)
self.workers.layoff.assert_called_once_with(worker)
self.reactor.callLater.assert_called_once_with(
0.1, self.running.execute,
)
self.logger.exception.assert_not_called()
self.logger.error.assert_not_called()
self.logger.warn.assert_not_called()
self.logger.info.assert_not_called()
self.worklist.push.assert_not_called()
self.patches["_handle_success"].assert_not_called()
self.patches["_handle_error"].assert_not_called()
self.patches["_handle_retry"].assert_not_called()
worker.reset_mock()
for patched in self.patches.values():
patched.reset_mock()
self.logger.reset_mock()
self.reactor.reset_mock()
self.worklist.reset_mock()
self.workers.reset_mock()
def clientReturn(self, clientid, requestid, result):
''' '''
log.info("Returned: clientid: %s, requestid: %s" % (
clientid,
requestid,
))
# remove this request from processing deque
client = self.clients[clientid]
client['processing'].discard(requestid)
# try to cancel the processing request.
# if occured an exception, that means the request
# was already finishd.
try:
self.processing_timeout[requestid].cancel()
del self.processing_timeout[requestid]
except KeyError: # 已经处理完成
pass
if requestid in self.push_requests:
push = self.push_requests[requestid]
if 'error' not in result:
push['defer'].callback(result['result'])
else:
error = result['error']
push['defer'].errback(
failure.Failure(
pb.RemoteError(
error['type'],
error['value'],
error['traceback'],
)))
servicename = push['servicename']
# remove this request from push_queue
try:
self.push_queue[servicename].remove(requestid)
except:
pass
if push['clientid'] is not None:
try:
self.clients[push['clientid']]['pushing'].discard(
requestid)
except:
pass
def f():
with pb._wrapRemoteException():
raise twisted_pb.RemoteError(
'twisted.spread.flavors.ProtocolError', None, None)
def f():
with pb._wrapRemoteException():
raise twisted_pb.RemoteError(
'twisted.spread.flavors.NoSuchMethod', None, None)
def side_effect(*args, **kwargs):
if args[0] == 'print':
return
return defer.fail(twisted_pb.RemoteError(
'twisted.spread.flavors.NoSuchMethod', None, None))
def extractFailure(reason):
return failure.Failure(
pb.RemoteError(reason.type, reason.value, reason.printTraceback))
