def start(self):
"""
Start the coordinator by clearing conflicting metadata and restarting any
interrupted tasks.
"""
# drop all previous knowledge of previous calls
self.call_resource_collection.remove(safe=True)
# re-start interrupted tasks
queued_call_collection = QueuedCall.get_collection()
queued_call_list = list(queued_call_collection.find().sort('timestamp'))
queued_call_collection.remove(safe=True)
queued_call_request_list = [CallRequest.deserialize(q['serialized_call_request']) for q in queued_call_list]
while queued_call_request_list:
call_request = queued_call_request_list[0]
# individually call un-grouped calls
if call_request.group_id is None:
queued_call_request_list.remove(call_request)
self.execute_call_asynchronously(call_request)
continue
# call grouped calls at all at once
call_request_group = [c for c in queued_call_request_list if c.group_id == call_request.group_id]
map(queued_call_request_list.remove, call_request_group)
try:
# NOTE (jconnor 2012-10-12) this will change the group_id, but I don't think I care
self.execute_multiple_calls(call_request_group)
except TopologicalSortError, e:
log_msg = _('Cannot execute call request group: %(g)s' % {'g': call_request.group_id})
_LOG.warn('\n'.join((log_msg, str(e))))
def test_serialize_deserialize(self):
args = ["fee", "fie", "foe", "foo"]
kwargs = {"one": "foo", "two": "bar", "three": "baz"}
call_request = CallRequest(function, args, kwargs)
data = call_request.serialize()
self.assertTrue(isinstance(data, dict))
call_request_2 = CallRequest.deserialize(data)
self.assertTrue(isinstance(call_request_2, CallRequest), str(type(call_request_2)))
def test_serialize_deserialize(self):
args = ['fee', 'fie', 'foe', 'foo']
kwargs = {'one': 'foo', 'two': 'bar', 'three': 'baz'}
call_request = CallRequest(function, args, kwargs)
data = call_request.serialize()
self.assertTrue(isinstance(data, dict))
call_request_2 = CallRequest.deserialize(data)
self.assertTrue(isinstance(call_request_2, CallRequest), str(type(call_request_2)))
def test_serialize_deserialize_with_execution_hook(self):
key = dispatch_constants.CALL_CANCEL_LIFE_CYCLE_CALLBACK
call_request = CallRequest(function)
call_request.add_life_cycle_callback(key, function)
data = call_request.serialize()
self.assertTrue(isinstance(data, dict))
call_request_2 = CallRequest.deserialize(data)
self.assertTrue(isinstance(call_request_2, CallRequest))
self.assertTrue(call_request_2.execution_hooks[key][0] == function)
def test_serialize_deserialize_with_control_hook(self):
key = dispatch_constants.CALL_CANCEL_CONTROL_HOOK
call_request = CallRequest(function)
call_request.add_control_hook(key, function)
data = call_request.serialize()
self.assertTrue(isinstance(data, dict))
call_request_2 = CallRequest.deserialize(data)
self.assertTrue(isinstance(call_request_2, CallRequest))
self.assertTrue(call_request_2.control_hooks[key] == function)
def test_serialize_deserialize_with_execution_hook(self):
key = dispatch_constants.CALL_CANCEL_LIFE_CYCLE_CALLBACK
call_request = CallRequest(function)
call_request.add_life_cycle_callback(key, function)
data = call_request.serialize()
self.assertTrue(isinstance(data, dict))
call_request_2 = CallRequest.deserialize(data)
self.assertTrue(isinstance(call_request_2, CallRequest))
self.assertTrue(call_request_2.execution_hooks[key][0] == function)
def test_serialize_deserialize_with_control_hook(self):
key = dispatch_constants.CALL_CANCEL_CONTROL_HOOK
call_request = CallRequest(function)
call_request.add_control_hook(key, function)
data = call_request.serialize()
self.assertTrue(isinstance(data, dict))
call_request_2 = CallRequest.deserialize(data)
self.assertTrue(isinstance(call_request_2, CallRequest))
self.assertTrue(call_request_2.control_hooks[key] == function)
def test_serialize_deserialize(self):
args = ['fee', 'fie', 'foe', 'foo']
kwargs = {'one': 'foo', 'two': 'bar', 'three': 'baz'}
call_request = CallRequest(function, args, kwargs)
data = call_request.serialize()
self.assertTrue(isinstance(data, dict))
call_request_2 = CallRequest.deserialize(data)
self.assertTrue(isinstance(call_request_2, CallRequest),
str(type(call_request_2)))
def test_queued_call_collection(self):
task = self.gen_task(call=call)
collection = QueuedCall.get_collection()
try:
self.queue.enqueue(task)
except:
self.fail(traceback.format_exc())
queued_call = collection.find_one({'_id': task.queued_call_id})
self.assertFalse(queued_call is None)
self.assertFalse(queued_call['serialized_call_request'] is None)
try:
call_request = CallRequest.deserialize(queued_call['serialized_call_request'])
except:
self.fail(traceback.format_exc())
self.assertFalse(call_request is None)
def start(self):
"""
Start the coordinator by clearing conflict metadata and restarting any
interrupted tasks.
"""
# drop all previous knowledge of running tasks
task_resource_collection = TaskResource.get_collection()
task_resource_collection.remove(safe=True)
# re-start interrupted tasks
queued_call_collection = QueuedCall.get_collection()
queued_call_list = list(queued_call_collection.find().sort('timestamp'))
queued_call_collection.remove(safe=True)
for queued_call in queued_call_list:
call_request = CallRequest.deserialize(queued_call['serialized_call_request'])
call_report = self.execute_call_asynchronously(call_request)
def test_queued_call_collection(self):
task = self.gen_task(call=call)
collection = QueuedCall.get_collection()
try:
self.queue.enqueue(task)
except:
self.fail(traceback.format_exc())
queued_call = collection.find_one({'_id': task.queued_call_id})
self.assertFalse(queued_call is None)
self.assertFalse(queued_call['serialized_call_request'] is None)
try:
call_request = CallRequest.deserialize(
queued_call['serialized_call_request'])
except:
self.fail(traceback.format_exc())
self.assertFalse(call_request is None)
def start(self):
"""
Start the coordinator by clearing conflicting metadata and restarting any
interrupted tasks.
"""
# drop all previous knowledge of previous calls
self.call_resource_collection.remove(safe=True)
# re-start interrupted tasks
queued_call_collection = QueuedCall.get_collection()
queued_call_list = list(
queued_call_collection.find().sort('timestamp'))
queued_call_collection.remove(safe=True)
queued_call_request_list = [
c for c in [
CallRequest.deserialize(q['serialized_call_request'])
for q in queued_call_list
] if c is not None
]
while queued_call_request_list:
call_request = queued_call_request_list[0]
# individually call un-grouped calls
if call_request.group_id is None:
queued_call_request_list.remove(call_request)
self.execute_call_asynchronously(call_request)
continue
# call grouped calls at all at once
call_request_group = [
c for c in queued_call_request_list
if c.group_id == call_request.group_id
]
map(queued_call_request_list.remove, call_request_group)
try:
# NOTE (jconnor 2012-10-12) this will change the group_id, but I don't think I care
self.execute_multiple_calls(call_request_group)
except TopologicalSortError, e:
log_msg = _('Cannot execute call request group: %(g)s' %
{'g': call_request.group_id})
_LOG.warn('\n'.join((log_msg, str(e))))
