Blocking I/O¶
This is a good option for simple scripts, where you don’t need to do anything else while waiting for a D-Bus reply. If you will use D-Bus for multiple threads, or you want a nicer way to wait for signals, see Blocking I/O with threads.
- jeepney.io.blocking.open_dbus_connection(bus='SESSION', enable_fds=False, auth_timeout=1.0) → jeepney.io.blocking.DBusConnection[source]¶
Connect to a D-Bus message bus
Pass
enable_fds=True
to allow sending & receiving file descriptors. An error will be raised if the bus does not allow this. For simplicity, it’s advisable to leave this disabled unless you need it.D-Bus has an authentication step before sending or receiving messages. This takes < 1 ms in normal operation, but there is a timeout so that client code won’t get stuck if the server doesn’t reply. auth_timeout configures this timeout in seconds.
- class jeepney.io.blocking.DBusConnection(sock: socket.socket, enable_fds=False)[source]¶
- send(message: jeepney.low_level.Message, serial=None)[source]¶
Serialise and send a
Message
object
- receive(*, timeout=None) → jeepney.low_level.Message[source]¶
Return the next available message from the connection
If the data is ready, this will return immediately, even if timeout<=0. Otherwise, it will wait for up to timeout seconds, or indefinitely if timeout is None. If no message comes in time, it raises TimeoutError.
- send_and_get_reply(message, *, timeout=None, unwrap=None)[source]¶
Send a message, wait for the reply and return it
Filters are applied to other messages received before the reply - see
add_filter()
.
- recv_messages(*, timeout=None)[source]¶
Receive one message and apply filters
See
filter()
. Returns nothing.
- filter(rule, *, queue: Optional[collections.deque] = None, bufsize=1)[source]¶
Create a filter for incoming messages
Usage:
with conn.filter(rule) as matches: # matches is a deque containing matched messages matching_msg = conn.recv_until_filtered(matches)
- Parameters
rule (jeepney.MatchRule) – Catch messages matching this rule
queue (collections.deque) – Matched messages will be added to this
bufsize (int) – If no deque is passed in, create one with this size
- recv_until_filtered(queue, *, timeout=None) → jeepney.low_level.Message[source]¶
Process incoming messages until one is filtered into queue
Pops the message from queue and returns it, or raises TimeoutError if the optional timeout expires. Without a timeout, this is equivalent to:
while len(queue) == 0: conn.recv_messages() return queue.popleft()
In the other I/O modules, there is no need for this, because messages are placed in queues by a separate task.
- Parameters
queue (collections.deque) – A deque connected by
filter()
timeout (float) – Maximum time to wait in seconds
- close()¶
Close the connection
Using
with open_dbus_connection()
will also close the connection on exiting the block.
- class jeepney.io.blocking.Proxy(msggen, connection, *, timeout=None)[source]¶
A blocking proxy for calling D-Bus methods
You can call methods on the proxy object, such as
bus_proxy.Hello()
to make a method call over D-Bus and wait for a reply. It will either return a tuple of returned data, or raiseDBusErrorResponse
. The methods available are defined by the message generator you wrap.You can set a time limit on a call by passing
_timeout=
in the method call, or set a default when creating the proxy. The_timeout
argument is not passed to the message generator. All timeouts are in seconds, andTimeoutErrror
is raised if it expires before a reply arrives.- Parameters
msggen – A message generator object
connection (DBusConnection) – Connection to send and receive messages
timeout (float) – Default seconds to wait for a reply, or None for no limit
See also