From e3422ed2558cab640935c515edb8742c7647f8f6 Mon Sep 17 00:00:00 2001 From: groche97 Date: Sat, 15 Jul 2023 09:27:16 +0200 Subject: [PATCH] start to use sqlite --- src/conf/mod.rs | 86 +++++++++++++++++++++++++++++++++++++++---- src/main.rs | 2 +- src/network_docker.rs | 22 ++++++++--- 3 files changed, 97 insertions(+), 13 deletions(-) diff --git a/src/conf/mod.rs b/src/conf/mod.rs index e55f962..5a443d9 100644 --- a/src/conf/mod.rs +++ b/src/conf/mod.rs @@ -1,5 +1,6 @@ use std::net::{Ipv4Addr, SocketAddrV4}; use rusqlite::{Connection, Result}; +use std::collections::hash_map::HashMap; const PATH: &str = "mdeploy.db"; @@ -12,19 +13,23 @@ pub struct ConfServer{ pub struct MInstance { id: i64, - ip: Ipv4Addr, + ip: String, + image: i64, } -pub struct instance { +pub struct InstanceStorage { con: Connection, - + instances: HashMap, + images: HashMap, } -impl instance { +impl InstanceStorage { pub fn new() -> Result { let con = Connection::open(PATH)?; let ret = Self { con : con, + instances: HashMap::new(), + images: HashMap::new(), }; ret.create_table()?; Ok(ret) @@ -38,15 +43,82 @@ impl instance { CREATE TABLE IF NOT EXISTS l_instances( id INTEGER PRIMARY KEY AUTOINCREMENT, ip TEXT, - image INTEGER + domain TEXT, + image INTEGER, FOREIGN KEY(INTEGER) REFERENCES images(id)); COMMIT;" ) } - fn insert_image(&self, image: String){ - + fn insert_image(&self, image: String) -> Result<()>{ + let mut stmt = self.con.prepare("INSERT INTO images values(?1)")?; + stmt.execute([image])?; + Ok(()) } + fn load_instances(&mut self) -> Result<()> { + let mut stmt = self.con.prepare("select id, ip, domain, image from l_instances")?; + let mut rows = stmt.query([])?; + for row in rows.next()? { + let mut domain = row.get::<_, String>(2)?; + self.instances.insert(domain, MInstance { + id: row.get::<_, i64>(0)?, + ip: row.get::<_, String>(1)?, + image: row.get::<_, i64>(3)? +, + }); + } + Ok(()) + } + + fn load_images(&mut self) -> Result<()> { + let mut stmt = self.con.prepare("select id, name from images")?; + let mut rows = stmt.query([])?; + for row in rows.next()? { + self.images.insert(row.get::<_, String>(1)?, row.get::<_, i64>(0)?); + } + Ok(()) + } + + fn get_image_id(&self, image: String) -> Result { + let mut stmt = self.con.prepare("select id from images where name = ?1")?; + let mut rows = stmt.query([image])?; + let id = rows.next()?.unwrap().get::<_, i64>(0)?; + Ok(id) + } + + fn get_instance_id(&self, domain: String) -> Result { + let mut stmt = self.con.prepare("select id from l_instances where domain = ?1")?; + let mut rows = stmt.query([domain])?; + let id = rows.next()?.unwrap().get::<_, i64>(0)?; + Ok(id) + } + + fn new_instance(&mut self, domain: String, image: String, ip: String) -> Result{ + let image_id = self.create_or_get_image_id(image.clone(), 0)?; + let mut stmt = self.con.prepare("INSERT INTO l_instances values(?1, ?2, ?3)")?; + stmt.execute([ip.clone(), image, image_id.to_string()])?; + let instance_id = self.get_instance_id(domain.clone())?; + self.instances.insert(domain.clone(), MInstance{ + id: instance_id, + ip: ip, + image: image_id + }); + Ok(instance_id) + } + + fn create_or_get_image_id(&self, image: String, mut depth: i64) -> Result { + if depth > 0 { + return Err(rusqlite::Error::QueryReturnedNoRows); + } + depth+=1; + match self.get_image_id(image.clone()) { + Ok(id) => Ok(id), + Err(_e) => { + self.insert_image(image.clone())?; + self.create_or_get_image_id(image, depth) + } + } + } } diff --git a/src/main.rs b/src/main.rs index 5d9c364..82001f9 100644 --- a/src/main.rs +++ b/src/main.rs @@ -15,7 +15,7 @@ async fn main() { let net_name = String::from("customnetwork"); let net_range = String::from("172.20.0.0/24"); - match network_docker::Network::create_network(docker.clone(), net_name, net_range).await { + match network_docker::Network::new(docker.clone(), net_name, net_range).await { Ok(_n)=> println!("va"), Err(e)=> println!("err: {}", e), }; diff --git a/src/network_docker.rs b/src/network_docker.rs index d41e321..ffd34a2 100644 --- a/src/network_docker.rs +++ b/src/network_docker.rs @@ -1,7 +1,8 @@ -use bollard::Docker; use bollard::errors::Error; +use bollard::errors::Error::DockerResponseServerError; use bollard::models::{IpamConfig,Ipam}; -use bollard::network::CreateNetworkOptions; +use bollard::network::{CreateNetworkOptions, ListNetworksOptions}; +use std::collections::hash_map::HashMap; pub struct Network { name: String, @@ -10,9 +11,20 @@ pub struct Network { } impl Network { - async fn check_network(docker: bollard::Docker, name) -> bool { + pub async fn new(docker: bollard::Docker, name: String, range: String) -> Result { + if Self::check_network(docker.clone(), name.clone()).await { + Ok(Network { + name: name, + range: range, + }) + } else { + Self::create_network(docker, name, range).await + } + } + + async fn check_network(docker: bollard::Docker, name: String) -> bool { let mut list_networks_filters = HashMap::new(); - list_networks_filters.insert("name", name); + list_networks_filters.insert("name", vec![name.as_str()]); match docker.list_networks(Some(ListNetworksOptions { filters: list_networks_filters, })).await { @@ -21,7 +33,7 @@ impl Network { } } - pub async fn create_network(docker: bollard::Docker, name: String, range: String) -> Result{ + async fn create_network(docker: bollard::Docker, name: String, range: String) -> Result{ let ipam_config = IpamConfig { subnet: Some(range.clone()), ..Default::default()