def __init__(self, interface, path=None): self._interface = interface if path is None: self._path = '/org/freedesktop/ModemManager1' self._dbus = SystemBus().get('.ModemManager1') else: self._path = path self._dbus = SystemBus().get('.ModemManager1', self._path)
def __init__(self, config): """Constructor. config: Dictionary containing BatWatch configuration details. """ self.logger = logging.getLogger(__name__) self.system_bus = SystemBus() self.upower_bus = SystemBus().get(UPOWER_BUS_NAME) self.config = config
def __init__(self, name): self.bus = SystemBus() self.systemd = SystemBus().get('.systemd1') self.name = name self.unit = self.bus.get('.systemd1', self.systemd.GetUnit(self.name)) self.connection = self.unit['org.freedesktop.DBus.Properties'].PropertiesChanged.connect(self.callback) self.og = OpsGenieApi() self.notify(True)
def start(self, median_path, config_path, db_path): # Always start in standby self.set_state(State.STANDBY) # Start up camera self.snapper = Snapper(logger) # Start up solver self.solver = Solver(logger) self.solver.startup(median_path, config_path, db_path) # Start solver thread self.s_thread.start() logger.info("Started solver thread.") # Start up D-Bus server bus = SystemBus() loop = GLib.MainLoop() bus.publish(self.interface_name, self) try: logger.info("Starting D-Bus loop.") loop.run() except KeyboardInterrupt as e: loop.quit() logger.info("Ended D-Bus loop.") self.end()
def run_event_loop(): bus = SystemBus() logger.debug('Publishing interface %s on DBus', constants.DEPUTY_DBUS_NAME) config = get_config() bus.publish(constants.DEPUTY_DBUS_NAME, HadesDeputyService(bus, config)) loop = GLib.MainLoop() loop.run()
def startDbus(self): self.bus = SystemBus() self.manager = self.bus.get("org.freedesktop.ModemManager1") for s in self.getAllModems(): self.buildModem(s) self.manager.InterfacesAdded.connect( lambda path, x: self.buildModem(path) ) self.manager.InterfacesRemoved.connect( lambda path, x: self.removeModem(path) )
def __init__(self): self.ostree_remote_attributes = None self.logger = logging.getLogger('fullmetalupdate_container_updater') self.mark_os_successful() bus = SystemBus() self.systemd = bus.get('.systemd1') self.sysroot = OSTree.Sysroot.new_default() self.sysroot.load(None) self.logger.info("Cleaning the sysroot") self.sysroot.cleanup(None) [_, repo] = self.sysroot.get_repo() self.repo_os = repo self.remote_name_os = None self.repo_containers = OSTree.Repo.new(Gio.File.new_for_path(PATH_REPO_APPS)) if os.path.exists(PATH_REPO_APPS): self.logger.info("Preinstalled OSTree for containers, we use it") self.repo_containers.open(None) else: self.logger.info("No preinstalled OSTree for containers, we create " "one") self.repo_containers.create(OSTree.RepoMode.BARE_USER_ONLY, None)
def __init__(self): self.prefix = 'W:' self.suffix = ' ' self.tooltip_heading = 'Wireless LAN Status:\n' self.iface = None # Set to interface name to override interface selection self.build_ui() # Needed by wpa_supplicant.core self.reactor = SelectReactor() thread = threading.Thread(target=self.reactor.run, kwargs={'installSignalHandlers': 0}) thread.daemon = True thread.start() time.sleep(0.1) # let reactor start self.wpasup = None self.wpasup_running = False self.wlan = None self.wlan_signal = None # Monitor the availability of wpa_supplicant via DBus self.dbus = SystemBus() # watch_name() fires an event as soon as GLib.MainLoop() starts, so we don't need to explicitly # call get_wpa_supplicant() here self.dbus.watch_name(BUS_NAME, 0, self.get_wpa_supplicant, self.get_wpa_supplicant) self.start_watch_thread()
def get_dbus_interface(fallback=True): """Get an interface to start and stop injecting keystrokes. Parameters ---------- fallback : bool If true, returns an instance of the daemon instead if it cannot connect """ msg = ('The daemon "key-mapper-service" is not running, mapping keys ' 'only works as long as the window is open. ' 'Try `sudo systemctl start key-mapper`') if not is_service_running(): if not fallback: logger.error('Service not running') return None logger.warning(msg) return Daemon() bus = SystemBus() try: interface = bus.get(BUS_NAME) except GLib.GError as error: logger.debug(error) if not fallback: logger.error('Failed to connect to the running service') return None logger.warning(msg) return Daemon() return interface
def start(self, median_path, config_path, db_path, sample_dir=None): if (DEBUG_ENABLED): global STACK_LAYERS print(f"{STACK_LAYERS * ' '}Inside Server.start") STACK_LAYERS = STACK_LAYERS + 1 # Start up star tracker self.st.startup(median_path, config_path, db_path, sample_dir=sample_dir) time.sleep(20) self.st_thread.start() logger.info("Started worker thread") # Start up D-Bus server bus = SystemBus() loop = GLib.MainLoop() bus.publish(self.interface_name, self) try: logger.info("Starting D-Bus loop...") loop.run() except KeyboardInterrupt as e: loop.quit() logger.info("Ended D-Bus loop") self.end() if (DEBUG_ENABLED): STACK_LAYERS = STACK_LAYERS - 1 print(f"{STACK_LAYERS * ' '}End Server.start")
def main(): # parse arguments parser = argparse.ArgumentParser() parser.add_argument("-a", "--add", dest="file", help="path to file to install") parser.add_argument("-u", "--update", action="store_true", help="start update") parser.add_argument("-s", "--status-archive", action="store_true", help="make status archive file") args = parser.parse_args() # set up bus connection bus = SystemBus() updater = bus.get(IFACE) if args.file: ret = updater.AddUpdateArchive(os.path.abspath(args.file)) print("AddUpdateArchive returned: " + str(ret)) elif args.update: ret = updater.Update() print("Update returned: " + str(ret)) elif args.status_archive: ret = updater.MakeStatusArchive() print("MakeStatusArchive returned: " + str(ret))
def run(self): self.logger.info("Starting Signal Interface") bus = SystemBus() self.signal = bus.get('org.asamk.Signal') self.signal.onMessageReceived = self.handle_message self.loop = GLib.MainLoop() #self.timer = GObject.idle_add(self.run_loop) self.logger.debug("Signal Interface Running") ps.subscribe(self.handle_panel_event, "events") ps.subscribe(self.handle_notify, "notifications") try: self.loop.run() except (KeyboardInterrupt, SystemExit): self.logger.debug("Signal loop stopping") if self.alarm is not None: self.loop.quit() self.alarm.disconnect() except Exception: self.logger.exception("Signal loop")
def post_config_hook(self): if self.user: bus = SessionBus() else: bus = SystemBus() systemd = bus.get("org.freedesktop.systemd1") self.systemd_unit = bus.get(".systemd1", systemd.LoadUnit(self.unit))
def __init__(self): self.object = None self.bus = SystemBus() self.udev = GUdev.Client(subsystems=["usb/usb_device"]) self.udev.connect("uevent", self.uevent) self.loop = GLib.MainLoop() self.busname = self.bus.publish(BUSNAME, self)
def post_config_hook(self): try: self._logind_proxy = SystemBus().get( bus_name="org.freedesktop.login1", object_path="/org/freedesktop/login1/session/self", ) except NameError: self._logind_proxy = None if not self.device: self.device = get_device() elif "/" not in self.device: self.device = f"/sys/class/backlight/{self.device}" if self.device is None: if self.hide_when_unavailable: return else: raise Exception(STRING_NOT_AVAILABLE) self.format = self.py3.update_placeholder_formats( self.format, {"level": ":.0f"}) # check for an error code and an output self.command_available = False try: output = self.py3.command_output(self._command_get()) try: float(output) self.command_available = True except ValueError: pass except self.py3.CommandError: pass if self.brightness_initial: self._set_backlight_level(self.brightness_initial)
def loop(): bus = SystemBus() bus.own_name('net.lvht.btk') obj_path = '/net/lvht/btk/HIDProfile' sock = bt.BluetoothSocket(bt.L2CAP) sock.setblocking(False) try: sock.bind(('', PSM_INTR)) except: print("For bluez5 add --noplugin=input to the bluetoothd commandline") print("Else there is another application running that has it open.") sys.exit(errno.EACCES) sock.listen(1) profile = HIDProfile(bus.con, obj_path, sock) opts = { "PSM": GLib.Variant.new_uint16(PSM_CTRL), "ServiceRecord": GLib.Variant.new_string(open('./sdp_record.xml', 'r').read()), "RequireAuthentication": GLib.Variant.new_boolean(True), "RequireAuthorization": GLib.Variant.new_boolean(False), } manager = bus.get('org.bluez')['.ProfileManager1'] manager.RegisterProfile(obj_path, str(uuid.uuid4()), opts) profile.run()
class Properties(MyBluez): interfaceName = "org.freedesktop.DBus.Properties" busName = "org.bluez" path = "/org/bluez/hci0" bus = SystemBus() objectsListArray = [] def __init__(self): print "Object Manager's Init Called" def PowerOff(self): properties = self.bus.get(self.busName, self.path) iface = "org.bluez.Adapter1" name = "Powered" properties.Set(iface, name, GLib.Variant("b", False)) def PowerOn(self): properties = self.bus.get(self.busName, self.path) iface = "org.bluez.Adapter1" name = "Powered" properties.Set(iface, name, GLib.Variant("b", True)) def GetAll(self): properties = self.bus.get(self.busName, self.pathIPhone) iface = "org.bluez.Adapter1" allProps = properties.GetAll(iface) print allProps
def __init__(self): GObject.GObject.__init__(self) self.interface = None self.welcomed_ok = False try: self.bus = SystemBus() self.dbus_proxy = self.bus.get(WelcomedClient._name, WelcomedClient._object_path) if not self.dbus_proxy: self.welcomed_ok = False else: self.dbus_proxy.PropertiesChanged.connect( self.on_properties_changed) self.welcomed_ok = self.dbus_proxy.is_alpm_on() except Exception as err: print(err) finally: if not self.welcomed_ok: msg = _( "Can't find Welcome d-bus service. Is it really installed?" ) Notify.init("antergos-welcome") Notify.Notification.new(_("ERROR!"), msg, 'dialog-error').show()
def main(): """The main for the oresat linux updater daemon""" ret = 0 pid_file = "/run/oresat-linux-updaterd.pid" parser = ArgumentParser() parser.add_argument("-d", "--daemon", action="store_true", help="daemonize the process") parser.add_argument("-v", "--verbose", action="store_true", help="enable debug log messaging") parser.add_argument("-w", "--work-dir", dest="work_dir", default=WORK_DIR, help="override the working directory") parser.add_argument("-c", "--cache-dir", dest="cache_dir", default=CACHE_DIR, help="override the update archive cache directory") args = parser.parse_args() if args.daemon: _daemonize(pid_file) log_handler = SysLogHandler(address="/dev/log") else: log_handler = logging.StreamHandler(sys.stderr) # turn on logging for debug messages if args.verbose: level = logging.DEBUG else: level = logging.INFO logging.basicConfig(level=level, handlers=[log_handler]) log = logging.getLogger('oresat-linux-updater') # make updater updater = DBusServer(args.work_dir, args.cache_dir, log) # set up dbus wrapper bus = SystemBus() bus.publish(DBUS_INTERFACE_NAME, updater) loop = GLib.MainLoop() try: updater.run() loop.run() except KeyboardInterrupt: updater.quit() loop.quit() except Exception as exc: # this should not happen log.critical(exc) updater.quit() loop.quit() ret = 1 if args.daemon: os.remove(pid_file) # clean up daemon return ret
def __init__(self, battery_name="BAT0"): self.loop = GLib.MainLoop() self.bat_name = battery_name self.dbus = SystemBus() self.upower = self.dbus.get('org.freedesktop.UPower', '/org/freedesktop/UPower') self.bat_obj_path = '/org/freedesktop/UPower/devices/battery_{}'\ .format(self.bat_name)
def publish(self): """Make the dbus interface available.""" bus = SystemBus() try: bus.publish(BUS_NAME, self) except RuntimeError as error: logger.error('Is the service is already running? %s', str(error)) sys.exit(1)
def restart_nginx(self): """ Restarts the nginx-1.12.2 service with DBUS """ self._logger.info("Restarting NGINX") bus = SystemBus() systemd = bus.get(".systemd1") systemd.RestartUnit("nginx.service", "fail")
def stop_start_systemd_unit(name="ssh.service"): """Stop and restart a systemd unit""" bus = SystemBus() # systemd is now a proxy for the .systemd1 remote object systemd = bus.get(".systemd1") job1 = systemd.StopUnit(name, "fail") job2 = systemd.StartUnit(name, "fail")
def __init__(self): self._logger = get_logger('uchroma.power') self._name_watchers = [] self._running = False self._sleeping = False self._session_bus = SessionBus() self._system_bus = SystemBus() self._dm = UChromaDeviceManager() #singleton
def quit(bus=None): if bus is None: bus = SystemBus() try: bts = bus.get(BTSDBusService.interface_name) bts.Quit() except GLib.Error: return -1
def signal_refresh(timeout: int = 1) -> None: """Signal the deputy to perform a refresh.""" logger.debug("Signaling refresh on DBus: %s.%s", constants.DEPUTY_DBUS_NAME, 'Refresh') with typed_glib_error(): bus = SystemBus() deputy = bus.get(constants.DEPUTY_DBUS_NAME, timeout=timeout) deputy_interface = deputy[constants.DEPUTY_DBUS_NAME] deputy_interface.Refresh(timeout=timeout)
def main (args, app): for trigger in Trigger.FromConfig(app.config): if args.name == trigger.name: with SystemBus( ) as bus: path = PATH + '/EventSink/{name:s}'.format(name=trigger.name) event = bus.get(BUS, path) event.Fire( ) props = event.GetAll(OWN_IFACE) print props
def __init__(self): self.bus = SystemBus() self.networkmanager = self.bus.get( "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager" ) self.use_alt_text = False signal.signal(signal.SIGUSR1, self.sigusr1_handler)
def signal_cleanup(timeout: int = 1) -> None: """Signal the deputy to perform a cleanup.""" logger.debug("Signaling cleanup on DBus: %s.%s", constants.DEPUTY_DBUS_NAME, 'Cleanup') with typed_glib_error(): bus = SystemBus() deputy = bus.get(constants.DEPUTY_DBUS_NAME, timeout=timeout) deputy_interface = deputy[constants.DEPUTY_DBUS_NAME] deputy_interface.Cleanup(timeout=timeout)
def watch_for_new_systemd_jobs(): """Wait for new systemd units and when they are created, print them out""" bus = SystemBus() # systemd is now a proxy for the .systemd1 remote object systemd = bus.get(".systemd1") systemd.JobNew.connect(print) GLib.MainLoop().run()