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

use std::collections::HashMap;
use crate::sled_json::{ TreeWrapper, JSONEncoder };
use crate::public_struct::{ ImageVersionJSONValue };

pub async fn record_image_repositories(db: &sled::Db,image_name:String,image_version:String,image_digest:String) -> sled::Result<()> {
    let image_name_version = format!("{}:{}",image_name.clone(),image_version.clone());
    let tree = TreeWrapper::<JSONEncoder<ImageVersionJSONValue>, JSONEncoder<ImageVersionJSONValue>>::new(
        db.open_tree("image_repositories")?,
    );

    let value = tree
    .get("Repositories".to_string());

    let  image_repositories_json_value:ImageVersionJSONValue;
    match value {
        Ok(res) => {
            match res {
                Some(res1) =>{
                    match res1.decode() {
                        Some(mut res2) => {
                            let mut image_repositories = HashMap::new();
                            image_repositories.insert(image_name_version.clone(),image_digest.clone());
                            res2.image_version.insert(image_name.clone(),image_repositories);
                            image_repositories_json_value = ImageVersionJSONValue {
                                image_version: res2.image_version
                            };
                        }
                        _ => {
                            let mut result = HashMap::new();
                            let mut image_repositories = HashMap::new();
                            image_repositories.insert(image_name_version.clone(),image_digest.clone());
                            result.insert(image_name.clone(),image_repositories);
                            image_repositories_json_value = ImageVersionJSONValue {
                                image_version: result
                            };
                        }
                    }
                },
                _ => {
                        let mut result = HashMap::new();
                        let mut image_repositories = HashMap::new();
                        image_repositories.insert(image_name_version.clone(),image_digest.clone());
                        result.insert(image_name.clone(),image_repositories);
                        image_repositories_json_value = ImageVersionJSONValue {
                            image_version: result
                        };
                }
            }
        },
        Err(_) => {
                    let mut result = HashMap::new();
                    let mut image_repositories = HashMap::new();
                    image_repositories.insert(image_name_version.clone(),image_digest.clone());
                    result.insert(image_name.clone(),image_repositories);
                    image_repositories_json_value = ImageVersionJSONValue {
                        image_version: result
                    };
        }
    };

    tree.insert("Repositories".to_string(), &image_repositories_json_value)?;
    // let value1 = tree
    //     .get(image_name.clone())?
    //     .expect("Value not found")
    //     .decode()
    //     .expect("Decoding failed");
    // assert_eq!(value, image_repositories_json_value);
    // println!("image_version:{:?}",value1);
    // println!("image_version:{:?}",value.image_version["nginx:latest"]);
    Ok(())
}



pub async fn remove_image_repositories(db: &sled::Db,image_name:String,image_version:String) -> sled::Result<()> {
    let image_name_version = format!("{}:{}",image_name.clone(),image_version.clone());
    let tree = TreeWrapper::<JSONEncoder<ImageVersionJSONValue>, JSONEncoder<ImageVersionJSONValue>>::new(
        db.open_tree("image_repositories")?,
    );

    let value = tree
    .get("Repositories".to_string());

    let  image_repositories_json_value:ImageVersionJSONValue;
    match value {
        Ok(res) => {
            match res {
                Some(res1) =>{
                    match res1.decode() {
                        Some(mut res2) => {
                            let k_v = res2.image_version.get(&*image_name.clone()).unwrap();
                            let mut tmp_hashmap:HashMap<String,String> = HashMap::new();
                            for (k,v) in k_v{
                                if *k == image_name_version{
                                    continue;
                                } else {
                                    tmp_hashmap.insert((*k.clone()).parse().unwrap(), (*v.clone()).parse().unwrap());
                                }
                            }



                            res2.image_version.insert(image_name.clone(),tmp_hashmap);
                            image_repositories_json_value = ImageVersionJSONValue {
                                image_version: res2.image_version
                            };
                            tree.insert("Repositories".to_string(), &image_repositories_json_value)?;
                        }
                        _ => {
                            println!("remove repositories info failed!");
                        }
                    }
                },
                _ => {
                    println!("remove repositories info failed!");
                }
            }
        },
        Err(_) => {
            println!("remove repositories info failed!");
        }
    };
    Ok(())
}