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 main():
print(
"starting to monitor your spotify tracks, make sure you start the spotify client before you run this program"
)
while True:
try:
session_bus = SessionBus()
bus_data = ("org.mpris.MediaPlayer2.spotify",
"/org/mpris/MediaPlayer2")
spotify_bus = session_bus.get_object(*bus_data)
interface = Interface(spotify_bus,
"org.freedesktop.DBus.Properties")
metadata = interface.Get("org.mpris.MediaPlayer2.Player",
"Metadata")
status = str(
interface.Get("org.mpris.MediaPlayer2.Player",
"PlaybackStatus"))
is_playing = False
if status == "Playing":
is_playing = True
data = {"artist": None, "song": None, "album": None}
artist_data = metadata.get("xesam:albumArtist")
artist = str(next(iter(artist_data)))
song_name = str(metadata.get("xesam:title"))
album = str(metadata.get("xesam:album"))
thread = Thread(target=handle_track,
args=(
song_name,
album,
artist,
is_playing,
prev_track,
))
thread.start()
# if is_playing:
# print('{} - {}'.format(song_name, artist))
sleep(1)
except Exception as e:
print("exception occurred")
print(e)
sleep(1)
print('exiting? wtf?')
def _get_rhythmbox_player(self):
# Para controlar el reproductor, usaremos la interfaz estándar que
# define FreeDestkop.org, es decir MPRIS
# Información de D-Bus para Rhythmbox usando interfaz estándar MPRIS
rhythmbox_bus_name = 'org.mpris.MediaPlayer2.rhythmbox'
rhythmbox_object_path = '/org/mpris/MediaPlayer2'
rhythmbox_dbus_interface_player = 'org.mpris.MediaPlayer2.Player'
rhythmbox_dbus_interface_playlists = 'org.mpris.MediaPlayer2.Playlists'
# Se obtiene el objeto remoto de Rhythmbox desde el bus de sesión
rhythmbox_object = self._session_bus.get_object(
rhythmbox_bus_name, rhythmbox_object_path)
# Se obtiene la interfaz Player del objeto remoto del reproductor
rhythmbox_player = Interface(rhythmbox_object,
rhythmbox_dbus_interface_player)
# Se obtiene la interfaz Playerlists del objeto remoto del reproductor
rhythmbox_playlists = Interface(rhythmbox_object,
rhythmbox_dbus_interface_playlists)
# Se necesita obtener la cantidad de listas de reproducción contenidas
# en el reproductor. Eso lo devuelve la propiedad "PlaylistCount"
playlists_properties = Interface(rhythmbox_object,
'org.freedesktop.DBus.Properties')
pl_count = playlists_properties.Get(rhythmbox_dbus_interface_playlists,
'PlaylistCount')
return rhythmbox_player, rhythmbox_playlists, pl_count
def mpris(self):
from dbus import Interface
player = self.NPCommand.get_text()
dbus_mpris_service = u'org.mpris.MediaPlayer2.'
dbus_mpris_player_service = u'org.mpris.MediaPlayer2.Player'
dbus_mpris_path = u'/org/mpris/MediaPlayer2'
dbus_property = u'org.freedesktop.DBus.Properties'
if not player:
names = self.bus.list_names()
players = []
for name in names:
if name.startswith(dbus_mpris_service):
players.append(name[len(dbus_mpris_service):])
if not players:
self.frame.logMessage(_("Could not find a suitable MPRIS player."))
return None
player = players[0]
if len(players) > 1:
self.frame.logMessage(_("Found multiple MPRIS players: %(players)s. Using: %(player)s") % {'players': players, 'player': player})
else:
self.frame.logMessage(_("Auto-detected MPRIS player: %s.") % player)
try:
player_obj = self.bus.get_object(dbus_mpris_service + player, dbus_mpris_path)
player_property_obj = Interface(player_obj, dbus_interface=dbus_property)
metadata = player_property_obj.Get(dbus_mpris_player_service, "Metadata")
except Exception, exception:
self.frame.logMessage(_("Something went wrong while querying %(player)s: %(exception)s") % {'player': player, 'exception': exception})
return None
class DBusProperties(object):
"""
Dbus property map abstraction.
Wraps properties of a DBus interface on a DBus object as attributes.
"""
def __init__(self, dbus_object, interface):
"""
Initialize a proxy object with standard DBus property interface.
:param dbus.proxies.ProxyObject dbus_object: accessed object
:param str interface: accessed interface name
"""
self.__proxy = Interface(
dbus_object, dbus_interface='org.freedesktop.DBus.Properties')
self.__interface = interface
def __getattr__(self, property):
"""
Retrieve the property via the DBus proxy.
:param str property: name of the dbus property
:returns: the property
"""
return self.__proxy.Get(self.__interface, property)
def get_service_status(self, service=None, unit=None):
"""Returns tuple of unit, service name, state, substate and pid."""
if not unit:
unit = self._bus.get_object('org.freedesktop.systemd1',\
self._manager.LoadUnit(service))
Iunit = Interface(unit,
dbus_interface='org.freedesktop.DBus.Properties')
if not service:
service = str(Iunit.Get('org.freedesktop.systemd1.Unit', 'Id'))
state = str(Iunit.Get('org.freedesktop.systemd1.Unit', 'ActiveState'))
substate = str(Iunit.Get('org.freedesktop.systemd1.Unit', 'SubState'))
pid = str(Iunit.Get('org.freedesktop.systemd1.Service', 'ExecMainPID'))
return (unit, service, state, substate, pid)
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 _get_device_mount_path(self, device_object_path):
# Información necesaria para procesar los dispositivos de UDisks
udisks_bus_name = 'org.freedesktop.UDisks'
device_dbus_interface = 'org.freedesktop.UDisks.Device'
# Se obtiene el objeto remoto del dispositivo insertado a través
# de la conexión al bus de sistema del demonio UDisks.
device_object = self._system_bus.get_object(udisks_bus_name,
device_object_path)
# Para acceder a las propiedades de un objeto FreeDesktop.org
# establece una interfaz estándar: 'org.freedesktop.DBus.Properties'
device = Interface(device_object, 'org.freedesktop.DBus.Properties')
# Con el método 'Get' de la interfaz 'org.freedesktop.DBus.Properties'
# se obtiene el valor de una propiedad en una interfaz determinada.
# La propiedad 'DeviceFile' devuelve el archivo de dispositivo en /dev
# En nuestro caso no lo necesitamos, se pone a modo de enseñanza.
dev_file = device.Get(device_dbus_interface, 'DeviceFile')
# La propiedad 'DeviceIsMounted' devuelve si está montado
is_mounted = device.Get(device_dbus_interface, 'DeviceIsMounted')
print u'¿Está montado %s? : %s' % (dev_file, str(bool(is_mounted)))
# Si el dispositivo ya fue escaneado y no está montado, significa que
# recién se desmontó, hay que olvidarlo.
mount_path = None
if device_object_path in self._already_scanned:
if not is_mounted:
del self._already_scanned[device_object_path]
# Si no ha sido escaneado y está montado, significa que recién se
# ha montado y hay que escanearlo y recordarlo, se devuelve el punto
# de montaje. En otros casos, no se hace nada y no se devuelve nada.
elif is_mounted:
self._already_scanned[device_object_path] = True
# La propiedad 'DeviceMountPaths' devuelve todos los directorios
# del sistema de archivos donde se ha montado este dispositivo.
mount_paths = device.Get(device_dbus_interface, 'DeviceMountPaths')
mount_path = mount_paths[0]
return mount_path
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')
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 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
class DBusProperties(object):
"""
Dbus property map abstraction.
Properties of the object can be accessed as attributes.
"""
def __init__(self, dbus_object, interface):
"""Initialize a proxy object with standard DBus property interface."""
self.__proxy = Interface(
dbus_object, dbus_interface='org.freedesktop.DBus.Properties')
self.__interface = interface
def __getattr__(self, property):
"""Retrieve the property via the DBus proxy."""
return self.__proxy.Get(self.__interface, property)
class ServiceObject:
def __init__(self, service, intf, obj_path):
obj = SystemBus().get_object(service, obj_path)
self.intf = Interface(obj, dbus_interface=intf)
self.propi = Interface(obj, dbus_interface='org.freedesktop.DBus.Properties')
def __getattr__(self, name):
# if wrapped dbus intf has it, call it
if isinstance(getattr(self.intf, name, None), collections.Callable):
return getattr(self.intf, name)
def get_property(self, key):
"""Lookup key on interface at path"""
return self.propi.Get(self.intf.dbus_interface, key)
def set_property(self, key, value):
"""Set key to value on interface at path"""
return str(self.propi.Set(self.intf.dbus_interface, key, value))
class Service:
"""
The Service class representing systemd service.
This class use various internals states for managing service state effectively.
"""
alerts = Queue()
non_active = set()
# once fault resolved detected for service, add service name
# into the active_services list.
active_services = set()
monitoring_disabled = set()
def __init__(self, unit):
"""
Initialize Service.
"""
self.unit = unit
self.properties_iface = Interface(self.unit,
dbus_interface=PROPERTIES_IFACE)
self.name = str(self.properties_iface.Get(UNIT_IFACE, 'Id'))
self.state = "N/A"
self.substate = "N/A"
self.pid = "N/A"
self.previous_state = "N/A"
self.previous_substate = "N/A"
self.previous_pid = "N/A"
self.nonactive_enter_timestamp = time.time()
self.active_enter_timestamp = time.time()
self.nonactive_threshold = int(
Conf.get(SSPL_CONF,
f"{ServiceMonitor.name().upper()}>threshold_inactive_time",
'60'))
self.active_threshold = int(Conf.get(SSPL_CONF,
f"{ServiceMonitor.name().upper()}>threshold_active_time",
'30'))
self.properties_changed_signal = None
self._service_state = ActiveState
self._unit_state = None
@property
def is_enabled(self):
if self.properties_iface.Get(UNIT_IFACE, 'UnitFileState'):
return 'disabled' not in self.properties_iface.Get(
UNIT_IFACE, 'UnitFileState')
return False
def is_nonactive_for_threshold_time(self):
return time.time() - self.nonactive_enter_timestamp > self.nonactive_threshold
def is_active_for_threshold_time(self):
return time.time() - self.active_enter_timestamp > self.active_threshold
def new_service_state(self, new_state):
if self._service_state != new_state:
self._service_state = new_state
new_state.enter(self)
def new_unit_state(self, new_state):
if new_state != self._unit_state:
self._unit_state = new_state
new_state.enter(self)
def properties_changed_handler(self, interface, changed_properties,
invalidated_properties):
state = str(self.properties_iface.Get(
UNIT_IFACE, 'ActiveState'))
substate = str(self.properties_iface.Get(
UNIT_IFACE, 'SubState'))
pid = str(self.properties_iface.Get(
SERVICE_IFACE, 'ExecMainPID'))
if state != self.state:
self.previous_state = self.state
self.state = state
if substate != self.substate:
self.previous_substate = self.substate
self.substate = substate
if pid != self.pid:
self.previous_pid = self.pid
self.pid = pid
if self.state != self.previous_state:
if self.state == "active":
if self._service_state is FailedState:
self.new_service_state(ActiveState)
Service.active_services.add(self.name)
if self._service_state is InactiveState:
self.new_service_state(ActiveState)
elif self.state == "failed":
if self._service_state is not FailedState:
Service.alerts.put(
ServiceMonitor.get_alert(self, FailedAlert))
self.new_service_state(FailedState)
else:
# Avoid raising duplicate alerts
if self._service_state != FailedState:
self.new_service_state(InactiveState)
self.dump_to_cache()
def handle_unit_state_change(self):
# TODO: Check if alert needs to be generated for UnitFileState change
if self.is_enabled:
self.new_unit_state(EnabledState)
else:
self.new_unit_state(DisabledState)
@classmethod
def from_cache(cls, service_name, unit):
"""
Initialize service from cache
"""
data = store.get(f"{CACHE_PATH}/{service_name}")
service = cls(unit)
service.new_service_state(data["service_monitor_state"])
service.state = data["service_state"]
service.nonactive_enter_timestamp = data["nonactive_enter_timestamp"]
service.active_enter_timestamp = data["active_enter_timestamp"]
return service
def dump_to_cache(self):
"""
Write service status to cache
"""
data = {
"service_state": self.state,
"service_monitor_state": self._service_state,
"nonactive_enter_timestamp": self.nonactive_enter_timestamp,
"active_enter_timestamp": self.active_enter_timestamp
}
store.put(data, f"{CACHE_PATH}/{self.name}")
@staticmethod
def cache_exists(service_name):
exists, _ = store.exists(f"{CACHE_PATH}/{service_name}")
return exists
def get_dbus_param(properties_interface: dbus.Interface, param_name: str):
return properties_interface.Get('org.mpris.MediaPlayer2.Player',
param_name)
def get_systemd_service_info(self, log, service_name):
"""Get info of specified service using dbus API."""
try:
unit = self._bus.get_object(SYSTEMD_BUS,
self._manager.LoadUnit(service_name))
properties_iface = Interface(unit, dbus_interface=PROPERTIES_IFACE)
except DBusException as err:
logger.error(
log.svc_log(
f"Unable to initialize {service_name} due to {err}"))
return None
path_array = properties_iface.Get(SERVICE_IFACE, 'ExecStart')
try:
command_line_path = str(path_array[0][0])
except IndexError as err:
logger.error(
log.svc_log(
f"Unable to find {service_name} path due to {err}"))
command_line_path = "NA"
is_installed = True if command_line_path != "NA" or 'invalid' in properties_iface.Get(
UNIT_IFACE, 'UnitFileState') else False
uid = str(properties_iface.Get(UNIT_IFACE, 'Id'))
if not is_installed:
health_status = "NA"
health_description = f"Software enabling {uid} is not installed"
recommendation = "NA"
specifics = [{
"service_name": uid,
"description": "NA",
"installed": str(is_installed).lower(),
"pid": "NA",
"state": "NA",
"substate": "NA",
"status": "NA",
"license": "NA",
"version": "NA",
"command_line_path": "NA"
}]
else:
service_license = "NA"
version = "NA"
service_description = str(
properties_iface.Get(UNIT_IFACE, 'Description'))
state = str(properties_iface.Get(UNIT_IFACE, 'ActiveState'))
substate = str(properties_iface.Get(UNIT_IFACE, 'SubState'))
service_status = 'enabled' if 'disabled' not in properties_iface.Get(
UNIT_IFACE, 'UnitFileState') else 'disabled'
pid = "NA" if state == "inactive" else str(
properties_iface.Get(SERVICE_IFACE, 'ExecMainPID'))
try:
version = self.get_service_info_from_rpm(uid, "VERSION")
except ServiceError as err:
logger.error(
log.svc_log(f"Unable to get service version due to {err}"))
try:
service_license = self.get_service_info_from_rpm(
uid, "LICENSE")
except ServiceError as err:
logger.error(
log.svc_log(f"Unable to get service license due to {err}"))
specifics = [{
"service_name": uid,
"description": service_description,
"installed": str(is_installed).lower(),
"pid": pid,
"state": state,
"substate": substate,
"status": service_status,
"license": service_license,
"version": version,
"command_line_path": command_line_path
}]
if state == 'active' and substate == 'running':
health_status = 'OK'
health_description = f"{uid} is in good health"
recommendation = "NA"
else:
health_status = state
health_description = f"{uid} is not in good health"
recommendation = DEFAULT_RECOMMENDATION
return uid, health_status, health_description, recommendation, specifics
def get_unit_uptime(self, unit):
unit = self.manager.LoadUnit(unit)
unit_object = self.bus.get_object(SYSTEMD_BUSNAME, unit)
unit_properties = Interface(unit_object, DBUS_INTERFACE)
return unit_properties.Get(SYSTEMD_UNIT_INTERFACE,
'ActiveEnterTimestamp')
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')
except DBusException as e:
index = wait(index, text=e.get_dbus_message())
def get_unit_load_state(self, unit):
unit = self.manager.LoadUnit(unit)
unit_object = self.bus.get_object(SYSTEMD_BUSNAME, unit)
unit_properties = Interface(unit_object, DBUS_INTERFACE)
return unit_properties.Get(SYSTEMD_UNIT_INTERFACE, 'LoadState')
