Python Scheduler.get_jobs方法代码示例

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class SnortScheduler(SimplePlugin):
    """ Enables Schduling for Snortmanager """
    
    scheduler = None # The APS instance
    
    def __init__(self, bus):
        """ Initiates scheduler. """
        SimplePlugin.__init__(self, bus)
        self.scheduler = Scheduler()
        
    def __initiate_jobs(self):
        """ Adds schedueled tasks if database is empty. """
        sched = self.scheduler
        sched.add_cron_job(update_snort_rules, hour = 7, jobstore='sql')
        sched.add_cron_job(produce_configuration_files, hour = 9, jobstore='sql')
        
    def start(self):
        """ Intitates scheduler when Snortmanager starts """
        sched = self.scheduler
        sched.add_jobstore(ScheduleStore(), 'sql')
        if len(sched.get_jobs()) is 0:
            self.__initiate_jobs()
        sched.start()
    
    def stop(self):
        """ Stops Scheduler service when thread dies. """
        self.scheduler.shutdown(wait=False)
        
    def restart(self):
        """ Restarts the service if necassary. """
        self.stop()
        self.start()
    
    def get_jobs(self):
        return self.scheduler.get_jobs()

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class FreshPots(BotPlugin):

    pots = [
        'http://i.imgur.com/Q2b54vc.jpg',
        'http://i.imgur.com/SYsdsew.jpg',
        'http://i.imgur.com/caIbQMh.png',
        'http://i.imgur.com/MCwiikl.jpg',
        'http://i.imgur.com/g4sFHwz.jpg',
        'http://i.imgur.com/vnuJQ4S.gif',
        'http://i.imgur.com/cm3Y6jX.jpg',
        'http://i.imgur.com/ZcKZTFU.jpg',
        'http://i.imgur.com/4mEaNIp.jpg',
        'http://i.imgur.com/gDukRFu.png',
        'http://i.imgur.com/1MDO9fV.png',
        'http://i.imgur.com/U5cFX3M.jpg'
    ]

    def activate(self):
        super(FreshPots, self).activate()
        self.sched = Scheduler(coalesce=True)
        self.sched.start()
        self.sched.add_cron_job(
            self.fresh_pots,
            kwargs={'message': 'fresh pots time'},
            day_of_week='mon-fri',
            hour=11)
        self.sched.add_cron_job(
            self.fresh_pots,
            kwargs={'message': 'fresh pots time'},
            day_of_week='mon-fri',
            hour=15)
        logging.info(self.sched.get_jobs())

    def callback_message(self, conn, mess):
        body = mess.getBody().lower()
        if body.find('coffee') != -1 or body.find('fresh pots') != -1:
            self.fresh_pots(mess.getFrom())

    def fresh_pots(self, channel='#cloudant-bristol', message=None):
        if message:
            self.send(
                channel,
                message,
                message_type='groupchat'
            )

        self.send(
            channel,
            choice(self.pots),
            message_type='groupchat'
        )
        self.check()

    def check(self):
        for job in self.sched:
            delta = job.next_run_time - datetime.now()
            hour_delta = timedelta(seconds=3600)
            if delta < hour_delta:
                job.compute_next_run_time(datetime.now() + hour_delta)

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class Job_Manager(object):
    def __init__(self, config):
        self.scheduler = Scheduler(config["SCHEDULER"])
        if self.scheduler is not None:
            self.scheduler.start()

    def add_job(self, task, interval, name, *args):
        args = args if args is not None else None
        self.scheduler.add_interval_job(task, seconds=interval, args=args, name=name, max_instances=50)

    def remove_job(self, name):
        matchedJobs = self.__get_jobs(name)
        self.__remove_jobs(matchedJobs)

    def __get_jobs(self, name):
        return [job for job in self.scheduler.get_jobs() if job.name == name]

    def __remove_jobs(self, matchedJobs):
        for job in matchedJobs:
            self.scheduler.unschedule_job(job)

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class ActivityScheduler(baseRunner.BaseRunner):
	def __init__(self):
		super(ActivityScheduler, self).__init__()

		# set logging options as defined in config file
		logConf = self.config._sections["logging"]
		# remove default __name__ item
		del logConf["__name__"]
		logConf["level"] = int(logConf["level"])
		logConf["filename"] = join(dirname(__file__), logConf["filename"])
		logging.basicConfig(**logConf)

		# initialize scheduler
		self.scheduler = Scheduler()
		self.scheduler.start()

		# create initial schedule
		if not self.scheduler.get_jobs():
			self.createSchedule()

		# main loop
		while True:
			try:
				time.sleep(10)
			except KeyboardInterrupt:
				logging.info("Shutting down..")
				self.scheduler.shutdown()
				break

	def createSchedule(self):
		logging.info("Schedule requests..")

		schedules = self.config._sections["schedule"]
		# remove default __name__ item
		del schedules["__name__"]
		for methodName, schedule in schedules.items():
			# schedule handler requests (wrapper method gets called with
			# cron-like notation and the method name)
			# name parameter is given for logging/debugging purposes only
			self.scheduler.add_cron_job(self.wrap, *schedule.split(), \
				args=[methodName], misfire_grace_time=120, name=methodName)

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
def start_schedule():

#if __name__ == '__main__':

    
    scheduler_pl = Scheduler(daemonic = False)

    scheduler_pl.print_jobs()


    scheduler_pl.shutdown()

    
    scheduler_pl.add_jobstore(ShelveJobStore('/tmp/db_pl_schedule'), 'file')

    v_current_jobs = scheduler_pl.get_jobs()

    print v_current_jobs

    if v_current_jobs:  # 如果job存在的话,先请客


        scheduler_pl.unschedule_func(upload_processlist) 

    scheduler_pl.add_interval_job(upload_processlist, minutes=1)
            



    scheduler_pl.start()

    print 'success!'

    scheduler_pl.print_jobs()

    '''

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]

#.........这里部分代码省略.........

    if self.__scheduler.running:
      self.__scheduler.shutdown(wait=False)
      self.__scheduler = Scheduler(self.APS_CONFIG)

    alert_callables = self.__load_definitions()

    # schedule each definition
    for _callable in alert_callables:
      self.schedule_definition(_callable)

    logger.info("[AlertScheduler] Starting {0}; currently running: {1}".format(
      str(self.__scheduler), str(self.__scheduler.running)))

    self.__scheduler.start()


  def stop(self):
    if not self.__scheduler is None:
      self.__scheduler.shutdown(wait=False)
      self.__scheduler = Scheduler(self.APS_CONFIG)

    logger.info("[AlertScheduler] Stopped the alert scheduler.")

  def reschedule(self):
    """
    Removes jobs that are scheduled where their UUID no longer is valid.
    Schedules jobs where the definition UUID is not currently scheduled.
    """
    jobs_scheduled = 0
    jobs_removed = 0

    definitions = self.__load_definitions()
    scheduled_jobs = self.__scheduler.get_jobs()

    # for every scheduled job, see if its UUID is still valid
    for scheduled_job in scheduled_jobs:
      uuid_valid = False

      for definition in definitions:
        definition_uuid = definition.get_uuid()
        if scheduled_job.name == definition_uuid:
          uuid_valid = True
          break

      # jobs without valid UUIDs should be unscheduled
      if uuid_valid == False:
        jobs_removed += 1
        logger.info("[AlertScheduler] Unscheduling {0}".format(scheduled_job.name))
        self._collector.remove_by_uuid(scheduled_job.name)
        self.__scheduler.unschedule_job(scheduled_job)

    # for every definition, determine if there is a scheduled job
    for definition in definitions:
      definition_scheduled = False
      for scheduled_job in scheduled_jobs:
        definition_uuid = definition.get_uuid()
        if definition_uuid == scheduled_job.name:
          definition_scheduled = True
          break

      # if no jobs are found with the definitions UUID, schedule it
      if definition_scheduled == False:
        jobs_scheduled += 1
        self.schedule_definition(definition)

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]

#.........这里部分代码省略.........
        if len(list(processingJobs)) != 0:
            jobs_dict = {}
            try:
                setattr(daemonArgs, jobCommand, 'list')
                jobs_dict = self.sendFrameworkCommand(jobCommand, daemonArgs)
            except:
                return
            finally:
                daemonArgs.clean(jobCommand)

            for processingJob in processingJobs:
                if processingJob.frameworkid in jobs_dict \
                and int(processingJob.status) != int(jobs_dict[processingJob.frameworkid]):
                    
                    try:
                        setattr(daemonArgs, jobCommand, 'details')
                        setattr(daemonArgs, 'gjd_id', processingJob.frameworkid)
                        job_details = self.sendFrameworkCommand(jobCommand, daemonArgs)
                    except:
                        continue
                    finally:
                        daemonArgs.clean(jobCommand)
                        daemonArgs.clean('gjd_id')
                        
                    processingJob.status = jobs_dict[processingJob.frameworkid]
                    processingJob.finished = job_details['job_end_time']
                    processingJob.save()
                elif processingJob.frameworkid not in jobs_dict:
                    processingJob.status = Job.COMPLETED_STATUS
                    processingJob.finished = None
                    processingJob.save()

    def checkJobs(self):
        scheduledJobs = self.scheduler.get_jobs()
        
        # remove scheduled jobs which are set to be deleted or deactivated
        deleteAndDeactivateJobs = Schedule.objects.filter( Q(status=Schedule.DELETE_STATUS) | Q(status=Schedule.DEACTIVATE_STATUS) )
        for deleteAndDeactivateJob in deleteAndDeactivateJobs:
            for scheduledJob in scheduledJobs:
                if scheduledJob.name == deleteAndDeactivateJob.job_name:
                    self.scheduler.unschedule_job(scheduledJob)
            deleteAndDeactivateJob.status = Schedule.DEACTIVATED_STATUS\
                if deleteAndDeactivateJob.status == Schedule.DEACTIVATE_STATUS\
                else Schedule.DELETED_STATUS

            deleteAndDeactivateJob.save()
        
        # add/update unscheduled jobs
        split_re  = re.compile("\s+")
        unScheduledJobs = Schedule.objects.filter( Q(status=Schedule.NEW_STATUS) | Q(status=Schedule.UPDATE_STATUS) )
        for unScheduledJob in unScheduledJobs:
            
            if unScheduledJob.status == Schedule.UPDATE_STATUS:
                for scheduledJob in scheduledJobs:
                    if scheduledJob.name == unScheduledJob.job_name:
                        self.scheduler.unschedule_job(scheduledJob)
            
            if unScheduledJob.scheduled_start is not None:
                schedule = { 'kwargs': { 'unScheduledJob': unScheduledJob }, 'name': unScheduledJob.job_name }
                
                try:
                    newJob = self.scheduler.add_date_job(self.submitJobToFramework, unScheduledJob.scheduled_start, **schedule)
                    self.logger.debug( 'Job will run on %s' % newJob.next_run_time )
                except Exception as e:
                    self.logger.error("Unknown error while submitting jobs to framework: %s" % str(e))
                    raise Exception

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class DataLogger:

    """
    In this class the different systems are initialiased:
        - logger and its handlers
        - local configuration
        - connection with internet

    If there is no connection with the internet:
        - A timed job is created that controls internet connection.
        - Logging of data is started with local configuration.
        - If the internet connection is started, and the online\
        configuration differs, the old wrongly logged data will be removed.

    If there is connection with the internet and the server is working:
        - Check if the online configuration differs from the local one. If so,\
        the configuration will be updated.
        - Logging of data is started.
        - Sending of data is started.
        - A timed job is created that checks if the online configuration is\
        updated
        - The management of leds is started.
    """

    def __init__(self):
        try:
            # initiate logger
            self.logger = logging.getLogger()
            self.logger.setLevel(logging.DEBUG)
            self.log_send_store_handler = LogSendStoreHandler(LOG_LOCATION)
            formatter = logging.Formatter(
                '%(asctime)s - %(levelname)s - %(name)s - %(message)s')
            self.log_send_store_handler.setFormatter(formatter)
            self.logger.addHandler(self.log_send_store_handler)
            self.logger.info('Initialising system...')
            job_info_filter = JobInfoFilter()
            logging.getLogger('apscheduler.scheduler').addFilter(
                job_info_filter)
            logging.getLogger('apscheduler.threadpool').addFilter(
                job_info_filter)

            # load local configuration
            self.conf_man = ConfigurationManager(CONFIG_LOCATION)
            self.log_send_store_handler.update_configuration()

            self.scheduler = Scheduler()
            self.scheduler.start()

            self.packet_manager = PacketManager(self.scheduler)

            # initiate network connection
            self.connection = ConnectionManager()

            # add scheduler and connection to log handler
            self.log_send_store_handler.update_configuration(
                scheduler=self.scheduler,
                connection=self.connection)

            # try to connect
            connected_to_internet = self.connection.check_internet_connection()
            connected_to_server = self.connection.check_server_connection()
            if connected_to_internet and connected_to_server:
                self.load_online_configuration_and_initiate_sending_data()
                self.packet_manager.update_time()
                self.packet_manager.initiate_send_packets(self.connection)
            else:
                '''
                if there is no connection:
                    keep checking for a connection
                    temporarily use offline timer and modbus slave
                    configuration
                '''

                if connected_to_internet:
                    self.packet_manager.update_time()
                self.wait_for_connection_to_load_configuration()

            # initiate sensor timers
            self.read_sensor_scheduler = ReadSensorScheduler(
                self.scheduler,
                self.packet_manager)
            self.led_manager = LedManager(self.scheduler)
            self.led_manager.update_led(PinName.powered, LedState.on)
            self.set_up_led_manager_calls()

            # sleep 2 seconds to intialise led of log handler
            sleep(1)
            self.logger.info('Initialisation complete')

            while True:
                sleep(10)
                self.logger.debug('Alive and kicking')
                if self.logger.level is logging.DEBUG:
                    scheduler_jobs = self.scheduler.get_jobs()
                    if len(scheduler_jobs) > 1:
                        self.logger.debug('Current scheduler jobs:')
                        for index, job in enumerate(scheduler_jobs):
                            self.logger.debug(' Job {0}: {1} {2}'.format(
                                index,
                                job.name,
#.........这里部分代码省略.........

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]

#.........这里部分代码省略.........
        if entityClass == "TNArchipelVirtualMachine":
            entity_uid = self.entity.uuid
        elif entityClass == "TNArchipelHypervisor":
            entity_uid = ARCHIPEL_SCHED_HYPERVISOR_UID
        self.cursor.execute("SELECT * FROM scheduler WHERE entity_uuid=?", (entity_uid, ))
        for values in self.cursor:
            try:
                entity_uuid, job_uuid, action, year, month, day, hour, minute, second, comment, params = values
                str_date = "%s/%s/%s %s:%s:%s" % (year, month, day, hour, minute, second)
                self.scheduler.add_cron_job(self.do_job_for_vm, year=year, month=month, day=day, hour=hour, minute=minute, second=second, args=[action, job_uuid, str_date, comment])
            except Exception as ex:
                self.entity.log.error("unable to restore a job: %s" % str(ex))

    def vm_terminate(self, origin, user_info, arguments):
        """
        Close the database connection.
        @type origin: TNArchipelEntity
        @param origin: the origin of the hook
        @type user_info: object
        @param user_info: random user information
        @type arguments: object
        @param arguments: runtime argument
        """
        self.database.close()

    ### Jobs

    def get_jod_with_uid(self, uid):
        """
        Get a job with given uid.
        @type uid: string
        @param uid: the uid of the job
        """
        if hasattr(self.scheduler, "get_jobs"):
            jobs = self.scheduler.get_jobs()
        else:
            jobs = self.scheduler.jobs

        for job in jobs:
            if str(job.args[1]) == uid:
                return job
        return None

    def do_job_for_vm(self, action, uid, str_date, comment, param):
        """
        Perform the job.
        @type action: string
        @param action: the action to execute
        @type uid: string
        @param uid: the uid of the job
        @type str_date: string
        @param str_date: the date of the job
        @type comment: string
        @param comment: comment about the job
        @type param: string
        @param param: a random parameter to give to job
        """
        if action == "create":
            self.entity.create()
        elif action == "shutdown":
            self.entity.shutdown()
        elif action == "destroy":
            self.entity.destroy()
        elif action == "suspend":
            self.entity.suspend()
        elif action == "resume":

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
from apscheduler.scheduler import Scheduler
from datetime import datetime, timedelta
from time import sleep
from random import randint

sched = Scheduler(coalesce=True)
sched.start()


def hello():
    print "hello", datetime.now()


sched.add_cron_job(hello, second='1,11,21,31,41,51')

job = sched.get_jobs()[0]
print len(job.get_run_times(datetime.now() + timedelta(minutes=60)))


def check():
    n = job.next_run_time
    if randint(1, 3) >= 2:
        job.compute_next_run_time(datetime.now() + timedelta(seconds=15))
        print 'rescheduling from', n, 'to', job.next_run_time
        return 1
    if job.runs > 10:
        print 'ran all my times, giving up.'
        raise
    return 0

i = 0

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class ProgramHandler:

    def __init__(self, db, radio_station):
        self.__db = db
        self.__radio_station = radio_station
        self.__scheduler = None
        self.__scheduled_jobs = None
        self.__start_listeners()
        self.__radio_station.logger.info("Done initialising ProgramHandler for {0}".format(radio_station.station.name))

    def run(self):
        self.run_today_schedule()

    def __prepare_schedule(self):
        self.__load_programs()
        self.__scheduler = Scheduler()
        self.__scheduled_jobs = dict()

    def run_today_schedule(self):
        self.__prepare_schedule()
        self.__scheduler.start()
        self.__schedule_programs()
        self.__schedule_next_day_scheduler()
        print self.__scheduler.get_jobs()

    def stop(self):
        self.__stop_program()
        # any clean up goes here
        # unschedule stuff

    def __schedule_next_day_scheduler(self):
        #TODO: make this safe for differebt timezones!
        base_date = date.today() + timedelta(1,0)
        tomorrow_date = datetime.combine(base_date, time())
        #add the timezone offset
        tomorrow_date = tomorrow_date + timedelta(0, timezone(self.__radio_station.station.timezone).utcoffset(datetime.now()).seconds)
        self.__scheduler.add_date_job(getattr(self, 'run_today_schedule'), tomorrow_date) #schedule the scheduler to reload at midnight 

    def __schedule_programs(self):
        for scheduled_program in self.__scheduled_programs:
            if not self.__is_program_expired(scheduled_program):
                self.__add_scheduled_job(scheduled_program)
                self.__radio_station.logger.info(
                    "Scheduled program {0} for station {1} starting at {2}".format(scheduled_program.program.name,
                                                                                   self.__radio_station.station.name,
                                                                                   scheduled_program.start))
        return

    def __add_scheduled_job(self, scheduled_program):
        program = RadioProgram(self.__db, scheduled_program, self.__radio_station)
        scheduled_job = self.__scheduler.add_date_job(getattr(program, 'start'),
                                                      self.__get_program_start_time(scheduled_program).replace(
                                                          tzinfo=None))
        self.__scheduled_jobs[scheduled_program.id] = scheduled_job

    def __delete_scheduled_job(self, index):
        if index in self.__scheduled_jobs:
            self.__scheduler.unschedule_job(self.__scheduled_jobs[index])
            del self.__scheduled_jobs[index]

    def __stop_program(self):
        #self.__running_program.stop()
        return

    def __run_program(self):
        #self.__running_program.run()
        return

    def __load_programs(self):
        self.__scheduled_programs = self.__db.query(ScheduledProgram).filter(
            ScheduledProgram.station_id == self.__radio_station.id).filter(text("date(start at TIME ZONE 'UTC') = current_date at TIME ZONE 'UTC'")).filter(
            ScheduledProgram.deleted == False).all()
        self.__radio_station.logger.info("Loaded programs for {0}".format(self.__radio_station.station.name))

    def __load_program(self, id):
        return self.__db.query(ScheduledProgram).filter(ScheduledProgram.id == id).first()

    def __start_listeners(self):
        t = threading.Thread(target=self.__listen_for_scheduling_changes,
                             args=(DefaultConfig.SCHEDULE_EVENTS_SERVER_IP, DefaultConfig.SCHEDULE_EVENTS_SERVER_PORT))
        t.start()

    def __listen_for_scheduling_changes(self, ip, port):
        sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        addr = (ip, port)
        
         #It may not be possible to connect after restart, TIME_WAIT could come into play etc. Anyway, keep trying
        connected = False
        while not connected:
            try:         
                sck.connect(addr)
                connected = True
            except:
                self.__radio_station.logger.error("Could not connect to server, retrying in 30 ...")
                sleep(30)
        sck.send(json.dumps({'station':self.__radio_station.id, 'action':'register'}))

        while True:
            data = sck.recv(1024)
            try:
#.........这里部分代码省略.........

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class DawnduskAPI:
    """
    dawndusk API
    """

    def __init__(self, lgt, lat, use_cron, myxpl, log):
        """
        Init the dawndusk API
        @param lgt : longitude of the observer
        @param lat : latitude of the observer
        """
        self.use_cron = use_cron
        self.log = log
        self.myxpl = myxpl
        if self.use_cron == False:
            self._scheduler = Scheduler()
            self._scheduler.start()
        else:
            self._cronquery = CronQuery(self.myxpl, self.log)
        self.mycity = ephem.Observer()
        self.mycity.lat, self.mycity.lon = lat, lgt
        self.mycity.horizon = '-6'
        self.job = None
        self.job_test_dawn = None
        self.job_test_dusk = None

    def __del__(self):
        """
        Kill the dawndusk API
        @param lgt : longitude of the observer
        @param lat : latitude of the observer
        """
        if self.use_cron == True:
            self._cronquery.halt_job("dawndusk")
            self._cronquery.halt_job("dawn-test")
            self._cronquery.halt_job("dusk-test")
        else :
            self._scheduler.shutdown()

    def sched_add(self, sdate, cb_function, label):
        """
        Add an event in the schedulered tasks
        @param sdate : the date of the event
        @param cb_function : the callback function to call
        @param : the label of the event
        """
        self.log.debug("dawndusk.schedAdd : Start ... %s" % label)
        if self.use_cron == False:
            if label == "dawn" or label == "dusk":
                self.job = self._scheduler.add_date_job(cb_function, \
                    sdate, args = [label])
                self.log.debug("dawndusk.schedAdd : Use internal cron \
                    for %s" % label)
            elif label == "dawn-test":
                self.job_test_dawn = self._scheduler.add_date_job\
                    (cb_function, sdate, args = ["dawn"])
                self.log.debug("dawndusk.schedAdd : Use internal cron \
                    for %s" % "dawn")
            elif label == "dusk-test":
                self.job_test_dusk = self._scheduler.add_date_job\
                    (cb_function, sdate, args = ["dusk"])
                self.log.debug("dawndusk.schedAdd : Use internal cron \
                    for %s" % "dusk")
            for i in self._scheduler.get_jobs():
                self.log.debug("APScheduler : %-10s | %8s" % \
                    (str(i.trigger), i.runs))
        else :
            self.log.debug("dawndusk.schedAdd : Use external cron ...")
            if label == "dawn" or label == "dusk":
                device = "dawndusk"
            elif label == "dawn-test":
                device = "dawn-test"
            elif label == "dusk-test":
                device = "dusk-test"
            if self._cronquery.status_job(device, extkey = "current") \
                != "halted":
                self._cronquery.halt_job(device)
                self.log.debug("dawndusk.schedAdd : Halt old device")
            nstmess = XplMessage()
            nstmess.set_type("xpl-trig")
            nstmess.set_schema("dawndusk.basic")
            nstmess.add_data({"type" : "dawndusk"})
            if label == "dawn":
                nstmess.add_data({"status" :  "dawn"})
            elif label == "dusk":
                nstmess.add_data({"status" :  "dusk"})
            elif label == "dawn-test":
                nstmess.add_data({"status" :  "dawn"})
            elif label == "dusk-test":
                nstmess.add_data({"status" :  "dusk"})
            if self._cronquery.start_date_job(device, nstmess, sdate):
                self.log.debug("dawndusk.schedAdd : External cron activated")
                self.log.debug("dawndusk.schedAdd : Done :)")
            else:
                self.log.error("dawndusk.schedAdd : Can't activate \
                    external cron")
                self.log.debug("dawndusk.schedAdd : Done :(")
                return False
        self.log.info("Add a new event of type %s at %s" % (label, sdate))
        return True
#.........这里部分代码省略.........

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]

#.........这里部分代码省略.........
            
            
    def __initializeScheduler(self, configurationReader):
        #Scheduler
        self.__scheduler = Scheduler()
        self.__scheduler.configure(standalone=True)
        self.__scheduler.add_listener(schedulerListener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
        
        #SchedulerTasks
        #TemperaturFeedService, TemperatureLogService, MixerControlService
        self.__loadBaseSchedulerTasks()
        
        self.__scheduler.start()
        
        #Benutzerdefinierte Schaltzeiten
        self.loadUserSchedulerTasks(configurationReader)
        
        self.logger.info("Scheduler started.")
        
    
    def getHeatingStatusBean(self):
        return self.__heatingStatusBean
    
    def getScheduler(self):
        return self.__scheduler
    
        
    def __loadBaseSchedulerTasks(self):
        temperatureFeedService = TemperatureFeedService.TemperatureFeedService(self)
        temperatureLogService = TemperatureLogService.TemperatureLogService(self)
        mixerControlService = MixerControlService.MixerControlService(self)
        
        #TemperaturFeedService
        job = self.__scheduler.add_interval_job(temperatureFeedService.run, seconds=INTERVALL_UPDATE_TEMPERATURE)
        job.name = SCHEDULE_SERVICE_TEMPERATURE_UPDATER
        self.logger.info("Scheduler-Job [" + job.name + "] loaded.")

        #TemperatureLogService
        job = self.__scheduler.add_interval_job(temperatureLogService.run, seconds=INTERVALL_LOG_TEMPERATURE)
        job.name = SCHEDULE_SERVICE_TEMPERATURE_LOGGER
        self.logger.info("Scheduler-Job [" + job.name + "] loaded.")
        
        #MixerControlService
        job = self.__scheduler.add_interval_job(mixerControlService.run, seconds=INTERVALL_UPDATE_MIXER)
        job.name = SCHEDULE_SERVICE_TEMPERATURE_MIXERCONTROL
        self.logger.info("Scheduler-Job [" + job.name + "] loaded.")
        
        
    def updateHeatingStatusBeanConfiguration(self, configurationReader):
        temperatures = configurationReader.temperatures
        self.__heatingStatusBean.setUpperFloorFlowTargetTemperature(float(temperatures.get('ogv')))
        self.__heatingStatusBean.setGroundFloorFlowTargetTemperature(float(temperatures.get('egv')))
        self.__heatingStatusBean.setWaterTargetTemperature(float(temperatures.get('hotwater')))
    
    
    def reloadUserSchedulerTasks(self):
        self.removeUserSchedulerTasks()
        
        configurationReader = ConfigurationReader(self.logger, os.getcwd() + FILEPATH_CONFIGURATION)
        self.updateHeatingStatusBeanConfiguration(configurationReader)
        
        self.loadUserSchedulerTasks(configurationReader)
        
        
    def removeUserSchedulerTasks(self):
        prefixLen = len(SERVICE_HEATING_ACTION_PREFIX) 
        jobList = self.__scheduler.get_jobs()
        for job in jobList:
            jobName = job.name
            if(jobName[:prefixLen] == SERVICE_HEATING_ACTION_PREFIX):
                self.logger.info("Scheduler-Job [" + job.name + "] removed.")
                self.__scheduler.unschedule_job(job)


    def loadUserSchedulerTasks(self, configurationReader):
        baseCronSched = {'year':None, 'month':None, 'day':None, 'week':None, 'day_of_week':None, 'hour':None, 'minute':None, 'second':None, 'start_date':None}
        for task in configurationReader.heatingTasks:
            
            schedType = task.get('schedule').get('type') 
            if(schedType == 'cron'):
                cronSched = baseCronSched.copy()
                cronSched.update(task.get('schedule'))
                cronSched.pop('type')
                if(task.get('type') == 'changeHeatingStatus'):
                    taskFunction = self.__heatingStatusBean.setHeatingStatusMap
                    job = self.__scheduler.add_cron_job(taskFunction,
                                                        year=cronSched['year'], month=cronSched['month'], day=cronSched['day'],
                                                        week=cronSched['week'], day_of_week=cronSched['day_of_week'], 
                                                        hour=cronSched['hour'], minute=cronSched['minute'], second=cronSched['second'], 
                                                        start_date=cronSched['start_date'],
                                                        args=[task.get('status')])
                    n = SERVICE_HEATING_ACTION_PREFIX + str(task.get('name'))
                    job.name = n
        
        prefixLen = len(SERVICE_HEATING_ACTION_PREFIX) 
        jobList = self.__scheduler.get_jobs()
        for job in jobList:
            jobName = job.name
            if(jobName[:prefixLen] == SERVICE_HEATING_ACTION_PREFIX):
                self.logger.info("Scheduler-Job [" + jobName + "] loaded.")

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class Sched(Basemodule):
    # ################################################################################
    # initialization of module and optional load of config files
    # ################################################################################
    def __init__(self, instance_queue, global_queue):
        #
        # "sched|port|command or action"
        #
        self.logger = logging.getLogger('Hasip.sched')
        self.sched = Scheduler()
        self.items = ConfigItemReader()
        self.jobs_config = ConfigJobReader()
        self.mod_list = self.items.get_items_dict()  # getting module list from item file
        self.queue_identifier = 'sched'  # this is the 'module address'
        self.instance_queue = instance_queue  # worker queue to receive jobs
        self.global_queue = global_queue  # queue to communicate back to main thread
        self.jobstore = {}
        self.sched.start()

        # read jobs configuration
        self.jobstore = self.jobs_config.get_jobs_dict()
        for job in self.jobstore.keys():
            self.logger.debug(self.jobstore[job][2])
            self.sched.add_cron_job(self.send_msg,
                                    name=job,
                                    year=self.jobstore[job][2],
                                    month=self.jobstore[job][3],
                                    day=self.jobstore[job][4],
                                    week=self.jobstore[job][5],
                                    day_of_week=self.jobstore[job][6],
                                    hour=self.jobstore[job][7],
                                    minute=self.jobstore[job][8],
                                    second=self.jobstore[job][9],
                                    args=(self.jobstore[job][0], self.jobstore[job][1]))

    # ################################################################################
    # main thread of this module file which runs in background and constantly checks working queue for new tasks.
    # ################################################################################
    def worker(self):
        while True:
            instance_queue_element = self.instance_queue.get(True)
            _senderport = instance_queue_element.get("module_from_port")
            _sender = instance_queue_element.get("module_from")
            _port = instance_queue_element.get("module_addr")
            _action = instance_queue_element.get("cmd")
            _optargs = instance_queue_element.get("opt_args")
            options = {
                "create": self.create,
                "delete": self.delete,
                "list_jobs": self.list_jobs
            }
            options[_action](_sender, _senderport, _port, _optargs)

    # ################################################################################
    #
    # "private" methods from here on...
    #
    # ################################################################################
    #Function to put jobs in the running scheduler job queue and store them persistent

    def create(self, sender, senderport, port, optargs):
        if optargs.get('name') in self.jobstore:
            self.delete(sender, senderport, port, optargs.get('name'))
        self.sched.add_cron_job(self.send_msg,
                                name=optargs.get('name'),
                                year=optargs.get('year'),
                                month=optargs.get('month'),
                                day=optargs.get('day'),
                                week=optargs.get('week'),
                                day_of_week=optargs.get('day_of_week'),
                                hour=optargs.get('hour'),
                                minute=optargs.get('minute'),
                                second=optargs.get('second'),
                                args=(optargs.get('module'), optargs.get('action')))
        self.jobstore.update(
            {
                optargs.get('name'): [
                    optargs.get('module'),
                    optargs.get('action'),
                    optargs.get('year'),
                    optargs.get('month'),
                    optargs.get('day'),
                    optargs.get('week'),
                    optargs.get('day_of_week'),
                    optargs.get('hour'),
                    optargs.get('minute'),
                    optargs.get('second')
                ]
            }
        )
        self.write_to_config()

    def delete(self, sender, senderport, port, optargs):
        for job in self.sched.get_jobs():
            if job.name == optargs:
                self.sched.unschedule_job(job)
                del self.jobstore[job.name]
                self.write_to_config()

    def list_jobs(self, sender, senderport, port, optargs):
#.........这里部分代码省略.........

# 需要导入模块: from apscheduler.scheduler import Scheduler [as 别名]
# 或者: from apscheduler.scheduler.Scheduler import get_jobs [as 别名]
class EventScheduler():
    """Class to scheduler regular events in a similar manner to cron."""
    __mysql_url = 'mysql+pymysql://powermonitor:%[email protected]/powermonitor' \
                  % str(base64.b64decode(bytes('cDB3M3JtMG4xdDBy')))
    '''This determines the number of seconds after the designated run time that the job is still allowed to be run.
    If jobs are not being run, try increasing this in increments of 1.'''
    __GRACE_PERIOD = 31536000  # Amazing grace! Time in seconds before the job is considered misfired. Currently a year
    __COALESCE = True   # Force the job to only run once instead of retrying multiple times
    '''If there is a problem with thread concurrency, play around with these values. You'd think with all these threads
    in the pool that the filter would get clogged up!'''
    __threadpool_corethreads = 0    # Maximum number of persistent threads in the pool
    __threadpool_maxthreads = 20    # Maximum number of total threads in the pool
    __threadpool_keepalive = 1      # Seconds to keep non-core worker threads in the pool

    def __init__(self, start=True):
        try:
            config = {'apscheduler.daemon': True, 'apscheduler.standalone': False,
                      'apscheduler.threadpool.core_threads': self.__threadpool_corethreads,
                      'apscheduler.threadpool.max_threads': self.__threadpool_maxthreads,
                      'apscheduler.threadpool.keepalive': self.__threadpool_keepalive,
                      'apscheduler.coalesce': self.__COALESCE}
            self.__sched = Scheduler(config)
            '''Add the SQLAlchemy job store as the default. This was surprisingly far less tedious than getting the
            shelve job store working.'''
            self.__sched.add_jobstore(SQLAlchemyJobStore(url=self.__mysql_url, tablename='SCHEDULE'), 'default')
            atexit.register(lambda: self.__sched.shutdown(wait=False))  # Stop the scheduler when the program exits
            if start:
                self.__sched.start()
        except KeyError:
            logging.warning('An error occurred starting the scheduler.')

    def start_scheduler(self):
        self.__sched.start()

    def add_cron_event(self, func, name, year=None, month=None, week=None, day=None,
                       day_of_week=None, hour=None, minute=None, second=None, start_date=None, *args,
                       **kwargs):
        """Add a cron like event to the schedule. Each job must be given a name in case it needs to be removed.
        The following expressions can be used in each field:
        Expression  Field   Description
        *           any     Fire on every value
        */a         any     Fire on every 'a' values, starting from the minimum
        a-b         any     Fire on any value in the 'a-b' range (a must be smaller than b
        a-b/c       any     Fire every 'c' values within the 'a-b' range
        xth y       day     Fire on the x -th occurrence of weekday y within the month
        last x      day     Fire on the last occurrence of weekday 'x' within the month
        last        day     Fire on the last day within the month
        x,y,z       any     Fire on any matching expression; can combine any number of any of the above expressions

        If you want to add **options to the event, use kwargs (keyword arguments dictionary)"""
        if self.__sched is not None:
            event_exists = False
            if self.__find_event(name) is not None:
                event_exists = True
            if not event_exists:
                self.__sched.add_cron_job(func=func, name=name, year=year, month=month, day=day, week=week,
                                          day_of_week=day_of_week, hour=hour, minute=minute, second=second,
                                          start_date=start_date, args=args, kwargs=kwargs,
                                          misfire_grace_time=self.__GRACE_PERIOD)
                logging.info('New cron event added')
            else:
                '''Every event needs a unique name so we can keep track of the little bastards. And please use
                descriptive names so that they can be properly identified in the job schedule.'''
                logging.warning('add_cron_event: Event already exists')
                raise EventExistsError('A job with name %s already exists' % name)
        else:
            raise SchedulerNotFoundError('add_cron_event: Scheduler does not exist. It may have not started.')

    def __find_event(self, event_name):
        if self.__sched is not None:
            events = self.__sched.get_jobs()
            for event in events:
                if event.name == event_name:
                    return event
                else:
                    return None
        else:
            logging.warning('__find_event: Scheduler does not exist. It may have not started.')
            raise SchedulerNotFoundError('Scheduler does not exist. It may have not started.')

    def add_onceoff_event(self, func, name, date, args=None):
        """Add a once off event to the schedule. The job is executed once at the specified date and time.
        Date/time format: YYYY-MM-DD HH:MM:SS"""
        if self.__sched is not None:
            try:
                if args is None:  # If there are no arguments to be passed to the function
                    self.__sched.add_date_job(func=func, name=name, date=date,
                                              misfire_grace_time=self.__GRACE_PERIOD)
                else:   # If there are arguments to be passed to the function
                    self.__sched.add_date_job(func=func, name=name, date=date, arge=args,
                                              misfire_grace_time=self.__GRACE_PERIOD)
            except ValueError:
                '''If the event is in the past, it will not run. This program is not capable of manipulating
                space and time. Try import __time_travel__'''
                raise EventWontRunError('The event will not run: Event time has expired.')
            logging.info('New once off event added')
        else:
            logging.warning('add_onceoff_event: Scheduler does not exist. It may have not started.')
            raise SchedulerNotFoundError('Scheduler does not exist. It may have not started.')

#.........这里部分代码省略.........