コード例 #1
0
ファイル: DWMService.py プロジェクト: smarkm/ovm
 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()
コード例 #2
0
ファイル: DWMService.py プロジェクト: smarkm/ovm
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()