def transaction(self):
if dnfpluginsextras.is_erasing(self.base.transaction,
"snapper"):
return
try:
bus = SystemBus()
snapper = Interface(bus.get_object('org.opensuse.Snapper',
'/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logger.critical(
"snapper: " + _("connect to snapperd failed: %s"), e
)
return
try:
logger.debug(
"snapper: " + _("creating snapshot")
)
snap = snapper.CreateSingleSnapshot("root", self.description, "", {})
logger.debug(
"snapper: " + _("created snapshot %d"), snap
)
except DBusException as e:
logger.critical(
"snapper: " + _("creating snapshot failed: %s"), e
)
def check_service_status(service):
""" queries systemd through dbus to see if the service is running """
service_running = False
bus = SystemBus()
systemd = bus.get_object("org.freedesktop.systemd1", "/org/freedesktop/systemd1")
manager = Interface(systemd, dbus_interface="org.freedesktop.systemd1.Manager")
try:
service_unit = (
service
if service.endswith(".service")
else manager.GetUnit(f"{service}.service")
)
service_proxy = bus.get_object("org.freedesktop.systemd1", str(service_unit))
service_props = Interface(
service_proxy, dbus_interface="org.freedesktop.DBus.Properties"
)
service_load_state = service_props.Get(
"org.freedesktop.systemd1.Unit", "LoadState"
)
service_active_state = service_props.Get(
"org.freedesktop.systemd1.Unit", "ActiveState"
)
if service_load_state == "loaded" and service_active_state == "active":
service_running = True
except DBusException:
pass
return service_running
def __init__(self, iface: str = 'hci0', ioc: str = 'NoInputNoOutput'):
super().__init__(iface=iface)
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
sys_bus = SystemBus()
self.agent_registered = False
def register_agent_callback():
logger.info('Agent object registered')
print(INFO_INDENT,
"IO capability: {}".format(
self.bluescan_agent.io_capability),
sep='')
self.agent_registered = True
def register_agent_error_callback(error):
logger.error("Failed to register agent object")
print(ERROR_INDENT, "{}".format(error), sep='')
print(ERROR_INDENT,
"IO capability: {}".format(
self.bluescan_agent.io_capability),
sep='')
self.agent_registered = False
self.bluescan_agent = BluescanAgent(sys_bus, 0, ioc)
self.agent_mgr_1_iface = dbus.Interface(
sys_bus.get_object(BLUEZ_NAME, '/org/bluez'), IFACE_AGENT_MGR_1)
self.agent_mgr_1_iface.RegisterAgent(
ObjectPath(self.bluescan_agent.path),
self.bluescan_agent.io_capability,
reply_handler=register_agent_callback,
error_handler=register_agent_error_callback)
def __init__(self, iface: str = 'hci0', ioc: str = 'NoInputNoOutput'):
super().__init__(iface=iface)
self.result = GattScanResult()
self.gatt_client = None
self.spinner = Halo()
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
sys_bus = SystemBus()
self.agent_registered = False
def register_agent_callback():
logger.debug('Agent object registered\n'
"IO capability: {}".format(
self.bluescan_agent.io_capability))
self.agent_registered = True
def register_agent_error_callback(error):
logger.error(
"Failed to register agent object.\n" + "{}\n".format(error) +
"IO capability: {}".format(self.bluescan_agent.io_capability))
self.agent_registered = False
self.bluescan_agent = BluescanAgent(sys_bus, 0, ioc)
self.agent_mgr_1_iface = dbus.Interface(
sys_bus.get_object(BLUEZ_NAME, '/org/bluez'), IFACE_AGENT_MGR_1)
self.agent_mgr_1_iface.RegisterAgent(
ObjectPath(self.bluescan_agent.path),
self.bluescan_agent.io_capability,
reply_handler=register_agent_callback,
error_handler=register_agent_error_callback)
def __init__(self, logger_instance, notifier_instance):
"""
Initialize class
"""
super(ThumbDriveDetector, self).__init__()
self._logger = logger_instance
self._logger.debug("ThumbDriveDetector.__init__ called")
# Unblock main thread by calling this method.
dbus.mainloop.glib.threads_init()
# Set global default main loop
DBusGMainLoop(set_as_default=True)
self._udisk2_interface = 'org.freedesktop.UDisks2'
self._object_manager_interface = 'org.freedesktop.DBus.ObjectManager'
self._object_path = '/org/freedesktop/UDisks2'
self._drive_interface = "org.freedesktop.UDisks2.Drive"
self._bus = SystemBus()
# Unblock main thread by calling this method.
gobject.threads_init()
# Create instance of main event loop and run it
self._loop = gobject.MainLoop()
self._notifier = notifier_instance
self._logger.debug("Instantiated ThumbDriveDetector")
def pre_transaction(self):
if not self.base.transaction:
return
try:
bus = SystemBus()
self._snapper = Interface(bus.get_object('org.opensuse.Snapper',
'/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logger.critical(
"snapper: " + _("connect to snapperd failed: %s"), e
)
return
try:
logger.debug(
"snapper: " + _("creating pre_snapshot")
)
self._pre_snap_number = self._snapper.CreatePreSnapshot("root", self.description,
"number", {})
self._pre_snap_created = True
logger.debug(
"snapper: " + _("created pre_snapshot %d"), self._pre_snap_number
)
except DBusException as e:
logger.critical(
"snapper: " + _("creating pre_snapshot failed: %s"), e
)
def initialize(self, conf_reader, msgQlist, product):
"""initialize configuration reader and internal msg queues."""
# Initialize ScheduledMonitorThread and InternalMsgQ
super(ServiceMonitor, self).initialize(conf_reader)
# Initialize internal message queues for this module
super(ServiceMonitor, self).initialize_msgQ(msgQlist)
self.iem = Iem()
self.iem.check_exsisting_fault_iems()
self.KAFKA = self.iem.EVENT_CODE["KAFKA_ACTIVE"][1]
# Integrate into the main dbus loop to catch events
DBusGMainLoop(set_as_default=True)
# Initialize SystemBus and get Manager Interface
self._bus = SystemBus()
systemd = self._bus.get_object("org.freedesktop.systemd1",
"/org/freedesktop/systemd1")
self._manager = Interface(
systemd, dbus_interface='org.freedesktop.systemd1.Manager')
self.remove_disabled_services()
return True
def is_service_running(service):
""" Queries systemd through dbus to see if the service is running """
service_running = False
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = dbus.Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
try:
service_unit = service if service.endswith(
'.service') else manager.GetUnit("{}.service".format(service))
service_proxy = bus.get_object('org.freedesktop.systemd1',
str(service_unit))
service_properties = dbus.Interface(
service_proxy, dbus_interface='org.freedesktop.DBus.Properties')
service_load_state = service_properties.Get(
'org.freedesktop.systemd1.Unit', 'LoadState')
service_active_state = service_properties.Get(
'org.freedesktop.systemd1.Unit', 'ActiveState')
if service_load_state == 'loaded' and service_active_state == 'active':
service_running = True
except dbus.DBusException as error:
logging.error(str(error))
return service_running
def __init__(self, object_path, service_object = None) : super().__init__(object_path, service_object) self._bus = SystemBus() self._systemd_manager = DBusInterface(self._bus.get_object( 'org.freedesktop.systemd1', '/org/freedesktop/systemd1' ), 'org.freedesktop.systemd1.Manager')
def __init__(self):
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
self.manager = Interface(systemd, 'org.freedesktop.systemd1.Manager')
self.supported_operations = ['stop', 'start', 'restart']
def set_dns_systemd_resolved(lease):
# NOTE: if systemd-resolved is not already running, we might not want to
# run it in case there's specific system configuration for other resolvers
ipr = IPRoute()
index = ipr.link_lookup(ifname=lease.interface)[0]
# Construct the argument to pass to DBUS.
# the equivalent argument for:
# busctl call org.freedesktop.resolve1 /org/freedesktop/resolve1 \
# org.freedesktop.resolve1.Manager SetLinkDNS 'ia(iay)' 2 1 2 4 1 2 3 4
# is SetLinkDNS(2, [(2, [8, 8, 8, 8])]_
iay = [(2, [int(b) for b in ns.split('.')])
for ns in lease.name_server.split()]
# if '.' in ns
# else (10, [ord(x) for x in
# socket.inet_pton(socket.AF_INET6, ns)])
bus = SystemBus()
resolved = bus.get_object('org.freedesktop.resolve1',
'/org/freedesktop/resolve1')
manager = Interface(resolved,
dbus_interface='org.freedesktop.resolve1.Manager')
try:
manager.SetLinkDNS(index, iay)
return True
except DBusException as e:
logger.error(e)
return False
def set_dns_systemd_resolved(lease):
# NOTE: if systemd-resolved is not already running, we might not want to
# run it in case there's specific system configuration for other resolvers
ipr = IPRoute()
index = ipr.link_lookup(ifname=lease.interface)[0]
# Construct the argument to pass to DBUS.
# the equivalent argument for:
# busctl call org.freedesktop.resolve1 /org/freedesktop/resolve1 \
# org.freedesktop.resolve1.Manager SetLinkDNS 'ia(iay)' 2 1 2 4 1 2 3 4
# is SetLinkDNS(2, [(2, [8, 8, 8, 8])]_
iay = [(2, [int(b) for b in ns.split('.')])
for ns in lease.name_server.split()]
# if '.' in ns
# else (10, [ord(x) for x in
# socket.inet_pton(socket.AF_INET6, ns)])
bus = SystemBus()
resolved = bus.get_object('org.freedesktop.resolve1',
'/org/freedesktop/resolve1')
manager = Interface(resolved,
dbus_interface='org.freedesktop.resolve1.Manager')
try:
manager.SetLinkDNS(index, iay)
return True
except DBusException as e:
logger.error(e)
return False
def run():
loop = MainLoop()
bus = SystemBus(mainloop=dglib.DBusGMainLoop())
dglib.threads_init()
bat_object = bus.get_object(
'org.freedesktop.UPower',
'/org/freedesktop/UPower/devices/battery_BAT1')
bat = Interface(bat_object, 'org.freedesktop.DBus.Properties')
lemonbar = Feeder(i3, bat, bus, bar, display_title)
lemonbar.render_all()
pulse = Pulse('event-printer')
pulse.event_mask_set('sink', 'server')
pulse.event_callback_set(lemonbar.on_volume_event)
pulse_thread = Thread(target=pulse.event_listen, args=[0])
pulse_thread.daemon = True
pulse_thread.start()
bat_object.connect_to_signal(
"PropertiesChanged",
lemonbar.on_battery_event,
dbus_interface='org.freedesktop.DBus.Properties')
bat_thread = Thread(target=loop.run)
bat_thread.daemon = True
bat_thread.start()
sched = BackgroundScheduler(daemon=True)
sched.add_job(lemonbar.on_timedate_event, 'cron', second=0)
sched.start()
def shutdown(caller, e):
bar.stop_bar(wbak, bar_pid)
print(e.change)
exit(0)
def reload_bar(caller, data):
global bar_pid
bar.stop_bar(wbak, bar_pid)
#print("reloading...")
bar_pid = bar.start_bar()
lemonbar.set_outputs()
lemonbar.render_all(caller=caller, e=data)
i3.on('workspace::urgent', lemonbar.on_workspace_event)
i3.on('workspace::empty', lemonbar.on_workspace_event)
if display_title:
i3.on('window::title', lemonbar.on_window_title_change)
i3.on('window::close', lemonbar.on_window_close)
i3.on('window::focus', lemonbar.on_window_title_change)
i3.on('workspace::focus', lemonbar.on_workspace_focus)
else:
i3.on('workspace::focus', lemonbar.on_workspace_event)
i3.on('mode', lemonbar.on_binding_mode_change)
i3.on('output', reload_bar)
i3.on('shutdown', shutdown)
i3.main()
def run(
write_pipe1=None, # write pipe to systemtray
write_pipe2=None, # write pipe to hpdio
read_pipe3=None): # read pipe from hpdio
global dbus_loop, main_loop
global system_bus, session_bus
global w1, w2, r3
log.set_module("hp-systray(hpssd)")
log.debug("PID=%d" % os.getpid())
w1, w2, r3 = write_pipe1, write_pipe2, read_pipe3
dbus_loop = DBusGMainLoop(set_as_default=True)
main_loop = MainLoop()
try:
system_bus = SystemBus(mainloop=dbus_loop)
except dbus.exceptions.DBusException as e:
log.error("Unable to connect to dbus system bus. Exiting.")
sys.exit(1)
try:
session_bus = dbus.SessionBus()
except dbus.exceptions.DBusException as e:
if os.getuid() != 0:
log.error("Unable to connect to dbus session bus. Exiting.")
sys.exit(1)
else:
log.error(
"Unable to connect to dbus session bus (running as root?)")
sys.exit(1)
# Receive events from the system bus
system_bus.add_signal_receiver(handle_system_signal,
sender_keyword='sender',
destination_keyword='dest',
interface_keyword='interface',
member_keyword='member',
path_keyword='path')
# Receive events from the session bus
session_bus.add_signal_receiver(handle_session_signal,
sender_keyword='sender',
destination_keyword='dest',
interface_keyword='interface',
member_keyword='member',
path_keyword='path')
# Export an object on the session bus
session_name = dbus.service.BusName("com.hplip.StatusService", session_bus)
status_service = StatusService(session_name, "/com/hplip/StatusService")
log.debug("Entering main dbus loop...")
try:
main_loop.run()
except KeyboardInterrupt:
log.debug("Ctrl-C: Exiting...")
def post_config_hook(self):
try:
self.login1 = SystemBus().get_object("org.freedesktop.login1",
"/org/freedesktop/login1")
except Exception:
raise Exception(STRING_DBUS_EXCEPTION)
self.lock = None
self.lock_types = ":".join(self.lock_types)
self.thresholds_init = self.py3.get_color_names_list(self.format)
def __init__( self ):
# prepare avahi binding
bus = SystemBus()
server = Interface(
bus.get_object( DBUS_NAME, DBUS_PATH_SERVER ),
DBUS_INTERFACE_SERVER )
self.hostname = server.GetHostNameFqdn()
self.group = Interface( bus.get_object( DBUS_NAME, server.EntryGroupNew() ), DBUS_INTERFACE_ENTRY_GROUP )
self.export()
def install_signal_handlers(self): """Hooks to some d-bus signals that are of interest to us""" bus = SystemBus() bus.add_signal_receiver( self.handle_incoming_message, 'IncomingMessage', 'org.freesmartphone.GSM.SIM' )
def enable(self):
bus = SystemBus()
if not self.handler:
self.signal = bus.add_signal_receiver(
self.handle_call_status,
signal_name='CallStatus',
dbus_interface='org.freesmartphone.GSM.Call',
bus_name='org.freesmartphone.ogsmd')
self.handler = True
self._initialized = True
def initialize_dbus(self):
DBusGMainLoop(set_as_default=True)
# Initialize SystemBus and get Manager Interface
self._bus = SystemBus()
systemd = self._bus.get_object(SYSTEMD_BUS,
"/org/freedesktop/systemd1")
self._manager = Interface(systemd, dbus_interface=MANAGER_IFACE)
# Retrieve the main loop which will be called in the run method
self._loop = GLib.MainLoop()
self.context = self._loop.get_context()
def simdi_kapat(istek):
bus = SystemBus()
dbus_k = bus.get_object('org.freedesktop.ConsoleKit',
'/org/freedesktop/ConsoleKit/Manager')
dbus_kapat = Interface(dbus_k, 'org.freedesktop.ConsoleKit.Manager')
if istek == 'Stop':
print("\033[1;41mBilgisayarınız kapatılıyor...\033[0m")
dbus_kapat.Stop()
else:
print("\033[1;41mBilgisayarınız yeniden başlatılıyor...\033[0m")
dbus_kapat.Restart()
def appliance_state():
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
appliance_unit = manager.LoadUnit('observer-appliance.service')
appliance_proxy = bus.get_object('org.freedesktop.systemd1',
str(appliance_unit))
appliance_properties = Interface(
appliance_proxy, dbus_interface='org.freedesktop.DBus.Properties')
return appliance_properties.Get('org.freedesktop.systemd1.Unit',
'ActiveState')
def restart_daemon():
cmd = f"systemctl restart chain-maind"
print("### Restart service ###")
sysbus = SystemBus()
systemd1 = sysbus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd1,
dbus_interface='org.freedesktop.systemd1.Manager')
if is_service_active('chain-maind.service'):
manager.StopUnit('chain-maind.service', 'replace')
#job = manager.RestartUnit('chain-maind.service', 'fail')
time.sleep(2)
manager.StartUnit('chain-maind.service', 'replace')
def start_service(service):
""" Start systemd service using through """
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = dbus.Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
try:
service_unit = service if service.endswith(
'.service') else manager.GetUnit("{}.service".format(service))
manager.StartUnit(service_unit, 'replace')
except dbus.DBusException as error:
logging.error(str(error))
def is_ap_mode(self) -> bool:
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
appliance_unit = manager.LoadUnit('hostapd.service')
appliance_proxy = bus.get_object('org.freedesktop.systemd1',
str(appliance_unit))
appliance_properties = Interface(
appliance_proxy, dbus_interface='org.freedesktop.DBus.Properties')
return appliance_properties.Get('org.freedesktop.systemd1.Unit',
'ActiveState') != 'inactive'
class SystemServices(service.FunctionObject) :
def __init__(self, object_path, service_object = None) :
super().__init__(object_path, service_object)
self._bus = SystemBus()
self._systemd_manager = DBusInterface(self._bus.get_object(
'org.freedesktop.systemd1', '/org/freedesktop/systemd1'
), 'org.freedesktop.systemd1.Manager')
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def enable(self, name):
logger.verbose("{mod}: Request to enable service \"%s\"" % name)
self._systemd_manager.EnableUnitFiles([name + '.service'], False, True)
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def disable(self, name):
logger.verbose("{mod}: Request to disable service \"%s\"" % name)
self._systemd_manager.DisableUnitFiles([name + '.service'], False, True)
###
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def reload(self, name) :
logger.verbose("{mod}: Request to reload service \"%s\"" % name)
self._systemd_manager.ReloadUnit(name + '.service', 'replace')
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def start(self, name) :
logger.verbose("{mod}: Request to start service \"%s\"" % name)
self._systemd_manager.StartUnit(name + '.service', 'replace')
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s")
def stop(self, name) :
logger.verbose("{mod}: Request to stop service \"%s\"" % name)
self._systemd_manager.StopUnit(name + '.service', 'replace')
@service.functionMethod(SYSTEM_SERVICE_METHODS_NAMESPACE, in_signature="s", out_signature="s")
def getActiveState(self, name) :
unit = DBusInterface(
self._bus.get_object(
'org.freedesktop.systemd1',
str(self._systemd_manager.LoadUnit(name + '.service'))
),
'org.freedesktop.systemd1.Unit'
)
active_state = unit.Get(
'org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties'
)
return active_state
def initialize(self, conf_reader, msgQlist, product):
"""initialize configuration reader and internal msg queues."""
# Initialize ScheduledMonitorThread and InternalMsgQ
super(ServiceMonitor, self).initialize(conf_reader)
# Initialize internal message queues for this module
super(ServiceMonitor, self).initialize_msgQ(msgQlist)
self.iem = Iem()
self.iem.check_exsisting_fault_iems()
self.KAFKA = self.iem.EVENT_CODE["KAFKA_ACTIVE"][1]
# Integrate into the main dbus loop to catch events
DBusGMainLoop(set_as_default=True)
# Initialize SystemBus and get Manager Interface
self._bus = SystemBus()
systemd = self._bus.get_object("org.freedesktop.systemd1",
"/org/freedesktop/systemd1")
self._manager = Interface(
systemd, dbus_interface='org.freedesktop.systemd1.Manager')
self._node_id = Conf.get(GLOBAL_CONF, NODE_ID_KEY, 'SN01')
cache_dir_path = os.path.join(DATA_PATH, self.CACHE_DIR_NAME)
self.SERVICE_MONITOR_DATA_PATH = os.path.join(
cache_dir_path, f'SERVICE_MONITOR_DATA_{self._node_id}')
# Get the stored previous service info
self.persistent_service_data = {}
if os.path.isfile(self.SERVICE_MONITOR_DATA_PATH):
self.persistent_service_data = \
store.get(self.SERVICE_MONITOR_DATA_PATH)
if self.persistent_service_data:
self.not_active_services = \
self.persistent_service_data['not_active_services']
self.failed_services = \
self.persistent_service_data['failed_services']
self.service_status = \
self.persistent_service_data['service_status']
else:
self.persistent_service_data = {
'not_active_services': self.not_active_services,
'failed_services': self.failed_services,
'service_status': self.service_status
}
store.put(self.persistent_service_data,
self.SERVICE_MONITOR_DATA_PATH)
self.remove_disabled_services()
return True
def systemd_resolved_status():
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
unit = manager.LoadUnit('sytemd-resolved.service')
proxy = bus.get_object('org.freedesktop.systemd1', str(unit))
r = proxy.Get('org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties')
if str(r) == 'active':
return True
return False
def __init__(self):
super(SystemdLogin, self).__init__()
# Use d-bus to communicate with systemd
# Described at: http://www.freedesktop.org/wiki/Software/systemd/logind/
# Obtain an instance of d-bus to communicate with systemd
self._bus = SystemBus()
# Obtain a manager interface to d-bus for communications with login1
logind = self._bus.get_object('org.freedesktop.login1',
'/org/freedesktop/login1')
self._manager = Interface(
logind, dbus_interface='org.freedesktop.login1.Manager')
def __init__(self, logger):
"""Inits the DBus client and creates a new System bus.
:param logger: Logger
:return:
"""
self.logger = logger
DbusPhoneHomeClient.logger = logger
self.logger.debug("Attaching to a main loop")
DBusGMainLoop(set_as_default=True)
self.logger.debug("Creating session in SystemBus")
self.bus = SystemBus()
def init_dbus(self):
print 'PylgrimView init_dbus'
try:
gps_obj = SystemBus(mainloop=DBusEcoreMainLoop()).get_object(DBUS_NAME,
#'/org/mobile/GoogleLocation',
'/org/mobile/GpsLocation',
)
gps_obj.connect_to_signal("position", self.position, dbus_interface=DIN_LOCATION)
self.gps_interface = Interface(gps_obj, DIN_LOCATION)
self.gps_interface.GetPosition(reply_handler=self.position, error_handler=err, )
return False
except Exception, e:
print 'PylgrimView', e
return True
def run(write_pipe1=None, # write pipe to systemtray
write_pipe2=None, # write pipe to hpdio
read_pipe3=None): # read pipe from hpdio
global dbus_loop, main_loop
global system_bus, session_bus
global w1, w2, r3
log.set_module("hp-systray(hpssd)")
log.debug("PID=%d" % os.getpid())
w1, w2, r3 = write_pipe1, write_pipe2, read_pipe3
dbus_loop = DBusGMainLoop(set_as_default=True)
main_loop = MainLoop()
try:
system_bus = SystemBus(mainloop=dbus_loop)
except dbus.exceptions.DBusException as e:
log.error("Unable to connect to dbus system bus. Exiting.")
sys.exit(1)
try:
session_bus = dbus.SessionBus()
except dbus.exceptions.DBusException as e:
if os.getuid() != 0:
log.error("Unable to connect to dbus session bus. Exiting.")
sys.exit(1)
else:
log.error("Unable to connect to dbus session bus (running as root?)")
sys.exit(1)
# Receive events from the system bus
system_bus.add_signal_receiver(handle_system_signal, sender_keyword='sender',
destination_keyword='dest', interface_keyword='interface',
member_keyword='member', path_keyword='path')
# Receive events from the session bus
session_bus.add_signal_receiver(handle_session_signal, sender_keyword='sender',
destination_keyword='dest', interface_keyword='interface',
member_keyword='member', path_keyword='path')
# Export an object on the session bus
session_name = dbus.service.BusName("com.hplip.StatusService", session_bus)
status_service = StatusService(session_name, "/com/hplip/StatusService")
log.debug("Entering main dbus loop...")
try:
main_loop.run()
except KeyboardInterrupt:
log.debug("Ctrl-C: Exiting...")
def systemd_resolved_status():
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
unit = manager.LoadUnit('sytemd-resolved.service')
proxy = bus.get_object('org.freedesktop.systemd1', str(unit))
r = proxy.Get('org.freedesktop.systemd1.Unit',
'ActiveState',
dbus_interface='org.freedesktop.DBus.Properties')
if str(r) == 'active':
return True
return False
def __init__(self):
# Diccionario para evitar los dobles escaneos producto de la emisión
# de señales repetidas. Pasa porque Rhythmbox vuelve a escanear todos
# los dispositivos cuando levanta por primera vez.
self._already_scanned = {}
# Se obtiene una conexión al bus de sistema
self._system_bus = SystemBus()
# Se obtiene una conexión al bus de sesión
self._session_bus = SessionBus()
# Conectar a las señales que emite de UDisks
self._connect_to_udisks()
def __init__(self):
super(SystemdService, self).__init__()
# Use d-bus to communicate with systemd
# Described at: http://www.freedesktop.org/wiki/Software/systemd/dbus/
# Obtain an instance of d-bus to communicate with systemd
self._bus = SystemBus()
# Obtain a manager interface to d-bus for communications with systemd
systemd = self._bus.get_object('org.freedesktop.systemd1', '/org/freedesktop/systemd1')
self._manager = Interface(systemd, dbus_interface='org.freedesktop.systemd1.Manager')
# Subscribe to signal changes
self._manager.Subscribe()
def __init__(self, bus=None, proxy=None):
"""
Initialize an instance with the given DBus proxy object.
:param dbus.Bus bus: connection to system bus
:param dbus.proxies.ProxyObject proxy: proxy to udisks object
"""
if proxy is None:
if bus is None:
from dbus import SystemBus
bus = SystemBus()
proxy = DBusProxy(bus.get_object(self.BusName, self.ObjectPath),
self.Interface)
self._proxy = proxy
def load_entries(self):
bus = SystemBus()
try:
gsm = bus.get_object('org.freesmartphone.ogsmd', '/org/freesmartphone/GSM/Device')
self.gsm_sim_iface = Interface(gsm, 'org.freesmartphone.GSM.SIM')
self.gsm_sim_iface.RetrieveMessagebook(
'all',
reply_handler=self.process_all_entries,
error_handler=self.handle_sim_error)
except DBusException, e:
syslog(LOG_WARNING, "%s: Could not request SIM messagebook from ogsmd, scheduling retry (%s)" % (self.name, e))
return True
class Policy:
def __init__(self, enforce=True):
self.enforce = enforce
self.bus = SystemBus()
self.dbus_iface = None
self.pk = Interface(self.bus.get_object('org.freedesktop.PolicyKit1',
'/org/freedesktop/PolicyKit1/Authority'),
'org.freedesktop.PolicyKit1.Authority')
if not enforce:
log.warn('Not enforcing PolicyKit privileges!')
def check(self, sender, conn, priv='com.ubuntu.jobservice.manage'):
"""
Check or ask for authentication for job management.
"""
if not self.enforce: return
log.debug('Asking for PolicyKit authorization')
# get the PID of the sender
if not self.dbus_iface:
self.dbus_iface = Interface(conn.get_object('org.freedesktop.DBus',
'/org/freedesktop/DBus/Bus'), 'org.freedesktop.DBus')
pid = self.dbus_iface.GetConnectionUnixProcessID(sender)
# ask PolicyKit
auth, challenge, details = self.pk.CheckAuthorization(
('unix-process', {'pid': pid, 'start-time': UInt64(0)}),
priv, {'': ''}, 1, '', timeout=500)
if not auth:
log.info('Authorization failed')
raise DeniedByPolicy('Not authorized to manage jobs.')
log.debug('Authorization passed')
def monitor(output='syslog'):
bus = SystemBus()
logger = DBusLogger(output)
bus.add_match_string("")
bus.add_message_filter(logger)
loop = MainLoop()
print "Press Ctrl-C to stop."
try:
loop.run()
except:
print " Loop exited"
bus.remove_message_filter(logger)
bus.remove_match_string("")
def __init__(self, send_queue):
assert isinstance(send_queue, MultiQueue)
self.send_queue = send_queue
self.bus = SystemBus()
self.systemd = self.bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
self.manager = Interface(self.systemd, dbus_interface='org.freedesktop.systemd1.Manager')
def start_stop_service(service_name, action):
assert action in ("running", "halted")
# Obtain an instance of d-bus to communicate with systemd
bus = SystemBus()
# Obtain a manager interface to d-bus for communications with systemd
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
if action == "running":
manager.StartUnit(service_name + ".service", 'replace')
else:
manager.StopUnit(service_name + ".service", 'replace')
class SystemdLogin(Debug):
"""Handles login request messages of systemd"""
ACTUATOR_NAME = "SystemdLogin"
@staticmethod
def name():
""" @return: name of the module."""
return SystemdLogin.ACTUATOR_NAME
def __init__(self):
super(SystemdLogin, self).__init__()
# Use d-bus to communicate with systemd
# Described at: http://www.freedesktop.org/wiki/Software/systemd/logind/
# Obtain an instance of d-bus to communicate with systemd
self._bus = SystemBus()
# Obtain a manager interface to d-bus for communications with login1
logind = self._bus.get_object('org.freedesktop.login1',
'/org/freedesktop/login1')
self._manager = Interface(
logind, dbus_interface='org.freedesktop.login1.Manager')
def perform_request(self, jsonMsg):
"""Performs the login request"""
self._check_debug(jsonMsg)
# Parse out the login request to perform
self._login_request = jsonMsg.get("login_request")
self._log_debug("perform_request, _login_request: %s" %
self._login_request)
user_names = []
try:
# Return a list of user names currently logged in
if self._login_request == "get_all_users":
users = self._manager.ListSessions()
for user in users:
# session id, user id, user name, seat id, session object path
if user[2] not in user_names:
self._log_debug("perform_request, user name: %s" %
(user[2]))
user_names.append(user[2])
except debus_exceptions.DBusException as error:
logger.exception(error)
self._bus = None
self._manager = None
return user_names
def _get_status(self):
""""Returns the active state of the unit"""
return self._proxy.Get(
'org.freedesktop.login1',
'Name',
dbus_interface='org.freedesktop.DBus.Properties')
def __init__(self):
DBusGMainLoop(set_as_default=True)
self.bus = SystemBus()
self.sessionbus = SessionBus()
try:
self.mce = self.bus.get_object("com.nokia.mce", "/com/nokia/mce")
except DBusException:
warning("Nokia MCE not found. Vibra is disabled\n")
return
self.profiled = self.sessionbus.get_object("com.nokia.profiled", "/com/nokia/profiled")
self.sessionbus.add_signal_receiver(
self.profile_changed_handler,
"profile_changed",
"com.nokia.profiled",
"com.nokia.profiled",
"/com/nokia/profiled",
)
profile = self.profiled.get_profile(dbus_interface="com.nokia.profiled")
self.get_vibra_enabled(profile)
self.register_plugin(PLUGIN_TYPE_VIBRA)
def send_message(device_uri, printer_name, event_code, username, job_id, title, pipe_name=''):
log.debug("send_message() entered")
args = [device_uri, printer_name, event_code, username, job_id, title, pipe_name]
msg = lowlevel.SignalMessage('/', DBUS_SERVICE, 'Event')
msg.append(signature='ssisiss', *args)
SystemBus().send_message(msg)
log.debug("send_message() returning")
def connect(self, config, secrets):
self.config = config
self.secrets = secrets
self.DBus = SystemBus()
self.SystemD = self.SystemDConnect("/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager")
self.LDAP = ldap_connect(config=config, passwd=secrets.get("ldap"))
self.Supervisor = supervisor_connect()
def __init__(self, enforce=True):
self.enforce = enforce
self.bus = SystemBus()
self.dbus_iface = None
self.pk = Interface(self.bus.get_object('org.freedesktop.PolicyKit1',
'/org/freedesktop/PolicyKit1/Authority'),
'org.freedesktop.PolicyKit1.Authority')
if not enforce:
log.warn('Not enforcing PolicyKit privileges!')
def connect_service(cls, bus=None, mainloop=None):
"""
Connect to the service object on dbus.
:param dbus.Bus bus: connection to system bus
:param dbus.mainloop.NativeMainLoop mainloop: system bus event loop
:raises dbus.DBusException: if unable to connect to service.
The mainloop parameter is only relevant if no bus is given. In this
case if ``mainloop is True``, use the default (glib) mainloop
provided by dbus-python.
"""
if bus is None:
mainloop = mainloop or cls.mainloop
if mainloop is True:
mainloop = DBusGMainLoop()
bus = SystemBus(mainloop=mainloop or cls.mainloop)
obj = bus.get_object(cls.BusName, cls.ObjectPath)
return DBusProxy(obj, cls.Interface)
def __init__(self):
"""
Connect to Upstart's dbus service.
"""
self.jobpaths = {}
self.instpaths = {}
self.bus = SystemBus()
self.upstart = Interface(
self.bus.get_object('com.ubuntu.Upstart', '/com/ubuntu/Upstart'),
'com.ubuntu.Upstart0_6'
)
class Vibra_Plugin(Plugin):
def __init__(self):
DBusGMainLoop(set_as_default=True)
self.bus = SystemBus()
self.sessionbus = SessionBus()
try:
self.mce = self.bus.get_object("com.nokia.mce", "/com/nokia/mce")
except DBusException:
warning("Nokia MCE not found. Vibra is disabled\n")
return
self.profiled = self.sessionbus.get_object("com.nokia.profiled", "/com/nokia/profiled")
self.sessionbus.add_signal_receiver(
self.profile_changed_handler,
"profile_changed",
"com.nokia.profiled",
"com.nokia.profiled",
"/com/nokia/profiled",
)
profile = self.profiled.get_profile(dbus_interface="com.nokia.profiled")
self.get_vibra_enabled(profile)
self.register_plugin(PLUGIN_TYPE_VIBRA)
def ready(self):
self.notification = get_plugin_by_type(PLUGIN_TYPE_NOTIFICATION)
sendfile = get_plugin_by_type(PLUGIN_TYPE_SEND_FILE)
sendfile.receive_cb.append(self.file_receive)
def get_vibra_enabled(self, profile):
self.enabled = (
self.profiled.get_value(profile, "vibrating.alert.enabled", dbus_interface="com.nokia.profiled") == "On"
)
debug("Vibra enabled: %s\n" % self.enabled)
def profile_changed_handler(self, foo, bar, profile, *args):
self.get_vibra_enabled(profile)
def vibrate(self):
if self.enabled:
self.mce.req_vibrator_pattern_activate("PatternChatAndEmail", dbus_interface="com.nokia.mce.request")
def file_receive(self, cb, user, fname):
self.vibrate()
def user_appears(self, user):
if user.get("friend"):
self.vibrate()
class ConnectionsManager:
def connect(self, config, secrets):
self.config = config
self.secrets = secrets
self.DBus = SystemBus()
self.SystemD = self.SystemDConnect("/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager")
self.LDAP = ldap_connect(config=config, passwd=secrets.get("ldap"))
self.Supervisor = supervisor_connect()
def SystemDConnect(self, path, interface):
systemd = self.DBus.get_object("org.freedesktop.systemd1", path)
return Interface(systemd, dbus_interface=interface)
class RemoteJobService:
def __init__(self):
self.jobs = {}
self._connect()
def _connect(self):
self.bus = SystemBus()
self.jobservice = Interface(self.bus.get_object(
'com.ubuntu.JobService', '/com/ubuntu/JobService'),
'com.ubuntu.JobService')
def get_all_jobs(self, protect=True):
self.jobs = {}
def call(): return self.jobservice.GetAllJobs()
alljobs = retry(self._connect, call)
for job, path in alljobs:
protected = is_protected(job)
if not protect or not protected:
self.jobs[job] = RemoteJob(job, path)
self.jobs[job].protected = protected
return self.jobs
class BootAnalyzer:
def __init__(self, send_queue):
assert isinstance(send_queue, MultiQueue)
self.send_queue = send_queue
self.bus = SystemBus()
self.systemd = self.bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
self.manager = Interface(self.systemd, dbus_interface='org.freedesktop.systemd1.Manager')
def __push(self, data, prio):
self.send_queue.put_element(data, prio)
def analyze(self):
for e in self.manager.ListUnits():
if len(e) != 10:
continue
name = str(e[0])
description = str(e[1])
load_state = str(e[2])
active_state = str(e[3])
sub_state = str(e[4])
followed_unit = str(e[5])
unit_object_path = str(e[6])
queued_job_id = int(e[7])
job_type = str(e[8])
job_object_path = str(e[9])
if not name.endswith('.service'):
continue
if name.startswith('user@'):
continue
if active_state == ACTIVE:
continue
if active_state == INACTIVE and sub_state == DEAD:
continue
print(e[0])
def _connect(self):
self.bus = SystemBus()
self.obj = self.bus.get_object('com.ubuntu.JobService', self.path)
self.interface = Interface(self.obj, 'com.ubuntu.JobService.Job')
class RemoteJob:
"""
A proxy object for a single job. DBus properties are accessible via
regular Python properties.
"""
def __init__(self, name, path):
self.name = name
self.path = path
self.props = {}
self.protected = False
self._connect()
def _connect(self):
self.bus = SystemBus()
self.obj = self.bus.get_object('com.ubuntu.JobService', self.path)
self.interface = Interface(self.obj, 'com.ubuntu.JobService.Job')
def __getattr__(self, name):
if not self.props:
def call():
self.props = self.obj.GetAll('com.ubuntu.JobService.Job',
dbus_interface=PROPERTIES_IFACE)
retry(self._connect, call)
# override description
if name == 'description':
alt = alt_description(self.name)
if alt:
return alt
return self.props[name]
def start(self, reply_handler=None, error_handler=None):
def call(): self.interface.Start(timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {} # states may change
def stop(self, reply_handler=None, error_handler=None):
def call(): self.interface.Stop(timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {}
def enable(self, reply_handler=None, error_handler=None):
def call(): self.interface.SetAutomatic(True, timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {}
def disable(self, reply_handler=None, error_handler=None):
def call(): self.interface.SetAutomatic(False, timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {}
def get_settings(self, reply_handler=None, error_handler=None):
if '_settings' in self.props:
return self.props['_settings']
def call():
self.props['_settings'] = self.interface.GetSettings(LANG,
timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
return self.props['_settings']
return retry(self._connect, call)
def set_settings(self, settings, reply_handler=None, error_handler=None):
def call(): self.interface.SetSettings(settings, timeout=500,
reply_handler=reply_handler, error_handler=error_handler)
retry(self._connect, call)
self.props = {}
def _connect(self):
self.bus = SystemBus()
self.jobservice = Interface(self.bus.get_object(
'com.ubuntu.JobService', '/com/ubuntu/JobService'),
'com.ubuntu.JobService')
class ServiceBackend(ServiceBase):
def __init__(self):
"""
Connect to Upstart's dbus service.
"""
self.jobpaths = {}
self.instpaths = {}
self.bus = SystemBus()
self.upstart = Interface(
self.bus.get_object('com.ubuntu.Upstart', '/com/ubuntu/Upstart'),
'com.ubuntu.Upstart0_6'
)
def get_all_services(self):
svclist = []
for path in self.upstart.GetAllJobs():
job_obj = self.bus.get_object('com.ubuntu.Upstart', path)
job_name = job_obj.Get('com.ubuntu.Upstart0_6.Job', 'name',
dbus_interface=PROPERTIES_IFACE)
job = Interface(job_obj, 'com.ubuntu.Upstart0_6.Job')
self.jobpaths[job_name] = path
# get the instance(s) and their states
instances = job.GetAllInstances()
self.instpaths[path] = []
if instances:
for inst_path in instances:
self.instpaths[path].append(inst_path)
inst_obj = self.bus.get_object('com.ubuntu.Upstart',
inst_path)
inst_name = inst_obj.Get('com.ubuntu.Upstart0_6.Instance',
'name', dbus_interface=PROPERTIES_IFACE)
if inst_name:
svclist.append(job_name + '/' + inst_name)
# if there is no instance name, there's probably only one
else:
svclist.append(job_name)
# no running instances
else:
svclist.append(job_name)
return svclist
def get_service(self, name):
# some defaults for values we might not find
info = {
'running': False,
'automatic': False,
'pid': 0,
'starton': Array(signature='s'),
'stopon': Array(signature='s'),
'description': '',
}
job_name, inst_name = self._split_job(name)
# job-level properties
job_obj = self.bus.get_object('com.ubuntu.Upstart',
self.jobpaths[job_name])
props = job_obj.GetAll('com.ubuntu.Upstart0_6.Job',
dbus_interface=PROPERTIES_IFACE)
# starton/stopon
info['file'] = '/etc/init/{0}.conf'.format(job_name)
try:
with open(info['file']) as conf:
starton = self._parse_conf(conf, 'start on')
stopon = self._parse_conf(conf, 'stop on')
info['starton'] += self._extract_events(starton)
info['stopon'] += self._extract_events(stopon)
# automatic if starton isn't commented out
info['automatic'] = (starton[0] != '#')
except:
return info
# running state: check the instance(s)
inst_obj, inst_props = self._get_inst(job_name, inst_name)
if inst_obj:
info['running'] = (inst_props['state'] == 'running')
if inst_props['processes']:
info['pid'] = inst_props['processes'][0][1]
# differentiate instances in descriptions
if inst_name and 'description' in props:
props['description'] += " ({0})".format(inst_name)
info.update(props)
return info
def start_service(self, name):
"""
If a job is given, try to start its instance first if it has one.
If it doesn't have one, start via job.
If an instance is given, start it directly.
"""
job_name, inst_name = self._split_job(name)
# no instances, start the job
if not self.instpaths[self.jobpaths[job_name]]:
job_obj = self.bus.get_object('com.ubuntu.Upstart',
self.jobpaths[job_name])
job = Interface(job_obj, 'com.ubuntu.Upstart0_6.Job')
job.Start([], True)
# one or more instances available
else:
inst_obj, inst_props = self._get_inst(job_name, inst_name)
inst_obj.Start(True, dbus_interface='com.ubuntu.Upstart0_6.Instance')
# reload
self.get_all_services()
def stop_service(self, name):
"""Find the appropritate job instance and stop it."""
job_name, inst_name = self._split_job(name)
inst_obj, inst_props = self._get_inst(job_name, inst_name)
inst_obj.Stop(True, dbus_interface='com.ubuntu.Upstart0_6.Instance')
# reload
self.get_all_services()
def set_service_automatic(self, name, auto):
job_name, inst_name = self._split_job(name)
with open('/etc/init/{0}.conf'.format(job_name)) as conf:
self._set_automatic(conf, auto)
def _split_job(self, name):
"""Return (job_name, inst_name) from name."""
if '/' in name:
job_name, inst_name = name.split('/', 1)
else:
job_name = name
inst_name = None
return (job_name, inst_name)
def _get_inst(self, job_name, inst_name):
"""Return (inst_obj, inst_props) matching job_name & inst_name."""
paths = self.instpaths[self.jobpaths[job_name]]
if not paths:
return (None, None)
for inst_path in paths:
inst_obj = self.bus.get_object('com.ubuntu.Upstart', inst_path)
inst_props = inst_obj.GetAll('com.ubuntu.Upstart0_6.Instance',
dbus_interface=PROPERTIES_IFACE)
if inst_props['name'] == inst_name:
break
return (inst_obj, inst_props)
def _set_automatic(self, conf, automatic=True):
"""Comment/uncomment a job conf file's start on line. Closes conf."""
newname = '{0}.new'.format(conf.name)
with open(newname, 'w') as new:
for line in conf:
# if we find a start on line
pos = line.find('start on')
if pos >= 0 and pos <= 2:
starton = '\n' + self._parse_conf(conf, 'start on')
# enabling
if automatic:
starton = starton.rstrip().replace('\n#', '\n')
# disabling
else:
starton = starton.rstrip().replace('\n', '\n#')
new.write(starton.lstrip() + '\n')
continue
new.write(line)
conf.close()
rename(conf.name, '{0}~'.format(conf.name))
rename(newname, conf.name)
def _parse_conf(self, conf, find):
"""
Parse file 'conf' for text 'find' and return the value.
Useful for grabbing the full contents of a start/stop on line.
"""
conf.seek(0)
reading = False
data = ""
paren = 0
for line in conf:
# could be at pos 1 or 2 if line is commented out
pos = line.find(find)
if pos >= 0 and pos <= 2:
reading = True
if reading:
data += line
paren += line.count('(') - line.count(')')
if not paren:
break
return data
def _extract_events(self, data):
"""
Grab events present in a text string (ie, a start/stop on line).
An event could be a runlevel or a starting/stopping string.
"""
events = []
keywords = ('starting', 'stopping', 'started', 'stopped', 'runlevel')
words = [d.strip(' ()') for d in data.split()]
i = 0
for w in words:
if w in keywords:
if w == 'runlevel':
try:
levels = words[i+1].strip('[]')
except:
levels = ''
if levels and levels[0] == '!':
events.append('not runlevels {0}'.format(' '.join(levels[1:])))
else:
events.append('runlevels {0}'.format(' '.join(levels)))
else:
events.append('{0} {1}'.format(w, words[i+1]))
i += 1
return events
def PLUGINEND(self, headers, body):
logging.info("PLUGINEND")
self.ack()
if "DISABLE_SNAPPER_ZYPP_PLUGIN" in environ:
logging.info("$DISABLE_SNAPPER_ZYPP_PLUGIN is set - disabling snapper-zypp-plugin")
# a dummy Plugin is needed
plugin = Plugin()
plugin.main()
else:
config = Config()
try:
bus = SystemBus()
snapper = Interface(bus.get_object('org.opensuse.Snapper', '/org/opensuse/Snapper'),
dbus_interface='org.opensuse.Snapper')
except DBusException as e:
logging.error("connect to snapperd failed:")
logging.error(" %s", e)
sys.exit(1)
plugin = MyPlugin()
plugin.main()
#!/usr/bin/env python
from dbus import Interface, SystemBus
from dbus.exceptions import DBusException
from wait import wait
DEVICE = '00:0C:8A:67:96:90'
DEVICE = DEVICE.replace(':', '_')
index = 0
bus = SystemBus()
proxy_power = bus.get_object('org.bluez', '/org/bluez/hci0')
interface_power = Interface(proxy_power, dbus_interface='org.freedesktop.DBus.Properties')
while not interface_power.Get('org.bluez.Adapter1', 'Powered'):
interface_power.Set('org.bluez.Adapter1', 'Powered', True)
index = wait(index, text='powering')
else:
print('\nInterface powered')
proxy_connected = bus.get_object('org.bluez', '/org/bluez/hci0/dev_{}'.format(DEVICE))
interface_connected = Interface(proxy_connected, dbus_interface='org.freedesktop.DBus.Properties')
while not interface_connected.Get('org.bluez.Device1', 'Connected'):
interface_connect = Interface(proxy_connected, dbus_interface='org.bluez.Device1')
try:
interface_connect.Connect()
index = wait(index, text='connecting')
class DbusPhoneHomeClient:
expected_signal_hostname = None
mainloop = None
data_received = None
logger = None
def __init__(self, logger):
"""Inits the DBus client and creates a new System bus.
:param logger: Logger
:return:
"""
self.logger = logger
DbusPhoneHomeClient.logger = logger
self.logger.debug("Attaching to a main loop")
DBusGMainLoop(set_as_default=True)
self.logger.debug("Creating session in SystemBus")
self.bus = SystemBus()
@staticmethod
def timeout(mainloop, logger, *args):
"""Timeout function for DBus MainLoop.
:param mainloop: Loop manager (MainLoop)
:param logger: Logger
:param args: Rest of arguments
:return: False. The function is called repeatedly until it returns FALSE,
at which point the timeout is automatically destroyed and the function will not be called again.
"""
logger.debug("Timed out!. Aborting the wait.")
mainloop.quit()
return False
@staticmethod
def phonehome_signal_handler(phonehome_http_data):
"""Handler for `PHONEHOME_SIGNAL`.
:param phonehome_http_data: Data the VM emitted in the signal. If matches the expected one, main loop finishes.
:return: None
"""
DbusPhoneHomeClient.logger.debug("Data received from PhoneHome Server: '%s'",
phonehome_http_data.encode('base64', 'strict').replace('\n', ' '))
hostname = re.match(".*hostname=([\w-]*)", phonehome_http_data)
hostname = hostname.group(1) if hostname is not None else hostname
if DbusPhoneHomeClient.expected_signal_hostname == hostname:
DbusPhoneHomeClient.logger.debug("Received hostname: '%s'",
DbusPhoneHomeClient.expected_signal_hostname)
DbusPhoneHomeClient.data_received = phonehome_http_data
DbusPhoneHomeClient.mainloop.quit()
else:
DbusPhoneHomeClient.logger.debug(log_message_data_out_of_sequence)
@staticmethod
def phonehome_signal_handler_metadata(phonehome_http_data, hostname):
"""Handler for `PHONEHOME_METADATA_SIGNAL`.
:param phonehome_http_data: Data the VM emitted in the signal.
:param hostname: VM hostname. If matches the expected one, main loop finishes.
:return: None
"""
DbusPhoneHomeClient.logger.debug("Data received from PhoneHome Server (Hostname): '%s'",
hostname.encode('base64', 'strict').replace('\n', ' '))
if DbusPhoneHomeClient.expected_signal_hostname == hostname:
DbusPhoneHomeClient.logger.debug("Received hostname: '%s'", hostname)
DbusPhoneHomeClient.data_received = phonehome_http_data
DbusPhoneHomeClient.mainloop.quit()
else:
DbusPhoneHomeClient.logger.debug(log_message_data_out_of_sequence)
def connect_and_wait_for_phonehome_signal(self, bus_name, object_path, phonehome_signal, data_expected):
"""Connects to Bus and gets the published object (PhoneHome DBus object).
:param bus_name: str
A bus name (either the unique name or a well-known name)
of the application owning the object. The keyword argument
named_service is a deprecated alias for this. PhoneHome DBus service.
:param object_path: str
The object path of the desired PhoneHome Object.
:param data_expected: The PhoneHome client will wait for `PHONEHOME_SIGNAL` with this data value.
When received, main loop will be finished and data received from the signal will be returned.
:return: None if signal has not been received after the timewait; Else, the content received in the signal
"""
DbusPhoneHomeClient.data_received = None
self.logger.debug("Connecting to PhoneHome DBus Service in bus '%s' and getting PhoneHome object "
"with path '%s'", bus_name, object_path)
DbusPhoneHomeClient.expected_signal_hostname = data_expected
try:
object = self.bus.get_object(bus_name, object_path)
phonehome_interface = dbus.Interface(object, bus_name)
except DBusException as e:
self.logger.error("PhoneHome bus or object not found. Please check the PhoneHome services. %s", str(e))
return False
# Connect to signal
self.logger.debug("Connecting to signal '%s'", phonehome_signal)
if phonehome_signal == PHONEHOME_SIGNAL:
phonehome_interface.connect_to_signal(phonehome_signal, self.phonehome_signal_handler)
elif phonehome_signal == PHONEHOME_METADATA_SIGNAL:
phonehome_interface.connect_to_signal(PHONEHOME_METADATA_SIGNAL, self.phonehome_signal_handler_metadata)
# Attach to a main loop
self.logger.debug("Creating main loop")
DbusPhoneHomeClient.mainloop = gobject.MainLoop()
# Setup timeout and start main loop
phonehome_timeout = PHONEHOME_TIMEOUT * 1000
self.logger.debug("Setting time out to: %d", phonehome_timeout)
gobject.timeout_add(phonehome_timeout, self.timeout, DbusPhoneHomeClient.mainloop, self.logger, priority=100)
self.logger.debug("Waiting for signal '%s' with value or header 'hostname=%s' ."
" Timeout set to %s seconds", phonehome_signal, data_expected, PHONEHOME_TIMEOUT)
DbusPhoneHomeClient.mainloop.run()
self.logger.debug("Dbus PhoneHome Service stopped")
return DbusPhoneHomeClient.data_received
gi.require_version('Notify', '0.7')
from threading import Thread
from gi.repository import Gtk, Gio, Gdk, GObject, GdkPixbuf
from random import randint
from dbus.mainloop.glib import DBusGMainLoop
from gi.repository import Notify
DBusGMainLoop(set_as_default = True)
from dbus import SystemBus, SessionBus, Interface
import gobject
currentDirectory = os.path.dirname(os.path.abspath(__file__))
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1'
, '/org/freedesktop/systemd1')
class LittleServerExecuterApp(Gtk.Application):
""" Application Id """
appId = "org.pandahugmonster.lse"
""" Version string """
version = "0.4.3"
""" Settings file """
settingsFile = "settings.json"
""" SystemD Manager """
manager = None
