rain_server 0.3.0-rc3

Distributed computational framework for large-scale task-based pipelines. Server and governor binaries.
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

use rain_core::types::*;
use std::collections::HashMap;

use super::{ClientRef, DataObjectRef, GovernorRef, SessionRef, TaskRef};

#[derive(Clone, Default)]
pub struct Graph {
    /// Contained objects
    pub(in super::super) governors: HashMap<GovernorId, GovernorRef>,
    pub(in super::super) tasks: HashMap<TaskId, TaskRef>,
    pub(in super::super) objects: HashMap<DataObjectId, DataObjectRef>,
    pub(in super::super) sessions: HashMap<SessionId, SessionRef>,
    pub(in super::super) clients: HashMap<ClientId, ClientRef>,

    /// The last SessionId assigned.
    session_id_counter: SessionId,
}

impl Graph {
    pub fn new(session_id_counter: SessionId) -> Self {
        let mut g: Graph = Default::default();
        g.session_id_counter = session_id_counter;
        g
    }

    pub fn new_session_id(&mut self) -> SessionId {
        self.session_id_counter += 1;
        self.session_id_counter
    }
}

#[cfg(test)]

mod tests {
    use super::super::{ClientRef, DataObjectRef, GovernorRef, Graph, SessionRef, TaskRef};
    use rain_core::types::Resources;
    use rain_core::types::{DataObjectId, SId, TaskId};
    use rain_core::types::{ObjectSpec, TaskSpec, TaskSpecInput};

    fn create_test_graph(
        governors: usize,
        clients: usize,
        sessions: usize,
        tasks: usize,
        objects: usize,
    ) -> Graph {
        use rain_core::types::DataType;

        let g = Graph::new(1);
        for wi in 0..governors {
            GovernorRef::new(
                format!("0.0.0.{}:67", wi + 1).parse().unwrap(),
                None,
                Resources { cpus: 8 },
            );
        }
        for ci in 0..clients {
            let c = ClientRef::new(format!("0.0.0.{}:42", ci + 1).parse().unwrap());
            for si in 0..sessions {
                let s = SessionRef::new(si as i32, &c);
                let mut objs = Vec::new();

                for oi in 0..objects {
                    let spec = ObjectSpec {
                        id: DataObjectId::new(s.get().id, oi as i32),
                        label: Default::default(),
                        user: Default::default(),
                        data_type: DataType::Blob,
                        content_type: "".into(),
                    };

                    let o = DataObjectRef::new(&s, spec, false, None);
                    objs.push(o);
                }
                for ti in 0..tasks {
                    let mut inputs = Vec::new();
                    let mut input_objs = Vec::new();

                    if ti >= 2 {
                        for i in 1..3 {
                            let obj = &objs[ti - i];
                            input_objs.push(obj.clone());
                            inputs.push(TaskSpecInput {
                                id: obj.get().id(),
                                label: Default::default(),
                            });
                        }
                    }
                    let output_objs = vec![objs[ti].clone()];
                    let outputs: Vec<_> = output_objs.iter().map(|o| o.get().id()).collect();

                    let spec = TaskSpec {
                        id: TaskId::new(s.get_id(), (ti + objects) as i32),
                        inputs: inputs,
                        outputs: outputs,
                        task_type: "TType".to_string(),
                        resources: Resources { cpus: 1 },
                        config: None,
                        user: Default::default(),
                    };

                    TaskRef::new(&s, spec, input_objs, output_objs).unwrap();
                }
            }
        }
        // TODO: add some governor links
        g
    }

    #[test]
    #[ignore]
    fn graph_create_delete() {
        let g = create_test_graph(4, 2, 3, 10, 20);

        assert!(!g.objects.is_empty());
        assert!(!g.governors.is_empty());

        //let client_rcs: Vec<_> = g.clients.values().map(|x| x.clone()).collect();
        //let governor_rcs: Vec<_> = g.governors.values().map(|x| x.clone()).collect();

        // FIXME!
        //for c in client_rcs { c.delete(&mut g); }
        //for w in governor_rcs { w.delete(&mut g); }

        assert!(g.clients.is_empty());
        assert!(g.governors.is_empty());
        assert!(g.tasks.is_empty());
        assert!(g.objects.is_empty());
        assert!(g.sessions.is_empty());
    }
}