Struct Compose

pub struct Compose {
    pub services: HashMap<String, Service>,
    pub networks: HashMap<String, Network>,
    pub volumes: HashMap<String, Volume>,
    pub executable: String,
    pub file: String,
    pub detached: bool,
}

The root struct of the compose file.

Fields

services: HashMap<String, Service>

networks: HashMap<String, Network>

volumes: HashMap<String, Volume>

executable: String

file: String

detached: bool

Implementations

impl Compose

pub fn new(config: Config) -> Self

Generate a compose file

use crate::generators::env::{ EnvironmentFile };
use crate::generators::compose::{ Compose};
use crate::generators::config::{ Config };

let mut config = Config::load("config-test.toml".to_string());
let deploy_dir: String = format!("{}/{}",config.settings.base_dir,&config.settings.deploy_dir);
let services_dir: String = format!("{}/{}",config.settings.base_dir,&config.settings.services_dir);
let compose_file: String = String::from("docker-compose-test.yaml");
config.validate();
let env_file_paths: Vec<String> = EnvironmentFile::generate(&config.env_files,&deploy_dir);
assert_eq!(env_file_paths.len()>0,true);
let compose_file_path : String = Compose::generate(&mut config.services,&config.networks,&config.volumes,&config.repositories, compose_file,&deploy_dir,&services_dir);
assert_eq!(!compose_file_path.is_empty(),true);

pub fn generate( services: &mut Vec<Service>, networks: &Vec<Network>, volumes: &Vec<Volume>, repositories: &Vec<Repository>, file_name: String, deploy_dir: &String, services_dir: &String, ) -> Self

pub fn insert_service(&mut self, name: String, data: Service)

pub fn insert_network(&mut self, name: String, data: Network)

pub fn insert_volume(&mut self, name: String, data: Volume)

pub fn write( compose: Compose, file_name: String, deploy_dir: &String, ) -> Result<String, Box<dyn Error>>

Write the compose file.

pub fn up(&self) -> bool

Execute the compose file.

pub fn down(&self) -> bool

Terminates the running compose file.

Trait Implementations

impl Clone for Compose

fn clone(&self) -> Compose

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Compose

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Compose

fn default() -> Compose

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Compose

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Compose

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.