class TestScheduler(TestCase):
def setUp(self):
self.app = Flask(__name__)
self.scheduler = APScheduler()
def test_running(self):
self.assertFalse(self.scheduler.running)
self.scheduler.start()
self.assertTrue(self.scheduler.running)
def test_start_with_allowed_hosts(self):
self.app.config['SCHEDULER_ALLOWED_HOSTS'] = ['any_server_name']
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertFalse(self.scheduler.running)
def test_start_without_allowed_hosts(self):
self.app.config['SCHEDULER_ALLOWED_HOSTS'] = []
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertFalse(self.scheduler.running)
def test_shutdown(self):
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertTrue(self.scheduler.running)
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_load_jobs_from_config(self):
self.app.config['JOBS'] = [
{
'id': 'job1',
'func': 'tests.test_api:job1',
'trigger': 'interval',
'seconds': 10
}
]
self.scheduler.init_app(self.app)
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
def test_task_decorator(self):
@self.scheduler.task('interval', seconds=10, id='job1')
def decorated_job():
pass
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
class TestScheduler(TestCase):
def setUp(self):
self.app = Flask(__name__)
self.scheduler = APScheduler()
def test_running(self):
self.assertFalse(self.scheduler.running)
self.scheduler.start()
self.assertTrue(self.scheduler.running)
def test_start_with_allowed_hosts(self):
self.app.config['SCHEDULER_ALLOWED_HOSTS'] = ['any_server_name']
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertFalse(self.scheduler.running)
def test_start_without_allowed_hosts(self):
self.app.config['SCHEDULER_ALLOWED_HOSTS'] = []
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertFalse(self.scheduler.running)
def test_shutdown(self):
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertTrue(self.scheduler.running)
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_load_jobs_from_config(self):
self.app.config['JOBS'] = [{
'id': 'job1',
'func': 'tests.test_api:job1',
'trigger': 'interval',
'seconds': 10
}]
self.scheduler.init_app(self.app)
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
def test_task_decorator(self):
@self.scheduler.task('interval', seconds=10, id='job1')
def decorated_job():
pass
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
class HeartWatch(object):
def __init__(self, app):
self.scheduler = APScheduler()
self.scheduler.init_app(app)
self.counter = 0
self.dbUrl = app.config['SQLALCHEMY_DATABASE_URI']
self.scheduler.add_job("watchTask",
self.__task,
trigger="interval",
seconds=1)
def start(self):
print('start log')
try:
self.scheduler.start()
except Exception as e:
# self.logger("Error from HeartWatch Start process:{0}".format(str(e)))
raise e
def stop(self):
try:
self.scheduler.shutdown()
except Exception as e:
# self.logger("Error from HeartWatch Stop process:{0}".format(str(e)))
raise e
def __task(self):
self.counter = self.counter + 1
mySess = DBSession(self.dbUrl)
with mySess.ManagedSession() as session:
data = {}
data['curTime'] = datetime.datetime.now()
data['cur_bpm'] = self.heartrateNow()
# dataset = session.query(HeartData).order_by(desc(HeartData.dataset)).first()
# if dataset:
# data['dataset'] = dataset + 1
# else:
# data['dataset'] = 0
data['dataset'] = 0
new_heart_data = HeartData(**data)
session.add(new_heart_data)
@staticmethod
def heartrateNow():
i2c = I2C.Device(0x50, 2)
curBPM = i2c.readS8(0xA0)
return curBPM
JOBS = [
{
'id': 'clear_courses',
'func': CourseModel.clear_all,
'args': (datetime.today().weekday(), True),
'trigger': 'cron',
'hour': 23,
'minute': 00
}
]
SCHEDULER_API_ENABLED = True
if __name__ == "__main__":
db.init_app(app)
db.app = app
ma.init_app(app)
app.config.from_object(Config())
# Jobs
cron = APScheduler()
cron.init_app(app)
# Explicitly kick off the background thread
cron.start()
# Shutdown your cron thread if the web process is stopped
atexit.register(lambda: cron.shutdown(wait=False))
# Start Flask APP
app.run(port=5000, host='0.0.0.0')
@app.route('/getdata', methods=['GET', 'POST'])
def jsondata():
global prevData
global counter
default = '{"prediction": "stable"}'
print(default)
if ("stable" not in MQTT_DATA and MQTT_DATA == prevData and counter < 6):
counter = counter + 1
return jsonify(default)
prevData = MQTT_DATA
counter = 0
return jsonify(MQTT_DATA)
@app.route('/graph', methods=['GET', 'POST'])
def graph():
return render_template('graph.html')
if __name__ == "__main__":
#socketio.run(app, host='localhost', port=5000, use_reloader=True, debug=True)
try:
app.run(debug=True)
except KeyboardInterrupt:
scheduler.shutdown(wait=True)
sys.exit()
app.extensions['IRRIGATION_CONNECTION'] = getattr(
importlib.import_module('app.irrigation.module'),
'IrrigationControllerConnectionProvider')()
app.extensions['LOG_LEVEL'] = 'info'
app.config['SECRET_KEY'] = 'vnkdjnfjknfl1232#'
socket = SocketIO(app, cors_allowed_origins="*")
scheduler = APScheduler()
scheduler.init_app(app)
#scheduler.add_job('sentinel', func=lambda: run_command(app, Logger('Sentinel', app), 'runSentinel', []), trigger="interval", seconds=37)
#scheduler.add_job('irrigation', func=lambda: run_command(app, Logger('Irrigation', app), 'runIrrigationProgramme'), trigger="interval", seconds=11)
scheduler.start()
atexit.register(lambda: scheduler.shutdown())
if __name__ == '__main__':
socket.run(app, debug=True)
@socket.on('command')
def handle_event(command, methods=['GET', 'POST']):
logger = Logger('Terminal', app,
[lambda message: socket.emit('log', message)])
arguments = command['input'].replace(command['type'], '').strip().split()
result = run_command(app, logger, command['type'],
[arguments[0] if len(arguments) > 0 else None])
socket.emit('log', result['result'])
socket.emit('result', result['success'])
scheduler.add_job(
func=periodically_checkin,
id='checkin',
trigger='interval',
args=[lic["id"], lic["pub_key"]],
seconds=10,
max_instances=1,
# misfire_grace_time=60,
)
# start the application
app.run(host=hostIP, port=serverPort)
# shutdown the scheduler after the flask app exits
scheduler.remove_all_jobs()
scheduler.shutdown()
# graceful exit
while True:
res = revoke_license(lic["id"])
print("Info: revoking license... res.status_code = {}".format(
res.status_code))
if res.status_code == 200:
print("Info: successfully revoked the license.")
break
elif res.status_code >= 400 and res.status_code < 500:
sys.exit(
"Error: failed to revoke the license due to client side error."
)
elif res.status_code >= 500:
print("Error: server side error, try again.")
class TestScheduler(TestCase):
def setUp(self):
self.app = Flask(__name__)
self.scheduler = APScheduler()
self.scheduler_two = APScheduler(app=self.app)
def test_running(self):
self.assertFalse(self.scheduler.running)
self.scheduler.start()
self.assertTrue(self.scheduler.running)
def test_start_with_allowed_hosts(self):
self.app.config['SCHEDULER_ALLOWED_HOSTS'] = ['any_server_name']
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertFalse(self.scheduler.running)
def test_start_without_allowed_hosts(self):
self.app.config['SCHEDULER_ALLOWED_HOSTS'] = []
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertFalse(self.scheduler.running)
def test_shutdown(self):
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertTrue(self.scheduler.running)
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_load_jobs_from_config(self):
self.app.config['JOBS'] = [{
'id': 'job1',
'func': 'tests.test_api:job1',
'trigger': 'interval',
'seconds': 10,
}]
self.app.config['SCHEDULER_JOBSTORES'] = {
"default": apscheduler.jobstores.memory.MemoryJobStore()
}
self.app.config['SCHEDULER_EXECUTORS'] = {
"default": {
"type": "threadpool"
}
}
self.app.config['SCHEDULER_JOB_DEFAULTS'] = {"coalesce": True}
self.app.config['SCHEDULER_TIMEZONE'] = utc
self.scheduler.init_app(app=self.app)
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
def test_task_decorator(self):
@self.scheduler.task('interval', seconds=10, id='job1')
def decorated_job():
pass
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
def test_state_prop(self):
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertTrue(self.scheduler.state)
self.scheduler.shutdown()
self.assertFalse(self.scheduler.state)
def test_scheduler_prop(self):
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertIsNotNone(self.scheduler.scheduler)
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_pause_resume(self):
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertTrue(self.scheduler.running)
self.scheduler.pause()
self.assertTrue(self.scheduler.state == 2)
self.scheduler.resume()
self.assertTrue(self.scheduler.state == 1)
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_add_listener(self):
self.scheduler.init_app(self.app)
self.scheduler.start()
self.assertTrue(self.scheduler.running)
self.scheduler.add_listener(None)
self.scheduler.remove_listener(None)
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_add_remove_job(self):
@self.scheduler.task('interval', seconds=10, id='job1')
def decorated_job():
pass
self.scheduler.init_app(self.app)
self.scheduler.start()
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
self.scheduler.remove_job('job1')
self.assertFalse(self.scheduler.get_job('job1'))
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_add_delete_job(self):
@self.scheduler.task('interval', seconds=10, id='job1')
def decorated_job():
pass
self.scheduler.init_app(self.app)
self.scheduler.start()
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
self.scheduler.delete_job('job1')
self.assertFalse(self.scheduler.get_job('job1'))
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_add_remove_all_jobs(self):
@self.scheduler.task('interval', hours=1, id='job1')
def decorated_job():
pass
@self.scheduler.task('interval', hours=1, id='job2')
def decorated_job2():
pass
self.scheduler.init_app(self.app)
self.scheduler.start()
jobs = self.scheduler.get_jobs()
self.assertTrue(len(jobs) == 2)
self.scheduler.remove_all_jobs()
self.assertFalse(self.scheduler.get_job('job1'))
self.assertFalse(self.scheduler.get_job('job2'))
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_add_delete_all_jobs(self):
@self.scheduler.task('interval', hours=1, id='job1')
def decorated_job():
pass
@self.scheduler.task('interval', hours=1, id='job2')
def decorated_job2():
pass
self.scheduler.init_app(self.app)
self.scheduler.start()
jobs = self.scheduler.get_jobs()
self.assertTrue(len(jobs) == 2)
self.scheduler.delete_all_jobs()
self.assertFalse(self.scheduler.get_job('job1'))
self.assertFalse(self.scheduler.get_job('job2'))
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def test_job_to_dict(self):
@self.scheduler.task('interval',
hours=1,
id='job1',
end_date=datetime.datetime.now(),
weeks=1,
days=1,
seconds=99)
def decorated_job():
pass
self.scheduler.init_app(self.app)
self.scheduler.start()
job = self.scheduler.get_job('job1')
self.assertIsNotNone(job)
self.assertTrue(len(utils.job_to_dict(job)))
self.scheduler.delete_job('job1')
self.assertFalse(self.scheduler.get_job('job1'))
self.scheduler.shutdown()
self.assertFalse(self.scheduler.running)
def get_app():
import atexit
import os
import yaml
from flask import Flask
from flask_apscheduler import APScheduler
from apscheduler.jobstores.redis import RedisJobStore
from apscheduler.jobstores.memory import MemoryJobStore
from tracker_client_plugins import tracker_clients
import docker_worker_pool
from docker_worker_pool import get_cron_workers, DockerWorker
global _app
if _app is not None:
return _app
_app = Flask(__name__)
# load tracker plugins
try:
with open('tracker_client_plugins.yaml', 'r') as f:
tracker_dict = yaml.load(f, Loader=yaml.FullLoader)
for plugin_name, kwargs in tracker_dict.items():
tracker_clients.add(plugin_name, **kwargs)
except FileNotFoundError:
pass
job_stores = {
'redis':
RedisJobStore(host=tracker_dict['redis_tracker_client']['host'],
port=tracker_dict['redis_tracker_client']['port']),
'default':
MemoryJobStore()
}
_app.config['SCHEDULER_JOBSTORES'] = job_stores
scheduler = APScheduler()
# it is also possible to enable the API directly
# scheduler.api_enabled = True
scheduler.init_app(_app)
atexit.register(lambda: scheduler.shutdown(wait=False))
num_workers = int(os.environ.get("NUM_WORKERS", 1))
for i in range(num_workers):
docker_worker_pool.add()
scheduler.start()
loaded_scheduled_jobs = scheduler.get_jobs(jobstore='redis')
_cron_workers = get_cron_workers()
if loaded_scheduled_jobs:
for cron_job in loaded_scheduled_jobs:
cron_worker_index = docker_worker_pool.get_cron_worker_index(
cron_job.id)
_cron_workers[cron_worker_index] = DockerWorker(
cron_job.id, cron_job)
return _app
