Struct LogProxy 

pub struct LogProxy<'c>(/* private fields */);

Log Service

Log service which receives all Log events from all of the OpenVPN 3 Linux services.

OpenVPN Documentation

Implementations

impl<'c> LogProxy<'c>

pub async fn new(conn: &Connection) -> Result<LogProxy<'c>>

Creates a new proxy with the default service and path.

pub fn builder(conn: &Connection) -> ProxyBuilder<'c, Self>

Returns a customizable builder for this proxy.

pub fn into_inner(self) -> Proxy<'c>

Consumes self, returning the underlying zbus::Proxy.

pub fn inner(&self) -> &Proxy<'c>

The reference to the underlying zbus::Proxy.

pub async fn assign_session( &self, session_path: &ObjectPath<'_>, interface: &str, ) -> Result<()>

AssignSession method

A net.openvpn.v3.backend.be${PID} service can through this method add a link between the Session D-Bus path to a specific VPN client service. This is required to have happened before the net.openvpn.v3.log service can do a lookup from a session path to log events coming from a specific client backend.

Arguments

• session_path - D-Bus Session Path to the session this client is responsible for.
• interface - String containing the client interface log events are related to.

pub async fn attach(&self, interface: &str) -> Result<()>

Attach method

This makes the log service aware of a Log signal producer which it needs to subscribe to. At the same time, the Log signal producer will then target these signals only to the net.openvpn.v3.log D-Bus service.

Arguments

• interface - String containing the service interface to subscribe to. If a service sends Log signals with different signals, each of these interfaces must be Attached.

pub async fn detach(&self, interface: &str) -> Result<()>

Detach method

This is the reverse operation of Attach(), where the log service will unsubscribe from a specific log producing sender. This is important to avoid resource leaking in the log service. Attached subscriptions should not hurt the performance if they never send signals, but it should be avoided to have too many idling subscriptions.

Arguments

• interface - String containing the service interface to unsubscribe from. If a service sends Log signals with different signals, each of these interfaces must be Detached.

pub async fn get_subscriber_list( &self, ) -> Result<Vec<(String, String, String, String)>>

GetSubscriberList method

Retrieve a list of all subscriptions the log service is attached to. The entries listed here are services which have used the Attach() method in this service. Services calling the Detach() method will be unlisted.

Returns

An array of subscriber tuples:

0. String containing a tag value which is used in the logs.
1. String containing the bus name the log service is attached to.
2. String containing the D-Bus object interface the subscription is tied to.
3. String containing the D-Bus object path the subscription is tied to.

pub async fn proxy_log_events( &self, target_address: &str, session_path: &ObjectPath<'_>, ) -> Result<LogNodeProxy<'c>>

ProxyLogEvents method

This method is by design only available by the openvpn user, which the net.openvpn.v3.sessions service is running under. The Session Manager can call this method to setup a new log recipient for a given VPN session. In addition to Log events being forwarded, StatusChange signals are also part of this feature.

• target_address - D-Bus unique bus name for the recipient of Log and StatusChange events.
• session_path - D-Bus object path to the VPN session object.

Returns

D-Bus object path to the Log Proxy object in the logger service.

pub async fn config_file(&self) -> Result<String>

Filename of the config/state file openvpn3-service-logger parsed at start-up.

pub fn cached_config_file( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the config_file property, or None if the property is not cached.

pub async fn receive_config_file_changed( &self, ) -> PropertyStream<'c, <Result<String> as ResultAdapter>::Ok>

Create a stream for the config_file property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn log_dbus_details(&self) -> Result<bool>

Should each Log event being processed carry a meta data line before with details about the D-Bus sender of the Log signal?

pub fn cached_log_dbus_details( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the log_dbus_details property, or None if the property is not cached.

pub async fn receive_log_dbus_details_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the log_dbus_details property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_log_dbus_details(&self, value: bool) -> Result<()>

pub async fn log_level(&self) -> Result<LogLevel>

How verbose should the logging be.

pub fn cached_log_level( &self, ) -> Result<Option<<Result<LogLevel> as ResultAdapter>::Ok>, <Result<LogLevel> as ResultAdapter>::Err>

Get the cached value of the log_level property, or None if the property is not cached.

pub async fn receive_log_level_changed( &self, ) -> PropertyStream<'c, <Result<LogLevel> as ResultAdapter>::Ok>

Create a stream for the log_level property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_log_level(&self, value: LogLevel) -> Result<()>

pub async fn log_method(&self) -> Result<String>

Indicates which logging method is in use.

pub fn cached_log_method( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the log_method property, or None if the property is not cached.

pub async fn receive_log_method_changed( &self, ) -> PropertyStream<'c, <Result<String> as ResultAdapter>::Ok>

Create a stream for the log_method property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn log_prefix_logtag(&self) -> Result<bool>

Configures if logged messages should be prefixed with the log senders LogTag hash value.

pub fn cached_log_prefix_logtag( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the log_prefix_logtag property, or None if the property is not cached.

pub async fn receive_log_prefix_logtag_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the log_prefix_logtag property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_log_prefix_logtag(&self, value: bool) -> Result<()>

pub async fn num_attached(&self) -> Result<u32>

Number of attached subscriptions.

pub fn cached_num_attached( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

Get the cached value of the num_attached property, or None if the property is not cached.

pub async fn receive_num_attached_changed( &self, ) -> PropertyStream<'c, <Result<u32> as ResultAdapter>::Ok>

Create a stream for the num_attached property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn timestamp(&self) -> Result<bool>

Should each log line be prefixed with a timestamp?

pub fn cached_timestamp( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the timestamp property, or None if the property is not cached.

pub async fn receive_timestamp_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the timestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_timestamp(&self, value: bool) -> Result<()>

pub async fn version(&self) -> Result<String>

Version information about the running service.

pub fn cached_version( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the version property, or None if the property is not cached.

pub async fn receive_version_changed( &self, ) -> PropertyStream<'c, <Result<String> as ResultAdapter>::Ok>

Create a stream for the version property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

Methods from Deref<Target = Proxy<'c>>

pub fn connection(&self) -> &Connection

Get a reference to the associated connection.

pub fn destination(&self) -> &BusName<'_>

Get a reference to the destination service name.

pub fn path(&self) -> &ObjectPath<'_>

Get a reference to the object path.

Examples found in repository

examples/basic.rs (line 50)

fn main() {
    task::block_on(async {
        let connection = zbus::Connection::system().await.unwrap();
        let config_manager = openvpn3_rs::ConfigurationProxy::new(&connection)
            .await
            .unwrap();
        let config = config_manager
            .import("My VPN", CONFIG_STR, true, false)
            .await
            .unwrap();

        let sessions_manager = openvpn3_rs::SessionsProxy::new(&connection).await.unwrap();
        let session = sessions_manager.new_tunnel(&config.path()).await.unwrap();

        let mut ready = false;
        while !ready {
            // If the session is ready, the `ready()` method will return Ok(), otherwise an error will be returned with more details.
            if let Err(err) = session.ready().await {
                let err_str = err.to_string();
                if err_str.contains("Missing user credentials") {
                    // This loop queries the session for which credentials are needed. This example covers username/password authentication.

                    let ui_type_group = session.user_input_queue_get_type_group().await.unwrap();

                    for (ca_type, ca_group) in ui_type_group {
                        let ui_queue_ids = session
                            .user_input_queue_check(ca_type, ca_group)
                            .await
                            .unwrap();

                        for id in ui_queue_ids {
                            let (ca_type, ca_group, id, name, _description, _hidden_input) =
                                session
                                    .user_input_queue_fetch(ca_type, ca_group, id)
                                    .await
                                    .unwrap();

                            if name == "username" {
                                session
                                    .user_input_provide(ca_type, ca_group, id, "smith")
                                    .await
                                    .unwrap();
                            }

                            if name == "password" {
                                session
                                    .user_input_provide(ca_type, ca_group, id, "hunter2")
                                    .await
                                    .unwrap();
                            }
                        }
                    }
                } else if err_str.contains("Backend VPN process is not ready") {
                    task::sleep(std::time::Duration::from_secs(1)).await;
                }
            } else {
                ready = true;
            }
        }

        session.connect().await.unwrap();

        // wait for signal to disconnect

        session.disconnect().await.unwrap();
    });
}

pub fn interface(&self) -> &InterfaceName<'_>

Get a reference to the interface.

pub async fn introspect(&self) -> Result<String, Error>

Introspect the associated object, and return the XML description.

See the xml or quick_xml module for parsing the result.

pub fn cached_property<T>( &self, property_name: &str, ) -> Result<Option<T>, Error>

where T: TryFrom<OwnedValue>, <T as TryFrom<OwnedValue>>::Error: Into<Error>,

Get the cached value of the property property_name.

This returns None if the property is not in the cache. This could be because the cache was invalidated by an update, because caching was disabled for this property or proxy, or because the cache has not yet been populated. Use get_property to fetch the value from the peer.

pub fn cached_property_raw<'p>( &'p self, property_name: &'p str, ) -> Option<impl Deref<Target = Value<'static>> + 'p>

Get the cached value of the property property_name.

Same as cached_property, but gives you access to the raw value stored in the cache. This is useful if you want to avoid allocations and cloning.

pub async fn get_property<T>(&self, property_name: &str) -> Result<T, Error>

where T: TryFrom<OwnedValue>, <T as TryFrom<OwnedValue>>::Error: Into<Error>,

Get the property property_name.

Get the property value from the cache (if caching is enabled) or call the Get method of the org.freedesktop.DBus.Properties interface.

pub async fn set_property<'t, T>( &self, property_name: &str, value: T, ) -> Result<(), Error>

where T: 't + Into<Value<'t>>,

Set the property property_name.

Effectively, call the Set method of the org.freedesktop.DBus.Properties interface.

pub async fn call_method<'m, M, B>( &self, method_name: M, body: &B, ) -> Result<Arc<Message>, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType,

Call a method and return the reply.

Typically, you would want to use call method instead. Use this method if you need to deserialize the reply message manually (this way, you can avoid the memory allocation/copying, by deserializing the reply to an unowned type).

pub async fn call<'m, M, B, R>( &self, method_name: M, body: &B, ) -> Result<R, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType, R: DeserializeOwned + Type,

Call a method and return the reply body.

Use call_method instead if you need to deserialize the reply manually/separately.

pub async fn call_with_flags<'m, M, B, R>( &self, method_name: M, flags: BitFlags<MethodFlags>, body: &B, ) -> Result<Option<R>, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType, R: DeserializeOwned + Type,

Call a method and return the reply body, optionally supplying a set of method flags to control the way the method call message is sent and handled.

Use call instead if you do not need any special handling via additional flags. If the NoReplyExpected flag is passed , this will return None immediately after sending the message, similar to call_noreply

pub async fn call_noreply<'m, M, B>( &self, method_name: M, body: &B, ) -> Result<(), Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType,

Call a method without expecting a reply

This sets the NoReplyExpected flag on the calling message and does not wait for a reply.

pub async fn receive_signal<'m, M>( &self, signal_name: M, ) -> Result<SignalStream<'m>, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>,

Create a stream for signal named signal_name.

pub async fn receive_signal_with_args<'m, M>( &self, signal_name: M, args: &[(u8, &str)], ) -> Result<SignalStream<'m>, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>,

Same as Proxy::receive_signal but with a filter.

The D-Bus specification allows you to filter signals by their arguments, which helps avoid a lot of unnecessary traffic and processing since the filter is run on the server side. Use this method where possible. Note that this filtering is limited to arguments of string types.

The arguments are passed as a tuples of argument index and expected value.

pub async fn receive_all_signals(&self) -> Result<SignalStream<'static>, Error>

Create a stream for all signals emitted by this service.

pub async fn receive_property_changed<'name, T>( &self, name: &'name str, ) -> PropertyStream<'a, T>

where 'name: 'a,

Get a stream to receive property changed events.

Note that zbus doesn’t queue the updates. If the listener is slower than the receiver, it will only receive the last update.

If caching is not enabled on this proxy, the resulting stream will not return any events.

pub async fn receive_owner_changed( &self, ) -> Result<OwnerChangedStream<'_>, Error>

Get a stream to receive destination owner changed events.

If the proxy destination is a unique name, the stream will be notified of the peer disconnection from the bus (with a None value).

If the proxy destination is a well-known name, the stream will be notified whenever the name owner is changed, either by a new peer being granted ownership (Some value) or when the name is released (with a None value).

Note that zbus doesn’t queue the updates. If the listener is slower than the receiver, it will only receive the last update.

Trait Implementations

impl<'c> AsMut<Proxy<'c>> for LogProxy<'c>

fn as_mut(&mut self) -> &mut Proxy<'c>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'c> AsRef<Proxy<'c>> for LogProxy<'c>

fn as_ref(&self) -> &Proxy<'c>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'c> Clone for LogProxy<'c>

fn clone(&self) -> LogProxy<'c>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'c> Debug for LogProxy<'c>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'c> Deref for LogProxy<'c>

type Target = Proxy<'c>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'c> DerefMut for LogProxy<'c>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'c> From<Proxy<'c>> for LogProxy<'c>

fn from(proxy: Proxy<'c>) -> Self

Converts to this type from the input type.

impl<'a> ProxyDefault for LogProxy<'a>

const INTERFACE: &'static str = "net.openvpn.v3.log"

const DESTINATION: &'static str = "net.openvpn.v3.log"

const PATH: &'static str = "/net/openvpn/v3/log"

impl<'c> Serialize for LogProxy<'c>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'c> Type for LogProxy<'c>

fn signature() -> Signature<'static>

Get the signature for the implementing type.