def __new__(cls): # Singleton if not cls._instance: # first instance cls.config = Configuration() cls.dct_filter = {} cls.dct_media = {} # {"filter_name" : class_filter} cls.dct_filterchain = {} cls.dct_filter = {} # initialize subscriber server publisher = Publisher(5031) cls.publisher = publisher # self.resource.set_all_publisher(publisher) publisher.start() publisher.register(keys.get_key_execution_list()) publisher.register(keys.get_key_filter_param()) publisher.register(keys.get_key_media_param()) publisher.register(keys.get_key_lst_rec_historic()) publisher.register(keys.get_key_count()) # instance class cls._instance = super(Resource, cls).__new__(cls) return cls._instance
def start_filterchain_execution( self, execution_name, media_name, filterchain_name, file_name, is_client_manager): self._post_command_(locals()) execution = self.dct_exec.get(execution_name, None) if execution: log.print_function( logger.error, "The execution %s is already created." % execution_name) return False filterchain = self.resource.get_filterchain( filterchain_name, force_new_filterchain=True) if not filterchain: log.print_function( logger.error, "Filterchain %s not exist or contain error." % filterchain_name) return False # Exception, if not media_name, we take the default media_name from the # filterchain if not media_name: media_name = filterchain.get_default_media_name() if not media_name: media_name = self.config.get_default_media_name() media = self.resource.get_media(media_name) if not media: log.print_function( logger.error, "Media %s not exist or you didn't set the default media on " "filterchain." % media_name) return False if media.is_media_video() and file_name: media.set_file(file_name) media.set_is_client_manager(is_client_manager) filterchain.set_media_param(media.get_params()) filterchain.set_execution_name(execution_name) media.add_observer(filterchain.execute) if self._is_keep_alive_media: media.add_observer(self._keep_alive_media) self.dct_exec[execution_name] = { KEY_FILTERCHAIN: filterchain, KEY_MEDIA: media} publisher = self.publisher publisher.publish( keys.get_key_execution_list(), "+%s" % execution_name) for o_filter in filterchain.get_filter(): o_filter.set_publisher(publisher) return True
def close(self): logger.info("Close cmdHandler and close server.") for media_name in self.resource.get_media_name_list(): media = self.resource.get_media(media_name) media.close() media.destroy() self.server_observer.stop() self.publisher.stop() self.publisher.deregister(keys.get_key_execution_list()) self.publisher.deregister(keys.get_key_filter_param()) self.publisher.deregister(keys.get_key_media_param()) self.publisher.deregister(keys.get_key_lst_rec_historic()) self.publisher.deregister(keys.get_key_count())
def __init__(self, controller, subscriber): super(WinExecution, self).__init__() self.controller = controller self.subscriber = subscriber self.shared_info = SharedInfo() self.mode_edit = False self.last_index = 0 self.ui = None self.reload_ui() self.shared_info.connect(SharedInfo.GLOBAL_MEDIA, self._change_media) self.shared_info.connect(SharedInfo.GLOBAL_FILTERCHAIN, self._change_filterchain) self.shared_info.connect(SharedInfo.GLOBAL_HIST_REC_PATH_MEDIA, self._change_media_path) self.subscriber.subscribe(keys.get_key_execution_list(), self.update_execution_list)
def stop_filterchain_execution(self, execution_name): self._post_command_(locals()) execution = self.dct_exec.get(execution_name, None) if not execution: log.print_function( logger.warning, "The execution %s is already stopped." % execution_name) return False # Remove execution image observer from media observer = execution.get(KEY_MEDIA, None) if observer is None: logger.critical( "Not found the observer about execution %s" % execution_name) return False filterchain = execution.get(KEY_FILTERCHAIN, None) if filterchain is None: logger.critical("Not found the filterchain about \ execution %s" % execution_name) return False observer.remove_observer(filterchain.execute) # deregiste key # TODO move this in filter destroy for filter_name in filterchain.get_filter_name(): key = keys.create_unique_exec_filter_name(execution_name, filter_name) self.publisher.deregister(key) filterchain.destroy() del self.dct_exec[execution_name] # publish removing filterchain self.publisher.publish( keys.get_key_execution_list(), "-%s" % execution_name) return True