etcd-detector

日志

tracing feature可以控制调试日志的输出

示例用法

use detector::{DetectMeta, Detector};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let builder = etcd_detector::Builder::connect(["localhost:2379"])
        .await
        .unwrap();

    let mut detect = {
        let s =
            detector::Service::from_key(ServiceKey::new("mail", ""))
                .ttl(Some(100))
                .ip(Some("127.0.0.1"))
                .port(Some(3001));
        builder.detector(s)
    };

    let mut meta_detector = {
        let meta = detector::Meta::new(MetaKey::new("mail", ""), 1);
        builder.meta_detector(meta)
    };

    // 注册元数据
    meta_detector.register().await.unwrap();

    // 获取元数据
    println!("meta fetch: {:?}", meta_detector.fetch().await);

    println!("oneself: {:?}", detect.oneself());
    println!("oneself status: {:?}", detect.oneself().status());
    println!("service: {:?}", detect.service());
    println!("service register: {:?}", detect.register().await);
    println!("oneself status: {:?}", detect.oneself().status());
    println!("service: {:?}", detect.service());

    let mut oneself = detect.oneself();
    tokio::spawn(async move {
        loop {
            match oneself.changed().await {
                Err(_) => break,
                Ok(status) => println!("watch status: {:?}", status),
            }
        }
    });

    // 监听所有
    let mut watch_all = detect.watch_all().await.unwrap();
    tokio::spawn(async move {
        loop {
            match watch_all.event().await {
                Ok(e) => {
                    println!("watch all, recv event:{:?}", e);
                },
                Err(e) => {
                    println!("watch all error: {:?}", e);
                    break;
                }
            }
        }
    });

    // 监听本类型服
    let mut watch = detect.watch().await.unwrap();
    tokio::spawn(async move {
        loop {
            match watch.event().await {
                Ok(e) => {
                    println!("watch, recv event:{:?}", e);
                },
                Err(e) => {
                    println!("watch error: {:?}", e);
                    break;
                }
            }
        }
    });

    tokio::time::sleep(Duration::from_secs(120)).await;
    drop(detect);
    println!("drop detect");
    tokio::time::sleep(Duration::from_secs(30)).await;
}