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