Month: December 2024

クラスの外部から静的メンバ変数を定義するには「クラス名+”::”+静的メンバ変数名」という名前のグローバル変数を定義する。

static data: &str = "this is static variable";

fn func1(){
    println!("func1: {:?}", data);
}

fn func2(){
    println!("func2: {:?}", data);
}

fn main(){
    
    func1();
    func2();
    println!("main: {:?}", data);
}

$ ./main
func1: “this is static variable”
func2: “this is static variable”
main: “this is static variable”
staticな変数を宣言することはできるが、mutableにできない。

### once_cell
once_cellを使用すると、mutableなstaticを作成できる。

use once_cell::sync::Lazy;
use std::sync::Mutex;

static ARRAY: Lazy<Mutex<Vec<u8>>> = Lazy::new(|| Mutex::new(vec![]));

fn do_a_call(){
    ARRAY.lock().unwrap().push(1);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", ARRAY.lock().unwrap().len());
}

vectorの型をu8ではなく構造体にして、一定数以上になったら関数を実行するように編集する

use once_cell::sync::Lazy;
use std::sync::Mutex;

struct Transaction {
    x: String,
    y: String,
    z: u32,
}

static Pool: Lazy<Mutex<Vec<Transaction>>> = Lazy::new(|| Mutex::new(vec![]));

fn make_block (){
    println!("blockを作成しました。");
    Pool.lock().unwrap().clear();

}

fn do_a_call(){
    let t = Transaction { x: "A".to_string(), y: "B".to_string(), z: 10};
    if Pool.lock().unwrap().len() > 4 {
        make_block();
    }
    Pool.lock().unwrap().push(t);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();
    do_a_call();
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", Pool.lock().unwrap().len());
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.25s
Running `target/debug/my_web_app`
blockを作成しました。
called 2

なるほど、やりたいことはできました。これをPostされたトランザクションに対して、トランザクションプールに入れるように実装します。

static Pool: Lazy<Mutex<Vec<SignedTransaction>>> = Lazy::new(|| Mutex::new(vec![]));

fn make_block (){
    println!("blockを作成しました。");
    Pool.lock().unwrap().clear();
}

#[post("/handshake")]
async fn handshake(req_body: String)-> impl Responder {
    let req : SignedTransaction = serde_json::from_str(&req_body).unwrap();
    Pool.lock().unwrap().push(req.clone());
    if Pool.lock().unwrap().len() > 1 {
        make_block();
    }
    println!("{}", req.signature);
    HttpResponse::Ok().body(req_body)

}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 4.94s
Running `target/debug/hoge`
8000E340A55A517D0F27F3A63FBE39ED576BA491DFAC89B44654AB147EC66B206B054BAAF53E318EB2721DC892B4736630F400547989AE9F7C069034ECB4DF98
blockを作成しました。
8000E340A55A517D

おおおおおおお、イイネ!

Post requestを受け取るにはactix-webを使う。
まず、受信のテストから。

use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder};

#[post("/handshake")]
async fn handshake(req_body: String)-> impl Responder {
    println!("{}", req_body);
    HttpResponse::Ok().body(req_body)

}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(||{
        App::new()
            .service(handshake)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

postする
$ curl -X POST -d “{\”time\”:\”2024-12-25 22:53:36.824066840 UTC\”,\”sender\”:\”4bac6cb0f4ad6397752c3d73b88c5c86e3d88ac695118494a1732e2abd16c76acad3d6586c37c8db7e69c2f812f99275198936957d72c38d71981991123\”,\”receiver\”:\”4bac6cb0f4ad6397752c3d73b88c5c86e3d88ac695118494a1732e2abd16c76acad3d6586c37c8db7e69c2f812f99275198936957d72c38d71981991124\”,\”amount\”:10,\”signature\”:\”8000E340A55A517D0F27F3A63FBE39ED576BA491DFAC89B44654AB147EC66B206B054BAAF53E318EB2721DC892B4736630F400547989AE9F7C069034ECB4DF98\”}”

サーバ側
Finished `dev` profile [unoptimized + debuginfo] target(s) in 3.70s
Running `target/debug/hoge`
{“time”:”2024-12-25 22:53:36.824066840 UTC”,”sender”:”4bac6cb0f4ad6397752c3d73b88c5c86e3d88ac695118494a1732e2abd16c76acad3d6586c37c8db7e69c2f812f99275198936957d72c38d71981991123″,”receiver”:”4bac6cb0f4ad6397752c3d73b88c5c86e3d88ac695118494a1732e2abd16c76acad3d6586c37c8db7e69c2f812f99275198936957d72c38d71981991124″,”amount”:10,”signature”:”8000E340A55A517D0F27F3A63FBE39ED576BA491DFAC89B44654AB147EC66B206B054BAAF53E318EB2721DC892B4736630F400547989AE9F7C069034ECB4DF98″}

受信できてます。
ここで受け取ったデータからverifyすればOKですね。

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
struct SignedTransaction {
    time: String,
    sender: String,
    receiver: String,
    amount: i32,
    signature: String,
}

#[post("/handshake")]
async fn handshake(req_body: String)-> impl Responder {
    let req : SignedTransaction = serde_json::from_str(&req_body).unwrap();;
    println!("{}", req.signature);
    HttpResponse::Ok().body(req_body)

}

Postされたデータはjsonにして、SignedTransactionの構造体で受け取ると、req.signatureというように、値を取り出すことができる。

まずcargo newでプロジェクトを作成し、dependenciesにactixを追加します。

[dependencies]
actix-web = "4"

use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder};

#[get("/")]
async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello world!")
}

#[post("/echo")]
async fn echo(req_body: String) -> impl Responder {
    HttpResponse::Ok().body(req_body)
}

async fn manual_hello() -> impl Responder {
    HttpResponse::Ok().body("Hey there!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(||{
        App::new()
            .service(hello)
            .service(echo)
            .route("/hey", web::get().to(manual_hello))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

$ curl -X POST -d “age=30” 127.0.0.1:8080/echo
age=30

おおおおおおお、get, postまではできたな…

use serde::{Deserialize, Serialize};

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {

    #[derive(Deserialize, Serialize)]
    struct Ip {
        ip: String,
    }

    let uri = "https://httpbin.org/post";
    let data = &Ip {
        ip: "129.0.0.1".into(),
    };
    let mut res = surf::post(uri).body_json(data)?.await?;
    let body = res.body_string().await?;
    println!("{}", body);

    let uri = "https://api.ipify.org?format=json";
    let Ip { ip } = surf::get(uri).recv_json().await?;
    println!("{}", ip);
    assert!(ip.len() > 10);
    Ok(())
}

Postができる。actix-webでpostされたデータを受け取ることができるかは要確認。

まずはGetリクエストから

use async_std::task;

fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    task::block_on(async {
        let mut res = surf::get("https://httpbin.org/get").await?;
        dbg!(res.body_string().await?);
        Ok(())
    })
}

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    let mut res = surf::get("https://httpbin.org/get").await?;
    dbg!(res.body_string().await?);
    Ok(())
}

[src/main.rs:4:5] res.body_string().await? = “{\n \”args\”: {}, \n \”headers\”: {\n \”Accept\”: \”*/*\”, \n \”Accept-Encoding\”: \”deflate, gzip\”, \n \”Host\”: \”httpbin.org\”, \n \”User-Agent\”: \”curl/8.11.0-DEV isahc/0.7.6\”, \n \”X-Amzn-Trace-Id\”: \”Root=1-676a57b7-3de7e4ff65be3baf597f36f8\”\n }, \n \”origin\”: \”106.155.3.182\”, \n \”url\”: \”https://httpbin.org/get\”\n}\n”

### actix-web
$ cargo new my_web_app
$ cd my_web_app

[dependencies]
actix-web = "4"

main.rs

use actix_web::{web, App, HttpResponse, HttpServer, Responder};

async fn greet() -> impl Responder {
    HttpResponse::Ok().body("Hello, world!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(||{
        App::new()
            .route("/", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

$ curl 127.0.0.1:8080
Hello, world!

ほう

### Rocket
$ cargo new rocket_web_app
$ cd rocket_web_app
$ rustup override set nightly

#[macro_use] extern crate rocket;

#[get("/")]
fn index() -> &'static str {
    "Hello, world!"
}

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![index])
}

$ cargo run
Compiling rocket_web_app v0.1.0 (/home/vagrant/dev/rust/rocket_web_app)
error[E0463]: can’t find crate for `rocket`
–> src/main.rs:1:14
|
1 | #[macro_use] extern crate rocket;
| ^^^^^^^^^^^^^^^^^^^^ can’t find crate
….

rocketの方は色々エラーが出るので、少し触った感じではactix-webの方が使いやすそう..