Struct BlockingClient 

pub struct BlockingClient {
    pub stream: GenericBlockingStream,
    pub daemon_version: String,
}

This struct contains the base logic for the client. The client is responsible for connecting to the daemon, sending instructions and interpreting their responses.

use std::path::PathBuf;
use pueue_lib::{
    BlockingClient,
    Response,
    Request,
    network_blocking::socket::ConnectionSettings,
};



// Connection settings and secret to connect to the daemon.
let settings = ConnectionSettings::UnixSocket {
    path: PathBuf::from("/home/user/.local/share/pueue/pueue.socket"),
};
let secret = "My secret";

// Create a client. This already establishes a connection to the daemon.
let mut client = BlockingClient::new(settings, secret.as_bytes(), true)
    .context("Failed to initialize client.")?;

// Request the state.
client.send_request(Request::Status)?;
let response: Response = client.receive_response()?;

let _state = match response {
    Response::Status(state) => state,
    _ => unreachable!(),
};

Fields

stream: GenericBlockingStream

daemon_version: String

Implementations

impl BlockingClient

pub fn new( settings: ConnectionSettings<'_>, secret: &[u8], show_version_warning: bool, ) -> Result<Self>

Initialize a new client. This includes establishing a connection to the daemon: - Connect to the daemon. - Authorize via secret. - Check versions incompatibilities.

If the show_version_warning flag is true and the daemon has a different version than the client, a warning will be logged.

pub fn stream(&mut self) -> &mut GenericBlockingStream

Convenience function to get a mutable handle on the client’s stream.

pub fn send_request<T>(&mut self, message: T) -> Result<(), Error>

where T: Into<Request> + Serialize + Debug,

Convenience wrapper around super::send_request to directly send Requests.

pub fn receive_response(&mut self) -> Result<Response, Error>

Convenience wrapper that wraps receive_message for Responses

pub fn daemon_version(&self) -> &String

Trait Implementations

impl Debug for BlockingClient

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

Formats the value using the given formatter.