Struct ManagedTargetConfig 

pub struct ManagedTargetConfig {
    pub id: TargetId,
    pub server_addr: String,
    pub address_family: Option<AddressFamily>,
    pub auth: TargetAuth,
}

Endpoint, address-family and authentication specification for one managed target.

Fields

id: TargetId

server_addr: String

address_family: Option<AddressFamily>

Override the shared address-family policy. None inherits it.

The endpoint remains a hostname when supplied as one, so every new generation resolves it again using the effective family policy.

auth: TargetAuth

Implementations

impl ManagedTargetConfig

pub fn new(id: impl Into<TargetId>, server_addr: impl Into<String>) -> Self

Examples found in repository

examples/managed_client.rs (line 44)

fn main() {
    let config = ManagedClientConfig {
        client: ClientConfig {
            open: OpenPolicy {
                timeouts: vec![Duration::from_millis(300)],
                ..Default::default()
            },
            request: SessionRequest {
                duration: None,
                interval: Duration::from_millis(200),
                ..Default::default()
            },
            ..Default::default()
        },
        completion: ManagedCompletionPolicy::ExplicitStop,
        ..Default::default()
    };
    let targets = vec![ManagedTargetConfig::new("local", "127.0.0.1:2112")];

    let (owner, mut events) = match BlockingManagedClient::start_with_subscription(config, targets)
    {
        Ok(started) => started,
        Err(err) => {
            eprintln!("failed to start managed client: {err}");
            return;
        }
    };

    let stop_after = Duration::from_secs(1);
    let deadline = std::time::Instant::now() + stop_after;
    while std::time::Instant::now() < deadline {
        match events.try_recv() {
            Ok(event) => print_event(&event),
            Err(_) => std::thread::sleep(Duration::from_millis(50)),
        }
    }

    // `stop()` requests the stop synchronously; the returned receipt is only
    // useful for awaiting durable acknowledgement, which this blocking
    // example does not need.
    std::mem::drop(owner.handle().stop());
    match owner.join() {
        Ok(outcome) => println!("managed run ended: {:?}", outcome.end_reason),
        Err(err) => eprintln!("managed worker did not join cleanly: {err}"),
    }
}

Trait Implementations

impl Clone for ManagedTargetConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ManagedTargetConfig

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

Formats the value using the given formatter.

impl Eq for ManagedTargetConfig

impl PartialEq for ManagedTargetConfig

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ManagedTargetConfig