def invoke(self, task, arguments, continuation=lambda r: r, worker=None):
environment = self.environment.create_local_environment(
worker.environment)
environment.define(Symbols.TASK, task)
environment.define_each(self.parameters, arguments)
return Evaluation(environment, self.body, self.factory,
task.finalise).result
def test_evaluation_of_lifo(self):
environment = Environment()
queue = LIFO()
Evaluation(environment, queue, Factory()).result
queue = environment.look_up(Symbols.QUEUE).delegate
self.assertIsInstance(queue, LIFOTaskPool)
def invoke(self):
def post_processing(result):
if result.is_successful:
self.on_success()
elif result.is_erroneous:
self.on_error()
else:
pass
self.environment.define(Symbols.TASK, Task())
env = self.environment.create_local_environment(self.environment)
env.define(Symbols.WORKER, self)
Evaluation(env, self.body, self.factory, post_processing).result
def test_evaluation_of_sequence_stops_at_the_first_failure(self):
environment = Environment()
succeed = MagicMock(Expression)
succeed.accept = MagicMock(return_value=Success())
def check_result(status):
self.assertTrue(status.is_erroneous)
Evaluation(environment,
Sequence(Fail(), succeed),
Factory(),
continuation=check_result).result
succeed.accept.assert_not_called()
def invoke(self, task, arguments, continuation=lambda r: r, worker=None):
environment = self.environment.create_local_environment(
worker.environment)
environment.define(Symbols.TASK, task)
environment.define_each(self.parameters, arguments)
def compute_and_send_response(status):
if task.request.kind == task.request.QUERY:
return Evaluation(environment, Think(1), self.factory,
lambda s: send_response(status)).result
else:
send_response(status)
def send_response(status):
if status.is_successful:
if task.request.is_pending: # Could have timed out
task.request.reply_success()
self.listener.success_replied_to(task.request)
else:
self.listener.error_replied_to(task.request)
elif status.is_erroneous:
task.request.reply_error()
self.listener.error_replied_to(task.request)
else:
pass
service = environment.look_up(Symbols.SELF)
worker = environment.dynamic_look_up(Symbols.WORKER)
service.release(worker)
continuation(
status
) # TODO: Must be over! Remove this useless call to continuation
return Evaluation(environment, self.body, self.factory,
compute_and_send_response).result
def evaluate(self, expression, continuation=lambda x: x):
return Evaluation(self.environment, expression, self.factory,
continuation).result
def compute_and_send_response(status):
if task.request.kind == task.request.QUERY:
return Evaluation(environment, Think(1), self.factory,
lambda s: send_response(status)).result
else:
send_response(status)
def test_evaluation_of_fail(self):
environment = Environment()
result = Evaluation(environment, Fail(), Factory()).result
self.assertTrue(result.is_erroneous)