wip on refactoring dtpm proto and type

build.rs

@@ -7,6 +7,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 "proto/daemon.proto",
                 "proto/shared.proto",
                 "proto/brain.proto",
+                "proto/dtpm.proto",
             ],
             &["proto"],
         )?;

proto/dtpm.proto

@@ -0,0 +1,61 @@
+syntax = "proto3";
+
+package dtpm;
+
+message Empty {
+}
+
+message DtpmConfigData {
+  repeated FileEntry filesystems = 1;
+  repeated EnvironmentEntry environments = 2;
+  repeated ChildProcess child_processes = 3;
+}
+
+message FileEntry {
+  string path = 1;
+  string content = 2;
+}
+
+message EnvironmentEntry {
+  string name = 1;
+  string value = 2;
+}
+
+message ChildProcess {
+  string path = 1;
+  repeated string arguments = 2;
+  RestartPolicy restart= 3;
+}
+
+message RestartPolicy {
+  uint32 max_retries = 1;
+  uint32 delay_seconds = 2;
+  oneof policy_type {
+    bool Always = 3;
+    bool OnNonZeroExit = 4;
+  }
+}
+
+
+message DtpmSetConfigReq {
+  DtpmConfigData config_data = 1;
+  string metadata = 2;
+}
+
+message DtpmSetConfigRes {
+  string status = 1;
+  string error = 2;
+}
+message DtpmGetConfigReq {
+  Empty empty = 1;
+}
+
+message DtpmGetConfigRes {
+  DtpmConfigData config_data = 1;
+}
+
+
+service DtpmConfigManager {
+  rpc SetConfig(DtpmSetConfigReq) returns (DtpmSetConfigRes) {}
+  rpc GetConfig(DtpmGetConfigReq) returns (DtpmGetConfigRes) {}
+}

src/lib.rs

@@ -9,6 +9,10 @@ pub mod pb {
     pub mod brain {
         tonic::include_proto!("brain");
     }
+
+    pub mod dtpm {
+        tonic::include_proto!("dtpm");
+    }
 }
 
 pub mod types;

src/types.rs

@@ -1,2 +1,3 @@
 pub mod brain;
+pub mod dtpm;
 pub mod shared;

src/types/dtpm.rs

@@ -0,0 +1,180 @@
+use crate::pb::dtpm as pb_dtpm;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct DtpmConfig {
+    pub filesystems: Vec<FileEntry>,
+    pub environments: Vec<EnvironmentEntry>,
+    pub child_processes: Vec<ChildProcess>,
+}
+
+impl From<pb_dtpm::DtpmConfigData> for DtpmConfig {
+    fn from(pb_val: pb_dtpm::DtpmConfigData) -> Self {
+        DtpmConfig {
+            filesystems: pb_val
+                .filesystems
+                .into_iter()
+                .map(FileEntry::from)
+                .collect(),
+            environments: pb_val
+                .environments
+                .into_iter()
+                .map(EnvironmentEntry::from)
+                .collect(),
+            child_processes: pb_val
+                .child_processes
+                .into_iter()
+                .map(ChildProcess::from)
+                .collect(),
+        }
+    }
+}
+
+impl From<DtpmConfig> for pb_dtpm::DtpmConfigData {
+    fn from(val: DtpmConfig) -> pb_dtpm::DtpmConfigData {
+        pb_dtpm::DtpmConfigData {
+            filesystems: val.filesystems.into_iter().map(Into::into).collect(),
+            environments: val.environments.into_iter().map(Into::into).collect(),
+            child_processes: val.child_processes.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileEntry {
+    pub path: String,
+    pub content: FileContent,
+}
+
+impl From<pb_dtpm::FileEntry> for FileEntry {
+    fn from(pb_val: pb_dtpm::FileEntry) -> Self {
+        FileEntry {
+            path: pb_val.path,
+            content: FileContent::Data(pb_val.content),
+        }
+    }
+}
+impl From<FileEntry> for pb_dtpm::FileEntry {
+    fn from(val: FileEntry) -> pb_dtpm::FileEntry {
+        pb_dtpm::FileEntry {
+            path: val.path,
+            content: match val.content {
+                FileContent::Data(data) => data,
+                FileContent::Path(path) => path,
+            },
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum FileContent {
+    #[serde(rename = "path")]
+    Path(String),
+    #[serde(rename = "data")]
+    Data(String),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EnvironmentEntry {
+    pub name: String,
+    pub value: String,
+}
+
+impl From<pb_dtpm::EnvironmentEntry> for EnvironmentEntry {
+    fn from(pb_val: pb_dtpm::EnvironmentEntry) -> Self {
+        EnvironmentEntry {
+            name: pb_val.name,
+            value: pb_val.value,
+        }
+    }
+}
+
+impl From<EnvironmentEntry> for pb_dtpm::EnvironmentEntry {
+    fn from(val: EnvironmentEntry) -> pb_dtpm::EnvironmentEntry {
+        pb_dtpm::EnvironmentEntry {
+            name: val.name,
+            value: val.value,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ChildProcess {
+    pub path: String,
+    pub arguments: Vec<String>,
+    pub restart: Option<RestartPolicy>,
+}
+
+impl From<pb_dtpm::ChildProcess> for ChildProcess {
+    fn from(pb_val: pb_dtpm::ChildProcess) -> Self {
+        ChildProcess {
+            path: pb_val.path,
+            arguments: pb_val.arguments,
+            restart: pb_val.restart.map(RestartPolicy::from),
+        }
+    }
+}
+
+impl From<ChildProcess> for pb_dtpm::ChildProcess {
+    fn from(val: ChildProcess) -> pb_dtpm::ChildProcess {
+        pb_dtpm::ChildProcess {
+            path: val.path,
+            arguments: val.arguments,
+            restart: val.restart.map(Into::into),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, Default)]
+pub struct RestartPolicy {
+    pub max_retries: u32,
+    pub delay_seconds: u32,
+    pub policy: Option<RestartPolicyType>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub enum RestartPolicyType {
+    Always(bool),
+    OnNonZeroExit(bool),
+}
+
+impl Default for RestartPolicyType {
+    fn default() -> Self {
+        RestartPolicyType::Always(true)
+    }
+}
+impl From<pb_dtpm::RestartPolicy> for RestartPolicy {
+    fn from(pb_val: pb_dtpm::RestartPolicy) -> Self {
+        RestartPolicy {
+            max_retries: pb_val.max_retries,
+            delay_seconds: pb_val.delay_seconds,
+            policy: match pb_val.policy_type {
+                Some(pb_dtpm::restart_policy::PolicyType::Always(_)) => {
+                    Some(RestartPolicyType::Always(true))
+                }
+                Some(pb_dtpm::restart_policy::PolicyType::OnNonZeroExit(_)) => {
+                    Some(RestartPolicyType::OnNonZeroExit(true))
+                }
+                None => None,
+            },
+        }
+    }
+}
+
+impl From<RestartPolicy> for pb_dtpm::RestartPolicy {
+    fn from(val: RestartPolicy) -> pb_dtpm::RestartPolicy {
+        pb_dtpm::RestartPolicy {
+            max_retries: val.max_retries,
+            delay_seconds: val.delay_seconds,
+            policy_type: match val.policy {
+                Some(RestartPolicyType::Always(_)) => {
+                    Some(pb_dtpm::restart_policy::PolicyType::Always(true))
+                }
+                Some(RestartPolicyType::OnNonZeroExit(_)) => {
+                    Some(pb_dtpm::restart_policy::PolicyType::OnNonZeroExit(true))
+                }
+                None => None,
+            },
+        }
+    }
+}

src/types/shared.rs

@@ -137,7 +137,7 @@ impl From<ChildProcess> for pb_shared::ChildProcess {
     }
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, Default)]
 pub struct RestartPolicy {
     pub max_retries: u32,
     pub delay_seconds: u32,