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 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)
class Locast(PluginObj):
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 refresh_channels_ext(self, _instance=None):
"""
External request to refresh channels. Called from the plugin manager.
All tasks are namespace based so instance is ignored.
This calls the scheduler to run the task.
"""
self.web_admin_url = 'http://' + self.config_obj.data['web']['plex_accessible_ip'] + \
':' + str(self.config_obj.data['web']['web_admin_port'])
task = self.scheduler_db.get_tasks('Channels',
'Refresh Locast Channels')[0]
url = (
self.web_admin_url +
'/pages/scheduler?action=runtask&taskid={}'.format(task['taskid']))
req = urllib.request.Request(url)
with urllib.request.urlopen(req) as resp:
result = resp.read()
# wait for the last run to update indicating the task has completed.
while True:
task_status = self.scheduler_db.get_task(task['taskid'])
x = datetime.datetime.utcnow() - task_status['lastran']
# If updated in the last 20 minutes, then ignore
# Many media servers will request this multiple times.
if x.total_seconds() < 1200:
break
time.sleep(0.5)
def refresh_epg_ext(self, _instance=None):
"""
External request to refresh epg. Called from the plugin manager.
All tasks are namespace based so instance is ignored.
This calls the scheduler to run the task.
"""
self.web_admin_url = 'http://' + self.config_obj.data['web']['plex_accessible_ip'] + \
':' + str(self.config_obj.data['web']['web_admin_port'])
task = self.scheduler_db.get_tasks('EPG', 'Refresh Locast EPG')[0]
url = (
self.web_admin_url +
'/pages/scheduler?action=runtask&taskid={}'.format(task['taskid']))
req = urllib.request.Request(url)
with urllib.request.urlopen(req) as resp:
result = resp.read()
# wait for the last run to update indicating the task has completed.
while True:
task_status = self.scheduler_db.get_task(task['taskid'])
x = datetime.datetime.utcnow() - task_status['lastran']
# If updated in the last 20 minutes, then ignore
# Many media servers will request this multiple times.
if x.total_seconds() < 1200:
break
time.sleep(0.5)
def get_channel_uri_ext(self, sid, _instance=None):
"""
External request to return the uri for a m3u8 stream.
Called from stream object.
"""
return self.instances[_instance].get_channel_uri(sid)
def is_time_to_refresh_ext(self, _last_refresh, _instance):
"""
External request to determine if the m3u8 stream uri needs to
be refreshed.
Called from stream object.
"""
return self.instances[_instance].is_time_to_refresh(_last_refresh)
def refresh_channels(self, _instance=None):
"""
Called from the scheduler
"""
if _instance is None:
for key, instance in self.instances.items():
instance.refresh_channels()
else:
self.instances[_instance].refresh_channels()
def refresh_epg(self, _instance=None):
"""
Called from the scheduler
"""
if _instance is None:
for key, instance in self.instances.items():
instance.refresh_epg()
else:
self.instances[_instance].refresh_epg()
def scheduler_tasks(self):
if self.scheduler_db.save_task('Channels', 'Refresh Locast Channels',
self.name, None, 'refresh_channels', 20,
'inline',
'Pulls channel lineup from Locast'):
self.scheduler_db.save_trigger('Channels',
'Refresh Locast Channels',
'startup')
self.scheduler_db.save_trigger('Channels',
'Refresh Locast Channels',
'daily',
timeofday='22:00')
if self.scheduler_db.save_task(
'EPG', 'Refresh Locast EPG', self.name, None, 'refresh_epg',
10, 'thread', 'Pulls channel program data from Locast'):
self.scheduler_db.save_trigger('EPG', 'Refresh Locast EPG',
'startup')
self.scheduler_db.save_trigger('EPG',
'Refresh Locast EPG',
'interval',
interval=700)
@property
def name(self):
return self.namespace