firecracker-http-client 0.1.3

A comprehensive HTTP client for the Firecracker VMM API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use firecracker_http_client::models::{
    Balloon, BootSource, Drive, Logger, MachineConfig, NetworkInterface, Vsock,
};
use firecracker_http_client::{
    action::InstanceActionInfo,
    balloon::BalloonOperations,
    boot::BootSourceOperations,
    cpu::{CpuConfig, CpuConfigOperations},
    drive::DriveOperations,
    entropy::{EntropyDevice, EntropyDeviceOperations},
    instance::InstanceOperations,
    logger::LoggerOperations,
    machine::MachineConfigOperations,
    metrics::{Metrics, MetricsOperations},
    mmds::MmdsOperations,
    network::NetworkInterfaceOperations,
    snapshot::{SnapshotCreateParams, SnapshotLoadParams, SnapshotOperations},
    version::VersionOperations,
    vsock::VsockOperations,
    FirecrackerClient,
};
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = FirecrackerClient::new("http://localhost:8080").await?;

    // Configure logger
    let logger = Logger {
        log_path: "/tmp/firecracker.log".to_string(),
        level: Some("Info".to_string()),
        show_level: Some(true),
        show_log_origin: Some(true),
    };
    client.put_logger(&logger).await?;

    // Configure metrics
    let metrics = Metrics {
        metrics_path: "/tmp/metrics".to_string(),
    };
    client.put_metrics(&metrics).await?;

    // Configure machine
    let machine_config = MachineConfig {
        vcpu_count: Some(2),
        mem_size_mib: Some(1024),
        cpu_template: None,
        ..Default::default()
    };
    client.put_machine_config(&machine_config).await?;

    // Configure boot source
    let boot_source = BootSource {
        kernel_image_path: "/path/to/kernel".to_string(),
        boot_args: Some("console=ttyS0 reboot=k panic=1 pci=off".to_string()),
        initrd_path: None,
    };
    client.put_boot_source(&boot_source).await?;

    // Configure drive
    let drive = Drive {
        drive_id: "rootfs".to_string(),
        path_on_host: "/path/to/rootfs".to_string(),
        is_root_device: true,
        is_read_only: false,
        cache_type: Some("Unsafe".to_string()),
        io_engine: None,
        rate_limiter: None,
        partuuid: None,
        socket: None,
    };
    client.put_drive("rootfs", &drive).await?;

    // Configure network
    let network = NetworkInterface {
        iface_id: "eth0".to_string(),
        host_dev_name: "tap0".to_string(),
        guest_mac: None,
        rx_rate_limiter: None,
        tx_rate_limiter: None,
    };
    client.put_network_interface("eth0", &network).await?;

    // Configure balloon
    let balloon = Balloon {
        amount_mib: 512,
        deflate_on_oom: Some(true),
        stats_polling_interval_s: Some(1),
    };
    client.put_balloon_config(&balloon).await?;

    // Configure vsock
    let vsock = Vsock {
        guest_cid: 3,
        uds_path: "/tmp/vsock".to_string(),
        vsock_id: None,
    };
    client.put_vsock(&vsock).await?;

    // Get version
    let version = client.get_version().await?;
    println!("Version: {:?}", version);

    // Get instance info
    let instance_info = client.describe_instance().await?;
    println!("Instance Info: {:?}", instance_info);

    // Test CPU configuration
    let cpu_config = CpuConfig {
        template: Some("C3".to_string()),
    };
    client.put_cpu_config(&cpu_config).await?;

    // Test entropy device
    let entropy = EntropyDevice { rate_limiter: None };
    client.put_entropy_device(&entropy).await?;

    // Test instance actions
    let action = InstanceActionInfo {
        action_type: "InstanceStart".to_string(),
    };
    client.create_sync_action(&action).await?;

    // Test snapshots
    let snapshot_params = SnapshotCreateParams {
        snapshot_path: "/tmp/snapshot".to_string(),
        mem_file_path: "/tmp/snapshot.mem".to_string(),
        version: Some("1.0".to_string()),
        snapshot_type: Some("Full".to_string()),
    };
    client.create_snapshot(&snapshot_params).await?;

    // Test loading snapshots
    let load_params = SnapshotLoadParams {
        snapshot_path: "/tmp/snapshot".to_string(),
        mem_file_path: "/tmp/snapshot.mem".to_string(),
        enable_diff_snapshots: Some(true),
    };
    client.load_snapshot(&load_params).await?;

    // Configure MMDS
    let mmds_data = Value::String("Hello, MMDS!".to_string());
    client.put_mmds(mmds_data).await?;

    Ok(())
}