Struct varlink::VarlinkService

pub struct VarlinkService { /* fields omitted */ }

VarlinkService handles all the I/O and dispatches method calls to the registered interfaces.

Implementations

impl VarlinkService

pub fn new<S: Into<Cow<'static, str>>>(
    vendor: S,
    product: S,
    version: S,
    url: S,
    interfaces: Vec<Box<dyn Interface + Send + Sync>>
) -> Self

Create a new VarlinkService.

See the Service section of the varlink wiki about the vendor, product, version and url.

The interfaces vector is an array of varlink Interfaces this service provides.

Examples

let service = varlink::VarlinkService::new(
    "org.varlink",
    "test service",
    "0.1",
    "http://varlink.org",
    vec![
        Box::new(interface_foo),
        Box::new(interface_bar),
        Box::new(interface_baz),
    ],
);

Trait Implementations

impl ConnectionHandler for VarlinkService

fn handle(
    &self,
    bufreader: &mut dyn BufRead,
    writer: &mut dyn Write,
    upgraded_last_interface: Option<String>
) -> Result<(Vec<u8>, Option<String>)>

handle() consumes every null terminated message from reader and writes the reply to writer.

This method can be used to implement your own server. Pass it one or more null terminated received messages in a BufReader and reply to the sender with the filled writer buffer.

Returns Ok(true), if the connection is upgraded. For upgraded connections messages are in legacy format and

Examples

use varlink::{ConnectionHandler, VarlinkService};
let service = VarlinkService::new(
    "org.varlink",
    "test service",
    "0.1",
    "http://varlink.org",
    vec![], // more interfaces ...
);
let mut in_buf = io::BufReader::new("received null terminated message(s) go here \000".as_bytes());
let mut out: Vec<u8> = Vec::new();
assert!(service.handle(&mut in_buf, &mut out, None).is_ok());

impl Interface for VarlinkService

fn get_description(&self) -> &'static str

fn get_name(&self) -> &'static str

fn call_upgraded(
    &self,
    call: &mut Call<'_>,
    _bufreader: &mut dyn BufRead
) -> Result<Vec<u8>>

fn call(&self, call: &mut Call<'_>) -> Result<()>