detcd 0.1.4

An etcd-based implementation of service registration and discovery.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use std::time::Duration;
use tokio::select;
use tokio::time::sleep;
use detcd::client::Builder;
use detcd::registrar::{Registrar, SimpleService};
use detector::ServiceState::Stateful;
use detector::{DestinationRule, Meta, MetaKey, Service, ServiceKey, Strategy};

#[tokio::main]
async fn main() {
    let mut r = match register_meta().await {
        Err(e) => {
            println!("{:?}", e);
            return;
        }
        Ok(r) => r,
    };

    //println!("register simple_service: {:?}", register_simple_service().await);

    println!("register service: {:?}", register_service().await);
    
    r.unregister().await.unwrap();
}

async fn register_meta() -> Result<Registrar<Meta>, detcd::Error> {
    let client = Builder::new().build(&["localhost:2379"]).await?;

    let mut registrar: Registrar<Meta> = Registrar::from((
        client,
        Meta::new(MetaKey::new("game", "dev"), 4)
            .state(Some(Stateful))
            .destination_rule(DestinationRule::Header(
                "user_id".to_string(),
                Strategy::ConsistentHash,
            )),
    ));

    let _ = registrar.register().await?;
    Ok(registrar)
}

#[allow(dead_code)]
async fn register_simple_service() -> Result<(), detcd::Error> {
    let client = Builder::new().build(&["localhost:2379"]).await?;

    let mut key = ServiceKey::new("game", "dev");
    key.id = Some(1);
    let mut registrar: Registrar<SimpleService> = Registrar::from((
        client,
        Service::from_key(key)
            .ip(Some("192.134.21.21"))
            .port(Some(322)),
    ));

    registrar.register().await?;
    
    sleep(Duration::from_secs(20)).await;
    
    registrar.unregister().await
}

#[allow(dead_code)]
async fn register_service() -> Result<(), detcd::Error> {
    let client = Builder::new().build(&["localhost:2379"]).await?;

    let mut registrar: Registrar<Service> = Registrar::from((
        client,
        Service::from_key(ServiceKey::new("game", "dev"))
            .ip(Some("192.134.21.21"))
            .port(Some(322)),
    ));

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

    loop {
        select! {
            status = registrar.changed() => {
                println!("status changed: {:?}", status);
            },
            _ = sleep(Duration::from_secs(200)) => {
                println!("over");
                break;
            }
        }
    }
    
    drop(registrar);
    sleep(Duration::from_secs(5)).await;
    Ok(())
}