jlengrand/engine
1
0
Fork 0
mirror of https://github.com/jlengrand/engine.git synced 2026-03-10 08:11:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev' into chore/upgrade_aws_charts

Browse Source
This commit is contained in:
MacLikorne
2022-02-16 09:26:48 +01:00
committed by GitHub
parent 938192194f 5daf1c5d96
commit 1b318bc8a5
12 changed files with 191 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/cloud_provider/aws/kubernetes/helm_charts.rs
View File

@@ -694,7 +694,7 @@ datasources:
},
ChartSetValue {
key: "replicaCount".to_string(),
value: "2".to_string(),
value: "1".to_string(),
},
// https://cert-manager.io/docs/configuration/acme/dns01/#setting-nameservers-for-dns01-self-check
ChartSetValue {

31
src/cloud_provider/aws/kubernetes/mod.rs
View File

@@ -835,7 +835,10 @@ impl<'a> EKS<'a> {
),
Err(err) => self.logger().log(
LogLevel::Error,
EngineEvent::Deploying(event_details.clone(), EventMessage::new(err.message(), None)),
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
),
),
};
@@ -1110,10 +1113,7 @@ impl<'a> EKS<'a> {
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", safe_message.to_string(), e.message()),
Some(safe_message.to_string()),
),
EventMessage::new(safe_message.to_string(), Some(e.message())),
),
);
@@ -1226,7 +1226,7 @@ impl<'a> EKS<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(format!("{}, error: {}", message_safe, e.message(),), Some(message_safe)),
EventMessage::new(message_safe, Some(e.message())),
),
);
}
@@ -1299,10 +1299,7 @@ impl<'a> EKS<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", message_safe, e.message()),
Some(message_safe),
),
EventMessage::new(message_safe, Some(e.message())),
),
)
}
@@ -1398,14 +1395,7 @@ impl<'a> EKS<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!(
"{}, error: {}",
message_safe,
e.message.unwrap_or("no error message".to_string())
),
Some(message_safe),
),
EventMessage::new(message_safe, e.message),
),
)
}
@@ -1418,10 +1408,7 @@ impl<'a> EKS<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", message_safe, e.message()),
Some(message_safe.to_string()),
),
EventMessage::new(message_safe.to_string(), Some(e.message())),
),
)
}

2
src/cloud_provider/digitalocean/kubernetes/helm_charts.rs
View File

@@ -534,7 +534,7 @@ datasources:
},
ChartSetValue {
key: "replicaCount".to_string(),
value: "2".to_string(),
value: "1".to_string(),
},
// https://cert-manager.io/docs/configuration/acme/dns01/#setting-nameservers-for-dns01-self-check
ChartSetValue {

31
src/cloud_provider/digitalocean/kubernetes/mod.rs
View File

@@ -850,7 +850,10 @@ impl<'a> DOKS<'a> {
),
Err(err) => self.logger().log(
LogLevel::Error,
EngineEvent::Deploying(event_details.clone(), EventMessage::new(err.message(), None)),
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
),
),
};
@@ -962,10 +965,7 @@ impl<'a> DOKS<'a> {
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", safe_message.to_string(), e.message()),
Some(safe_message.to_string()),
),
EventMessage::new(safe_message.to_string(), Some(e.message())),
),
);
@@ -1078,7 +1078,7 @@ impl<'a> DOKS<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(format!("{}, error: {}", message_safe, e.message(),), Some(message_safe)),
EventMessage::new(message_safe, Some(e.message())),
),
);
}
@@ -1151,10 +1151,7 @@ impl<'a> DOKS<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", message_safe, e.message(),),
Some(message_safe),
),
EventMessage::new(message_safe, Some(e.message())),
),
)
}
@@ -1250,14 +1247,7 @@ impl<'a> DOKS<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!(
"{}, error: {}",
message_safe,
e.message.unwrap_or("no error message".to_string())
),
Some(message_safe),
),
EventMessage::new(message_safe, e.message),
),
)
}
@@ -1270,10 +1260,7 @@ impl<'a> DOKS<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", message_safe, e.message()),
Some(message_safe.to_string()),
),
EventMessage::new(message_safe.to_string(), Some(e.message())),
),
)
}

41
src/cloud_provider/digitalocean/kubernetes/node.rs
View File

@@ -4,15 +4,24 @@ use core::fmt;
use serde::{Deserialize, Serialize};
use std::str::FromStr;
// flavors helper: https://pcr.cloud-mercato.com/providers/flavors?provider=digitalocean
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum DoInstancesType {
S1vcpu1gb,
S1vcpu2gb,
S1vcpu3gb,
S2vcpu2gb,
S2vcpu4gb,
S3vcpu1gb,
S4vcpu8gb,
S6vcpu16gb,
S8vcpu16gb,
S8vcpu32gb,
S12vcpu48gb,
S16vcpu64gb,
S20vcpu96gb,
S24vcpu128gb,
S32vcpu192gb,
}
impl InstanceType for DoInstancesType {
@@ -21,10 +30,18 @@ impl InstanceType for DoInstancesType {
DoInstancesType::S1vcpu1gb => "s-1vcpu-1gb",
DoInstancesType::S1vcpu2gb => "s-1vcpu-2gb",
DoInstancesType::S1vcpu3gb => "s-1vcpu-3gb",
DoInstancesType::S2vcpu2gb => "s-2vcpu-2gb",
DoInstancesType::S3vcpu1gb => "s-3vcpu-1gb",
DoInstancesType::S2vcpu4gb => "s-2vcpu-4gb",
DoInstancesType::S4vcpu8gb => "s-4vcpu-8gb",
DoInstancesType::S6vcpu16gb => "s-6vcpu-16gb",
DoInstancesType::S8vcpu16gb => "s-8vcpu-16gb",
DoInstancesType::S8vcpu32gb => "s-8vcpu-32gb",
DoInstancesType::S12vcpu48gb => "s-12vcpu-48gb",
DoInstancesType::S16vcpu64gb => "s-16vcpu-64gb",
DoInstancesType::S20vcpu96gb => "s-20vcpu-96gb",
DoInstancesType::S24vcpu128gb => "s-24vcpu-128gb",
DoInstancesType::S32vcpu192gb => "s-32vcpu-192gb",
}
.to_string()
}
@@ -36,10 +53,18 @@ impl DoInstancesType {
DoInstancesType::S1vcpu1gb => "s-1vcpu-1gb",
DoInstancesType::S1vcpu2gb => "s-1vcpu-2gb",
DoInstancesType::S1vcpu3gb => "s-1vcpu-3gb",
DoInstancesType::S2vcpu2gb => "s-2vcpu-2gb",
DoInstancesType::S2vcpu4gb => "s-2vcpu-4gb",
DoInstancesType::S3vcpu1gb => "s-3vcpu-1gb",
DoInstancesType::S4vcpu8gb => "s-4vcpu-8gb",
DoInstancesType::S6vcpu16gb => "s-6vcpu-16gb",
DoInstancesType::S8vcpu16gb => "s-8vcpu-16gb",
DoInstancesType::S8vcpu32gb => "s-8vcpu-32gb",
DoInstancesType::S12vcpu48gb => "s-12vcpu-48gb",
DoInstancesType::S16vcpu64gb => "s-16vcpu-64gb",
DoInstancesType::S20vcpu96gb => "s-20vcpu-96gb",
DoInstancesType::S24vcpu128gb => "s-24vcpu-128gb",
DoInstancesType::S32vcpu192gb => "s-32vcpu-192gb",
}
}
}
@@ -50,10 +75,18 @@ impl fmt::Display for DoInstancesType {
DoInstancesType::S1vcpu1gb => write!(f, "s-1vcpu-1gb"),
DoInstancesType::S1vcpu2gb => write!(f, "s-1vcpu-2gb"),
DoInstancesType::S1vcpu3gb => write!(f, "s-1vcpu-3gb"),
DoInstancesType::S2vcpu2gb => write!(f, "s-2vcpu-2gb"),
DoInstancesType::S2vcpu4gb => write!(f, "s-2vcpu-4gb"),
DoInstancesType::S3vcpu1gb => write!(f, "s-3vcpu-1gb"),
DoInstancesType::S4vcpu8gb => write!(f, "s-4vcpu-8gb"),
DoInstancesType::S6vcpu16gb => write!(f, "s-6vcpu-16gb"),
DoInstancesType::S8vcpu16gb => write!(f, "s-8vcpu-16gb"),
DoInstancesType::S8vcpu32gb => write!(f, "s-8vcpu-32gb"),
DoInstancesType::S12vcpu48gb => write!(f, "s-12vcpu-48gb"),
DoInstancesType::S16vcpu64gb => write!(f, "s-16vcpu-64gb"),
DoInstancesType::S20vcpu96gb => write!(f, "s-20vcpu-96gb"),
DoInstancesType::S24vcpu128gb => write!(f, "s-24vcpu-128gb"),
DoInstancesType::S32vcpu192gb => write!(f, "s-32vcpu-192gb"),
}
}
}
@@ -66,10 +99,18 @@ impl FromStr for DoInstancesType {
"s-1vcpu-1gb" => Ok(DoInstancesType::S1vcpu1gb),
"s-1vcpu-2gb" => Ok(DoInstancesType::S1vcpu2gb),
"s-1vcpu-3gb" => Ok(DoInstancesType::S1vcpu3gb),
"s-2vcpu-2gb" => Ok(DoInstancesType::S2vcpu2gb),
"s-2vcpu-4gb" => Ok(DoInstancesType::S2vcpu4gb),
"s-3vcpu-1gb" => Ok(DoInstancesType::S3vcpu1gb),
"s-4vcpu-8gb" => Ok(DoInstancesType::S4vcpu8gb),
"s-6vcpu-16gb" => Ok(DoInstancesType::S6vcpu16gb),
"s-8vcpu-16gb" => Ok(DoInstancesType::S8vcpu16gb),
"s-8vcpu-32gb" => Ok(DoInstancesType::S8vcpu32gb),
"s-12vcpu-48gb" => Ok(DoInstancesType::S12vcpu48gb),
"s-16vcpu-64gb" => Ok(DoInstancesType::S16vcpu64gb),
"s-20vcpu-96gb" => Ok(DoInstancesType::S20vcpu96gb),
"s-24vcpu-128gb" => Ok(DoInstancesType::S24vcpu128gb),
"s-32vcpu-192gb" => Ok(DoInstancesType::S32vcpu192gb),
_ => {
let message = format!("`{}` instance type is not supported", s);
return Err(CommandError::new(message.clone(), Some(message)));

86
src/cloud_provider/kubernetes.rs
View File

@@ -15,7 +15,7 @@ use retry::OperationResult;
use serde::{Deserialize, Serialize};
use crate::cloud_provider::aws::regions::AwsZones;
use crate::cloud_provider::environment::{Environment, EnvironmentResources};
use crate::cloud_provider::environment::Environment;
use crate::cloud_provider::models::NodeGroups;
use crate::cloud_provider::service::CheckAction;
use crate::cloud_provider::utilities::VersionsNumber;
@@ -384,17 +384,10 @@ pub fn deploy_environment(
},
};
// Resources check before deploy
// TODO(ENG-1066): we should check if env can be deployed or not based on required resources and available ones.
// This check is not trivial since auto-scaler comes to play and resources distribution on nodes might not behave necesarly the way we think.
// do not deploy if there is not enough resources
let resources = kubernetes.resources(environment)?;
let required_resources = environment.required_resources();
if let Err(e) = check_kubernetes_has_enough_resources_to_deploy_environment(
resources,
required_resources,
event_details.clone(),
) {
return Err(e);
}
// create all stateful services (database)
for service in &environment.stateful_services {
@@ -704,38 +697,6 @@ pub fn delete_environment(
Ok(())
}
/// check that there is enough CPU and RAM, and pods resources
/// before starting to deploy stateful and stateless services
pub fn check_kubernetes_has_enough_resources_to_deploy_environment(
resources: Resources,
environment_resources: EnvironmentResources,
event_details: EventDetails,
) -> Result<(), EngineError> {
if (environment_resources.cpu > resources.free_cpu)
|| (environment_resources.ram_in_mib > resources.free_ram_in_mib)
{
// not enough resources CPU or RAM
return Err(EngineError::new_cannot_deploy_not_enough_resources_available(
event_details.clone(),
environment_resources.ram_in_mib,
resources.free_ram_in_mib,
environment_resources.cpu,
resources.free_cpu,
));
}
if environment_resources.pods > resources.free_pods {
// not enough free pods on the cluster
return Err(EngineError::new_cannot_deploy_not_enough_free_pods_available(
event_details,
environment_resources.pods,
resources.free_pods,
));
}
Ok(())
}
pub fn uninstall_cert_manager<P>(
kubernetes_config: P,
envs: Vec<(&str, &str)>,
@@ -764,12 +725,8 @@ where
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!(
"Encountering issues while trying to get objects kind {}: {:?}",
object,
e.message()
),
None,
format!("Encountering issues while trying to get objects kind {}.", object,),
Some(e.message()),
),
),
);
@@ -786,7 +743,10 @@ where
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(format!("Failed to delete all {} objects, retrying...", object,), None),
EventMessage::new_from_safe(format!(
"Failed to delete all {} objects, retrying...",
object,
)),
),
);
OperationResult::Retry(e)
@@ -1039,7 +999,7 @@ fn check_kubernetes_upgrade_status(
if let Some(msg) = x.message {
logger.log(
LogLevel::Info,
EngineEvent::Deploying(event_details.clone(), EventMessage::new(msg, None)),
EngineEvent::Deploying(event_details.clone(), EventMessage::new_from_safe(msg)),
);
};
if x.older_version_detected {
@@ -1067,9 +1027,8 @@ fn check_kubernetes_upgrade_status(
LogLevel::Warning,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new(
EventMessage::new_from_safe(
"No worker nodes found, can't check if upgrade is required for workers".to_string(),
None,
),
),
);
@@ -1120,19 +1079,16 @@ fn check_kubernetes_upgrade_status(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new(
match &required_upgrade_on {
None => "All workers are up to date, no upgrade required".to_string(),
Some(node_type) => match node_type {
KubernetesNodesType::Masters => "Kubernetes master upgrade required".to_string(),
KubernetesNodesType::Workers => format!(
"Kubernetes workers upgrade required, need to update {}/{} nodes",
non_up_to_date_workers, total_workers
),
},
EventMessage::new_from_safe(match &required_upgrade_on {
None => "All workers are up to date, no upgrade required".to_string(),
Some(node_type) => match node_type {
KubernetesNodesType::Masters => "Kubernetes master upgrade required".to_string(),
KubernetesNodesType::Workers => format!(
"Kubernetes workers upgrade required, need to update {}/{} nodes",
non_up_to_date_workers, total_workers
),
},
None,
),
}),
),
);

2
src/cloud_provider/scaleway/kubernetes/helm_charts.rs
View File

@@ -483,7 +483,7 @@ datasources:
},
ChartSetValue {
key: "replicaCount".to_string(),
value: "2".to_string(),
value: "1".to_string(),
},
// https://cert-manager.io/docs/configuration/acme/dns01/#setting-nameservers-for-dns01-self-check
ChartSetValue {

33
src/cloud_provider/scaleway/kubernetes/mod.rs
View File

@@ -677,11 +677,14 @@ impl<'a> Kapsule<'a> {
match kubectl_exec_get_events(kubeconfig_path, None, environment_variables) {
Ok(ok_line) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(event_details.clone(), EventMessage::new(ok_line, None)),
EngineEvent::Deploying(event_details.clone(), EventMessage::new_from_safe(ok_line)),
),
Err(err) => self.logger().log(
LogLevel::Error,
EngineEvent::Deploying(event_details.clone(), EventMessage::new(err.message(), None)),
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
),
),
};
@@ -957,10 +960,7 @@ impl<'a> Kapsule<'a> {
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", safe_message.to_string(), e.message()),
Some(safe_message.to_string()),
),
EventMessage::new(safe_message.to_string(), Some(e.message())),
),
);
skip_kubernetes_step = true;
@@ -1072,7 +1072,7 @@ impl<'a> Kapsule<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(format!("{}, error: {}", message_safe, e.message()), Some(message_safe)),
EventMessage::new(message_safe, Some(e.message())),
),
);
}
@@ -1145,10 +1145,7 @@ impl<'a> Kapsule<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", message_safe, e.message()),
Some(message_safe),
),
EventMessage::new(message_safe, Some(e.message())),
),
)
}
@@ -1244,14 +1241,7 @@ impl<'a> Kapsule<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!(
"{}, error: {}",
message_safe,
e.message.unwrap_or("no error message".to_string())
),
Some(message_safe),
),
EventMessage::new(message_safe, e.message),
),
)
}
@@ -1264,10 +1254,7 @@ impl<'a> Kapsule<'a> {
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!("{}, error: {}", message_safe, e.message()),
Some(message_safe.to_string()),
),
EventMessage::new(message_safe.to_string(), Some(e.message())),
),
)
}

4
src/errors/mod.rs
View File

@@ -529,7 +529,7 @@ impl EngineError {
) -> EngineError {
let mut message = vec!["There is not enough resources on the cluster:".to_string()];
if free_cpu > requested_cpu {
if requested_cpu > free_cpu {
message.push(format!(
"{} CPU requested and only {} CPU available",
free_cpu, requested_cpu
@@ -549,7 +549,7 @@ impl EngineError {
event_details,
Tag::NotEnoughResourcesToDeployEnvironment,
message.to_string(),
message.to_string(),
message,
None,
None,
Some("Consider to add one more node or upgrade your nodes configuration. If not possible, pause or delete unused environments.".to_string()),

8
src/events/io.rs
View File

@@ -81,15 +81,15 @@ impl From<events::EngineEvent> for EngineEvent {
#[derive(Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub struct EventMessage {
raw: String,
safe: Option<String>,
safe_message: String,
full_details: Option<String>,
}
impl From<events::EventMessage> for EventMessage {
fn from(message: events::EventMessage) -> Self {
EventMessage {
raw: message.raw,
safe: message.safe,
safe_message: message.safe_message,
full_details: message.full_details,
}
}
}

112
src/events/mod.rs
View File

@@ -46,27 +46,33 @@ impl EngineEvent {
}
/// Returns engine's event message.
pub fn get_message(&self) -> String {
pub fn message(&self, message_verbosity: EventMessageVerbosity) -> String {
match self {
EngineEvent::Error(engine_error) => engine_error.message(),
EngineEvent::Waiting(_details, message) => message.message(),
EngineEvent::Deploying(_details, message) => message.message(),
EngineEvent::Pausing(_details, message) => message.message(),
EngineEvent::Deleting(_details, message) => message.message(),
EngineEvent::Deployed(_details, message) => message.message(),
EngineEvent::Paused(_details, message) => message.message(),
EngineEvent::Deleted(_details, message) => message.message(),
EngineEvent::Waiting(_details, event_message) => event_message.message(message_verbosity),
EngineEvent::Deploying(_details, event_message) => event_message.message(message_verbosity),
EngineEvent::Pausing(_details, event_message) => event_message.message(message_verbosity),
EngineEvent::Deleting(_details, event_message) => event_message.message(message_verbosity),
EngineEvent::Deployed(_details, event_message) => event_message.message(message_verbosity),
EngineEvent::Paused(_details, event_message) => event_message.message(message_verbosity),
EngineEvent::Deleted(_details, event_message) => event_message.message(message_verbosity),
}
}
}
/// EventMessageVerbosity: represents event message's verbosity from minimal to full verbosity.
pub enum EventMessageVerbosity {
SafeOnly,
FullDetails,
}
#[derive(Debug, Clone)]
/// EventMessage: represents an event message.
pub struct EventMessage {
/// raw: represents a raw event message which may include unsafe elements such as passwords and tokens.
raw: String,
/// safe: represents an event message from which unsafe elements have been removed (passwords and tokens).
safe: Option<String>,
// Message which is known to be safe: doesn't expose any credentials nor touchy info.
safe_message: String,
// String containing full details including touchy data (passwords and tokens).
full_details: Option<String>,
}
impl EventMessage {
@@ -74,40 +80,50 @@ impl EventMessage {
///
/// Arguments
///
/// * `raw`: Event raw message string (which may include unsafe text such as passwords and tokens).
/// * `safe`: Event safe message string (from which all unsafe text such as passwords and tokens has been removed).
pub fn new(raw: String, safe: Option<String>) -> Self {
EventMessage { raw, safe }
/// * `safe_message`: Event safe message string (from which all unsafe text such as passwords and tokens has been removed).
/// * `full_details`: Event raw message string (which may include unsafe text such as passwords and tokens).
pub fn new(safe_message: String, full_details: Option<String>) -> Self {
EventMessage {
safe_message,
full_details,
}
}
/// Creates e new EventMessage from safe message.
///
/// Arguments
///
/// * `safe`: Event safe message string (from which all unsafe text such as passwords and tokens has been removed).
pub fn new_from_safe(safe: String) -> Self {
/// * `safe_message`: Event safe message string (from which all unsafe text such as passwords and tokens has been removed).
pub fn new_from_safe(safe_message: String) -> Self {
EventMessage {
raw: safe.to_string(),
safe: Some(safe),
safe_message,
full_details: None,
}
}
/// Returns message for event message.
pub fn message(&self) -> String {
if let Some(msg) = &self.safe {
return format!("{} {}", msg.clone(), self.raw.clone());
///
/// Arguments
///
/// * `message_verbosity`: Which verbosity is required for the message.
pub fn message(&self, message_verbosity: EventMessageVerbosity) -> String {
match message_verbosity {
EventMessageVerbosity::SafeOnly => self.safe_message.to_string(),
EventMessageVerbosity::FullDetails => match &self.full_details {
None => self.safe_message.to_string(),
Some(details) => format!(
"{} / Full details: {}",
self.safe_message.to_string(),
details.to_string()
),
},
}
self.raw.clone()
}
}
impl Display for EventMessage {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.write_str(match &self.safe {
Some(safe) => safe,
None => &self.raw,
})
f.write_str(self.message(EventMessageVerbosity::SafeOnly).as_str()) // By default, expose only the safe message.
}
}
@@ -408,23 +424,45 @@ impl EventDetails {
#[cfg(test)]
mod tests {
use crate::events::{EnvironmentStep, EventMessage, InfrastructureStep, Stage};
use crate::events::{EnvironmentStep, EventMessage, EventMessageVerbosity, InfrastructureStep, Stage};
#[test]
fn test_event_message_get_message() {
fn test_event_message() {
// setup:
let test_cases: Vec<(Option<String>, String, String)> = vec![
(None, "raw".to_string(), "raw".to_string()),
(Some("safe".to_string()), "raw".to_string(), "safe raw".to_string()),
let test_cases: Vec<(String, Option<String>, EventMessageVerbosity, String)> = vec![
(
"safe".to_string(),
Some("raw".to_string()),
EventMessageVerbosity::SafeOnly,
"safe".to_string(),
),
(
"safe".to_string(),
None,
EventMessageVerbosity::SafeOnly,
"safe".to_string(),
),
(
"safe".to_string(),
None,
EventMessageVerbosity::FullDetails,
"safe".to_string(),
),
(
"safe".to_string(),
Some("raw".to_string()),
EventMessageVerbosity::FullDetails,
"safe / Full details: raw".to_string(),
),
];
for tc in test_cases {
// execute:
let (safe_message, raw_message, expected) = tc;
let event_message = EventMessage::new(raw_message, safe_message);
let (safe_message, raw_message, verbosity, expected) = tc;
let event_message = EventMessage::new(safe_message, raw_message);
// validate:
assert_eq!(expected, event_message.message());
assert_eq!(expected, event_message.message(verbosity));
}
}

32
src/logger.rs
View File

@@ -1,4 +1,4 @@
use crate::events::EngineEvent;
use crate::events::{EngineEvent, EventMessageVerbosity};
use tracing;
#[derive(Debug, Clone)]
@@ -40,13 +40,14 @@ impl Logger for StdIoLogger {
fn log(&self, log_level: LogLevel, event: EngineEvent) {
let event_details = event.get_details();
let stage = event_details.stage();
let execution_id = event_details.execution_id().to_string();
tracing::span!(
tracing::Level::INFO,
"std_io_logger",
organization_id = event_details.organisation_id().short(),
cluster_id = event_details.cluster_id().short(),
execution_id = event_details.execution_id().short(),
execution_id = execution_id.as_str(),
provider = match event_details.provider_kind() {
Some(kind) => kind.to_string(),
None => "".to_string(),
@@ -63,10 +64,10 @@ impl Logger for StdIoLogger {
)
.in_scope(|| {
match log_level {
LogLevel::Debug => debug!("{}", event.get_message()),
LogLevel::Info => info!("{}", event.get_message()),
LogLevel::Warning => warn!("{}", event.get_message()),
LogLevel::Error => error!("{}", event.get_message()),
LogLevel::Debug => debug!("{}", event.message(EventMessageVerbosity::FullDetails)),
LogLevel::Info => info!("{}", event.message(EventMessageVerbosity::FullDetails)),
LogLevel::Warning => warn!("{}", event.message(EventMessageVerbosity::FullDetails)),
LogLevel::Error => error!("{}", event.message(EventMessageVerbosity::FullDetails)),
};
});
}
@@ -107,8 +108,8 @@ mod tests {
let app_name = format!("simple-app-{}", app_id);
let qovery_message = "Qovery message";
let user_message = "User message";
let safe_message = "Safe message";
let raw_message = "Raw message";
let raw_message_safe = "Raw message safe";
let link = Url::parse("https://qovery.com").expect("cannot parse Url");
let hint = "An hint !";
@@ -128,8 +129,8 @@ mod tests {
qovery_message.to_string(),
user_message.to_string(),
Some(errors::CommandError::new(
raw_message.to_string(),
Some(raw_message_safe.to_string()),
safe_message.to_string(),
Some(raw_message.to_string()),
)),
Some(link.clone()),
Some(hint.to_string()),
@@ -148,7 +149,7 @@ mod tests {
Stage::Infrastructure(InfrastructureStep::Create),
Transmitter::Kubernetes(cluster_id.to_string(), cluster_name.to_string()),
),
EventMessage::new(raw_message.to_string(), Some(raw_message_safe.to_string())),
EventMessage::new(raw_message.to_string(), Some(safe_message.to_string())),
),
description: "Deploying info event",
},
@@ -164,7 +165,7 @@ mod tests {
Stage::Environment(EnvironmentStep::Pause),
Transmitter::Application(app_id.to_string(), app_name.to_string()),
),
EventMessage::new(raw_message.to_string(), Some(raw_message_safe.to_string())),
EventMessage::new(raw_message.to_string(), Some(safe_message.to_string())),
),
description: "Pausing application debug event",
},
@@ -180,7 +181,7 @@ mod tests {
Stage::Environment(EnvironmentStep::Delete),
Transmitter::Application(app_id.to_string(), app_name.to_string()),
),
EventMessage::new(raw_message.to_string(), Some(raw_message_safe.to_string())),
EventMessage::new(raw_message.to_string(), Some(safe_message.to_string())),
),
description: "Deleting application warning event",
},
@@ -215,7 +216,7 @@ mod tests {
tc.description
);
assert!(
logs_contain(format!("execution_id=\"{}\"", execution_id.short()).as_str()),
logs_contain(format!("execution_id=\"{}\"", execution_id.to_string()).as_str()),
"{}",
tc.description
);
@@ -267,8 +268,9 @@ mod tests {
tc.description
);
let message = tc.event.get_message().to_string();
assert!(logs_contain(&message), "{}", tc.description);
// Logger should display everything
assert!(logs_contain(safe_message), "{}", tc.description);
assert!(logs_contain(raw_message), "{}", tc.description);
}
}
}