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

use crate::action::Action;
use crate::resource::ResourceAddr;
use crate::server::{config::OptionalConfig, Config};
use crate::util::Hash;
use eyre::{eyre, Result};
use serde::{Deserialize, Serialize};
use serde_cbor::ser::to_vec_packed;

#[derive(Deserialize, Serialize, Debug)]
pub struct Block {
    name: String,
    tree: Box<dyn Action>,
    #[serde(default)]
    config: OptionalConfig,
}

impl Block {
    pub fn init(&mut self) -> Result<()> {
        self.verify_name()?;
        Ok(())
    }

    fn verify_name(&self) -> Result<()> {
        if self.name.is_empty() {
            Err(eyre!("Block `name` cannot be the empty string."))
        } else if !self
            .name
            .chars()
            .all(|c| c.is_alphabetic() || c.is_alphanumeric() | "+-_ ".contains(c))
        {
            Err(eyre!(
                "Block `name` characters need to be alphanumeric or one of (+-_ ): '{}'",
                self.name
            ))
        } else {
            Ok(())
        }
    }

    pub fn resources(&self, config: &Config) -> Vec<ResourceAddr> {
        self.tree.resources(config)
    }

    #[inline(always)]
    pub fn action_tree(&self) -> &dyn Action {
        &*self.tree
    }

    #[inline(always)]
    pub fn action_tree_vec(&self) -> Vec<u8> {
        to_vec_packed(&self.tree).unwrap()
    }

    #[inline(always)]
    pub fn label(&self) -> &str {
        &self.name
    }

    #[inline]
    pub fn config(&self, base_config: &Config) -> Config {
        self.config.fill_blanks(base_config)
    }
}

impl Hash for Block {
    fn hash(&self) -> String {
        use sha2::{Digest, Sha256};
        let mut hasher = Sha256::default();
        hasher.update(&serde_cbor::to_vec(&(&self.tree, &self.config)).unwrap());
        hex::encode(hasher.finalize())
    }
}