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