groche97/mrdeploy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

start refactor of ip management

Browse Source
This commit is contained in:
Guillermo Roche
2025-12-14 21:22:07 +00:00
parent 3b5e7e1986
commit 7cabefc76e
13 changed files with 1500 additions and 777 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
src/controller/mod.rs
View File

@@ -1,12 +1,12 @@
use bollard::Docker;
use bollard::errors::Error;
use crate::deploy;
use crate::deploy::container::Container;
use crate::database::exposer::MemStorage;
use crate::database::instance::Instance;
use crate::deploy;
use crate::deploy::container::Container;
use crate::deploy::container_options::Options;
use std::sync::Mutex;
use bollard::errors::Error;
use bollard::Docker;
use log::error;
use std::sync::Mutex;
pub struct Controller {
driver: Docker,
@@ -16,7 +16,11 @@ pub struct Controller {
}
impl Controller {
pub async fn new(driver: Docker, network: String, range: String) -> Result<Self, bollard::errors::Error>{
pub async fn new(
driver: Docker,
network: String,
range: String,
) -> Result<Self, bollard::errors::Error> {
deploy::network::Network::new(driver.clone(), network.clone(), range).await?;
let cont = Self {
driver: driver,
@@ -27,60 +31,86 @@ impl Controller {
Ok(cont)
}
pub async fn create_container(&self, domain: String, ip: String, image: String, ops: Options) -> String {
pub async fn create_container(
&self,
domain: String,
ip: Option<String>,
image: String,
ops: Options,
) -> String {
let is_stored = self.storage.lock().unwrap().search_instance(domain.clone());
match is_stored {
Some(c) => match c.docker_id {
Some(id) => id,
None => "Container without docker_id".to_string()
None => "Container without docker_id".to_string(),
},
None => {
match self.load_container(None,domain.clone(),ip.clone(),image.clone(),ops).await {
match self
.load_container(None, domain.clone(), ip.clone(), image.clone(), ops)
.await
{
Ok(c) => {
self.storage.try_lock().unwrap().new_instance(c.clone()).unwrap();
self.storage
.try_lock()
.unwrap()
.new_instance(c.clone())
.unwrap();
c.get_id()
},
Err(_e) => "error creating container".to_string(),
}
Err(e) => format!("error creating container: {}", e.to_string()),
}
}
}
}
pub async fn start_container_from_instance(&self, instance: Instance) {
let image = match self.storage.lock().unwrap().id_to_image(instance.image.clone()) {
let image = match self
.storage
.lock()
.unwrap()
.id_to_image(instance.image.clone())
{
Ok(i) => i,
Err(e) => {
error!("image not found: {}", e);
return
},
error!("image not found: {}", e);
return;
}
};
match self.load_container(
Some(instance.docker_id.clone()),
instance.domain.clone(),
instance.ip.clone(),
image,
Options::new(None, None)).await {
match self
.load_container(
Some(instance.docker_id.clone()),
instance.domain.clone(),
instance.ip.clone(),
image,
Options::new(None, None),
)
.await
{
Ok(c) => {
self.storage.lock().unwrap().loaded_instance(instance, c);
},
Err(e) => error!("{}",e),
}
Err(e) => error!("{}", e),
}
}
async fn load_container(&self, docker_id: Option<String>,
domain: String,
ip: String,
image: String,
ops: Options) -> Result<deploy::container::Container,
bollard::errors::Error>
{
deploy::container::Container::new(self.driver.clone(),
docker_id,
domain,
ip,
image,
self.network.clone(),
ops).await
async fn load_container(
&self,
docker_id: Option<String>,
domain: String,
ip: Option<String>,
image: String,
ops: Options,
) -> Result<deploy::container::Container, bollard::errors::Error> {
deploy::container::Container::new(
self.driver.clone(),
docker_id,
domain,
ip,
image,
self.network.clone(),
ops,
)
.await
}
pub async fn is_started(&self) -> bool {
@@ -91,9 +121,9 @@ impl Controller {
let data = match self.storage.lock().unwrap().get_instances_db() {
Ok(d) => d,
Err(e) => {
error!("instances can't be loaded: {}",e);
return false
},
error!("instances can't be loaded: {}", e);
return false;
}
};
println!("instances {}", data.len());
for instance in data {
@@ -102,14 +132,14 @@ impl Controller {
return true;
}
async fn stop_given_container(&self, container:Container) -> Result<String, Error> {
async fn stop_given_container(&self, container: Container) -> Result<String, Error> {
match container.stop(&self.driver).await {
Ok(_i) => Ok(container.get_id()),
Err(e) => Err(e),
}
}
async fn prune_given_container(&self, container:Container) -> Result<String, Error> {
async fn prune_given_container(&self, container: Container) -> Result<String, Error> {
match container.remove(&self.driver).await {
Ok(_i) => Ok(container.get_id()),
Err(e) => Err(e),
@@ -118,30 +148,34 @@ impl Controller {
pub async fn stop_container(&self, domain: String) -> Result<String, Error> {
match self.storage.lock().unwrap().stop_instance(domain) {
Some(c) => {
self.stop_given_container(c).await
},
Some(c) => self.stop_given_container(c).await,
None => Err(Error::DockerResponseServerError {
status_code: 404, message: "container not found".to_string()
}),
status_code: 404,
message: "container not found".to_string(),
}),
}
}
pub async fn delete_container(&self, domain: String) -> Result<String, Error> {
match self.storage.lock().unwrap().remove_instance(domain) {
Some(data) => {
match data.1 {
Some(c) => self.prune_given_container(c).await,
None => Ok(data.0.docker_id),
}
Some(data) => match data.1 {
Some(c) => self.prune_given_container(c).await,
None => Ok(data.0.docker_id),
},
None => Err(Error::DockerResponseServerError {
status_code: 404, message: "container not found".to_string()
}),
status_code: 404,
message: "container not found".to_string(),
}),
}
}
pub async fn get_ip(&self, domain: String) -> Result<String, Error> {
let container = self
.storage
.lock()
.unwrap()
.search_instance(domain.clone())
.unwrap();
container.get_ip(&self.driver).await
}
}