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 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, 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 __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 __init__(self, logger_instance, notifier_instance): """ Initialize class """ super(ThumbDriveDetector, self).__init__() self._logger = logger_instance self._logger.debug("ThumbDriveDetector.__init__ called") # Unblock main thread by calling this method. dbus.mainloop.glib.threads_init() # Set global default main loop DBusGMainLoop(set_as_default=True) self._udisk2_interface = 'org.freedesktop.UDisks2' self._object_manager_interface = 'org.freedesktop.DBus.ObjectManager' self._object_path = '/org/freedesktop/UDisks2' self._drive_interface = "org.freedesktop.UDisks2.Drive" self._bus = SystemBus() # Unblock main thread by calling this method. gobject.threads_init() # Create instance of main event loop and run it self._loop = gobject.MainLoop() self._notifier = notifier_instance self._logger.debug("Instantiated ThumbDriveDetector")
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 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] # Integrate into the main dbus loop to catch events DBusGMainLoop(set_as_default=True) # Initialize SystemBus and get Manager Interface self._bus = SystemBus() systemd = self._bus.get_object("org.freedesktop.systemd1", "/org/freedesktop/systemd1") self._manager = Interface( systemd, dbus_interface='org.freedesktop.systemd1.Manager') self.remove_disabled_services() return True
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 __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')
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 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
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 run( write_pipe1=None, # write pipe to systemtray write_pipe2=None, # write pipe to hpdio read_pipe3=None): # read pipe from hpdio global dbus_loop, main_loop global system_bus, session_bus global w1, w2, r3 log.set_module("hp-systray(hpssd)") log.debug("PID=%d" % os.getpid()) w1, w2, r3 = write_pipe1, write_pipe2, read_pipe3 dbus_loop = DBusGMainLoop(set_as_default=True) main_loop = MainLoop() try: system_bus = SystemBus(mainloop=dbus_loop) except dbus.exceptions.DBusException as e: log.error("Unable to connect to dbus system bus. Exiting.") sys.exit(1) try: session_bus = dbus.SessionBus() except dbus.exceptions.DBusException as e: if os.getuid() != 0: log.error("Unable to connect to dbus session bus. Exiting.") sys.exit(1) else: log.error( "Unable to connect to dbus session bus (running as root?)") sys.exit(1) # Receive events from the system bus system_bus.add_signal_receiver(handle_system_signal, sender_keyword='sender', destination_keyword='dest', interface_keyword='interface', member_keyword='member', path_keyword='path') # Receive events from the session bus session_bus.add_signal_receiver(handle_session_signal, sender_keyword='sender', destination_keyword='dest', interface_keyword='interface', member_keyword='member', path_keyword='path') # Export an object on the session bus session_name = dbus.service.BusName("com.hplip.StatusService", session_bus) status_service = StatusService(session_name, "/com/hplip/StatusService") log.debug("Entering main dbus loop...") try: main_loop.run() except KeyboardInterrupt: log.debug("Ctrl-C: Exiting...")
def post_config_hook(self): try: self.login1 = SystemBus().get_object("org.freedesktop.login1", "/org/freedesktop/login1") except Exception: raise Exception(STRING_DBUS_EXCEPTION) self.lock = None self.lock_types = ":".join(self.lock_types) self.thresholds_init = self.py3.get_color_names_list(self.format)
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 install_signal_handlers(self): """Hooks to some d-bus signals that are of interest to us""" bus = SystemBus() bus.add_signal_receiver( self.handle_incoming_message, 'IncomingMessage', 'org.freesmartphone.GSM.SIM' )
def enable(self): bus = SystemBus() if not self.handler: self.signal = bus.add_signal_receiver( self.handle_call_status, signal_name='CallStatus', dbus_interface='org.freesmartphone.GSM.Call', bus_name='org.freesmartphone.ogsmd') self.handler = True self._initialized = True
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 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()
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 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')
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 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'
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 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] # Integrate into the main dbus loop to catch events DBusGMainLoop(set_as_default=True) # Initialize SystemBus and get Manager Interface self._bus = SystemBus() systemd = self._bus.get_object("org.freedesktop.systemd1", "/org/freedesktop/systemd1") self._manager = Interface( systemd, dbus_interface='org.freedesktop.systemd1.Manager') self._node_id = Conf.get(GLOBAL_CONF, NODE_ID_KEY, 'SN01') cache_dir_path = os.path.join(DATA_PATH, self.CACHE_DIR_NAME) self.SERVICE_MONITOR_DATA_PATH = os.path.join( cache_dir_path, f'SERVICE_MONITOR_DATA_{self._node_id}') # Get the stored previous service info self.persistent_service_data = {} if os.path.isfile(self.SERVICE_MONITOR_DATA_PATH): self.persistent_service_data = \ store.get(self.SERVICE_MONITOR_DATA_PATH) if self.persistent_service_data: self.not_active_services = \ self.persistent_service_data['not_active_services'] self.failed_services = \ self.persistent_service_data['failed_services'] self.service_status = \ self.persistent_service_data['service_status'] else: self.persistent_service_data = { 'not_active_services': self.not_active_services, 'failed_services': self.failed_services, 'service_status': self.service_status } store.put(self.persistent_service_data, self.SERVICE_MONITOR_DATA_PATH) self.remove_disabled_services() return True
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): 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 __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()
def init_dbus(self): print 'PylgrimView init_dbus' try: gps_obj = SystemBus(mainloop=DBusEcoreMainLoop()).get_object(DBUS_NAME, #'/org/mobile/GoogleLocation', '/org/mobile/GpsLocation', ) gps_obj.connect_to_signal("position", self.position, dbus_interface=DIN_LOCATION) self.gps_interface = Interface(gps_obj, DIN_LOCATION) self.gps_interface.GetPosition(reply_handler=self.position, error_handler=err, ) return False except Exception, e: print 'PylgrimView', e return True
def run(write_pipe1=None, # write pipe to systemtray write_pipe2=None, # write pipe to hpdio read_pipe3=None): # read pipe from hpdio global dbus_loop, main_loop global system_bus, session_bus global w1, w2, r3 log.set_module("hp-systray(hpssd)") log.debug("PID=%d" % os.getpid()) w1, w2, r3 = write_pipe1, write_pipe2, read_pipe3 dbus_loop = DBusGMainLoop(set_as_default=True) main_loop = MainLoop() try: system_bus = SystemBus(mainloop=dbus_loop) except dbus.exceptions.DBusException as e: log.error("Unable to connect to dbus system bus. Exiting.") sys.exit(1) try: session_bus = dbus.SessionBus() except dbus.exceptions.DBusException as e: if os.getuid() != 0: log.error("Unable to connect to dbus session bus. Exiting.") sys.exit(1) else: log.error("Unable to connect to dbus session bus (running as root?)") sys.exit(1) # Receive events from the system bus system_bus.add_signal_receiver(handle_system_signal, sender_keyword='sender', destination_keyword='dest', interface_keyword='interface', member_keyword='member', path_keyword='path') # Receive events from the session bus session_bus.add_signal_receiver(handle_session_signal, sender_keyword='sender', destination_keyword='dest', interface_keyword='interface', member_keyword='member', path_keyword='path') # Export an object on the session bus session_name = dbus.service.BusName("com.hplip.StatusService", session_bus) status_service = StatusService(session_name, "/com/hplip/StatusService") log.debug("Entering main dbus loop...") try: main_loop.run() except KeyboardInterrupt: log.debug("Ctrl-C: Exiting...")
def __init__(self): # Diccionario para evitar los dobles escaneos producto de la emisión # de señales repetidas. Pasa porque Rhythmbox vuelve a escanear todos # los dispositivos cuando levanta por primera vez. self._already_scanned = {} # Se obtiene una conexión al bus de sistema self._system_bus = SystemBus() # Se obtiene una conexión al bus de sesión self._session_bus = SessionBus() # Conectar a las señales que emite de UDisks self._connect_to_udisks()
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 __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 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
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 monitor(output='syslog'): bus = SystemBus() logger = DBusLogger(output) bus.add_match_string("") bus.add_message_filter(logger) loop = MainLoop() print "Press Ctrl-C to stop." try: loop.run() except: print " Loop exited" bus.remove_message_filter(logger) bus.remove_match_string("")
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 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')
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 __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 send_message(device_uri, printer_name, event_code, username, job_id, title, pipe_name=''): log.debug("send_message() entered") args = [device_uri, printer_name, event_code, username, job_id, title, pipe_name] msg = lowlevel.SignalMessage('/', DBUS_SERVICE, 'Event') msg.append(signature='ssisiss', *args) SystemBus().send_message(msg) log.debug("send_message() returning")
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 __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 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 __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' )
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()
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)
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 _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')
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 = {}
def _connect(self): self.bus = SystemBus() self.jobservice = Interface(self.bus.get_object( 'com.ubuntu.JobService', '/com/ubuntu/JobService'), 'com.ubuntu.JobService')
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
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()
#!/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 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
gi.require_version('Notify', '0.7') 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