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 __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 )
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)
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