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 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 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):
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 __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 __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, 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 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 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 __systemd_create_interface():
try:
systemd = SystemBus().get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
return(Interface(systemd, 'org.freedesktop.systemd1.Manager'))
except Exception as e:
print(e)
return
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 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 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 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 register_phonehome_object(self, phonehome_object_path):
"""Registers the bus name and a new phonehome object in this one.
:param phonehome_object_path: The object path tho publish the desired PhoneHome Object. Format: /xxx/...
:return: None
"""
self.logger.debug("Registering new DBus name '%s'", PHONEHOME_DBUS_NAME)
bus = BusName(PHONEHOME_DBUS_NAME, bus=SystemBus())
self.logger.debug("Registering new PhoneHome Object '%s' in the Bus", phonehome_object_path)
self.dbus_phonehome_objects[phonehome_object_path] = DbusPhoneHomeObject(self.logger, bus,
phonehome_object_path)
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 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'
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 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 __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(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 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, 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__(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 send_message(device_uri,
printer_name,
event_code,
username,
job_id,
title,
pipe_name=''):
args = [
device_uri, printer_name, event_code, username, job_id, title,
pipe_name
]
msg = lowlevel.SignalMessage('/', 'com.hplip.StatusService', 'Event')
msg.append(signature='ssisiss', *args)
SystemBus().send_message(msg)
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')
