arcbox-api 0.0.1-alpha.1

API server for ArcBox (gRPC + REST)
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

//! API server implementation.

use crate::error::Result;
use crate::generated::{
    container_service_server::ContainerServiceServer,
    image_service_server::ImageServiceServer,
    machine_service_server::MachineServiceServer,
    system_service_server::SystemServiceServer,
};
use crate::grpc::{ContainerServiceImpl, ImageServiceImpl, MachineServiceImpl, SystemServiceImpl};
use arcbox_core::{Config, Runtime};
use arcbox_docker::{DockerApiServer, ServerConfig as DockerConfig};
use std::path::PathBuf;
use std::sync::Arc;
use tonic::transport::Server;

/// API server configuration.
#[derive(Debug, Clone)]
pub struct ApiServerConfig {
    /// gRPC listen address.
    pub grpc_addr: String,
    /// Docker API socket path.
    pub docker_socket: PathBuf,
}

impl Default for ApiServerConfig {
    fn default() -> Self {
        Self {
            grpc_addr: "[::1]:50051".to_string(),
            docker_socket: PathBuf::from("/var/run/arcbox-docker.sock"),
        }
    }
}

/// ArcBox API server.
pub struct ApiServer {
    config: ApiServerConfig,
    runtime: Arc<Runtime>,
}

impl ApiServer {
    /// Creates a new API server.
    ///
    /// # Errors
    ///
    /// Returns an error if the runtime cannot be created.
    pub fn new(api_config: ApiServerConfig, core_config: Config) -> Result<Self> {
        let runtime = Arc::new(Runtime::new(core_config)?);
        Ok(Self {
            config: api_config,
            runtime,
        })
    }

    /// Returns the runtime.
    #[must_use]
    pub fn runtime(&self) -> &Arc<Runtime> {
        &self.runtime
    }

    /// Runs the API server.
    ///
    /// # Errors
    ///
    /// Returns an error if the server fails to start.
    pub async fn run(&self) -> Result<()> {
        // Initialize runtime
        self.runtime.init().await?;

        // Start Docker API server in background
        let docker_config = DockerConfig {
            socket_path: self.config.docker_socket.clone(),
        };
        let docker_server = DockerApiServer::new(docker_config, Arc::clone(&self.runtime));

        let docker_handle = tokio::spawn(async move {
            if let Err(e) = docker_server.run().await {
                tracing::error!("Docker API server error: {}", e);
            }
        });

        // Create gRPC services
        let container_service = ContainerServiceImpl::new(Arc::clone(&self.runtime));
        let machine_service = MachineServiceImpl::new(Arc::clone(&self.runtime));
        let image_service = ImageServiceImpl::new(Arc::clone(&self.runtime));
        let system_service = SystemServiceImpl::new(Arc::clone(&self.runtime));

        // Parse gRPC address
        let grpc_addr = self
            .config
            .grpc_addr
            .parse()
            .map_err(|e| crate::error::ApiError::Config(format!("invalid gRPC address: {}", e)))?;

        tracing::info!("ArcBox API server starting");
        tracing::info!("  gRPC: {}", self.config.grpc_addr);
        tracing::info!(
            "  Docker API: {}",
            self.config.docker_socket.display()
        );

        // Build gRPC server
        let grpc_server = Server::builder()
            .add_service(ContainerServiceServer::new(container_service))
            .add_service(MachineServiceServer::new(machine_service))
            .add_service(ImageServiceServer::new(image_service))
            .add_service(SystemServiceServer::new(system_service))
            .serve_with_shutdown(grpc_addr, async {
                tokio::signal::ctrl_c()
                    .await
                    .expect("failed to listen for ctrl-c");
                tracing::info!("Received shutdown signal");
            });

        tracing::info!("ArcBox API server running");

        // Run gRPC server
        grpc_server.await.map_err(|e| {
            crate::error::ApiError::Transport(format!("gRPC server error: {}", e))
        })?;

        tracing::info!("Shutting down...");

        docker_handle.abort();
        self.runtime.shutdown().await?;

        Ok(())
    }
}