dcp 0.4.1

A utility tool to copy container filesystems easily
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

use anyhow::{anyhow, Result};
use async_trait::async_trait;

use super::docker::Image as DockerImage;
use super::podman::Image as PodmanImage;
use super::Runtime;

/// Container is a trait that defines the functionality of a container
/// to be used by dcp. It contains various methods that are required for
/// the process of copying files out of a container but leaves the physical
/// actions of accomplishing this to the implementation.
///
/// # Functions
///
/// * `pull` - Pulls the container's image. Accepts authentication and can ignore local images if `force` is set.
/// * `start` - Starts the container and returns the started container's ID if successful.
/// * `stop` - Stops the container.
/// * `copy_files` - Copies the files from the specified locations to the specified destination locally.
/// * `present_locally` - Checks to see if the image is already pulled locally.
#[async_trait]
pub trait Container {
    async fn pull(&self, username: String, password: String, force: bool) -> Result<()>;
    async fn start(&self) -> Result<String>;
    async fn stop(&self, id: String) -> Result<()>;
    async fn copy_files(
        &self,
        content_path: String,
        download_path: String,
        write_to_stdout: bool,
    ) -> Result<()>;
    async fn present_locally(&self) -> bool;
}

/// Returns a container with the provided image and runtime
///
/// # Arguments
///
/// * `image` - String representation of an image
/// * `runtime` - Runtime object from representing what this container will run on
pub fn new(image: String, runtime: Runtime) -> Result<Box<dyn Container>> {
    let repo: String;
    let tag: String;
    match split(image.clone()) {
        Some(image) => {
            repo = image.0;
            tag = image.1;
        }
        None => {
            return Err(anyhow!(
                "could not split provided image into repository and tag"
            ))
        }
    }

    if let Some(docker) = runtime.docker {
        return Ok(Box::new(DockerImage {
            image,
            repo,
            tag,
            runtime: docker,
        }));
    }

    if let Some(podman) = runtime.podman {
        return Ok(Box::new(PodmanImage {
            image,
            repo,
            tag,
            runtime: podman,
        }));
    }

    Err(anyhow!("failed to determine proper runtime for image"))
}

fn split(image: String) -> Option<(String, String)> {
    let image_split: Vec<&str> = if image.contains('@') {
        image.split('@').collect()
    } else {
        image.split(':').collect()
    };

    if image_split.is_empty() {
        return None;
    }

    let repo: String;
    if let Some(i) = image_split.first() {
        repo = i.to_string();
    } else {
        return None;
    }

    let tag: String;
    if let Some(i) = image_split.get(1) {
        tag = i.to_string();
    } else {
        // Fall back to latest tag if none is provided
        tag = String::from("latest");
    }

    Some((repo, tag))
}
#[cfg(test)]
mod tests {
    use super::split;

    #[test]
    fn test_split() {
        let digest_image = "quay.io/tflannag/bundles@sha256:145ccb5e7e73d4ae914160c066e49f35bc2be2bb86e4ab0002a802aa436599bf";
        let image = digest_image.to_string();

        let (out_repo, out_tag) = split(image).unwrap();
        assert_eq!(out_repo, "quay.io/tflannag/bundles".to_string());
        assert_eq!(
            out_tag,
            "sha256:145ccb5e7e73d4ae914160c066e49f35bc2be2bb86e4ab0002a802aa436599bf".to_string()
        );
    }
}