Current File : //proc/self/root/proc/self/root/proc/thread-self/root/lib64/python2.7/site-packages/dbus/_dbus.py
"""Implementation for dbus.Bus. Not to be imported directly."""
# Copyright (C) 2003, 2004, 2005, 2006 Red Hat Inc. <http://www.redhat.com/>
# Copyright (C) 2003 David Zeuthen
# Copyright (C) 2004 Rob Taylor
# Copyright (C) 2005, 2006 Collabora Ltd. <http://www.collabora.co.uk/>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the "Software"), to deal in the Software without
# restriction, including without limitation the rights to use, copy,
# modify, merge, publish, distribute, sublicense, and/or sell copies
# of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
from __future__ import generators
__all__ = ('Bus', 'SystemBus', 'SessionBus', 'StarterBus')
__docformat__ = 'reStructuredText'
from dbus.exceptions import DBusException
from _dbus_bindings import (
BUS_DAEMON_IFACE, BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_SESSION,
BUS_STARTER, BUS_SYSTEM, DBUS_START_REPLY_ALREADY_RUNNING,
DBUS_START_REPLY_SUCCESS, validate_bus_name,
validate_interface_name, validate_member_name, validate_object_path)
from dbus.bus import BusConnection
from dbus.lowlevel import SignalMessage
from dbus._compat import is_py2
if is_py2:
from _dbus_bindings import UTF8String
class Bus(BusConnection):
"""A connection to one of three possible standard buses, the SESSION,
SYSTEM, or STARTER bus. This class manages shared connections to those
buses.
If you're trying to subclass `Bus`, you may be better off subclassing
`BusConnection`, which doesn't have all this magic.
"""
_shared_instances = {}
def __new__(cls, bus_type=BusConnection.TYPE_SESSION, private=False,
mainloop=None):
"""Constructor, returning an existing instance where appropriate.
The returned instance is actually always an instance of `SessionBus`,
`SystemBus` or `StarterBus`.
:Parameters:
`bus_type` : cls.TYPE_SESSION, cls.TYPE_SYSTEM or cls.TYPE_STARTER
Connect to the appropriate bus
`private` : bool
If true, never return an existing shared instance, but instead
return a private connection.
:Deprecated: since 0.82.3. Use dbus.bus.BusConnection for
private connections.
`mainloop` : dbus.mainloop.NativeMainLoop
The main loop to use. The default is to use the default
main loop if one has been set up, or raise an exception
if none has been.
:Changed: in dbus-python 0.80:
converted from a wrapper around a Connection to a Connection
subclass.
"""
if (not private and bus_type in cls._shared_instances):
return cls._shared_instances[bus_type]
# this is a bit odd, but we create instances of the subtypes
# so we can return the shared instances if someone tries to
# construct one of them (otherwise we'd eg try and return an
# instance of Bus from __new__ in SessionBus). why are there
# three ways to construct this class? we just don't know.
if bus_type == BUS_SESSION:
subclass = SessionBus
elif bus_type == BUS_SYSTEM:
subclass = SystemBus
elif bus_type == BUS_STARTER:
subclass = StarterBus
else:
raise ValueError('invalid bus_type %s' % bus_type)
bus = BusConnection.__new__(subclass, bus_type, mainloop=mainloop)
bus._bus_type = bus_type
if not private:
cls._shared_instances[bus_type] = bus
return bus
def close(self):
t = self._bus_type
if self.__class__._shared_instances.get(t) is self:
del self.__class__._shared_instances[t]
super(Bus, self).close()
def get_connection(self):
"""Return self, for backwards compatibility with earlier dbus-python
versions where Bus was not a subclass of Connection.
:Deprecated: since 0.80.0
"""
return self
_connection = property(get_connection, None, None,
"""self._connection == self, for backwards
compatibility with earlier dbus-python versions
where Bus was not a subclass of Connection.""")
def get_session(private=False):
"""Static method that returns a connection to the session bus.
:Parameters:
`private` : bool
If true, do not return a shared connection.
"""
return SessionBus(private=private)
get_session = staticmethod(get_session)
def get_system(private=False):
"""Static method that returns a connection to the system bus.
:Parameters:
`private` : bool
If true, do not return a shared connection.
"""
return SystemBus(private=private)
get_system = staticmethod(get_system)
def get_starter(private=False):
"""Static method that returns a connection to the starter bus.
:Parameters:
`private` : bool
If true, do not return a shared connection.
"""
return StarterBus(private=private)
get_starter = staticmethod(get_starter)
def __repr__(self):
if self._bus_type == BUS_SESSION:
name = 'session'
elif self._bus_type == BUS_SYSTEM:
name = 'system'
elif self._bus_type == BUS_STARTER:
name = 'starter'
else:
name = 'unknown bus type'
return '<%s.%s (%s) at %#x>' % (self.__class__.__module__,
self.__class__.__name__,
name, id(self))
__str__ = __repr__
# FIXME: Drop the subclasses here? I can't think why we'd ever want
# polymorphism
class SystemBus(Bus):
"""The system-wide message bus."""
def __new__(cls, private=False, mainloop=None):
"""Return a connection to the system bus.
:Parameters:
`private` : bool
If true, never return an existing shared instance, but instead
return a private connection.
`mainloop` : dbus.mainloop.NativeMainLoop
The main loop to use. The default is to use the default
main loop if one has been set up, or raise an exception
if none has been.
"""
return Bus.__new__(cls, Bus.TYPE_SYSTEM, mainloop=mainloop,
private=private)
class SessionBus(Bus):
"""The session (current login) message bus."""
def __new__(cls, private=False, mainloop=None):
"""Return a connection to the session bus.
:Parameters:
`private` : bool
If true, never return an existing shared instance, but instead
return a private connection.
`mainloop` : dbus.mainloop.NativeMainLoop
The main loop to use. The default is to use the default
main loop if one has been set up, or raise an exception
if none has been.
"""
return Bus.__new__(cls, Bus.TYPE_SESSION, private=private,
mainloop=mainloop)
class StarterBus(Bus):
"""The bus that activated this process (only valid if
this process was launched by DBus activation).
"""
def __new__(cls, private=False, mainloop=None):
"""Return a connection to the bus that activated this process.
:Parameters:
`private` : bool
If true, never return an existing shared instance, but instead
return a private connection.
`mainloop` : dbus.mainloop.NativeMainLoop
The main loop to use. The default is to use the default
main loop if one has been set up, or raise an exception
if none has been.
"""
return Bus.__new__(cls, Bus.TYPE_STARTER, private=private,
mainloop=mainloop)
Mini Shell