def is_service_running(service):
""" Queries systemd through dbus to see if the service is running """
service_running = False
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = dbus.Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
try:
service_unit = service if service.endswith(
'.service') else manager.GetUnit("{}.service".format(service))
service_proxy = bus.get_object('org.freedesktop.systemd1',
str(service_unit))
service_properties = dbus.Interface(
service_proxy, dbus_interface='org.freedesktop.DBus.Properties')
service_load_state = service_properties.Get(
'org.freedesktop.systemd1.Unit', 'LoadState')
service_active_state = service_properties.Get(
'org.freedesktop.systemd1.Unit', 'ActiveState')
if service_load_state == 'loaded' and service_active_state == 'active':
service_running = True
except dbus.DBusException as error:
logging.error(str(error))
return service_running
def check_service_status(service):
""" queries systemd through dbus to see if the service is running """
service_running = False
bus = SystemBus()
systemd = bus.get_object("org.freedesktop.systemd1", "/org/freedesktop/systemd1")
manager = Interface(systemd, dbus_interface="org.freedesktop.systemd1.Manager")
try:
service_unit = (
service
if service.endswith(".service")
else manager.GetUnit(f"{service}.service")
)
service_proxy = bus.get_object("org.freedesktop.systemd1", str(service_unit))
service_props = Interface(
service_proxy, dbus_interface="org.freedesktop.DBus.Properties"
)
service_load_state = service_props.Get(
"org.freedesktop.systemd1.Unit", "LoadState"
)
service_active_state = service_props.Get(
"org.freedesktop.systemd1.Unit", "ActiveState"
)
if service_load_state == "loaded" and service_active_state == "active":
service_running = True
except DBusException:
pass
return service_running
def __init__( self ):
# prepare avahi binding
bus = SystemBus()
server = Interface(
bus.get_object( DBUS_NAME, DBUS_PATH_SERVER ),
DBUS_INTERFACE_SERVER )
self.hostname = server.GetHostNameFqdn()
self.group = Interface( bus.get_object( DBUS_NAME, server.EntryGroupNew() ), DBUS_INTERFACE_ENTRY_GROUP )
self.export()
def is_ap_mode(self) -> bool:
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
appliance_unit = manager.LoadUnit('hostapd.service')
appliance_proxy = bus.get_object('org.freedesktop.systemd1',
str(appliance_unit))
appliance_properties = Interface(
appliance_proxy, dbus_interface='org.freedesktop.DBus.Properties')
return appliance_properties.Get('org.freedesktop.systemd1.Unit',
'ActiveState') != 'inactive'
def appliance_state():
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
appliance_unit = manager.LoadUnit('observer-appliance.service')
appliance_proxy = bus.get_object('org.freedesktop.systemd1',
str(appliance_unit))
appliance_properties = Interface(
appliance_proxy, dbus_interface='org.freedesktop.DBus.Properties')
return appliance_properties.Get('org.freedesktop.systemd1.Unit',
'ActiveState')
class SystemServices(service.FunctionObject) :
def __init__(self, object_path, service_object = None) :
super().__init__(object_path, service_object)
self._bus = SystemBus()
self._systemd_manager = DBusInterface(self._bus.get_object(
'org.freedesktop.systemd1', '/org/freedesktop/systemd1'
), 'org.freedesktop.systemd1.Manager')
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def enable(self, name):
logger.verbose("{mod}: Request to enable service \"%s\"" % name)
self._systemd_manager.EnableUnitFiles([name + '.service'], False, True)
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def disable(self, name):
logger.verbose("{mod}: Request to disable service \"%s\"" % name)
self._systemd_manager.DisableUnitFiles([name + '.service'], False, True)
###
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def reload(self, name) :
logger.verbose("{mod}: Request to reload service \"%s\"" % name)
self._systemd_manager.ReloadUnit(name + '.service', 'replace')
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def start(self, name) :
logger.verbose("{mod}: Request to start service \"%s\"" % name)
self._systemd_manager.StartUnit(name + '.service', 'replace')
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def stop(self, name) :
logger.verbose("{mod}: Request to stop service \"%s\"" % name)
self._systemd_manager.StopUnit(name + '.service', 'replace')
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s", out_signature="s")
def getActiveState(self, name) :
unit = DBusInterface(
self._bus.get_object(
'org.freedesktop.systemd1',
str(self._systemd_manager.LoadUnit(name + '.service'))
),
'org.freedesktop.systemd1.Unit'
)
active_state = unit.Get(
'org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties'
)
return active_state
def systemd_resolved_status():
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
unit = manager.LoadUnit('sytemd-resolved.service')
proxy = bus.get_object('org.freedesktop.systemd1', str(unit))
r = proxy.Get('org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties')
if str(r) == 'active':
return True
return False
def systemd_resolved_status():
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
unit = manager.LoadUnit('sytemd-resolved.service')
proxy = bus.get_object('org.freedesktop.systemd1', str(unit))
r = proxy.Get('org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties')
if str(r) == 'active':
return True
return False
def __init__(self):
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
self.manager = Interface(systemd, 'org.freedesktop.systemd1.Manager')
self.supported_operations = ['stop', 'start', 'restart']
def __init__(self, iface: str = 'hci0', ioc: str = 'NoInputNoOutput'):
super().__init__(iface=iface)
self.result = GattScanResult()
self.gatt_client = None
self.spinner = Halo()
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
sys_bus = SystemBus()
self.agent_registered = False
def register_agent_callback():
logger.debug('Agent object registered\n'
"IO capability: {}".format(
self.bluescan_agent.io_capability))
self.agent_registered = True
def register_agent_error_callback(error):
logger.error(
"Failed to register agent object.\n" + "{}\n".format(error) +
"IO capability: {}".format(self.bluescan_agent.io_capability))
self.agent_registered = False
self.bluescan_agent = BluescanAgent(sys_bus, 0, ioc)
self.agent_mgr_1_iface = dbus.Interface(
sys_bus.get_object(BLUEZ_NAME, '/org/bluez'), IFACE_AGENT_MGR_1)
self.agent_mgr_1_iface.RegisterAgent(
ObjectPath(self.bluescan_agent.path),
self.bluescan_agent.io_capability,
reply_handler=register_agent_callback,
error_handler=register_agent_error_callback)
def set_dns_systemd_resolved(lease):
# NOTE: if systemd-resolved is not already running, we might not want to
# run it in case there's specific system configuration for other resolvers
ipr = IPRoute()
index = ipr.link_lookup(ifname=lease.interface)[0]
# Construct the argument to pass to DBUS.
# the equivalent argument for:
# busctl call org.freedesktop.resolve1 /org/freedesktop/resolve1 \
# org.freedesktop.resolve1.Manager SetLinkDNS 'ia(iay)' 2 1 2 4 1 2 3 4
# is SetLinkDNS(2, [(2, [8, 8, 8, 8])]_
iay = [(2, [int(b) for b in ns.split('.')])
for ns in lease.name_server.split()]
# if '.' in ns
# else (10, [ord(x) for x in
# socket.inet_pton(socket.AF_INET6, ns)])
bus = SystemBus()
resolved = bus.get_object('org.freedesktop.resolve1',
'/org/freedesktop/resolve1')
manager = Interface(resolved,
dbus_interface='org.freedesktop.resolve1.Manager')
try:
manager.SetLinkDNS(index, iay)
return True
except DBusException as e:
logger.error(e)
return False
class SystemdLogin(Debug):
"""Handles login request messages of systemd"""
ACTUATOR_NAME = "SystemdLogin"
@staticmethod
def name():
""" @return: name of the module."""
return SystemdLogin.ACTUATOR_NAME
def __init__(self):
super(SystemdLogin, self).__init__()
# Use d-bus to communicate with systemd
# Described at: http://www.freedesktop.org/wiki/Software/systemd/logind/
# Obtain an instance of d-bus to communicate with systemd
self._bus = SystemBus()
# Obtain a manager interface to d-bus for communications with login1
logind = self._bus.get_object('org.freedesktop.login1',
'/org/freedesktop/login1')
self._manager = Interface(
logind, dbus_interface='org.freedesktop.login1.Manager')
def perform_request(self, jsonMsg):
"""Performs the login request"""
self._check_debug(jsonMsg)
# Parse out the login request to perform
self._login_request = jsonMsg.get("login_request")
self._log_debug("perform_request, _login_request: %s" %
self._login_request)
user_names = []
try:
# Return a list of user names currently logged in
if self._login_request == "get_all_users":
users = self._manager.ListSessions()
for user in users:
# session id, user id, user name, seat id, session object path
if user[2] not in user_names:
self._log_debug("perform_request, user name: %s" %
(user[2]))
user_names.append(user[2])
except debus_exceptions.DBusException as error:
logger.exception(error)
self._bus = None
self._manager = None
return user_names
def _get_status(self):
""""Returns the active state of the unit"""
return self._proxy.Get(
'org.freedesktop.login1',
'Name',
dbus_interface='org.freedesktop.DBus.Properties')
def transaction(self):
if dnfpluginsextras.is_erasing(self.base.transaction,
"snapper"):
return
try:
bus = SystemBus()
snapper = Interface(bus.get_object('org.opensuse.Snapper',
'/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logger.critical(
"snapper: " + _("connect to snapperd failed: %s"), e
)
return
try:
logger.debug(
"snapper: " + _("creating snapshot")
)
snap = snapper.CreateSingleSnapshot("root", self.description, "", {})
logger.debug(
"snapper: " + _("created snapshot %d"), snap
)
except DBusException as e:
logger.critical(
"snapper: " + _("creating snapshot failed: %s"), e
)
def set_dns_systemd_resolved(lease):
# NOTE: if systemd-resolved is not already running, we might not want to
# run it in case there's specific system configuration for other resolvers
ipr = IPRoute()
index = ipr.link_lookup(ifname=lease.interface)[0]
# Construct the argument to pass to DBUS.
# the equivalent argument for:
# busctl call org.freedesktop.resolve1 /org/freedesktop/resolve1 \
# org.freedesktop.resolve1.Manager SetLinkDNS 'ia(iay)' 2 1 2 4 1 2 3 4
# is SetLinkDNS(2, [(2, [8, 8, 8, 8])]_
iay = [(2, [int(b) for b in ns.split('.')])
for ns in lease.name_server.split()]
# if '.' in ns
# else (10, [ord(x) for x in
# socket.inet_pton(socket.AF_INET6, ns)])
bus = SystemBus()
resolved = bus.get_object('org.freedesktop.resolve1',
'/org/freedesktop/resolve1')
manager = Interface(resolved,
dbus_interface='org.freedesktop.resolve1.Manager')
try:
manager.SetLinkDNS(index, iay)
return True
except DBusException as e:
logger.error(e)
return False
class Policy:
def __init__(self, enforce=True):
self.enforce = enforce
self.bus = SystemBus()
self.dbus_iface = None
self.pk = Interface(self.bus.get_object('org.freedesktop.PolicyKit1',
'/org/freedesktop/PolicyKit1/Authority'),
'org.freedesktop.PolicyKit1.Authority')
if not enforce:
log.warn('Not enforcing PolicyKit privileges!')
def check(self, sender, conn, priv='com.ubuntu.jobservice.manage'):
"""
Check or ask for authentication for job management.
"""
if not self.enforce: return
log.debug('Asking for PolicyKit authorization')
# get the PID of the sender
if not self.dbus_iface:
self.dbus_iface = Interface(conn.get_object('org.freedesktop.DBus',
'/org/freedesktop/DBus/Bus'), 'org.freedesktop.DBus')
pid = self.dbus_iface.GetConnectionUnixProcessID(sender)
# ask PolicyKit
auth, challenge, details = self.pk.CheckAuthorization(
('unix-process', {'pid': pid, 'start-time': UInt64(0)}),
priv, {'': ''}, 1, '', timeout=500)
if not auth:
log.info('Authorization failed')
raise DeniedByPolicy('Not authorized to manage jobs.')
log.debug('Authorization passed')
def pre_transaction(self):
if not self.base.transaction:
return
try:
bus = SystemBus()
self._snapper = Interface(bus.get_object('org.opensuse.Snapper',
'/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logger.critical(
"snapper: " + _("connect to snapperd failed: %s"), e
)
return
try:
logger.debug(
"snapper: " + _("creating pre_snapshot")
)
self._pre_snap_number = self._snapper.CreatePreSnapshot("root", self.description,
"number", {})
self._pre_snap_created = True
logger.debug(
"snapper: " + _("created pre_snapshot %d"), self._pre_snap_number
)
except DBusException as e:
logger.critical(
"snapper: " + _("creating pre_snapshot failed: %s"), e
)
def __init__(self, iface: str = 'hci0', ioc: str = 'NoInputNoOutput'):
super().__init__(iface=iface)
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
sys_bus = SystemBus()
self.agent_registered = False
def register_agent_callback():
logger.info('Agent object registered')
print(INFO_INDENT,
"IO capability: {}".format(
self.bluescan_agent.io_capability),
sep='')
self.agent_registered = True
def register_agent_error_callback(error):
logger.error("Failed to register agent object")
print(ERROR_INDENT, "{}".format(error), sep='')
print(ERROR_INDENT,
"IO capability: {}".format(
self.bluescan_agent.io_capability),
sep='')
self.agent_registered = False
self.bluescan_agent = BluescanAgent(sys_bus, 0, ioc)
self.agent_mgr_1_iface = dbus.Interface(
sys_bus.get_object(BLUEZ_NAME, '/org/bluez'), IFACE_AGENT_MGR_1)
self.agent_mgr_1_iface.RegisterAgent(
ObjectPath(self.bluescan_agent.path),
self.bluescan_agent.io_capability,
reply_handler=register_agent_callback,
error_handler=register_agent_error_callback)
def run():
loop = MainLoop()
bus = SystemBus(mainloop=dglib.DBusGMainLoop())
dglib.threads_init()
bat_object = bus.get_object(
'org.freedesktop.UPower',
'/org/freedesktop/UPower/devices/battery_BAT1')
bat = Interface(bat_object, 'org.freedesktop.DBus.Properties')
lemonbar = Feeder(i3, bat, bus, bar, display_title)
lemonbar.render_all()
pulse = Pulse('event-printer')
pulse.event_mask_set('sink', 'server')
pulse.event_callback_set(lemonbar.on_volume_event)
pulse_thread = Thread(target=pulse.event_listen, args=[0])
pulse_thread.daemon = True
pulse_thread.start()
bat_object.connect_to_signal(
"PropertiesChanged",
lemonbar.on_battery_event,
dbus_interface='org.freedesktop.DBus.Properties')
bat_thread = Thread(target=loop.run)
bat_thread.daemon = True
bat_thread.start()
sched = BackgroundScheduler(daemon=True)
sched.add_job(lemonbar.on_timedate_event, 'cron', second=0)
sched.start()
def shutdown(caller, e):
bar.stop_bar(wbak, bar_pid)
print(e.change)
exit(0)
def reload_bar(caller, data):
global bar_pid
bar.stop_bar(wbak, bar_pid)
#print("reloading...")
bar_pid = bar.start_bar()
lemonbar.set_outputs()
lemonbar.render_all(caller=caller, e=data)
i3.on('workspace::urgent', lemonbar.on_workspace_event)
i3.on('workspace::empty', lemonbar.on_workspace_event)
if display_title:
i3.on('window::title', lemonbar.on_window_title_change)
i3.on('window::close', lemonbar.on_window_close)
i3.on('window::focus', lemonbar.on_window_title_change)
i3.on('workspace::focus', lemonbar.on_workspace_focus)
else:
i3.on('workspace::focus', lemonbar.on_workspace_event)
i3.on('mode', lemonbar.on_binding_mode_change)
i3.on('output', reload_bar)
i3.on('shutdown', shutdown)
i3.main()
def get_minecraft_info():
if not alpm_imported or not dbus_imported:
out = "Minecraft info not available due to modules:"
out += "" if alpm_imported else " pyalpm"
out += "" if dbus_imported else " dbus"
return out
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
unit = manager.LoadUnit(config_get("minecraft", "unit"))
uproxy = bus.get_object('org.freedesktop.systemd1', str(unit))
state = Interface(uproxy, dbus_interface='org.freedesktop.DBus.Properties')
active_state = str(
state.Get('org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties'))
if active_state == 'active':
active_time = int(
state.Get('org.freedesktop.systemd1.Unit',
'ActiveEnterTimestamp',
dbus_interface='org.freedesktop.DBus.Properties'))
else:
active_time = 0
alpm_handle = pyalpm.Handle(config_get("alpm", "rootdir"),
config_get("alpm", "dbdir"))
local_db = alpm_handle.get_localdb()
mc_pkg = local_db.get_pkg(config_get("minecraft", "pkgname"))
ver = mc_pkg.version
sanitized_ver = ''.join(re.findall(r'(\d+\.)(\d+\.)?(\*|\d*)', ver)[0])
if active_state == 'active':
out = "Minecraft server is up!\nUptime: %s\nVersion: %s\nAddress: %s" % \
(datetime.datetime.now() - datetime.datetime.fromtimestamp(int(active_time/1000000)),
sanitized_ver,
config_get("minecraft", "address"))
else:
out = "Minecraft server is down!"
return out
def simdi_kapat(istek):
bus = SystemBus()
dbus_k = bus.get_object('org.freedesktop.ConsoleKit',
'/org/freedesktop/ConsoleKit/Manager')
dbus_kapat = Interface(dbus_k, 'org.freedesktop.ConsoleKit.Manager')
if istek == 'Stop':
print("\033[1;41mBilgisayarınız kapatılıyor...\033[0m")
dbus_kapat.Stop()
else:
print("\033[1;41mBilgisayarınız yeniden başlatılıyor...\033[0m")
dbus_kapat.Restart()
class Vibra_Plugin(Plugin):
def __init__(self):
DBusGMainLoop(set_as_default=True)
self.bus = SystemBus()
self.sessionbus = SessionBus()
try:
self.mce = self.bus.get_object("com.nokia.mce", "/com/nokia/mce")
except DBusException:
warning("Nokia MCE not found. Vibra is disabled\n")
return
self.profiled = self.sessionbus.get_object("com.nokia.profiled", "/com/nokia/profiled")
self.sessionbus.add_signal_receiver(
self.profile_changed_handler,
"profile_changed",
"com.nokia.profiled",
"com.nokia.profiled",
"/com/nokia/profiled",
)
profile = self.profiled.get_profile(dbus_interface="com.nokia.profiled")
self.get_vibra_enabled(profile)
self.register_plugin(PLUGIN_TYPE_VIBRA)
def ready(self):
self.notification = get_plugin_by_type(PLUGIN_TYPE_NOTIFICATION)
sendfile = get_plugin_by_type(PLUGIN_TYPE_SEND_FILE)
sendfile.receive_cb.append(self.file_receive)
def get_vibra_enabled(self, profile):
self.enabled = (
self.profiled.get_value(profile, "vibrating.alert.enabled", dbus_interface="com.nokia.profiled") == "On"
)
debug("Vibra enabled: %s\n" % self.enabled)
def profile_changed_handler(self, foo, bar, profile, *args):
self.get_vibra_enabled(profile)
def vibrate(self):
if self.enabled:
self.mce.req_vibrator_pattern_activate("PatternChatAndEmail", dbus_interface="com.nokia.mce.request")
def file_receive(self, cb, user, fname):
self.vibrate()
def user_appears(self, user):
if user.get("friend"):
self.vibrate()
def restart_daemon():
cmd = f"systemctl restart chain-maind"
print("### Restart service ###")
sysbus = SystemBus()
systemd1 = sysbus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd1,
dbus_interface='org.freedesktop.systemd1.Manager')
if is_service_active('chain-maind.service'):
manager.StopUnit('chain-maind.service', 'replace')
#job = manager.RestartUnit('chain-maind.service', 'fail')
time.sleep(2)
manager.StartUnit('chain-maind.service', 'replace')
class ConnectionsManager:
def connect(self, config, secrets):
self.config = config
self.secrets = secrets
self.DBus = SystemBus()
self.SystemD = self.SystemDConnect("/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager")
self.LDAP = ldap_connect(config=config, passwd=secrets.get("ldap"))
self.Supervisor = supervisor_connect()
def SystemDConnect(self, path, interface):
systemd = self.DBus.get_object("org.freedesktop.systemd1", path)
return Interface(systemd, dbus_interface=interface)
def start_service(service):
""" Start systemd service using through """
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = dbus.Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
try:
service_unit = service if service.endswith(
'.service') else manager.GetUnit("{}.service".format(service))
manager.StartUnit(service_unit, 'replace')
except dbus.DBusException as error:
logging.error(str(error))
def __init__(self, bus=None, proxy=None):
"""
Initialize an instance with the given DBus proxy object.
:param dbus.Bus bus: connection to system bus
:param dbus.proxies.ProxyObject proxy: proxy to udisks object
"""
if proxy is None:
if bus is None:
from dbus import SystemBus
bus = SystemBus()
proxy = DBusProxy(bus.get_object(self.BusName, self.ObjectPath),
self.Interface)
self._proxy = proxy
def get_minecraft_info():
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
unit = manager.LoadUnit('spigot.service')
uproxy = bus.get_object('org.freedesktop.systemd1', str(unit))
state = Interface(uproxy, dbus_interface='org.freedesktop.DBus.Properties')
active_state = str(
state.Get('org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties'))
if active_state == 'active':
active_time = int(
state.Get('org.freedesktop.systemd1.Unit',
'ActiveEnterTimestamp',
dbus_interface='org.freedesktop.DBus.Properties'))
else:
active_time = 0
alpm_handle = pyalpm.Handle("/", "/var/lib/pacman")
local_db = alpm_handle.get_localdb()
spigot_pkg = local_db.get_pkg("spigot")
ver = spigot_pkg.version
if active_state == 'active':
out = "Minecraft server is up!\nUptime: %s\nVersion: %s\nAddress: %s" % \
(datetime.datetime.now() - datetime.datetime.fromtimestamp(int(active_time/1000000)),
ver.split(":")[1].split("-")[0],
config_get("minecraft", "address"))
else:
out = "Minecraft server is down!"
return out
def load_entries(self):
bus = SystemBus()
try:
gsm = bus.get_object('org.freesmartphone.ogsmd', '/org/freesmartphone/GSM/Device')
self.gsm_sim_iface = Interface(gsm, 'org.freesmartphone.GSM.SIM')
self.gsm_sim_iface.RetrieveMessagebook(
'all',
reply_handler=self.process_all_entries,
error_handler=self.handle_sim_error)
except DBusException, e:
syslog(LOG_WARNING, "%s: Could not request SIM messagebook from ogsmd, scheduling retry (%s)" % (self.name, e))
return True
def start_stop_service(service_name, action):
assert action in ("running", "halted")
# Obtain an instance of d-bus to communicate with systemd
bus = SystemBus()
# Obtain a manager interface to d-bus for communications with systemd
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
if action == "running":
manager.StartUnit(service_name + ".service", 'replace')
else:
manager.StopUnit(service_name + ".service", 'replace')
def is_service_active(service):
"""
is_service_active method will check if service is running or not.
It raise exception if there is service is not loaded
Return value, True if service is running otherwise False.
:param str service: name of the service
"""
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd, 'org.freedesktop.systemd1.Manager')
try:
manager.GetUnit('chain-maind.service')
return True
except:
return False
def transaction(self):
if dnfpluginsextras.is_erasing(self.base.transaction, "snapper"):
return
try:
bus = SystemBus()
snapper = Interface(bus.get_object('org.opensuse.Snapper',
'/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logger.critical("snapper: " + _("connect to snapperd failed: %s"),
e)
return
try:
logger.debug("snapper: " + _("creating snapshot"))
snap = snapper.CreateSingleSnapshot("root", self.description, "",
{})
logger.debug("snapper: " + _("created snapshot %d"), snap)
except DBusException as e:
logger.critical("snapper: " + _("creating snapshot failed: %s"), e)
def connect_service(cls, bus=None, mainloop=None):
"""
Connect to the service object on dbus.
:param dbus.Bus bus: connection to system bus
:param dbus.mainloop.NativeMainLoop mainloop: system bus event loop
:raises dbus.DBusException: if unable to connect to service.
The mainloop parameter is only relevant if no bus is given. In this
case if ``mainloop is True``, use the default (glib) mainloop
provided by dbus-python.
"""
if bus is None:
mainloop = mainloop or cls.mainloop
if mainloop is True:
mainloop = DBusGMainLoop()
bus = SystemBus(mainloop=mainloop or cls.mainloop)
obj = bus.get_object(cls.BusName, cls.ObjectPath)
return DBusProxy(obj, cls.Interface)
def connect_service(cls, bus=None, mainloop=None):
"""
Connect to the service object on dbus.
:param dbus.Bus bus: connection to system bus
:param dbus.mainloop.NativeMainLoop mainloop: system bus event loop
:raises dbus.DBusException: if unable to connect to service.
The mainloop parameter is only relevant if no bus is given. In this
case if ``mainloop is True``, use the default (glib) mainloop
provided by dbus-python.
"""
if bus is None:
mainloop = mainloop or cls.mainloop
if mainloop is True:
mainloop = DBusGMainLoop()
bus = SystemBus(mainloop=mainloop or cls.mainloop)
obj = bus.get_object(cls.BusName, cls.ObjectPath)
return DBusProxy(obj, cls.Interface)
class RemoteJobService:
def __init__(self):
self.jobs = {}
self._connect()
def _connect(self):
self.bus = SystemBus()
self.jobservice = Interface(self.bus.get_object(
'com.ubuntu.JobService', '/com/ubuntu/JobService'),
'com.ubuntu.JobService')
def get_all_jobs(self, protect=True):
self.jobs = {}
def call(): return self.jobservice.GetAllJobs()
alljobs = retry(self._connect, call)
for job, path in alljobs:
protected = is_protected(job)
if not protect or not protected:
self.jobs[job] = RemoteJob(job, path)
self.jobs[job].protected = protected
return self.jobs
class BootAnalyzer:
def __init__(self, send_queue):
assert isinstance(send_queue, MultiQueue)
self.send_queue = send_queue
self.bus = SystemBus()
self.systemd = self.bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
self.manager = Interface(self.systemd, dbus_interface='org.freedesktop.systemd1.Manager')
def __push(self, data, prio):
self.send_queue.put_element(data, prio)
def analyze(self):
for e in self.manager.ListUnits():
if len(e) != 10:
continue
name = str(e[0])
description = str(e[1])
load_state = str(e[2])
active_state = str(e[3])
sub_state = str(e[4])
followed_unit = str(e[5])
unit_object_path = str(e[6])
queued_job_id = int(e[7])
job_type = str(e[8])
job_object_path = str(e[9])
if not name.endswith('.service'):
continue
if name.startswith('user@'):
continue
if active_state == ACTIVE:
continue
if active_state == INACTIVE and sub_state == DEAD:
continue
print(e[0])
def __init__(self, log: logging.Logger, pm: PluginMan.PluginManager,
bus_path: str, bus: dbus.SystemBus):
self._proxy = bus.get_object('org.freedesktop.login1', bus_path)
self.session = dbus.Interface(self._proxy,
'org.freedesktop.login1.Session')
self.properties = dbus.Interface(self._proxy,
'org.freedesktop.DBus.Properties')
self.isGUI = "seat" in self.properties.Get(
"org.freedesktop.login1.Session", "Seat")[0]
self.name = self.properties.Get("org.freedesktop.login1.Session", "Id")
self.isRemote = self.properties.Get("org.freedesktop.login1.Session",
"Remote")
self.uname = self.properties.Get("org.freedesktop.login1.Session",
"Name")
self.uID = self.properties.Get("org.freedesktop.login1.Session",
"User")
self.lockedHint = self.properties.Get("org.freedesktop.login1.Session",
"LockedHint")
self._log = log.getChild("Session")
self._pman = pm
self._lock_notify = None
self._unlock_notify = None
def pre_transaction(self):
if not self.base.transaction:
return
try:
bus = SystemBus()
self._snapper = Interface(bus.get_object('org.opensuse.Snapper',
'/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logger.critical("snapper: " + _("connect to snapperd failed: %s"),
e)
return
try:
logger.debug("snapper: " + _("creating pre_snapshot"))
self._pre_snap_number = self._snapper.CreatePreSnapshot(
"root", self.description, "number", {})
self._pre_snap_created = True
logger.debug("snapper: " + _("created pre_snapshot %d"),
self._pre_snap_number)
except DBusException as e:
logger.critical(
"snapper: " + _("creating pre_snapshot failed: %s"), e)
class ConnectionsManager:
"""Manages arkOS connections to system-level processes via their APIs."""
def __init__(self, config, secrets):
self.config = config
self.secrets = secrets
def connect(self):
"""Initialize the connections."""
self.connect_services()
self.connect_ldap()
def connect_services(self):
self.DBus = SystemBus()
self.SystemD = self.SystemDConnect("/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager")
self.Supervisor = supervisor_connect()
def connect_ldap(self):
self.LDAP = ldap_connect(config=self.config,
passwd=self.secrets.get("ldap"))
def SystemDConnect(self, path, interface):
systemd = self.DBus.get_object("org.freedesktop.systemd1", path)
return Interface(systemd, dbus_interface=interface)
def get_ble_dbus_path(self,
system_bus: dbus.SystemBus,
device: str = 'hci0') -> dbus.ObjectPath:
"""Retrieve the path to the Bluez Dbus."""
object_manager = dbus.Interface(
system_bus.get_object(Constants.dbus_bluez_service_name, '/'),
Constants.dbus_object_manager)
# Dictionary of all dBus Objects
objects = object_manager.GetManagedObjects()
# Return the object with the targeted BLE interface
for obj_path, props in objects.items():
if device not in str(obj_path):
continue
# Verify that the Advertising Manager is found.
if Constants.dbus_ble_interface_advertising_manager in props:
Utils.logger.debug(f'Found {obj_path} for interface {device}.')
return obj_path
raise SystemError(
f'Interface {device} was not found.'
'Run sudo hcitool devices to check if BLE device is up.')
#!/usr/bin/env python
from dbus import Interface, SystemBus
from dbus.exceptions import DBusException
from wait import wait
DEVICE = '00:0C:8A:67:96:90'
DEVICE = DEVICE.replace(':', '_')
index = 0
bus = SystemBus()
proxy_power = bus.get_object('org.bluez', '/org/bluez/hci0')
interface_power = Interface(proxy_power, dbus_interface='org.freedesktop.DBus.Properties')
while not interface_power.Get('org.bluez.Adapter1', 'Powered'):
interface_power.Set('org.bluez.Adapter1', 'Powered', True)
index = wait(index, text='powering')
else:
print('\nInterface powered')
proxy_connected = bus.get_object('org.bluez', '/org/bluez/hci0/dev_{}'.format(DEVICE))
interface_connected = Interface(proxy_connected, dbus_interface='org.freedesktop.DBus.Properties')
while not interface_connected.Get('org.bluez.Device1', 'Connected'):
interface_connect = Interface(proxy_connected, dbus_interface='org.bluez.Device1')
try:
interface_connect.Connect()
index = wait(index, text='connecting')
class SystemdService(Debug):
"""Handles service request messages to systemd"""
ACTUATOR_NAME = "SystemdService"
@staticmethod
def name():
""" @return: name of the module."""
return SystemdService.ACTUATOR_NAME
def __init__(self):
super(SystemdService, self).__init__()
# Use d-bus to communicate with systemd
# Described at: http://www.freedesktop.org/wiki/Software/systemd/dbus/
# Obtain an instance of d-bus to communicate with systemd
self._bus = SystemBus()
# Obtain a manager interface to d-bus for communications with systemd
systemd = self._bus.get_object('org.freedesktop.systemd1', '/org/freedesktop/systemd1')
self._manager = Interface(systemd, dbus_interface='org.freedesktop.systemd1.Manager')
# Subscribe to signal changes
self._manager.Subscribe()
def perform_request(self, jsonMsg):
"""Performs the service request"""
self._check_debug(jsonMsg)
# Parse out the service name and request to perform on it
if jsonMsg.get("actuator_request_type").get("service_controller") is not None:
self._service_name = jsonMsg.get("actuator_request_type").get("service_controller").get("service_name")
self._service_request = jsonMsg.get("actuator_request_type").get("service_controller").get("service_request")
else:
self._service_name = jsonMsg.get("actuator_request_type").get("service_watchdog_controller").get("service_name")
self._service_request = jsonMsg.get("actuator_request_type").get("service_watchdog_controller").get("service_request")
self._log_debug("perform_request, service_name: %s, service_request: %s" % \
(self._service_name, self._service_request))
try:
# Load the systemd unit for the service
systemd_unit = self._manager.LoadUnit(self._service_name)
# Get a proxy to systemd for accessing properties of units
self._proxy = self._bus.get_object("org.freedesktop.systemd1", str(systemd_unit))
# The returned result of the desired action
result = None
if self._service_request == "restart":
self._manager.RestartUnit(self._service_name, 'replace')
# Ensure we get an "active" status and not "activating"
max_wait = 0
while self._get_activestate() != "active":
self._log_debug("status is still activating, pausing")
time.sleep(1)
max_wait += 1
if max_wait > 20:
self._log_debug("maximum wait for service restart reached")
break
elif self._service_request == "start":
self._manager.StartUnit(self._service_name, 'replace')
elif self._service_request == "stop":
self._manager.StopUnit(self._service_name, 'replace')
elif self._service_request == "status":
# Return the status below
state = self._get_activestate()
substate = self._get_active_substate()
self._log_debug("perform_request, state: %s, substate: %s" %
(str(state), str(substate)))
return (self._service_name, state, substate)
elif self._service_request == "enable":
service_list = []
service_list.append(self._service_name)
"""EnableUnitFiles() function takes second argument as boolean.
True will enable a service for runtime only(creates symlink in /run/.. directory)
False will enable a service persistently(creates symlink in /etc/.. directory)"""
bool_res, result = self._manager.EnableUnitFiles(service_list, False, True)
self._log_debug("perform_request, bool: %s, result: %s" % (bool_res, result))
elif self._service_request == "disable":
service_list = []
service_list.append(self._service_name)
"""DisableUnitFiles() function takes second argument as boolean.
True will disable a service for runtime only(removes symlink from /run/.. directory)
False will disable a service persistently(removes symlink from /etc/.. directory)"""
result = self._manager.DisableUnitFiles(service_list, False)
self._log_debug("perform_request, result: %s" % result)
else:
self._log_debug("perform_request, Unknown service request")
return (self._service_name, "Unknown service request", None)
except debus_exceptions.DBusException as error:
logger.exception("DBus Exception: %r" % error)
return (self._service_name, str(error), None)
except Exception as ae:
logger.exception("Exception: %r" % ae)
return (self._service_name, str(ae), None)
# Give the unit some time to finish starting/stopping to get final status
time.sleep(5)
# Get the current status of the process and return it back if no result
if result is None:
state = self._get_activestate()
substate = self._get_active_substate()
self._log_debug("perform_request, state: %s, substate: %s" %
(str(state), str(substate)))
return (self._service_name, state, substate)
return (self._service_name, str(result), None)
def _get_activestate(self):
""""Returns the active state of the unit"""
return self._proxy.Get('org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties')
def _get_active_substate(self):
""""Returns the active state of the unit"""
return self._proxy.Get('org.freedesktop.systemd1.Unit',
'SubState',
dbus_interface='org.freedesktop.DBus.Properties')
class ServiceBackend(ServiceBase):
def __init__(self):
"""
Connect to Upstart's dbus service.
"""
self.jobpaths = {}
self.instpaths = {}
self.bus = SystemBus()
self.upstart = Interface(
self.bus.get_object('com.ubuntu.Upstart', '/com/ubuntu/Upstart'),
'com.ubuntu.Upstart0_6'
)
def get_all_services(self):
svclist = []
for path in self.upstart.GetAllJobs():
job_obj = self.bus.get_object('com.ubuntu.Upstart', path)
job_name = job_obj.Get('com.ubuntu.Upstart0_6.Job', 'name',
dbus_interface=PROPERTIES_IFACE)
job = Interface(job_obj, 'com.ubuntu.Upstart0_6.Job')
self.jobpaths[job_name] = path
# get the instance(s) and their states
instances = job.GetAllInstances()
self.instpaths[path] = []
if instances:
for inst_path in instances:
self.instpaths[path].append(inst_path)
inst_obj = self.bus.get_object('com.ubuntu.Upstart',
inst_path)
inst_name = inst_obj.Get('com.ubuntu.Upstart0_6.Instance',
'name', dbus_interface=PROPERTIES_IFACE)
if inst_name:
svclist.append(job_name + '/' + inst_name)
# if there is no instance name, there's probably only one
else:
svclist.append(job_name)
# no running instances
else:
svclist.append(job_name)
return svclist
def get_service(self, name):
# some defaults for values we might not find
info = {
'running': False,
'automatic': False,
'pid': 0,
'starton': Array(signature='s'),
'stopon': Array(signature='s'),
'description': '',
}
job_name, inst_name = self._split_job(name)
# job-level properties
job_obj = self.bus.get_object('com.ubuntu.Upstart',
self.jobpaths[job_name])
props = job_obj.GetAll('com.ubuntu.Upstart0_6.Job',
dbus_interface=PROPERTIES_IFACE)
# starton/stopon
info['file'] = '/etc/init/{0}.conf'.format(job_name)
try:
with open(info['file']) as conf:
starton = self._parse_conf(conf, 'start on')
stopon = self._parse_conf(conf, 'stop on')
info['starton'] += self._extract_events(starton)
info['stopon'] += self._extract_events(stopon)
# automatic if starton isn't commented out
info['automatic'] = (starton[0] != '#')
except:
return info
# running state: check the instance(s)
inst_obj, inst_props = self._get_inst(job_name, inst_name)
if inst_obj:
info['running'] = (inst_props['state'] == 'running')
if inst_props['processes']:
info['pid'] = inst_props['processes'][0][1]
# differentiate instances in descriptions
if inst_name and 'description' in props:
props['description'] += " ({0})".format(inst_name)
info.update(props)
return info
def start_service(self, name):
"""
If a job is given, try to start its instance first if it has one.
If it doesn't have one, start via job.
If an instance is given, start it directly.
"""
job_name, inst_name = self._split_job(name)
# no instances, start the job
if not self.instpaths[self.jobpaths[job_name]]:
job_obj = self.bus.get_object('com.ubuntu.Upstart',
self.jobpaths[job_name])
job = Interface(job_obj, 'com.ubuntu.Upstart0_6.Job')
job.Start([], True)
# one or more instances available
else:
inst_obj, inst_props = self._get_inst(job_name, inst_name)
inst_obj.Start(True, dbus_interface='com.ubuntu.Upstart0_6.Instance')
# reload
self.get_all_services()
def stop_service(self, name):
"""Find the appropritate job instance and stop it."""
job_name, inst_name = self._split_job(name)
inst_obj, inst_props = self._get_inst(job_name, inst_name)
inst_obj.Stop(True, dbus_interface='com.ubuntu.Upstart0_6.Instance')
# reload
self.get_all_services()
def set_service_automatic(self, name, auto):
job_name, inst_name = self._split_job(name)
with open('/etc/init/{0}.conf'.format(job_name)) as conf:
self._set_automatic(conf, auto)
def _split_job(self, name):
"""Return (job_name, inst_name) from name."""
if '/' in name:
job_name, inst_name = name.split('/', 1)
else:
job_name = name
inst_name = None
return (job_name, inst_name)
def _get_inst(self, job_name, inst_name):
"""Return (inst_obj, inst_props) matching job_name & inst_name."""
paths = self.instpaths[self.jobpaths[job_name]]
if not paths:
return (None, None)
for inst_path in paths:
inst_obj = self.bus.get_object('com.ubuntu.Upstart', inst_path)
inst_props = inst_obj.GetAll('com.ubuntu.Upstart0_6.Instance',
dbus_interface=PROPERTIES_IFACE)
if inst_props['name'] == inst_name:
break
return (inst_obj, inst_props)
def _set_automatic(self, conf, automatic=True):
"""Comment/uncomment a job conf file's start on line. Closes conf."""
newname = '{0}.new'.format(conf.name)
with open(newname, 'w') as new:
for line in conf:
# if we find a start on line
pos = line.find('start on')
if pos >= 0 and pos <= 2:
starton = '\n' + self._parse_conf(conf, 'start on')
# enabling
if automatic:
starton = starton.rstrip().replace('\n#', '\n')
# disabling
else:
starton = starton.rstrip().replace('\n', '\n#')
new.write(starton.lstrip() + '\n')
continue
new.write(line)
conf.close()
rename(conf.name, '{0}~'.format(conf.name))
rename(newname, conf.name)
def _parse_conf(self, conf, find):
"""
Parse file 'conf' for text 'find' and return the value.
Useful for grabbing the full contents of a start/stop on line.
"""
conf.seek(0)
reading = False
data = ""
paren = 0
for line in conf:
# could be at pos 1 or 2 if line is commented out
pos = line.find(find)
if pos >= 0 and pos <= 2:
reading = True
if reading:
data += line
paren += line.count('(') - line.count(')')
if not paren:
break
return data
def _extract_events(self, data):
"""
Grab events present in a text string (ie, a start/stop on line).
An event could be a runlevel or a starting/stopping string.
"""
events = []
keywords = ('starting', 'stopping', 'started', 'stopped', 'runlevel')
words = [d.strip(' ()') for d in data.split()]
i = 0
for w in words:
if w in keywords:
if w == 'runlevel':
try:
levels = words[i+1].strip('[]')
except:
levels = ''
if levels and levels[0] == '!':
events.append('not runlevels {0}'.format(' '.join(levels[1:])))
else:
events.append('runlevels {0}'.format(' '.join(levels)))
else:
events.append('{0} {1}'.format(w, words[i+1]))
i += 1
return events
class SystemdService(Debug):
"""Handles service request messages to systemd"""
ACTUATOR_NAME = "SystemdService"
@staticmethod
def name():
""" @return: name of the module."""
return SystemdService.ACTUATOR_NAME
def __init__(self):
super(SystemdService, self).__init__()
# Use d-bus to communicate with systemd
# Described at: http://www.freedesktop.org/wiki/Software/systemd/dbus/
# Obtain an instance of d-bus to communicate with systemd
self._bus = SystemBus()
# Obtain a manager interface to d-bus for communications with systemd
systemd = self._bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
self._manager = Interface(
systemd, dbus_interface='org.freedesktop.systemd1.Manager')
# Subscribe to signal changes
self._manager.Subscribe()
# create service cls obj.
self._service = DbusServiceHandler()
def perform_request(self, jsonMsg):
"""Performs the service request"""
self._check_debug(jsonMsg)
# Parse out the service name and request to perform on it
if jsonMsg.get("actuator_request_type").get("service_controller") \
is not None:
self._service_name = jsonMsg.get("actuator_request_type").\
get("service_controller").get("service_name")
self._service_request = jsonMsg.get("actuator_request_type").\
get("service_controller").get("service_request")
else:
self._service_name = jsonMsg.get("actuator_request_type").\
get("service_watchdog_controller").get("service_name")
self._service_request = jsonMsg.get("actuator_request_type").\
get("service_watchdog_controller").get("service_request")
logger.debug("perform_request, service_name: %s, service_request: %s" % \
(self._service_name, self._service_request))
try:
# Load the systemd unit for the service
systemd_unit = self._manager.LoadUnit(self._service_name)
# Get a proxy to systemd for accessing properties of units
self._proxy = self._bus.get_object("org.freedesktop.systemd1", \
str(systemd_unit))
# The returned result of the desired action
result = {}
is_err_response = False
if self._service_request in ['restart', 'start']:
# Before restart/start the service, check service state.
# If it is not active or activating then only process
# restart/start request.
service_state = self._service.get_state(self._service_name)
state = service_state.state
if state not in ['active', 'activating']:
if self._service_request == "restart":
self._service.restart(self._service_name)
elif self._service_request == "start":
self._service.start(self._service_name)
# Ensure we get an "active" state and not "activating"
service_state = self._service.get_state(self._service_name)
state = service_state.state
max_wait = 0
while state != "active":
logger.debug(
"%s status is activating, needs 'active' "
"state after %s request has been processed, retrying"
% (self._service_name, self._service_request))
time.sleep(1)
max_wait += 1
if max_wait > 20:
logger.debug("maximum wait - %s seconds, for "
"service restart reached." % max_wait)
break
service_state = self._service.get_state(
self._service_name)
state = service_state.state
else:
is_err_response = True
err_msg = (
"Can not process %s request, for %s, as service "
"is already in %s state." %
(self._service_request, self._service_name, state))
logger.error(err_msg)
return (self._service_name, err_msg, is_err_response)
elif self._service_request == "stop":
self._service.stop(self._service_name)
elif self._service_request == "status":
# Return the status below
service_status = self._service.get_state(self._service_name)
# TODO: Use cortx.utils Service class methods for
# enable/disable services.
elif self._service_request == "enable":
service_list = []
service_list.append(self._service_name)
# EnableUnitFiles() function takes second argument as boolean.
# 'True' will enable a service for runtime only(creates symlink
# in /run/.. directory) 'False' will enable a service
# persistently (creates symlink in /etc/.. directory)
_, dbus_result = self._manager.EnableUnitFiles(
service_list, False, True)
res = parse_enable_disable_dbus_result(dbus_result)
result.update(res)
logger.debug("perform_request, result for enable request: "
"result: %s" % (result))
elif self._service_request == "disable":
service_list = []
service_list.append(self._service_name)
# DisableUnitFiles() function takes second argument as boolean.
# 'True' will disable a service for runtime only(removes symlink
# from /run/.. directory) 'False' will disable a service
# persistently(removes symlink from /etc/.. directory)
dbus_result = self._manager.DisableUnitFiles(
service_list, False)
res = parse_enable_disable_dbus_result(dbus_result)
result.update(res)
logger.debug(
"perform_request, result for disable request: %s" % result)
else:
logger.error("perform_request, Unknown service request - %s "
"for service - %s" %
(self._service_request, self._service_name))
is_err_response = True
return (self._service_name, "Unknown service request",
is_err_response)
except debus_exceptions.DBusException as error:
is_err_response = True
logger.exception("DBus Exception: %r" % error)
return (self._service_name, str(error), is_err_response)
except Exception as ae:
logger.exception("SystemD Exception: %r" % ae)
is_err_response = True
return (self._service_name, str(ae), is_err_response)
# Give the unit some time to finish starting/stopping to get final status
time.sleep(5)
# Get the current status of the process and return it back:
service_status = self._service.get_state(self._service_name)
pid = service_status.pid
state = service_status.state
substate = service_status.substate
status = self._service.is_enabled(self._service_name)
uptime = get_service_uptime(self._service_name)
# Parse dbus output to fetch command line path with args.
command_line = service_status.command_line_path
command_line_path_with_args = []
for field in list(command_line[0][1]):
command_line_path_with_args.append(str(field))
result["pid"] = pid
result["state"] = state
result["substate"] = substate
result["status"] = status
result["uptime"] = uptime
result["command_line_path"] = command_line_path_with_args
logger.debug("perform_request, state: %s, substate: %s" %
(str(state), str(substate)))
return (self._service_name, result, is_err_response)
logging.info("deleting pre snapshot")
snapper.DeleteSnapshots("root", [self.num1])
logging.debug("deleted pre snapshot %d" % self.num1)
except DBusException as e:
logging.error("deleting snapshot failed:")
logging.error(" %s", e)
self.ack()
def PLUGINEND(self, headers, body):
logging.info("PLUGINEND")
self.ack()
config = Config()
try:
bus = SystemBus()
snapper = Interface(bus.get_object('org.opensuse.Snapper',
'/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logging.error("connect to snapperd failed:")
logging.error(" %s", e)
sys.exit(1)
plugin = MyPlugin()
plugin.main()
def PLUGINEND(self, headers, body):
logging.info("PLUGINEND")
self.ack()
if "DISABLE_SNAPPER_ZYPP_PLUGIN" in environ:
logging.info("$DISABLE_SNAPPER_ZYPP_PLUGIN is set - disabling snapper-zypp-plugin")
# a dummy Plugin is needed
plugin = Plugin()
plugin.main()
else:
config = Config()
try:
bus = SystemBus()
snapper = Interface(bus.get_object('org.opensuse.Snapper', '/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logging.error("connect to snapperd failed:")
logging.error(" %s", e)
sys.exit(1)
plugin = MyPlugin()
plugin.main()
class UsbguardDbusInterface:
def __init__(self) -> None:
DBusGMainLoop(set_as_default=True)
self._bus = SystemBus()
self._policy_proxy = self._bus.get_object(_BUS_NAME, _POLICY_PATH)
self._policy = Interface(self._policy_proxy, _POLICY_IFACE_NAME)
self._devices_proxy = self._bus.get_object(_BUS_NAME, _DEVICES_PATH)
self._devices = Interface(self._devices_proxy, _DEVICES_IFACE_NAME)
self._devices.connect_to_signal(
'DevicePresenceChanged', self._on_device_presence_changed)
self._devices.connect_to_signal(
'DevicePolicyChanged', self._on_device_policy_changed)
self._callbacks: Dict[CallbackEventType, Set[Callable]] = \
{e: set() for e in CallbackEventType}
def register_callback(
self,
event_type: CallbackEventType,
callback: Callable
) -> None:
callbacks = self._callbacks[event_type]
if callback in callbacks:
raise Exception(f'callback {callback} already registered')
self._callbacks[event_type].add(callback)
def unregister_callback(
self,
event_type: CallbackEventType,
callback: Callable
) -> None:
self._callbacks[event_type].remove(callback)
def list_devices(self, query: str = 'match') -> List[Device]:
response: Array[Struct[UInt32, String]] = \
self._devices.listDevices(query)
return [
Device(
device_id=int(device_struct[0]),
rule=RuleParser.parse(str(device_struct[1])))
for device_struct in response
]
def apply_device_policy(
self,
device_id: int,
target: RuleTarget,
permanent: bool
) -> Optional[int]:
response: UInt32 = self._devices.applyDevicePolicy(
device_id,
_TARGET_TO_INT[target],
permanent)
return int(response) if permanent else None
def _on_device_presence_changed(
self,
device_id: UInt32,
event: UInt32,
target: UInt32,
device_rule: String,
_attributes: Dictionary
) -> None:
"""
:param device_id: Device id of the device.
:param event: Type of the presence change event in numerical form.
0 = Present, 1 = Insert, 2 = Update, 3 = Remove.
:param target: The current authorization target of the device in
numerical form.
:param device_rule: Device specific rule.
:param _attributes: A dictionary of device attributes and their values.
"""
try:
resolved_event = EventPresenceChangeType(int(event))
resolved_target = int(target)
device = Device(
device_id=int(device_id),
rule=RuleParser.parse(device_rule))
except Exception as error:
event_type = CallbackEventType.DEVICE_PRESENCE_CHANGED_ERROR
for callback in self._callbacks[event_type]:
callback(error)
return
event_type = CallbackEventType.DEVICE_PRESENCE_CHANGED
for callback in self._callbacks[event_type]:
callback(device, resolved_event, resolved_target)
def _on_device_policy_changed(
self,
device_id: UInt32,
target_old: UInt32,
target_new: UInt32,
device_rule: String,
rule_id: UInt32,
_attributes: Dictionary
) -> None:
"""
:param device_id: Device id of the device.
:param target_old: Previous authorization target in numerical form.
:param target_new: Current authorization target in numerical form.
:param device_rule: Device specific rule.
:param rule_id: A rule id of the matched rule. Otherwise a reserved
rule id value is used.
:param _attributes: A dictionary of device attributes and their values.
"""
try:
resolved_target_old = _INT_TO_TARGET[int(target_old)]
resolved_target_new = _INT_TO_TARGET[int(target_new)]
resolved_rule_id = int(rule_id)
device = Device(
device_id=int(device_id),
rule=RuleParser.parse(device_rule))
except Exception as error:
event_type = CallbackEventType.DEVICE_POLICY_CHANGED_ERROR
for callback in self._callbacks[event_type]:
callback(error)
return
event_type = CallbackEventType.DEVICE_POLICY_CHANGED
for callback in self._callbacks[event_type]:
callback(
device,
resolved_target_old,
resolved_target_new,
resolved_rule_id)
class RemoteJob:
"""
A proxy object for a single job. DBus properties are accessible via
regular Python properties.
"""
def __init__(self, name, path):
self.name = name
self.path = path
self.props = {}
self.protected = False
self._connect()
def _connect(self):
self.bus = SystemBus()
self.obj = self.bus.get_object('com.ubuntu.JobService', self.path)
self.interface = Interface(self.obj, 'com.ubuntu.JobService.Job')
def __getattr__(self, name):
if not self.props:
def call():
self.props = self.obj.GetAll('com.ubuntu.JobService.Job',
dbus_interface=PROPERTIES_IFACE)
retry(self._connect, call)
# override description
if name == 'description':
alt = alt_description(self.name)
if alt:
return alt
return self.props[name]
def start(self, reply_handler=None, error_handler=None):
def call(): self.interface.Start(timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {} # states may change
def stop(self, reply_handler=None, error_handler=None):
def call(): self.interface.Stop(timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {}
def enable(self, reply_handler=None, error_handler=None):
def call(): self.interface.SetAutomatic(True, timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {}
def disable(self, reply_handler=None, error_handler=None):
def call(): self.interface.SetAutomatic(False, timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {}
def get_settings(self, reply_handler=None, error_handler=None):
if '_settings' in self.props:
return self.props['_settings']
def call():
self.props['_settings'] = self.interface.GetSettings(LANG,
timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
return self.props['_settings']
return retry(self._connect, call)
def set_settings(self, settings, reply_handler=None, error_handler=None):
def call(): self.interface.SetSettings(settings, timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {}
from threading import Thread
from gi.repository import Gtk, Gio, Gdk, GObject, GdkPixbuf
from random import randint
from dbus.mainloop.glib import DBusGMainLoop
from gi.repository import Notify
DBusGMainLoop(set_as_default = True)
from dbus import SystemBus, SessionBus, Interface
import gobject
currentDirectory = os.path.dirname(os.path.abspath(__file__))
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1'
, '/org/freedesktop/systemd1')
class LittleServerExecuterApp(Gtk.Application):
""" Application Id """
appId = "org.pandahugmonster.lse"
""" Version string """
version = "0.4.3"
""" Settings file """
settingsFile = "settings.json"
""" SystemD Manager """
manager = None
""" Application Pid Number """
class ServiceMonitor(SensorThread, InternalMsgQ):
""" Sensor to monitor state change events of services. """
SENSOR_NAME = "ServiceMonitor"
PRIORITY = 2
# Section and keys in configuration file
SERVICEMONITOR = SENSOR_NAME.upper()
MONITORED_SERVICES = 'monitored_services'
THREAD_SLEEP = 'thread_sleep'
POLLING_FREQUENCY = 'polling_frequency'
# Dependency list
DEPENDENCIES = {"plugins": ["SeviceMsgHandler"]}
RESOURCE_TYPE = "node:sw:os:service"
@staticmethod
def name():
"""@return: name of the module."""
return ServiceMonitor.SENSOR_NAME
def __init__(self):
"""Initialize the relevant datastructures."""
super(ServiceMonitor, self).__init__(self.SENSOR_NAME,
self.PRIORITY)
self.services_to_monitor = set(Conf.get(
SSPL_CONF, f"{self.SERVICEMONITOR}>{self.MONITORED_SERVICES}", []))
self.services = {}
self.thread_sleep = int(Conf.get(SSPL_CONF,
f"{self.SERVICEMONITOR}>{self.THREAD_SLEEP}",
"1"))
self.polling_frequency = int(Conf.get(SSPL_CONF,
f"{self.SERVICEMONITOR}>{self.POLLING_FREQUENCY}",
"30"))
def read_data(self):
"""Return the dict of service status."""
return self.service_status
def initialize(self, conf_reader, msgQlist, product):
"""initialize configuration reader and internal msg queues."""
# Initialize ScheduledMonitorThread and InternalMsgQ
super(ServiceMonitor, self).initialize(conf_reader)
# Initialize internal message queues for this module
super(ServiceMonitor, self).initialize_msgQ(msgQlist)
self.iem = Iem()
self.iem.check_exsisting_fault_iems()
self.KAFKA = self.iem.EVENT_CODE["KAFKA_ACTIVE"][1]
self.initialize_dbus()
for service in self.services_to_monitor:
self.initialize_service(service)
self.subscribe_unit_file_changed_signal()
return True
def run(self):
try:
logger.info(f"Monitoring Services : {self.services.keys()}")
if not self.services_to_monitor:
logger.info(
"No service to monitor, shutting down {}".format(
self.name()))
self.shutdown()
# WHILE LOOP FUNCTION : every second we check for
# properties change event if any generated (using context
# iteration) and after a delay of polling frequency we
# check for non_active processes.
iterations = 0
non_active_check = int(
self.polling_frequency / self.thread_sleep) or 1
while self.is_running():
# At interval of 'thread_sleep' check for events occurred for
# services and process them
self.process_events()
self.process_alerts()
if not iterations % non_active_check:
# Initialize errored service again
for service in self.services_to_monitor - set(
self.services.keys()):
self.initialize_service(service)
for service in Service.monitoring_disabled.copy():
self.services[service].new_unit_state(EnabledState)
# Check for services in intermediate state(not active)
self.check_nonactive_services()
self.check_active_services()
time.sleep(self.thread_sleep)
iterations += 1
logger.info("ServiceMonitor gracefully breaking out " +
"of dbus Loop, not restarting.")
except GLib.Error as err:
raise ThreadException(self.SENSOR_NAME,
"Ungrecefully breaking out of"
"GLib.MainLoop() with error: %s"
% err)
except DBusException as err:
raise ThreadException(self.SENSOR_NAME,
"Ungracefully breaking out of dbus loop"
"with error: %s" % err)
except Exception as err:
raise ThreadException(self.SENSOR_NAME,
"Ungracefully breaking out of"
"ServiceMonitor:run() with error: %s" % err)
def initialize_service(self, service_name):
try:
unit = self._bus.get_object(SYSTEMD_BUS,
self._manager.LoadUnit(service_name))
if Service.cache_exists(service_name):
service = Service.from_cache(service_name, unit)
else:
service = Service(unit)
service.handle_unit_state_change()
self.services[service_name] = service
except DBusException:
logger.error("Error: {} Failed to initialize service {},"
"initialization will be retried in"
"{} seconds".format(DBusException, service_name,
self.polling_frequency))
def subscribe_unit_file_changed_signal(self):
self._manager.connect_to_signal('UnitFilesChanged',
self.unit_file_state_change_handler,
dbus_interface=MANAGER_IFACE)
@staticmethod
def subscribe_properties_changed_signal(service):
service.properties_changed_signal = Interface(
object=service.unit,
dbus_interface=MANAGER_IFACE).connect_to_signal(
'PropertiesChanged', service.properties_changed_handler,
PROPERTIES_IFACE)
def unit_file_state_change_handler(self):
for service in self.services.values():
service.handle_unit_state_change()
def process_events(self):
while self.context.pending():
self.context.iteration(False)
def process_alerts(self):
while not Service.alerts.empty():
message = Service.alerts.get()
self.raise_alert(message)
def initialize_dbus(self):
DBusGMainLoop(set_as_default=True)
# Initialize SystemBus and get Manager Interface
self._bus = SystemBus()
systemd = self._bus.get_object(SYSTEMD_BUS,
"/org/freedesktop/systemd1")
self._manager = Interface(systemd,
dbus_interface=MANAGER_IFACE)
# Retrieve the main loop which will be called in the run method
self._loop = GLib.MainLoop()
self.context = self._loop.get_context()
def check_nonactive_services(self):
"""
Monitor non-active Services.
Raise FAULT Alert if any of the not-active services has exceeded
the threshold time for inactivity.
"""
for service in Service.non_active.copy():
if self.services[service].is_nonactive_for_threshold_time():
self.services[service].new_service_state(FailedState)
self.raise_alert(self.get_alert(self.services[service],
InactiveAlert))
def check_active_services(self):
"""
Monitor active services.
Raise fault resolved alert for active services
if service stays in active state for threshhold time.
"""
for service in Service.active_services.copy():
if self.services[service].is_active_for_threshold_time():
self.raise_alert(
self.get_alert(self.services[service], ResolvedAlert))
Service.active_services.discard(service)
def raise_iem(self, service, alert_type):
"""Raise iem alert for kafka service."""
if service == "kafka.service" and alert_type == "fault":
self.iem.iem_fault("KAFKA_NOT_ACTIVE")
if (self.KAFKA not in self.iem.fault_iems):
self.iem.fault_iems.append(self.KAFKA)
elif (service == "kafka.service" and alert_type == "fault_resolved"
and self.KAFKA in self.iem.fault_iems):
self.iem.iem_fault_resolved("KAFKA_ACTIVE")
self.iem.fault_iems.remove(self.KAFKA)
@classmethod
def get_alert(cls, service, alert):
if service.state == "active":
description = alert.description.format(
service.name, service.state, service.active_threshold)
else:
description = alert.description.format(
service.name, service.state, service.nonactive_threshold)
return {
"sensor_request_type": {
"service_status_alert": {
"host_id": socket.getfqdn(),
"severity": SeverityReader().map_severity(
alert.alert_type),
"alert_id": get_alert_id(str(int(time.time()))),
"alert_type": alert.alert_type,
"info": {
"resource_type": cls.RESOURCE_TYPE,
"resource_id": service.name,
"event_time": str(int(time.time())),
"description": description,
"impact": alert.impact.format(service.name),
"recommendation": alert.recommendation,
},
"specific_info": {
"service_name": service.name,
"previous_state": service.previous_state,
"state": service.state,
"previous_substate": service.previous_substate,
"substate": service.substate,
"previous_pid": service.previous_pid,
"pid": service.pid,
}
}
}
}
def raise_alert(self, message):
service = message["sensor_request_type"]["service_status_alert"][
"info"]["resource_id"]
alert_type = message["sensor_request_type"]["service_status_alert"][
"alert_type"]
self.raise_iem(service, alert_type)
self._write_internal_msgQ(ServiceMsgHandler.name(), message)
self.services[service].dump_to_cache()
def suspend(self):
"""Suspend the module thread. It should be non-blocking."""
super(ServiceMonitor, self).suspend()
self._suspended = True
def resume(self):
"""Resumes the module thread. It should be non-blocking."""
super(ServiceMonitor, self).resume()
self._suspended = False
def shutdown(self):
"""Clean up scheduler queue and gracefully shutdown thread."""
super(ServiceMonitor, self).shutdown()
class DbusPhoneHomeClient:
expected_signal_hostname = None
mainloop = None
data_received = None
logger = None
def __init__(self, logger):
"""Inits the DBus client and creates a new System bus.
:param logger: Logger
:return:
"""
self.logger = logger
DbusPhoneHomeClient.logger = logger
self.logger.debug("Attaching to a main loop")
DBusGMainLoop(set_as_default=True)
self.logger.debug("Creating session in SystemBus")
self.bus = SystemBus()
@staticmethod
def timeout(mainloop, logger, *args):
"""Timeout function for DBus MainLoop.
:param mainloop: Loop manager (MainLoop)
:param logger: Logger
:param args: Rest of arguments
:return: False. The function is called repeatedly until it returns FALSE,
at which point the timeout is automatically destroyed and the function will not be called again.
"""
logger.debug("Timed out!. Aborting the wait.")
mainloop.quit()
return False
@staticmethod
def phonehome_signal_handler(phonehome_http_data):
"""Handler for `PHONEHOME_SIGNAL`.
:param phonehome_http_data: Data the VM emitted in the signal. If matches the expected one, main loop finishes.
:return: None
"""
DbusPhoneHomeClient.logger.debug("Data received from PhoneHome Server: '%s'",
phonehome_http_data.encode('base64', 'strict').replace('\n', ' '))
hostname = re.match(".*hostname=([\w-]*)", phonehome_http_data)
hostname = hostname.group(1) if hostname is not None else hostname
if DbusPhoneHomeClient.expected_signal_hostname == hostname:
DbusPhoneHomeClient.logger.debug("Received hostname: '%s'",
DbusPhoneHomeClient.expected_signal_hostname)
DbusPhoneHomeClient.data_received = phonehome_http_data
DbusPhoneHomeClient.mainloop.quit()
else:
DbusPhoneHomeClient.logger.debug(log_message_data_out_of_sequence)
@staticmethod
def phonehome_signal_handler_metadata(phonehome_http_data, hostname):
"""Handler for `PHONEHOME_METADATA_SIGNAL`.
:param phonehome_http_data: Data the VM emitted in the signal.
:param hostname: VM hostname. If matches the expected one, main loop finishes.
:return: None
"""
DbusPhoneHomeClient.logger.debug("Data received from PhoneHome Server (Hostname): '%s'",
hostname.encode('base64', 'strict').replace('\n', ' '))
if DbusPhoneHomeClient.expected_signal_hostname == hostname:
DbusPhoneHomeClient.logger.debug("Received hostname: '%s'", hostname)
DbusPhoneHomeClient.data_received = phonehome_http_data
DbusPhoneHomeClient.mainloop.quit()
else:
DbusPhoneHomeClient.logger.debug(log_message_data_out_of_sequence)
def connect_and_wait_for_phonehome_signal(self, bus_name, object_path, phonehome_signal, data_expected):
"""Connects to Bus and gets the published object (PhoneHome DBus object).
:param bus_name: str
A bus name (either the unique name or a well-known name)
of the application owning the object. The keyword argument
named_service is a deprecated alias for this. PhoneHome DBus service.
:param object_path: str
The object path of the desired PhoneHome Object.
:param data_expected: The PhoneHome client will wait for `PHONEHOME_SIGNAL` with this data value.
When received, main loop will be finished and data received from the signal will be returned.
:return: None if signal has not been received after the timewait; Else, the content received in the signal
"""
DbusPhoneHomeClient.data_received = None
self.logger.debug("Connecting to PhoneHome DBus Service in bus '%s' and getting PhoneHome object "
"with path '%s'", bus_name, object_path)
DbusPhoneHomeClient.expected_signal_hostname = data_expected
try:
object = self.bus.get_object(bus_name, object_path)
phonehome_interface = dbus.Interface(object, bus_name)
except DBusException as e:
self.logger.error("PhoneHome bus or object not found. Please check the PhoneHome services. %s", str(e))
return False
# Connect to signal
self.logger.debug("Connecting to signal '%s'", phonehome_signal)
if phonehome_signal == PHONEHOME_SIGNAL:
phonehome_interface.connect_to_signal(phonehome_signal, self.phonehome_signal_handler)
elif phonehome_signal == PHONEHOME_METADATA_SIGNAL:
phonehome_interface.connect_to_signal(PHONEHOME_METADATA_SIGNAL, self.phonehome_signal_handler_metadata)
# Attach to a main loop
self.logger.debug("Creating main loop")
DbusPhoneHomeClient.mainloop = gobject.MainLoop()
# Setup timeout and start main loop
phonehome_timeout = PHONEHOME_TIMEOUT * 1000
self.logger.debug("Setting time out to: %d", phonehome_timeout)
gobject.timeout_add(phonehome_timeout, self.timeout, DbusPhoneHomeClient.mainloop, self.logger, priority=100)
self.logger.debug("Waiting for signal '%s' with value or header 'hostname=%s' ."
" Timeout set to %s seconds", phonehome_signal, data_expected, PHONEHOME_TIMEOUT)
DbusPhoneHomeClient.mainloop.run()
self.logger.debug("Dbus PhoneHome Service stopped")
return DbusPhoneHomeClient.data_received
