def listen(): TYPE = "_piper._tcp" def store(devic): global device device=devic #print device def service_resolved(*args): global device print 'service resolved' print 'name:', args[2] #print IP, PORT print 'address:', args[7] print 'port:', args[8] device['IP'].append(str(args[7])) device['PORT'].append(int(args[8])) store(device) if ":" in device['IP'][-1] : del device['IP'][-1] del device['PORT'][-1] if len(device['IP'])==1: loop.quit() def print_error(*args): global device print 'error_handler' print args[0] def myhandler(interface, protocol, name, stype, domain, flags): global device print "Found service '%s' type '%s' domain '%s' " % (name, stype, domain) if flags & avahi.LOOKUP_RESULT_LOCAL: # local service, skip pass server.ResolveService(interface, protocol, name, stype, domain, avahi.PROTO_UNSPEC, dbus.UInt32(0), reply_handler=service_resolved, error_handler=print_error) #print IP, PORT loop = DBusGMainLoop() bus = dbus.SystemBus(mainloop=loop) server = dbus.Interface( bus.get_object(avahi.DBUS_NAME, '/'), 'org.freedesktop.Avahi.Server') sbrowser = dbus.Interface(bus.get_object(avahi.DBUS_NAME, server.ServiceBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, TYPE, 'local', dbus.UInt32(0))), avahi.DBUS_INTERFACE_SERVICE_BROWSER) sbrowser.connect_to_signal("ItemNew", myhandler) loop=gobject.MainLoop() loop.run()
def __init__(self): print("Initializing nemo-font-manager extension") DBusGMainLoop(set_as_default=True) self.bus = dbus.SessionBus() self.bus.watch_name_owner(DBUS_ID, FontViewer.set_state)
def setup_session(): DBusGMainLoop(set_as_default=True) sesbus = dbus.SessionBus() sesbus.add_signal_receiver(screensaver_changed, 'ActiveChanged', 'org.gnome.ScreenSaver')
def setup_mainloop(): global loop_ loop_ = DBusGMainLoop(set_as_default=True)
def initialize(self): super(platform_CryptohomeMigrateChapsTokenClient, self).initialize() bus_loop = DBusGMainLoop(set_as_default=True) self._cryptohome_proxy = cryptohome.CryptohomeProxy( bus_loop, self.autodir, self.job)
def setup_for_cli_run(): import signal from dbus.mainloop.glib import DBusGMainLoop, threads_init threads_init() DBusGMainLoop(set_as_default=True) signal.signal(signal.SIGINT, signal.SIG_DFL) # quit on Ctrl-C
def __init__(self): r.start_ip() # Initializes variables and threads self.interface_name = p.wifiPort #Wireless interface #Start epidemic protocol r.start_protocol(p.wifiPort) self.wpas_dbus_interface = 'fi.w1.wpa_supplicant1' # Initializes thread and daemon allows for ctrl-c kill threading.Thread.__init__(self) self.daemon = True # Generating interface/object paths self.wpas_dbus_opath = "/" + \ self.wpas_dbus_interface.replace(".","/") self.wpas_wpas_dbus_interfaces_opath = self.wpas_dbus_opath + \ "/Interfaces" self.wpas_dbus_interfaces_interface = \ self.wpas_dbus_interface + ".Interface" self.wpas_dbus_interfaces_p2pdevice = \ self.wpas_dbus_interfaces_interface \ + ".P2PDevice" # Getting interfaces and objects DBusGMainLoop(set_as_default=True) self.bus = dbus.SystemBus() self.wpas_object = self.bus.get_object(self.wpas_dbus_interface, self.wpas_dbus_opath) self.wpas = dbus.Interface(self.wpas_object, self.wpas_dbus_interface) self.path = self.wpas.GetInterface(self.interface_name) self.interface_object = self.bus.get_object(self.wpas_dbus_interface, self.path) self.p2p_interface = dbus.Interface( self.interface_object, self.wpas_dbus_interfaces_p2pdevice) #Adds listeners for find and lost self.bus.add_signal_receiver( self.deviceFound, dbus_interface=self.wpas_dbus_interfaces_p2pdevice, signal_name="DeviceFound") self.bus.add_signal_receiver( self.deviceLost, dbus_interface=self.wpas_dbus_interfaces_p2pdevice, signal_name="DeviceLost") self.bus.add_signal_receiver( self.goNegotiationRequest, dbus_interface=self.wpas_dbus_interfaces_p2pdevice, signal_name="GONegotiationRequest") self.bus.add_signal_receiver( self.GONegotiationSuccess, dbus_interface=self.wpas_dbus_interfaces_p2pdevice, signal_name="GONegotiationSuccess") self.bus.add_signal_receiver( self.GONegotiationFailure, dbus_interface=self.wpas_dbus_interfaces_p2pdevice, signal_name="GONegotiationFailure") self.bus.add_signal_receiver( self.GroupStarted, dbus_interface=self.wpas_dbus_interfaces_p2pdevice, signal_name="GroupStarted") self.bus.add_signal_receiver( self.WpsFailure, dbus_interface=self.wpas_dbus_interfaces_p2pdevice, signal_name="WpsFailed") self.bus.add_signal_receiver( self.GroupFinished, dbus_interface=self.wpas_dbus_interfaces_p2pdevice, signal_name="GroupFinished")
def main(): parser = ArgumentParser(description=sys.argv[0]) parser.add_argument( '--servicebase', help='Base service name on dbus, default is com.victronenergy', default='com.victronenergy') parser.add_argument( '--debug', help= 'Enable debug counter, this ignores the real gpios and simulates input', default=False, action="store_true") parser.add_argument('inputs', nargs='+', help='Path to digital input') args = parser.parse_args() if args.debug: PulseCounter = DebugPulseCounter else: PulseCounter = EpollPulseCounter DBusGMainLoop(set_as_default=True) # Keep track of enabled services services = {} inputs = dict(enumerate(args.inputs, 1)) pulses = PulseCounter() # callable that iterates over pulses def register_gpio(path, gpio, bus, settings): _type = settings['inputtype'] print "Registering GPIO {} for type {}".format(gpio, _type) handler = PinHandler.createHandler(_type, bus, args.servicebase, path, gpio, settings) services[gpio] = handler # Only monitor if enabled if _type > 0: pulses.register(path, gpio) def unregister_gpio(gpio): print "unRegistering GPIO {}".format(gpio) pulses.unregister(gpio) services[gpio].deactivate() def handle_setting_change(inp, setting, old, new): if setting == 'inputtype': if new: # Get current bus and settings objects, to be reused service = services[inp] bus, settings = service.bus, service.settings # Input enabled. If already enabled, unregister the old one first. if pulses.registered(inp): unregister_gpio(inp) register_gpio(inputs[inp], inp, bus, settings) elif old: # Input disabled unregister_gpio(inp) elif setting in ('rate', 'invert', 'alarm'): services[inp].refresh() elif setting == 'name': services[inp].product_name = new for inp, pth in inputs.items(): supported_settings = { 'inputtype': [ '/Settings/DigitalInput/{}/Type'.format(inp), 0, 0, len(INPUTTYPES) ], 'rate': [ '/Settings/DigitalInput/{}/Multiplier'.format(inp), 0.001, 0, 1.0 ], 'count': ['/Settings/DigitalInput/{}/Count'.format(inp), 0, 0, MAXCOUNT, 1], 'invert': [ '/Settings/DigitalInput/{}/InvertTranslation'.format(inp), 0, 0, 1 ], 'alarm': ['/Settings/DigitalInput/{}/AlarmSetting'.format(inp), 0, 0, 1], 'name': ['/Settings/DigitalInput/{}/CustomName'.format(inp), '', '', ''], } bus = dbusconnection() sd = SettingsDevice(bus, supported_settings, partial(handle_setting_change, inp), timeout=10) register_gpio(pth, inp, bus, sd) def poll(mainloop): from time import time idx = 0 try: for inp, level in pulses(): # epoll object only resyncs once a second. We may receive # a pulse for something that's been deregistered. try: services[inp].toggle(level) except KeyError: continue except: traceback.print_exc() mainloop.quit() # Need to run the gpio polling in separate thread. Pass in the mainloop so # the thread can kill us if there is an exception. gobject.threads_init() mainloop = gobject.MainLoop() poller = Thread(target=lambda: poll(mainloop)) poller.daemon = True poller.start() # Periodically save the counter def save_counters(): for inp in inputs: services[inp].save_count() return True gobject.timeout_add(SAVEINTERVAL, save_counters) # Save counter on shutdown signal.signal(signal.SIGTERM, lambda *args: sys.exit(0)) try: mainloop.run() except KeyboardInterrupt: pass finally: save_counters()
def _dbus_init(self): dbus_loop = DBusGMainLoop() bus = dbus.SessionBus(mainloop=dbus_loop) bus.add_signal_receiver(self._layout_changed, dbus_interface='ru.gentoo.kbdd', signal_name='layoutChanged')
def do_startup(self): Gtk.Application.do_startup(self) self.create_actions() builder = Gtk.Builder() builder.set_translation_domain(gpodder.textdomain) menu_filename = None for ui_folder in gpodder.ui_folders: filename = os.path.join(ui_folder, 'gtk/menus.ui') if os.path.exists(filename): builder.add_from_file(filename) menu_filename = filename break menubar = builder.get_object('menubar') if menubar is None: logger.error('Cannot find gtk/menus.ui in %r, exiting' % gpodder.ui_folders) sys.exit(1) self.menu_view_columns = builder.get_object('menuViewColumns') self.set_menubar(menubar) # If $XDG_CURRENT_DESKTOP is set then it contains a colon-separated list of strings. # https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html # See https://askubuntu.com/a/227669 for a list of values in different environments xdg_current_desktops = os.environ.get('XDG_CURRENT_DESKTOP', '').split(':') # See https://developer.gnome.org/gtk3/stable/gtk-running.html # GTK_CSD=0 is used to disable client side decorations csd_disabled = os.environ.get('GTK_CSD') == '0' self.want_headerbar = ('GNOME' in xdg_current_desktops) and not gpodder.ui.osx and not csd_disabled self.app_menu = builder.get_object('app-menu') if self.want_headerbar: # Use GtkHeaderBar for client-side decorations on recent GNOME 3 versions self.header_bar_menu_button = Gtk.Button.new_from_icon_name('open-menu-symbolic', Gtk.IconSize.SMALL_TOOLBAR) self.header_bar_menu_button.set_action_name('app.menu') self.header_bar_refresh_button = Gtk.Button.new_from_icon_name('view-refresh-symbolic', Gtk.IconSize.SMALL_TOOLBAR) self.header_bar_refresh_button.set_action_name('win.updateChannel') self.menu_popover = Gtk.Popover.new_from_model(self.header_bar_menu_button, self.app_menu) self.menu_popover.set_position(Gtk.PositionType.BOTTOM) for (accel, action) in parse_app_menu_for_accels(menu_filename): self.add_accelerator(accel, action, None) else: self.set_app_menu(self.app_menu) Gtk.Window.set_default_icon_name('gpodder') try: dbus_main_loop = DBusGMainLoop(set_as_default=True) gpodder.dbus_session_bus = dbus.SessionBus(dbus_main_loop) self.bus_name = dbus.service.BusName(gpodder.dbus_bus_name, bus=gpodder.dbus_session_bus) except dbus.exceptions.DBusException as dbe: logger.warn('Cannot get "on the bus".', exc_info=True) dlg = Gtk.MessageDialog(None, Gtk.DialogFlags.MODAL, Gtk.MessageType.ERROR, Gtk.ButtonsType.CLOSE, _('Cannot start gPodder')) dlg.format_secondary_markup(_('D-Bus error: %s') % (str(dbe),)) dlg.set_title('gPodder') dlg.run() dlg.destroy() sys.exit(0) util.idle_add(self.check_root_folder_path_gui)
def main(): """ Main function that starts everything """ if is_wayland( ) and gdk_backend().lower() != 'x11' and not is_wayland_compatibility_on(): warn = """ [!] Looks like you are in Wayland session Please run Ulauncher with env var GDK_BACKEND set to 'x11' like this: GDK_BACKEND=x11 ulauncher """ print(warn, file=sys.stderr) sys.exit(1) # start DBus loop DBusGMainLoop(set_as_default=True) bus = dbus.SessionBus() instance = bus.request_name(DBUS_SERVICE) if instance != dbus.bus.REQUEST_NAME_REPLY_PRIMARY_OWNER: toggle_window = dbus.SessionBus().get_object( DBUS_SERVICE, DBUS_PATH).get_dbus_method("toggle_window") toggle_window() return _create_dirs() options = get_options() setup_logging(options) logger = logging.getLogger('ulauncher') logger.info('Ulauncher version %s', get_version()) logger.info('Extension API version %s', api_version) logger.info("GTK+ %s.%s.%s", Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) logger.info("Is Wayland: %s", is_wayland()) logger.info("Wayland compatibility: %s", ('on' if is_wayland_compatibility_on() else 'off')) # log uncaught exceptions def except_hook(exctype, value, tb): logger.error("Uncaught exception", exc_info=(exctype, value, tb)) sys.excepthook = except_hook window = UlauncherWindow.get_instance() UlauncherDbusService(window) if not options.hide_window: window.show() if Settings.get_instance().get_property('show-indicator-icon'): AppIndicator.get_instance().show() # workaround to make Ctrl+C quiting the app signal_handler = SignalHandler(window) gtk_thread = run_async(Gtk.main)() try: while gtk_thread.is_alive() and not signal_handler.killed(): time.sleep(0.5) except KeyboardInterrupt: logger.warning('On KeyboardInterrupt') finally: Gtk.main_quit()
self.service = bus.get_object(MUNIN_BUS_NAME, '/' + MUNIN_BUS_NAME.replace('.', '/')) def connect_signal(self, signal_name, callback): self.service.connect_to_signal(signal_name, callback, dbus_interface=MUNIN_INTERFACE) def __call__(self, name, *args, **kwargs): method = self.service.get_dbus_method(name, MUNIN_BUS_NAME) if kwargs.get('async') is not None: # Make dbus python-dbus call this method async kwargs['reply_handler'] = kwargs.get('async') kwargs['error_handler'] = lambda *_: _ return method(*args, **kwargs) if __name__ == '__main__': loop = DBusGMainLoop(set_as_default=True) sess = SessionClient('test') def hellower(): print('... async call:', end='') sess('rebuild', 'full', async=lambda: print('client: finished')) print('... [DONE]') return True GLib.timeout_add(500, hellower) GLib.MainLoop().run() loop.run()
def handle_system_suspend(): DBusGMainLoop(set_as_default=True) bus = dbus.SystemBus() bus.add_signal_receiver(handle_suspend_callback, 'PrepareForSleep', 'org.freedesktop.login1.Manager', 'org.freedesktop.login1')
def run(self): DBusGMainLoop(set_as_default=True) GObject.threads_init() dbus.mainloop.glib.threads_init()
class SessionClient: def __init__(self, name): bus = dbus.SessionBus() self.service = bus.get_object(MUNIN_BUS_NAME, "/" + MUNIN_BUS_NAME.replace(".", "/")) def connect_signal(self, signal_name, callback): self.service.connect_to_signal(signal_name, callback, dbus_interface=MUNIN_INTERFACE) def __call__(self, name, *args, **kwargs): method = self.service.get_dbus_method(name, MUNIN_BUS_NAME) if kwargs.get("async") is not None: # Make dbus python-dbus call this method async kwargs["reply_handler"] = kwargs.get("async") kwargs["error_handler"] = lambda *_: _ return method(*args, **kwargs) if __name__ == "__main__": loop = DBusGMainLoop(set_as_default=True) sess = SessionClient("test") def hellower(): print("... async call:", end="") sess("rebuild", "full", async=lambda: print("client: finished")) print("... [DONE]") return True GLib.timeout_add(500, hellower) GLib.MainLoop().run() loop.run()
def main(): ap = argparse.ArgumentParser() ap.add_argument('--debug', action='store_true') ap.add_argument('--sound', dest='sound_spec', action='append', help='registers a sound for a specific filter with format <filter-name>:<file-path> or use format <file-path> for everything') ap.add_argument('--filter', dest='filters', action='append', choices=FILTERS.keys()) ap.add_argument('--player', default=DEFAULT_PLAYER) ap.add_argument('--rate-ms', type=int, default=DEFAULT_RATE_MS) params = ap.parse_args() logging.basicConfig( datefmt='%H:%M:%S', format='%(asctime)s %(levelname)5s - %(message)s', level='DEBUG' if params.debug else 'INFO', stream=sys.stdout, ) LOG.debug('build sound registry: %s', params.sound_spec) sounds = {'*': DEFAULT_SOUND} if params.sound_spec: for spec in params.sound_spec: spec = spec.strip() # type: str m = PATTERN_SOUNDSPEC.match(spec) if m: key = m.group('name').lower() value = m.group('path') if key not in FILTERS: ap.error('unknown filter %r in sound spec %r' % (key, spec)) return else: key = '*' value = spec if not os.access(value, os.R_OK): ap.error('audio file %r cannot be read in sound spec %r' % (value, spec)) return sounds[key] = value LOG.debug('sound registry: %s', sounds) LOG.debug('check audio player') if not os.access(params.player, os.R_OK | os.X_OK): ap.error('player %r does not exist or is not executable' % (params.player,)) LOG.debug('initialize dbus') DBusGMainLoop(set_as_default=True) bus = SessionBus() filter_keys = tuple(sorted(set(params.filters if params.filters else FILTERS.keys()))) subscribe_to_messages(bus, filter_keys) audio_player = AudioPlayer(params.player, sounds, params.rate_ms) attach_message_handler(bus, audio_player, filter_keys) LOG.info('ONLINE') loop = GLib.MainLoop() try: loop.run() except KeyboardInterrupt: loop.quit()
def register(self): if self.registered: return try: # register the main loop for d-bus events DBusGMainLoop(set_as_default=True) bus = dbus.SessionBus() except dbus.DBusException as e: raise DRingCtrlDBusError("Unable to connect DBUS session bus") if not bus.name_has_owner(DBUS_DEAMON_OBJECT): raise DRingCtrlDBusError(("Unable to find %s in DBUS." % DBUS_DEAMON_OBJECT) + " Check if dring is running") try: proxy_instance = bus.get_object(DBUS_DEAMON_OBJECT, DBUS_DEAMON_PATH + '/Instance', introspect=False) proxy_callmgr = bus.get_object(DBUS_DEAMON_OBJECT, DBUS_DEAMON_PATH + '/CallManager', introspect=False) proxy_confmgr = bus.get_object(DBUS_DEAMON_OBJECT, DBUS_DEAMON_PATH + '/ConfigurationManager', introspect=False) proxy_videomgr = bus.get_object(DBUS_DEAMON_OBJECT, DBUS_DEAMON_PATH + '/VideoManager', introspect=False) self.instance = dbus.Interface(proxy_instance, DBUS_DEAMON_OBJECT + '.Instance') self.callmanager = dbus.Interface( proxy_callmgr, DBUS_DEAMON_OBJECT + '.CallManager') self.configurationmanager = dbus.Interface( proxy_confmgr, DBUS_DEAMON_OBJECT + '.ConfigurationManager') if proxy_videomgr: self.videomanager = dbus.Interface( proxy_videomgr, DBUS_DEAMON_OBJECT + '.VideoManager') except dbus.DBusException as e: raise DRingCtrlDBusError("Unable to bind to dring DBus API") try: self.instance.Register(os.getpid(), self.name) self.registered = True except dbus.DBusException as e: raise DRingCtrlDeamonError("Client registration failed") try: proxy_callmgr.connect_to_signal('incomingCall', self.onIncomingCall) proxy_callmgr.connect_to_signal('callStateChanged', self.onCallStateChanged) proxy_callmgr.connect_to_signal('conferenceCreated', self.onConferenceCreated) proxy_confmgr.connect_to_signal('accountsChanged', self.onAccountsChanged) except dbus.DBusException as e: raise DRingCtrlDBusError("Unable to connect to dring DBus signals")
def main(): logging.basicConfig(level=logging.INFO) DBusGMainLoop(set_as_default=True) conn = dbus.SystemBus() generators = smart_dict() consumers = smart_dict() stats = smart_dict() # Set the user timezone if 'TZ' not in os.environ: tz = query(conn, "com.victronenergy.settings", "/Settings/System/TimeZone") if tz is not None: os.environ['TZ'] = tz # Find solarcharger services solarchargers = find_services(conn, 'solarcharger') logger.info("Found solarchargers at %s", ', '.join(solarchargers)) # Find grid meters meters = find_services(conn, 'grid') logger.info("Found grid meters at %s", ', '.join(meters)) # Find vebus service vebus = str(query(conn, "com.victronenergy.system", "/VebusService")) logger.info("Found vebus at %s", vebus) # Track solarcharger yield for charger in solarchargers: track(conn, generators, charger, "/Yield/User", charger) # Track grid consumption for meter in meters: track(conn, consumers, meter, "/Ac/L1/Energy/Forward", meter) # Track vebus consumption, from battery to input and output track(conn, consumers, vebus, "/Energy/InverterToAcOut", "c1") track(conn, consumers, vebus, "/Energy/InverterToAcIn1", "c2") # Track power values track(conn, stats, "com.victronenergy.system", "/Ac/Consumption/L1/Power", "pc") track(conn, stats, "com.victronenergy.system", "/Dc/Pv/Power", "pg") # Periodic work def _upload(): energy_generated = sum(filter(None, generators.itervalues())) energy_consumed = sum(filter(None, consumers.itervalues())) logger.info("EG: %.2f, EC: %.2f, PG: %.2f, PC: %.2f", energy_generated, energy_consumed, stats.pg, stats.pc) # Post the values to pvoutput now = datetime.now() payload = { "d": now.strftime("%Y%m%d"), "t": now.strftime("%H:%M"), "v1": int(energy_generated * 1000), "v2": int(stats.pg), "v3": int(energy_consumed * 1000), "v4": int(stats.pc), "c1": 1 } try: requests.post(PVOUTPUT, headers={ "X-Pvoutput-Apikey": APIKEY, "X-Pvoutput-SystemId": SYSTEMID }, data=payload) except: pass return True _upload() gobject.timeout_add(INTERVAL, _upload) gobject.MainLoop().run()
def __init__(self, name, service_type='_ros-master._tcp', host=socket.gethostname(), port=11311, domain='local', txt_array=[]): ''' Initialization method of the Zeroconf class. :param name: the name of the local ROS master :type name: str :param service_type: the avahi service type :type service_type: str :param host: the host of the local ROS master :type host: str :param port: the port of the local ROS master :type port: int :param domain: the domain name :type domain: str :param txt_array: (optional) additional information :type txt_array: list of strings ''' self.masterInfo = MasterInfo(name, service_type, domain, host, port, txt_array) # FIXME Review thread locking as needed. # init thread threading.Thread.__init__(self) self._lock = threading.RLock() # Gobjects are an event based model of evil, do not trust them, DBusGMainLoop(set_as_default=True) # Magic? Yes, don't start threads without it. # Why? I'm sure thats documented somewhere. gobject.threads_init() dbus.mainloop.glib.threads_init() self.__main_loop = gobject.MainLoop() self.__bus = dbus.SystemBus() # Initialize iterface to DBUS Server self.__server = dbus.Interface(self.__bus.get_object(avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER) # The DBUS entry group self.__group = None # Monitor server state changes self.__server.connect_to_signal("StateChanged", self.__avahi_callback_state_changed) # the browser to register the updates and new services self.__browser = dbus.Interface(self.__bus.get_object(avahi.DBUS_NAME, self.__server.ServiceBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, self.masterInfo.stype, self.masterInfo.domain, dbus.UInt32(0))), avahi.DBUS_INTERFACE_SERVICE_BROWSER) self.__browser.connect_to_signal("ItemNew", self.__avahi_callback_service_browser_new) self.__browser.connect_to_signal("ItemRemove", self.__avahi_callback_service_browser_remove)
def __init__(self): DBusGMainLoop(set_as_default=True) self.session_bus = dbus.SessionBus() self.proxy = self.session_bus.get_object('org.xiphos.remote', '/org/xiphos/remote/ipc') self.session_bus.add_signal_receiver( self.receive_navigation, dbus_interface='org.xiphos.remote', signal_name='navigationSignal') self.session_bus.add_signal_receiver( self.receive_search_event, dbus_interface='org.xiphos.remote', signal_name='searchPerformedSignal') self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.connect("destroy", self.destroy) self.window.set_border_width(10) self.vbox = gtk.VBox() self.window.add(self.vbox) self.vbox.show() self.hbox = gtk.HBox() self.vbox.pack_start(self.hbox) self.hbox.show() self.entry = gtk.Entry() self.hbox.pack_start(self.entry) self.entry.show() self.button = gtk.Button("Navigate Xiphos") self.button.connect("clicked", self.navigate_xiphos, None) self.hbox.pack_end(self.button) self.button.show() self.hbox_ref = gtk.HBox() self.vbox.pack_end(self.hbox_ref) self.hbox_ref.show() self.label_ref_static = gtk.Label('Current Reference: ') self.hbox_ref.pack_start(self.label_ref_static) self.label_ref_static.show() self.label_ref = gtk.Label(self.proxy.getCurrentReference()) self.hbox_ref.pack_end(self.label_ref) self.label_ref.show() self.hbox_res = gtk.HBox() self.vbox.pack_end(self.hbox_res) self.hbox_res.show() self.scrollbox = gtk.ScrolledWindow() self.hbox_res.pack_end(self.scrollbox) self.scrollbox.show() self.results_tree = gtk.TreeView() self.results_tree.set_size_request(-1, 200) self.cell = gtk.CellRendererText() self.column = gtk.TreeViewColumn('Reference') self.column.pack_start(self.cell, True) self.column.add_attribute(self.cell, 'text', 0) self.results_tree.append_column(self.column) self.scrollbox.add(self.results_tree) self.results_tree.show() self.window.show()
def fullSync(name): """Triggers a full Sync of a resource and blocks until it is done. name: a string of the resource f.ex: akonadi_kolab_resource_0 you can find the resource from qdbusviewer org.freedesktop.Akonadu.Resource.<name> """ DBusGMainLoop(set_as_default=True) session_bus = dbus.SessionBus() def statusCallback(status, msg): logger.debug("%i: %s" % (status, msg)) if status == 0: logger.info("status switched to idle on {}.".format(name)) def synchronizedCallback(): logger.info("fullSync for {} complete.".format(name)) gobject.timeout_add(1, loop.quit) def warningCallback(msg): logger.info("Warning during sync: %s" % (msg)) def errorCallback(msg): logger.info("Error during sync: %s" % (msg)) timeout = 0 while 1: try: proxy = session_bus.get_object( 'org.freedesktop.Akonadi.Resource.{}'.format(name), "/") break except dbus.exceptions.DBusException: time.sleep(1) timeout = timeout + 1 if timeout >= 10: logger.critical( "Failed to find the resource on dbus {}".format(name)) sys.exit(-1) if not proxy.isOnline(): proxy.setOnline(True) time.sleep(1) if not proxy.isOnline() or proxy.statusMessage( ) == u'Server is not available.': logger.critical("Kolab server is not available.") sys.exit(-1) proxy.connect_to_signal( "status", statusCallback, dbus_interface="org.freedesktop.Akonadi.Agent.Status") proxy.connect_to_signal("synchronized", synchronizedCallback, dbus_interface="org.freedesktop.Akonadi.Resource") proxy.connect_to_signal( "warning", warningCallback, dbus_interface="org.freedesktop.Akonadi.Agent.Status") proxy.connect_to_signal( "error", errorCallback, dbus_interface="org.freedesktop.Akonadi.Agent.Status") proxy.synchronize(dbus_interface='org.freedesktop.Akonadi.Resource') logger.info("fullSync for {} started".format(name)) loop = gobject.MainLoop() loop.run()
def main(): DBusGMainLoop(set_as_default=True) session_bus = dbus.SessionBus() if not session_bus.name_has_owner(BUS_NAME): run_service()
def post_config_hook(self): if self.py3.is_gevent(): raise Exception(STRING_GEVENT) self._name_owner_change_match = None self._kill = False self._mpris_players: dict[Player] = {} self._identity_cache = {} self._identity_index = {} self._priority_cache = {} self._player: [Player, None] = None self._tries = 0 self._empty_response = { "album": None, "artist": None, "length": None, "title": None, "nowplaying": None, "time": None, "state": None, "player": None, # for debugging ;p "full_name": None, } self._states = { "pause": { "action": "Pause", "clickable": "CanPause", "icon": self.icon_pause, "inactive": [STATE.Stopped, STATE.Paused], }, "play": { "action": "Play", "clickable": "CanPlay", "icon": self.icon_play, "inactive": [STATE.Playing], }, "stop": { "action": "Stop", "clickable": "CanControl", "icon": self.icon_stop, "inactive": [STATE.Stopped], }, "next": { "action": "Next", "clickable": "CanGoNext", "icon": self.icon_next, }, "previous": { "action": "Previous", "clickable": "CanGoPrevious", "icon": self.icon_previous, }, "toggle": { "action": "PlayPause", "clickable": "CanPause", # Not used, but it will be set dynamically with player state map. "icon": None, }, } self._state_icon_color_map = { STATE.Playing: { "state_icon": self.state_play, "color": self.py3.COLOR_PLAYING or self.py3.COLOR_GOOD, "toggle_icon": self.state_pause, "cached_until": self.cache_timeout, }, STATE.Paused: { "state_icon": self.state_pause, "color": self.py3.COLOR_PAUSED or self.py3.COLOR_DEGRADED, "toggle_icon": self.state_play, "cached_until": self.py3.CACHE_FOREVER, }, STATE.Stopped: { "state_icon": self.state_stop, "color": self.py3.COLOR_STOPPED or self.py3.COLOR_BAD, "toggle_icon": self.state_play, "cached_until": self.py3.CACHE_FOREVER, }, } self._color_active = self.py3.COLOR_CONTROL_ACTIVE or self.py3.COLOR_GOOD self._color_inactive = self.py3.COLOR_CONTROL_INACTIVE or self.py3.COLOR_BAD self._format_contains_metadata = False self._metadata_keys = ["album", "artist", "title", "nowplaying", "length"] for key in self._metadata_keys: if self.py3.format_contains(self.format, key): self._format_contains_metadata = True break self._format_contains_control_buttons = False self._used_can_properties = [] for key, value in self._states.items(): if self.py3.format_contains(self.format, key): self._format_contains_control_buttons = True self._used_can_properties.append(value["clickable"]) if ( len(self.player_hide_non_canplay) and "CanPlay" not in self._used_can_properties ): self._used_can_properties.append("CanPlay") self._format_contains_time = self.py3.format_contains(self.format, "time") self._button_cache_flush = None if 2 not in [ self.button_next, self.button_next_player, self.button_prev_player, self.button_previous, self.button_stop, self.button_switch_to_top_player, self.button_toggle, ]: self._button_cache_flush = 2 if self.player_priority: try: self._random_player_priority = self.player_priority.index("*") except ValueError: self._random_player_priority = False else: self._random_player_priority = 0 # start last self._dbus_loop = DBusGMainLoop() self._dbus = SessionBus(mainloop=self._dbus_loop) self._start_listener()
def set_install_update(which): """ Install any available updates for the activity identified by the given (localized) name or bundle id, or all available updates if 'all' is given. """ import os ul = UpdateList(skip_icons=True) ul.refresh(_print_status) def too_many(): raise ValueError(_('More than one match found for the given activity name or id.')) def no_updates(): raise ValueError(_('The given activity is already up-to-date.')) if which != 'all': found = False for row in ul: row[UPDATE_SELECTED] = False for row in ul: if row[IS_HEADER]: continue if which==row[ACTIVITY_ID]: if found: too_many() found = True if not row[UPDATE_EXISTS]: no_updates() row[UPDATE_SELECTED] = True if not found: found_but_uptodate=False for row in ul: if row[IS_HEADER]: continue if which in row[DESCRIPTION_BIG]: if not row[UPDATE_EXISTS]: # could be false match found_but_uptodate=True continue if found: too_many() found = True row[UPDATE_SELECTED] = True if not found: if found_but_uptodate: no_updates() raise ValueError(_('No activity found with the given name or id.')) assert ul.updates_selected() == 1 # okay, now we've selected only our desired updates. Download and # install them! # we need to set up a glib event loop in order to connect to the # activity registry (sigh) in ActivityBundle.upgrade() below. from dbus.mainloop.glib import DBusGMainLoop DBusGMainLoop(set_as_default=True) # we'll fetch the main loop, but we don't actually have to run it. loop = GObject.MainLoop() from jarabe.model.bundleregistry import get_registry registry = get_registry() def reporthook(n, row): _print_status(n, _('Downloading %s...') % row[DESCRIPTION_BIG]) for row, f in ul.download_selected_updates(reporthook): if f is None: continue # cancelled or network error try: _print_status(None, _('Examining %s...') % row[DESCRIPTION_BIG]) b = actutils.BundleHelper(f) if b.is_installed(registry): _print_status(None, _('Upgrading %s...') % row[DESCRIPTION_BIG]) else: _print_status(None, _('Installing %s...')% row[DESCRIPTION_BIG]) b.install_or_upgrade(registry) except: print print _('Error installing %s.') % row[DESCRIPTION_BIG] import traceback traceback.print_exc() # complain! but go on. if os.path.exists(f): os.unlink(f) else: print "Failed trying to clean up", f
def main(): global args if os.geteuid() != 0: print('[E] No root no party. Try again with sudo.') sys.exit(1) parser = argparse.ArgumentParser() parser.add_argument('--debug', action='store_true', help='add some debug info and additional checks') parser.add_argument('--config', default='/etc/lenovo_fix.conf', help='override default config file path') args = parser.parse_args() config = load_config() power['source'] = 'BATTERY' if is_on_battery(config) else 'AC' platform_info = get_cpu_platform_info() if args.debug: for key, value in platform_info.items(): print('[D] cpu platform info: {} = {}'.format(key.replace("_", " "), value)) regs = calc_reg_values(platform_info, config) if not config.getboolean('GENERAL', 'Enabled'): return exit_event = Event() thread = Thread(target=power_thread, args=(config, regs, exit_event)) thread.daemon = True thread.start() undervolt(config) # handle dbus events for applying undervolt on resume from sleep/hybernate def handle_sleep_callback(sleeping): if not sleeping: undervolt(config) def handle_ac_callback(*args): try: power['source'] = 'BATTERY' if args[1]['Online'] == 0 else 'AC' power['method'] = 'dbus' except: power['method'] = 'polling' DBusGMainLoop(set_as_default=True) bus = dbus.SystemBus() # add dbus receiver only if undervolt is enabled in config if any(config.getfloat('UNDERVOLT', plane) != 0 for plane in VOLTAGE_PLANES): bus.add_signal_receiver(handle_sleep_callback, 'PrepareForSleep', 'org.freedesktop.login1.Manager', 'org.freedesktop.login1') bus.add_signal_receiver( handle_ac_callback, signal_name="PropertiesChanged", dbus_interface="org.freedesktop.DBus.Properties", path="/org/freedesktop/UPower/devices/line_power_AC") try: loop = GLib.MainLoop() loop.run() except (KeyboardInterrupt, SystemExit): pass exit_event.set() loop.quit() thread.join(timeout=1)
import dbus from dbus.mainloop.glib import DBusGMainLoop import gobject service = "org.mpris.demo" #service = "org.mpris.audacious" interface = "org.freedesktop.MediaPlayer" object_path = "/Player" loop = gobject.MainLoop() def track_change_cb(track, sender=None): print "Track changed: %s" % track['title'] print "Sender is: %s" % sender if __name__ == '__main__': mainloop = DBusGMainLoop() session = dbus.SessionBus(mainloop=mainloop) try: proxy = session.get_object(service, object_path) except dbus.DBusException: print "Can not connect to service" exit(1) iface = dbus.Interface(proxy, dbus_interface=interface) iface.connect_to_signal("TrackChange", track_change_cb, sender_keyword="sender") loop.run()
def main(): global args parser = argparse.ArgumentParser() exclusive_group = parser.add_mutually_exclusive_group() exclusive_group.add_argument( '--debug', action='store_true', help='add some debug info and additional checks') exclusive_group.add_argument( '--monitor', metavar='update_rate', const=1.0, type=float, nargs='?', help='realtime monitoring of throttling causes (default 1s)', ) parser.add_argument('--config', default='/etc/lenovo_fix.conf', help='override default config file path') parser.add_argument('--force', action='store_true', help='bypass compatibility checks (EXPERTS only)') parser.add_argument('--log', metavar='/path/to/file', help='log to file instead of stdout') args = parser.parse_args() if args.log: try: args.log = open(args.log, 'w') except: args.log = None fatal('Unable to write to the log file!') if not args.force: check_kernel() check_cpu() set_msr_allow_writes() log('[I] Loading config file.') config = load_config() power['source'] = 'BATTERY' if is_on_battery(config) else 'AC' platform_info = get_cpu_platform_info() if args.debug: for key, value in platform_info.items(): log('[D] cpu platform info: {} = {}'.format( key.replace("_", " "), value)) regs = calc_reg_values(platform_info, config) if not config.getboolean('GENERAL', 'Enabled'): log('[I] Throttled is disabled in config file... Quitting. :(') return undervolt(config) set_icc_max(config) set_hwp(config.getboolean('AC', 'HWP_Mode', fallback=False)) exit_event = Event() thread = Thread(target=power_thread, args=(config, regs, exit_event)) thread.daemon = True thread.start() # handle dbus events for applying undervolt/IccMax on resume from sleep/hybernate def handle_sleep_callback(sleeping): if not sleeping: undervolt(config) set_icc_max(config) def handle_ac_callback(*args): try: power['source'] = 'BATTERY' if args[1]['Online'] == 0 else 'AC' power['method'] = 'dbus' except: power['method'] = 'polling' DBusGMainLoop(set_as_default=True) bus = dbus.SystemBus() # add dbus receiver only if undervolt/IccMax is enabled in config if any( config.getfloat(key, plane, fallback=0) != 0 for plane in VOLTAGE_PLANES for key in UNDERVOLT_KEYS + ICCMAX_KEYS): bus.add_signal_receiver(handle_sleep_callback, 'PrepareForSleep', 'org.freedesktop.login1.Manager', 'org.freedesktop.login1') bus.add_signal_receiver( handle_ac_callback, signal_name="PropertiesChanged", dbus_interface="org.freedesktop.DBus.Properties", path="/org/freedesktop/UPower/devices/line_power_AC", ) log('[I] Starting main loop.') if args.monitor is not None: monitor_thread = Thread(target=monitor, args=(exit_event, args.monitor)) monitor_thread.daemon = True monitor_thread.start() try: loop = GLib.MainLoop() loop.run() except (KeyboardInterrupt, SystemExit): pass exit_event.set() loop.quit() thread.join(timeout=1) if args.monitor is not None: monitor_thread.join(timeout=0.1)
import mido import dbus import signal from dbus.mainloop.glib import DBusGMainLoop from gi.repository import GLib from midi_controller import MidiController from dbus_media_player_monitor import DbusMediaPlayerMonitor from audio_mixer import AudioMixer from event_handler import EventHandler mido.set_backend('mido.backends.rtmidi/LINUX_ALSA') controller = MidiController('X-Touch One') controller.reset() dbus_loop = DBusGMainLoop(set_as_default=True) session_bus = dbus.SessionBus(mainloop=dbus_loop) monitor = DbusMediaPlayerMonitor(session_bus) mixer = AudioMixer() handler = EventHandler(controller, monitor, mixer) handler.setup() loop = GLib.MainLoop() def sigint_handler(sig, frame): if sig == signal.SIGINT: loop.quit()
def __init__(self, wanted_myos=None, sleep=False, verbose=False): self.sleep = sleep self.verbose = verbose # Event loop and dbus DBusGMainLoop(set_as_default=True) self.loop = GLib.MainLoop() self.bus = dbus.SystemBus() self.myos = {} self.timers = [] self.status = [] self.num_myos = 0 connected_myos = discover_available_myos() use_these_myos = [] if wanted_myos is None: use_these_myos = list(connected_myos.values()) else: for myo in wanted_myos: if myo not in connected_myos: print("Error: {} not connected".format(myo)) return None for i, myo in enumerate(use_these_myos): self.myos[myo['path']] = MyoDbus(self.bus, myo['path']) self.myos[myo['path']].num = i self.num_myos = len(self.myos) if self.num_myos == 0: if wanted_myos is None: print("No devices available.") else: print("None of the specified devices were available.") sys.exit(0) """ Connect to all and subscribe to IMU """ for myo in self.myos.itervalues(): myo.connect(wait=True) if verbose: self.timers.append(Timer("{}".format(myo.myo_name), 1)) self.status.append(None) myo.lock() myo.setNeverSleep() myo.subscribeToIMU() myo.attachIMUHandler(self.handleIMU) myo.enableIMU() print("Battery: {}%".format(myo.getBatterLevel())) print("Sensor name: {}".format(myo.getName())) # Connect to message bus self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) messageBusAddress = '/tmp/sensor_producer' print("Connecting to message bus at {}".format(messageBusAddress)) try: self.sock.connect(messageBusAddress) except socket.error: print(socket.error) sys.exit(1) else: print("Connected to message bus") # Start main loop try: print("Running main loop!") self.loop.run() except KeyboardInterrupt: print("\nShutting down...") self.sock.close() self.loop.quit() for myo in self.myos.itervalues(): print("Disconnecting...") myo.unsubscribeFromIMU() myo.detachIMUHandler() myo.disableIMU_EMG_CLF() myo.vibrate(duration='short') if args.sleep: print("Setting Myo to deep sleep...") myo.setDeepSleep() myo.disconnect()
import dbus import pytest from dbus.mainloop.glib import DBusGMainLoop from dbusmock import DBusTestCase from wiring.scanning import scan_to_graph from focusyn.pomodoro import Application from focusyn.pomodoro.app import State DBusGMainLoop(set_as_default=True) @pytest.fixture def app(graph, window, plugin_engine, mocker) -> Application: graph.register_instance("focusyn.ui.view", window) graph.register_instance("focusyn.plugin", plugin_engine) graph.register_instance("dbus.session", mocker.Mock()) scan_to_graph(["focusyn.pomodoro.app"], graph) return graph.get("focusyn.app") def test_module(graph, app): instance = graph.get("focusyn.app") assert isinstance(instance, Application) assert instance is app def test_collects_plugins_on_start(app, plugin_engine):
"No session data about %s, no need to restore session." % (buf.url)) else: print( "No data present in session file, no need to restore session." ) else: print("Not found %s, no need restore session." % (self.session_file_path)) if __name__ == "__main__": import sys import signal DBusGMainLoop(set_as_default=True) # WARING: only use once in one process bus = dbus.SessionBus() if bus.request_name( EAF_DBUS_NAME) != dbus.bus.REQUEST_NAME_REPLY_PRIMARY_OWNER: print("EAF process has startup.") else: emacs_width = emacs_height = 0 app = QApplication(sys.argv) eaf = EAF(sys.argv[1:]) print("EAF process start.") signal.signal(signal.SIGINT, signal.SIG_DFL)
def init_dbus(): from calibre.constants import islinux, isbsd if islinux or isbsd: from dbus.mainloop.glib import DBusGMainLoop, threads_init threads_init() DBusGMainLoop(set_as_default=True)
def listen(): TYPE = "_ssm._tcp" def store(devic): global device device=devic def service_resolved(*args): """ Resolves the services so found """ global device print 'service resolved' print 'name:', args[2] #print IP, PORT print 'address:', args[7] print 'port:', args[8] device['IP'].append(str(args[7])) device['PORT'].append(int(args[8])) store(device) #Below I have excluded IPv6 addresses from consideration. #Another thing is I have hardcoded that the Service listener should discover X number of devices and then the loop should quit,else the Loop will #keep running and my code after that will not work.There is a solution to this:Multithreading.I am not aware of how to do that in python,so I left it #like this. if ":" in device['IP'][-1] : del device['IP'][-1] del device['PORT'][-1] if len(device['IP'])==3: loop.quit() def print_error(*args): global device print 'error_handler' print args[0] def myhandler(interface, protocol, name, stype, domain, flags): global device print "Found service '%s' type '%s' domain '%s' " % (name, stype, domain) if flags & avahi.LOOKUP_RESULT_LOCAL: # local service, skip pass server.ResolveService(interface, protocol, name, stype, domain, avahi.PROTO_UNSPEC, dbus.UInt32(0), reply_handler=service_resolved, error_handler=print_error) #print IP, PORT loop = DBusGMainLoop() bus = dbus.SystemBus(mainloop=loop) server = dbus.Interface( bus.get_object(avahi.DBUS_NAME, '/'), 'org.freedesktop.Avahi.Server') sbrowser = dbus.Interface(bus.get_object(avahi.DBUS_NAME, server.ServiceBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, TYPE, 'local', dbus.UInt32(0))), avahi.DBUS_INTERFACE_SERVICE_BROWSER) sbrowser.connect_to_signal("ItemNew", myhandler) loop=gobject.MainLoop() loop.run()