RustのWarpフレームワークで柔軟なルーティングを実現する方法

async fn fetch_data() -> String {
    // 非同期処理（例：APIからデータを取得）
    "データ取得完了".to_string()
}

async fn handle_request() {
    let data = fetch_data().await;
    println!("{}", data);
}

use warp::Filter;

#[tokio::main]
async fn main() {
    let hello = warp::path("hello")
        .map(|| warp::reply::html("Hello, World!"));

    warp::serve(hello)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // /hello というパスにアクセスされた場合のルート
    let hello = warp::path("hello")
        .map(|| warp::reply::html("Hello, World!"));

    // サーバーを起動
    warp::serve(hello)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // GETリクエストに対する処理
    let get_route = warp::path("get_route")
        .and(warp::get())
        .map(|| warp::reply::html("GET request"));

    // POSTリクエストに対する処理
    let post_route = warp::path("post_route")
        .and(warp::post())
        .map(|| warp::reply::html("POST request"));

    // 両方のルートを結合
    let routes = get_route.or(post_route);

    // サーバーを起動
    warp::serve(routes)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // /user/{id}というパスからidパラメータを取得
    let user_route = warp::path!("user" / u32) // パスパラメータとしてu32型のidを受け取る
        .map(|id| warp::reply::html(format!("User ID: {}", id)));

    // サーバーを起動
    warp::serve(user_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // /helloルート
    let hello = warp::path("hello")
        .map(|| warp::reply::html("Hello, World!"));

    // /goodbyeルート
    let goodbye = warp::path("goodbye")
        .map(|| warp::reply::html("Goodbye, World!"));

    // 両方のルートを結合
    let routes = hello.or(goodbye);

    // サーバーを起動
    warp::serve(routes)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // /user/{id} というパスからidを取得
    let user_route = warp::path!("user" / u32) // u32型のidを取得
        .map(|id| warp::reply::html(format!("User ID: {}", id)));

    // サーバーを起動
    warp::serve(user_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // クエリパラメータ "query" と "limit" を処理
    let search_route = warp::path("search")
        .and(warp::get())
        .and(warp::query::<std::collections::HashMap<String, String>>()) // クエリパラメータを取得
        .map(|params: std::collections::HashMap<String, String>| {
            let query = params.get("query").unwrap_or(&"".to_string());
            let limit = params.get("limit").unwrap_or(&"10".to_string());
            warp::reply::html(format!("Search for: {}, Limit: {}", query, limit))
        });

    // サーバーを起動
    warp::serve(search_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // /user/{id} とクエリパラメータを組み合わせたルート
    let user_route = warp::path!("user" / u32)
        .and(warp::query::<std::collections::HashMap<String, String>>()) // クエリパラメータを取得
        .map(|id, params: std::collections::HashMap<String, String>| {
            let sort = params.get("sort").unwrap_or(&"asc".to_string());
            let limit = params.get("limit").unwrap_or(&"10".to_string());
            warp::reply::html(format!(
                "User ID: {}, Sort: {}, Limit: {}",
                id, sort, limit
            ))
        });

    // サーバーを起動
    warp::serve(user_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct User {
    name: String,
    age: u32,
}

#[tokio::main]
async fn main() {
    // JSONデータを受け取るルート
    let create_user = warp::path("user")
        .and(warp::post()) // POSTメソッドのみ受け付け
        .and(warp::body::json()) // JSONボディを受け取る
        .map(|user: User| {
            warp::reply::json(&user) // 受け取ったユーザー情報をそのまま返す
        });

    // サーバーを起動
    warp::serve(create_user)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // Authorizationヘッダーを取得するルート
    let check_authorization = warp::path("secure")
        .and(warp::header::<String>("Authorization")) // Authorizationヘッダーを取得
        .map(|auth_token: String| {
            if auth_token == "Bearer my-secret-token" {
                warp::reply::html("Authorized!")
            } else {
                warp::reply::html("Unauthorized!")
            }
        });

    // サーバーを起動
    warp::serve(check_authorization)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // レスポンスをカスタマイズするルート
    let custom_response = warp::path("custom")
        .map(|| {
            warp::reply()
                .with_header("X-Custom-Header", "HelloWarp") // カスタムヘッダーを追加
                .with_status(200) // HTTPステータスコードを指定
                .with_body("This is a custom response!") // ボディを指定
        });

    // サーバーを起動
    warp::serve(custom_response)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::{Filter, Rejection, Reply};

#[tokio::main]
async fn main() {
    // エラーハンドリングのカスタマイズ
    let error_route = warp::path("error")
        .map(|| {
            Err(warp::reject::custom(MyError))
        })
        .recover(handle_rejection);

    // サーバーを起動
    warp::serve(error_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

#[derive(Debug)]
struct MyError;

impl warp::reject::Reject for MyError {}

async fn handle_rejection(err: Rejection) -> Result<impl Reply, warp::Rejection> {
    if let Some(_) = err.find::<MyError>() {
        Ok(warp::reply::with_status("Something went wrong!", warp::http::StatusCode::INTERNAL_SERVER_ERROR))
    } else {
        Err(err)
    }
}

use warp::Filter;
use reqwest::Client;
use std::convert::Infallible;

#[tokio::main]
async fn main() {
    // 非同期APIリクエストを行うルート
    let fetch_data = warp::path("fetch_data")
        .map(|| async {
            let client = Client::new();
            let response = client.get("https://api.example.com/data")
                .send()
                .await
                .map_err(|_| warp::reject())?;

            let body = response.text().await.unwrap();
            warp::reply::html(body)
        });

    // サーバーを起動
    warp::serve(fetch_data)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;
use reqwest::Client;
use tokio::try_join;
use std::convert::Infallible;

#[tokio::main]
async fn main() {
    // 並列でAPIリクエストを行うルート
    let fetch_data_parallel = warp::path("fetch_parallel")
        .map(|| async {
            let client = Client::new();

            // 2つの非同期リクエストを並列で実行
            let request1 = client.get("https://api.example.com/data1").send();
            let request2 = client.get("https://api.example.com/data2").send();

            // 両方の結果を待機
            let (response1, response2) = try_join!(request1, request2).map_err(|_| warp::reject())?;

            let body1 = response1.text().await.unwrap();
            let body2 = response2.text().await.unwrap();

            // 両方の結果を結合してレスポンスとして返す
            warp::reply::html(format!("Data1: {}\nData2: {}", body1, body2))
        });

    // サーバーを起動
    warp::serve(fetch_data_parallel)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;
use reqwest::Client;
use tokio::time::timeout;
use std::time::Duration;

#[tokio::main]
async fn main() {
    // タイムアウトを設けて非同期APIリクエストを行うルート
    let fetch_with_timeout = warp::path("fetch_with_timeout")
        .map(|| async {
            let client = Client::new();

            // 非同期APIリクエストにタイムアウトを設定
            let response = timeout(Duration::from_secs(5), client.get("https://api.example.com/data").send())
                .await;

            match response {
                Ok(Ok(res)) => {
                    let body = res.text().await.unwrap();
                    warp::reply::html(body)
                }
                Ok(Err(_)) => {
                    warp::reply::html("Failed to fetch data from API")
                }
                Err(_) => {
                    warp::reply::html("Request timed out")
                }
            }
        });

    // サーバーを起動
    warp::serve(fetch_with_timeout)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // ミドルウェア：リクエストの前にログを出力
    let log_request = warp::any()
        .map(|| {
            println!("Request received");
        })
        .untuple_one();

    // メインのルート：ログ出力後にレスポンスを返す
    let hello_route = warp::path("hello")
        .map(|| {
            "Hello, World!"
        });

    // ミドルウェアを適用
    let route_with_middleware = log_request
        .and(hello_route);

    // サーバーを起動
    warp::serve(route_with_middleware)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // 認証ミドルウェア：Authorizationヘッダーを検証
    let auth_middleware = warp::header::<String>("Authorization")
        .map(|auth_header: String| {
            if auth_header == "Bearer my-secret-token" {
                warp::reply::html("Authenticated!")
            } else {
                warp::reply::html("Unauthorized!")
            }
        });

    // サーバーを起動
    warp::serve(auth_middleware)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::{Filter, Rejection, Reply};

#[tokio::main]
async fn main() {
    // エラーハンドリングミドルウェア
    let custom_error_route = warp::path("error")
        .map(|| {
            Err(warp::reject::custom(MyError))
        })
        .recover(handle_rejection);

    // サーバーを起動
    warp::serve(custom_error_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

#[derive(Debug)]
struct MyError;

impl warp::reject::Reject for MyError {}

async fn handle_rejection(err: Rejection) -> Result<impl Reply, warp::Rejection> {
    if let Some(_) = err.find::<MyError>() {
        Ok(warp::reply::with_status("Custom error occurred!", warp::http::StatusCode::INTERNAL_SERVER_ERROR))
    } else {
        Err(err)
    }
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // CORSミドルウェア：レスポンスヘッダーにCORS設定を追加
    let cors_middleware = warp::any()
        .map(|| {
            warp::reply::html("Hello, World!")
                .with_header("Access-Control-Allow-Origin", "*")
                .with_header("Access-Control-Allow-Methods", "GET, POST")
                .with_header("Access-Control-Allow-Headers", "Content-Type")
        });

    // サーバーを起動
    warp::serve(cors_middleware)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::test]
async fn test_hello_route() {
    // テスト用のハンドラーを作成
    let hello_route = warp::path("hello")
        .map(|| warp::reply::html("Hello, World!"));

    // テストリクエストを送信
    let res = warp::test::request()
        .path("/hello")
        .reply(&hello_route)
        .await;

    // レスポンスのステータスコードとボディを確認
    assert_eq!(res.status(), 200);
    assert_eq!(res.body(), "Hello, World!");
}

use warp::Filter;

#[tokio::test]
async fn test_integration() {
    // テスト用のエンドポイントを作成
    let hello_route = warp::path("hello")
        .map(|| warp::reply::html("Hello, World!"));

    let goodbye_route = warp::path("goodbye")
        .map(|| warp::reply::html("Goodbye, World!"));

    // サーバーを統合的にテスト
    let routes = hello_route.or(goodbye_route);

    // "/hello"のリクエストを送信
    let res = warp::test::request()
        .path("/hello")
        .reply(&routes)
        .await;

    assert_eq!(res.status(), 200);
    assert_eq!(res.body(), "Hello, World!");

    // "/goodbye"のリクエストを送信
    let res = warp::test::request()
        .path("/goodbye")
        .reply(&routes)
        .await;

    assert_eq!(res.status(), 200);
    assert_eq!(res.body(), "Goodbye, World!");
}

use warp::Filter;
use log::{info};

#[tokio::main]
async fn main() {
    // ログの初期化
    env_logger::init();

    // ログを出力するミドルウェアを作成
    let log_middleware = warp::any().map(move || {
        info!("Request received");
        warp::reply::html("Hello, World!")
    });

    // サーバーを起動
    warp::serve(log_middleware)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;
use tokio::task;
use log::{info};

#[tokio::main]
async fn main() {
    // ログの初期化
    env_logger::init();

    // 非同期タスクを生成
    let hello_task = task::spawn(async {
        info!("Hello task started");
        // 何か処理を行う
        info!("Hello task completed");
    });

    // 非同期タスクを待機
    hello_task.await.unwrap();

    // サーバーを起動
    warp::serve(warp::path("hello").map(|| warp::reply::html("Hello, World!")))
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // パスパラメータを使ったルート
    let user_route = warp::path!("user" / u32) // パスに含まれるIDを取得
        .map(|id: u32| {
            format!("User ID: {}", id) // IDを使ってレスポンスを生成
        });

    // サーバーを起動
    warp::serve(user_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // クエリパラメータを使ったルート
    let search_route = warp::path("search")
        .and(warp::query::<std::collections::HashMap<String, String>>()) // クエリパラメータを取得
        .map(|params: std::collections::HashMap<String, String>| {
            if let Some(query) = params.get("query") {
                format!("Search results for: {}", query) // クエリパラメータを使ってレスポンスを生成
            } else {
                "No query provided".to_string()
            }
        });

    // サーバーを起動
    warp::serve(search_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // 2つのルートを組み合わせる
    let hello_route = warp::path("hello")
        .map(|| "Hello, World!");

    let goodbye_route = warp::path("goodbye")
        .map(|| "Goodbye, World!");

    // 2つのルートをORでつなげる
    let routes = hello_route.or(goodbye_route);

    // サーバーを起動
    warp::serve(routes)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::Filter;

#[tokio::main]
async fn main() {
    // 動的パスパラメータとクエリパラメータを組み合わせる
    let user_search_route = warp::path!("user" / u32 / "search")
        .and(warp::query::<std::collections::HashMap<String, String>>())
        .map(|user_id: u32, params: std::collections::HashMap<String, String>| {
            if let Some(query) = params.get("query") {
                format!("User ID: {}, Search query: {}", user_id, query)
            } else {
                format!("User ID: {}, No search query provided", user_id)
            }
        });

    // サーバーを起動
    warp::serve(user_search_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::{Filter, Rejection, Reply};

#[derive(Clone)]
struct Credentials {
    username: String,
    password: String,
}

async fn authenticate(credentials: Credentials) -> Result<impl Reply, Rejection> {
    if credentials.username == "admin" && credentials.password == "password" {
        Ok(warp::reply::html("Authenticated!"))
    } else {
        Err(warp::reject::custom("Unauthorized"))
    }
}

fn with_basic_auth() -> impl Filter<Extract = (Credentials,), Error = Rejection> + Clone {
    warp::header::<String>("authorization")
        .map(|auth_header: String| {
            let decoded = base64::decode(&auth_header[6..]).unwrap();
            let decoded_str = String::from_utf8(decoded).unwrap();
            let mut parts = decoded_str.split(':');
            let username = parts.next().unwrap().to_string();
            let password = parts.next().unwrap().to_string();

            Credentials { username, password }
        })
}

#[tokio::main]
async fn main() {
    let login_route = warp::path("login")
        .and(with_basic_auth())
        .and_then(authenticate);

    warp::serve(login_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::{Filter, Rejection, Reply};
use jsonwebtoken::{encode, Header, EncodingKey};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Claims {
    sub: String,
    exp: usize,
}

fn create_jwt(username: &str) -> String {
    let claims = Claims {
        sub: username.to_string(),
        exp: 10000000000, // トークンの有効期限
    };

    let encoding_key = EncodingKey::from_secret("secret_key".as_bytes());
    encode(&Header::default(), &claims, &encoding_key).unwrap()
}

async fn authenticate(token: String) -> Result<impl Reply, Rejection> {
    let validation = jsonwebtoken::decode::<Claims>(
        &token,
        &jsonwebtoken::DecodingKey::from_secret("secret_key".as_bytes()),
        &jsonwebtoken::Validation::default(),
    );

    match validation {
        Ok(_) => Ok(warp::reply::html("Authenticated via JWT!")),
        Err(_) => Err(warp::reject::custom("Unauthorized")),
    }
}

fn with_jwt_auth() -> impl Filter<Extract = (String,), Error = Rejection> + Clone {
    warp::header::<String>("authorization")
}

#[tokio::main]
async fn main() {
    let login_route = warp::path("login")
        .and(with_jwt_auth())
        .and_then(authenticate);

    let jwt_token = create_jwt("admin");

    println!("JWT Token: {}", jwt_token);

    warp::serve(login_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

use warp::{Filter, Rejection, Reply};

#[derive(Serialize, Deserialize)]
struct Claims {
    sub: String,
    role: String, // ユーザーのロール
}

async fn authorize(claims: Claims) -> Result<impl Reply, Rejection> {
    if claims.role == "admin" {
        Ok(warp::reply::html("Admin Access Granted!"))
    } else {
        Err(warp::reject::custom("Unauthorized"))
    }
}

fn with_role() -> impl Filter<Extract = (Claims,), Error = Rejection> + Clone {
    warp::header::<String>("authorization")
        .map(|auth_header: String| {
            let token = auth_header[7..].to_string(); // Bearer + Token
            let validation = jsonwebtoken::decode::<Claims>(
                &token,
                &jsonwebtoken::DecodingKey::from_secret("secret_key".as_bytes()),
                &jsonwebtoken::Validation::default(),
            );

            match validation {
                Ok(decoded_token) => decoded_token.claims,
                Err(_) => Claims {
                    sub: "unknown".to_string(),
                    role: "guest".to_string(),
                },
            }
        })
}

#[tokio::main]
async fn main() {
    let admin_route = warp::path("admin")
        .and(with_role())
        .and_then(authorize);

    warp::serve(admin_route)
        .run(([127, 0, 0, 1], 3030))
        .await;
}