oci-util 0.2.0

云网关OCI公共库
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

pub mod tar_file;

use crate::filesystem::FileSystem;
use crate::util::DigestPre;
use anyhow::{anyhow, Context, Result};
use oci_distribution::client::ImageLayer;

pub static LAYER_MEDIA_TYPE: &str = "application/vnd.oci.image.layer.v1.tar";

pub struct LayerAndData {
    pub data: Vec<u8>,
    // pub layer: Layer,
    pub media_type: String,
}

// #[derive(Serialize, Deserialize)]
// pub struct Layer {
//     desc: Descriptor,
// }
//
// impl Layer {
//     /// 好像不行
//     pub fn save_descriptor(&self) -> Result<String> {
//         let path = FileSystem.layer_contents()?;
//         let data = serde_json::to_vec(&self.desc)?;
//         let digest = sha256::digest_bytes(data.as_slice());
//         let path = path.join(&digest);
//         std::fs::write(path, data)?;
//         Ok(digest)
//     }
// }
//
// impl From<Descriptor> for Layer {
//     fn from(desc: Descriptor) -> Self {
//         Self { desc }
//     }
// }
// impl Deref for Layer {
//     type Target = Descriptor;
//
//     fn deref(&self) -> &Self::Target {
//         &self.desc
//     }
// }

impl LayerAndData {
    pub fn load(desc_digest: &String, media_type: String) -> Result<Self> {
        let layer_digest = desc_digest.get_digest()?;
        let layer_path = FileSystem.layer_blobs()?.join(&layer_digest);
        let data = std::fs::read(&layer_path).context(anyhow!("加载{:?}失败", layer_path))?;
        Ok(Self {
            data,
            media_type, // layer: desc.into(),
        })
    }
}

impl From<LayerAndData> for ImageLayer {
    fn from(lad: LayerAndData) -> Self {
        let LayerAndData { data, media_type } = lad;
        // let media_type = layer.desc.media_type().to_string();
        Self {
            data,
            media_type,
            annotations: None,
        }
    }
}