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),
+        }
+    }
+}