def PropertiesChanged(self, interface_name, changed_properties,
invalidated_properties):
interface_name = dbus_to_python(interface_name)
changed_properties = dbus_to_python(changed_properties)
invalidated_properties = dbus_to_python(invalidated_properties)
log.debug1("PropertiesChanged('%s', '%s', '%s')",
interface_name, changed_properties, invalidated_properties)
def Set(self, interface_name, property_name, new_value, sender=None):
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
new_value = dbus_to_python(new_value)
log.debug1("%s.Set('%s', '%s', '%s')", self._log_prefix,
interface_name, property_name, new_value)
if interface_name != DBUS_INTERFACE_ROLE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
if property_name in self._exported_rw_properties:
if not hasattr(self, "__check_%s", property_name):
raise RolekitError(MISSING_CHECK, property_name)
x = getattr(self, "__check_%s", property_name)
x(new_value)
self._settings.set(property_name, new_value)
self._settings.write()
self.PropertiesChanged(interface_name, {property_name: new_value},
[])
elif property_name in self._exported_ro_properties:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.PropertyReadOnly: "
"Property '%s' is read-only" % property_name)
else:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.AccessDenied: "
"Property '%s' does not exist" % property_name)
def Set(self, interface_name, property_name, new_value, sender=None):
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
new_value = dbus_to_python(new_value)
log.debug1("%s.Set('%s', '%s', '%s')", self._log_prefix,
interface_name, property_name, new_value)
if interface_name != DBUS_INTERFACE_ROLE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
if property_name in self._exported_rw_properties:
if not hasattr(self, "__check_%s", property_name):
raise RolekitError(MISSING_CHECK, property_name)
x = getattr(self, "__check_%s", property_name)
x(new_value)
self._settings.set(property_name, new_value)
self._settings.write()
self.PropertiesChanged(interface_name,
{ property_name: new_value }, [ ])
elif property_name in self._exported_ro_properties:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.PropertyReadOnly: "
"Property '%s' is read-only" % property_name)
else:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.AccessDenied: "
"Property '%s' does not exist" % property_name)
def PropertiesChanged(self, interface_name, changed_properties,
invalidated_properties):
interface_name = dbus_to_python(interface_name)
changed_properties = dbus_to_python(changed_properties)
invalidated_properties = dbus_to_python(invalidated_properties)
log.debug1("%s.PropertiesChanged('%s', '%s', '%s')", self._log_prefix,
interface_name, changed_properties, invalidated_properties)
def Get(self, interface_name, property_name, sender=None):
# get a property
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
log.debug1("Get('%s', '%s')", interface_name, property_name)
if interface_name != DBUS_INTERFACE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"roled does not implement %s" % interface_name)
return self._get_property(property_name)
def Get(self, interface_name, property_name, sender=None):
# get a property
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
log.debug1("Get('%s', '%s')", interface_name, property_name)
if interface_name != DBUS_INTERFACE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: " "roled does not implement %s" % interface_name
)
return self._get_property(property_name)
def Get(self, interface_name, property_name, sender=None):
# get a property
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
log.debug1("%s.Get('%s', '%s')", self._log_prefix, interface_name,
property_name)
if interface_name != DBUS_INTERFACE_ROLE_INSTANCE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
return self.get_dbus_property(self, property_name)
def Get(self, interface_name, property_name, sender=None):
# get a property
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
log.debug1("%s.Get('%s', '%s')", self._log_prefix, interface_name,
property_name)
if interface_name != DBUS_INTERFACE_ROLE_INSTANCE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
return self.get_dbus_property(self, property_name)
def __deploy_async(self, name, values):
values = dbus_to_python(values)
name = dbus_to_python(name)
log.debug1("%s.deploy('%s', %s)", self._log_prefix, name, values)
# limit role instances to max instances per role
if len(self._instances) >= self._role._MAX_INSTANCES:
raise RolekitError(TOO_MANY_INSTANCES, "> %d" % \
self._role._MAX_INSTANCES)
# TODO: lock
# Create the settings object. If no name has been passed in,
# this function will create one from the next available value.
# Note: this isn't protected by a lock, so name-generation
# might be racy.
settings = RoleSettings(self.get_name(), name)
# create escaped name and check if it is already in use
instance_escaped_name = dbus_label_escape(settings.get_name())
if instance_escaped_name in self._instances:
raise RolekitError(NAME_CONFLICT, instance_escaped_name)
try:
settings.read()
except ValueError:
raise RolekitError(NAME_CONFLICT, settings.filename)
except IOError:
pass
else:
raise RolekitError(NAME_CONFLICT, settings.filename)
# create role
role = self._role(
self,
settings.get_name(),
self.get_name(),
self._directory,
settings,
self.busname,
"%s/%s/%s" %
(DBUS_PATH_ROLES, self._escaped_name, instance_escaped_name),
persistent=self.persistent)
self._instances[instance_escaped_name] = role
self.InstanceAdded(instance_escaped_name)
# TODO: unlock
# deploy role, lock in role now
result = yield async .call_future(role.deploy_async(values))
yield result
def Set(self, interface_name, property_name, new_value, sender=None):
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
new_value = dbus_to_python(new_value)
log.debug1("Set('%s', '%s', '%s')", interface_name, property_name, new_value)
self.accessCheck(sender)
if interface_name != DBUS_INTERFACE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: " "roled does not implement %s" % interface_name
)
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.AccessDenied: " "Property '%s' is not settable" % property_name
)
def apply_values(self, values):
# Copy key value pairs for the properties that are read-write to
# self._settings and write the settings out.
values = dbus_to_python(values)
changed = []
for x in values:
if x in self._DEFAULTS:
if x in self._READONLY_SETTINGS:
raise RolekitError(READONLY_SETTING, x)
# use _check_property method from derived or parent class
self._check_property(x, values[x])
# set validated setting
self._settings[x] = values[x]
changed.append(x)
else:
raise RolekitError(UNKNOWN_SETTING, x)
if len(changed) > 0:
dbus_changed = dbus.Dictionary(signature="sv")
for x in changed:
dbus_changed[x] = self.get_dbus_property(self, x)
self.PropertiesChanged(DBUS_INTERFACE_ROLE_INSTANCE, dbus_changed,
[])
# write validated setting
self._settings.write()
def _signal_receiver(self, *args, **kwargs):
_args = []
for arg in args:
_args.append(dbus_to_python(arg))
args = _args
if not "member" in kwargs:
return
signal = kwargs["member"]
interface = kwargs["interface"]
if interface != DBUS_INTERFACE or signal != "NotifyUnitFailed" or len(args) != 2:
return
log.debug1("NotifyUnitFailed('%s', '%s')", args[0], args[1])
for obj in self._roles:
if obj.get_name() != args[0]:
continue
instances = obj.get_instances()
for instance_name in instances:
if instance_name != args[1]:
continue
instance = instances[instance_name]
if instance._settings["state"] == RUNNING:
state = target_unit_state(instance.target_unit)
if state != "active":
instance.change_state(ERROR, write=True)
def apply_values(self, values):
# Copy key value pairs for the properties that are read-write to
# self._settings and write the settings out.
values = dbus_to_python(values)
changed = [ ]
for x in values:
if x in self._DEFAULTS:
if x in self._READONLY_SETTINGS:
raise RolekitError(READONLY_SETTING, x)
# use _check_property method from derived or parent class
self._check_property(x, values[x])
# set validated setting
self._settings[x] = values[x]
changed.append(x)
else:
raise RolekitError(UNKNOWN_SETTING, x)
if len(changed) > 0:
dbus_changed = dbus.Dictionary(signature="sv")
for x in changed:
dbus_changed[x] = self.get_dbus_property(self, x)
self.PropertiesChanged(DBUS_INTERFACE_ROLE_INSTANCE,
dbus_changed, [ ])
# write validated setting
self._settings.write()
def _signal_receiver(self, *args, **kwargs):
_args = []
for arg in args:
_args.append(dbus_to_python(arg))
args = _args
if not "member" in kwargs:
return
signal = kwargs["member"]
interface = kwargs["interface"]
cb = None
cb_args = []
# config signals need special treatment
# pimp signal name
if interface.startswith(DBUS_INTERFACE_ROLE):
signal = "config:Role" + signal
for callback in self._callbacks:
if self._callbacks[callback] == signal and self._callbacks[callback] in self._callback:
cb = self._callback[self._callbacks[callback]]
if not cb:
return
cb_args.extend(args)
# call back ...
try:
if cb[1]:
# add call data
cb_args.extend(cb[1])
# call back
cb[0](*cb_args)
except Exception as msg:
print(msg)
def _signal_receiver(self, *args, **kwargs):
_args = []
for arg in args:
_args.append(dbus_to_python(arg))
args = _args
if not "member" in kwargs:
return
signal = kwargs["member"]
interface = kwargs["interface"]
if interface != DBUS_INTERFACE or signal != "NotifyUnitFailed" or \
len(args) != 2:
return
log.debug1("NotifyUnitFailed('%s', '%s')", args[0], args[1])
for obj in self._roles:
if obj.get_name() != args[0]:
continue
instances = obj.get_instances()
for instance_name in instances:
if instance_name != args[1]:
continue
instance = instances[instance_name]
if instance._settings["state"] == RUNNING:
state = target_unit_state(instance.target_unit)
if state != "active":
instance.change_state(ERROR, write=True)
def Set(self, interface_name, property_name, new_value, sender=None):
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
new_value = dbus_to_python(new_value)
log.debug1("Set('%s', '%s', '%s')", interface_name, property_name,
new_value)
self.accessCheck(sender)
if interface_name != DBUS_INTERFACE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"roled does not implement %s" % interface_name)
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.AccessDenied: "
"Property '%s' is not settable" % property_name)
def getNamedInstance(self, name, sender=None):
""" return the role with the name, otherwise raise error """
name = dbus_to_python(name)
log.debug1("%s.getNamedInstance('%s')", self._log_prefix, name)
instance_escaped_name = dbus_label_escape(name)
if instance_escaped_name in self._instances:
return self._instances[instance_escaped_name]
raise RolekitError(INVALID_INSTANCE, name)
def getNamedInstance(self, name, sender=None):
""" return the role with the name, otherwise raise error """
name = dbus_to_python(name)
log.debug1("%s.getNamedInstance('%s')", self._log_prefix, name)
instance_escaped_name = dbus_label_escape(name)
if instance_escaped_name in self._instances:
return self._instances[instance_escaped_name]
raise RolekitError(INVALID_INSTANCE, name)
def __deploy_async(self, name, values):
values = dbus_to_python(values)
name = dbus_to_python(name)
log.debug1("%s.deploy('%s', %s)", self._log_prefix, name, values)
# limit role instances to max instances per role
if len(self._instances) >= self._role._MAX_INSTANCES:
raise RolekitError(TOO_MANY_INSTANCES, "> %d" % \
self._role._MAX_INSTANCES)
# TODO: lock
# Create the settings object. If no name has been passed in,
# this function will create one from the next available value.
# Note: this isn't protected by a lock, so name-generation
# might be racy.
settings = RoleSettings(self.get_name(), name)
# create escaped name and check if it is already in use
instance_escaped_name = dbus_label_escape(settings.get_name())
if instance_escaped_name in self._instances:
raise RolekitError(NAME_CONFLICT, instance_escaped_name)
try:
settings.read()
except ValueError:
raise RolekitError(NAME_CONFLICT, settings.filename)
except IOError:
pass
else:
raise RolekitError(NAME_CONFLICT, settings.filename)
# create role
role = self._role(self, settings.get_name(), self.get_name(),
self._directory, settings, self.busname,
"%s/%s/%s" % (DBUS_PATH_ROLES, self._escaped_name,
instance_escaped_name),
persistent=self.persistent)
self._instances[instance_escaped_name] = role
self.InstanceAdded(instance_escaped_name)
# TODO: unlock
# deploy role, lock in role now
result = yield async.call_future(role.deploy_async(values))
yield result
def getNamedRole(self, name, sender=None):
""" return the role with the name, otherwise raise error """
name = dbus_to_python(name)
log.debug1("getNamedRole('%s')", name)
for obj in self._roles:
if obj.get_name() == name:
return obj
raise RolekitError(INVALID_ROLE, name)
def getNamedRole(self, name, sender=None):
""" return the role with the name, otherwise raise error """
name = dbus_to_python(name)
log.debug1("getNamedRole('%s')", name)
for obj in self._roles:
if obj.get_name() == name:
return obj
raise RolekitError(INVALID_ROLE, name)
def __redeploy_async(self, values, sender):
values = dbus_to_python(values)
# Make sure we are in the proper state
self.assert_state(READY_TO_START, ERROR)
# Log
log.debug1("%s.redeploy(%s)", self._log_prefix, values)
# Check values
try:
self.check_values(values)
except Exception as e:
# checking of values failed, set state to error
self.change_state(ERROR, error=str(e), write=True)
raise
try:
# Change to redeploying state
self.change_state(REDEPLOYING)
# Uninstall firewall
self.uninstallFirewall()
# Copy _DEFAULTS to self._settings
self.copy_defaults()
# Install package groups and packages
log.debug9("TRACE: Installing packages")
yield async .call_future(self.installPackages())
# Install firewall
self.installFirewall()
# Call do_redeploy_async
log.debug9("TRACE: Performing role-specific redeployment")
yield async .call_future(self.do_redeploy_async(values, sender))
# Continue only after successful deployment:
# Apply values to self._settings
log.debug9(
"TRACE: role-specific redeployment complete, applying values")
self.apply_values(values)
# Change to ready to start state
self.change_state(READY_TO_START, write=True)
# Attempt to start the newly-deployed role
# We do this because many role-installers will conclude by
# starting anyway and we want to ensure that our role mechanism
# is in sync with them.
log.debug9("TRACE: Starting %s" % self.get_name())
yield async .call_future(self.__start_async(sender))
except Exception as e:
# Something failed, set state to error
self.change_state(ERROR, error=str(e), write=True)
raise
def __redeploy_async(self, values, sender):
values = dbus_to_python(values)
# Make sure we are in the proper state
self.assert_state(READY_TO_START, ERROR)
# Log
log.debug1("%s.redeploy(%s)", self._log_prefix, values)
# Check values
try:
self.check_values(values)
except Exception as e:
# checking of values failed, set state to error
self.change_state(ERROR, error=str(e), write=True)
raise
try:
# Change to redeploying state
self.change_state(REDEPLOYING)
# Uninstall firewall
self.uninstallFirewall()
# Copy _DEFAULTS to self._settings
self.copy_defaults()
# Install package groups and packages
log.debug9("TRACE: Installing packages")
yield async.call_future(self.installPackages())
# Install firewall
self.installFirewall()
# Call do_redeploy_async
log.debug9("TRACE: Performing role-specific redeployment")
yield async.call_future(self.do_redeploy_async(values, sender))
# Continue only after successful deployment:
# Apply values to self._settings
log.debug9("TRACE: role-specific redeployment complete, applying values")
self.apply_values(values)
# Change to ready to start state
self.change_state(READY_TO_START, write=True)
# Attempt to start the newly-deployed role
# We do this because many role-installers will conclude by
# starting anyway and we want to ensure that our role mechanism
# is in sync with them.
log.debug9("TRACE: Starting %s" % self.get_name())
yield async.call_future(self.__start_async(sender))
except Exception as e:
# Something failed, set state to error
self.change_state(ERROR, error=str(e), write=True)
raise
def GetAll(self, interface_name, sender=None):
interface_name = dbus_to_python(interface_name)
log.debug1("GetAll('%s')", interface_name)
if interface_name != DBUS_INTERFACE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: " "roled does not implement %s" % interface_name
)
return {"version": self._get_property("version"), "roles": self._get_property("roles")}
def getAllRoleInstancesByState(self, state, sender=None):
""" return the list of all roles instances that are in a particular state """
state = dbus_to_python(state)
log.debug1("getAllRoleInstancesByState('%s')", state)
ret_list = []
for obj in self._roles:
for instance in obj.get_instances().values():
if instance.get_state() == state:
ret_list.append(instance)
return ret_list
def getAllRoleInstancesByState(self, state, sender=None):
""" return the list of all roles instances that are in a particular state """
state = dbus_to_python(state)
log.debug1("getAllRoleInstancesByState('%s')", state)
ret_list = []
for obj in self._roles:
for instance in obj.get_instances().values():
if instance.get_state() == state:
ret_list.append(instance)
return ret_list
def Set(self, interface_name, property_name, new_value, sender=None):
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
new_value = dbus_to_python(new_value)
log.debug1("%s.Set('%s', '%s', '%s')", self._log_prefix,
interface_name, property_name, new_value)
if interface_name != DBUS_INTERFACE_ROLE_INSTANCE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
if property_name in self._DEFAULTS or \
property_name in self._READONLY_SETTINGS:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.PropertyReadOnly: "
"Property '%s' is read-only" % property_name)
else:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.AccessDenied: "
"Property '%s' does not exist" % property_name)
def Set(self, interface_name, property_name, new_value, sender=None):
interface_name = dbus_to_python(interface_name)
property_name = dbus_to_python(property_name)
new_value = dbus_to_python(new_value)
log.debug1("%s.Set('%s', '%s', '%s')", self._log_prefix,
interface_name, property_name, new_value)
if interface_name != DBUS_INTERFACE_ROLE_INSTANCE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
if property_name in self._DEFAULTS or \
property_name in self._READONLY_SETTINGS:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.PropertyReadOnly: "
"Property '%s' is read-only" % property_name)
else:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.AccessDenied: "
"Property '%s' does not exist" % property_name)
def GetAll(self, interface_name, sender=None):
interface_name = dbus_to_python(interface_name)
log.debug1("GetAll('%s')", interface_name)
if interface_name != DBUS_INTERFACE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"roled does not implement %s" % interface_name)
return {
'version': self._get_property("version"),
'roles': self._get_property("roles"),
}
def check_values(self, values):
# Check key value pairs for the properties
values = dbus_to_python(values)
for x in values:
if x in self._DEFAULTS:
if x in self._READONLY_SETTINGS:
raise RolekitError(READONLY_SETTING, x)
# use _check_property method from derived or parent class
self._check_property(x, values[x])
else:
log.error("Unknown property: %s" % x)
raise RolekitError(UNKNOWN_SETTING, x)
def GetAll(self, interface_name, sender=None):
interface_name = dbus_to_python(interface_name)
log.debug1("%s.GetAll('%s')", self._log_prefix, interface_name)
if interface_name != DBUS_INTERFACE_ROLE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
ret = dbus.Dictionary(signature="sv")
for x in ["name", "DEFAULTS"]:
ret[x] = self.get_dbus_property(x)
return ret
def check_values(self, values):
# Check key value pairs for the properties
values = dbus_to_python(values)
for x in values:
if x in self._DEFAULTS:
if x in self._READONLY_SETTINGS:
raise RolekitError(READONLY_SETTING, x)
# use _check_property method from derived or parent class
self._check_property(x, values[x])
else:
log.error("Unknown property: %s" % x)
raise RolekitError(UNKNOWN_SETTING, x)
def GetAll(self, interface_name, sender=None):
interface_name = dbus_to_python(interface_name)
log.debug1("%s.GetAll('%s')", self._log_prefix, interface_name)
if interface_name != DBUS_INTERFACE_ROLE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
ret = dbus.Dictionary(signature = "sv")
for x in [ "name", "DEFAULTS" ]:
ret[x] = self.get_dbus_property(x)
return ret
def GetAll(self, interface_name, sender=None):
interface_name = dbus_to_python(interface_name)
log.debug1("%s.GetAll('%s')", self._log_prefix, interface_name)
if interface_name != DBUS_INTERFACE_ROLE_INSTANCE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
ret = {}
for name in self._DEFAULTS:
ret[name] = self.get_dbus_property(self, name)
# add settings that are not in _DEFAULTS
for name in self._ADDITIONAL_PROPERTIES:
ret[name] = self.get_dbus_property(self, name)
return ret
def GetAll(self, interface_name, sender=None):
interface_name = dbus_to_python(interface_name)
log.debug1("%s.GetAll('%s')", self._log_prefix, interface_name)
if interface_name != DBUS_INTERFACE_ROLE_INSTANCE:
raise dbus.exceptions.DBusException(
"org.freedesktop.DBus.Error.UnknownInterface: "
"RolekitD does not implement %s" % interface_name)
ret = { }
for name in self._DEFAULTS:
ret[name] = self.get_dbus_property(self, name)
# add settings that are not in _DEFAULTS
for name in self._ADDITIONAL_PROPERTIES:
ret[name] = self.get_dbus_property(self, name)
return ret
def _signal_receiver(self, *args, **kwargs):
_args = []
for arg in args:
_args.append(dbus_to_python(arg))
args = _args
if not "member" in kwargs:
return
signal = kwargs["member"]
interface = kwargs["interface"]
cb = None
cb_args = []
# config signals need special treatment
# pimp signal name
if interface.startswith(DBUS_INTERFACE_ROLE):
signal = "config:Role" + signal
for callback in self._callbacks:
if self._callbacks[callback] == signal and \
self._callbacks[callback] in self._callback:
cb = self._callback[self._callbacks[callback]]
if not cb:
return
cb_args.extend(args)
# call back ...
try:
if cb[1]:
# add call data
cb_args.extend(cb[1])
# call back
cb[0](*cb_args)
except Exception as msg:
print(msg)
def deploy_async(self, values, sender=None):
"""deploy role"""
remove_instance = False
values = dbus_to_python(values)
# Make sure we are in the proper state
self.assert_state(NASCENT)
# Log
log.debug1("%s.deploy(%s)", self._log_prefix, values)
# Check values
try:
self.check_values(values)
except Exception as e:
# Check values failed, remove the instance again if verification
# failed, set state to error, save it (will be visible in the
# .old backup file).
self.change_state(ERROR, error=str(e), write=True)
# cleanup
self.__remove_instance()
raise
try:
# Change to deploying state
self.change_state(DEPLOYING)
# Copy _DEFAULTS to self._settings
self.copy_defaults()
# Install package groups and packages
log.debug9("TRACE: Installing packages")
yield async.call_future(self.installPackages())
# Install firewall
self.installFirewall()
# Call do_deploy
log.debug9("TRACE: Performing role-specific deployment")
try:
target = yield async.call_future(self.do_deploy_async(values, sender))
except RolekitError as e:
if e.code == INVALID_VALUE:
# If we failed because the input values were incorrect,
# also remove the instance.
remove_instance = True
raise
# Continue only after successful deployment:
# Apply values to self._settings
log.debug9("TRACE: role-specific deployment complete, applying values")
self.apply_values(values)
# Set up systemd target files
log.debug9("TRACE: Creating systemd target files")
self.create_target(target)
# Change to ready to start state
self.change_state(READY_TO_START, write=True)
# In case this was a nextboot deployment, make sure to remove
# the deferred role settings and systemd unit
try:
# Remove settings
deferredsettings = "%s/%s/%s.json" % (ETC_ROLEKIT_DEFERREDROLES, self.get_type(), self.get_name())
os.unlink(deferredsettings)
# Remove systemd service unit
deferredunit = "%s/deferred-role-deployment-%s-%s.service" % (
SYSTEMD_UNITS, self.get_type(), self.get_name())
disable_units([deferredunit])
os.unlink(deferredunit)
except FileNotFoundError:
# Files didn't exist; ignore that
pass
except PermissionError:
# SELinux bug?
log.fatal("ERROR: permission error attempting to delete %s or %s" % (
deferredsettings, deferredunit
))
# We'll continue anyway, since the service should be runnable at this point
# The ConditionPathExists will prevent the service from trying to deploy
# again
# Tell systemd to reload the daemon configuration
log.debug9("Reloading systemd units\n")
with SystemdJobHandler() as job_handler:
job_handler.manager.Reload()
# Start monitoring the role
self.monitor_unit()
# Attempt to start the newly-deployed role
# We do this because many role-installers will conclude by
# starting anyway and we want to ensure that our role mechanism
# is in sync with them.
log.debug9("TRACE: Starting %s" % self.get_name())
yield async.call_future(self.__start_async(sender))
except Exception as e:
# Something failed, set state to error
self.change_state(ERROR, error=str(e), write=True)
if remove_instance:
self.__remove_instance()
raise
def deploy_async(self, values, sender=None):
"""deploy role"""
remove_instance = False
values = dbus_to_python(values)
# Make sure we are in the proper state
self.assert_state(NASCENT)
# Log
log.debug1("%s.deploy(%s)", self._log_prefix, values)
# Check values
try:
self.check_values(values)
except Exception as e:
# Check values failed, remove the instance again if verification
# failed, set state to error, save it (will be visible in the
# .old backup file).
self.change_state(ERROR, error=str(e), write=True)
# cleanup
self.__remove_instance()
raise
try:
# Change to deploying state
self.change_state(DEPLOYING)
# Copy _DEFAULTS to self._settings
self.copy_defaults()
# Install package groups and packages
log.debug9("TRACE: Installing packages")
yield async .call_future(self.installPackages())
# Install firewall
self.installFirewall()
# Call do_deploy
log.debug9("TRACE: Performing role-specific deployment")
try:
target = yield async .call_future(
self.do_deploy_async(values, sender))
except RolekitError as e:
if e.code == INVALID_VALUE:
# If we failed because the input values were incorrect,
# also remove the instance.
remove_instance = True
raise
# Continue only after successful deployment:
# Apply values to self._settings
log.debug9(
"TRACE: role-specific deployment complete, applying values")
self.apply_values(values)
# Set up systemd target files
log.debug9("TRACE: Creating systemd target files")
self.create_target(target)
# Change to ready to start state
self.change_state(READY_TO_START, write=True)
# In case this was a nextboot deployment, make sure to remove
# the deferred role settings and systemd unit
try:
# Remove settings
deferredsettings = "%s/%s/%s.json" % (
ETC_ROLEKIT_DEFERREDROLES, self.get_type(),
self.get_name())
os.unlink(deferredsettings)
# Remove systemd service unit
deferredunit = "%s/deferred-role-deployment-%s-%s.service" % (
SYSTEMD_UNITS, self.get_type(), self.get_name())
disable_units([deferredunit])
os.unlink(deferredunit)
except FileNotFoundError:
# Files didn't exist; ignore that
pass
except PermissionError:
# SELinux bug?
log.fatal(
"ERROR: permission error attempting to delete %s or %s" %
(deferredsettings, deferredunit))
# We'll continue anyway, since the service should be runnable at this point
# The ConditionPathExists will prevent the service from trying to deploy
# again
# Tell systemd to reload the daemon configuration
log.debug9("Reloading systemd units\n")
with SystemdJobHandler() as job_handler:
job_handler.manager.Reload()
# Start monitoring the role
self.monitor_unit()
# Attempt to start the newly-deployed role
# We do this because many role-installers will conclude by
# starting anyway and we want to ensure that our role mechanism
# is in sync with them.
log.debug9("TRACE: Starting %s" % self.get_name())
yield async .call_future(self.__start_async(sender))
except Exception as e:
# Something failed, set state to error
self.change_state(ERROR, error=str(e), write=True)
if remove_instance:
self.__remove_instance()
raise
def getInstances(self):
return dbus_to_python(self.role.getInstances())
def getNamedInstance(self, name):
return dbus_to_python(self.role.getNamedInstance(name))
def getNamedInstanceObj(self, name):
return RolekitClientRoleInstance(self.bus, dbus_to_python(self.role.getNamedInstance(name)))
def get_property(self, prop):
return dbus_to_python(self.properties.Get(DBUS_INTERFACE_ROLE, prop))
def getInstances(self):
return dbus_to_python(self.role.getInstances())
def get_property(self, prop):
return dbus_to_python(self.properties.Get(DBUS_INTERFACE_ROLE, prop))
def decommission(self, force, reply_handler, error_handler, sender=None):
"""decommission role"""
force = dbus_to_python(force)
async .start_with_dbus_callbacks(
self.__decommission_async(force, sender), reply_handler,
error_handler)
def getNamedInstance(self, name):
return dbus_to_python(self.role.getNamedInstance(name))
def decommission(self, force, reply_handler, error_handler, sender=None):
"""decommission role"""
force = dbus_to_python(force)
async.start_with_dbus_callbacks(self.__decommission_async(force,
sender),
reply_handler, error_handler)
def getNamedInstanceObj(self, name):
return RolekitClientRoleInstance(
self.bus, dbus_to_python(self.role.getNamedInstance(name)))
def get_properties(self):
return dbus_to_python(self.properties.GetAll(DBUS_INTERFACE_ROLE))
def get_properties(self):
return dbus_to_python(self.properties.GetAll(DBUS_INTERFACE_ROLE))
