def main():
### 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 tool must be run with the user defined in /etc/default/domogik as DOMOGIK_USER : {0}".format(dmg_user))
sys.exit(1)
pkg = PackageInstaller()
def main():
### 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 tool must be run with the user defined in /etc/default/domogik as DOMOGIK_USER : {0}"
.format(dmg_user))
sys.exit(1)
pkg = PackageInstaller()
def __init__(self, name, stop_cb = None, p = None, daemonize = True, log_prefix= ""):
'''
@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()
'''
### 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))
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
res, pid_list = is_already_launched(self.log, 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,
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, 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
