def activity_callback(activity_id, callback_data):
"""
callback a schedule node
:param activity_id:
:param callback_data:
:return:
"""
version = Status.objects.version_for(activity_id)
times = 0
# it's possible that ScheduleService is not be set when callback make
while times < 3:
try:
service = ScheduleService.objects.schedule_for(activity_id, version)
break
except ScheduleService.DoesNotExist as e:
times += 1
time.sleep(times)
if times >= 3:
raise e
try:
process_id = PipelineProcess.objects.get(current_node_id=activity_id).id
except PipelineProcess.DoesNotExist:
return ActionResult(result=False,
message='invalid operation, this node is finished or pipeline have been revoked')
if service.is_finished:
raise exceptions.InvalidOperationException('activity(%s) callback already finished' % activity_id)
service.callback(callback_data, process_id)
return ActionResult(result=True, message='success')
def callback(self, callback_data, process_id):
if not self.wait_callback:
raise exceptions.InvalidOperationException('can\'t callback a poll schedule.')
self.callback_data = callback_data
self.save()
valve.send(signals, 'schedule_ready', sender=ScheduleService, process_id=process_id, schedule_id=self.id,
countdown=0)
def set_next_schedule(self):
if self.wait_callback:
raise exceptions.InvalidOperationException('can\'t set next schedule on callback schedule.')
count_down = self.service_act.service.interval.next()
self.is_scheduling = False
self.save()
ScheduleCeleryTask.objects.unbind(self.id)
valve.send(signals, 'schedule_ready', sender=ScheduleService, process_id=self.process_id,
schedule_id=self.id,
countdown=count_down)
def activity_callback(activity_id, callback_data):
"""
callback a schedule node
:param activity_id:
:param callback_data:
:return:
"""
if FunctionSwitch.objects.is_frozen():
return False
version = Status.objects.version_for(activity_id)
service = ScheduleService.objects.schedule_for(activity_id, version)
process_id = PipelineProcess.objects.get(current_node_id=activity_id).id
if service.is_finished:
raise exceptions.InvalidOperationException(
'activity(%s) callback already finished' % activity_id)
service.callback(callback_data, process_id)
return True
def get_status_tree(node_id, max_depth=1):
"""
get state and children states for a node
:param node_id:
:param max_depth:
:return:
"""
rel_qs = NodeRelationship.objects.filter(ancestor_id=node_id,
distance__lte=max_depth)
if not rel_qs.exists():
raise exceptions.InvalidOperationException(
'node(%s) does not exist, may have not by executed' % node_id)
descendants = map(lambda rel: rel.descendant_id, rel_qs)
# remove root node
descendants.remove(node_id)
rel_qs = NodeRelationship.objects.filter(descendant_id__in=descendants,
distance=1)
targets = map(lambda rel: rel.descendant_id, rel_qs)
root_status = Status.objects.filter(id=node_id).values().first()
root_status['elapsed_time'] = calculate_elapsed_time(
root_status['started_time'], root_status['archived_time'])
status_map = {node_id: root_status}
status_qs = Status.objects.filter(id__in=targets).values()
for status in status_qs:
status['elapsed_time'] = calculate_elapsed_time(
status['started_time'], status['archived_time'])
status_map[status['id']] = status
relationships = [(s.ancestor_id, s.descendant_id) for s in rel_qs]
for (parent_id, child_id) in relationships:
if parent_id not in status_map:
return
parent_status = status_map[parent_id]
child_status = status_map[child_id]
child_status.setdefault('children', {})
parent_status.setdefault('children',
{}).setdefault(child_id, child_status)
return status_map[node_id]
def start_pipeline(pipeline_instance, check_workers=True, priority=PIPELINE_DEFAULT_PRIORITY):
"""
start a pipeline
:param pipeline_instance:
:param priority:
:return:
"""
if priority > PIPELINE_MAX_PRIORITY or priority < PIPELINE_MIN_PRIORITY:
raise exceptions.InvalidOperationException('pipeline priority must between [{min}, {max}]'.format(
min=PIPELINE_MIN_PRIORITY, max=PIPELINE_MAX_PRIORITY
))
Status.objects.prepare_for_pipeline(pipeline_instance)
process = PipelineProcess.objects.prepare_for_pipeline(pipeline_instance)
PipelineModel.objects.prepare_for_pipeline(pipeline_instance, process, priority)
PipelineModel.objects.pipeline_ready(process_id=process.id)
return ActionResult(result=True, message='success')
