2014-05-26 05:07:39 -05:00
|
|
|
# Author: Alexander Bokovoy <abokovoy@redhat.com>
|
|
|
|
# Tomas Babej <tbabej@redhat.com>
|
2014-05-21 07:38:57 -05:00
|
|
|
#
|
|
|
|
# Copyright (C) 2014 Red Hat
|
|
|
|
# see file 'COPYING' for use and warranty information
|
|
|
|
#
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU General Public License as published by
|
|
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
|
|
# (at your option) any later version.
|
|
|
|
#
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
# GNU General Public License for more details.
|
|
|
|
#
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#
|
|
|
|
|
|
|
|
'''
|
|
|
|
This base module contains default implementations of IPA interface for
|
|
|
|
interacting with system services.
|
|
|
|
'''
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
import os
|
|
|
|
import json
|
2015-06-26 08:55:12 -05:00
|
|
|
import time
|
2015-06-22 06:28:09 -05:00
|
|
|
import collections
|
2014-05-26 05:07:39 -05:00
|
|
|
|
Use Python3-compatible dict method names
Python 2 has keys()/values()/items(), which return lists,
iterkeys()/itervalues()/iteritems(), which return iterators,
and viewkeys()/viewvalues()/viewitems() which return views.
Python 3 has only keys()/values()/items(), which return views.
To get iterators, one can use iter() or a for loop/comprehension;
for lists there's the list() constructor.
When iterating through the entire dict, without modifying the dict,
the difference between Python 2's items() and iteritems() is
negligible, especially on small dicts (the main overhead is
extra memory, not CPU time). In the interest of simpler code,
this patch changes many instances of iteritems() to items(),
iterkeys() to keys() etc.
In other cases, helpers like six.itervalues are used.
Reviewed-By: Christian Heimes <cheimes@redhat.com>
Reviewed-By: Jan Cholasta <jcholast@redhat.com>
2015-08-11 06:51:14 -05:00
|
|
|
import six
|
|
|
|
|
2014-05-26 05:07:39 -05:00
|
|
|
import ipalib
|
|
|
|
from ipapython import ipautil
|
|
|
|
from ipaplatform.paths import paths
|
|
|
|
|
|
|
|
# Canonical names of services as IPA wants to see them. As we need to have
|
|
|
|
# *some* naming, set them as in Red Hat distributions. Actual implementation
|
|
|
|
# should make them available through knownservices.<name> and take care of
|
|
|
|
# re-mapping internally, if needed
|
|
|
|
wellknownservices = ['certmonger', 'dirsrv', 'httpd', 'ipa', 'krb5kdc',
|
|
|
|
'messagebus', 'nslcd', 'nscd', 'ntpd', 'portmap',
|
|
|
|
'rpcbind', 'kadmin', 'sshd', 'autofs', 'rpcgssd',
|
2015-11-09 11:28:47 -06:00
|
|
|
'rpcidmapd', 'pki_tomcatd', 'chronyd', 'domainname',
|
|
|
|
'named', 'ods_enforcerd', 'ods_signerd']
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
# The common ports for these services. This is used to wait for the
|
|
|
|
# service to become available.
|
|
|
|
wellknownports = {
|
|
|
|
'dirsrv': [389], # only used if the incoming instance name is blank
|
|
|
|
'pki-tomcatd@pki-tomcat.service': [8080, 8443],
|
|
|
|
'pki-tomcat': [8080, 8443],
|
|
|
|
'pki-tomcatd': [8080, 8443], # used if the incoming instance name is blank
|
|
|
|
}
|
|
|
|
|
2015-06-26 08:55:12 -05:00
|
|
|
SERVICE_POLL_INTERVAL = 0.1 # seconds
|
|
|
|
|
2014-05-26 05:07:39 -05:00
|
|
|
|
2015-06-22 06:28:09 -05:00
|
|
|
class KnownServices(collections.Mapping):
|
2014-05-26 05:07:39 -05:00
|
|
|
"""
|
|
|
|
KnownServices is an abstract class factory that should give out instances
|
|
|
|
of well-known platform services. Actual implementation must create these
|
|
|
|
instances as its own attributes on first access (or instance creation)
|
|
|
|
and cache them.
|
|
|
|
"""
|
|
|
|
|
2015-06-22 06:28:09 -05:00
|
|
|
def __init__(self, d):
|
|
|
|
self.__d = d
|
|
|
|
|
|
|
|
def __getitem__(self, key):
|
|
|
|
return self.__d[key]
|
|
|
|
|
|
|
|
def __iter__(self):
|
|
|
|
return iter(self.__d)
|
|
|
|
|
|
|
|
def __len__(self):
|
|
|
|
return len(self.__d)
|
|
|
|
|
|
|
|
def __call__(self):
|
Use Python3-compatible dict method names
Python 2 has keys()/values()/items(), which return lists,
iterkeys()/itervalues()/iteritems(), which return iterators,
and viewkeys()/viewvalues()/viewitems() which return views.
Python 3 has only keys()/values()/items(), which return views.
To get iterators, one can use iter() or a for loop/comprehension;
for lists there's the list() constructor.
When iterating through the entire dict, without modifying the dict,
the difference between Python 2's items() and iteritems() is
negligible, especially on small dicts (the main overhead is
extra memory, not CPU time). In the interest of simpler code,
this patch changes many instances of iteritems() to items(),
iterkeys() to keys() etc.
In other cases, helpers like six.itervalues are used.
Reviewed-By: Christian Heimes <cheimes@redhat.com>
Reviewed-By: Jan Cholasta <jcholast@redhat.com>
2015-08-11 06:51:14 -05:00
|
|
|
return six.itervalues(self.__d)
|
2015-06-22 06:28:09 -05:00
|
|
|
|
|
|
|
def __getattr__(self, name):
|
|
|
|
try:
|
|
|
|
return self.__d[name]
|
|
|
|
except KeyError:
|
|
|
|
raise AttributeError(name)
|
|
|
|
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
class PlatformService(object):
|
|
|
|
"""
|
|
|
|
PlatformService abstracts out external process running on the system
|
|
|
|
which is possible to administer (start, stop, check status, etc).
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
def __init__(self, service_name, api=ipalib.api):
|
|
|
|
self.service_name = service_name
|
|
|
|
self.api = api
|
|
|
|
|
|
|
|
def start(self, instance_name="", capture_output=True, wait=True,
|
|
|
|
update_service_list=True):
|
|
|
|
"""
|
|
|
|
When a service is started record the fact in a special file.
|
|
|
|
This allows ipactl stop to always stop all services that have
|
|
|
|
been started via ipa tools
|
|
|
|
"""
|
|
|
|
if not update_service_list:
|
|
|
|
return
|
|
|
|
svc_list = []
|
|
|
|
try:
|
|
|
|
with open(paths.SVC_LIST_FILE, 'r') as f:
|
|
|
|
svc_list = json.load(f)
|
|
|
|
except Exception:
|
|
|
|
# not fatal, may be the first service
|
|
|
|
pass
|
|
|
|
|
|
|
|
if self.service_name not in svc_list:
|
|
|
|
svc_list.append(self.service_name)
|
|
|
|
|
|
|
|
with open(paths.SVC_LIST_FILE, 'w') as f:
|
|
|
|
json.dump(svc_list, f)
|
|
|
|
|
|
|
|
return
|
|
|
|
|
|
|
|
def stop(self, instance_name="", capture_output=True,
|
|
|
|
update_service_list=True):
|
|
|
|
"""
|
|
|
|
When a service is stopped remove it from the service list file.
|
|
|
|
"""
|
|
|
|
if not update_service_list:
|
|
|
|
return
|
|
|
|
svc_list = []
|
|
|
|
try:
|
|
|
|
with open(paths.SVC_LIST_FILE, 'r') as f:
|
|
|
|
svc_list = json.load(f)
|
|
|
|
except Exception:
|
|
|
|
# not fatal, may be the first service
|
|
|
|
pass
|
|
|
|
|
|
|
|
while self.service_name in svc_list:
|
|
|
|
svc_list.remove(self.service_name)
|
|
|
|
|
|
|
|
with open(paths.SVC_LIST_FILE, 'w') as f:
|
|
|
|
json.dump(svc_list, f)
|
|
|
|
|
|
|
|
return
|
|
|
|
|
|
|
|
def restart(self, instance_name="", capture_output=True, wait=True):
|
|
|
|
return
|
|
|
|
|
|
|
|
def is_running(self, instance_name=""):
|
|
|
|
return False
|
|
|
|
|
|
|
|
def is_installed(self):
|
|
|
|
return False
|
|
|
|
|
|
|
|
def is_enabled(self, instance_name=""):
|
|
|
|
return False
|
|
|
|
|
2014-09-01 03:49:28 -05:00
|
|
|
def is_masked(self, instance_name=""):
|
|
|
|
return False
|
|
|
|
|
2014-05-26 05:07:39 -05:00
|
|
|
def enable(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
|
|
|
def disable(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
2014-09-01 03:49:28 -05:00
|
|
|
def mask(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
|
|
|
def unmask(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
2014-05-26 05:07:39 -05:00
|
|
|
def install(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
|
|
|
def remove(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
|
|
|
def get_config_dir(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
2014-10-20 15:00:16 -05:00
|
|
|
def get_user_name(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
|
|
|
def get_group_name(self, instance_name=""):
|
|
|
|
return
|
|
|
|
|
|
|
|
def get_binary_path(self):
|
|
|
|
return
|
|
|
|
|
|
|
|
def get_package_name(self):
|
|
|
|
return
|
|
|
|
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
class SystemdService(PlatformService):
|
|
|
|
SYSTEMD_SRV_TARGET = "%s.target.wants"
|
|
|
|
|
|
|
|
def __init__(self, service_name, systemd_name, **kwargs):
|
|
|
|
super(SystemdService, self).__init__(service_name, **kwargs)
|
|
|
|
self.systemd_name = systemd_name
|
2014-06-09 06:45:48 -05:00
|
|
|
self.lib_path = os.path.join(paths.LIB_SYSTEMD_SYSTEMD_DIR, self.systemd_name)
|
2014-05-26 05:07:39 -05:00
|
|
|
self.lib_path_exists = None
|
|
|
|
|
|
|
|
def service_instance(self, instance_name, operation=None):
|
|
|
|
if self.lib_path_exists is None:
|
|
|
|
self.lib_path_exists = os.path.exists(self.lib_path)
|
|
|
|
|
|
|
|
elements = self.systemd_name.split("@")
|
|
|
|
|
|
|
|
# Make sure the correct DS instance is returned
|
2014-11-11 09:07:37 -06:00
|
|
|
if elements[0] == 'dirsrv' and not instance_name:
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
return ('dirsrv@%s.service'
|
|
|
|
% str(self.api.env.realm.replace('.', '-')))
|
|
|
|
|
|
|
|
# Short-cut: if there is already exact service name, return it
|
|
|
|
if self.lib_path_exists and instance_name:
|
|
|
|
if len(elements) == 1:
|
|
|
|
# service name is like pki-tomcatd.target or krb5kdc.service
|
|
|
|
return self.systemd_name
|
|
|
|
if len(elements) > 1 and elements[1][0] != '.':
|
|
|
|
# Service name is like pki-tomcatd@pki-tomcat.service
|
|
|
|
# and that file exists
|
|
|
|
return self.systemd_name
|
|
|
|
|
|
|
|
if len(elements) > 1:
|
|
|
|
# We have dynamic service
|
|
|
|
if instance_name:
|
|
|
|
# Instanciate dynamic service
|
|
|
|
return "%s@%s.service" % (elements[0], instance_name)
|
|
|
|
else:
|
|
|
|
# No instance name, try with target
|
|
|
|
tgt_name = "%s.target" % (elements[0])
|
2014-06-09 06:45:48 -05:00
|
|
|
srv_lib = os.path.join(paths.LIB_SYSTEMD_SYSTEMD_DIR, tgt_name)
|
2014-05-26 05:07:39 -05:00
|
|
|
if os.path.exists(srv_lib):
|
|
|
|
return tgt_name
|
|
|
|
|
|
|
|
return self.systemd_name
|
|
|
|
|
|
|
|
def parse_variables(self, text, separator=None):
|
|
|
|
"""
|
|
|
|
Parses 'systemctl show' output and returns a dict[variable]=value
|
|
|
|
Arguments: text -- 'systemctl show' output as string
|
|
|
|
separator -- optional (defaults to None), what separates
|
|
|
|
the key/value pairs in the text
|
|
|
|
"""
|
|
|
|
|
|
|
|
def splitter(x, separator=None):
|
|
|
|
if len(x) > 1:
|
|
|
|
y = x.split(separator)
|
|
|
|
return (y[0], y[-1])
|
|
|
|
return (None, None)
|
|
|
|
|
|
|
|
return dict(splitter(x, separator=separator) for x in text.split("\n"))
|
|
|
|
|
|
|
|
def wait_for_open_ports(self, instance_name=""):
|
|
|
|
"""
|
|
|
|
If this is a service we need to wait for do so.
|
|
|
|
"""
|
|
|
|
ports = None
|
|
|
|
if instance_name in wellknownports:
|
|
|
|
ports = wellknownports[instance_name]
|
|
|
|
else:
|
|
|
|
elements = self.systemd_name.split("@")
|
|
|
|
if elements[0] in wellknownports:
|
|
|
|
ports = wellknownports[elements[0]]
|
|
|
|
if ports:
|
|
|
|
ipautil.wait_for_open_ports('localhost', ports,
|
|
|
|
self.api.env.startup_timeout)
|
|
|
|
|
|
|
|
def stop(self, instance_name="", capture_output=True):
|
|
|
|
instance = self.service_instance(instance_name)
|
2014-06-09 06:45:48 -05:00
|
|
|
args = [paths.SYSTEMCTL, "stop", instance]
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
# The --ignore-dependencies switch is used to avoid possible
|
|
|
|
# deadlock during the shutdown transaction. For more details, see
|
|
|
|
# https://fedorahosted.org/freeipa/ticket/3729#comment:1 and
|
|
|
|
# https://bugzilla.redhat.com/show_bug.cgi?id=973331#c11
|
|
|
|
if instance == "ipa-otpd.socket":
|
|
|
|
args.append("--ignore-dependencies")
|
|
|
|
|
2015-11-25 10:17:18 -06:00
|
|
|
ipautil.run(args, skip_output=not capture_output)
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
if getattr(self.api.env, 'context', None) in ['ipactl', 'installer']:
|
|
|
|
update_service_list = True
|
|
|
|
else:
|
|
|
|
update_service_list = False
|
|
|
|
super(SystemdService, self).stop(
|
|
|
|
instance_name,
|
|
|
|
update_service_list=update_service_list)
|
|
|
|
|
|
|
|
def start(self, instance_name="", capture_output=True, wait=True):
|
2014-06-09 06:45:48 -05:00
|
|
|
ipautil.run([paths.SYSTEMCTL, "start",
|
2014-05-26 05:07:39 -05:00
|
|
|
self.service_instance(instance_name)],
|
2015-11-25 10:17:18 -06:00
|
|
|
skip_output=not capture_output)
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
if getattr(self.api.env, 'context', None) in ['ipactl', 'installer']:
|
|
|
|
update_service_list = True
|
|
|
|
else:
|
|
|
|
update_service_list = False
|
|
|
|
|
|
|
|
if wait and self.is_running(instance_name):
|
|
|
|
self.wait_for_open_ports(self.service_instance(instance_name))
|
|
|
|
super(SystemdService, self).start(
|
|
|
|
instance_name,
|
|
|
|
update_service_list=update_service_list)
|
|
|
|
|
|
|
|
def restart(self, instance_name="", capture_output=True, wait=True):
|
2014-06-09 06:45:48 -05:00
|
|
|
ipautil.run([paths.SYSTEMCTL, "restart",
|
2014-05-26 05:07:39 -05:00
|
|
|
self.service_instance(instance_name)],
|
2015-11-25 10:17:18 -06:00
|
|
|
skip_output=not capture_output)
|
2014-05-26 05:07:39 -05:00
|
|
|
|
|
|
|
if wait and self.is_running(instance_name):
|
|
|
|
self.wait_for_open_ports(self.service_instance(instance_name))
|
|
|
|
|
|
|
|
def is_running(self, instance_name=""):
|
|
|
|
instance = self.service_instance(instance_name, 'is-active')
|
|
|
|
|
|
|
|
while True:
|
|
|
|
try:
|
2015-11-25 10:17:18 -06:00
|
|
|
result = ipautil.run(
|
2014-06-09 06:45:48 -05:00
|
|
|
[paths.SYSTEMCTL, "is-active", instance],
|
2014-05-26 05:07:39 -05:00
|
|
|
capture_output=True
|
|
|
|
)
|
|
|
|
except ipautil.CalledProcessError as e:
|
|
|
|
if e.returncode == 3 and 'activating' in str(e.output):
|
2015-06-26 08:55:12 -05:00
|
|
|
time.sleep(SERVICE_POLL_INTERVAL)
|
2014-05-26 05:07:39 -05:00
|
|
|
continue
|
|
|
|
return False
|
|
|
|
else:
|
|
|
|
# activating
|
2015-11-25 10:17:18 -06:00
|
|
|
if result.returncode == 3 and 'activating' in result.output:
|
2015-06-26 08:55:12 -05:00
|
|
|
time.sleep(SERVICE_POLL_INTERVAL)
|
2014-05-26 05:07:39 -05:00
|
|
|
continue
|
|
|
|
# active
|
2015-11-25 10:17:18 -06:00
|
|
|
if result.returncode == 0:
|
2014-05-26 05:07:39 -05:00
|
|
|
return True
|
|
|
|
# not active
|
|
|
|
return False
|
|
|
|
|
|
|
|
def is_installed(self):
|
|
|
|
try:
|
2015-11-25 10:17:18 -06:00
|
|
|
result = ipautil.run(
|
|
|
|
[paths.SYSTEMCTL, "list-unit-files", "--full"],
|
|
|
|
capture_output=True)
|
|
|
|
if result.returncode != 0:
|
2014-05-26 05:07:39 -05:00
|
|
|
return False
|
|
|
|
else:
|
2015-11-25 10:17:18 -06:00
|
|
|
svar = self.parse_variables(result.output)
|
2014-05-26 05:07:39 -05:00
|
|
|
if not self.service_instance("") in svar:
|
|
|
|
# systemd doesn't show the service
|
|
|
|
return False
|
|
|
|
except ipautil.CalledProcessError:
|
|
|
|
return False
|
|
|
|
|
|
|
|
return True
|
|
|
|
|
|
|
|
def is_enabled(self, instance_name=""):
|
|
|
|
enabled = True
|
|
|
|
try:
|
2015-11-25 10:17:18 -06:00
|
|
|
result = ipautil.run(
|
|
|
|
[paths.SYSTEMCTL, "is-enabled",
|
|
|
|
self.service_instance(instance_name)])
|
2014-05-26 05:07:39 -05:00
|
|
|
|
2015-11-25 10:17:18 -06:00
|
|
|
if result.returncode != 0:
|
2014-05-26 05:07:39 -05:00
|
|
|
enabled = False
|
|
|
|
|
|
|
|
except ipautil.CalledProcessError:
|
|
|
|
enabled = False
|
|
|
|
return enabled
|
|
|
|
|
2014-09-01 03:49:28 -05:00
|
|
|
def is_masked(self, instance_name=""):
|
|
|
|
masked = False
|
|
|
|
try:
|
2015-11-25 10:17:18 -06:00
|
|
|
result = ipautil.run(
|
|
|
|
[paths.SYSTEMCTL, "is-enabled",
|
|
|
|
self.service_instance(instance_name)],
|
|
|
|
capture_output=True)
|
2014-09-01 03:49:28 -05:00
|
|
|
|
2015-11-25 10:17:18 -06:00
|
|
|
if result.returncode == 1 and result.output == 'masked':
|
2014-09-01 03:49:28 -05:00
|
|
|
masked = True
|
|
|
|
|
|
|
|
except ipautil.CalledProcessError:
|
|
|
|
pass
|
|
|
|
return masked
|
|
|
|
|
2014-05-26 05:07:39 -05:00
|
|
|
def enable(self, instance_name=""):
|
|
|
|
if self.lib_path_exists is None:
|
|
|
|
self.lib_path_exists = os.path.exists(self.lib_path)
|
|
|
|
elements = self.systemd_name.split("@")
|
|
|
|
l = len(elements)
|
|
|
|
|
|
|
|
if self.lib_path_exists and (l > 1 and elements[1][0] != '.'):
|
|
|
|
# There is explicit service unit supporting this instance,
|
|
|
|
# follow normal systemd enabler
|
|
|
|
self.__enable(instance_name)
|
|
|
|
return
|
|
|
|
|
|
|
|
if self.lib_path_exists and (l == 1):
|
|
|
|
# There is explicit service unit which does not support
|
|
|
|
# the instances, ignore instance
|
|
|
|
self.__enable()
|
|
|
|
return
|
|
|
|
|
|
|
|
if len(instance_name) > 0 and l > 1:
|
|
|
|
# New instance, we need to do following:
|
|
|
|
# 1. Make /etc/systemd/system/<service>.target.wants/
|
|
|
|
# if it is not there
|
|
|
|
# 2. Link /etc/systemd/system/<service>.target.wants/
|
|
|
|
# <service>@<instance_name>.service to
|
|
|
|
# /lib/systemd/system/<service>@.service
|
|
|
|
|
2014-06-09 06:45:48 -05:00
|
|
|
srv_tgt = os.path.join(paths.ETC_SYSTEMD_SYSTEM_DIR,
|
2014-05-26 05:07:39 -05:00
|
|
|
self.SYSTEMD_SRV_TARGET % (elements[0]))
|
|
|
|
srv_lnk = os.path.join(srv_tgt,
|
|
|
|
self.service_instance(instance_name))
|
|
|
|
|
|
|
|
try:
|
|
|
|
if not ipautil.dir_exists(srv_tgt):
|
|
|
|
os.mkdir(srv_tgt)
|
2015-12-22 09:34:32 -06:00
|
|
|
os.chmod(srv_tgt, 0o755)
|
2014-05-26 05:07:39 -05:00
|
|
|
if os.path.exists(srv_lnk):
|
|
|
|
# Remove old link
|
|
|
|
os.unlink(srv_lnk)
|
|
|
|
if not os.path.exists(srv_lnk):
|
|
|
|
# object does not exist _or_ is a broken link
|
|
|
|
if not os.path.islink(srv_lnk):
|
|
|
|
# if it truly does not exist, make a link
|
|
|
|
os.symlink(self.lib_path, srv_lnk)
|
|
|
|
else:
|
|
|
|
# Link exists and it is broken, make new one
|
|
|
|
os.unlink(srv_lnk)
|
|
|
|
os.symlink(self.lib_path, srv_lnk)
|
2014-06-09 06:45:48 -05:00
|
|
|
ipautil.run([paths.SYSTEMCTL, "--system", "daemon-reload"])
|
2014-05-26 05:07:39 -05:00
|
|
|
except:
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
self.__enable(instance_name)
|
|
|
|
|
|
|
|
def disable(self, instance_name=""):
|
|
|
|
elements = self.systemd_name.split("@")
|
|
|
|
if instance_name != "" and len(elements) > 1:
|
|
|
|
# Remove instance, we need to do following:
|
|
|
|
# Remove link from /etc/systemd/system/<service>.target.wants/
|
|
|
|
# <service>@<instance_name>.service
|
|
|
|
# to /lib/systemd/system/<service>@.service
|
|
|
|
|
2014-06-09 06:45:48 -05:00
|
|
|
srv_tgt = os.path.join(paths.ETC_SYSTEMD_SYSTEM_DIR,
|
2014-05-26 05:07:39 -05:00
|
|
|
self.SYSTEMD_SRV_TARGET % (elements[0]))
|
|
|
|
srv_lnk = os.path.join(srv_tgt,
|
|
|
|
self.service_instance(instance_name))
|
|
|
|
|
|
|
|
try:
|
|
|
|
if ipautil.dir_exists(srv_tgt):
|
|
|
|
if os.path.islink(srv_lnk):
|
|
|
|
os.unlink(srv_lnk)
|
2014-06-09 06:45:48 -05:00
|
|
|
ipautil.run([paths.SYSTEMCTL, "--system", "daemon-reload"])
|
2014-05-26 05:07:39 -05:00
|
|
|
except:
|
|
|
|
pass
|
|
|
|
else:
|
2014-11-06 16:57:26 -06:00
|
|
|
try:
|
|
|
|
ipautil.run([paths.SYSTEMCTL, "disable",
|
|
|
|
self.service_instance(instance_name)])
|
|
|
|
except ipautil.CalledProcessError:
|
|
|
|
pass
|
2014-05-26 05:07:39 -05:00
|
|
|
|
2014-09-01 03:49:28 -05:00
|
|
|
def mask(self, instance_name=""):
|
2014-11-06 17:08:58 -06:00
|
|
|
srv_tgt = os.path.join(paths.ETC_SYSTEMD_SYSTEM_DIR, self.service_instance(instance_name))
|
|
|
|
if os.path.exists(srv_tgt):
|
|
|
|
os.unlink(srv_tgt)
|
2014-05-26 05:07:39 -05:00
|
|
|
try:
|
2014-11-06 16:57:26 -06:00
|
|
|
ipautil.run([paths.SYSTEMCTL, "mask",
|
2014-05-26 05:07:39 -05:00
|
|
|
self.service_instance(instance_name)])
|
|
|
|
except ipautil.CalledProcessError:
|
|
|
|
pass
|
|
|
|
|
2014-11-06 16:57:26 -06:00
|
|
|
def unmask(self, instance_name=""):
|
2014-09-01 03:49:28 -05:00
|
|
|
try:
|
2014-11-06 16:57:26 -06:00
|
|
|
ipautil.run([paths.SYSTEMCTL, "unmask",
|
2014-09-01 03:49:28 -05:00
|
|
|
self.service_instance(instance_name)])
|
|
|
|
except ipautil.CalledProcessError:
|
|
|
|
pass
|
|
|
|
|
2014-11-06 16:57:26 -06:00
|
|
|
def __enable(self, instance_name=""):
|
2014-09-01 03:49:28 -05:00
|
|
|
try:
|
2014-11-06 16:57:26 -06:00
|
|
|
ipautil.run([paths.SYSTEMCTL, "enable",
|
2014-09-01 03:49:28 -05:00
|
|
|
self.service_instance(instance_name)])
|
|
|
|
except ipautil.CalledProcessError:
|
|
|
|
pass
|
|
|
|
|
2014-05-26 05:07:39 -05:00
|
|
|
def install(self):
|
|
|
|
self.enable()
|
|
|
|
|
|
|
|
def remove(self):
|
|
|
|
self.disable()
|
|
|
|
|
|
|
|
|
|
|
|
# Objects below are expected to be exported by platform module
|
|
|
|
|
|
|
|
service = None
|
|
|
|
knownservices = None
|
|
|
|
|
|
|
|
# System may support more time&date services. FreeIPA supports ntpd only, other
|
|
|
|
# services will be disabled during IPA installation
|
|
|
|
timedate_services = ['ntpd', 'chronyd']
|