feat: implement Nginx service with upstream management and configuration generation

apps/api/src/services/nginx/info/upstream.rs

@@ -0,0 +1,148 @@
+use chrono::{DateTime, Utc};
+use optfield::optfield;
+
+use database::generated::entities::{upstream, upstream_target};
+use uuid::Uuid;
+
+use crate::{
+    services::nginx::{
+        builder::{INDENT_SIZE, NginxConfigProvider},
+        info::upstream_target as upstream_target_info,
+        traits::indentable::Indentable,
+    },
+    set_if_some,
+};
+
+#[optfield(pub UpdateUpstreamInfo)]
+#[derive(Clone)]
+pub struct UpstreamInfo {
+    pub id: uuid::Uuid,
+    pub name: String,
+    pub protocol: String,
+    pub algorithm: String,
+    pub sticky_session: bool,
+    pub created_by: Option<uuid::Uuid>,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+    //
+    pub upstream_targets: Vec<upstream_target_info::UpstreamTargetInfo>,
+}
+
+pub struct UpstreamCreateInfo {
+    pub name: String,
+    pub protocol: String,
+    pub algorithm: String,
+    pub sticky_session: bool,
+    pub created_by: Option<uuid::Uuid>,
+    //
+    pub upstream_targets: Vec<upstream_target_info::UpstreamTargetCreateInfo>,
+}
+
+impl NginxConfigProvider for UpstreamInfo {
+    fn to_nginx_config(&self, indent: Option<usize>) -> String {
+        let targets_config: Vec<String> = self
+            .upstream_targets
+            .iter()
+            .map(|target| target.to_nginx_config(Some(indent.unwrap_or(0) + INDENT_SIZE)))
+            .collect();
+
+        format!(
+            "upstream {} {{\n{}\n}}",
+            self.name,
+            targets_config.join("\n".indent(indent.unwrap_or(0) + INDENT_SIZE).as_str())
+        )
+        .indent(indent.unwrap_or(0))
+    }
+}
+
+impl From<UpstreamCreateInfo> for upstream::ActiveModel {
+    fn from(val: UpstreamCreateInfo) -> Self {
+        upstream::ActiveModel {
+            id: sea_orm::ActiveValue::Set(Uuid::new_v4()),
+            name: sea_orm::ActiveValue::Set(val.name),
+            protocol: sea_orm::ActiveValue::Set(val.protocol),
+            algorithm: sea_orm::ActiveValue::Set(val.algorithm),
+            sticky_session: sea_orm::ActiveValue::Set(val.sticky_session),
+            created_by: sea_orm::ActiveValue::Set(val.created_by),
+            created_at: sea_orm::ActiveValue::Set(chrono::Utc::now()),
+            updated_at: sea_orm::ActiveValue::Set(chrono::Utc::now()),
+        }
+    }
+}
+
+impl From<upstream::Model> for UpstreamInfo {
+    fn from(model: upstream::Model) -> Self {
+        Self {
+            id: model.id,
+            name: model.name,
+            protocol: model.protocol,
+            algorithm: model.algorithm,
+            sticky_session: model.sticky_session,
+            created_by: model.created_by,
+            created_at: model.created_at,
+            updated_at: model.updated_at,
+            upstream_targets: Vec::new(),
+        }
+    }
+}
+
+impl From<(upstream::Model, Vec<upstream_target::Model>)> for UpstreamInfo {
+    fn from(data: (upstream::Model, Vec<upstream_target::Model>)) -> Self {
+        let (upstream_model, upstream_target_models) = data;
+
+        Self {
+            id: upstream_model.id,
+            name: upstream_model.name,
+            protocol: upstream_model.protocol,
+            algorithm: upstream_model.algorithm,
+            sticky_session: upstream_model.sticky_session,
+            created_by: upstream_model.created_by,
+            created_at: upstream_model.created_at,
+            updated_at: upstream_model.updated_at,
+            upstream_targets: upstream_target_models
+                .into_iter()
+                .map(upstream_target_info::UpstreamTargetInfo::from)
+                .collect(),
+        }
+    }
+}
+
+impl From<UpstreamInfo> for (upstream::ActiveModel, Vec<upstream_target::ActiveModel>) {
+    fn from(val: UpstreamInfo) -> Self {
+        (
+            upstream::ActiveModel {
+                id: sea_orm::ActiveValue::Set(val.id),
+                name: sea_orm::ActiveValue::Set(val.name),
+                protocol: sea_orm::ActiveValue::Set(val.protocol),
+                algorithm: sea_orm::ActiveValue::Set(val.algorithm),
+                sticky_session: sea_orm::ActiveValue::Set(val.sticky_session),
+                created_by: sea_orm::ActiveValue::Set(val.created_by),
+                created_at: sea_orm::ActiveValue::Set(val.created_at),
+                updated_at: sea_orm::ActiveValue::Set(val.updated_at),
+            },
+            val.upstream_targets
+                .into_iter()
+                .map(|target| target.into())
+                .collect(),
+        )
+    }
+}
+
+impl UpdateUpstreamInfo {
+    pub fn apply_to_model(self, current_model: upstream::Model) -> upstream::ActiveModel {
+        upstream::ActiveModel {
+            id: sea_orm::ActiveValue::Unchanged(current_model.id),
+            name: set_if_some!(self.name),
+            protocol: set_if_some!(self.protocol),
+            algorithm: set_if_some!(self.algorithm),
+            sticky_session: set_if_some!(self.sticky_session),
+            created_by: set_if_some!(if self.created_by.is_some() {
+                Some(self.created_by)
+            } else {
+                None
+            }),
+            created_at: set_if_some!(self.created_at),
+            updated_at: set_if_some!(self.updated_at),
+        }
+    }
+}

apps/api/src/services/nginx/info/upstream_target.rs

@@ -0,0 +1,118 @@
+use chrono::{DateTime, Utc};
+use optfield::optfield;
+
+use sea_orm::ActiveValue::{Set, Unchanged};
+use uuid::Uuid;
+
+use database::generated::entities::upstream_target;
+
+use crate::{
+    services::nginx::{builder::NginxConfigProvider, traits::indentable::Indentable},
+    set_if_some,
+};
+
+#[optfield(pub UpdateUpstreamTargetInfo)]
+#[derive(Clone)]
+pub struct UpstreamTargetInfo {
+    pub id: uuid::Uuid,
+    pub target_host: String,
+    pub target_port: i64,
+    pub weight: i64,
+    pub is_backup: bool,
+    pub enabled: bool,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+    //
+    pub upstream_id: uuid::Uuid,
+}
+
+pub struct UpstreamTargetCreateInfo {
+    pub target_host: String,
+    pub target_port: i64,
+    pub weight: i64,
+    pub is_backup: bool,
+    pub enabled: bool,
+    //
+    pub upstream_id: uuid::Uuid,
+}
+
+impl From<upstream_target::Model> for UpstreamTargetInfo {
+    fn from(model: upstream_target::Model) -> Self {
+        Self {
+            id: model.id,
+            target_host: model.target_host,
+            target_port: model.target_port,
+            weight: model.weight,
+            is_backup: model.is_backup,
+            enabled: model.enabled,
+            created_at: model.created_at,
+            updated_at: model.updated_at,
+            upstream_id: model.upstream_id,
+        }
+    }
+}
+
+impl From<UpstreamTargetInfo> for upstream_target::ActiveModel {
+    fn from(val: UpstreamTargetInfo) -> Self {
+        upstream_target::ActiveModel {
+            id: Set(val.id),
+            target_host: Set(val.target_host),
+            target_port: Set(val.target_port),
+            weight: Set(val.weight),
+            is_backup: Set(val.is_backup),
+            enabled: Set(val.enabled),
+            created_at: Set(val.created_at),
+            updated_at: Set(val.updated_at),
+            upstream_id: Set(val.upstream_id),
+        }
+    }
+}
+
+impl From<UpstreamTargetCreateInfo> for upstream_target::ActiveModel {
+    fn from(val: UpstreamTargetCreateInfo) -> Self {
+        upstream_target::ActiveModel {
+            id: Set(Uuid::new_v4()),
+            target_host: Set(val.target_host),
+            target_port: Set(val.target_port),
+            weight: Set(val.weight),
+            is_backup: Set(val.is_backup),
+            enabled: Set(val.enabled),
+            created_at: Set(chrono::Utc::now()),
+            updated_at: Set(chrono::Utc::now()),
+            upstream_id: Set(val.upstream_id),
+        }
+    }
+}
+
+impl NginxConfigProvider for UpstreamTargetInfo {
+    fn to_nginx_config(&self, indent: Option<usize>) -> String {
+        format!(
+            "{}:{} weight={}{}{}",
+            self.target_host,
+            self.target_port,
+            self.weight,
+            if self.is_backup { " backup" } else { "" },
+            if !self.enabled { " down" } else { "" },
+        )
+        .indent(indent.unwrap_or(0))
+    }
+}
+
+impl UpdateUpstreamTargetInfo {
+    pub fn apply_to_model(
+        self,
+        current_model: upstream_target::Model,
+    ) -> upstream_target::ActiveModel {
+        upstream_target::ActiveModel {
+            id: Unchanged(current_model.id),
+            target_host: set_if_some!(self.target_host),
+            target_port: set_if_some!(self.target_port),
+            weight: set_if_some!(self.weight),
+            is_backup: set_if_some!(self.is_backup),
+            enabled: set_if_some!(self.enabled),
+            created_at: set_if_some!(self.created_at),
+            updated_at: set_if_some!(self.updated_at),
+            upstream_id: set_if_some!(self.upstream_id),
+        }
+    }
+}