def handle(self, *args, **options): sched = Scheduler(daemonic=True) sched.add_cron_job(job_function, minute='*') sched.configure() try: sched.start() except (KeyboardInterrupt, SystemExit): pass print sched.print_jobs()
def testOne(self):
sched = Scheduler()
#@sched.interval_schedule(seconds=10)
@sched.cron_schedule(day_of_week=0,hour=5,minute=30)
def testSched():
print "job invoked!"
config = {'apscheduler.standalone': True}
sched.configure(config)
sched.start()
class TestRunningScheduler(object):
def setup(self):
self.scheduler = Scheduler()
self.scheduler.start()
def teardown(self):
if self.scheduler.running:
self.scheduler.shutdown()
def test_shutdown_timeout(self):
self.scheduler.shutdown()
@raises(SchedulerAlreadyRunningError)
def test_scheduler_double_start(self):
self.scheduler.start()
@raises(SchedulerAlreadyRunningError)
def test_scheduler_configure_running(self):
self.scheduler.configure({})
def test_scheduler_double_shutdown(self):
self.scheduler.shutdown()
self.scheduler.shutdown(False)
class TestRunningScheduler(object):
def setup(self):
self.scheduler = Scheduler()
self.scheduler.start()
def teardown(self):
if self.scheduler.running:
self.scheduler.shutdown()
def test_shutdown_timeout(self):
self.scheduler.shutdown()
@raises(SchedulerAlreadyRunningError)
def test_scheduler_double_start(self):
self.scheduler.start()
@raises(SchedulerAlreadyRunningError)
def test_scheduler_configure_running(self):
self.scheduler.configure({})
def test_scheduler_double_shutdown(self):
self.scheduler.shutdown()
self.scheduler.shutdown(False)
all_items = {}
def process_items_from_day(items):
data = []
for item in filter(lambda item: item['link'] is not None, [item for item in items]):
item = process(item)
if item['link'] not in all_items:
all_items[item['link']] = True
data.append(item)
return data
collections = ['AND observed > date("now", "start of day", "-1 day") AND observed < date("now", "start of day")',
'AND observed > date("now", "start of day", "-2 day") AND observed < date("now", "start of day", "-1 day")',
'AND observed > date("now", "start of day", "-3 day") AND observed < date("now", "start of day", "-2 day")']
collections = [process_items_from_day(get_items_from_day(date)) for date in collections]
with open('./templates/newsletter.html', 'r') as newspaper:
template = Template(newspaper.read())
html = template.render(title="Reddit News Agency", edition=len(os.listdir('./deploy')),
collections=collections).encode('utf-8')
f = open('./deploy/' + str(int(time())) + '.html', 'w')
f.write(html)
requests.post('http://reddit-snews-agency.herokuapp.com/', data=html, headers={
'Authorization': '9f9fa431c64a86da8324bb370d05377bbf49dbf9'
})
if __name__ == '__main__':
main()
sched.configure(standalone=True)
sched.start()
import datetime
import logging
import time
from apscheduler.scheduler import Scheduler
gconfig = {'apscheduler.threadpool.core_threads':2,
'apscheduler.threadpool.max_threads':50,
'apscheduler.threadpool.keepalive':4,
'apscheduler.misfire_grace_time':1,
'apscheduler.coalesce':True}
logging.basicConfig()
sched = Scheduler()
sched.daemonic = True
sched.configure(gconfig)
sched.start()
def do_job(a):
print "This is " + str(a)
print repr(sched._threadpool), str(sched._threadpool._queue.qsize())
print time.strftime('%Y-%m-%d %H:%M:%S')
current_date = datetime.datetime.now()
for i in range(0,10):
start_date = current_date+datetime.timedelta(seconds=i)
sched.add_interval_job(do_job, seconds=10, args=('number ' + str(i),), start_date=start_date)
while(True):
#print repr(pool)
time.sleep(1)
de_quien = 'Xendra info Cambio de ip'
try:
myip = urllib2.urlopen('http://www.curlmyip.com').read()
except urllib2.HTTPError, e:
myip = ''
if myip:
myip = myip.split(' ')[0].split('\n')[0]
try:
ip_history = IpServer.objects.get(pk=1)
except ObjectDoesNotExist, e:
ip_history = IpServer()
ip_history.ip = myip
ip_history.save()
correo = send_mail(asunto, myip, de_quien, para, fail_silently=True)
if not myip == ip_history.ip:
correo = send_mail(asunto, myip, de_quien, para, fail_silently=True)
ip_history.ip = myip
ip_history.save()
def borrar_antiguos():
pass
sched = Scheduler(daemonic=True)
sched.add_cron_job(job_function, minute='*/5')
sched.configure()
try:
sched.start()
except (KeyboardInterrupt, SystemExit):
pass
#print sched.print_jobs()
class TestOfflineScheduler(object):
def setup(self):
self.scheduler = Scheduler()
def teardown(self):
if self.scheduler.running:
self.scheduler.shutdown()
@raises(KeyError)
def test_jobstore_twice(self):
self.scheduler.add_jobstore(RAMJobStore(), 'dummy')
self.scheduler.add_jobstore(RAMJobStore(), 'dummy')
def test_add_tentative_job(self):
job = self.scheduler.add_date_job(lambda: None,
datetime(2200, 7, 24),
jobstore='dummy')
assert isinstance(job, Job)
eq_(self.scheduler.get_jobs(), [])
def test_configure_jobstore(self):
conf = {
'apscheduler.jobstore.ramstore.class':
'apscheduler.jobstores.ram_store:RAMJobStore'
}
self.scheduler.configure(conf)
self.scheduler.remove_jobstore('ramstore')
def test_shutdown_offline(self):
self.scheduler.shutdown()
def test_configure_no_prefix(self):
global_options = {'misfire_grace_time': '2', 'daemonic': 'false'}
self.scheduler.configure(global_options)
eq_(self.scheduler.misfire_grace_time, 1)
eq_(self.scheduler.daemonic, True)
def test_configure_prefix(self):
global_options = {
'apscheduler.misfire_grace_time': 2,
'apscheduler.daemonic': False
}
self.scheduler.configure(global_options)
eq_(self.scheduler.misfire_grace_time, 2)
eq_(self.scheduler.daemonic, False)
def test_add_listener(self):
val = []
self.scheduler.add_listener(val.append)
event = SchedulerEvent(EVENT_SCHEDULER_START)
self.scheduler._notify_listeners(event)
eq_(len(val), 1)
eq_(val[0], event)
event = SchedulerEvent(EVENT_SCHEDULER_SHUTDOWN)
self.scheduler._notify_listeners(event)
eq_(len(val), 2)
eq_(val[1], event)
self.scheduler.remove_listener(val.append)
self.scheduler._notify_listeners(event)
eq_(len(val), 2)
def test_pending_jobs(self):
# Tests that pending jobs are properly added to the jobs list when
# the scheduler is started (and not before!)
self.scheduler.add_date_job(lambda: None, datetime(9999, 9, 9))
eq_(self.scheduler.get_jobs(), [])
self.scheduler.start()
jobs = self.scheduler.get_jobs()
eq_(len(jobs), 1)
count_of_data_requests_pending = count_of_data_requests_received - count_of_data_requests_responded - count_of_data_requests_declined
reciprocity = count_of_data_requests_responded * 1.0 / count_of_data_requests_received if count_of_data_requests_received > 0 else 0
Partner.objects.filter(hfpp_network_id=partner_id).update(
count_of_data_requests_received=count_of_data_requests_received,
count_of_data_requests_sent=count_of_data_requests_sent,
count_of_data_requests_responded=count_of_data_requests_responded,
count_of_data_requests_declined=count_of_data_requests_declined,
count_of_data_requests_pending=count_of_data_requests_pending,
reciprocity=reciprocity
)
except urllib.error.HTTPError as e:
# Parse response XML
resp_content = e.read().decode('utf-8')
logger.debug('response:%s',resp_content)
try:
root = ElementTree.fromstring(resp_content)
# Not succeeded
# 400, 401, 403 or 500
error_code = root.findtext('./ErrorCode')
error_message = root.findtext('./ErrorMessage')
# Log error code and error message
logging.error('error code:%s',error_code)
logging.error('error message:%s',error_message)
except Exception as e:
logging.exception("")
logginghelper.method_exit(logger, signature)
sched.configure()
sched.start()
#!/usr/bin/env python
from apscheduler.scheduler import Scheduler
from datetime import datetime
from time import sleep
from memcheck import check, info
import signal
# Start the scheduler
sched = Scheduler()
options = {'misfire_grace_time': '2',
'daemonic': 'false'}
sched.configure(options)
stop = 0
# KeyboardInterrupt handler
def shutdown(signl, frme):
global stop
global sched
stop = 1
sched.shutdown(10)
#log.info('Catched signal %r. Processing will stop.', signl)
return 0
def get_info(signl, frme):
info()
signal.signal(signal.SIGINT, shutdown )
signal.signal(signal.SIGUSR1, get_info)
class Master(object):
def __init__(self):
self.scheduler = Scheduler()
self.scheduler.configure({'daemonic': True})
self.scheduler.add_interval_job(self._balance, seconds=60)
self.scheduler.start()
pass
def _balance(self):
def wrapper():
balancer.rebalance()
self.reload_all()
q.put((wrapper, [], {}))
# reconfigure haproxy
def reload_all(self):
from upscale.utils.common import get_hosts
for host in get_hosts():
print ("Reloading host {0}.".format(host.private_dns_name))
with Tasks("tcp://{0}:10000/".format(host.private_dns_name)) as h:
# should run async and wait for all results to finish
h.reload()
# start host
@queue
def start(self, namespace, application):
from upscale.master.balancer import get_containers
print namespace, application,
(hosts, containers) = get_containers()
# also weighted hosts, so one in static host, one on spot instance
min_host = None
for host in containers:
if (not min_host or len(containers[host])<len(containers[min_host])):
# check if it already contains project
min_host_applications = set([(b.split('_')[0], b.split('_')[1]) for b in containers[host] if len(b.split('_'))==3])
if ((namespace, application) in min_host_applications):
continue
min_host=host
if not min_host:
raise Exception('No host available')
print 'Starting on host {0}.'.format(min_host)
# start container on min host
# check minhost
with Worker("tcp://{0}:10000/".format(hosts[min_host])) as h:
#h.start(namespace, application).get(timeout=5)
print ('Starting new container')
h.start(namespace, application)
self.reload_all()
# health checks, does namespace, application exist
#enqueue(wrapper, )
return (True)
@queue
def destroy(self, namespace, website):
# get all containers for project and destroy them
print namespace, application,
(hosts, containers) = get_containers()
for host in containers:
for container in containers[host]:
pass
@queue
def upgrade(self, namespace, website):
# rolling upgrade, first start new instances with new version,
# then shutdown old ones
# get containers and host of old version
# start new containers with new version
# shutdown old versions
pass
def schedule_job(sched, function, periodicity, start_time,args):
sched.add_interval_job(function, seconds=periodicity, start_date=start_time,args=args)
##############################################################
if __name__ == "__main__":
#########################################################
# Palinsesto ArOmino
sched = Scheduler()
sched.configure({'apscheduler.daemonic': False})
sched.start() # start the scheduler
#UPDATE
schedule_job(sched, update_frasi, 600, '2014-09-19 22:00:00',args=[''])
schedule_job(sched, update_sensors, 300, '2014-09-19 22:00:00',args=[''])
schedule_job(sched, update_weather, 3000, '2014-09-19 22:00:00',args=[''])
schedule_job(sched, update_forecast, 86400, '2014-09-20 8:00:00',args=[''])
#PERIODIC
schedule_job(sched, send_message_p, 1800,'2014-09-20 8:10:00',args=['realtime'])
schedule_job(sched, send_message_p, 1800,'2014-09-20 8:10::00',args=['history'])
schedule_job(sched, send_message_p, 1800,'2014-09-20 8:10::00',args=['weather'])
schedule_job(sched, send_message_p, 1800,'2014-09-20 8:10::00',args=['biometeo'])
class TestOfflineScheduler(object):
def setup(self):
self.scheduler = Scheduler()
def teardown(self):
if self.scheduler.running:
self.scheduler.shutdown()
@raises(KeyError)
def test_jobstore_twice(self):
self.scheduler.add_jobstore(RAMJobStore(), "dummy")
self.scheduler.add_jobstore(RAMJobStore(), "dummy")
def test_add_tentative_job(self):
job = self.scheduler.add_date_job(lambda: None, datetime(2200, 7, 24), jobstore="dummy")
assert isinstance(job, Job)
eq_(self.scheduler.get_jobs(), [])
def test_add_job_by_reference(self):
job = self.scheduler.add_date_job("copy:copy", datetime(2200, 7, 24))
eq_(job.func, copy)
eq_(job.func_ref, "copy:copy")
def test_configure_jobstore(self):
conf = {"apscheduler.jobstore.ramstore.class": "apscheduler.jobstores.ram_store:RAMJobStore"}
self.scheduler.configure(conf)
self.scheduler.remove_jobstore("ramstore")
def test_shutdown_offline(self):
self.scheduler.shutdown()
def test_configure_no_prefix(self):
global_options = {"misfire_grace_time": "2", "daemonic": "false"}
self.scheduler.configure(global_options)
eq_(self.scheduler.misfire_grace_time, 1)
eq_(self.scheduler.daemonic, True)
def test_configure_prefix(self):
global_options = {"apscheduler.misfire_grace_time": 2, "apscheduler.daemonic": False}
self.scheduler.configure(global_options)
eq_(self.scheduler.misfire_grace_time, 2)
eq_(self.scheduler.daemonic, False)
def test_add_listener(self):
val = []
self.scheduler.add_listener(val.append)
event = SchedulerEvent(EVENT_SCHEDULER_START)
self.scheduler._notify_listeners(event)
eq_(len(val), 1)
eq_(val[0], event)
event = SchedulerEvent(EVENT_SCHEDULER_SHUTDOWN)
self.scheduler._notify_listeners(event)
eq_(len(val), 2)
eq_(val[1], event)
self.scheduler.remove_listener(val.append)
self.scheduler._notify_listeners(event)
eq_(len(val), 2)
def test_pending_jobs(self):
# Tests that pending jobs are properly added to the jobs list when
# the scheduler is started (and not before!)
self.scheduler.add_date_job(lambda: None, datetime(9999, 9, 9))
eq_(self.scheduler.get_jobs(), [])
self.scheduler.start()
jobs = self.scheduler.get_jobs()
eq_(len(jobs), 1)
class HouseControl(object):
__scheduler = None
__heatingStatusBean = None
busJobsQueue = Queue.Queue()
busWorkerThread = BusWorker(busJobsQueue)
def __init__(self):
self.logger = logging.getLogger(APPLICATION_LOGGER_NAME)
self.logger.info("HouseControl starting...")
configurationReader = ConfigurationReader(self.logger, os.getcwd() + FILEPATH_CONFIGURATION)
#Initialize HeatingStatusBean
self.__initalizeHeatingStatusBean(configurationReader)
#Initialize Scheduler
self.__initializeScheduler(configurationReader)
#Initialize BusQueueWorker
self.busWorkerThread.setDaemon(True)
self.busWorkerThread.start()
self.logger.info("HouseControl started.")
def __initalizeHeatingStatusBean(self, configurationReader):
#HeatingStatusBean
self.__heatingStatusBean = HeatingStatusBean.HeatingStatusBean()
#Configure Bean
self.updateHeatingStatusBeanConfiguration(configurationReader)
#Add ChangeListener
self.__heatingStatusBean.addChangeListener(HeatingControlService.HeatingControlService(self))
self.__heatingStatusBean.addChangeListener(HeatingSwitchService.HeatingSwitchService(self))
##self.__heatingStatusBean.addChangeListener(HeatingMonitorService.HeatingMonitorService(self))
self.logger.info("HeatingStatusBean configured.")
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.")
class MessageScheduler(object):
def __init__(self, jobstore, url):
self.logger = setup(__name__)
self.logger.debug("Creating MessageScheduler")
self.logger.debug("id = {}".format(id(self)))
config = read_env('config.cfg')
self._scheduler = Scheduler(daemonic=True)
config_scheduler = {'apscheduler.jobstores.file.class': 'apscheduler.jobstores%s' % jobstore,
'apscheduler.jobstores.file.url': url}
self._scheduler.configure(config_scheduler)
#Open a publishing socket to the forwarder to pass messages out
self.broadcast_socket = zmq.Context().socket(zmq.PUB)
self.broadcast_socket.connect(config['ZMQ_FORWARDER_SUCKS_IN'])
def start_ap_daemon(self):
self.logger.info("scheduler start")
setup("apscheduler.scheduler")
self._scheduler.start()
def shutdown(self):
self.logger.info("scheduler shutdown")
self._scheduler.shutdown()
def schedule(self, topic, msg):
""" Takes incoming message, massages it, and dispatches
to appropriate function.
"""
self.logger.debug("schedule received {}: {}".format(topic, msg))
if 'obj_id' in msg:
obj_id = msg.pop('obj_id')
if 'start_time' in msg:
if 'window' in msg:
msg_time = msg['start_time'] - timedelta(seconds=msg['window'])
else:
msg_time = msg['start_time']
else:
offset = timedelta(seconds=10)
#needs to be a little bit in the future, so scheduler can run it
msg_time = datetime.now() + offset
if 'operation' in msg:
if msg['operation'] == 'insert':
self.schedule_message(topic, msg, msg_time, obj_id)
elif msg['operation'] == 'update':
self.reschedule_message(obj_id, topic, msg, msg_time)
elif msg['operation'] == 'delete':
self.cancel_message(obj_id)
else:
self.logger.debug("Scheduler has been sent unknown database signal operation.")
else:
self.schedule_message(topic, msg, msg_time)
def send_to_station(self, topic, msg):
""" Send a message on to rootio_telephony """
topic = "station.{}.db".format(msg['station_id'])
# reserialize any datetime elements for zmq -- unpack again at ts
for key, value in msg.items():
if isinstance(value, datetime):
msg[key] = isodate.datetime_isoformat(value)
msg = json.dumps(msg)
self.logger.debug("fwd %s: %s" % (topic, msg))
self.broadcast_socket.send_multipart((topic, msg))
def schedule_message(self, topic, message, send_at, obj_id):
self.logger.info("schedule message %s:%s at %s" % (topic, message, send_at))
#create lambda for scheduler to call at execution time
#and add it
message['obj_id'] = obj_id
try:
job = self._scheduler.add_date_job(self.send_to_station,
send_at,
args=(topic, message),
name=obj_id)
self.logger.debug("scheduled job: {}".format(job))
self.logger.debug("scheduled job_name: {}".format(job.name))
except ValueError, e:
self.logger.error(e)
class Master(object):
def __init__(self):
self.scheduler = Scheduler()
self.scheduler.configure({'daemonic': True})
self.scheduler.add_interval_job(self._balance, seconds=60)
self.scheduler.start()
pass
def _balance(self):
def wrapper():
balancer.rebalance()
self.reload_all()
q.put((wrapper, [], {}))
# reconfigure haproxy
def reload_all(self):
from upscale.utils.common import get_hosts
for host in get_hosts():
print("Reloading host {0}.".format(host.private_dns_name))
with Tasks("tcp://{0}:10000/".format(host.private_dns_name)) as h:
# should run async and wait for all results to finish
h.reload()
# start host
@queue
def start(self, namespace, application):
from upscale.master.balancer import get_containers
print namespace, application,
(hosts, containers) = get_containers()
# also weighted hosts, so one in static host, one on spot instance
min_host = None
for host in containers:
if (not min_host
or len(containers[host]) < len(containers[min_host])):
# check if it already contains project
min_host_applications = set([(b.split('_')[0], b.split('_')[1])
for b in containers[host]
if len(b.split('_')) == 3])
if ((namespace, application) in min_host_applications):
continue
min_host = host
if not min_host:
raise Exception('No host available')
print 'Starting on host {0}.'.format(min_host)
# start container on min host
# check minhost
with Worker("tcp://{0}:10000/".format(hosts[min_host])) as h:
#h.start(namespace, application).get(timeout=5)
print('Starting new container')
h.start(namespace, application)
self.reload_all()
# health checks, does namespace, application exist
#enqueue(wrapper, )
return (True)
@queue
def destroy(self, namespace, website):
# get all containers for project and destroy them
print namespace, application,
(hosts, containers) = get_containers()
for host in containers:
for container in containers[host]:
pass
@queue
def upgrade(self, namespace, website):
# rolling upgrade, first start new instances with new version,
# then shutdown old ones
# get containers and host of old version
# start new containers with new version
# shutdown old versions
pass
class MessageScheduler(object):
def __init__(self, jobstore, url):
self.socket = zmq.Context().socket(zmq.SUB)
self.logger = setup(__name__)
self.logger.debug("Creating MessageScheduler")
self.logger.debug("id = {}".format(id(self)))
config = read_env('config.cfg')
self._scheduler = Scheduler(daemonic=True)
config_scheduler = {'apscheduler.jobstores.file.class': 'apscheduler.jobstores%s' % jobstore,
'apscheduler.jobstores.file.url': url}
self._scheduler.configure(config_scheduler)
# Open a publishing socket to the forwarder to pass messages out
self.broadcast_socket = zmq.Context().socket(zmq.PUB)
self.broadcast_socket.connect(config['ZMQ_FORWARDER_SUCKS_IN'])
def start_ap_daemon(self):
self.logger.info("scheduler start")
setup("apscheduler.scheduler")
self._scheduler.start()
def shutdown(self):
self.logger.info("scheduler shutdown")
self._scheduler.shutdown()
def schedule(self, topic, msg):
""" Takes incoming message, massages it, and dispatches
to appropriate function.
"""
self.logger.debug("schedule received {}: {}".format(topic, msg))
if 'obj_id' in msg:
obj_id = msg.pop('obj_id')
if 'start_time' in msg:
if 'window' in msg:
msg_time = msg['start_time'] - timedelta(seconds=msg['window'])
else:
msg_time = msg['start_time']
else:
offset = timedelta(seconds=10)
# needs to be a little bit in the future, so scheduler can run it
msg_time = datetime.now() + offset
if 'operation' in msg:
if msg['operation'] == 'insert':
self.schedule_message(topic, msg, msg_time, obj_id)
elif msg['operation'] == 'update':
self.reschedule_message(obj_id, topic, msg, msg_time)
elif msg['operation'] == 'delete':
self.cancel_message(obj_id)
else:
self.logger.debug("Scheduler has been sent unknown database signal operation.")
else:
self.schedule_message(topic, msg, msg_time)
def send_to_station(self, topic, msg):
""" Send a message on to rootio_telephony """
topic = "station.{}.db".format(msg['station_id'])
# reserialize any datetime elements for zmq -- unpack again at ts
for key, value in msg.items():
if isinstance(value, datetime):
msg[key] = isodate.datetime_isoformat(value)
msg = json.dumps(msg)
self.logger.debug("fwd %s: %s" % (topic, msg))
self.broadcast_socket.send_multipart((topic, msg))
def schedule_message(self, topic, message, send_at, obj_id):
self.logger.info("schedule message %s:%s at %s" % (topic, message, send_at))
# create lambda for scheduler to call at execution time
# and add it
message['obj_id'] = obj_id
try:
job = self._scheduler.add_date_job(self.send_to_station,
send_at,
args=(topic, message),
name=obj_id)
self.logger.debug("scheduled job: {}".format(job))
self.logger.debug("scheduled job_name: {}".format(job.name))
except ValueError, e:
self.logger.error(e)
db.connect()
if not AO_Login.table_exists():
init_db(db)
print('OK database SQLite '+DATABASE+' installato!')
else:
print('OK database SQLite '+DATABASE+' precedentemente installato!')
db.close()
#cgi_manage()
#########################################################
# Scheduling
sched = Scheduler()
sched.configure({'apscheduler.daemonic': False})
sched.start() # start the scheduler
job_param = sched.add_interval_job(send_parametric, seconds=10, args=['1', 'p', '3', '1', '1','2'])
job_inform= sched.add_interval_job(send_informative, seconds=20, args=['1', 'i', '1', '1'])
###############################################################################################################################à
# Example of scheduling
#job = sched.add_date_job(my_job, '2013-08-05 23:47:05', ['text'])
#job = sched.add_interval_job(my_job, seconds=3,args=)
#job = sched.add_cron_job(my_job, minute="*/15", args=['text'])
while True:
pass
print(page_path)
command = "cp {} {}".format(old_page_path, new_page_path)
os.system(command)
def process_request():
global SAFE
while True:
if not update_queue.empty() and SAFE:
item = update_queue.get()
# print(*item)
update_page(*item)
update_queue.task_done()
elif not SAFE:
replace_page_with_new_page()
SAFE = True
@sched.interval_schedule(minutes=DELAY)
def scheduled_update():
global SAFE
SAFE = False
# Register APS Scheduler to update the pages
sched.configure(misfire_grace_time=30)
sched.start()
t = threading.Thread(target=process_request)
t.daemon = True
t.start()
