tosca-controller 0.1.1

A library for building a controller that manages all Tosca devices across a network.
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
140
141
142
143
144

use std::collections::HashMap;

use tosca::hazards::Hazards;

// TODO: Eventually rewrite policy IDs as &'static str.

/// A privacy policy manager.
///
/// It allows or blocks the requests to devices, or to a specific device,
/// according to a set of privacy rules.
#[derive(Debug, PartialEq)]
pub struct Policy {
    block_on_hazards: Hazards,
    block_device_on_hazards: HashMap<usize, Hazards>,
}

impl Policy {
    /// Creates a [`Policy`] to block **all** requests that have the given
    /// [`Hazards`] in their routes.
    #[must_use]
    #[inline]
    pub fn new(block_on_hazards: Hazards) -> Self {
        Self {
            block_on_hazards,
            block_device_on_hazards: HashMap::new(),
        }
    }

    /// Creates a [`Policy`] to block **all** [`crate::device::Device`] id
    /// requests that have the given [`Hazards`] in their routes.
    #[must_use]
    #[inline]
    pub fn only_local_policy(id: usize, hazards: Hazards) -> Self {
        let policy = Self::init();
        policy.block_device_on_hazards(id, hazards)
    }

    /// Adds a new [`Policy`] to block **all** [`crate::device::Device`] id
    /// requests that have the given [`Hazards`] in their routes.
    #[must_use]
    #[inline]
    pub fn block_device_on_hazards(mut self, id: usize, hazards: Hazards) -> Self {
        self.block_device_on_hazards.insert(id, hazards);
        self
    }

    pub(crate) fn init() -> Self {
        Self {
            block_on_hazards: Hazards::new(),
            block_device_on_hazards: HashMap::new(),
        }
    }

    pub(crate) fn global_blocked_hazards(&self, hazards: &Hazards) -> Hazards {
        let mut blocked_hazards = Hazards::new();
        for hazard in hazards {
            if self.block_on_hazards.contains(hazard) {
                blocked_hazards.add(*hazard);
            }
        }
        blocked_hazards
    }

    pub(crate) fn local_blocked_hazards(&self, id: usize, hazards: &Hazards) -> Hazards {
        if let Some(local_hazards) = self.block_device_on_hazards.get(&id) {
            let mut blocked_hazards = Hazards::new();
            for hazard in hazards {
                if local_hazards.contains(hazard) {
                    blocked_hazards.add(*hazard);
                }
            }
            blocked_hazards
        } else {
            Hazards::new()
        }
    }
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;

    use tosca::hazards::{Hazard, Hazards};

    use super::Policy;

    fn create_policy() -> (Hazards, Policy) {
        let hazards = Hazards::new().insert(Hazard::ElectricEnergyConsumption);

        let policy = Policy::new(hazards.clone());

        (hazards, policy)
    }

    fn check_device_policies(policy: &Policy, block_on_hazards: Hazards, local_hazards: &Hazards) {
        let mut devices_hazards = HashMap::new();
        devices_hazards.insert(1, local_hazards.clone());
        devices_hazards.insert(2, local_hazards.clone());

        assert_eq!(
            policy,
            &Policy {
                block_on_hazards,
                block_device_on_hazards: devices_hazards,
            }
        );
    }

    #[test]
    fn only_global_policy() {
        let (hazards, policy) = create_policy();

        assert_eq!(
            policy,
            Policy {
                block_on_hazards: hazards,
                block_device_on_hazards: HashMap::new()
            }
        );
    }

    #[test]
    fn only_local_policy() {
        let local_hazards = Hazards::new().insert(Hazard::Explosion);

        let policy = Policy::only_local_policy(1, local_hazards.clone())
            .block_device_on_hazards(2, local_hazards.clone());

        check_device_policies(&policy, Hazards::new(), &local_hazards);
    }

    #[test]
    fn complete_policy() {
        let (global_hazards, policy) = create_policy();

        let local_hazards = Hazards::new().insert(Hazard::Explosion);

        let policy = policy
            .block_device_on_hazards(1, local_hazards.clone())
            .block_device_on_hazards(2, local_hazards.clone());

        check_device_policies(&policy, global_hazards, &local_hazards);
    }
}