def __init__(self, context, main_ep, opt_ep=None): """Init MDPBroker instance. """ l = logger.Logger('mq_broker') self.log = l.get_logger() self.log.info("MDP broker startup...") socket = ZmqSocket(context, zmq.ROUTER) socket.bind(main_ep) self.main_stream = ZMQStream(socket) self.main_stream.on_recv(self.on_message) if opt_ep: socket = ZmqSocket(context, zmq.ROUTER) socket.bind(opt_ep) self.client_stream = ZMQStream(socket) self.client_stream.on_recv(self.on_message) else: self.client_stream = self.main_stream self.log.debug("Socket created...") self._workers = {} # services contain the worker queue and the request queue self._services = {} self._worker_cmds = { b'\x01': self.on_ready, b'\x03': self.on_reply, b'\x04': self.on_heartbeat, b'\x05': self.on_disconnect, } self.log.debug("Launch the timer...") self.hb_check_timer = PeriodicCallback(self.on_timer, HB_INTERVAL) self.hb_check_timer.start() self.log.info("MDP broker started") return
def __init__(self, serialConf): l = logger.Logger('x10API') self._log = l.get_logger() self._retry = 3 self._lastUnit = -1 # Mutex for serial port acces self._lock = threading.Lock() self._timeout = serialConf['timeout'] self._serialdevice = serial.Serial() # Port self._serialdevice.setPort(serialConf['port']) # Speed self._serialdevice.setBaudrate(serialConf['speed']) # Timeout self._serialdevice.setTimeout(serialConf['timeout']) # Parity self._serialdevice.setParity(serialConf['parity']) # Stop bit self._serialdevice.setStopbits(serialConf['stop_bits']) # Byte size self._serialdevice.setByteSize(serialConf['byte_size']) self._open()
def __init__(self): """ telldusTool helper """ self.commands = \ { "list" : { "cb" : self.list, "desc" : "List devices referenced by the telldus", "min_args" : 0, "usage" : "list [devicetype]" }, "info" : { "cb" : self.info, "desc" : "Display device information", "min_args" : 1, "usage" : "info <id>" } } log = logger.Logger('telldus-helper') self._log = log.get_logger('telldus-helper') # self._config = Query(self.myxpl, self._log) self._log.info("telldusHelper.init : done") self._telldusd = Telldusd()
def __init__(self): """ Init onewire helper """ self.commands = \ { "all" : { "cb" : self.all, "desc" : "Show all devices found on onewire network", "min_args" : 1, "usage" : "all <adaptator device>" }, "detail" : { "cb" : self.detail, "desc" : "Show detail for a device.", "min_args" : 1, "usage" : "detail <adaptator device> <device id>" }, "ds18b20" : { "cb" : self.ds18b20, "desc" : "Show detail for all DS18B20 devices", "min_args" : 1, "usage" : "ds18b20 <adaptator device>" }, "ds18s20" : { "cb" : self.ds18s20, "desc" : "Show detail for all DS18S20 devices", "min_args" : 1, "usage" : "ds18s20 <adaptator device>" }, "ds2401" : { "cb" : self.ds2401, "desc" : "Show detail for all DS2401 devices", "min_args" : 1, "usage" : "ds2401 <adaptator device>" }, "ds2438" : { "cb" : self.ds2438, "desc" : "Show detail for all DS2438 devices", "min_args" : 1, "usage" : "ds2438 <adaptator device>" }, "ds2408" : { "cb" : self.ds2408, "desc" : "Show detail for all DS2408/DS2406/DS2405 devices", "min_args" : 1, "usage" : "ds2408 <adaptator device>" } } log = logger.Logger('onewire-helper') self._log = log.get_logger('onewire-helper') self.my_ow = None
def __init__(self): ### init zmq zmqc = zmq.Context() ### init logger loginst = logger.Logger('manager') log = loginst.get_logger('manager') self.qry = QueryMQ(zmqc, log)
def __init__(self): """ Init """ # set logger l = logger.Logger("testrunner") l.set_format_mode("messageOnly") self.log = l.get_logger() # read the config file try: cfg = Loader('domogik') config = cfg.load() conf = dict(config[1]) # pid dir path self._libraries_path = conf['libraries_path'] self.log.debug("Libraries path is : {0}".format(self._libraries_path)) except: self.log.error(u"Error while reading the configuration file '{0}' : {1}".format(CONFIG_FILE, traceback.format_exc())) return parser = ArgumentParser(description="Launch all the tests that don't need hardware.") parser.add_argument("directory", help="What directory to run") parser.add_argument("-a", "--allow-alter", dest="allow_alter", action="store_true", help="Launch the tests that can alter the configuration of the plugin or the setup (devices, ...)") parser.add_argument("-c", "--criticity", dest="criticity", help="Set the minimum level of criticity to use to filter the tests to execute. low/medium/high. Default is low.") self.options = parser.parse_args() self.testcases = {} self.results = {} # options self.log.info("Domogik release : {0}".format(DMG_VERSION)) self.log.info("Running test with the folowing parameters:") if self.options.allow_alter: self.log.info("- allow to alter the configuration or setup.") if self.options.criticity not in (LOW, MEDIUM, HIGH): self.options.criticity = LOW self.log.info("- criticity : {0}".format(self.options.criticity)) # check tests folder self.log.info("- path {0}".format(self.options.directory)) if not self.check_dir(): return # check and load the json file self.log.info("- json file {0}".format(self.json_file)) if not self.load_json(): return
def __init__(self): ### init zmq zmqc = zmq.Context() ### init logger loginst = logger.Logger('butler') log = loginst.get_logger('butler') self.qry = QueryMQ(zmqc, log, get_sanitized_hostname())
def __init__(self): """ Init """ l = logger.Logger("testrunner") l.set_format_mode("messageOnly") self.log = l.get_logger() parser = ArgumentParser( description="Launch all the tests that don't need hardware.") parser.add_argument("directory", help="What directory to run") parser.add_argument( "-a", "--allow-alter", dest="allow_alter", action="store_true", help= "Launch the tests that can alter the configuration of the plugin or the setup (devices, ...)" ) parser.add_argument( "-c", "--criticity", dest="criticity", help= "Set the minimum level of criticity to use to filter the tests to execute. low/medium/high. Default is low." ) self.options = parser.parse_args() self.testcases = {} self.results = {} # options self.log.info("Domogik release : {0}".format(DMG_VERSION)) self.log.info("Running test with the folowing parameters:") if self.options.allow_alter: self.log.info("- allow to alter the configuration or setup.") if self.options.criticity not in (LOW, MEDIUM, HIGH): self.options.criticity = LOW self.log.info("- criticity : {0}".format(self.options.criticity)) # check tests folder self.log.info("- path {0}".format(self.options.directory)) if not self.check_dir(): return False # check and load the json file self.log.info("- json file {0}".format(self.json_file)) if not self.load_json(): return False self._run_testcases() print self.results # TODO : return False is some tests fails return True
def __init__(self, pipe): """ @param pipe : the Popen instance """ threading.Thread.__init__(self) self._pipe = pipe self._cbs = [] log = logger.Logger(self.__class__.__name__) self._log = log.get_logger('x10_heyu') # for last command self._selectedunit = None self._last_hashcmd = None
def __init__(self, heyuconf, serial_port=0): self._serialconf = { 'speed': 4800, 'timeout': 15, 'parity': serial.PARITY_NONE, 'stop_bits': serial.STOPBITS_ONE, 'byte_size': serial.EIGHTBITS } self._serialconf['port'] = serial_port l = logger.Logger('x10API') self._log = l.get_logger() self._housecodes = list('ABCDEFGHIJKLMNOP') self._unitcodes = range(1, 17) self._heyuconf = heyuconf self._controller = X10Controller(self._serialconf)
def __init__(self): """ Init Teleinfo helper """ self.commands = \ { "read" : { "cb" : self.read, "desc" : "Display electric meter informations", "min_args" : 1, "usage" : "read <device path>" } } log = logger.Logger('teleinfo-helper') self._log = log.get_logger('teleinfo-helper')
def __init__(self): """ Init Caller Id with a modem helper """ self.commands = \ { "read" : { "cb" : self.read, "desc" : "Wait for a inbound call event", "min_args" : 1, "usage" : "read <device>" }, } log = logger.Logger('cidmodem-helper') self._log = log.get_logger('cidmodem-helper')
def __init__(self): """ Init Mir:ror helper """ self.commands = \ { "read" : { "cb" : self.read, "desc" : "Wait for a Mir:ror event", "min_args" : 1, "usage" : "read <device>" } } log = logger.Logger('mirror-helper') self._log = log.get_logger('mirror-helper')
def __init__(self): """ bluez helper """ self.commands = \ { "scan" : { "cb" : self.scan, "desc" : "Scan for bluetooth phones, ...", "min_args" : 0, "usage" : "scan" }, } log = logger.Logger('bluez-helper') self._log = log.get_logger('bluez-helper')
def main(): """ Main loop for the forwarder """ ctx = DaemonContext() ctx.open() cfg = Loader('mq').load() config = dict(cfg[1]) log = logger.Logger('mq_forwarder').get_logger() log.info("Starting the forwarder") try: context = zmq.Context(1) # Socket facing emitters frontend = context.socket(zmq.SUB) # Forwarder subscribes to the emitter *pub* port sub_addr = "tcp://{0}:{1}".format(\ config['ip'], config['pub_port']) frontend.bind(sub_addr) log.info("Waiting for messages on {0}".format(sub_addr)) # We want to get all messages from emitters frontend.setsockopt(zmq.SUBSCRIBE, "") # Socket facing receivers backend = context.socket(zmq.PUB) # Forwarder publishes to the receiver *sub* port pub_addr = "tcp://{0}:{1}".format(\ config['ip'], config['sub_port']) backend.bind(pub_addr) log.info("Sending messages to {0}".format(pub_addr)) log.info("Forwarding messages...") zmq.device(zmq.FORWARDER, frontend, backend) except Exception as exp: log.error(exp) log.error("Bringing down ZMQ device") raise Exception("Error with forwarder device") finally: frontend.close() backend.close() context.term() log.info("Forwarder stopped")
def __init__(self): self._event = Event() self.message = [] self.commands = \ { "find" : { "cb" : self.find, "desc" : "Show all nodes found on Z-wave network", }, "info" : { "cb" : self.info, "desc" : "Show node info", "min_args" : 1, "usage" : "Show info for specified node <node id>", } } log = logger.Logger('zwave-helper') self._log = log.get_logger('zwave-helper')
def __init__(self): """ Init IPX 800 helper """ self.commands = \ { "find" : { "cb" : self.find, "desc" : "Find ipx800 relay boards" }, "status" : { "cb" : self.status, "desc" : "Display all ipx800 elements status", "min_args" : 1, "usage" : "status <ipx800 ip> <ipx800 model : %s>" % IPX800_MODELS } } log = logger.Logger('ipx800-helper') self._log = log.get_logger('ipx800-helper')
def __init__(self): """ Init """ l = logger.Logger("package") l.set_format_mode("messageOnly") self.log = l.get_logger() parser = ArgumentParser() parser.add_argument( "-i", "--install", dest="install", help= "Install a package from a path, a zip file or an url to a zip file or to a github repository and branch" ) parser.add_argument( "-u", "--uninstall", dest="uninstall", help="Uninstall a package. Example : plugin_rfxcom") self.options = parser.parse_args() # get install path for packages cfg = Loader('domogik') config = cfg.load() conf = dict(config[1]) self.pkg_path = os.path.join(conf['libraries_path'], PACKAGES_DIR) # install a package if self.options.install: self.install(self.options.install) # uninstall a package elif self.options.uninstall: self.uninstall(self.options.uninstall) # no choice : display the list of installed packages else: self.list_packages()
def __init__(self): self._event = Event() self.liste_found = [] self.commands = \ { "all" : { "cb" : self.all, "desc" : "Show all devices found on plcbus network", "min_args" : 2, "usage" : "find device for specified house code <house code> and user code <user code>." }, "detail" : { "cb" : self.detail, "desc" : "Show device detail ", "min_args" : 2, "usage" : "show status for specified device <device code> and user code <user code>" } } log = logger.Logger('plcbus-helper') self._log = log.get_logger('plcbus-helper') device = '/dev/plcbus' self.api1 = PLCBUSAPI(self._log, device, self._command_cb, self._message_cb)
def __init__(self, minute, hour, day, month, daynumber, year): ''' Create a time condition Each param can be : * an integer (eg : 6, 9, 12) * a tuple (eg : (3,9)) : repesents an interval (here between 3 and 9) * a list (eg : [4,6,9]) * a list of tuple (eg : [(4,9),(18,22)] : union of intervals * a string (eg : '*', '*/8') : '*' = always, '*/X' = every X time unit @param year @param month @param day @param daynumber : 0 - 6 for Monday - Sunday @param hour @param minute ''' self.year = year self.month = month self.day = day self.hour = hour self.minute = minute self.daynumber = daynumber l = logger.Logger('trigger') self._log = l.get_logger('trigger')
def __init__(self, name, stop_cb = None, p = None, daemonize = True): ''' @param p : An instance of OptionParser. If you want to add extra options to the generic option parser, create your own optionparser instance, use parser.addoption and then pass your parser instance as parameter. Your options/params will then be available on self.options and self.args @param daemonize : If set to False, force the instance *not* to daemonize, even if '-f' is not passed on the command line. If set to True (default), will check if -f was added. ''' # First, check if the user is allowed to launch the plugin. The user must be the same as the one defined # in the file /etc/default/domogik : DOMOGIK_USER Default = DefaultLoader() dmg_user = Default.get("DOMOGIK_USER") logname = pwd.getpwuid(os.getuid())[0] if dmg_user != logname: print("ERROR : this Domogik part must be run with the user defined in /etc/default/domogik as DOMOGIK_USER : %s" % dmg_user) sys.exit(1) # Then, start the plugin... self._threads = [] self._timers = [] if name is not None: self._plugin_name = name self._stop = threading.Event() self._lock_add_thread = threading.Semaphore() self._lock_add_timer = threading.Semaphore() self._lock_add_cb = threading.Semaphore() if stop_cb is not None: self._stop_cb = [stop_cb] else: self._stop_cb = [] # options management if p is not None and isinstance(p, OptionParser): parser = p else: parser = OptionParser() parser.add_option("-V", "--version", action="store_true", dest="display_version", default=False, help="Display Domogik version.") parser.add_option("-f", action="store_true", dest="run_in_foreground", default=False, help="Run the plugin in foreground, default to background.") (self.options, self.args) = parser.parse_args() if self.options.display_version: __import__("domogik") global_release = sys.modules["domogik"].__version__ print global_release sys.exit(0) elif not self.options.run_in_foreground and daemonize: createDaemon() l = logger.Logger(name) self.log = l.get_logger() self.log.info("Daemonize plugin %s" % name) self.is_daemon = True else: l = logger.Logger(name) self.log = l.get_logger() self.is_daemon = False
def __init__(self, server_ip, server_port): """ Initiate DbHelper, Logs and config Then, start HTTP server and give it initialized data @param server_ip : ip of HTTP server @param server_port : port of HTTP server """ XplPlugin.__init__(self, name='rest') # logging initialization self.log.info("Rest Server initialisation...") self.log.debug("locale : %s %s" % locale.getdefaultlocale()) # logging Queue activities log_queue = logger.Logger('rest-queues') self.log_queue = log_queue.get_logger('rest-queues') self.log_queue.info("Rest's queues activities...") # logging data manipulation initialization log_dm = logger.Logger('rest-dm') self.log_dm = log_dm.get_logger('rest-dm') self.log_dm.info("Rest Server Data Manipulation...") # API version self._rest_api_version = REST_API_VERSION # Hosts list self._hosts_list = { self.get_sanitized_hostname(): { "id": self.get_sanitized_hostname(), "status": "on", "primary": True, "last_seen": time.time(), "ip": "", "interval": "1" } } try: ### Config # directory data cfg = Loader('domogik') config = cfg.load() conf = dict(config[1]) self.log_dir_path = conf['log_dir_path'] # plugin installation path if conf.has_key('package_path'): self._package_path = conf['package_path'] self._src_prefix = None self.log.info("Set package path to '%s' " % self._package_path) print("Set package path to '%s' " % self._package_path) self._design_dir = "%s/domogik_packages/design/" % self._package_path self.package_mode = True else: self.log.info("No package path defined in config file") self._package_path = None self._src_prefix = conf['src_prefix'] self._design_dir = "%s/share/domogik/design/" % conf[ 'src_prefix'] self.package_mode = False # HTTP server ip and port try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.server_ip = conf_rest['rest_server_ip'] self.server_port = conf_rest['rest_server_port'] except KeyError: # default parameters self.server_ip = server_ip self.server_port = server_port self.log.info("Configuration : ip:port = %s:%s" % (self.server_ip, self.server_port)) # SSL configuration try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.use_ssl = conf_rest['rest_use_ssl'] if self.use_ssl == "True": self.use_ssl = True else: self.use_ssl = False self.ssl_certificate = conf_rest['rest_ssl_certificate'] except KeyError: # default parameters self.use_ssl = USE_SSL self.ssl_certificate = SSL_CERTIFICATE if self.use_ssl == True: self.log.info( "Configuration : SSL support activated (certificate : %s)" % self.ssl_certificate) else: self.log.info("Configuration : SSL support not activated") # File repository try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.repo_dir = conf_rest['rest_repository'] except KeyError: # default parameters self.repo_dir = DEFAULT_REPO_DIR # Gloal Queues config self.log.debug("Get queues configuration") self._config = Query(self.myxpl, self.log) self._queue_timeout = self._config.query('rest', 'q-timeout') if self._queue_timeout == None: self._queue_timeout = QUEUE_TIMEOUT self._queue_timeout = float(self._queue_timeout) self._queue_package_size = self._config.query('rest', 'q-pkg-size') if self._queue_package_size == None: self._queue_package_size = QUEUE_PACKAGE_SIZE self._queue_package_size = float(self._queue_package_size) self._queue_size = self._config.query('rest', 'q-size') if self._queue_size == None: self._queue_size = QUEUE_SIZE self._queue_size = float(self._queue_size) self._queue_life_expectancy = self._config.query( 'rest', 'q-life-exp') if self._queue_life_expectancy == None: self._queue_life_expectancy = QUEUE_LIFE_EXPECTANCY self._queue_life_expectancy = float(self._queue_life_expectancy) self._queue_sleep = self._config.query('rest', 'q-sleep') if self._queue_sleep == None: self._queue_sleep = QUEUE_SLEEP self._queue_sleep = float(self._queue_sleep) # /command Queues config self._queue_command_size = self._config.query('rest', 'q-cmd-size') if self._queue_command_size == None: self._queue_command_size = QUEUE_COMMAND_SIZE self._queue_command_size = float(self._queue_command_size) # /event Queues config self._event_timeout = self._config.query('rest', 'evt-timeout') if self._event_timeout == None: self._event_timeout = EVENT_TIMEOUT self._event_timeout = float(self._event_timeout) self._queue_event_size = self._config.query('rest', 'q-evt-size') if self._queue_event_size == None: self._queue_event_size = QUEUE_EVENT_SIZE self._queue_event_size = float(self._queue_event_size) self._queue_event_timeout = self._config.query( 'rest', 'q-evt-timeout') if self._queue_event_timeout == None: self._queue_event_timeout = QUEUE_EVENT_TIMEOUT self._queue_event_timeout = float(self._queue_event_timeout) self._queue_event_life_expectancy = self._config.query( 'rest', 'q-evt-life-exp') if self._queue_event_life_expectancy == None: self._queue_event_life_expectancy = QUEUE_EVENT_LIFE_EXPECTANCY self._queue_event_life_expectancy = float( self._queue_event_life_expectancy) # Queues for xPL # Queues for packages management self._queue_package = Queue(self._queue_package_size) # Queues for domogik system actions self._queue_system_list = Queue(self._queue_size) self._queue_system_detail = Queue(self._queue_size) self._queue_system_start = Queue(self._queue_size) self._queue_system_stop = Queue(self._queue_size) # Queues for /command self._queue_command = Queue(self._queue_command_size) # Queues for /events/domogik self._queue_event_dmg = Queue(self._queue_event_size) # Queues for /events/request # this queue will be fill by stat manager self._event_requests = RequestEvents( self.get_stop, self.log, self._event_timeout, self._queue_event_size, self._queue_event_timeout, self._queue_event_life_expectancy) self.add_stop_cb(self._event_requests.set_stop_clean) # Queues for /events/domogik # this queue will be fill by stat manager self._event_dmg = DmgEvents(self.get_stop, self.log, self._event_timeout, self._queue_event_size, self._queue_event_timeout, self._queue_event_life_expectancy) # notice : adding data in queue is made in _add_to_queue_system_list self.add_stop_cb(self._event_dmg.set_stop_clean) # define listeners for queues self.log.debug("Create listeners") if self.package_mode == True: Listener(self._list_installed_packages, self.myxpl, \ {'schema': 'domogik.package', 'xpltype': 'xpl-trig', 'command' : 'installed-packages-list'}) Listener(self._add_to_queue_package, self.myxpl, \ {'schema': 'domogik.package', 'xpltype': 'xpl-trig'}) Listener(self._add_to_queue_system_list, self.myxpl, \ {'schema': 'domogik.system', 'xpltype': 'xpl-trig', 'command' : 'list'}) Listener(self._add_to_queue_system_list, self.myxpl, \ {'schema': 'domogik.system', 'xpltype': 'xpl-trig', 'command' : 'enable'}) Listener(self._add_to_queue_system_list, self.myxpl, \ {'schema': 'domogik.system', 'xpltype': 'xpl-trig', 'command' : 'disable'}) Listener(self._add_to_queue_system_detail, self.myxpl, \ {'schema': 'domogik.system', 'xpltype': 'xpl-trig', 'command' : 'detail'}) Listener(self._add_to_queue_system_start, self.myxpl, \ {'schema': 'domogik.system', 'xpltype': 'xpl-trig', 'command' : 'start'}) Listener(self._add_to_queue_system_stop, self.myxpl, \ {'schema': 'domogik.system', 'xpltype': 'xpl-trig', 'command' : 'stop'}) Listener(self._add_to_queue_command, self.myxpl, \ {'xpltype': 'xpl-trig'}) # Listener for hosts list Listener(self._list_hosts, self.myxpl, \ {'schema': 'hbeat.app', 'xpltype': 'xpl-stat'}) # Background process to check if hosts has disappeared thr_hbeat = XplTimer(10, \ self._refresh_status_for_list_hosts, \ self.myxpl) thr_hbeat.start() self._discover_hosts() # Enable hbeat self.enable_hbeat() # Ask for installed packages on all hosts # Semaphore init for installed package list update self.sema_installed = Semaphore(value=1) self._installed_packages = {} if self.package_mode == True: self._get_installed_packages_from_manager() # Launch server, stats self.log.info("REST Initialisation OK") self.add_stop_cb(self.stop_http) self.server = None self.start_stats() self.start_http() except: self.log.error("%s" % self.get_exception())
def __init__(self, name, stop_cb=None, p=None, daemonize=True, log_prefix="", log_on_stdout=True): ''' @param p : An instance of ArgumentParser. If you want to add extra options to the generic option parser, create your own ArgumentParser instance, use parser.add_argument and then pass your parser instance as parameter. Your options/params will then be available on self.options and self.args @param daemonize : If set to False, force the instance *not* to daemonize, even if '-f' is not passed on the command line. If set to True (default), will check if -f was added. @param log_prefix : If set, use this prefix when creating the log file in Logger() @param log_on_stdout : if set to True, allow to read logs on both stdout and log file ''' ### First, check if the user is allowed to launch the plugin. The user must be the same as the one defined # in the file /etc/default/domogik : DOMOGIK_USER Default = DefaultLoader() dmg_user = Default.get("DOMOGIK_USER") logname = pwd.getpwuid(os.getuid())[0] if dmg_user != logname: print( u"ERROR : this Domogik part must be run with the user defined in /etc/default/domogik as DOMOGIK_USER : %s" % dmg_user) sys.exit(1) if name is not None: self._plugin_name = name l = logger.Logger(name, use_filename="{0}{1}".format(log_prefix, name), log_on_stdout=log_on_stdout) self.log = l.get_logger() ### Check if the plugin is not already launched # notice that when the plugin is launched from the manager, this call is not done as the manager already does this test before starting a plugin # TODO : improve ? currently, as it is not used, we set the type of the client to None # in case the 'is_already_launched function would use it a day, we should find a way to get the client type res, pid_list = is_already_launched(self.log, None, name) if res: sys.exit(2) ### Create a file to handle the return code # this is used by the function set_return_code and get_return_code # this is needed as a Domogik process is forked, there is no way to send from a class a return code from the child to the parent. try: self.return_code_filename = "{0}/{1}_return_code_{2}".format( FIFO_DIR, self._plugin_name, os.getpid()) # just touch the file to create it open(self.return_code_filename, 'a').close() except: self.log.error( "Error while creating return_code file '{0}' : {1}".format( self.return_code_filename, traceback.format_exc())) sys.exit(3) ### Start the plugin... self._threads = [] self._timers = [] self._stop = threading.Event() self._lock_add_thread = threading.Semaphore() self._lock_add_timer = threading.Semaphore() self._lock_add_cb = threading.Semaphore() if stop_cb is not None: self._stop_cb = [stop_cb] else: self._stop_cb = [] ### options management if p is not None and isinstance(p, ArgumentParser): parser = p else: parser = ArgumentParser() parser.add_argument("-V", "--version", action="store_true", dest="display_version", default=False, help="Display Domogik version.") parser.add_argument( "-f", action="store_true", dest="run_in_foreground", default=False, help="Run the plugin in foreground, default to background.") parser.add_argument("-T", dest="test_option", default=None, help="Test option.") self.options = parser.parse_args() if self.options.display_version: __import__("domogik") global_release = sys.modules["domogik"].__version__ print(global_release) sys.exit(0) elif not self.options.run_in_foreground and daemonize: self.log.info(u"Starting the plugin in background...") ctx = DaemonContext() ctx.files_preserve = l.get_fds([name]) ctx.open() self.log.info(u"Daemonize plugin %s" % name) self.is_daemon = True else: #l = logger.Logger(name) #self.log = l.get_logger() self.is_daemon = False
def __init__(self): """ Init tool """ log = logger.Logger("package-manager") self._log = log.get_logger("package-manager")
def __init__(self): """ Init """ l = logger.Logger("package") l.set_format_mode("messageOnly") self.log = l.get_logger() parser = ArgumentParser() parser.add_argument( "-i", "--install", dest="install", help= "Install a package from a path, a zip file or an url to a zip file or to a github repository and branch" ) parser.add_argument("-u", "--upgrade", dest="upgrade", help="Upgrade a package (zip and url only).") parser.add_argument( "-r", "--remove", dest="uninstall", help="Remove (uninstall) a package. Example : plugin_rfxcom") parser.add_argument( "-d", "--refresh-docs", dest="refresh_docs", action="store_true", help= "Refresh all packages documentations (usefull when you use the git sources" ) parser.add_argument( "-H", "--hash", dest="hash", help= "Hash value to check the package integrity. Only for zip files!") self.options = parser.parse_args() # get install path for packages cfg = Loader('domogik') config = cfg.load() conf = dict(config[1]) self.pkg_path = os.path.join(conf['libraries_path'], PACKAGES_DIR) self.resources_path = os.path.join(conf['libraries_path'], RESOURCES_DIR) # install a package if self.options.install: if self.options.hash: self.install(self.options.install, self.options.hash) else: self.install(self.options.install) # uninstall a package elif self.options.uninstall: self.uninstall(self.options.uninstall) # upgrade a package elif self.options.upgrade: if self.options.hash: self.install(self.options.upgrade, hash=self.options.hash, upgrade=True) else: self.install(self.options.upgrade, hash=None, upgrade=True) # refresh the docs elif self.options.refresh_docs: self.refresh_docs() # no choice : display the list of installed packages else: self.list_packages()