def main(): if os.geteuid() != 0: exit("Comitup requires root privileges") args = parse_args() log = deflog() log.info("Starting comitup") (conf, data) = load_data() if args.check: if wificheck.run_checks(): sys.exit(1) else: sys.exit(0) else: wificheck.run_checks(verbose=False) webmgr.init_webmgr(conf.web_service) iptmgr.init_iptmgr() statemgr.init_state_mgr( conf, data, [ webmgr.state_callback, iptmgr.state_callback, cdns.state_callback, ], ) loop = MainLoop() loop.run()
def pydbus_server(): loop = MainLoop() bus = pydbus.SessionBus() try: bus.get('pydbus.unittest',timeout=1) except: with bus.publish("pydbus.unittest", PyDbusUnitTestService(loop)): loop.run()
class RoficationDbusService: def __init__(self, queue: NotificationQueue) -> None: # preserve D-Bus object reference self._object = RoficationDbusObject(queue) # create GLib mainloop, this is needed to make D-Bus work and takes care of catching signals. self._loop = MainLoop() def run(self) -> None: self._loop.run()
def ObjListUpdater(self): self.system_bus = pydbus.SystemBus() self.system_bus.subscribe(sender='org.bluez', signal='PropertiesChanged', signal_fired=self.Update_obj_list) loop = MainLoop() timeout_add(100, self.checkTerminate, loop) loop.run()
def initialize_bus(self, bus=None, loop=None): if bus is None: self.bus = SessionBus() else: self.bus = bus if loop is None: self.loop = MainLoop() else: self.loop = loop self.bus.publish(self.INTERFACE_NAME, self)
def main(): global log if os.geteuid() != 0: exit("Comitup requires root privileges") args = parse_args() (conf, data) = config.load_data() log = deflog(args.verbose or conf.getboolean("verbose")) log.info("Starting comitup") if args.info: for (key, val) in statemgr.get_info(conf, data).items(): print("{}: {}".format(key, val)) sys.exit(0) if args.check: if wificheck.run_checks(): sys.exit(1) else: sys.exit(0) else: wificheck.run_checks(verbose=False) check_environment(log) webmgr.init_webmgr(conf.web_service) iptmgr.init_iptmgr() statemgr.init_state_mgr( conf, data, [ webmgr.state_callback, iptmgr.state_callback, cdns.state_callback, ], ) nuke.init_nuke() signal.signal(signal.SIGTERM, handle_term) loop = MainLoop() try: loop.run() except Exception: log.error("Terminal exception encountered") raise finally: cleanup()
def main(): handler = logging.StreamHandler(stream=None) log.addHandler(handler) log.setLevel(logging.DEBUG) log.info('starting') init_state_mgr('comitup.local', 'comitup-1111.local') states.set_state('HOTSPOT', timeout=5) loop = MainLoop() loop.run()
def main(): handler = logging.StreamHandler(stream=None) log.addHandler(handler) log.setLevel(logging.DEBUG) log.info("starting") init_state_mgr("comitup.local", "comitup-1111.local") states.set_state("HOTSPOT", timeout=5) loop = MainLoop() loop.run()
def on_message(bus: Gst.Bus, message:Gst.Message, loop: GLib.MainLoop): mtype = message.type if mtype == Gst.MessageType.EOS: print('End Of Stream') loop.quit() elif mtype == Gst.MessageType.ERROR: err, debug = message.parse_error() print(err, debug) loop.quit() elif mtype == Gst.MessageType.WARNING: err, debug = message.parse_warning() print(err, debug) return True
def bus_call(bus: Gst.Bus, message: Gst.Message, loop: GLib.MainLoop): t = message.type if t == Gst.MessageType.EOS: sys.stdout.write("End-of-stream\n") loop.quit() elif t == Gst.MessageType.ERROR: err, debug = message.parse_error() sys.stderr.write("Error: %s: %s\n" % (err, debug)) loop.quit() elif t == Gst.MessageType.WARNING: # Handle warnings err, debug = message.parse_warning() sys.stderr.write("Warning: %s: %s\n" % (err, debug)) return True
def main(): args = cli_aruments() try: hci = Adapter(args.adapter) except BluezError as e: print(str(e), file=sys.stderr) sys.exit(1) loop = MainLoop.new(None, False) if args.scan_duration: timeout_add_seconds(args.scan_duration, scan_timeout, loop) hci.onPropertiesChanged(adapter_changed, loop) hci.onDeviceAdded(device_found, args.properties, init=True, some="Foo") # hci.onDeviceRemoved(device_removed, args.properties) # hci.scan() # for d in hci.devices(): # device_found(d, d.properties, args.properties) try: loop.run() except (KeyboardInterrupt, SystemExit): pass finally: try: hci.onDeviceAdded(None) hci.onPropertiesChanged(None) hci.scan(enable=False) hci.clear() except: pass
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 main(): handler = logging.StreamHandler(stream=None) log.addHandler(handler) log.setLevel(logging.DEBUG) log.info('starting') init_nmmon() def up(): print("wifi up") def down(): print("wifi down") enable(modemgr.get_ap_device(), up, down) loop = MainLoop() loop.run()
def on_message(bus: Gst.Bus, message: Gst.Message, loop: GLib.MainLoop): mtype = message.type """ Gstreamer Message Types and how to parse https://lazka.github.io/pgi-docs/Gst-1.0/flags.html#Gst.MessageType """ if mtype == Gst.MessageType.EOS: print("End of stream") loop.quit() elif mtype == Gst.MessageType.ERROR: err, debug = message.parse_error() print(err, debug) loop.quit() elif mtype == Gst.MessageType.WARNING: err, debug = message.parse_warning() print(err, debug) return True
def main(): handler = logging.StreamHandler(stream=None) log.addHandler(handler) log.setLevel(logging.DEBUG) log.info('starting') init_nmmon() def up(): print("wifi up") def down(): print("wifi down") set_device_callbacks('HOTSPOT', up, down) loop = MainLoop() loop.run()
def do_notify_single(self, arg): "enable notifications on char and print changed values" args = _parse_args_simple(arg) timeout_seconds = None if len(args) > 1: try: timeout_seconds = int(args[1]) except Exception as e: print(str(e)) return else: print("To few arguments (char, [timeout[)") return g_char = self.find_char_or_desc_obj(args[0]) if not g_char: print( "get:", str(g_char), "Not valid in GATT database or not resolved", file=sys.stderr, ) return c = g_char try: flags = c.flags if "notify" in flags or "indicate" in flags: c.onValueChanged(generic_notify) c.notifyOn() elif "read" in flags: c.onValueChanged(generic_notify) except bluez.BluezDoesNotExistError as e: print(c.name, str(e), file=sys.stderr) loop = MainLoop.new(None, False) self.gatt.dev.onPropertiesChanged(dev_connected_changed) timeout = None if timeout_seconds: timeout = CmdTimeout(timeout_seconds, loop) try: if timeout_seconds: print("Notifying for {} seconds".format(timeout_seconds), file=sys.stderr) else: print("Notifiying, CTRL+C to end", file=sys.stderr) loop.run() except (KeyboardInterrupt, bluez.BluezError) as e: print("aborted:", self.gatt.dev.name, str(e), file=sys.stderr) loop.quit() if timeout: timeout.canceled = True
def main(): if os.geteuid() != 0: exit("Comitup requires root privileges") args = parse_args() log = deflog() log.info("Starting comitup") (conf, data) = config.load_data() if args.info: for (key, val) in statemgr.get_info(conf, data).items(): print("{}: {}".format(key, val)) sys.exit(0) if args.check: if wificheck.run_checks(): sys.exit(1) else: sys.exit(0) else: wificheck.run_checks(verbose=False) check_environment(log) webmgr.init_webmgr(conf.web_service) iptmgr.init_iptmgr() statemgr.init_state_mgr( conf, data, [ webmgr.state_callback, iptmgr.state_callback, cdns.state_callback, ], ) loop = MainLoop() loop.run()
def do_notify(self, arg): "enable all notifications and print changed values" args = _parse_args_simple(arg) timeout_seconds = None if len(args) > 0: try: timeout_seconds = int(args[0]) except Exception as e: print(str(e)) return if not self.gatt: print("Disconnected", file=sys.stderr) return for s in self.gatt.services: for c in s.chars: try: flags = c.flags if "notify" in flags or "indicate" in flags: c.onValueChanged(generic_notify) c.notifyOn() elif "read" in flags: c.onValueChanged(generic_notify) except bluez.BluezDoesNotExistError as e: print(c.name, str(e), file=sys.stderr) except bluez.BluezError as e: print(str(e), file=sys.stderr) loop = MainLoop.new(None, False) self.gatt.dev.onPropertiesChanged(dev_connected_changed) timeout = None if timeout_seconds: timeout = CmdTimeout(timeout_seconds, loop) try: if timeout_seconds: print("Notifying for {} seconds".format(timeout_seconds), file=sys.stderr) else: print("Notifiying, CTRL+C to end", file=sys.stderr) loop.run() except (KeyboardInterrupt, bluez.BluezError) as e: print("aborted:", self.gatt.dev.name, str(e), file=sys.stderr) loop.quit() if timeout: timeout.canceled = True
def __init__(self, adapter_name, peripheral_addresses, logger, gatt_description): self.adapter_name = adapter_name self.peripheral_addresses = peripheral_addresses self.logger = logger self.scan_filters = {'Transport': 'le'} self.mainloop = MainLoop.new(None, False) # Use same gatt description for all peripherals (matching uuids to names/formats) self.gatt_description = gatt_description # state information for all peripherals we want to interact with, dictionary with addr as key self.peripherals = {} for idx, p_addr in enumerate(self.peripheral_addresses): # use upper case addresses self.peripheral_addresses[idx] = p_addr.upper() self.peripherals[p_addr.upper()] = None try: self.init_adapter() except bluez.BluezError as e: logger.error(str(e)) bluez.ObjectManager.get().onAdapterAdded(adapter_added, self.adapter_name, self)
def __init__(self, batn, design): self.bus = SystemBus() self.loop = MainLoop() self.bat = self.upower = None self.use_design_capacity = design self.bat_path = f'/org/freedesktop/UPower/devices/battery_BAT{batn}'
set_hosts(*hosts) for callback in callbacks: add_state_callback(callback) hotspot_name = dns_to_conn(hosts[0]) assure_hotspot(hotspot_name, modemgr.get_ap_device()) def add_state_callback(callback): global state_callbacks state_callbacks.append(callback) if __name__ == '__main__': handler = logging.StreamHandler(stream=None) log.addHandler(handler) log.setLevel(logging.DEBUG) log.info("Starting") init_states('comitup.local', 'comitup-1111.local') set_state('HOTSPOT') # set_state('CONNECTING', candidate_connections()) loop = MainLoop() loop.run()
def main(self): main_loop = MainLoop() self.connect('ipc_shutdown', lambda self: main_loop.quit()) main_loop.run()
def create_main_loop(): """Create GLib main loop. :returns: GLib.MainLoop instance. """ return MainLoop()
class Daemon(ManagesProcesses): INTERFACE_NAME = "pro.wizardsoftheweb.pyrofibus.daemon" dbus = """ <node> <interface name='{}'> <method name='is_running'> <arg type='b' name='response' direction='out'/> </method> <method name='start'> </method> <method name='stop'> </method> <method name='load_apps'> <arg type='i' name='response' direction='out'/> </method> </interface> </node> """.format(INTERFACE_NAME) _is_running = False def __init__(self, bus=None, loop=None, *args, **kwargs): super(Daemon, self).__init__(*args, **kwargs) self.initialize_bus(bus, loop) def initialize_bus(self, bus=None, loop=None): if bus is None: self.bus = SessionBus() else: self.bus = bus if loop is None: self.loop = MainLoop() else: self.loop = loop self.bus.publish(self.INTERFACE_NAME, self) def start(self): if not self._is_running: try: self._is_running = True self.loop.run() except KeyboardInterrupt: self.loop.quit() self._is_running = False def is_running(self): return self._is_running def stop(self): self.loop.quit() self._is_running = False def load_apps(self): old_length = len(self.managed_processes) new_scripts = self.check_for_new_scripts() self.load_new_scripts(new_scripts) new_length = len(self.managed_processes) return new_length - old_length @classmethod def bootstrap(cls): daemon = cls() daemon.start()
class BatteryMonitor: ''' Class for Battery Monitoring ''' def __init__(self, batn, design): self.bus = SystemBus() self.loop = MainLoop() self.bat = self.upower = None self.use_design_capacity = design self.bat_path = f'/org/freedesktop/UPower/devices/battery_BAT{batn}' def run(self): ''' Run the event loop ''' self.upower = self.bus.get('org.freedesktop.UPower', '/org/freedesktop/UPower') if self.bat_path in self.upower.EnumerateDevices(): self.add_battery(self.bat_path) else: self.upower.onDeviceAdded = self.add_battery # Handle SIGTERM and SIGINT signal endloop = lambda signum, fname: self.loop.quit() signal.signal(signal.SIGINT, endloop) signal.signal(signal.SIGTERM, endloop) self.loop.run() return 0 def add_battery(self, dev_path): ''' Add the battery when the battery exists ''' if dev_path == self.bat_path: self.upower.onDeviceRemoved = self.remove_battery if self.upower.onDeviceAdded is not None: self.upower.onDeviceAdded = None self.bat = self.bus.get('org.freedesktop.UPower', self.bat_path) self.bat.onPropertiesChanged = self.update_battery self.update_battery() def remove_battery(self, dev_path): ''' Remove the battery when the battery not exists ''' if dev_path == self.bat_path: self.upower.onDeviceAdded = self.add_battery self.upower.onDeviceRemoved = None self.bat.onPropertiesChanged = None self.bat = None self.update_battery() def update_battery(self, ifname=None, changed_props=None, invalid_props=None): ''' Print the updated battery info ''' del ifname, invalid_props if (changed_props is None) or (('Energy' in changed_props) or ('State' in changed_props)): text = '' css_class = '' if self.bat is not None: bat_state = BAT_STATE[self.bat.State] bat_energy_empty = self.bat.EnergyEmpty bat_energy_full = self.bat.EnergyFullDesign if \ self.use_design_capacity else self.bat.EnergyFull # Calculate the battery capacity percentage bat_capacity = 100 * (self.bat.Energy - bat_energy_empty) \ / (bat_energy_full - bat_energy_empty) # Find the battery capacity label for key, value in BAT_LEVEL.items(): if bat_capacity <= key: bat_level = value break if bat_state['class'] == BAT_STATE[2]['class']: if bat_capacity <= BAT_STATE[2]['crit']['level']: css_class = BAT_STATE[2]['crit']['class'] elif bat_capacity <= BAT_STATE[2]['warn']['level']: css_class = BAT_STATE[2]['warn']['class'] if css_class == '': css_class = bat_state['class'] text = f"{bat_state['label']}{bat_level}{bat_capacity:.2f}%" print(f'{{"text": "{text}", "class": "{css_class}"}}', flush=True)
def main(): parser = ArgumentParser(description="bluetooth tester") parser.add_argument( "-i", "--adapter", metavar="hciX", default=def_adapter, help="bluetooh adapter to use (default={})".format(def_adapter), ) parser.add_argument( "-a", "--device", metavar="addr", default=None, help="device address to connect to", ) parser.add_argument( "-p", "--pair", default=False, action="store_true", help="Send pairing request to device, if not paired (Needs an agent)", ) parser.add_argument("-k", "--keep", default=False, action="store_true", help="keep connection alive") parser.add_argument( "-l", "--loop", default=False, action="store_true", help="loop requesting info (sleeps 1s)", ) parser.add_argument( "-w", "--wait", metavar="sec", default=1, type=int, help="time to wait before starting to read", ) args = parser.parse_args() print("Scanning on: {}".format(args.adapter)) try: adapter = Adapter(args.adapter) except BluezDoesNotExistError as e: print(str(e)) sys.exit(2) devs = adapter.devices() dev = None for d in devs: da = d.address() if da and da.upper() == args.device.upper(): print("Found {}: {}".format(args.device, d)) dev = d if not dev: adapter.scan() sleep(3) sr = adapter.devices() for d in sr: da = d.address() if da and da.upper() == args.device.upper(): print("Found {}: {}".format(args.device, d)) dev = d if not dev: print("Could not find device nearby: {}".format(args.device)) adapter.scan(enable=False) sys.exit(1) adapter.scan(enable=False) if dev.connected(): print("Already connected: {}".format(dev)) else: if args.pair: if not dev.paired(): print("Device is not paired") print("Connecting/pairing to: {}".format(str(dev))) dev.pair() # waait for paring-agent wait_secs = 60 while wait_secs > 0 and not dev.paired(): wait_secs -= 1 sleep(1) if not dev.paired(): print("Pairing failed") sys.exit(1) if not dev.trusted(): dev.trust(True) print("Device is now trusted") if not dev.connect(): print("Connecting failed") sys.exit(1) gatt = Gatt(dev, [device_information]) gatt.resolve() if not dev.services_resolved: print( "Waited not long enough for service resolving, did not find uuids") sys.exit(1) print("Service UUIDs resolved") dev_info = gatt.device_information # pylint: disable=no-member for dinfo in dev_info.chars: if dinfo.obj: print(dinfo.name, ":", dinfo.read(options={"timeout": 4})) if args.wait > 0: sleep(args.wait) if args.loop: loop = MainLoop.new(None, False) for dinfo_char in dev_info.chars: if dinfo_char.obj: # add callback for printing if new value is avalable dinfo_char.onPropertiesChanged(print_char) # add cyclic read every 1 sec timeout_add_seconds(1, read_char, dinfo_char) try: loop.run() except (KeyboardInterrupt, SystemExit) as e: print("Interupted:", str(e)) if not args.keep: dev.disconnect()
if signal != 'ActiveChanged': logging.debug("Not what we are looking for, ignored") return logging.debug("START OF SIGNAL PROCESSING") if signal_msg is True: logging.debug("Screensaver now active") else: logging.info("Running 'on 0\\nas\\nquit' to turn on TV") proc = subprocess.Popen(['/usr/bin/cec-client'], stdin=subprocess.PIPE) results = proc.communicate(input='on 0\nas\nquit\n'.encode()) time.sleep(3) logging.debug(results[0]) logging.debug(results[1]) proc.terminate() proc.kill() logging.debug("END OF SIGNAL PROCESSING") BUS.subscribe(iface=DBUS_INTERFACE, signal_fired=signal_recieved) # loop forever, until CTRL+C, or something goes wrong try: MainLoop().run() except KeyboardInterrupt: logging.debug('Got CTRL+C, exiting cleanly') raise SystemExit