krata-daemon 0.0.21

Daemon for the krata isolation engine
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

use std::{collections::HashMap, path::Path};

use anyhow::Result;
use serde::{Deserialize, Serialize};
use tokio::fs;

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct DaemonConfig {
    #[serde(default)]
    pub oci: OciConfig,
    #[serde(default)]
    pub pci: DaemonPciConfig,
    #[serde(default = "default_network")]
    pub network: DaemonNetworkConfig,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct OciConfig {
    #[serde(default)]
    pub seed: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct DaemonPciConfig {
    #[serde(default)]
    pub devices: HashMap<String, DaemonPciDeviceConfig>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct DaemonPciDeviceConfig {
    pub locations: Vec<String>,
    #[serde(default)]
    pub permissive: bool,
    #[serde(default)]
    #[serde(rename = "msi-translate")]
    pub msi_translate: bool,
    #[serde(default)]
    #[serde(rename = "power-management")]
    pub power_management: bool,
    #[serde(default)]
    #[serde(rename = "rdm-reserve-policy")]
    pub rdm_reserve_policy: DaemonPciDeviceRdmReservePolicy,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub enum DaemonPciDeviceRdmReservePolicy {
    #[default]
    #[serde(rename = "strict")]
    Strict,
    #[serde(rename = "relaxed")]
    Relaxed,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct DaemonNetworkConfig {
    #[serde(default = "default_network_nameservers")]
    pub nameservers: Vec<String>,
    #[serde(default = "default_network_ipv4")]
    pub ipv4: DaemonIpv4NetworkConfig,
    #[serde(default = "default_network_ipv6")]
    pub ipv6: DaemonIpv6NetworkConfig,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct DaemonIpv4NetworkConfig {
    #[serde(default = "default_network_ipv4_subnet")]
    pub subnet: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct DaemonIpv6NetworkConfig {
    #[serde(default = "default_network_ipv6_subnet")]
    pub subnet: String,
}

fn default_network() -> DaemonNetworkConfig {
    DaemonNetworkConfig {
        nameservers: default_network_nameservers(),
        ipv4: default_network_ipv4(),
        ipv6: default_network_ipv6(),
    }
}

fn default_network_nameservers() -> Vec<String> {
    vec![
        "1.1.1.1".to_string(),
        "1.0.0.1".to_string(),
        "2606:4700:4700::1111".to_string(),
        "2606:4700:4700::1001".to_string(),
    ]
}

fn default_network_ipv4() -> DaemonIpv4NetworkConfig {
    DaemonIpv4NetworkConfig {
        subnet: default_network_ipv4_subnet(),
    }
}

fn default_network_ipv4_subnet() -> String {
    "10.75.0.0/16".to_string()
}

fn default_network_ipv6() -> DaemonIpv6NetworkConfig {
    DaemonIpv6NetworkConfig {
        subnet: default_network_ipv6_subnet(),
    }
}

fn default_network_ipv6_subnet() -> String {
    "fdd4:1476:6c7e::/48".to_string()
}

impl DaemonConfig {
    pub async fn load(path: &Path) -> Result<DaemonConfig> {
        if !path.exists() {
            let config: DaemonConfig = toml::from_str("")?;
            let content = toml::to_string_pretty(&config)?;
            fs::write(&path, content).await?;
        }
        let content = fs::read_to_string(path).await?;
        let config: DaemonConfig = toml::from_str(&content)?;
        Ok(config)
    }
}