WASI0.2とWebAssemblyComponentModel:言語非依存のマイクロサービスとWITインターフェース

// user-processor.wit
package locionic:user-processor;

/// Represents a user profile.
record UserProfile {
    id: u64,
    username: string,
    email: string,
    is-active: bool,
}

/// Defines the interface for user data processing.
interface processor {
    /// Processes a single user profile.
    /// Returns true if processing was successful, false otherwise.
    process-user: func(user: UserProfile) -> bool;

    /// Retrieves a user profile by ID.
    /// Returns an optional UserProfile, which is `none` if not found.
    get-user-by-id: func(id: u64) -> option<UserProfile>;
}

world user-service {
    export processor;
    import wasi:cli/environment; // Example of importing a WASI interface
}

rustup target add wasm32-wasi
cargo install wasm-tools

cargo new --lib user-processor-rust
cd user-processor-rust

# Cargo.toml
[package]
name = "user-processor-rust"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
# wit-bindgen is used to generate Rust bindings from WIT
wit-bindgen = { version = "0.11.0", features = ["macros"] }

[build-dependencies]
wit-bindgen = { version = "0.11.0" }

// build.rs
fn main() {
    println!("cargo:rerun-if-changed=../user-processor.wit");
    wit_bindgen::generate("user-processor.wit")
        .expect("wit-bindgen failed to generate code");
}

// src/lib.rs
wit_bindgen::generate!({
    path: "../user-processor.wit",
    world: "user-service",
});

struct UserProcessorRust;

impl guest::locionic::user_processor::processor::Processor for UserProcessorRust {
    fn process_user(user: guest::locionic::user_processor::processor::UserProfile) -> bool {
        println!("Rust component: Processing user: id={}, username={}, email={}, active={}",
            user.id, user.username, user.email, user.is_active);
        // Simulate some processing logic
        user.is_active // Return true if user is active
    }

    fn get_user_by_id(id: u64) -> Option<guest::locionic::user_processor::processor::UserProfile> {
        println!("Rust component: Retrieving user by ID: {}", id);
        if id == 123 {
            Some(guest::locionic::user_processor::processor::UserProfile {
                id: 123,
                username: "rust_user".to_string(),
                email: "rust@example.com".to_string(),
                is_active: true,
            })
        } else {
            None
        }
    }
}

// This macro generates the necessary boilerplate for the component to export its functions.
export!(UserProcessorRust);

cargo build --target wasm32-wasi --release

wasm-tools component new target/wasm32-wasi/release/user_processor_rust.wasm \
  --adapt wasi_snapshot_preview1 \
  -o user_processor_rust.wasm

pip install componentize-py

# user_consumer.py
from typing import Optional
from componentize_py import componentize

# Define the WIT interface directly in Python for componentize-py
# In a real scenario, you'd likely generate this from a .wit file
# For demonstration, we'll define a simple interface that imports
# the user-processor and exports a 'run' function.

# This is a simplified representation for componentize-py.
# The actual WIT definition would be in user-processor.wit
# and componentize-py would generate the Python types.
# For this example, we'll define a 'world' that imports our Rust component.

# We need to define the types that the imported component uses.
class UserProfile:
    id: int
    username: str
    email: str
    is_active: bool

    def __init__(self, id: int, username: str, email: str, is_active: bool):
        self.id = id
        self.username = username
        self.email = email
        self.is_active = is_active

# This is the Python code that will be componentized.
# It will import the 'processor' interface from our Rust component.
class UserConsumer:
    def run(self) -> None:
        # This part assumes the 'processor' interface is available
        # in the current scope due to how componentize-py generates bindings.
        # In a real scenario, you'd access it via a generated module.
        print("Python component: Starting user consumption...")

        # Simulate calling the imported Rust component's functions
        # These types (UserProfile) would be generated by wit-bindgen for Python
        # For this example, we'll manually construct them.

        # Call process_user
        test_user = UserProfile(id=456, username="python_test", email="py@example.com", is_active=True)
        # The actual call signature depends on the generated bindings.
        # For componentize-py, it often looks like this:
        # from locionic.user_processor.processor import process_user, get_user_by_id, UserProfile
        # For this example, we'll mock the call.

        # In a real componentized Python, you'd have:
        # from locionic.user_processor.processor import process_user, get_user_by_id, UserProfile
        # result = process_user(test_user)
        # print(f"Python component: Processed user (Python): {result}")

        # For demonstration without full componentize-py binding generation setup:
        # We'll assume the host will link the Rust component and provide its functions.
        # The Python component itself will just print.
        print(f"Python component: Would call process_user with {test_user.username}")

        # Call get_user_by_id
        # user_from_rust = get_user_by_id(123)
        # if user_from_rust:
        #     print(f"Python component: Retrieved user from Rust: {user_from_rust.username}")
        # else:
        #     print("Python component: User 123 not found by Rust component.")

        print("Python component: Would call get_user_by_id(123)")

# This is the WIT definition for the Python component's world.
# It imports the 'processor' interface from our Rust component.
# This WIT defines what the Python component *expects* from its environment.
python_consumer_wit = """
package locionic:user-consumer;

import locionic:user-processor/processor;

world python-consumer {
    import processor; // Import the interface from the Rust component
    export run: func();
}
"""

# Componentize the Python module
componentize(
    "user_consumer.py",
    wit=python_consumer_wit,
    world="python-consumer",
    output="user_consumer.wasm",
)

curl https://wasmtime.dev/install.sh -sSf | bash

wasmtime run user_processor_rust.wasm --invoke process-user '{ "id": 789, "username": "test_user", "email": "test@example.com", "is-active": true }'

// host_app.rs
use anyhow::Result;
use wasmtime::{component::*, Config, Engine, Store};

// Define the WIT types for the host to interact with
wit_bindgen::generate!({
    path: "user-processor.wit",
    world: "user-service",
    // This tells wit-bindgen to generate types for the host side
    // so it can interact with the component.
    // We need to define the types for the Python consumer as well if we want to call it.
    // For simplicity, we'll just call the Rust component directly from the host.
});

#[tokio::main]
async fn main() -> Result<()> {
    let mut config = Config::new();
    config.wasm_component_model(true); // Enable Component Model support
    config.async_support(true); // Enable async for WASI futures

    let engine = Engine::new(&config)?;
    let mut store = Store::new(&engine, ()); // No host state needed for this example

    // Load the Rust component
    let component = Component::from_file(&engine, "user_processor_rust.wasm")?;

    // Instantiate the component
    let (instance, _exports) = UserService::instantiate_async(&mut store, &component, &[])
        .await?;

    // Access the exported 'processor' interface
    let processor = instance.processor();

    // Call process_user
    let user_profile = locionic::user_processor::processor::UserProfile {
        id: 101,
        username: "host_caller".to_string(),
        email: "host@example.com".to_string(),
        is_active: true,
    };
    let success = processor.process_user(&mut store, &user_profile).await?;
    println!("Host app: Processed user via Rust component: {}", success);

    // Call get_user_by_id
    let retrieved_user = processor.get_user_by_id(&mut store, 123).await?;
    if let Some(user) = retrieved_user {
        println!("Host app: Retrieved user from Rust component: id={}, username={}", user.id, user.username);
    } else {
        println!("Host app: User 123 not found by Rust component.");
    }

    Ok(())
}

cargo add anyhow wasmtime wasmtime-wasi tokio --features "macros,rt-multi-thread"
cargo run --bin host_app

curl -fsSL https://developer.fermyon.com/downloads/install.sh | bash

# spin.toml
spin_version = "1"
authors = ["Locionic Engineering <engineering@locionic.com>"]
description = "User Processor Service"
name = "user-processor-service"
trigger = { type = "http", base = "/" }

[[component]]
id = "user-processor-rust"
source = "user_processor_rust.wasm"
# This is a placeholder for how Spin would expose the WIT interface
# and allow other components to call it.
# For HTTP triggers, Spin automatically maps HTTP requests to component functions.
# For component-to-component calls, Spin's linking mechanism would be used.
# For this example, we'll expose a simple HTTP endpoint.
trigger = { route = "/process", executor = { type = "wagi" } }
# Environment variables or other capabilities can be configured here
# environment = { MY_VAR = "value" }

spin up

curl -X POST -H "Content-Type: application/json" -d '{"id": 999, "username": "spin_user", "email": "spin@example.com", "is-active": true}' http://127.0.0.1:3000/process