def dom_start(self, auth, dom, node, retry_count=1, wait_interval=3):
retry = 0
dom.node = node
try:
wait_interval = float(wait_interval)
except Exception as e:
traceback.print_exc()
LOGGER.info('Error converting wait_interval(' + str(wait_interval) + ') to float ' + 'default to 3')
wait_interval = 3
try:
retry_count = int(retry_count)
except Exception as e:
traceback.print_exc()
LOGGER.info('Error converting retry_count(' + str(retry_count) + ') to int ' + 'default to 3')
retry_count = 3
if retry < retry_count:
try:
tc = TaskCreator()
task_id = tc.vm_action(auth, dom.id, node.id, constants.START, constants.CORE, constants.Maintenance)
LOGGER.info('Trying to start the Virtual Machine:' + dom.name + '. Try:' + str(retry + 1) + '. Task:' + str(task_id))
wait_time = dom.get_wait_time(constants.START)
wait_time = int(wait_time) + 3
finished,status = self.wait_for_task_completion(task_id, wait_time)
# as status
if finished == True and status == Task.SUCCEEDED:
return True
except Exception as e:
traceback.print_exc()
LOGGER.info('Error trying to start Virtual Machine,' + dom.name + '. ' + to_str(e))
if retry != retry_count - 1:
time.sleep(wait_interval)
retry += 1
return False
def process_ha_events(self, conn):
try:
tc = TaskCreator()
auth = AuthorizationService()
auth.user = User.by_user_name(u'admin')
grps = conn.query(ServerGroup).all()
for grp in grps:
running_ha_evts = conn.query(HAEvent).filter(HAEvent.status == HAEvent.STARTED).filter(HAEvent.sp_id == grp.id).all()
if running_ha_evts:
continue
ha_events = conn.query(HAEvent).filter(HAEvent.status == HAEvent.IDLE).filter(HAEvent.sp_id == grp.id).order_by(HAEvent.event_id.asc()).all()
if len(ha_events) > 0:
tc.ha_action(auth, grp.id, grp.name)
finally:
conn.commit()
def dom_pause(self, auth, dom, node):
dom.node = node
try:
tc = TaskCreator()
task_id = tc.vm_action(auth, dom.id, node.id, constants.PAUSE, constants.CORE)
LOGGER.info('Trying to pause the Virtual Machine:' + dom.name + '. Task:' + str(task_id))
wait_time = dom.get_wait_time(constants.PAUSE)
wait_time = int(wait_time) + 3
finished,status = self.wait_for_task_completion(task_id, wait_time)
if finished == True and status == Task.SUCCEEDED:
return True
except Exception as e:
traceback.print_exc()
LOGGER.info('Error trying to pause Virtual Machine,' + dom.name + '. ' + to_str(e))
return False
def dom_migrate(self, auth, dom, src_node, dest_node, live=None):
LOGGER.debug('In dom_migrate: \ndom, src_node, dest_node, live\n%s, %s, %s, %s' % (dom, src_node, dest_node, live))
try:
tc = TaskCreator()
dom_ent = DBSession.query(Entity).filter(Entity.entity_id == dom.id).first()
node_ent = dom_ent.parents[0]
task_id = tc.migrate_vm(auth, [dom.id], node_ent.entity_id, dest_node.id, live, None, None, constants.Maintenance)
self.maint_task_context['migrated_vms'].append((dom.id, task_id))
self.update_maint_task_context()
wait_time = dom.get_wait_time(constants.MIGRATE)
wait_time = int(wait_time) + 3
finished,status = self.wait_for_task_completion(task_id, wait_time)
if finished == True and status == Task.SUCCEEDED:
return True
except Exception as e:
traceback.print_exc()
LOGGER.info('Error trying to migrate Virtual Machine,' + dom.name + '. ' + to_str(e))
return False
def delete_dwm_details(cls, group_id):
try:
task_ids = []
policy_ids = []
dwms = DBSession.query(DWM).filter(DWM.sp_id == group_id).all()
for dwm in dwms:
task_ids.append(dwm.interval_task_id)
if isinstance(dwm.calendar_task_ids,list):
task_ids.extend(dwm.calendar_task_ids)
policy_ids.append(dwm.id)
if policy_ids:
tc = TaskCreator()
DBSession.query(DWMPolicySchedule).filter(DWMPolicySchedule.policy_id.in_(policy_ids)).delete()
DBSession.query(SPDWMPolicy).filter(SPDWMPolicy.sp_id == group_id).delete()
DBSession.query(DWM).filter(DWM.id.in_(policy_ids)).delete()
tc.delete_task(task_ids)
return True
except Exception,ex:
traceback.print_exc()
def sync_task(self, auth, type, logger=None):
from sqlalchemy.orm import eagerload
from stackone.model.services import Task
from stackone.viewModel.TaskCreator import TaskCreator
tc = TaskCreator()
boot_time = self.get_boot_time()
msg = {Task.STARTED:' is not completed in '+str(boot_time)+ 'seconds',\
Task.FAILED:' failed.',Task.CANCELED:' canceled.',Task.SUCCEEDED:' succeeded.',\
}
if not logger:
logger = LOGGER
result_flags = {}
logger.info('Submitting ' + str(type) + ' Sync task for ' + self.hostname)
nw_task = tc.server_sync_task(auth,self.id,type,True)
task_ids = [nw_task]
result_flags['flag'+str(nw_task)] = Task.STARTED
result = False
for i in range(0, boot_time):
time.sleep(3)
transaction.begin()
tasks = DBSession.query(Task).filter(Task.task_id.in_(task_ids)).options(eagerload('result')).all()
for task in tasks:
if task.is_finished():
result_flags['flag'+str(task.task_id)] = task.result[0].status
if task.result[0].status == Task.SUCCEEDED:
result = True
task_ids.remove(task.task_id)
if len(task_ids) == 0:
transaction.commit()
break
transaction.commit()
nw_msg = str(type) + ' syncing task(id:' + str(nw_task) + ') for ' + self.hostname + msg[result_flags['flag'+ str(nw_task)]]
logger.info(nw_msg)
return result
def __init__(self, auth):
from stackone.viewModel.TaskCreator import TaskCreator
self.max_workers = 1
self.worker = u'DefaultWorker'
self.worker_ids = []
self.available_workers = self.max_workers
self.tc = TaskCreator()
self.auth = auth
self.start_time = datetime.now()
self.execution_context = {}
s = DBSession.query(ServiceItem).filter(ServiceItem.name == to_unicode('Task Manager Service')).one()
self.task_service_id = s.id
self.svc_central = base_config.stackone_service_central
try:
self.max_worker_wait_time = int(tg.config.get('max_worker_wait_time'))
except Exception as e:
print 'Exception: ',e
self.max_worker_wait_time = 300
def save_dwm_details(self, auth, group_id, policy_object, enabled, offset):
try:
self.tc = TaskCreator()
self.utcoffset = timedelta(milliseconds=long(offset))
group = self.get_group(auth, group_id)
if enabled == 'true':
dwm_list = DBSession.query(DWM).filter(DWM.sp_id == group_id).all()
task_ids = []
interval_task_ids = []
dwmelems = {}
for dwmelem in dwm_list:
interval_task_ids.append(dwmelem.interval_task_id)
if dwmelem.calendar_task_ids:
task_ids.extend(dwmelem.calendar_task_ids)
dwmelem.enabled = False
dwmelems[dwmelem.policy] = dwmelem
if task_ids:
self.tc.delete_task(task_ids)
policy_obj = json.loads(policy_object)
policies = policy_obj['policy_object']['policies']
freq = 5
dwms = []
schedules = []
for policy in policies:
dwmelem = dwmelems.get(policy['policy_name'])
if dwmelem != None:
dwmelem.enabled = True
(dwm, policy_schedules) = self.save_dwm_policy(auth, group_id, policy['threshold'], policy['frequency'], policy['data_period'], policy['upper_threshold'], policy['policy_name'], policy['schedule_object'])
freq = policy['frequency']
dwms.append(dwm)
schedules.extend(policy_schedules)
sp_dwm = SPDWMPolicy(group_id, None)
DBSession.merge(sp_dwm)
if interval_task_ids:
self.tc.delete_task(interval_task_ids)
interval_task_id = self.tc.dwm_task(auth, group_id, freq)
for d in dwms:
d.interval_task_id = interval_task_id
DBSession.add(d)
group.dwm_enabled = True
DBSession.add(group)
transaction.commit()
DBSession.add_all(schedules)
transaction.commit()
DBSession.query(DWM).filter(DWM.sp_id == group_id).update(dict(interval_task_id=interval_task_id))
pol = DWM.find_current_policy(group_id)
if pol and pol.is_enabled():
sp_dwm = SPDWMPolicy.set_sp_current_policy(group_id, pol.policy, SPDWMPolicy.ON)
return True
result = self.delete_dwm_tasks(auth, group_id)
DBSession.query(DWM).filter(DWM.sp_id == group_id).update(dict(interval_task_id=None, calendar_task_ids=None))
group.dwm_enabled = False
DBSession.add(group)
sp_dwm = SPDWMPolicy(group_id, None)
DBSession.merge(sp_dwm)
return result
except Exception as ex:
traceback.print_exc()
raise ex
class DWMService():
#PASSED
def __init__(self):
self.tc = None
self.utcoffset = None
#PASSED
def get_group(self, auth, group_id):
return DBSession.query(ServerGroup).filter(ServerGroup.id == group_id).first()
#PASSED
def get_dwm_details(self, auth, group_id):
info = []
group = self.get_group(auth, group_id)
if group:
dwm_enabled = group.dwm_enabled
dwms = DBSession.query(DWM).filter(DWM.sp_id == group_id).all()
for dwm in dwms:
schedule = self.get_dwm_schedule_details(group_id, dwm.id)
info.append(dict(policy_id=dwm.id, policy=dwm.policy, frequency=dwm.frequency, data_period=dwm.data_period, threshold=dwm.threshold, scobject=schedule, enabled=dwm.enabled, up_threshold=dwm.upper_threshold, dwm_enabled=dwm_enabled))
return info
#PASSED
def get_dwm_schedule_details(self, group_id, policy_id):
info = []
schedules = self.get_dwm_schedule(group_id, policy_id)
for schedule in schedules:
sch = {}
sch['type'] = schedule.type
sch['starttime'] = schedule.start_time
sch['duration'] = schedule.duration
if schedule.type == 'Daily':
day = 'Daily'
elif schedule.type == 'Weekly':
day = schedule.weekdays_list
sch['dows'] = schedule.dows
sch['weekdays_list'] = day
sch['day'] = day
info.append(sch)
return info
#PASSED
def get_dwm_schedule(self, group_id, policy_id):
schedules = DBSession.query(DWMPolicySchedule).filter(DWMPolicySchedule.policy_id == policy_id).filter(DWMPolicySchedule.sp_id == group_id).all()
return schedules
#PASSED
def save_dwm_details(self, auth, group_id, policy_object, enabled, offset):
try:
self.tc = TaskCreator()
self.utcoffset = timedelta(milliseconds=long(offset))
group = self.get_group(auth, group_id)
if enabled == 'true':
dwm_list = DBSession.query(DWM).filter(DWM.sp_id == group_id).all()
task_ids = []
interval_task_ids = []
dwmelems = {}
for dwmelem in dwm_list:
interval_task_ids.append(dwmelem.interval_task_id)
if dwmelem.calendar_task_ids:
task_ids.extend(dwmelem.calendar_task_ids)
dwmelem.enabled = False
dwmelems[dwmelem.policy] = dwmelem
if task_ids:
self.tc.delete_task(task_ids)
policy_obj = json.loads(policy_object)
policies = policy_obj['policy_object']['policies']
freq = 5
dwms = []
schedules = []
for policy in policies:
dwmelem = dwmelems.get(policy['policy_name'])
if dwmelem != None:
dwmelem.enabled = True
(dwm, policy_schedules) = self.save_dwm_policy(auth, group_id, policy['threshold'], policy['frequency'], policy['data_period'], policy['upper_threshold'], policy['policy_name'], policy['schedule_object'])
freq = policy['frequency']
dwms.append(dwm)
schedules.extend(policy_schedules)
sp_dwm = SPDWMPolicy(group_id, None)
DBSession.merge(sp_dwm)
if interval_task_ids:
self.tc.delete_task(interval_task_ids)
interval_task_id = self.tc.dwm_task(auth, group_id, freq)
for d in dwms:
d.interval_task_id = interval_task_id
DBSession.add(d)
group.dwm_enabled = True
DBSession.add(group)
transaction.commit()
DBSession.add_all(schedules)
transaction.commit()
DBSession.query(DWM).filter(DWM.sp_id == group_id).update(dict(interval_task_id=interval_task_id))
pol = DWM.find_current_policy(group_id)
if pol and pol.is_enabled():
sp_dwm = SPDWMPolicy.set_sp_current_policy(group_id, pol.policy, SPDWMPolicy.ON)
return True
result = self.delete_dwm_tasks(auth, group_id)
DBSession.query(DWM).filter(DWM.sp_id == group_id).update(dict(interval_task_id=None, calendar_task_ids=None))
group.dwm_enabled = False
DBSession.add(group)
sp_dwm = SPDWMPolicy(group_id, None)
DBSession.merge(sp_dwm)
return result
except Exception as ex:
traceback.print_exc()
raise ex
#PASSED
def save_dwm_policy(self, auth, group_id, threshold, frequency, data_period, upper_threshold, policyname, schedule_object):
try:
dwm = DBSession.query(DWM).filter(DWM.sp_id == group_id).filter(DWM.policy == policyname).first()
if dwm:
dwm.threshold = threshold
dwm.frequency = frequency
dwm.data_perod = data_period
dwm.upper_threshold = upper_threshold
else:
dwm = DWM(group_id, policyname, threshold, frequency, data_period)
(calendar_task_ids, policy_schedules) = self.add_dwm_policy_schedule(auth, group_id, dwm.id, policyname, schedule_object)
dwm.calendar_task_ids = calendar_task_ids
dwm.upper_threshold = upper_threshold
dwm.enabled = True
return (dwm, policy_schedules)
except Exception as ex:
traceback.print_exc()
raise ex
#PASSED
def add_dwm_policy_schedule(self, auth, sp_id, policy_id, policy_name, schedules):
try:
start_schedule_list = []
end_schedule_list = []
calendar_task_ids = []
tot_shedules = []
policy_schedules = []
for schedule in schedules:
policy_schedule = DWMPolicySchedule()
policy_schedule.policy_id = policy_id
policy_schedule.sp_id = sp_id
policy_schedule.type = schedule['type']
policy_schedule.start_time = schedule['starttime']
policy_schedule.duration = schedule['duration']
timeparts = schedule['starttime'].split(':')
hr = int(timeparts[0])
min = int(timeparts[1])
durn = int(schedule['duration'])
start = float(timeparts[0] + '.' + timeparts[1])
end = start
today = datetime.now()
start_day = datetime(today.year, today.month, today.day, hr, min)
start_day = start_day + self.utcoffset
occurance = schedule['type']
if occurance == DWMPolicySchedule.WEEKLY:
weekday_string = schedule['weekdays_list']
policy_schedule.weekdays_list = weekday_string
dows_list = schedule['dows']
dows = dows_list
policy_schedule.dows = dows
utc_dows = []
for dow in dows:
dow = int(dow)
while start_day.weekday() != dow:
start_day += timedelta(days=1)
utc_dows.append(start_day.weekday())
end_day = start_day + timedelta(hours=durn)
start_schedule_elem = dict(occurance=occurance, dow=dow, start_day=[dow], hour=start_day.hour, minute=start_day.minute)
end_schedule_elem = dict(occurance=occurance, dow=end_day.weekday(), start_day=[dow], hour=end_day.hour, minute=end_day.minute)
start_schedule_list.append(start_schedule_elem)
end_schedule_list.append(end_schedule_elem)
policy_schedule.utc_days_list = utc_dows
if occurance == DWMPolicySchedule.DAILY:
end_day = start_day + timedelta(hours=durn)
start_schedule_elem = dict(occurance=occurance, hour=start_day.hour, minute=start_day.minute)
end_schedule_elem = dict(occurance=occurance, hour=end_day.hour, minute=end_day.minute)
start_schedule_list.append(start_schedule_elem)
end_schedule_list.append(end_schedule_elem)
end = float(str(end_day.hour) + '.' + get_minute_string(end_day.minute))
start = float(str(start_day.hour) + '.' + get_minute_string(start_day.minute))
policy_schedule.start = start
policy_schedule.end = end
policy_schedule.hour = start_day.hour
policy_schedule.minute = start_day.minute
policy_schedules.append(policy_schedule)
tot_shedules.append(dict(policy_schedule=policy_schedule, start=start_schedule_elem, end=end_schedule_elem))
for policy_sch in policy_schedules:
for sch in tot_shedules:
if sch.get('policy_schedule') != policy_sch:
print '\n\n++++++++++++++++++++++++++++++++++++check_overlapping_schedules'
if DWM.check_overlapping_schedules([sch.get('start')], [policy_sch], 'start', True) == True:
if DWM.check_overlapping_schedules([sch.get('end')], [policy_sch], 'end', True) == True:
raise Exception('Overlapping schedules within a Policy is not allowed.')
self.delete_dwm_schedule_details(policy_id, sp_id)
calendar_task_ids.append(self.tc.dwm_calendar_task(auth, sp_id, policy_name, SPDWMPolicy.ON, start_schedule_list))
calendar_task_ids.append(self.tc.dwm_calendar_task(auth, sp_id, policy_name, SPDWMPolicy.OFF, end_schedule_list))
return (calendar_task_ids, policy_schedules)
except Exception as ex:
traceback.print_exc()
raise ex
#PASSED
def delete_dwm_tasks(self, auth, group_id):
try:
task_ids = []
dwms = DBSession.query(DWM).filter(DWM.sp_id == group_id).all()
for dwm in dwms:
task_ids.append(dwm.interval_task_id)
if isinstance(dwm.calendar_task_ids, list):
task_ids.extend(dwm.calendar_task_ids)
if task_ids:
self.tc.delete_task(task_ids)
return True
except Exception as ex:
traceback.print_exc()
raise ex
#PASSED
def delete_dwm_schedule_details(self, policy_id, group_id):
try:
dwm_schedules = DBSession.query(DWMPolicySchedule).filter(DWMPolicySchedule.sp_id == group_id).filter(DWMPolicySchedule.policy_id == policy_id).delete()
return True
except Exception as ex:
traceback.print_exc()
raise ex
@classmethod
def delete_dwm_details(cls, group_id):
try:
task_ids = []
policy_ids = []
dwms = DBSession.query(DWM).filter(DWM.sp_id == group_id).all()
for dwm in dwms:
task_ids.append(dwm.interval_task_id)
if isinstance(dwm.calendar_task_ids,list):
task_ids.extend(dwm.calendar_task_ids)
policy_ids.append(dwm.id)
if policy_ids:
tc = TaskCreator()
DBSession.query(DWMPolicySchedule).filter(DWMPolicySchedule.policy_id.in_(policy_ids)).delete()
DBSession.query(SPDWMPolicy).filter(SPDWMPolicy.sp_id == group_id).delete()
DBSession.query(DWM).filter(DWM.id.in_(policy_ids)).delete()
tc.delete_task(task_ids)
return True
except Exception,ex:
traceback.print_exc()
class WorkManager():
#pass
def __init__(self, auth):
from stackone.viewModel.TaskCreator import TaskCreator
self.max_workers = 1
self.worker = u'DefaultWorker'
self.worker_ids = []
self.available_workers = self.max_workers
self.tc = TaskCreator()
self.auth = auth
self.start_time = datetime.now()
self.execution_context = {}
s = DBSession.query(ServiceItem).filter(ServiceItem.name == to_unicode('Task Manager Service')).one()
self.task_service_id = s.id
self.svc_central = base_config.stackone_service_central
try:
self.max_worker_wait_time = int(tg.config.get('max_worker_wait_time'))
except Exception as e:
print 'Exception: ',e
self.max_worker_wait_time = 300
#pass
def get_work(self):
raise Exception('get_work needs to be implemented.')
#pass
def get_task(self):
pass
#pass
def workers_in_progress(self):
return self.worker_ids
#pass
def make_entity_task_entries(self, task_id, entity_ids):
ent_tasks = []
#add 0902
WRK_LOGGER.debug('in make_entity_task_entries task_id : ' + str(task_id) + ' :entity_ids :' + str(entity_ids))
for ent_id in entity_ids:
try:
ent_task = EntityTasks(self.worker, to_unicode(task_id), ent_id, False, datetime.now())
ent_tasks.append(ent_task)
except Exception as e:
traceback.print_exc()
self.update_execution_context()
for ent_task in ent_tasks:
DBSession.merge(ent_task)
transaction.commit()
#add 0902
WRK_LOGGER.debug('in make_entity_task_entries committed task_id : ' + str(task_id) + ' :entity_ids :' + str(entity_ids))
#pass
def wait_for_workers_to_finish(self, task_ids):
WRK_LOGGER.debug('wait_for_workers_to_finish for ' + self.worker + ' max_worker_wait_time: ' + str(self.max_worker_wait_time))
task_completed = False
self.wait_start_time = datetime.now()
while task_completed == False:
time.sleep(5)
completed_tasks = self.check_tasks_completed(task_ids)
WRK_LOGGER.debug('wait_for_workers_to_finish for ' + self.worker + ' completed_tasks :' + str(completed_tasks))
if len(completed_tasks) > 0:
task_completed = True
for task in completed_tasks:
self.worker_ids.remove(task['task_id'])
WRK_LOGGER.debug('child task completed, update EntityTasks ' + self.worker + ' completed_tasks :' + str(task['task_id']))
ets = DBSession.query(EntityTasks).filter(EntityTasks.worker_id == to_unicode(task['task_id'])).all()
for et in ets:
et.worker_id = None
et.finished = True
et.end_time = datetime.now()
DBSession.merge(et)
transaction.commit()
WRK_LOGGER.debug('child tasks completed, updated EntityTasks ' + self.worker)
wait_time_sec = (datetime.now() - self.wait_start_time).seconds
WRK_LOGGER.debug('No completed child tasks for ' + self.worker + '. waiting for ' + str(wait_time_sec))
if wait_time_sec > self.max_worker_wait_time:
task_service = self.svc_central.get_service(self.task_service_id)
past_time = self.start_time - timedelta(minutes=1)
for task_id in task_ids:
task_obj = task_service.get_running_task_obj(task_id)
if task_obj:
(hung,completed,pending) = task_obj.get_running_status()
WRK_LOGGER.debug('HUNG STATUS for ' + self.worker + ':' + str(hung) + ':' + str(task_id) + ':' + str(completed) + ':' + str(pending))
if hung:
task_completed = True
self.worker_ids.remove(task_id)
WRK_LOGGER.debug('Hung task. Cleanup EntityTask for ' + self.worker + '. task id : ' + str(task_id))
DBSession.query(EntityTasks).filter(EntityTasks.worker == self.worker).filter(EntityTasks.entity_id.in_(completed)).update(dict(worker_id=None, finished=True, end_time=datetime.now()))
DBSession.query(EntityTasks).filter(EntityTasks.worker == self.worker).filter(EntityTasks.entity_id.in_(pending)).update(dict(worker_id=None, finished=True, start_time=past_time))
transaction.commit()
WRK_LOGGER.debug('Hung task. Cleaned up EntityTask for ' + self.worker + '. task id : ' + str(task_id))
#pass
def check_tasks_completed(self, task_ids):
transaction.begin()
tasks = DBSession.query(Task).filter(Task.task_id.in_(task_ids)).options(eagerload('result')).all()
completed_tasks = []
for task in tasks:
if task.is_finished():
completed_tasks.append(dict(task_id=task.task_id, status=task.result[0L].status))
transaction.commit()
return completed_tasks
#pass
def do_work(self):
WRK_LOGGER.debug('GETTING WORK for ' + self.worker)
new_work,entity_ids = self.get_work()
wip = self.workers_in_progress()
while new_work or wip:
if new_work and len(wip) < self.max_workers:
# add 0902
WRK_LOGGER.debug('Submitting new WORK for ' + self.worker)
work_id = self.tc.submit_task(new_work)
self.worker_ids.append(work_id)
WRK_LOGGER.debug('Submitting new WORK for ' + self.worker + ' : child task id : ' + str(work_id))
self.make_entity_task_entries(work_id, entity_ids)
else:
if len(wip) > 0:
WRK_LOGGER.debug('WAIT for ' + self.worker)
self.wait_for_workers_to_finish(wip)
LOGGER.debug('WAIT OVER for ' + self.worker)
WRK_LOGGER.debug('WAIT OVER for ' + self.worker)
WRK_LOGGER.debug('GETTING WORK new for ' + self.worker)
new_work,entity_ids = self.get_work()
wip = self.workers_in_progress()
#pass
def update_execution_context(self):
tid = TaskUtil.get_task_context()
WRK_LOGGER.debug('in update_execution_context Parent task : ' + str(tid) + ' : child tasks :' + str(self.worker_ids))
task = Task.get_task(tid)
if task is not None:
self.execution_context['start_time'] = self.start_time
self.execution_context['worker_ids'] = self.worker_ids
task.context['execution_context'] = self.execution_context
DBSession.add(task)
WRK_LOGGER.debug('in update_execution_context updated Parent task : ' + str(tid))
#pass
def resume_work(self, context):
execution_context = context['execution_context']
WRK_LOGGER.debug('RESUMING WORKER for :' + self.worker)
if execution_context:
self.start_time = execution_context.get('start_time', datetime.now())
self.worker_ids = execution_context.get('worker_ids', [])
self.sp_list = execution_context.get('sp_list', [])
ets = DBSession.query(EntityTasks).filter(EntityTasks.worker == self.worker).filter(not_(EntityTasks.worker_id.in_(self.worker_ids))).all()
#add 0902
if len.ents() > 0:
xtra_work_ids = [et.worker_id for et in ets]
WRK_LOGGER.error('GOT ENT Tasks different from execution_context :' + self.worker + ': CONTEXT WORKERS : ' + str(self.worker_ids) + ': XTRA WORKERS :' + str(xtra_work_ids))
r = DBSession.query(EntityTasks.entity_id).filter(EntityTasks.worker_id.in_(xtra_work_ids)).filter(EntityTasks.worker(self.worker.update=='values')).dict(worker_id =None,finished=True, end_time= datetime.now())
transaction.commit()
WRK_LOGGER.debug('Cleaned Up entity_tasks . worker:rows : ' + self.worker + ':' + str(r))
WRK_LOGGER.debug('RESUMING WORKER for :' + self.worker + ':' + str(self.start_time) + ':' + str(self.worker_ids))
self.do_work()
return None
