ciruela 0.6.12

A peer-to-peer synchronization software for servers in datacenters.
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

use std::collections::HashMap;
use std::time::SystemTime;

use index::ImageId;
use machine_id::MachineId;
use proto::{Signature, SigData, Request, Response};
use serialize::timestamp;
// use signature::SignedUpload;
use time_util::to_ms;
use {VPath};


#[derive(Serialize, Deserialize, Debug)]
pub struct AppendDir {
    pub path: VPath,
    pub image: ImageId,
    #[serde(with="timestamp")]
    pub timestamp: SystemTime,
    pub signatures: Vec<Signature>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ReplaceDir {
    pub path: VPath,
    pub image: ImageId,
    pub old_image: Option<ImageId>,
    #[serde(with="timestamp")]
    pub timestamp: SystemTime,
    pub signatures: Vec<Signature>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct AppendDirAck {
    pub accepted: bool,
    pub reject_reason: Option<String>,
    #[serde(default)]
    pub hosts: HashMap<MachineId, String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ReplaceDirAck {
    pub accepted: bool,
    pub reject_reason: Option<String>,
    #[serde(default)]
    pub hosts: HashMap<MachineId, String>,
}

impl AppendDir {
    pub fn sig_data(&self) -> SigData {
        SigData {
            path: self.path.as_ref().to_str().expect("path is string"),
            image: self.image.as_ref(),
            timestamp: to_ms(self.timestamp),
        }
    }
    /*
    pub fn new(up: &SignedUpload) -> AppendDir {
        AppendDir {
            image: up.image_id.clone(),
            timestamp: up.timestamp,
            signatures: up.signatures.clone(),
            path: up.path.clone(),
        }
    }
    */
}

impl ReplaceDir {
    pub fn sig_data(&self) -> SigData {
        SigData {
            path: self.path.as_ref().to_str().expect("path is string"),
            image: self.image.as_ref(),
            timestamp: to_ms(self.timestamp),
        }
    }
    /*
    pub fn new(up: &SignedUpload, old: Option<&ImageId>) -> ReplaceDir {
        ReplaceDir {
            image: up.image_id.clone(),
            timestamp: up.timestamp,
            signatures: up.signatures.clone(),
            path: up.path.clone(),
            old_image: old.map(|x| x.clone()),
        }
    }
    */
}

impl Request for AppendDir {
    type Response = AppendDirAck;
    fn type_name(&self) -> &'static str {
        return "AppendDir";
    }
}

impl Response for AppendDirAck {
    fn type_name(&self) -> &'static str {
        return "AppendDir";
    }
    fn static_type_name() -> &'static str {
        return "AppendDir";
    }
}

impl Request for ReplaceDir {
    type Response = ReplaceDirAck;
    fn type_name(&self) -> &'static str {
        return "ReplaceDir";
    }
}

impl Response for ReplaceDirAck {
    fn type_name(&self) -> &'static str {
        return "ReplaceDir";
    }
    fn static_type_name() -> &'static str {
        return "ReplaceDir";
    }
}