diff --git a/build.rs b/build.rs index badef58..9d2effe 100644 --- a/build.rs +++ b/build.rs @@ -7,6 +7,7 @@ fn main() -> Result<(), Box> { "proto/daemon.proto", "proto/shared.proto", "proto/brain.proto", + "proto/dtpm.proto", ], &["proto"], )?; diff --git a/proto/dtpm.proto b/proto/dtpm.proto new file mode 100644 index 0000000..7299f29 --- /dev/null +++ b/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) {} +} \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index 270b3bb..e3fd798 100644 --- a/src/lib.rs +++ b/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; diff --git a/src/types.rs b/src/types.rs index ef95ce9..5bcd7ab 100644 --- a/src/types.rs +++ b/src/types.rs @@ -1,2 +1,3 @@ pub mod brain; +pub mod dtpm; pub mod shared; diff --git a/src/types/dtpm.rs b/src/types/dtpm.rs new file mode 100644 index 0000000..cac3387 --- /dev/null +++ b/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, + pub environments: Vec, + pub child_processes: Vec, +} + +impl From 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 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 for FileEntry { + fn from(pb_val: pb_dtpm::FileEntry) -> Self { + FileEntry { + path: pb_val.path, + content: FileContent::Data(pb_val.content), + } + } +} +impl From 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 for EnvironmentEntry { + fn from(pb_val: pb_dtpm::EnvironmentEntry) -> Self { + EnvironmentEntry { + name: pb_val.name, + value: pb_val.value, + } + } +} + +impl From 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, + pub restart: Option, +} + +impl From 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 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, +} + +#[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 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 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, + }, + } + } +} diff --git a/src/types/shared.rs b/src/types/shared.rs index fdb69c5..a08b2d6 100644 --- a/src/types/shared.rs +++ b/src/types/shared.rs @@ -137,7 +137,7 @@ impl From 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,