def __init__(self, _plugin):
super().__init__(_plugin)
self.auth = Authenticate(_plugin.config_obj, self.namespace.lower())
self.scheduler_db = DBScheduler(self.config_obj.data)
for inst in _plugin.instances:
self.instances[inst] = LocastInstance(self, inst)
self.scheduler_tasks()
def scheduler_tasks(config):
scheduler_db = DBScheduler(config)
if scheduler_db.save_task('Applications', 'Backup', 'internal', None,
'lib.db.datamgmt.backups.backup_data', 20,
'thread',
'Backs up cabernet including databases'):
scheduler_db.save_trigger('Applications',
'Backup',
'weekly',
dayofweek='Sunday',
timeofday='02:00')
def reset_sched(_config, _name):
db_scheduler = DBScheduler(_config)
tasks = db_scheduler.get_tasks_by_name(_name)
html = ''
for task in tasks:
db_scheduler.del_task(task['area'], task['title'])
html = ''.join([
html, '<b>', task['area'], ':', task['title'],
'</b> deleted from Scheduler<br>'
])
return ''.join(
[html, 'Restart the app to re-populate the scheduler with defaults'])
def restart_api(_webserver):
scheduler_db = DBScheduler(_webserver.config)
tasks = scheduler_db.get_tasks('Applications', 'Restart')
if len(tasks) == 1:
_webserver.sched_queue.put({
'cmd': 'runtask',
'taskid': tasks[0]['taskid']
})
_webserver.do_mime_response(200, 'text/html', 'Restarting Cabernet')
else:
_webserver.do_mime_response(
404, 'text/html',
web_templates['htmlError'].format('404 - Request Not Found'))
def select_reset_sched(self):
db_sched = DBScheduler(self.config)
plugins_sched = db_sched.get_task_names()
html_option = ''.join([
'<td nowrap>Plugin: <select id="name" name="name"</select>',
'<option value="">ALL</option>',
])
for name in plugins_sched:
html_option = ''.join([
html_option,
'<option value="',
name['namespace'],
'">',
name['namespace'],
'</option>',
])
return ''.join([html_option, '</select></td></tr>'])
def __init__(self, _plugins, _queue):
Thread.__init__(self)
self.logger = logging.getLogger(__name__)
self.plugins = _plugins
self.queue = _queue
self.config = _plugins.config_obj.data
self.scheduler_db = DBScheduler(self.config)
self.scheduler_db.reset_activity()
self.schedule = lib.schedule.schedule
self.daemon = True
self.stop_thread = False
Scheduler.scheduler_obj = self
def _queue_thread():
while not self.stop_thread:
queue_item = self.queue.get(True)
self.process_queue(queue_item)
_q_thread = Thread(target=_queue_thread, args=())
_q_thread.start()
self.start()
def main(script_dir):
""" main startup method for app """
global RESTART_REQUESTED
hdhr_serverx = None
ssdp_serverx = None
webadmin = None
tuner = None
# Gather args
args = get_args()
if args.restart:
time.sleep(0.01)
# Get Operating system
opersystem = platform.system()
config_obj = None
try:
RESTART_REQUESTED = False
config_obj = user_config.get_config(script_dir, opersystem, args)
config = config_obj.data
logger = logging.getLogger(__name__)
logger.warning('#########################################')
logger.warning('MIT License, Copyright (C) 2021 ROCKY4546')
logger.info('Initiating Cabernet v{}'.format(utils.get_version_str()))
utils.cleanup_web_temp(config)
logger.info('Getting Plugins...')
plugins = plugin_handler.PluginHandler(config_obj)
plugins.initialize_plugins()
config_obj.defn_json = None
scheduler_db = DBScheduler(config)
scheduler_db.save_task('Applications', 'Restart', 'internal', None,
'lib.main.restart_cabernet', 20, 'inline',
'Restarts Cabernet')
if opersystem in ['Windows']:
pickle_it = Pickling(config)
pickle_it.to_pickle(plugins)
backups.scheduler_tasks(config)
hdhr_queue = Queue()
sched_queue = Queue()
logger.info('Starting admin website on {}:{}'.format(
config['web']['plex_accessible_ip'],
config['web']['web_admin_port']))
webadmin = Process(target=web_admin.start,
args=(plugins, hdhr_queue, sched_queue))
webadmin.start()
time.sleep(0.1)
logger.info('Starting streaming tuner website on {}:{}'.format(
config['web']['plex_accessible_ip'],
config['web']['plex_accessible_port']))
tuner = Process(target=web_tuner.start, args=(
plugins,
hdhr_queue,
))
tuner.start()
time.sleep(0.1)
scheduler = Scheduler(plugins, sched_queue)
time.sleep(0.1)
if not config['ssdp']['disable_ssdp']:
logger.info('Starting SSDP service on port 1900')
ssdp_serverx = Process(target=ssdp_server.ssdp_process,
args=(config, ))
ssdp_serverx.daemon = True
ssdp_serverx.start()
if not config['hdhomerun']['disable_hdhr']:
logger.info('Starting HDHR service on port 65001')
hdhr_serverx = Process(target=hdhr_server.hdhr_process,
args=(
config,
hdhr_queue,
))
hdhr_serverx.start()
time.sleep(0.1)
if opersystem in ['Windows']:
time.sleep(2)
pickle_it.delete_pickle(plugins.__class__.__name__)
logger.info('Cabernet is now online.')
RESTART_REQUESTED = False
while not RESTART_REQUESTED:
time.sleep(5)
RESTART_REQUESTED = False
logger.info('Shutting Down...')
time.sleep(1)
terminate_processes(config, hdhr_serverx, ssdp_serverx, webadmin,
tuner, scheduler, config_obj)
except KeyboardInterrupt:
logger.info('^C received, shutting down the server')
shutdown(config, hdhr_serverx, ssdp_serverx, webadmin, tuner,
scheduler, config_obj)
def __init__(self, _config, _queue):
self.logger = logging.getLogger(__name__)
self.config = _config
self.queue = _queue
self.scheduler_db = DBScheduler(self.config)