Rust 網路服務架構設計與實作

// 示例：使用 serde 進行 JSON 序列化
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Response {
    data: String,
}

impl Response {
    fn new(data: String) -> Self {
        Response { data }
    }
}

// 示例：簡單的電話號碼驗證邏輯
fn validate_phone_number(phone_number: &str) -> bool {
    // 簡化的驗證邏輯，實際應用中應更為複雜
    phone_number.len() == 10 && phone_number.chars().all(|c| c.is_numeric())
}

// 示例：定義 Agent 和 Job 結構體
struct Agent {
    id: i32,
    name: String,
}

struct Job {
    id: i32,
    command: String,
}

// 示例：使用 sqlx 進行資料函式庫操作
use sqlx::PgPool;

async fn get_agent(pool: &PgPool, id: i32) -> Result<Agent, sqlx::Error> {
    sqlx::query_as!("SELECT id, name FROM agents WHERE id = $1", id)
        .fetch_one(pool)
        .await
}

# 使用官方 Rust 映像檔作為基礎映像檔
FROM rust:latest

# 設定工作目錄
WORKDIR /app

# 複製 Cargo.toml 和 Cargo.lock
COPY Cargo.toml Cargo.lock ./

# 複製原始碼
COPY src ./src

# 編譯 Rust 應用程式
RUN cargo build --release

# 暴露應用程式的連線埠
EXPOSE 8080

# 執行應用程式
CMD ["cargo", "run", "--release"]

use thiserror::Error;

#[derive(Error, Debug, Clone)]
pub enum Error {
    #[error("Internal error")]
    Internal(String),
}

use dotenv::dotenv;

pub struct Config {
    pub port: u16,
    pub database_url: String,
}

impl Config {
    pub fn load() -> Result<Config, Error> {
        dotenv().ok();
        let port = std::env::var("PORT")
            .ok()
            .map_or(Ok(8080), |env_val| env_val.parse::<u16>())?;
        let database_url = std::env::var("DATABASE_URL")
            .map_err(|_| Error::NotFound("DATABASE_URL not found".to_string()))?;
        Ok(Config { port, database_url })
    }
}

use warp::Filter;

pub fn routes(
    app_state: Arc<AppState>,
) -> impl Filter<Extract = impl warp::Reply, Error = Infallible> + Clone {
    let api = warp::path("api");
    let api_with_state = api.and(warp::any().map(move || app_state.clone()));

    // GET /api
    let index = api.and(warp::path::end()).and(warp::get()).and_then(index);

    // GET /api/jobs
    let get_jobs = api_with_state
        .clone()
        .and(warp::path("jobs"))
        .and(warp::path::end())
        .and(warp::get())
        .and_then(get_jobs);

    // POST /api/jobs
    let post_jobs = api_with_state
        .clone()
        .and(warp::path("jobs"))
        .and(warp::path::end())
        .and(warp::post())
        .and(warp::body::json())
        .and_then(create_job);

    api.and(index.or(get_jobs).or(post_jobs))
}

#[derive(Debug)]
pub struct Service {
    repo: Repository,
    db: Pool<Postgres>,
}

impl Service {
    pub fn new(db: Pool<Postgres>) -> Service {
        let repo = Repository {};
        Service { db, repo }
    }
}

impl Service {
    /// 建立新任務
    pub async fn create_job(&self, input: CreateJob) -> Result<Job, Error> {
        let command = input.command.trim();
        let mut command_with_args: Vec<String> = command
            .split_whitespace()
            .into_iter()
            .map(|s| s.to_owned())
            .collect();
        
        if command_with_args.is_empty() {
            return Err(Error::InvalidArgument("Command is not valid".to_string()));
        }
        
        let command = command_with_args.remove(0);
        let now = Utc::now();
        let new_job = Job {
            id: Uuid::new_v4(),
            created_at: now,
            executed_at: None,
            command,
            args: Json(command_with_args),
            output: None,
            agent_id: input.agent_id,
        };
        
        self.repo.create_job(&self.db, &new_job).await?;
        Ok(new_job)
    }

    /// 查詢特定任務
    pub async fn find_job(&self, job_id: Uuid) -> Result<Job, Error> {
        self.repo.find_job_by_id(&self.db, job_id).await
    }
}

impl Service {
    /// 註冊新代理
    pub async fn register_agent(&self) -> Result<AgentRegistered, Error> {
        let id = Uuid::new_v4();
        let created_at = Utc::now();
        let agent = Agent {
            id,
            created_at,
            last_seen_at: created_at,
        };
        
        self.repo.create_agent(&self.db, &agent).await?;
        Ok(AgentRegistered { id })
    }

    /// 列出所有代理
    pub async fn list_agents(&self) -> Result<Vec<entities::Agent>, Error> {
        self.repo.find_all_agents(&self.db).await
    }
}

let routes = index
    .or(get_jobs)
    .or(post_jobs)
    .or(get_job)
    .or(post_job_result)
    .or(post_agents)
    .or(get_agents)
    .or(get_agents_job)
    .with(warp::log("server"))
    .recover(super::handle_error);

pub async fn create_job(
    state: Arc<AppState>,
    input: api::CreateJob,
) -> Result<impl warp::Reply, warp::Rejection> {
    let job = state.service.create_job(input).await?;
    let job: api::Job = job.into();
    let res = api::Response::ok(job);
    let res_json = warp::reply::json(&res);
    Ok(warp::reply::with_status(res_json, StatusCode::OK))
}

pub async fn get_job_result(
    state: Arc<AppState>,
    job_id: Uuid,
) -> Result<impl warp::Reply, warp::Rejection> {
    let sleep_for = Duration::from_secs(1);
    
    for _ in 0..5u64 {
        let job = state.service.find_job(job_id).await?;
        match &job.output {
            Some(_) => {
                let job: api::Job = job.into();
                let res = api::Response::ok(job);
                let res_json = warp::reply::json(&res);
                return Ok(warp::reply::with_status(res_json, StatusCode::OK));
            }
            None => tokio::time::sleep(sleep_for).await,
        }
    }
    
    let res = api::Response::<Option<()>>::ok(None);
    let res_json = warp::reply::json(&res);
    Ok(warp::reply::with_status(res_json, StatusCode::OK))
}