def __init__(self, name = None, url = None, path = None, pkg_type = "plugin", data = None):
""" Read json file of a plugin and make an object from it
@param name : name of package
@param url : url of file
@param path : path of file
@param pkg_type : package type (default : 'plugin')
To use only with name != None
@param data : json data as a python object. Used by package.py when installing a zip file : the json is read from memory
"""
json_file = None
try:
# load from sources repository
if name != None:
# get config
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
if pkg_type == "plugin":
json_file = "{0}/{1}/{2}_{3}/info.json".format(conf['libraries_path'], PACKAGES_DIR, pkg_type, name)
icon_file = "{0}/{1}/{2}_{3}/design/icon.png".format(conf['libraries_path'], PACKAGES_DIR, pkg_type, name)
# TODO : reactivate later
#elif pkg_type == "external":
# if conf.has_key('package_path'):
# json_directory = "%s/domogik_packages/externals/" % (conf['package_path'])
# else:
# json_directory = "%s/%s" % (conf['src_prefix'], "share/domogik/externals/")
else:
raise PackageException("Type '%s' doesn't exists" % pkg_type)
#json_file = "%s/%s.json" % (json_directory, name)
self.json = json.load(open(json_file))
elif path != None:
json_file = path
icon_file = None
self.json = json.load(open(json_file))
elif url != None:
json_file = url
icon_file = None
json_data = urllib2.urlopen(json_file)
# TODO : there is an error here!!!!!
self.json = json.load(xml_data)
elif data != None:
json_file = None
icon_file = None
self.json = data
self.validate()
# complete json
self.json["identity"]["package_id"] = "%s-%s" % (self.json["identity"]["type"],
self.json["identity"]["name"])
self.json["identity"]["icon_file"] = icon_file
except PackageException as exp:
raise PackageException(exp.value)
except:
raise PackageException("Error reading json file : %s : %s" % (json_file, str(traceback.format_exc())))
def __init__(self, xpl, log = None):
'''
Init the query system and connect it to xPL network
:param xpl: the XplManager instance (usually self.myxpl)
:param log: a Logger instance (usually took from self.log))
'''
self.log = log
self.__myxpl = xpl
if self.log != None : self.log.debug("Init config query instance")
self._keys = {}
self._listens = {}
self._result = None
self.parameters = ["parameter0", "parameter1"]
self.values = ["valueon", "valueoff"]
# Check in config file is target is forced
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
if conf.has_key('query_xpl_timeout'):
try:
self.query_timeout = int(conf["query_xpl_timeout"])
msg = "Set query timeout to '%s' from domogik.cfg" % self.query_timeout
if self.log != None : self.log.debug(msg)
except ValueError:
#There is an error in domogik.cfg. Set it to default.
self.query_timeout = 10
msg = "Error in domogik.cfg. query_xpl_timeout ('%s') is not an integer." % conf["query_xpl_timeout"]
if self.log != None : self.log.error(msg)
else:
#There is not option in domogik.cfg. Set it to default.
self.query_timeout = 10
def get_data_files_directory(self):
"""
Return the directory where a plugin developper can store data files.
If the directory doesn't exist, try to create it.
After that, try to create a file inside it.
If something goes wrong, generate an explicit exception.
"""
cfg = Loader('domogik')
my_conf = cfg.load()
config = dict(my_conf[1])
path = "{0}/{1}/{2}_{3}/data/" % (self.librairies_directory, PACKAGES_DIR, "plugin", self._name)
if os.path.exists(path):
if not os.access(path, os.W_OK & os.X_OK):
raise OSError("Can't write in directory %s" % path)
else:
try:
os.mkdir(path, '0770')
self.log.info(u"Create directory %s." % path)
except:
raise OSError("Can't create directory %s." % path)
try:
tmp_prefix = "write_test";
count = 0
filename = os.path.join(path, tmp_prefix)
while(os.path.exists(filename)):
filename = "{}.{}".format(os.path.join(path, tmp_prefix),count)
count = count + 1
f = open(filename,"w")
f.close()
os.remove(filename)
except :
raise IOError("Can't create a file in directory %s." % path)
return path
def __init__(self, xpl, log=None):
'''
Init the query system and connect it to xPL network
:param xpl: the XplManager instance (usually self.myxpl)
:param log: a Logger instance (usually took from self.log))
'''
self.log = log
self.__myxpl = xpl
if self.log != None: self.log.debug("Init config query instance")
self._keys = {}
self._listens = {}
self._result = None
self.parameters = ["parameter0", "parameter1"]
self.values = ["valueon", "valueoff"]
# Check in config file is target is forced
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
if conf.has_key('query_xpl_timeout'):
try:
self.query_timeout = int(conf["query_xpl_timeout"])
msg = "Set query timeout to '%s' from domogik.cfg" % self.query_timeout
if self.log != None: self.log.debug(msg)
except ValueError:
#There is an error in domogik.cfg. Set it to default.
self.query_timeout = 10
msg = "Error in domogik.cfg. query_xpl_timeout ('%s') is not an integer." % conf[
"query_xpl_timeout"]
if self.log != None: self.log.error(msg)
else:
#There is not option in domogik.cfg. Set it to default.
self.query_timeout = 10
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 get_data_files_directory(self):
"""
Return the directory where a plugin developper can store data files.
If the directory doesn't exist, try to create it.
After that, try to create a file inside it.
If something goes wrong, generate an explicit exception.
"""
cfg = Loader('domogik')
my_conf = cfg.load()
config = dict(my_conf[1])
path = "{0}/{1}/{2}_{3}/data/" % (self.librairies_directory, PACKAGES_DIR, "plugin", self._name)
if os.path.exists(path):
if not os.access(path, os.W_OK & os.X_OK):
raise OSError("Can't write in directory %s" % path)
else:
try:
os.mkdir(path, '0770')
self.log.info(u"Create directory %s." % path)
except:
raise OSError("Can't create directory %s." % path)
try:
tmp_prefix = "write_test";
count = 0
filename = os.path.join(path, tmp_prefix)
while(os.path.exists(filename)):
filename = "{}.{}".format(os.path.join(path, tmp_prefix),count)
count = count + 1
f = open(filename,"w")
f.close()
os.remove(filename)
except :
raise IOError("Can't create a file in directory %s." % path)
return path
def __init__(self, server_interfaces, server_port):
""" Initiate DbHelper, Logs and config
Then, start HTTP server and give it initialized data
@param server_interfaces : interfaces of HTTP server
@param server_port : port of HTTP server
"""
Plugin.__init__(self, name = 'admin')
# logging initialization
self.log.info(u"Admin Server initialisation...")
self.log.debug(u"locale : %s %s" % locale.getdefaultlocale())
try:
try:
# admin config
cfg_admin = Loader('admin')
config_admin = cfg_admin.load()
conf_admin = dict(config_admin[1])
self.interfaces = conf_admin['interfaces']
self.port = conf_admin['port']
# if use_ssl = True, set here path for ssl certificate/key
self.use_ssl = conf_admin['use_ssl']
self.key_file = conf_admin['ssl_certificate']
self.cert_file = conf_admin['ssl_key']
except KeyError:
# default parameters
self.interfaces = server_interfaces
self.port = server_port
self.use_ssl = False
self.key_file = ""
self.cert_file = ""
self.clean_json = False
self.log.error("Error while reading configuration for section [admin] : using default values instead")
self.log.info(u"Configuration : interfaces:port = %s:%s" % (self.interfaces, self.port))
# get all datatypes
cli = MQSyncReq(self.zmq)
msg = MQMessage()
msg.set_action('datatype.get')
res = cli.request('manager', msg.get(), timeout=10)
if res is not None:
self.datatypes = res.get_data()['datatypes']
else:
self.datatypes = {}
# Launch server, stats
self.log.info(u"Admin Initialisation OK")
self.add_stop_cb(self.stop_http)
self.server = None
self.start_http()
# calls the tornado.ioloop.instance().start()
### Component is ready
self.ready(0)
IOLoop.instance().start()
except :
self.log.error(u"%s" % self.get_exception())
def __init__(self, component_name, domogik_prefix=True, use_filename=None, log_on_stdout = True):
'''
Get a logger with provided parameters and set config
@param component_name : component name to log
@param domogik_prefix : if logger name should be prefixed by 'domogik-'
@param use_filename : if set tells the logger to use this file name (otherwise takes 'component_name')
@param log_on_stdout : if set to True, allow to display logs in both stdout and log file
'''
if component_name not in self.logger:
LEVELS = {
'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL
}
cfg = Loader()
config = cfg.load()[0]
if use_filename is None:
filename = "{0}/{1}.log".format(config['log_dir_path'], component_name)
else:
filename = "{0}/{1}.log".format(config['log_dir_path'], use_filename)
level = config['log_level']
if 'log_when' not in config:
config['log_when'] = 'D'
if 'log_interval' not in config:
config['log_interval'] = 1
if 'log_backup_count' not in config:
config['log_backup_count'] = 10
if level not in LEVELS:
raise ValueError("level must be one of 'debug','info','warning',"\
"'error','critical'. Check your config.")
if domogik_prefix:
my_logger = logging.getLogger('domogik-{0}'.format(component_name))
else:
my_logger = logging.getLogger(component_name)
# log to file
my_logger.propagate = 0
if not my_logger.handlers:
hdlr = TimedRotatingFileHandler(filename, \
when=config['log_when'], interval=int(config['log_interval']), \
backupCount=int(config['log_backup_count']))
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
my_logger.addHandler(hdlr)
# if loglevvel is set to debug (all log entries also go to stdout)
# TODO : why looking about level=debug ? to clean ?
if log_on_stdout and level == 'debug' and component_name.find('sqlalchemy') == -1:
dhdlr = logging.StreamHandler(sys.stdout)
dhdlr.setFormatter(formatter)
my_logger.addHandler(dhdlr)
my_logger.setLevel(LEVELS[level])
self.logger[component_name] = my_logger
def get_data_files_directory_for_plugin(plugin_name):
""" This function is already defined in the Plugin class, but this one is used by the admin in application.py
In fact, this is not really the same function as this one takes one parameter
"""
# global config
cfg_global = Loader('domogik')
config_global = cfg_global.load()
conf_global = dict(config_global[1])
return "{0}/{1}/plugin_{2}/data".format(conf_global['libraries_path'], "domogik_packages", plugin_name)
def get_libraries_directory():
""" This function is already defined in the Plugin class, but this one is used by the admin in application.py
TODO : see if there is a cleaner way to do this!
"""
# global config
cfg_global = Loader('domogik')
config_global = cfg_global.load()
conf_global = dict(config_global[1])
return conf_global['libraries_path']
def __init__(self,
component_name,
domogik_prefix=True,
use_filename=None,
log_on_stdout=True):
'''
Get a logger with provided parameters and set config
@param component_name : component name to log
@param domogik_prefix : if logger name should be prefixed by 'domogik-'
@param use_filename : if set tells the logger to use this file name (otherwise takes 'component_name')
@param log_on_stdout : if set to True, allow to display logs in both stdout and log file
'''
if component_name not in self.logger:
LEVELS = {
'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL
}
cfg = Loader()
config = cfg.load()[0]
if use_filename is None:
filename = "%s/%s.log" % (config['log_dir_path'],
component_name)
else:
filename = "%s/%s.log" % (config['log_dir_path'], use_filename)
level = config['log_level']
if level not in LEVELS:
raise ValueError("level must be one of 'debug','info','warning',"\
"'error','critical'. Check your config.")
if domogik_prefix:
my_logger = logging.getLogger('domogik-%s' % component_name)
else:
my_logger = logging.getLogger(component_name)
# log to file
my_logger.propagate = 0
if not my_logger.handlers:
hdlr = logging.FileHandler(filename)
formatter = logging.Formatter(
'%(asctime)s %(name)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
my_logger.addHandler(hdlr)
# if loglevvel is set to debug (all log entries also go to stdout)
# TODO : why looking about level=debug ? to clean ?
if log_on_stdout and level == 'debug' and component_name.find(
'sqlalchemy') == -1:
dhdlr = logging.StreamHandler(sys.stdout)
dhdlr.setFormatter(formatter)
my_logger.addHandler(dhdlr)
my_logger.setLevel(LEVELS[level])
self.logger[component_name] = my_logger
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 api_root():
"""
@api {get} /rest/ Get the status of the REST server
@apiName getStatus
@apiGroup Status
@apiVersion 0.4.1
@apiSuccess {json} result A json result with the status
@apiSuccessExample Success-Response:
HTTTP/1.1 200 OK
{
"info": {
"REST_API_version": "0.7",
"SSL": false,
"Host": "igor",
"Domogik_release": "0.4.0",
"Domogik_version": "0.4.0",
"REST_API_release": "0.7",
"Sources_release": "0.4.0",
"Sources_version": "0.4.0"
},
"mq": {
"sub_port": "40412",
"ip": "127.0.0.1",
"req_rep_port": "40410",
"pub_port": "40411"
}
}
"""
# domogik global version
global_version = sys.modules["domogik"].__version__
src_version = global_version
info = {}
info["REST_API_version"] = app.apiversion
info["Domogik_version"] = global_version
info["Sources_version"] = src_version
info["SSL"] = app.use_ssl
info["Host"] = app.hostname
# for compatibility with Rest API < 0.6
info["REST_API_release"] = app.apiversion
info["Domogik_release"] = global_version
info["Sources_release"] = src_version
# mq part
mqconfig = Loader('mq', 'domogik-mq.cfg')
config = dict(mqconfig.load()[1])
mq = {}
mq["sub_port"] = config["sub_port"]
mq["ip"] = config["ip"]
mq["req_rep_port"] = config["req_rep_port"]
mq["pub_port"] = config["pub_port"]
data = {"info" : info, "mq": mq}
return 200, data
def get_libraries_directory():
""" This function is already defined in the Plugin class, but this one is used by the admin in application.py
TODO : see if there is a cleaner way to do this!
"""
# global config
cfg_global = Loader('domogik')
config_global = cfg_global.load()
conf_global = dict(config_global[1])
return conf_global['libraries_path']
def __init__(self, server_interfaces, server_port):
""" Initiate DbHelper, Logs and config
Then, start HTTP server and give it initialized data
@param server_interfaces : interfaces of HTTP server
@param server_port : port of HTTP server
"""
Plugin.__init__(self, name='admin')
# logging initialization
self.log.info(u"Admin Server initialisation...")
self.log.debug(u"locale : %s %s" % locale.getdefaultlocale())
try:
try:
cfg_rest = Loader('admin')
config_rest = cfg_rest.load()
conf_rest = dict(config_rest[1])
self.interfaces = conf_rest['interfaces']
self.port = conf_rest['port']
# if rest_use_ssl = True, set here path for ssl certificate/key
self.use_ssl = conf_rest['use_ssl']
self.key_file = conf_rest['ssl_certificate']
self.cert_file = conf_rest['ssl_key']
except KeyError:
# default parameters
self.interfaces = server_interfaces
self.port = server_port
self.use_ssl = False
self.key_file = ""
self.cert_file = ""
self.clean_json = False
self.log.info(u"Configuration : interfaces:port = %s:%s" %
(self.interfaces, self.port))
# get all datatypes
cli = MQSyncReq(self.zmq)
msg = MQMessage()
msg.set_action('datatype.get')
res = cli.request('manager', msg.get(), timeout=10)
if res is not None:
self.datatypes = res.get_data()['datatypes']
else:
self.datatypes = {}
# Launch server, stats
self.log.info(u"Admin Initialisation OK")
self.add_stop_cb(self.stop_http)
self.server = None
self.start_http()
# calls the tornado.ioloop.instance().start()
### Component is ready
self.ready(0)
IOLoop.instance().start()
except:
self.log.error(u"%s" % self.get_exception())
def api_datatype():
""" return the datatypes json file
"""
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
json_file = "{0}/datatypes.json".format(urlHandler.resources_directory)
data = json.load(open(json_file))
return 200, data
def get_rest_url():
""" Return the REST server url (constructed from the configuration file of the host)
"""
cfg = Loader('rest')
config = cfg.load()
conf = dict(config[1])
# we return the url related to the first declared interface in domogik.cfg
intf = conf['interfaces'].split(",")[0]
ip = get_ip_for_interfaces([intf])[0]
return "http://{0}:{1}/".format(ip, conf['port'])
def get_rest_doc_path():
""" return the REST API generated doc path
"""
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
### get libraries path
path = conf['libraries_path']
return "{0}/rest_doc_generated_during_install/".format(path)
def get_rest_doc_path():
""" return the REST API generated doc path
"""
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
### get libraries path
path = conf['libraries_path']
return "{0}/rest_doc_generated_during_install/".format(path)
def get_data_files_directory_for_plugin(plugin_name):
""" This function is already defined in the Plugin class, but this one is used by the admin in application.py
In fact, this is not really the same function as this one takes one parameter
"""
# global config
cfg_global = Loader('domogik')
config_global = cfg_global.load()
conf_global = dict(config_global[1])
return "{0}/{1}/plugin_{2}/data".format(conf_global['libraries_path'],
"domogik_packages", plugin_name)
def get_rest_url():
""" Return the REST server url (constructed from the configuration file of the host)
"""
cfg = Loader('rest')
config = cfg.load()
conf = dict(config[1])
# we return the url related to the first declared interface in domogik.cfg
intf = conf['interfaces'].split(",")[0]
ip = get_ip_for_interfaces([intf])[0]
return "http://{0}:{1}/".format(ip, conf['port'])
def api_datatype():
""" return the datatypes json file
"""
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
json_file = "{0}/datatypes.json".format(urlHandler.resources_directory)
data = json.load(open(json_file))
return 200, data
def get_backup_dir():
### Read the configuration file
try:
cfg = Loader('backup')
config = cfg.load()
conf = dict(config[1])
return conf['folder']
except:
print(u"Error while reading the configuration file '{0}' : {1}".format(CONFIG_FILE, traceback.format_exc()))
return None
def get_stats_files_directory(self):
""" Return the directory where a plugin developper can store data files
"""
cfg = Loader('domogik')
my_conf = cfg.load()
config = dict(my_conf[1])
if config.has_key('package_path'):
path = "%s/domogik_packages/stats/%s" % (config['package_path'], self._name)
else:
path = "%s/share/domogik/stats/%s" % (config['src_prefix'], self._name)
return path
def get_packages_dir():
### Read the configuration file
try:
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
return os.path.join(conf['libraries_path'], PACKAGES_DIR)
except:
print(u"Error while reading the configuration file '{0}' : {1}".format(CONFIG_FILE, traceback.format_exc()))
return None
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("-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)
# 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)
# no choice : display the list of installed packages
else:
self.list_packages()
def __init__(self, handler_params, xpl):
"""
@param handler_params : The server params
@param xpl : A xPL Manager instance
"""
try:
self.myxpl = xpl
# logging initialization
log = logger.Logger('rest-stat')
self._log_stats = log.get_logger('rest-stat')
self._log_stats.info("Rest Stat Manager initialisation...")
# logging initialization for unkwnon devices
log_unknown = logger.Logger('rest-stat-unknown-devices')
self._log_stats_unknown = log_unknown.get_logger('rest-stat-unknown-devices')
# config
cfg = Loader('domogik')
config = cfg.load()
cfg_db = dict(config[1])
# plugin installation path
if cfg_db.has_key('package_path'):
self._package_path = cfg_db['package_path']
self._log_stats.info("Set package path to '%s' " % self._package_path)
print("Set package path to '%s' " % self._package_path)
self.directory = "%s/domogik_packages/stats/" % self._package_path
else:
self._log_stats.info("No package path defined in config file")
self._package_path = None
self.directory = "%s/share/domogik/stats/" % cfg_db['src_prefix']
self._db = DbHelper()
### Rest data
self.handler_params = handler_params
self.handler_params.append(self._log_stats)
self.handler_params.append(self._log_stats_unknown)
self.handler_params.append(self._db)
self._event_requests = self.handler_params[0]._event_requests
self.get_exception = self.handler_params[0].get_exception
self.stats = None
### list of loaded and KO xml files
self.xml_date = None
self.xml = []
self.xml_ko = []
except :
self._log_stats.error("%s" % traceback.format_exc())
def get_packages_dir():
### Read the configuration file
try:
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
return os.path.join(conf['libraries_path'], PACKAGES_DIR)
except:
print(u"Error while reading the configuration file '{0}' : {1}".format(
CONFIG_FILE, traceback.format_exc()))
return None
def get_backup_dir():
### Read the configuration file
try:
cfg = Loader('backup')
config = cfg.load()
conf = dict(config[1])
return conf['folder']
except:
print(u"Error while reading the configuration file '{0}' : {1}".format(
CONFIG_FILE, traceback.format_exc()))
return None
def __init__(self, xpl, log):
cfg = Loader('mq')
config = cfg.load()
conf = dict(config[1])
if conf.has_key('query_mq'):
self.mq = True
else:
self.mq = False
if self.mq:
self.qry = QueryMQ(None, log)
else:
self.qry = QueryXPL(xpl, log)
def main():
cfg = Loader('mq')
my_conf = cfg.load()
config = dict(my_conf[1])
ctx = DaemonContext()
ctx.open()
context = zmq.Context()
print(("tcp://{0}:{1}".format(config['ip'], config['req_rep_port'])))
broker = MDPBroker(context, "tcp://{0}:{1}".format(config['ip'], config['req_rep_port']))
IOLoop.instance().start()
broker.shutdown()
def __init__(self, xpl, log):
cfg = Loader("mq")
config = cfg.load()
conf = dict(config[1])
if conf.has_key("query_mq"):
self.mq = True
else:
self.mq = False
if self.mq:
self.qry = QueryMQ(None, log)
else:
self.qry = QueryXPL(xpl, log)
def rest():
cfg = Loader('rest')
config = cfg.load()
conf = dict(config[1])
port = conf['port']
r = requests.get("http://localhost:{0}/map".format(port))
return render_template('rest.html',
mactive="rest",
urls = r.json(),
)
def get_stats_files_directory(self):
""" Return the directory where a plugin developper can store data files
"""
cfg = Loader('domogik')
my_conf = cfg.load()
config = dict(my_conf[1])
if config.has_key('package_path'):
path = "%s/domogik_packages/stats/%s" % (config['package_path'],
self._name)
else:
path = "%s/share/domogik/stats/%s" % (config['src_prefix'],
self._name)
return path
def get_rest_url():
""" Build and return the rest url
"""
cfg = Loader('rest')
config = cfg.load()
conf = dict(config[1])
### get REST ip and port
port = conf['port']
interfaces = conf['interfaces']
intf = interfaces.split(',')
# get the first ip of the first interface declared
ip = get_ip_for_interfaces(intf)[0]
return "http://{0}:{1}".format(ip, port)
def main():
cfg = Loader('mq')
my_conf = cfg.load()
config = dict(my_conf[1])
ctx = DaemonContext()
ctx.open()
context = zmq.Context()
print(("tcp://{0}:{1}".format(config['ip'], config['req_rep_port'])))
broker = MDPBroker(
context, "tcp://{0}:{1}".format(config['ip'], config['req_rep_port']))
IOLoop.instance().start()
broker.shutdown()
def get_rest_url():
""" Build and return the rest url
"""
cfg = Loader('rest')
config = cfg.load()
conf = dict(config[1])
### get REST ip and port
port = conf['port']
interfaces = conf['interfaces']
intf = interfaces.split(',')
# get the first ip of the first interface declared
ip = get_ip_for_interfaces(intf)[0]
return "http://{0}:{1}".format(ip, port)
def __init__(self, component_name, domogik_prefix=True, use_filename=None):
"""
Get a logger with provided parameters and set config
@param component_name : component name to log
@param domogik_prefix : if logger name should be prefixed by 'domogik-'
@param use_filename : if set tells the logger to use this file name (otherwise takes 'component_name')
"""
if component_name not in self.logger:
LEVELS = {
"debug": logging.DEBUG,
"info": logging.INFO,
"warning": logging.WARNING,
"error": logging.ERROR,
"critical": logging.CRITICAL,
}
cfg = Loader()
config = cfg.load()[0]
if use_filename is None:
filename = "%s/%s.log" % (config["log_dir_path"], component_name)
else:
filename = "%s/%s.log" % (config["log_dir_path"], use_filename)
level = config["log_level"]
if level not in LEVELS:
raise ValueError(
"level must be one of 'debug','info','warning'," "'error','critical'. Check your config."
)
if domogik_prefix:
my_logger = logging.getLogger("domogik-%s" % component_name)
else:
my_logger = logging.getLogger(component_name)
# log to file
my_logger.propagate = 0
if not my_logger.handlers:
hdlr = logging.FileHandler(filename)
formatter = logging.Formatter("%(asctime)s %(name)s %(levelname)s %(message)s")
hdlr.setFormatter(formatter)
my_logger.addHandler(hdlr)
# if loglevvel is set to debug (all log entries also go to stdout)
if level == "debug" and component_name.find("sqlalchemy") == -1:
dhdlr = logging.StreamHandler(sys.stdout)
dhdlr.setFormatter(formatter)
my_logger.addHandler(dhdlr)
my_logger.setLevel(LEVELS[level])
self.logger[component_name] = my_logger
def test_config_files():
# TODO : /etc/default
### /etc/domogik/domogik.cfg
from domogik.common.configloader import Loader, CONFIG_FILE
try:
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
ok("Configuration file '{0}' can be read".format(CONFIG_FILE))
return True
except:
error(u"Error while reading the configuration file '{0}' : {1}".format(CONFIG_FILE, traceback.format_exc()))
solution("Make sure the Domogik installation is OK")
return False
def test_config_files():
# TODO : /etc/default
### /etc/domogik/domogik.cfg
from domogik.common.configloader import Loader, CONFIG_FILE
try:
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
ok("Configuration file '{0}' can be read".format(CONFIG_FILE))
return True
except:
error(u"Error while reading the configuration file '{0}' : {1}".format(CONFIG_FILE, traceback.format_exc()))
solution("Make sure the Domogik installation is OK")
return False
def api_datatype():
"""
@api {get} /datatype Retrieve all datatypes
@apiName getDataTypes
@apiGroup DataType
@apiSuccess {json} result The json representation of the datatypes
@apiSuccessExample Success-Response:
HTTTP/1.1 200 OK
{
"DT_HVACVent": {
"childs": [],
"values": {
"0": "Auto",
"1": "Heat",
"2": "Cool",
"3": "Fan only",
"4": "Dry"
}
},
"DT_DateTime": {
"childs": [
"DT_Date",
"DT_Time"
],
"format": "YYYY-MM-DDThh:mm:ss.s"
},
"DT_String": {
"childs": [
"DT_Phone",
"DT_Hexa",
"DT_ColorRGBHexa"
],
"maxLengh": null,
"format": null
},
...
}
"""
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
json_file = "{0}/datatypes.json".format(urlHandler.resources_directory)
data = json.load(open(json_file))
return 200, data
def __init__(self, server_interfaces, server_port):
""" Initiate DbHelper, Logs and config
Then, start HTTP server and give it initialized data
@param server_interfaces : interfaces of HTTP server
@param server_port : port of HTTP server
"""
XplPlugin.__init__(self, name = 'admin')
# logging initialization
self.log.info(u"Admin Server initialisation...")
self.log.debug(u"locale : %s %s" % locale.getdefaultlocale())
try:
try:
cfg_rest = Loader('admin')
config_rest = cfg_rest.load()
conf_rest = dict(config_rest[1])
self.interfaces = conf_rest['interfaces']
self.port = conf_rest['port']
# if rest_use_ssl = True, set here path for ssl certificate/key
self.use_ssl = conf_rest['use_ssl']
self.key_file = conf_rest['ssl_certificate']
self.cert_file = conf_rest['ssl_key']
except KeyError:
# default parameters
self.interfaces = server_interfaces
self.port = server_port
self.use_ssl = False
self.key_file = ""
self.cert_file = ""
self.clean_json = False
self.log.info(u"Configuration : interfaces:port = %s:%s" % (self.interfaces, self.port))
# TODO : delete
#self.db = DbHelper()
# Launch server, stats
self.log.info(u"Admin Initialisation OK")
self.add_stop_cb(self.stop_http)
self.server = None
self.start_http()
# calls the tornado.ioloop.instance().start()
### Component is ready
self.ready(0)
IOLoop.instance().start()
except :
self.log.error(u"%s" % self.get_exception())
def __init__(self, listitems, expr):
'''
@param listitems a dictionnary discribing items used in the condition
@param expr : the condition
'''
XplPlugin.__init__(self, 'dbmgr')
self._log = self.get_my_logger()
self.listitems = listitems
loader = Loader('trigger')
config = loader.load()[1]
self.__expr = expr
#We should try/catch this bloc in case of undefined method
#Anyway, if they're not defined, needed value will never be updated,
#So we prefer raise an exception now
for k in listitems:
call = "self.build%slistener(listitems[k])" % k.lower()
eval(call)
def __init__(self, log=None, params=None):
AbstractAction.__init__(self, log)
self.set_description("Make the butler say something.")
### Butler configuration elements
try:
cfg = Loader('butler')
config = cfg.load()
conf = dict(config[1])
self.butler_name = conf['name']
self.butler_sex = conf['sex']
except:
self._log.error(u"ButlerACtion init : error while reading the configuration file '{0}' : {1}".format(CONFIG_FILE, traceback.format_exc()))
### MQ
self._mq_name = "butler"
self.zmq = zmq.Context()
self.pub = MQPub(self.zmq, self._mq_name)
def rest():
cfg = Loader('rest')
config = cfg.load()
conf = dict(config[1])
### get REST ip and port
port = conf['port']
interfaces = conf['interfaces']
intf = interfaces.split(',')
print intf
# get the first ip of the first interface declared
ip = get_ip_for_interfaces(intf)[0]
r = requests.get("http://{0}:{1}/map".format(ip, port))
return render_template('rest.html',
mactive="rest",
urls = r.json(),
)
def load_plugin_library(name, element):
'''
Function to call in the bin part of each plugin to load the appropriate library : from the sources in development mode and from packages folder in package mode
To do a : from foo import bar
Do : bar = load_plugin_library("foo", "bar")
'''
# Read config files to get mode
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
if conf.has_key('package_path'):
print("Load library from packages")
sys.path.append(conf["package_path"])
lib_path = "packages.xpl.lib." + name
else:
print("Load library from sources")
lib_path = "domogik.xpl.lib." + name
imp = __import__(lib_path, globals(), locals(), element)
ret = "imp." + element
return eval(ret)
def load_plugin_library(name, element):
'''
Function to call in the bin part of each plugin to load the appropriate library : from the sources in development mode and from packages folder in package mode
To do a : from foo import bar
Do : bar = load_plugin_library("foo", "bar")
'''
# Read config files to get mode
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
if conf.has_key('package_path'):
print("Load library from packages")
sys.path.append(conf["package_path"])
lib_path = "packages.xpl.lib." + name
else:
print("Load library from sources")
lib_path = "domogik.xpl.lib." + name
imp = __import__(lib_path, globals(), locals(), element)
ret = "imp." + element
return eval(ret)
def get_data_files_directory(self):
"""
Return the directory where a plugin developper can store data files.
If the directory doesn't exist, try to create it.
After that, try to create a file inside it.
If something goes wrong, generate an explicit exception.
"""
cfg = Loader('domogik')
my_conf = cfg.load()
config = dict(my_conf[1])
if config.has_key('package_path'):
path = "%s/domogik_packages/data/%s" % (config['package_path'],
self._name)
else:
path = "%s/share/domogik/data/%s" % (config['src_prefix'],
self._name)
if os.path.exists(path):
if not os.access(path, os.W_OK & os.X_OK):
raise OSError("Can't write in directory %s" % path)
else:
try:
os.mkdir(path, 0770)
self.log.info("Create directory %s." % path)
except:
raise OSError("Can't create directory %s." % path)
try:
tmp_prefix = "write_test"
count = 0
filename = os.path.join(path, tmp_prefix)
while (os.path.exists(filename)):
filename = "{}.{}".format(os.path.join(path, tmp_prefix),
count)
count = count + 1
f = open(filename, "w")
f.close()
os.remove(filename)
except:
raise IOError("Can't create a file in directory %s." % path)
return path
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, xpl, log):
'''
Init the query system and connect it to xPL network
@param xpl : the XplManager instance (usually self.myxpl)
@param log : a Logger instance (usually took from self.log))
'''
self.log = log
self.__myxpl = xpl
self.log.debug("Init config query instance")
self._keys = {}
self._l = {}
self._result = None
# Check in config file is target is forced
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
if conf.has_key('config_provider'):
self.target = "domogik-dbmgr.%s" % conf["config_provider"]
msg = "Force config provider to '%s'" % self.target
#print("Query config : %s" % msg)
self.log.debug(msg)
else:
self.target = "*"
if conf.has_key('query_xpl_timeout'):
try:
self.query_timeout = int(conf["query_xpl_timeout"])
msg = "Set query timeout to '%s' from domogik.cfg" % self.query_timeout
self.log.debug(msg)
except ValueError:
#There is an error in domogik.cfg. Set it to default.
self.query_timeout = 10
msg = "Error in domogik.cfg. query_xpl_timeout ('%s') is not an integer." % conf[
"query_xpl_timeout"]
self.log.error(msg)
else:
#There is not option in domogik.cfg. Set it to default.
self.query_timeout = 10
def __init__(self,
name=None,
url=None,
path=None,
pkg_type="plugin",
data=None):
""" Read json file of a plugin and make an object from it
@param name : name of package
@param url : url of file
@param path : path of file
@param pkg_type : package type (default : 'plugin')
To use only with name != None
@param data : json data as a python object. Used by package.py when installing a zip file : the json is read from memory
"""
json_file = None
try:
# load from sources repository
if name != None:
# get config
cfg = Loader('domogik')
config = cfg.load()
conf = dict(config[1])
if pkg_type == "plugin":
json_file = "{0}/{1}/{2}_{3}/info.json".format(
conf['libraries_path'], PACKAGES_DIR, pkg_type, name)
icon_file = "{0}/{1}/{2}_{3}/design/icon.png".format(
conf['libraries_path'], PACKAGES_DIR, pkg_type, name)
# TODO : reactivate later
#elif pkg_type == "external":
# if conf.has_key('package_path'):
# json_directory = "%s/domogik_packages/externals/" % (conf['package_path'])
# else:
# json_directory = "%s/%s" % (conf['src_prefix'], "share/domogik/externals/")
else:
raise PackageException("Type '%s' doesn't exists" %
pkg_type)
#json_file = "%s/%s.json" % (json_directory, name)
self.json = json.load(open(json_file))
elif path != None:
json_file = path
icon_file = None
self.json = json.load(open(json_file))
elif url != None:
json_file = url
icon_file = None
json_data = urllib2.urlopen(json_file)
# TODO : there is an error here!!!!!
self.json = json.load(xml_data)
elif data != None:
json_file = None
icon_file = None
self.json = data
self.validate()
### complete json
# identity data
self.json["identity"]["package_id"] = "%s-%s" % (
self.json["identity"]["type"], self.json["identity"]["name"])
self.json["identity"]["icon_file"] = icon_file
# common configuration items
auto_startup = {
"default": False,
"description":
"Automatically start the plugin at Domogik startup",
"key": "auto_startup",
"name": "Start the plugin with Domogik",
"required": True,
"type": "boolean"
}
# check that auto_startup key is not already defined in the json
for config_elt in self.json["configuration"]:
if config_elt["key"] == "auto_startup":
raise PackageException(
"Configuration parameter 'auto_startup' has not to be defined in the json file. Please remove it"
)
self.json["configuration"].insert(0, auto_startup)
except PackageException as exp:
raise PackageException(exp.value)
except:
raise PackageException("Error reading json file : %s : %s" %
(json_file, str(traceback.format_exc())))
def reload_config(self):
'''
Load configuration an start proxy server
'''
if self.server != None:
self.stop_http()
self.server = None
self.server_process = None
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:
self.log.error(
"Can't retrieve REST configuration from domogik.cfg. Leave plugin."
)
self.force_leave()
try:
self.proxy_ip = self._config.query('proxy', 'proxy-ip')
self.proxy_port = self._config.query('proxy', 'proxy-port')
except:
self.log.warning(
"Can't get proxy address configuration from XPL. Use default value."
)
finally:
if self.proxy_ip == None:
self.proxy_ip = self.server_ip
try:
self.proxy_port = int(self.proxy_port)
except:
self.proxy_port = str(int(self.server_port) + 1)
try:
self.auth_method = self._config.query('proxy', 'auth-method')
except:
self.log.warning(
"Can't get authentification method from XPL. Use basic by default."
)
finally:
if self.auth_method == None:
self.auth_method = "basic"
try:
self.username = self._config.query('proxy', 'username')
self.password = self._config.query('proxy', 'password')
except:
self.log.warning(
"Can't get username/password from XPL. Use defaults.")
finally:
if self.username == None or self.username == "None":
self.username = "******"
if self.password == None or self.password == "None":
self.password = "******"
try:
boo = self._config.query('proxy', 'use-ssl')
#print boo
self.use_ssl = True if boo == "True" else False
if self.use_ssl:
cfg_rest = Loader('rest')
config_rest = cfg_rest.load()
conf_rest = dict(config_rest[1])
self.ssl_certificate = conf_rest['rest_ssl_certificate']
except KeyError:
self.log.warning(
"Can't get ssl configuration from XPL. Do not use it.")
self.use_ssl = False
self.ssl_certificate = None
self.log.info("Proxy configuration : ip:port = %s:%s" %
(self.proxy_ip, self.proxy_port))
if self.use_ssl == True:
self.log.info(
"Proxy configuration : SSL support activated (certificate : %s)"
% self.ssl_certificate)
else:
self.log.info("Proxy configuration : SSL support not activated")
self.log.info("Proxy authentification : %s" % (self.auth_method))
self.log.info("Rest configuration : ip:port = %s:%s" %
(self.server_ip, self.server_port))
try:
self.start_http()
except:
self.log.error("Can't start proxy. Leave plugin.")
self.log.error("%s" %
str(traceback.format_exc()).replace('"', "'"))
self.force_leave()
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):
### Option parser
parser = ArgumentParser()
parser.add_argument("-i",
action="store_true",
dest="interactive",
default=False, \
help="Butler interactive mode (must be used WITH -f).")
Plugin.__init__(self, name='butler', parser=parser, log_prefix='core_')
### MQ
# MQ publisher
#self._mq_name = "interface-{0}.{1}".format(self._name, self.get_sanitized_hostname())
self._mq_name = "butler"
#self.zmq = zmq.Context()
self.pub = MQPub(self.zmq, self._mq_name)
# subscribe the MQ for interfaces inputs
self.add_mq_sub('interface.input')
# devices updates
self.add_mq_sub('device.update')
### Configuration elements
try:
cfg = Loader('butler')
config = cfg.load()
conf = dict(config[1])
self.lang = conf['lang']
self.butler_name = conf['name']
self.log.debug(u"The butler configured name is '{0}'".format(
self.butler_name))
self.butler_name_cleaned = clean_input(conf['name'])
self.log.debug(u"The butler cleaned name is '{0}'".format(
self.butler_name_cleaned))
self.butler_sex = conf['sex']
self.butler_mood = None
if self.butler_sex not in SEX_ALLOWED:
self.log.error(
u"Exiting : the butler sex configured is not valid : '{0}'. Expecting : {1}"
.format(self.butler_sex, SEX_ALLOWED))
self.force_leave()
return
except:
self.log.error(
u"Exiting : error while reading the configuration file '{0}' : {1}"
.format(CONFIG_FILE, traceback.format_exc()))
self.force_leave()
return
# user name (default is 'localuser')
# this is not used for now on Domogik side
self.user_name = "localuser"
### Prepare the brain
# - validate packages
# Start the brain :)
self.brain = RiveScript(utf8=True)
# set rivescript variables
# Configure bot variables
# all must be lower case....
self.log.info(u"Configuring name and sex : {0}, {1}".format(
self.butler_name_cleaned.lower(), self.butler_sex.lower()))
self.brain.set_variable(u"name", self.butler_name_cleaned.lower())
self.brain.set_variable(u"fullname", self.butler_name.lower())
self.brain.set_variable(u"sex", self.butler_sex.lower())
# set the PYTHONPATH
sys.path.append(self.get_libraries_directory())
# load the brain
self.brain_content = None
self.learn_content = None
self.not_understood_content = None
self.load_all_brain()
# shortcut to allow the core brain package to reload the brain for learning
self.brain.reload_butler = self.reload
# shortcut to allow the core brain package to do logging and access the devices in memory
self.brain.log = self.log
self.brain.devices = [] # will be loaded in self.reload_devices()
# history
self.history = []
# load all known devices
self.reload_devices()
self.log.info(
u"*** Welcome in {0} world, your digital assistant! ***".format(
self.butler_name))
# for chat more only
#self.log.info(u"You may type /quit to let {0} have a break".format(self.butler_name))
### Interactive mode
if self.options.interactive:
self.log.info(u"Launched in interactive mode : running the chat!")
# TODO : run as a thread
#self.run_chat()
thr_run_chat = Thread(None, self.run_chat, "run_chat", (), {})
thr_run_chat.start()
else:
self.log.info(u"Not launched in interactive mode")
### TODO
#self.add_stop_cb(self.shutdown)
self.log.info(u"Butler initialized")
self.ready()
