ax_core 0.3.2

Core library implementing the functions of ax
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

use crate::{
    api::rejections::{ApiError, UnauthorizedReason},
    certs::{AppLicenseType, Expiring, SignedAppLicense},
    crypto::PublicKey,
};
use ax_types::AppId;
use chrono::Utc;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Licensing {
    node: String,
    pub apps: BTreeMap<AppId, String>,
}

impl Licensing {
    pub fn new(node: String, apps: BTreeMap<AppId, String>) -> Self {
        Self { node, apps }
    }

    pub fn is_node_licensed(&self, ax_public_key: &PublicKey) -> Result<bool, ApiError> {
        if self.node == "development" {
            return Ok(false);
        }
        let license = self
            .node
            .parse::<SignedAppLicense>()
            .map_err(|_| ApiError::NodeUnauthorized {
                reason: UnauthorizedReason::MalformedLicense,
            })?;
        license
            .validate(ax_public_key)
            .map_err(|_| ApiError::NodeUnauthorized {
                reason: UnauthorizedReason::InvalidSignature,
            })?;
        match license.license.license_type {
            AppLicenseType::Expiring(Expiring { app_id, expires_at }) => {
                if app_id.as_str() != "com.actyx.node" {
                    Err(ApiError::NodeUnauthorized {
                        reason: UnauthorizedReason::WrongSubject,
                    })
                } else if expires_at < Utc::now() {
                    Err(ApiError::NodeUnauthorized {
                        reason: UnauthorizedReason::Expired,
                    })
                } else {
                    Ok(true)
                }
            }
        }
    }

    pub fn app_id_license(&self, app_id: &AppId) -> Option<&String> {
        self.apps.get(app_id)
    }
}

impl Default for Licensing {
    fn default() -> Self {
        Licensing {
            node: "development".into(),
            apps: BTreeMap::default(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::api::{licensing::Licensing, rejections::ApiError};
    use std::collections::BTreeMap;

    #[test]
    fn default() {
        let licensing = Licensing::default();
        assert_eq!(licensing.node, "development");
        assert!(licensing.apps.is_empty());
    }

    #[test]
    fn is_node_licensed() {
        let licensing = Licensing::default();
        let ax_key = PublicKey::ax_public_key();
        assert!(!licensing.is_node_licensed(&ax_key).unwrap());

        let licensing = Licensing {
            node: "licensed".into(),
            apps: BTreeMap::default(),
        };
        assert_eq!(
            licensing.is_node_licensed(&ax_key).unwrap_err(),
            ApiError::NodeUnauthorized {
                reason: UnauthorizedReason::MalformedLicense
            }
        );
    }
}