dragonfly-client-init 1.5.5

/*
 *     Copyright 2024 The Dragonfly Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use dragonfly_client_config::dfinit::{Config, ContainerRuntimeConfig};
use dragonfly_client_core::Result;
use tracing::{info, instrument};

pub mod containerd;
pub mod crio;
pub mod docker;
pub mod podman;

/// Represents config of the container runtime engine.
#[derive(Debug, Clone)]
enum Engine {
    Containerd(containerd::Containerd),
    Docker(docker::Docker),
    Crio(crio::CRIO),
    Podman(podman::Podman),
}

/// Represents the container runtime manager.
pub struct ContainerRuntime {
    engine: Option<Engine>,
}

/// Implements the container runtime manager.
impl ContainerRuntime {
    /// Creates a new container runtime manager.
    #[instrument(skip_all)]
    pub fn new(config: &Config) -> Self {
        Self {
            engine: Self::get_engine(config),
        }
    }

    /// Runs the container runtime to initialize runtime environment for the dfdaemon.
    #[instrument(skip_all)]
    pub async fn run(&self) -> Result<()> {
        match &self.engine {
            None => Ok(()),
            Some(Engine::Containerd(containerd)) => containerd.run().await,
            Some(Engine::Docker(docker)) => docker.run().await,
            Some(Engine::Crio(crio)) => crio.run().await,
            Some(Engine::Podman(podman)) => podman.run().await,
        }
    }

    /// Returns the runtime engine from the config.
    #[instrument(skip_all)]
    fn get_engine(config: &Config) -> Option<Engine> {
        if let Some(ref container_runtime_config) = config.container_runtime.config {
            let engine = match container_runtime_config {
                ContainerRuntimeConfig::Containerd(containerd) => Engine::Containerd(
                    containerd::Containerd::new(containerd.clone(), config.proxy.clone()),
                ),
                ContainerRuntimeConfig::Docker(docker) => {
                    Engine::Docker(docker::Docker::new(docker.clone(), config.proxy.clone()))
                }
                ContainerRuntimeConfig::CRIO(crio) => {
                    Engine::Crio(crio::CRIO::new(crio.clone(), config.proxy.clone()))
                }
                ContainerRuntimeConfig::Podman(podman) => {
                    Engine::Podman(podman::Podman::new(podman.clone(), config.proxy.clone()))
                }
            };

            info!("container runtime engine is {:?}", engine);
            return Some(engine);
        }

        info!("container runtime engine is not set");
        None
    }
}

#[cfg(test)]
mod tests {
    #![allow(clippy::type_complexity)]

    use super::*;
    use dragonfly_client_config::dfinit;

    #[test]
    fn new_picks_engine_matching_config() {
        let test_cases: Vec<(Option<ContainerRuntimeConfig>, fn(Option<&Engine>))> = vec![
            (None, |engine| assert!(engine.is_none())),
            (
                Some(ContainerRuntimeConfig::Containerd(Default::default())),
                |engine| assert!(matches!(engine, Some(Engine::Containerd(_)))),
            ),
            (
                Some(ContainerRuntimeConfig::Docker(Default::default())),
                |engine| assert!(matches!(engine, Some(Engine::Docker(_)))),
            ),
            (
                Some(ContainerRuntimeConfig::CRIO(Default::default())),
                |engine| assert!(matches!(engine, Some(Engine::Crio(_)))),
            ),
            (
                Some(ContainerRuntimeConfig::Podman(Default::default())),
                |engine| assert!(matches!(engine, Some(Engine::Podman(_)))),
            ),
        ];

        for (container_runtime_config, expect) in test_cases {
            let runtime = ContainerRuntime::new(&Config {
                container_runtime: dfinit::ContainerRuntime {
                    config: container_runtime_config,
                },
                ..Default::default()
            });
            expect(runtime.engine.as_ref());
        }
    }

    #[tokio::test]
    async fn run_returns_ok_without_engine() {
        let runtime = ContainerRuntime::new(&Config::default());
        assert!(runtime.run().await.is_ok());
    }
}