【Rust】Bruno我來了，一起來打網路API…

cargo new rust_csv_api

[dependencies]
actix-web = "4.4.0"
actix-multipart = "0.6"
serde = { version = "1.0", features = ["derive"] }
serde_json = { version = "1.0" }
csv = "1.3.1"
futures = "0.3.31"
chrono = { version = "0.4", features = ["serde"] }
colored = "3.0"
local-ip-address = "0.6.5"

cargo check

cargo clean                     # 清理當前編譯產物
cargo clean --target debug		# 清理當前編譯產物 for debug環境
cargo clean --target release	# 清理當前編譯產物 for release環境
cargo clean -p <package>		# 清理該指名套件

cargo tree --duplicate

#[macro_export]
macro_rules! ww_print {
    ($message:expr) => {
        println!("\n[{file} - {line}]\n{message}",
            file = file!().green().bold(),
            line = format!("line.{}", line!().to_string()).yellow().bold(),
            message = $message
        )
    };
}

use colored::Colorize;

mod library;

fn main() {
    ww_print!("Hello, world!");
}

pub const DEFAULT_PORT: u16 = 8080;
pub const LOCALHOST: &str = "127.0.0.1";
pub const CSV_FOLDER_PATH: &str = "document";

use serde::{Serialize};

#[derive(Serialize)]
pub struct Message {
    pub message: String,
    pub timestamp: i64,
    pub date: String,
}

use std::io::{Error};

use colored::Colorize;
use actix_web::{get};
use actix_web::{App, HttpServer, Responder, web};
use chrono::{Utc};
use local_ip_address::{local_ip};

mod library;
mod model;
mod config;

use crate::model::{Message};
use crate::config::*;

#[get("/first")]
async fn get_first_action() -> impl Responder {

    let now = Utc::now();

    let response = Message {
        message: "安安你好嗎？".to_string(),
        timestamp: now.timestamp_millis(),
        date: now.to_rfc3339(),
    };

    web::Json(response)
}

async fn register_service() -> Result<(), Error> {

    let current_ip = local_ip().unwrap_or_else(|_| LOCALHOST.parse().unwrap());

    ww_print!(format!(
        "Starting server at {localhost}:{port}\nStarting server at {ip}:{port}",
        ip = current_ip,
        port = DEFAULT_PORT,
        localhost = LOCALHOST
    ));

    HttpServer::new(|| {
        App::new().service(get_first_action)
    })
    .bind(format!("{}:{}", current_ip, DEFAULT_PORT))?
    .bind(format!("{}:{}", LOCALHOST, DEFAULT_PORT))?
    .run()
    .await
}

#[actix_web::main]
async fn main() -> Result<(), Error> {
    register_service().await
}

cargo run

fn  add_one_v1   (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };

cargo install cargo-watch
cargo watch -c -q -d 2 -x run

pub struct Defer<F: FnMut()> {
    closure: F,
}

impl<F: FnMut()> Defer<F> {
    pub fn new(closure: F) -> Self {
        Self { closure }
    }
}

impl<F: FnMut()> Drop for Defer<F> {
    fn drop(&mut self) {
        (self.closure)();
    }
}

...
use crate::model::{Message, Defer};
...

#[get("/first")]
async fn get_first_action() -> impl Responder {

    let _defer = Defer::new(|| {
        ww_print!("執行Defer closure");
    });

    ww_print!("執行get_first_action");
    ...
}

#[derive(Debug)]
#[allow(dead_code)]
pub enum HttpMethod {
    Get,
    Post,
}

impl HttpMethod {

    pub fn as_str(&self) -> &str {
        match self {
            HttpMethod::Get => "Get",
            HttpMethod::Post => "Post",
        }
    }

    pub fn on_custom_color(&self) -> CustomColor {
        match self {
            HttpMethod::Get => CustomColor::new(24, 226, 18),
            HttpMethod::Post => CustomColor::new(255, 250, 250),
        }
    }
}

/// library/utility.rs
use std::cell::Cell;

use colored::Colorize;
use actix_web::http::StatusCode;
use actix_web::{HttpRequest};
use chrono::{Local};

use crate::model::{HttpMethod};

pub fn log_message(request: &HttpRequest, status_code: &Cell<StatusCode>, method: HttpMethod) -> String {

    let connection_info = request.connection_info().clone();
    let client_ip = connection_info.peer_addr().unwrap_or("unknown");
    let request_url = request.uri().to_string();

    let status = match status_code.get() {
        code if (500..600).contains(&code.as_u16()) => status_code.get().to_string().red(),
        StatusCode::OK => status_code.get().to_string().green(),
        _ => status_code.get().to_string().yellow(),
    };

    let fix_method = format!("{:^5}", method.as_str());

    format!(
        "{ip} - [{date}] {method} {url}, {status}",
        ip = client_ip.bold(),
        date = Local::now().format("%d/%b/%Y %H:%M:%S"),
        url = request_url.yellow(),
        method = fix_method.on_custom_color(method.on_custom_color()),
        status = status,
    )
}

/// library/mod.rs
pub mod macros;
pub mod utility;

mod library;
...

use crate::library::utility::log_message;
...
#[get("/first")]
async fn get_first_action(request: HttpRequest) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let now = Utc::now();

    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Get));
    });

    let response = Message {
        message: "安安你好嗎？".to_string(),
        timestamp: now.timestamp_millis(),
        date: now.to_rfc3339(),
    };

    web::Json(response)
}

use serde::{Deserialize};

#[derive(Deserialize)]
pub struct Params {
    pub id: Option<i32>,
    pub name: Option<String>,
}

...
use crate::model::{Message, Defer, HttpMethod, Params};
...

#[get("/query")]
async fn get_query_action(request: HttpRequest, query: web::Query<Params>) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let now = Utc::now();

    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Get));
    });

    let message = match (&query.name, query.id) {
        (Some(name), Some(id)) => format!("[Hello, {} (ID: {})!", name, id),
        (Some(name), None) => format!("Hello, {}!", name),
        (None, Some(id)) => format!("Hello, User {}!", id),
        (None, None) => String::from("Hello, World!"),
    };

    let response = Message {
        message: message.to_string(),
        timestamp: now.timestamp_millis(),
        date: now.to_rfc3339(),
    };

    web::Json(response)
}

...
async fn register_service() -> Result<(), Error> {
...
    HttpServer::new(|| {
            App::new()
                .service(get_first_action)
                .service(get_query_action)
        })
        .bind(format!("{}:{}", current_ip, DEFAULT_PORT))?
        .bind(format!("{}:{}", LOCALHOST, DEFAULT_PORT))?
        .run()
        .await
}

...
use serde_json::{Value};
...

#[post("/json")]
async fn post_json_action(request: HttpRequest, input: web::Json<Params>) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let now = Utc::now();

    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    let message = match (&input.name, input.id) {
        (Some(name), Some(id)) => format!("Hello, {} (ID: {})!", name, id),
        (Some(name), None) => format!("Hello, {}!", name),
        (None, Some(id)) => format!("Hello, User {}!", id),
        (None, None) => String::from("Hello, World!"),
    };

    let json = format!(
        r#"{{
            "message": "{}",
            "timestamp": {},
            "date": "{}"
        }}"#,
        message,
        now.timestamp_millis(),
        now.to_rfc3339()
    );

    let parsed: Value = serde_json::from_str(&json).unwrap();
    web::Json(parsed).customize().with_status(status_code.get())
}
...

#[post("/user/{id}/{name}")]
async fn post_router_action(request: HttpRequest, path: web::Path<(String, String)>) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    let (id, _name) = path.into_inner();

    let response = serde_json::json!({
        "id": id,
        "message": "更新成功",
        "timestamp": Utc::now().timestamp_millis()
    });

    web::Json(parsed).customize().with_status(status_code.get())
}

let user: (i32, &str, bool) = (42, "hello", true);
let (name, age, is_active) = user;

println!("第一個值: {}", user.0);
println!("第二個值: {}", user.1);
println!("第三個值: {}", user.2);

...
use actix_web::{App, HttpServer, HttpRequest, HttpResponse, Responder, web};
use std::collections::HashMap;
...

#[post("/dynamic")]
async fn dynamic_query(request: HttpRequest, query: web::Query<HashMap<String, String>>) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    for (key, value) in query.iter() {
        println!("{}: {}", key, value);
    }

    HttpResponse::Ok().json(query.into_inner())
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CsvRecord {
    pub name: String,
    pub notes: String,
    pub url: String,
    pub example: String,
    pub level: u8,
}

...
use std::fmt::Debug;
use csv::Reader;
use serde::de::DeserializeOwned;
...

pub fn parse_csv_file<T>(file_path: String) -> Result<Vec<T>, Error> where T: DeserializeOwned + Debug {

    let mut records: Vec<T> = Vec::new();

    let opened_file = match File::open(file_path) {
        Err(error) => return Err(error),
        Ok(file) => file,
    };

    let mut reader = Reader::from_reader(opened_file);

    for result in reader.deserialize() {
        match result {
            Err(error) => return Err(error.into()),
            Ok(record) => {
                ww_print!(format!("解析到記錄: {:?}", record));
                records.push(record)
            }
        }
    }

    Ok(records)
}

#[post("/csv")]
async fn csv_action(request: HttpRequest) -> impl Responder {

    let status_code = Cell::new(StatusCode::NOT_FOUND);
    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    let filename = "Linux.csv";
    let file_path = format!("{}/{}", config::CSV_FOLDER_PATH, filename);

    let records: Vec<CsvRecord> = match parse_csv_file(file_path) {
        Err(error) => {`
            return web::Json(serde_json::json!({ "error": error.to_string() }))
                .customize()
                .with_status(status_code.get());
        }
        Ok(records) => records,
    };

    status_code.set(StatusCode::OK);
    web::Json(serde_json::json!({})).customize().with_status(status_code.get())
}

#[post("/csv")]
async fn csv_action(request: HttpRequest) -> impl Responder {
    ...
    let response = serde_json::json!({ "result": records });
    status_code.set(StatusCode::OK);

    web::Json(serde_json::json!(response)).customize().with_status(status_code.get())
}

use colored::{CustomColor};

pub enum CustomError {
    EmptyString,
    ParseStringError,
    InvalidType(String),
    FileNotFound(String),
    UnknownError,
}

impl std::fmt::Display for CustomError {

    fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            CustomError::InvalidType(_type) => write!(format, "無效的檔案類型: {}", _type),
            CustomError::EmptyString => write!(format, "檔案類型不能為空"),
            CustomError::UnknownError => write!(format, "未知錯誤"),
            CustomError::ParseStringError => write!(format, "字串解析錯誤"),
            CustomError::FileNotFound(path) => write!(format, "檔案未找到: {}", path),
        }
    }
}

#[derive(Debug)]
#[allow(dead_code)]
pub enum HttpMethod {
    Get,
    Post,
}
...


#[derive(Debug)]
#[allow(dead_code)]
pub enum CsvFileType {
    Linux,
    CrossPlatform,
}
...

#[post("/csv/{filename}")]
async fn csv_action(request: HttpRequest, path: web::Path<String>) -> impl Responder {
    ...
    let filename = path.into_inner();
    let error = CustomError::ParseStringError;

    ww_print!(format!("CSV檔名: {}", filename));
    ww_print!(format!("自定義錯誤: {}", error));

...
use std::str::FromStr;
...
use crate::constant::{HttpMethod, CsvFileType};
...

#[post("/csv/{filename}")]
async fn csv_action(request: HttpRequest, path: web::Path<String>) -> impl Responder {
    ...
    let filename = path.into_inner();
    // let file_type: CsvFileType = match filename.parse() {
    let file_type: CsvFileType = match CsvFileType::from_str(filename.as_str()) {
        Ok(_type) => _type,
        Err(error) => {
            ww_print!(format!("錯誤: {}. 預設為: Linux.csv", error));
            CsvFileType::Linux
        }
    };

    ww_print!(format!("轉換的類型: {:?}", file_type));
    ww_print!(format!("CSV檔名: {:?}", file_type.as_str()));
    ...
}

use colored::{Colorize, CustomColor};
use crate::ww_print;

impl std::str::FromStr for CsvFileType {

    type Err = CustomError;

    fn from_str(str: &str) -> Result<Self, Self::Err> {

        ww_print!(format!("輸入的文字為: {}", str));

        match str.to_lowercase().as_str() {
            "linux" => Ok(CsvFileType::Linux),
            "crossplatform" => Ok(CsvFileType::CrossPlatform),
            _ => Err(CustomError::InvalidType(str.to_string())),
        }
    }
}

#[post("/csv/{filename}")]
async fn csv_action(request: HttpRequest, path: web::Path<String>) -> impl Responder {

    let status_code = Cell::new(StatusCode::NOT_FOUND);
    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    let filename = path.into_inner();
    // let file_type: CsvFileType = match filename.parse() {
    let file_type: CsvFileType = match CsvFileType::from_str(filename.as_str()) {
        Ok(_type) => _type,
        Err(error) => {
            ww_print!(format!("錯誤: {}. 預設為: Linux.csv", error));
            CsvFileType::Linux
        }
    };

    let file_path: String = format!("{}/{}", config::CSV_FOLDER_PATH, file_type.as_str());
    let records: Vec<CsvRecord> = match parse_csv_file(file_path) {
        Err(error) => {
            return web::Json(serde_json::json!({ "error": error.to_string() }))
                .customize()
                .with_status(status_code.get());
        }
        Ok(records) => records,
    };

    let response = serde_json::json!({ "result": records });
    status_code.set(StatusCode::OK);

    web::Json(serde_json::json!(response)).customize().with_status(status_code.get())
}

{
  "error": "CSV deserialize error: record 1 (line: 2, byte: 33): missing field `example`"
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CsvRecord {
    pub name: String,
    pub notes: String,
    pub url: String,
    pub level: u8,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub example: Option<String>,

    #[serde(deserialize_with = "deserialize_platform")]
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub platform: Vec<String>,
}

#[serde(skip_serializing_if = "Option::is_none")]
pub example: Option<String>,

#[serde(deserialize_with = "deserialize_platform")]
#[serde(default)]
#[serde(skip_serializing_if = "Vec::is_empty")]
pub platform: Vec<String>,

use serde::de::Deserializer;

fn deserialize_platform<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error> where D: Deserializer<'de> {
    let s: String = String::deserialize(deserializer)?;
    Ok(s.split(',').map(|s| s.trim().to_string()).collect())
}

http://127.0.0.1:8080/csv/CrossPlatform
http://127.0.0.1:8080/csv/linux

use serde::{Serialize, Deserialize};
use serde::de::Deserializer;

#[derive(Serialize)]
pub struct Message {
    pub message: String,
    pub timestamp: i64,
    pub date: String,
}

#[derive(Deserialize)]
pub struct Params {
    pub id: Option<i32>,
    pub name: Option<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CsvRecord {
    pub name: String,
    pub notes: String,
    pub url: String,
    pub level: u8,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub example: Option<String>,

    #[serde(deserialize_with = "deserialize_platform")]
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub platform: Vec<String>,
}

fn deserialize_platform<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error> where D: Deserializer<'de> {
    let str = String::deserialize(deserializer)?;
    Ok(str.split(',').map(|str| str.trim().to_string()).collect())
}

pub struct Defer<F: FnMut()> {
    closure: F,
}

impl<F: FnMut()> Defer<F> {
    pub fn new(closure: F) -> Self {
        Self { closure }
    }
}

impl<F: FnMut()> Drop for Defer<F> {
    fn drop(&mut self) {
        (self.closure)();
    }
}

use std::cell::Cell;
use std::collections::HashMap;
use std::str::FromStr;

use actix_web::http::StatusCode;
use actix_web::{HttpRequest, HttpResponse, Responder, web};
use chrono::{Utc};
use colored::Colorize;
use serde_json::{Value};

use crate::library::utility::{log_message, parse_csv_file};
use crate::model::*;
use crate::config;
use crate::constant::{HttpMethod, CsvFileType};
use crate::ww_print;

pub fn get_first_action(request: HttpRequest) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let now = Utc::now();

    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Get));
    });

    let response = Message {
        message: "安安你好嗎？".to_string(),
        timestamp: now.timestamp_millis(),
        date: now.to_rfc3339(),
    };

    web::Json(response)
}

pub fn get_query_action(request: HttpRequest, query: web::Query<Params>) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let now = Utc::now();

    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Get));
    });

    let message = match (&query.name, query.id) {
        (Some(name), Some(id)) => format!("[Hello, {} (ID: {})!", name, id),
        (Some(name), None) => format!("Hello, {}!", name),
        (None, Some(id)) => format!("Hello, User {}!", id),
        (None, None) => String::from("Hello, World!"),
    };

    let response = Message {
        message: message.to_string(),
        timestamp: now.timestamp_millis(),
        date: now.to_rfc3339(),
    };

    web::Json(response)
}

pub fn post_json_action(request: HttpRequest, input: web::Json<Params>) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let now = Utc::now();

    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    let message = match (&input.name, input.id) {
        (Some(name), Some(id)) => format!("Hello, {} (ID: {})!", name, id),
        (Some(name), None) => format!("Hello, {}!", name),
        (None, Some(id)) => format!("Hello, User {}!", id),
        (None, None) => String::from("Hello, World!"),
    };

    let json = format!(
        r#"{{
            "message": "{}",
            "timestamp": {},
            "date": "{}"
        }}"#,
        message,
        now.timestamp_millis(),
        now.to_rfc3339()
    );

    let parsed: Value = serde_json::from_str(&json).unwrap();
    web::Json(parsed).customize().with_status(status_code.get())
}

pub fn post_router_action(request: HttpRequest, path: web::Path<(String, String)>) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    let (id, _name) = path.into_inner();

    let response = serde_json::json!({
        "id": id,
        "message": "更新成功",
        "timestamp": Utc::now().timestamp_millis()
    });

    web::Json(response).customize().with_status(status_code.get())
}

pub fn dynamic_query(request: HttpRequest, query: web::Query<HashMap<String, String>>) -> impl Responder {

    let status_code = Cell::new(StatusCode::OK);
    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    for (key, value) in query.iter() {
        println!("{}: {}", key, value);
    }

    HttpResponse::Ok().json(query.into_inner())
}

pub fn read_csv_action(request: HttpRequest, path: web::Path<String>) -> impl Responder {

    let status_code = Cell::new(StatusCode::NOT_FOUND);
    let _defer = Defer::new(|| {
        ww_print!(log_message(&request, &status_code, HttpMethod::Post));
    });

    let filename = path.into_inner();
    // let file_type: CsvFileType = match filename.parse() {
    let file_type: CsvFileType = match CsvFileType::from_str(filename.as_str()) {
        Ok(_type) => _type,
        Err(error) => {
            ww_print!(format!("錯誤: {}. 預設為: Linux.csv", error));
            CsvFileType::Linux
        }
    };

    let file_path: String = format!("{}/{}", config::CSV_FOLDER_PATH, file_type.as_str());
    let records: Vec<CsvRecord> = match parse_csv_file(file_path) {
        Err(error) => {
            status_code.set(StatusCode::BAD_REQUEST);
            return web::Json(serde_json::json!({ "error": error.to_string() })).customize().with_status(status_code.get());
        }
        Ok(records) => records,
    };

    let response = serde_json::json!({ "result": records });
    status_code.set(StatusCode::OK);

    web::Json(serde_json::json!(response)).customize().with_status(status_code.get())
}

use std::io::{Error};
use std::collections::HashMap;

use colored::Colorize;
use actix_web::{get, post};
use actix_web::{App, HttpServer, HttpRequest, Responder, web};
use local_ip_address::{local_ip};

mod library;
mod model;
mod config;
mod constant;
mod service;

use crate::model::Params;
use crate::config::*;

use crate::{
    service::csv_service as _service_,
};

#[get("/first")]
async fn get_first_action(request: HttpRequest) -> impl Responder {
    _service_::get_first_action(request)
}

#[get("/query")]
async fn get_query_action(request: HttpRequest, query: web::Query<Params>) -> impl Responder {
    _service_::get_query_action(request, query)
}

#[post("/json")]
async fn post_json_action(request: HttpRequest, input: web::Json<Params>) -> impl Responder {
    _service_::post_json_action(request, input)
}

#[post("/user/{id}/{name}")]
async fn post_router_action(request: HttpRequest, path: web::Path<(String, String)>) -> impl Responder {
    _service_::post_router_action(request, path)
}

#[post("/dynamic")]
async fn dynamic_query(request: HttpRequest, query: web::Query<HashMap<String, String>>) -> impl Responder {
    _service_::dynamic_query(request, query)
}

#[post("/csv/{filename}")]
async fn csv_action(request: HttpRequest, path: web::Path<String>) -> impl Responder {
    _service_::read_csv_action(request, path)
}

async fn register_service() -> Result<(), Error> {

    let current_ip = local_ip().unwrap_or_else(|_| LOCALHOST.parse().unwrap());

    ww_print!(format!(
        "Starting server at {localhost}:{port}\nStarting server at {ip}:{port}",
        ip = current_ip,
        port = DEFAULT_PORT,
        localhost = LOCALHOST
    ));

    HttpServer::new(|| {
        App::new()
            .service(get_first_action)
            .service(get_query_action)
            .service(post_json_action)
            .service(dynamic_query)
            .service(post_router_action)
            .service(csv_action)
    })
    .bind(format!("{}:{}", current_ip, DEFAULT_PORT))?
    .bind(format!("{}:{}", LOCALHOST, DEFAULT_PORT))?
    .run()
    .await
}

#[actix_web::main]
async fn main() -> Result<(), Error> {
    register_service().await
}

cargo build                                             #編譯debug版
cargo run                                               #執行debug版
cargo build --release                                   #編譯release版
cargo run --release                                     #執行release版
cargo build --target aarch64-apple-darwin --release     #編譯aarch64-apple-darwin release版
cargo build --target x86_64-apple-darwin --release      #編譯x86_64-apple-darwin release版