Rustとtokioランタイムを使ったスケーラブルなWebアプリ設計の実践

[dependencies]
tokio = { version = "1", features = ["full"] }

#[tokio::main]
async fn main() {
    println!("Hello, Tokio!");
}

#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
async fn main() {
    println!("Hello, Tokio with custom threads!");
}

use tokio;

async fn fetch_data(id: u32) -> String {
    format!("Fetched data for id: {}", id)
}

#[tokio::main]
async fn main() {
    let task1 = tokio::spawn(fetch_data(1));
    let task2 = tokio::spawn(fetch_data(2));

    let result1 = task1.await.unwrap();
    let result2 = task2.await.unwrap();

    println!("{}", result1);
    println!("{}", result2);
}

use tokio;

async fn fetch_data(id: u32) -> Result<String, String> {
    if id == 0 {
        Err("Invalid ID".to_string())
    } else {
        Ok(format!("Fetched data for id: {}", id))
    }
}

#[tokio::main]
async fn main() {
    let task = tokio::spawn(fetch_data(0));

    match task.await.unwrap() {
        Ok(result) => println!("{}", result),
        Err(e) => println!("Error: {}", e),
    }
}

[dependencies]
tokio = { version = "1", features = ["full"] }
warp = "0.3"

use warp::Filter;

#[tokio::main]
async fn main() {
    // "Hello, World!"を返すAPIエンドポイントを作成
    let hello = warp::path!("hello" / String)
        .map(|name: String| format!("Hello, {}!", name));

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

use warp::Filter;

#[tokio::main]
async fn main() {
    // "Hello"を返すエンドポイント
    let hello = warp::path!("hello" / String)
        .map(|name: String| format!("Hello, {}!", name));

    // 健康チェック用エンドポイント
    let health_check = warp::path!("health")
        .map(|| warp::reply::with_status("OK", warp::http::StatusCode::OK));

    // すべてのエンドポイントを結合
    let routes = hello.or(health_check);

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

use warp::Filter;

async fn fetch_data_from_db() -> String {
    // 実際にはデータベースからデータを非同期で取得する
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    "Database result".to_string()
}

#[tokio::main]
async fn main() {
    // データベースからデータを取得するエンドポイント
    let db_endpoint = warp::path!("data")
        .map(|| {
            // 非同期タスクを実行してデータを取得
            let data = tokio::spawn(fetch_data_from_db());
            format!("Data: {}", data.await.unwrap())
        });

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

use tokio::time::{sleep, Duration};

async fn fetch_data(id: u32) -> Result<String, String> {
    if id == 0 {
        return Err("Invalid ID".to_string());
    }

    sleep(Duration::from_secs(1)).await;
    Ok(format!("Data for ID: {}", id))
}

#[tokio::main]
async fn main() {
    match fetch_data(0).await {
        Ok(data) => println!("{}", data),
        Err(e) => eprintln!("Error occurred: {}", e),
    }
}

use tokio::task;

async fn fetch_data(id: u32) -> Result<String, String> {
    if id == 0 {
        return Err("Invalid ID".to_string());
    }
    Ok(format!("Data for ID: {}", id))
}

#[tokio::main]
async fn main() {
    let task1 = task::spawn(fetch_data(1));
    let task2 = task::spawn(fetch_data(0));

    let result1 = task1.await.unwrap();
    let result2 = task2.await.unwrap();

    match result1 {
        Ok(data) => println!("{}", data),
        Err(e) => eprintln!("Error in task1: {}", e),
    }

    match result2 {
        Ok(data) => println!("{}", data),
        Err(e) => eprintln!("Error in task2: {}", e),
    }
}

use tokio::time::{sleep, Duration};
use std::fmt;

#[derive(Debug)]
enum MyError {
    InvalidId,
    Timeout,
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

async fn fetch_data(id: u32) -> Result<String, MyError> {
    if id == 0 {
        return Err(MyError::InvalidId);
    }

    sleep(Duration::from_secs(1)).await;
    Ok(format!("Data for ID: {}", id))
}

#[tokio::main]
async fn main() {
    match fetch_data(0).await {
        Ok(data) => println!("{}", data),
        Err(e) => eprintln!("Error occurred: {}", e),
    }
}

[dependencies]
tracing = "0.1"
tracing-subscriber = "0.2"

use tracing::{info, error};
use tracing_subscriber;

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    info!("Starting the application");

    if let Err(e) = fetch_data(0).await {
        error!("Error occurred: {}", e);
    }
}

use tokio::task;

async fn perform_blocking_operation() {
    task::block_in_place(|| {
        // ここでブロッキングI/O操作（例:ファイルの読み書き）を行う
        std::thread::sleep(std::time::Duration::from_secs(2));
    });
}

use tokio::task;

async fn heavy_computation() -> i32 {
    task::spawn_blocking(|| {
        // 重い計算をここで行う
        42
    })
    .await
    .unwrap()
}

use tokio::sync::Semaphore;
use tokio::task;

async fn process_task(semaphore: &Semaphore) {
    let _permit = semaphore.acquire().await.unwrap();
    // タスクの処理を行う
    println!("Processing task");
}

#[tokio::main]
async fn main() {
    let semaphore = Semaphore::new(3);  // 同時実行数を3に制限

    let tasks = (0..10).map(|_| {
        let semaphore = semaphore.clone();
        tokio::spawn(async move {
            process_task(&semaphore).await;
        })
    });

    futures::future::join_all(tasks).await;
}

use tokio::sync::RwLock;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let cache = Arc::new(RwLock::new(HashMap::new()));

    // データをキャッシュに追加
    {
        let mut cache = cache.write().await;
        cache.insert("key", "value");
    }

    // キャッシュからデータを取得
    {
        let cache = cache.read().await;
        println!("{:?}", cache.get("key"));
    }
}

use tokio::runtime::Builder;

fn main() {
    let rt = Builder::new_multi_thread()
        .worker_threads(4) // スレッド数を指定
        .enable_all()
        .build()
        .unwrap();

    rt.block_on(async {
        // 非同期処理を実行
    });
}

[dependencies]
tokio = { version = "1", features = ["full"] }
warp = "0.3"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

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

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

async fn handle_request() -> Result<impl warp::Reply, warp::Rejection> {
    let response = Response {
        message: String::from("Hello, tokio!"),
    };

    Ok(warp::reply::json(&response))
}

#[tokio::main]
async fn main() {
    // エンドポイント `/hello` にアクセスした場合、handle_request() を実行
    let hello_route = warp::path("hello")
        .and(warp::get())
        .and_then(handle_request);

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

use warp::Filter;
use serde::{Serialize, Deserialize};
use tokio::task;
use std::time::Duration;

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

async fn long_running_task() -> String {
    // 擬似的な長時間処理（例: データベースアクセス）
    tokio::time::sleep(Duration::from_secs(5)).await;
    String::from("Task completed!")
}

async fn handle_request() -> Result<impl warp::Reply, warp::Rejection> {
    // 非同期タスクをバックグラウンドで実行
    let task_result = task::spawn(long_running_task()).await.unwrap();

    let response = Response {
        message: task_result,
    };

    Ok(warp::reply::json(&response))
}

#[tokio::main]
async fn main() {
    let hello_route = warp::path("hello")
        .and(warp::get())
        .and_then(handle_request);

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

[dependencies]
tokio = { version = "1", features = ["full"] }
warp = "0.3"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
sqlx = { version = "0.5", features = ["mysql", "runtime-tokio-rustls"] }

use warp::Filter;
use serde::{Serialize, Deserialize};
use sqlx::mysql::MySqlPoolOptions;
use sqlx::Error;

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

async fn get_message_from_db(pool: &sqlx::MySqlPool) -> Result<String, Error> {
    let row: (String,) = sqlx::query_as("SELECT message FROM greetings LIMIT 1")
        .fetch_one(pool)
        .await?;

    Ok(row.0)
}

async fn handle_request(pool: sqlx::MySqlPool) -> Result<impl warp::Reply, warp::Rejection> {
    let message = get_message_from_db(&pool).await.unwrap_or_else(|_| String::from("Failed to fetch message"));

    let response = Response { message };

    Ok(warp::reply::json(&response))
}

#[tokio::main]
async fn main() {
    // データベース接続プールを作成
    let pool = MySqlPoolOptions::new()
        .max_connections(5)
        .connect("mysql://user:password@localhost/db_name")
        .await
        .expect("Failed to create pool.");

    let hello_route = warp::path("hello")
        .and(warp::get())
        .and_then(move || handle_request(pool.clone()));

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

use warp::Filter;
use tokio::fs;
use tokio::io::AsyncReadExt;
use warp::hyper::server::conn::AddrStream;
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    // HTTPS用の証明書と秘密鍵を読み込む
    let cert = fs::read("cert.pem").await.unwrap();
    let key = fs::read("key.pem").await.unwrap();

    // サーバーをセットアップ
    let addr: SocketAddr = "127.0.0.1:3030".parse().unwrap();
    let hello_route = warp::path("hello")
        .map(|| warp::reply::html("Hello, secure world!"));

    warp::serve(hello_route)
        .tls()
        .cert(cert)
        .key(key)
        .run(addr)
        .await;
}

use warp::Filter;
use serde::Deserialize;
use warp::Rejection;

#[derive(Deserialize)]
struct QueryParams {
    name: String,
}

async fn handle_request(params: QueryParams) -> Result<impl warp::Reply, Rejection> {
    // 入力の検証
    if params.name.contains("<") || params.name.contains(">") {
        return Err(warp::reject::custom("Invalid input"));
    }

    Ok(format!("Hello, {}!", params.name))
}

#[tokio::main]
async fn main() {
    let hello_route = warp::path("hello")
        .and(warp::get())
        .and(warp::query::<QueryParams>())
        .and_then(handle_request);

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

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

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

fn generate_token() -> String {
    let claims = Claims {
        sub: "user123".to_string(),
        exp: 10000000000,
    };

    encode(&Header::default(), &claims, &EncodingKey::from_secret("secret".as_ref())).unwrap()
}

async fn handle_request(token: Option<String>) -> Result<impl warp::Reply, Rejection> {
    match token {
        Some(token) => {
            let decoded = decode::<Claims>(&token, &DecodingKey::from_secret("secret".as_ref()), &Validation::default());
            match decoded {
                Ok(_) => Ok(warp::reply::html("Access granted")),
                Err(_) => Err(warp::reject::custom("Invalid token")),
            }
        }
        None => Err(warp::reject::custom("No token provided")),
    }
}

#[tokio::main]
async fn main() {
    let hello_route = warp::path("hello")
        .and(warp::get())
        .and(warp::header::optional("Authorization"))
        .and_then(handle_request);

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

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

async fn handle_rejection(err: Rejection) -> Result<impl Reply, warp::Rejection> {
    if let Some(e) = err.find::<warp::filters::body::BodyDeserializeError>() {
        return Ok(warp::reply::with_status(
            format!("Invalid body: {}", e),
            warp::http::StatusCode::BAD_REQUEST,
        ));
    }

    // その他のエラー処理
    Ok(warp::reply::with_status(
        "Internal server error",
        warp::http::StatusCode::INTERNAL_SERVER_ERROR,
    ))
}

#[tokio::main]
async fn main() {
    let hello_route = warp::path("hello")
        .and(warp::get())
        .map(|| "Hello, world!");

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

use warp::Filter;
use warp::multipart::{FormData, Part};
use std::fs::File;
use std::io::Write;
use tokio::fs::OpenOptions;

async fn upload_file(mut data: FormData) -> Result<impl warp::Reply, warp::Rejection> {
    while let Some(part) = data.next().await {
        let part = part.unwrap();
        if part.name() == "file" {
            let filename = part.filename().unwrap_or("uploaded_file");
            let filepath = format!("./uploads/{}", filename);
            let mut file = OpenOptions::new().create(true).write(true).open(filepath).await.unwrap();
            let mut content = part.stream();
            while let Some(chunk) = content.next().await {
                file.write_all(&chunk.unwrap()).await.unwrap();
            }
            return Ok(warp::reply::html("File uploaded successfully"));
        }
    }
    Err(warp::reject::custom("No file found"))
}

#[tokio::main]
async fn main() {
    let upload_route = warp::path("upload")
        .and(warp::post())
        .and(warp::multipart::form())
        .and_then(upload_file);

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

use tokio_postgres::{NoTls, Error};
use warp::Filter;

async fn get_user_data() -> Result<impl warp::Reply, warp::Rejection> {
    let (client, connection) = tokio_postgres::connect("host=localhost user=postgres dbname=mydb", NoTls)
        .await
        .map_err(|_| warp::reject::custom("Database connection error"))?;

    // 接続をバックグラウンドで処理する
    tokio::spawn(connection);

    // ユーザー情報を取得
    let row = client.query_one("SELECT name FROM users WHERE id = $1", &[&1])
        .await
        .map_err(|_| warp::reject::custom("Query error"))?;

    let name: String = row.get(0);
    Ok(warp::reply::html(format!("User name: {}", name)))
}

#[tokio::main]
async fn main() {
    let user_route = warp::path("user")
        .and(warp::get())
        .and_then(get_user_data);

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

#[cfg(test)]
mod tests {
    use super::*;
    use warp::test::request;

    #[tokio::test]
    async fn test_file_upload() {
        let data = warp::multipart::FormData::new();
        let response = request()
            .method("POST")
            .path("/upload")
            .body(data)
            .reply(&upload_file)
            .await;

        assert_eq!(response.status(), 200);
        assert_eq!(response.body(), "File uploaded successfully");
    }
}

#[tokio::test]
async fn test_get_user_data() {
    let user_route = warp::path("user")
        .and(warp::get())
        .and_then(get_user_data);

    let response = request()
        .method("GET")
        .path("/user")
        .reply(&user_route)
        .await;

    assert_eq!(response.status(), 200);
    assert!(response.body().contains("User name"));
}

#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
async fn main() {
    // 非同期タスクの実行
}

tokio::task::spawn_blocking(move || {
    // 高優先度タスク
});

use tokio::sync::Mutex;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let data = Arc::new(Mutex::new(0));

    let data_clone = Arc::clone(&data);
    let task = tokio::spawn(async move {
        let mut data = data_clone.lock().await;
        *data += 1;
    });

    task.await.unwrap();
}

use tokio::sync::Mutex;
use std::sync::Arc;
use std::collections::HashMap;

struct Cache {
    data: Mutex<HashMap<String, String>>,
}

impl Cache {
    fn new() -> Self {
        Cache {
            data: Mutex::new(HashMap::new()),
        }
    }

    async fn get(&self, key: &str) -> Option<String> {
        let data = self.data.lock().await;
        data.get(key).cloned()
    }

    async fn set(&self, key: String, value: String) {
        let mut data = self.data.lock().await;
        data.insert(key, value);
    }
}

#[tokio::main]
async fn main() {
    let cache = Arc::new(Cache::new());

    // キャッシュにデータを設定
    cache.set("user123".to_string(), "John Doe".to_string()).await;

    // キャッシュからデータを取得
    if let Some(user) = cache.get("user123").await {
        println!("Cache hit: {}", user);
    } else {
        println!("Cache miss");
    }
}

use reqwest::Client;

#[tokio::main]
async fn main() {
    let client = Client::new();

    let response1 = client.get("https://example.com/api1").send().await.unwrap();
    let response2 = client.get("https://example.com/api2").send().await.unwrap();

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

    println!("Response 1: {}", body1);
    println!("Response 2: {}", body2);
}

# Rust公式イメージをベースにする
FROM rust:1.70-slim as builder

# 作業ディレクトリを作成
WORKDIR /usr/src/app

# Cargo.toml と Cargo.lock をコピー
COPY Cargo.toml Cargo.lock ./

# 依存関係をビルドしてキャッシュする
RUN cargo build --release

# ソースコードをコピー
COPY . .

# アプリケーションをビルド
RUN cargo build --release

# 最終的な実行環境
FROM debian:bullseye-slim

# 必要なライブラリをインストール
RUN apt-get update && apt-get install -y \
    libssl-dev \
    && rm -rf /var/lib/apt/lists/*

# ビルド済みのバイナリをコピー
COPY --from=builder /usr/src/app/target/release/myapp /usr/local/bin/myapp

# アプリケーションを実行
CMD ["myapp"]

# Cargo.tomlにtracingの依存関係を追加

use tracing::{info, error};

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    info!("アプリケーションが開始されました");

    if let Err(e) = do_something().await {
        error!("エラーが発生しました: {}", e);
    }
}

async fn do_something() -> Result<(), &'static str> {
    Err("エラー")
}

[dependencies]
tokio = { version = "1", features = ["full"] }
tokio-metrics = "0.1"

use tokio_metrics::Meter;

#[tokio::main]
async fn main() {
    let meter = Meter::new();

    // パフォーマンスの監視開始
    meter.observe("task_completion_time", 50.0);

    // アプリケーションロジック
}

[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["full"] }
tokio-rustls = "0.23"

use warp::Filter;
use tokio_rustls::rustls::ServerConfig;
use tokio_rustls::TlsAcceptor;
use std::sync::Arc;
use std::fs::File;
use std::io::BufReader;

#[tokio::main]
async fn main() {
    let addr = ([127, 0, 0, 1], 3030).into();

    // SSL証明書と秘密鍵の読み込み
    let cert_file = File::open("cert.pem").unwrap();
    let key_file = File::open("key.pem").unwrap();
    let certs = rustls::internal::pemfile::certs(&mut BufReader::new(cert_file)).unwrap();
    let privkey = rustls::internal::pemfile::pkcs8_private_keys(&mut BufReader::new(key_file)).unwrap().remove(0);

    // サーバー設定
    let mut config = ServerConfig::new(rustls::NoClientAuth::new());
    config.set_single_cert(certs, privkey).unwrap();
    let acceptor = TlsAcceptor::from(Arc::new(config));

    // シンプルなHTTPハンドラ
    let routes = warp::any().map(|| "Hello, secure world!");

    // TLSを使用してサーバーを起動
    warp::serve(routes)
        .tls()
        .acceptor(acceptor)
        .run(addr)
        .await;
}

[dependencies]
regex = "1"

use regex::Regex;

fn validate_email(email: &str) -> bool {
    let re = Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
    re.is_match(email)
}

#[tokio::main]
async fn main() {
    let email = "example@example.com";
    if validate_email(email) {
        println!("Valid email!");
    } else {
        println!("Invalid email!");
    }
}

[dependencies]
jsonwebtoken = "7.2"
tokio = { version = "1", features = ["full"] }

use jsonwebtoken::{encode, Header, EncodingKey};
use serde::{Serialize, Deserialize};

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

fn generate_jwt() -> String {
    let my_claims = Claims {
        sub: "user123".to_owned(),
        exp: 10000000000,
    };

    let key = EncodingKey::from_secret("secret".as_ref());
    encode(&Header::default(), &my_claims, &key).unwrap()
}

#[tokio::main]
async fn main() {
    let token = generate_jwt();
    println!("Generated JWT: {}", token);
}

fn check_access(role: &str) {
    match role {
        "admin" => println!("Admin access granted"),
        "user" => println!("User access granted"),
        _ => println!("Access denied"),
    }
}

#[tokio::main]
async fn main() {
    let role = "admin"; // ここでは例として"admin"と設定
    check_access(role);
}