def main():
"""
The script's main function.
"""
# Sets up exception hook
sys.excepthook = fail
# Gets script arguments
args = get_args()
# If the "version" argument is present, prints version and exit
if (args.version):
version()
# Attempts to connect to the bus specified via command line arguments
if (args.system):
bus = pydbus.SystemBus()
elif (args.session):
bus = pydbus.SessionBus()
else:
bus = pydbus.connect(args.bus)
# Request bus name, register object and run loop
loop = GObject.MainLoop()
bus.request_name(args.name)
bus.register_object('/org/mpris/MediaPlayer2', MediaPlayer2(args.identity),
MediaPlayer2.__doc__)
vprint('Registered object to the message bus.')
loop.run()
def get_new_connection(self):
"""Get an Anaconda bus connection."""
if DBUS_ANACONDA_SESSION_ADDRESS in os.environ:
bus_address = os.environ.get(DBUS_ANACONDA_SESSION_ADDRESS)
elif os.path.exists(ANACONDA_BUS_ADDR_FILE):
with open(ANACONDA_BUS_ADDR_FILE, 'rt') as f:
bus_address = f.read().strip()
else:
raise ConnectionError("Can't find Anaconda bus address!")
log.info("Connecting to an Anaconda bus at %s.", bus_address)
return pydbus.connect(bus_address)
def get_new_connection(self):
"""Get an Anaconda bus connection."""
if DBUS_ANACONDA_SESSION_ADDRESS in os.environ:
bus_address = os.environ.get(DBUS_ANACONDA_SESSION_ADDRESS)
elif os.path.exists(ANACONDA_BUS_ADDR_FILE):
with open(ANACONDA_BUS_ADDR_FILE, 'rt') as f:
bus_address = f.read().strip()
else:
raise ConnectionError("Can't find Anaconda bus address!")
log.info("Connecting to an Anaconda bus at %s.", bus_address)
return pydbus.connect(bus_address)
def __enter__(self):
# SIGTERMs should also lead to __exit__() being called. Note that
# SIGINTs/KeyboardInterrupts are already handled by GLib.MainLoop
signal.signal(signal.SIGTERM, self._sigterm_handler)
if self._config['bus'] == 'session' or self._config['bus'] is None:
self._bus = SessionBus()
elif self.args.bus == 'system':
self._bus = SystemBus()
else:
self._bus = connect(self._config['bus'])
if self._mocker:
self._signal = self._bus.get('org.signalbot.signalclidbusmock')
else:
self._signal = self._bus.get('org.asamk.Signal')
self._signal.onMessageReceived = self._triagemessage
# Actively discourage chdir in plugins, see _triagemessage
self._fakecwd = TemporaryDirectory()
Path(self._fakecwd.name).chmod(S_IEXEC)
chdir(self._fakecwd.name)
try:
self._plugin_routers = {}
self._chats = Chats(bot=self)
for plugin in self._config['plugins']:
self._init_plugin(plugin)
for plugin in self._config['testing_plugins']:
self._init_plugin(plugin, test=True)
self._loop = GLib.MainLoop()
self._thread = Thread(daemon=True, target=self._loop.run)
self._thread.start()
if self._config['startup_notification']:
for master in self._config['master']:
master_chat_id = Chats.get_id_from_sender_and_group_id(
master)
master_chat = self._chats.get(master_chat_id, store=True)
self.send_success('Always at your service!', [],
master_chat)
except Exception as e:
# Try not to leave empty temporary directories behind when e.g. a
# plugin fails to load
Path(self._fakecwd.name).chmod(S_IREAD)
self._fakecwd.cleanup()
raise e
return self
def get_new_connection(self):
"""Get a default bus connection.
Connect to the bus specified by the environmental variable
DBUS_STARTER_ADDRESS. If it is not specified, connect to
the Anaconda bus.
"""
if DBUS_STARTER_ADDRESS in os.environ:
bus_address = os.environ.get(DBUS_STARTER_ADDRESS)
log.info("Connecting to a default bus at %s.", bus_address)
return pydbus.connect(bus_address)
return super().get_new_connection()
def get_new_connection(self):
"""Get a default bus connection.
Connect to the bus specified by the environmental variable
DBUS_STARTER_ADDRESS. If it is not specified, connect to
the Anaconda bus.
"""
if DBUS_STARTER_ADDRESS in os.environ:
bus_address = os.environ.get(DBUS_STARTER_ADDRESS)
log.info("Connecting to a default bus at %s.", bus_address)
return pydbus.connect(bus_address)
return super().get_new_connection()
def get_bus():
"""Get a DBUS bus connection corresponding to the current environment.
During normal usage this function should return connection to the system bus,
but during testing/development a custom bus might be used.
So just always connect to the bus specified by the DBUS_STARTER_ADDRESS
environmental variable.
"""
bus_address = os.environ.get("DBUS_STARTER_ADDRESS")
if bus_address:
return pydbus.connect(os.environ["DBUS_STARTER_ADDRESS"])
else:
log.critical("DBUS_STARTER_ADDRESS not defined, can't use DBUS!")
raise RuntimeError("DBUS_STARTER_ADDRESS not defined in environment")
def get_bus(request, get_environment, create_session_bus):
"""
Provide the session bus instance.
Adapted from: https://github.com/martinpitt/python-dbusmock/blob/master/dbusmock/testcase.py#L137 # noqa
"""
# Fixture finalization / executing teardown code pytest
# supports execution of fixture specific finalization code
# when the fixture goes out of scope.
# By using a yield statement instead of return,
# all the code after the yield
# statement serves as the teardown code.:
# if os.environ.get('DBUS_SESSION_BUS_ADDRESS'):
if get_environment["DBUS_SESSION_BUS_ADDRESS"]:
print("[get_bus] inside if environment['DBUS_SESSION_BUS_ADDRESS']")
bus = connect(get_environment["DBUS_SESSION_BUS_ADDRESS"])
# yield bus
# print("teardown new session bus")
# return dbus.bus.BusConnection(os.environ['DBUS_SESSION_BUS_ADDRESS'])
else:
print("\n[get_bus] default SessionBus")
bus = SessionBus()
def teardown():
"""
As historical note, another way to write teardown code is by
accepting a request object into your fixture function and can
call its request.addfinalizer one or multiple times:
"""
# NOTE: # SessionBus() and SystemBus() are not closed automatically, so this should work
# source: https://github.com/xZise/pydbus/blob/addf3913368cdc7225039525f3e53ab62b2a0f70/pydbus/bus.py#L31
# NOTE: bus.dbus = @property from pydbus bus object.
# NOTE: When you try to grab the property and it doesn't exist,
# NOTE: it assigns a dbus connection again via: self._dbus = self.get(".DBus")[""]
# NOTE: That's why we delete it each time
# print("running: bus.con.close()")
# bus.con.close()
print("running: del bus._dbus")
del bus._dbus
# The finalizer is called after all of the tests that use the fixture.
# If you’ve used parameterized fixtures,
# the finalizer is called between instances of the parameterized fixture changes.
request.addfinalizer(teardown)
bus.dbus
return bus
def get_new_connection(self):
"""Get a default bus connection.
Connect to the bus specified by the environmental variable
DBUS_STARTER_ADDRESS. If it is not specified, connect to
the session bus.
"""
if DBUS_STARTER_ADDRESS in os.environ:
bus_address = os.environ.get(DBUS_STARTER_ADDRESS)
elif DBUS_ANACONDA_SESSION_ADDRESS in os.environ:
bus_address = os.environ.get(DBUS_ANACONDA_SESSION_ADDRESS)
else:
raise ConnectionError("Can't find usable bus address!")
log.info("Connecting to a default bus at %s.", bus_address)
return pydbus.connect(bus_address)
def get_new_connection():
"""Get a DBus connection.
You shouldn't create new connections unless there is a good
reason for it. Use DBus.get_connection instead.
Normally this method should return a connection to the system
bus, but during testing/development a custom bus might be used.
So just always connect to the bus specified by the environmental
variable DBUS_STARTER_ADDRESS.
"""
bus_address = os.environ.get("DBUS_STARTER_ADDRESS")
if bus_address:
log.info("Connecting to DBus at %s.", bus_address)
return pydbus.connect(bus_address)
log.info("Connecting to system DBus.")
return pydbus.SystemBus()
def start(self):
# Load requested plugins
self.plugins = [
importlib.import_module('plugins.' + plugin).__plugin__(self)
for plugin in self.args.plugins
]
# Start listening for messages
if self.args.bus == 'session' or self.args.bus is None:
bus = SessionBus()
elif self.args.bus == 'system':
bus = SystemBus()
else:
bus = connect(self.args.bus)
self.signal = bus.get('org.asamk.Signal')
self.signal.onMessageReceived = self.receive
loop = GLib.MainLoop()
loop.run()
def main():
"""
The script's main function.
"""
# Sets up exception hook
sys.excepthook = fail
# Gets script arguments
args = get_args()
# If the "version" argument is present, prints version and exit
if (args.version):
version()
# Creates a list for storing data on found players
player_list = list()
# Attempts to connect to the bus specified via command line arguments
if (args.system):
bus = pydbus.SystemBus()
elif (args.session):
bus = pydbus.SessionBus()
else:
bus = pydbus.connect(args.bus)
# Gets names and proxy objects, and appends them to the list of found
# players
names = get_mpris_names(bus)
for name in names:
proxy = get_proxy_object(bus, name)
player_list.append({'name': name, 'proxy': proxy})
# Prints information about each player found
for player in player_list:
print_player_info(player, args.color)
from pydbus import SessionBus, connect
import os
DBUS_SESSION_BUS_ADDRESS = os.getenv("DBUS_SESSION_BUS_ADDRESS")
with connect(DBUS_SESSION_BUS_ADDRESS) as bus:
bus.dbus
del bus._dbus
try:
bus.dbus
assert (False)
except RuntimeError:
pass
with SessionBus() as bus:
pass
# SessionBus() and SystemBus() are not closed automatically, so this should work:
bus.dbus
with bus.request_name("net.lew21.Test"):
pass
with bus.request_name("net.lew21.Test"):
pass
with bus.request_name("net.lew21.Test"):
try:
bus.request_name("net.lew21.Test")
assert (False)
def new_bus(type_) -> Bus:
return connect(Gio.dbus_address_get_for_bus_sync(type_))
def get_new_connection(self):
"""Get a connection to a bus at the specified address."""
log.info("Connecting to a bus at %s.", self._address)
return pydbus.connect(self._address)
from pydbus import SessionBus, connect
import os
DBUS_SESSION_BUS_ADDRESS = os.getenv("DBUS_SESSION_BUS_ADDRESS")
with connect(DBUS_SESSION_BUS_ADDRESS) as bus:
bus.dbus
del bus._dbus
try:
bus.dbus
assert(False)
except RuntimeError:
pass
with SessionBus() as bus:
pass
# SessionBus() and SystemBus() are not closed automatically, so this should work:
bus.dbus
with bus.request_name("net.lew21.Test"):
pass
with bus.request_name("net.lew21.Test"):
pass
with bus.request_name("net.lew21.Test"):
try:
bus.request_name("net.lew21.Test")
assert(False)
def get_new_connection(self):
"""Get a connection to a bus at the specified address."""
log.info("Connecting to a bus at %s.", self._address)
return pydbus.connect(self._address)
target_file_path = os.path.join(temp_service_dir.name, filename)
shutil.copy(file_path, target_file_path)
test_dbus = Gio.TestDBus()
# set service folder
test_dbus.add_service_dir(temp_service_dir.name)
try:
# start the custom DBUS daemon
print("starting custom dbus session")
test_dbus.up()
print(test_dbus.get_bus_address())
# our custom bus is now running, connect to it
test_dbus_connection = pydbus.connect(test_dbus.get_bus_address())
print("starting Boss")
test_dbus_connection.dbus.StartServiceByName(dbus_constants.DBUS_BOSS_NAME,
0)
input("press any key to stop Boss and cleanup")
print("stopping Boss")
boss_object = test_dbus_connection.get(dbus_constants.DBUS_BOSS_NAME)
boss_object.Quit()
print("waiting a bit for module shutdown to happen")
time.sleep(1)
