etcd 0.9.0

A client library for CoreOS's etcd.
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use etcd::auth::{self, AuthChange, NewUser, Role, RoleUpdate, UserUpdate};
use etcd::{BasicAuth, Client};
use futures::future::Future;
use tokio::runtime::Runtime;

#[test]
fn auth() {
    let client = Client::new(&["http://etcd:2379"], None).unwrap();
    let client_2 = client.clone();
    let client_3 = client.clone();

    let basic_auth = BasicAuth {
        username: "root".into(),
        password: "secret".into(),
    };

    let authed_client = Client::new(&["http://etcd:2379"], Some(basic_auth)).unwrap();
    let authed_client_2 = authed_client.clone();
    let authed_client_3 = authed_client.clone();
    let authed_client_4 = authed_client.clone();
    let authed_client_5 = authed_client.clone();
    let authed_client_6 = authed_client.clone();
    let authed_client_7 = authed_client.clone();
    let authed_client_8 = authed_client.clone();
    let authed_client_9 = authed_client.clone();

    let root_user = NewUser::new("root", "secret");

    let work: Box<dyn Future<Item = (), Error = ()> + Send> = Box::new(
        auth::status(&client)
            .then(move |res| {
                let response = res.unwrap();

                assert_eq!(response.data, false);

                auth::create_user(&client_2, root_user)
            })
            .then(move |res| {
                let response = res.unwrap();

                assert_eq!(response.data.name(), "root");

                auth::enable(&client_3)
            })
            .then(move |res| {
                let response = res.unwrap();

                assert_eq!(response.data, AuthChange::Changed);

                let mut update_guest = RoleUpdate::new("guest");

                update_guest.revoke_kv_write_permission("/*");

                auth::update_role(&authed_client, update_guest)
            })
            .then(move |res| {
                res.unwrap();

                let mut rkt_role = Role::new("rkt");

                rkt_role.grant_kv_read_permission("/rkt/*");
                rkt_role.grant_kv_write_permission("/rkt/*");

                auth::create_role(&authed_client_2, rkt_role)
            })
            .then(move |res| {
                res.unwrap();

                let mut rkt_user = NewUser::new("rkt", "secret");

                rkt_user.add_role("rkt");

                auth::create_user(&authed_client_3, rkt_user)
            })
            .then(move |res| {
                let response = res.unwrap();

                let rkt_user = response.data;

                assert_eq!(rkt_user.name(), "rkt");

                let role_name = &rkt_user.role_names()[0];

                assert_eq!(role_name, "rkt");

                let mut update_rkt_user = UserUpdate::new("rkt");

                update_rkt_user.update_password("secret2");
                update_rkt_user.grant_role("root");

                auth::update_user(&authed_client_4, update_rkt_user)
            })
            .then(move |res| {
                res.unwrap();

                auth::get_role(&authed_client_5, "rkt")
            })
            .then(move |res| {
                let response = res.unwrap();

                let role = response.data;

                assert!(role.kv_read_permissions().contains(&"/rkt/*".to_owned()));
                assert!(role.kv_write_permissions().contains(&"/rkt/*".to_owned()));

                auth::delete_user(&authed_client_6, "rkt")
            })
            .then(move |res| {
                res.unwrap();

                auth::delete_role(&authed_client_7, "rkt")
            })
            .then(move |res| {
                res.unwrap();

                let mut update_guest = RoleUpdate::new("guest");

                update_guest.grant_kv_write_permission("/*");

                auth::update_role(&authed_client_8, update_guest)
            })
            .then(move |res| {
                res.unwrap();

                auth::disable(&authed_client_9)
            })
            .then(|res| {
                let response = res.unwrap();

                assert_eq!(response.data, AuthChange::Changed);

                Ok(())
            }),
    );

    let _ = Runtime::new()
        .expect("failed to create Tokio runtime")
        .block_on(work);
}