use crate::get_manifest::{get_manifest_info,Manifest as NDockerManifest};
use crate::local_repositories::judge_image_local;
use crate::get_config::{ write_config_json,read_config_json };
use crate::record_image_layer_level::{ record_image_layer_diff_id_to_level,remove_image_layer_diff_id_to_level };
use crate::utils::{ determine_whether_image_layer_exists,compute_layer_size,computer_layer_chain_id,remove_image_gz,get_completed_digest,remove_image_rootfs };
use crate::record_image_digest_layerdiffid_layerdigest::{ record_image_digest_layer_diff_id_to_layer_digest,record_image_digest_layer_digest_layer_diff_id,remove_image_digest_layer_diff_id_to_layer_digest,remove_image_digest_layer_digest_layer_diff_id };
use crate::get_layers::get_layers;
use crate::record_image_repositories::{ record_image_repositories,remove_image_repositories };
use crate::record_image_digest_image_name_version_repositories::{ record_image_digest_image_name_version_repositories,remove_image_digest_image_name_version_repositories,get_image_name_version };
use crate::record_image_chainid::{ record_image_chain_id,remove_image_chain_id };
use crate::get_manifest_dockerhub::{get_manifest_info_dockerhub,Manifest as DockerManifest};
use crate::get_config_dockerhub::{ write_config_json_dockerhub,read_config_json_dockerhub };
use crate::get_layers_dockerhub::get_layers_dockerhub;
use crate::get_token_dockerhub::get_token_dockerhub;
use std::collections::HashMap;
pub async fn pull_image(db: &sled::Db,repositories_url_ip:String,image_name:String,image_version:String,username:String,password:String,docker:bool) {
let token;
match !docker {
true => {
token = "".to_string();
},
false => {
let token_1 = get_token_dockerhub(image_name.clone()).await.unwrap();
token = format!("{}",token_1.access_token);
}
}
let mut manifest_info1:NDockerManifest = NDockerManifest::default();
let mut manifest_info_docker1:DockerManifest = DockerManifest::default();
match !docker{
true => {
let manifest_info = get_manifest_info(repositories_url_ip.clone(), username.clone(), password.clone(), image_name.clone(), image_version.clone()).await;
manifest_info1 = match manifest_info {
Ok(res) => {
res
},
Err(e) => {
println!("Get manifest_Info failed!Reason:{}",e);
return
}
}
},
false => {
let manifest_info_docker = get_manifest_info_dockerhub( image_name.clone(), image_version.clone(),token.clone()).await;
manifest_info_docker1 = match manifest_info_docker {
Ok(res) => {
res
},
Err(e) => {
println!("Get manifest_Info failed!Reason:{}",e);
return
}
}
}
};
let image_digest;
match !docker {
true => image_digest = manifest_info1.config.digest.clone(),
false => image_digest = manifest_info_docker1.config.digest.clone()
}
let image_digest_no_sha256_1 = image_digest.split(':');
let image_digest_no_sha256_2: Vec<&str> = image_digest_no_sha256_1.collect();
let image_digest_no_sha256_3 = image_digest_no_sha256_2[1];
let image_digest_no_sha256 = format!("{}",image_digest_no_sha256_3.clone());
let local_image = judge_image_local(db, image_name.clone(), image_version.clone(), image_digest.clone()).await;
if local_image {
println!("Image already exists!");
return
} else {
match !docker {
true => {
write_config_json(repositories_url_ip.clone(), username.clone(), password.clone(), image_name.clone(), image_digest.clone()).await;
},
false => {
write_config_json_dockerhub( image_name.clone(), image_digest.clone(),token.clone()).await;
}
};
let config_info = match !docker {
true => read_config_json(image_digest_no_sha256.clone()).await,
false => read_config_json_dockerhub(image_digest_no_sha256.clone()).await
};
let layer_1 = format!("{}", config_info["rootfs"]["diff_ids"]);
let layer_2 = layer_1.split(',');
let layer_3: Vec<&str> = layer_2.collect();
let mut rayon_vec = Vec::new();
let mut layer_parent_chain_id = "".to_string();
for i in 0..layer_3.len() {
let mut layer_vec = Vec::new();
let layer_diff_id1 = format!("{}", config_info["rootfs"]["diff_ids"][i]);
let layer_diff_id2 = layer_diff_id1.split('"');
let layer_diff_id3: Vec<&str> = layer_diff_id2.collect();
let layer_diff_id = format!("{}", layer_diff_id3[1]);
record_image_layer_diff_id_to_level(db, image_digest_no_sha256.clone(), layer_diff_id.clone(), i as i64).await.unwrap();
let layer_digest;
match !docker {
true => layer_digest = manifest_info1.layers[i].digest.clone(),
false => layer_digest = manifest_info_docker1.layers[i].digest.clone()
}
let layer_digest1 = layer_digest.split(':');
let layer_digest2: Vec<&str> = layer_digest1.collect();
let layer_digest1_no_sha256 = format!("{}", layer_digest2[1]);
layer_vec.push(image_digest_no_sha256.clone());
layer_vec.push(layer_digest1_no_sha256.clone());
layer_vec.push(layer_diff_id.clone());
let whether_image_layer = determine_whether_image_layer_exists(db,image_digest_no_sha256.clone(),layer_diff_id.clone());
if whether_image_layer{
continue
}else {
let chain_id = computer_layer_chain_id(layer_parent_chain_id.clone(),layer_diff_id.clone());
layer_vec.push(chain_id.clone());
layer_vec.push(layer_parent_chain_id.clone());
layer_parent_chain_id = chain_id.clone();
}
layer_vec.push(image_digest.clone());
layer_vec.push(layer_digest.clone());
let mut layer_hashmap = HashMap::new();
layer_hashmap.insert("item",layer_vec);
rayon_vec.push(layer_hashmap);
}
for item in rayon_vec {
match !docker {
true => {
get_layers(
repositories_url_ip.clone(),
username.clone(),
password.clone(),
image_name.clone(),
item["item"][5].clone(),
item["item"][6].clone(),
item["item"][2].clone()
).await;
record_image_digest_layer_diff_id_to_layer_digest(db,item["item"][5].clone(),item["item"][2].clone(),item["item"][6].clone()).await.unwrap();
record_image_digest_layer_digest_layer_diff_id(db,item["item"][5].clone(),item["item"][2].clone(),item["item"][6].clone()).await.unwrap();
},
false => {
get_layers_dockerhub(
image_name.clone(),
item["item"][5].clone(),
item["item"][6].clone(),
item["item"][2].clone(),
token.clone()
).await;
record_image_digest_layer_diff_id_to_layer_digest(db,item["item"][5].clone(),item["item"][2].clone(),item["item"][6].clone()).await.unwrap();
record_image_digest_layer_digest_layer_diff_id(db,item["item"][5].clone(),item["item"][2].clone(),item["item"][6].clone()).await.unwrap();
}
};
let path = format!("/var/lib/AntKing/gz/{}/{}.tar", item["item"][0.clone()], item["item"][1].clone());
let size = compute_layer_size(path.clone());
record_image_chain_id(db, item["item"][0].clone(), item["item"][3].clone(), item["item"][2].clone(), item["item"][2].clone(), item["item"][4].clone(), size).await.unwrap();
}
let image_name_version = format!("{}:{}",image_name.clone(),image_version.clone());
println!("Download Image {} complete!",image_name_version);
record_image_repositories(db,image_name.clone(),image_version.clone(),image_digest.clone()).await.unwrap();
record_image_digest_image_name_version_repositories(db,image_name.clone(),image_version.clone(),image_digest.clone()).await.unwrap();
}
}
pub async fn remove_image(db: &sled::Db,image_digest:String) {
let image_completed_digest = get_completed_digest(image_digest.clone());
let image_digest = format!("sha256:{}",image_completed_digest);
let image_digest_no_sha256 = format!("{}",image_completed_digest);
let image_tuple = get_image_name_version(db,image_digest.clone()).await;
let image_name = format!("{}",image_tuple.0);
let image_version = format!("{}",image_tuple.1);
remove_image_layer_diff_id_to_level(db,image_digest_no_sha256.clone()).await.unwrap();
remove_image_chain_id(db,image_digest_no_sha256.clone()).await.unwrap();
remove_image_digest_image_name_version_repositories(db,image_digest.clone()).await.unwrap();
remove_image_digest_layer_digest_layer_diff_id(db,image_digest.clone()).await.unwrap();
remove_image_digest_layer_diff_id_to_layer_digest(db,image_digest.clone()).await.unwrap();
remove_image_repositories(db,image_name.clone(),image_version.clone()).await.unwrap();
let remove_gz_path = format!("{}",image_digest_no_sha256.clone());
remove_image_gz(remove_gz_path.clone());
let remove_rootfs_path = format!("{}",image_digest_no_sha256.clone());
remove_image_rootfs(remove_rootfs_path.clone());
}