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

refactor: remove deprecated log param (#665)

Browse Source
This commit is contained in:
BenjaminCh
2022-03-25 16:37:13 +01:00
committed by GitHub
parent 69b9d9d50c
commit a46a7e42f6
14 changed files with 910 additions and 1588 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
src/build_platform/local_docker.rs
View File

@@ -17,7 +17,7 @@ use crate::cmd::docker::{ContainerImage, Docker, DockerError};
use crate::events::{EngineEvent, EventDetails, EventMessage, ToTransmitter, Transmitter};
use crate::fs::workspace_directory;
use crate::git;
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{
Context, Listen, Listener, Listeners, ListenersHelper, ProgressInfo, ProgressLevel, ProgressScope,
};
@@ -62,15 +62,10 @@ impl LocalDocker {
fn reclaim_space_if_needed(&self) {
if env::var_os("CI").is_some() {
self.logger.log(
LogLevel::Info,
EngineEvent::Info(
self.get_event_details(),
EventMessage::new_from_safe(
"CI environment variable found, no docker prune will be made".to_string(),
),
),
);
self.logger.log(EngineEvent::Info(
self.get_event_details(),
EventMessage::new_from_safe("CI environment variable found, no docker prune will be made".to_string()),
));
return;
}
@@ -92,10 +87,10 @@ impl LocalDocker {
event_details.clone(),
&*self.logger(),
) {
self.logger.log(
LogLevel::Warning,
EngineEvent::Warning(event_details, EventMessage::new(e.to_string(), Some(e.to_string()))),
);
self.logger.log(EngineEvent::Warning(
event_details,
EventMessage::new(e.to_string(), Some(e.to_string())),
));
}
break;
};
@@ -114,10 +109,10 @@ impl LocalDocker {
let log_info = {
let app_id = build.image.application_id.clone();
move |msg: String| {
self.logger.log(
LogLevel::Info,
EngineEvent::Info(self.get_event_details(), EventMessage::new_from_safe(msg.clone())),
);
self.logger.log(EngineEvent::Info(
self.get_event_details(),
EventMessage::new_from_safe(msg.clone()),
));
lh.deployment_in_progress(ProgressInfo::new(
ProgressScope::Application { id: app_id.clone() },
@@ -276,10 +271,10 @@ impl LocalDocker {
let cmd_killer = CommandKiller::from(Duration::from_secs(BUILD_DURATION_TIMEOUT_SEC), is_task_canceled);
exit_status = cmd.exec_with_abort(
&mut |line| {
self.logger.log(
LogLevel::Info,
EngineEvent::Info(self.get_event_details(), EventMessage::new_from_safe(line.to_string())),
);
self.logger.log(EngineEvent::Info(
self.get_event_details(),
EventMessage::new_from_safe(line.to_string()),
));
lh.deployment_in_progress(ProgressInfo::new(
ProgressScope::Application {
@@ -291,10 +286,10 @@ impl LocalDocker {
));
},
&mut |line| {
self.logger.log(
LogLevel::Warning,
EngineEvent::Warning(self.get_event_details(), EventMessage::new_from_safe(line.to_string())),
);
self.logger.log(EngineEvent::Warning(
self.get_event_details(),
EventMessage::new_from_safe(line.to_string()),
));
lh.deployment_in_progress(ProgressInfo::new(
ProgressScope::Application {
@@ -376,10 +371,8 @@ impl BuildPlatform for LocalDocker {
Some(msg.clone()),
self.context.execution_id(),
));
self.logger.log(
LogLevel::Info,
EngineEvent::Info(event_details, EventMessage::new_from_safe(msg)),
);
self.logger
.log(EngineEvent::Info(event_details, EventMessage::new_from_safe(msg)));
// LOGGING
// Create callback that will be called by git to provide credentials per user
@@ -524,32 +517,26 @@ fn check_docker_space_usage_and_clean(
let docker_percentage_remaining = available_space * 100 / docker_path_size_info.get_total_space();
if docker_percentage_remaining < docker_max_disk_percentage_usage_before_purge || available_space == 0 {
logger.log(
LogLevel::Warning,
EngineEvent::Warning(
event_details,
EventMessage::new_from_safe(format!(
"Docker disk remaining ({}%) is lower than {}%, requesting cleaning (purge)",
docker_percentage_remaining, docker_max_disk_percentage_usage_before_purge
)),
),
);
logger.log(EngineEvent::Warning(
event_details,
EventMessage::new_from_safe(format!(
"Docker disk remaining ({}%) is lower than {}%, requesting cleaning (purge)",
docker_percentage_remaining, docker_max_disk_percentage_usage_before_purge
)),
));
return docker.prune_images();
};
logger.log(
LogLevel::Info,
EngineEvent::Info(
event_details,
EventMessage::new_from_safe(format!(
"No need to purge old docker images, only {}% ({}/{}) disk used",
100 - docker_percentage_remaining,
docker_path_size_info.get_available_space(),
docker_path_size_info.get_total_space(),
)),
),
);
logger.log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe(format!(
"No need to purge old docker images, only {}% ({}/{}) disk used",
100 - docker_percentage_remaining,
docker_path_size_info.get_available_space(),
docker_path_size_info.get_total_space(),
)),
));
Ok(())
}

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

@@ -38,7 +38,7 @@ use crate::dns_provider::DnsProvider;
use crate::errors::{CommandError, EngineError};
use crate::events::Stage::Infrastructure;
use crate::events::{EngineEvent, EnvironmentStep, EventDetails, EventMessage, InfrastructureStep, Stage, Transmitter};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{
Action, Context, Features, Listen, Listener, Listeners, ListenersHelper, QoveryIdentifier, ToHelmString,
ToTerraformString,
@@ -184,7 +184,7 @@ impl EKS {
let err =
EngineError::new_unsupported_instance_type(event_details, node_group.instance_type.as_str(), e);
logger.log(LogLevel::Error, EngineEvent::Error(err.clone(), None));
logger.log(EngineEvent::Error(err.clone(), None));
return Err(err);
}
@@ -273,13 +273,10 @@ impl EKS {
event_details: EventDetails,
replicas_count: u32,
) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(format!("Scaling cluster autoscaler to `{}`.", replicas_count)),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Scaling cluster autoscaler to `{}`.", replicas_count)),
));
let (kubeconfig_path, _) = self.get_kubeconfig_file()?;
let selector = "cluster-autoscaler-aws-cluster-autoscaler";
let namespace = "kube-system";
@@ -443,16 +440,13 @@ impl EKS {
match env::var_os("VAULT_SECRET_ID") {
Some(secret_id) => context.insert("vault_secret_id", secret_id.to_str().unwrap()),
None => self.logger().log(
LogLevel::Error,
EngineEvent::Error(
EngineError::new_missing_required_env_variable(
event_details,
"VAULT_SECRET_ID".to_string(),
),
None,
None => self.logger().log(EngineEvent::Error(
EngineError::new_missing_required_env_variable(
event_details,
"VAULT_SECRET_ID".to_string(),
),
),
None,
)),
}
}
None => {
@@ -557,13 +551,10 @@ impl EKS {
let event_details = self.get_event_details(Stage::Infrastructure(InfrastructureStep::Create));
let listeners_helper = ListenersHelper::new(&self.listeners);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing EKS cluster deployment.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing EKS cluster deployment.".to_string()),
));
self.send_to_customer(
format!("Preparing EKS {} cluster deployment with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
@@ -583,28 +574,18 @@ impl EKS {
return self.upgrade_with_status(x);
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes cluster upgrade not required".to_string()),
),
)
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes cluster upgrade not required".to_string()),
))
}
Err(e) => {
self.logger().log(LogLevel::Error, EngineEvent::Error(e, None));
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"Error detected, upgrade won't occurs, but standard deployment.".to_string(),
),
),
);
self.logger().log(EngineEvent::Error(e, Some(EventMessage::new_from_safe(
"Error detected, upgrade won't occurs, but standard deployment.".to_string(),
))));
}
},
Err(_) => self.logger().log(LogLevel::Info, EngineEvent::Deploying(event_details.clone(), EventMessage::new_from_safe("Kubernetes cluster upgrade not required, config file is not found and cluster have certainly never been deployed before".to_string())))
Err(_) => self.logger().log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe("Kubernetes cluster upgrade not required, config file is not found and cluster have certainly never been deployed before".to_string())))
};
@@ -615,23 +596,17 @@ impl EKS {
self.cloud_provider.access_key_id().as_str(),
self.cloud_provider.secret_access_key().as_str(),
) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Role {} is already present, no need to create",
role.role_name
)),
),
),
Err(e) => self.logger().log(
LogLevel::Error,
EngineEvent::Error(
EngineError::new_cannot_get_or_create_iam_role(event_details.clone(), role.role_name, e),
None,
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Role {} is already present, no need to create",
role.role_name
)),
)),
Err(e) => self.logger().log(EngineEvent::Error(
EngineError::new_cannot_get_or_create_iam_role(event_details.clone(), role.role_name, e),
None,
)),
}
}
@@ -667,13 +642,10 @@ impl EKS {
));
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Deploying EKS cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deploying EKS cluster.".to_string()),
));
self.send_to_customer(
format!("Deploying EKS {} cluster deployment with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
@@ -687,13 +659,10 @@ impl EKS {
for entry in x.clone() {
if entry.starts_with(item) {
match terraform_exec(temp_dir.as_str(), vec!["state", "rm", &entry]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(format!("successfully removed {}", &entry)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("successfully removed {}", &entry)),
)),
Err(e) => {
return Err(EngineError::new_terraform_cannot_remove_entry_out(
event_details,
@@ -706,10 +675,10 @@ impl EKS {
}
}
}
Err(e) => self.logger().log(
LogLevel::Warning,
EngineEvent::Error(EngineError::new_terraform_state_does_not_exist(event_details.clone(), e), None),
),
Err(e) => self.logger().log(EngineEvent::Error(
EngineError::new_terraform_state_does_not_exist(event_details.clone(), e),
None,
)),
};
// terraform deployment dedicated to cloud resources
@@ -756,13 +725,10 @@ impl EKS {
disable_pleco: self.context.disable_pleco(),
};
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing chart configuration to be deployed".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing chart configuration to be deployed".to_string()),
));
let helm_charts_to_deploy = aws_helm_charts(
format!("{}/qovery-tf-config.json", &temp_dir).as_str(),
&charts_prerequisites,
@@ -786,39 +752,29 @@ impl EKS {
let (kubeconfig_path, _) = self.get_kubeconfig_file()?;
let environment_variables: Vec<(&str, &str)> = self.cloud_provider.credentials_environment_variables();
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Create)),
EventMessage::new_from_safe("EKS.create_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Create)),
EventMessage::new_from_safe("EKS.create_error() called.".to_string()),
));
match kubectl_exec_get_events(kubeconfig_path, None, environment_variables) {
Ok(ok_line) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(event_details, EventMessage::new(ok_line, None)),
),
Err(err) => self.logger().log(
LogLevel::Error,
EngineEvent::Deploying(
event_details,
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
),
),
Ok(ok_line) => self
.logger()
.log(EngineEvent::Info(event_details, EventMessage::new(ok_line, None))),
Err(err) => self.logger().log(EngineEvent::Warning(
event_details,
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
)),
};
Ok(())
}
fn upgrade_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Upgrade)),
EventMessage::new_from_safe("EKS.upgrade_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Upgrade)),
EventMessage::new_from_safe("EKS.upgrade_error() called.".to_string()),
));
Ok(())
}
@@ -828,13 +784,10 @@ impl EKS {
}
fn downgrade_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Downgrade)),
EventMessage::new_from_safe("EKS.downgrade_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Downgrade)),
EventMessage::new_from_safe("EKS.downgrade_error() called.".to_string()),
));
Ok(())
}
@@ -848,13 +801,10 @@ impl EKS {
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Pausing(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("Preparing EKS cluster pause.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("Preparing EKS cluster pause.".to_string()),
));
let temp_dir = self.get_temp_dir(event_details.clone())?;
@@ -906,8 +856,7 @@ impl EKS {
}
Err(e) => {
let error = EngineError::new_terraform_state_does_not_exist(event_details, e);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
};
@@ -960,7 +909,7 @@ impl EKS {
match wait_engine_job_finish {
Ok(_) => {
self.logger().log(LogLevel::Info, EngineEvent::Pausing(event_details.clone(), EventMessage::new_from_safe("No current running jobs on the Engine, infrastructure pause is allowed to start".to_string())));
self.logger().log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe("No current running jobs on the Engine, infrastructure pause is allowed to start".to_string())));
}
Err(Operation { error, .. }) => {
return Err(error)
@@ -970,7 +919,7 @@ impl EKS {
}
}
}
false => self.logger().log(LogLevel::Warning, EngineEvent::Pausing(event_details.clone(), EventMessage::new_from_safe("The Engines are running Client side, but metric history flag is disabled. You will encounter issues during cluster lifecycles if you do not enable metric history".to_string()))),
false => self.logger().log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe("Engines are running Client side, but metric history flag is disabled. You will encounter issues during cluster lifecycles if you do not enable metric history".to_string()))),
}
}
@@ -984,22 +933,17 @@ impl EKS {
format!("Pausing EKS {} cluster deployment with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Pausing(
event_details.clone(),
EventMessage::new_from_safe("Pausing EKS cluster deployment.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Pausing EKS cluster deployment.".to_string()),
));
match terraform_exec(temp_dir.as_str(), terraform_args) {
Ok(_) => {
let message = format!("Kubernetes cluster {} successfully paused", self.name());
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Pausing(event_details, EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details, EventMessage::new_from_safe(message)));
Ok(())
}
Err(e) => Err(EngineError::new_terraform_error_while_executing_pipeline(event_details, e)),
@@ -1007,13 +951,10 @@ impl EKS {
}
fn pause_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Pausing(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("EKS.pause_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("EKS.pause_error() called.".to_string()),
));
Ok(())
}
@@ -1027,13 +968,10 @@ impl EKS {
format!("Preparing to delete EKS cluster {} with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Preparing to delete EKS cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing to delete EKS cluster.".to_string()),
));
let temp_dir = self.get_temp_dir(event_details.clone())?;
@@ -1071,13 +1009,10 @@ impl EKS {
Ok(x) => x,
Err(e) => {
let safe_message = "Skipping Kubernetes uninstall because it can't be reached.";
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(safe_message.to_string(), Some(e.message())),
),
);
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(safe_message.to_string(), Some(e.message())),
));
skip_kubernetes_step = true;
"".to_string()
@@ -1092,27 +1027,19 @@ impl EKS {
self.id()
);
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform apply before running a delete.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform apply before running a delete.".to_string()),
));
if let Err(e) = cmd::terraform::terraform_init_validate_plan_apply(temp_dir.as_str(), false) {
// An issue occurred during the apply before destroy of Terraform, it may be expected if you're resuming a destroy
self.logger().log(
LogLevel::Error,
EngineEvent::Error(
EngineError::new_terraform_error_while_executing_pipeline(event_details.clone(), e),
None,
),
);
self.logger().log(EngineEvent::Error(
EngineError::new_terraform_error_while_executing_pipeline(event_details.clone(), e),
None,
));
};
if !skip_kubernetes_step {
@@ -1122,10 +1049,10 @@ impl EKS {
self.name(),
self.id()
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message.to_string())),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(message.to_string()),
));
self.send_to_customer(&message, &listeners_helper);
let all_namespaces = kubectl_exec_get_all_namespaces(
@@ -1138,13 +1065,10 @@ impl EKS {
let namespaces_as_str = namespace_vec.iter().map(std::ops::Deref::deref).collect();
let namespaces_to_delete = get_firsts_namespaces_to_delete(namespaces_as_str);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting non Qovery namespaces".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting non Qovery namespaces".to_string()),
));
for namespace_to_delete in namespaces_to_delete.iter() {
match cmd::kubectl::kubectl_exec_delete_namespace(
@@ -1152,28 +1076,22 @@ impl EKS {
namespace_to_delete,
self.cloud_provider().credentials_environment_variables(),
) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Namespace `{}` deleted successfully.",
namespace_to_delete
)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Namespace `{}` deleted successfully.",
namespace_to_delete
)),
)),
Err(e) => {
if !(e.message().contains("not found")) {
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete the namespace `{}`",
namespace_to_delete
)),
),
);
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete the namespace `{}`",
namespace_to_delete
)),
));
}
}
}
@@ -1184,13 +1102,10 @@ impl EKS {
"Error while getting all namespaces for Kubernetes cluster {}",
self.name_with_id(),
);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.message())),
),
);
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.message())),
));
}
}
@@ -1200,10 +1115,8 @@ impl EKS {
self.id()
);
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
// delete custom metrics api to avoid stale namespaces on deletion
let helm = Helm::new(
@@ -1223,13 +1136,10 @@ impl EKS {
self.logger(),
)?;
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed helm charts".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed helm charts".to_string()),
));
let qovery_namespaces = get_qovery_managed_namespaces();
for qovery_namespace in qovery_namespaces.iter() {
@@ -1240,34 +1150,25 @@ impl EKS {
for chart in charts_to_delete {
let chart_info = ChartInfo::new_from_release_name(&chart.name, &chart.namespace);
match helm.uninstall(&chart_info, &[]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
)),
Err(e) => {
let message_safe = format!("Can't delete chart `{}`: {}", &chart.name, e);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
))
}
}
}
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed namespaces".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed namespaces".to_string()),
));
for qovery_namespace in qovery_namespaces.iter() {
let deletion = cmd::kubectl::kubectl_exec_delete_namespace(
@@ -1276,90 +1177,64 @@ impl EKS {
self.cloud_provider().credentials_environment_variables(),
);
match deletion {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Namespace {} is fully deleted", qovery_namespace)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Namespace {} is fully deleted", qovery_namespace)),
)),
Err(e) => {
if !(e.message().contains("not found")) {
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete namespace {}.",
qovery_namespace
)),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(format!("Can't delete namespace {}.", qovery_namespace)),
))
}
}
}
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Delete all remaining deployed helm applications".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Delete all remaining deployed helm applications".to_string()),
));
match helm.list_release(None, &[]) {
Ok(helm_charts) => {
for chart in helm_charts {
let chart_info = ChartInfo::new_from_release_name(&chart.name, &chart.namespace);
match helm.uninstall(&chart_info, &[]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
)),
Err(e) => {
let message_safe = format!("Error deleting chart `{}`: {}", chart.name, e);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
))
}
}
}
}
Err(e) => {
let message_safe = "Unable to get helm list";
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe.to_string(), Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe.to_string(), Some(e.to_string())),
))
}
}
};
let message = format!("Deleting Kubernetes cluster {}/{}", self.name(), self.id());
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform destroy".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform destroy".to_string()),
));
match retry::retry(Fibonacci::from_millis(60000).take(3), || {
match cmd::terraform::terraform_init_validate_destroy(temp_dir.as_str(), false) {
@@ -1372,13 +1247,10 @@ impl EKS {
format!("Kubernetes cluster {}/{} successfully deleted", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details,
EventMessage::new_from_safe("Kubernetes cluster successfully deleted".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe("Kubernetes cluster successfully deleted".to_string()),
));
Ok(())
}
Err(Operation { error, .. }) => Err(EngineError::new_terraform_error_while_executing_destroy_pipeline(
@@ -1393,13 +1265,10 @@ impl EKS {
}
fn delete_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Delete)),
EventMessage::new_from_safe("EKS.delete_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Delete)),
EventMessage::new_from_safe("EKS.delete_error() called.".to_string()),
));
Ok(())
}
@@ -1507,13 +1376,10 @@ impl Kubernetes for EKS {
.as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Start preparing EKS cluster upgrade process".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Start preparing EKS cluster upgrade process".to_string()),
));
let temp_dir = self.get_temp_dir(event_details.clone())?;
@@ -1529,13 +1395,10 @@ impl Kubernetes for EKS {
format!("Start upgrading process for master nodes on {}/{}", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Start upgrading process for master nodes.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Start upgrading process for master nodes.".to_string()),
));
// AWS requires the upgrade to be done in 2 steps (masters, then workers)
// use the current kubernetes masters' version for workers, in order to avoid migration in one step
@@ -1580,13 +1443,10 @@ impl Kubernetes for EKS {
format!("Upgrading Kubernetes {} master nodes", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Upgrading Kubernetes master nodes.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Upgrading Kubernetes master nodes.".to_string()),
));
match terraform_init_validate_plan_apply(temp_dir.as_str(), self.context.is_dry_run_deploy()) {
Ok(_) => {
@@ -1594,15 +1454,12 @@ impl Kubernetes for EKS {
format!("Kubernetes {} master nodes have been successfully upgraded", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"Kubernetes master nodes have been successfully upgraded.".to_string(),
),
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(
"Kubernetes master nodes have been successfully upgraded.".to_string(),
),
);
));
}
Err(e) => {
return Err(EngineError::new_terraform_error_while_executing_pipeline(event_details, e));
@@ -1610,26 +1467,20 @@ impl Kubernetes for EKS {
}
}
Some(KubernetesNodesType::Workers) => {
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"No need to perform Kubernetes master upgrade, they are already up to date.".to_string(),
),
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(
"No need to perform Kubernetes master upgrade, they are already up to date.".to_string(),
),
);
));
}
None => {
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details,
EventMessage::new_from_safe(
"No Kubernetes upgrade required, masters and workers are already up to date.".to_string(),
),
self.logger().log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe(
"No Kubernetes upgrade required, masters and workers are already up to date.".to_string(),
),
);
));
return Ok(());
}
}
@@ -1641,7 +1492,7 @@ impl Kubernetes for EKS {
self.cloud_provider().credentials_environment_variables(),
Stage::Infrastructure(InfrastructureStep::Upgrade),
) {
self.logger().log(LogLevel::Error, EngineEvent::Error(e.clone(), None));
self.logger().log(EngineEvent::Error(e.clone(), None));
return Err(e);
}
@@ -1652,13 +1503,10 @@ impl Kubernetes for EKS {
format!("Preparing workers nodes for upgrade for Kubernetes cluster {}", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing workers nodes for upgrade for Kubernetes cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing workers nodes for upgrade for Kubernetes cluster.".to_string()),
));
// disable cluster autoscaler to avoid interfering with AWS upgrade procedure
context.insert("enable_cluster_autoscaler", &false);
@@ -1699,13 +1547,10 @@ impl Kubernetes for EKS {
format!("Upgrading Kubernetes {} worker nodes", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Upgrading Kubernetes worker nodes.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Upgrading Kubernetes worker nodes.".to_string()),
));
// Disable cluster autoscaler deployment
let _ = self.set_cluster_autoscaler_replicas(event_details.clone(), 0)?;
@@ -1716,15 +1561,12 @@ impl Kubernetes for EKS {
format!("Kubernetes {} workers nodes have been successfully upgraded", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"Kubernetes workers nodes have been successfully upgraded.".to_string(),
),
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(
"Kubernetes workers nodes have been successfully upgraded.".to_string(),
),
);
));
}
Err(e) => {
// enable cluster autoscaler deployment

45
src/cloud_provider/aws/router.rs
View File

@@ -12,7 +12,7 @@ use crate::cmd::helm;
use crate::cmd::helm::{to_engine_error, Timeout};
use crate::errors::EngineError;
use crate::events::{EngineEvent, EnvironmentStep, EventMessage, Stage, ToTransmitter, Transmitter};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{Context, Listen, Listener, Listeners};
use ::function_name::named;
@@ -192,27 +192,21 @@ impl Service for RouterAws {
Some(hostname) => context.insert("external_ingress_hostname_default", hostname.as_str()),
None => {
// TODO(benjaminch): Handle better this one via a proper error eventually
self.logger().log(
LogLevel::Warning,
EngineEvent::Warning(
event_details,
EventMessage::new_from_safe(
"Error while trying to get Load Balancer hostname from Kubernetes cluster".to_string(),
),
self.logger().log(EngineEvent::Warning(
event_details,
EventMessage::new_from_safe(
"Error while trying to get Load Balancer hostname from Kubernetes cluster".to_string(),
),
);
));
}
},
_ => {
// FIXME really?
// TODO(benjaminch): Handle better this one via a proper error eventually
self.logger().log(
LogLevel::Warning,
EngineEvent::Warning(
event_details,
EventMessage::new_from_safe("Can't fetch external ingress hostname.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
event_details,
EventMessage::new_from_safe("Can't fetch external ingress hostname.".to_string()),
));
}
}
@@ -386,19 +380,16 @@ impl Create for RouterAws {
}
Ok(err) | Err(err) => {
// TODO(benjaminch): Handle better this one via a proper error eventually
self.logger().log(
LogLevel::Warning,
EngineEvent::Warning(
event_details.clone(),
EventMessage::new(
format!(
"Invalid CNAME for {}. Might not be an issue if user is using a CDN.",
domain_to_check.domain,
),
Some(err.to_string()),
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(
format!(
"Invalid CNAME for {}. Might not be an issue if user is using a CDN.",
domain_to_check.domain,
),
Some(err.to_string()),
),
);
));
}
}
}

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

@@ -40,7 +40,7 @@ use crate::events::Stage::Infrastructure;
use crate::events::{
EngineEvent, EnvironmentStep, EventDetails, EventMessage, GeneralStep, InfrastructureStep, Stage, Transmitter,
};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{
Action, Context, Features, Listen, Listener, Listeners, ListenersHelper, ProgressInfo, ProgressLevel,
ProgressScope, QoveryIdentifier, StringPath, ToHelmString,
@@ -140,7 +140,7 @@ impl DOKS {
e,
);
logger.log(LogLevel::Error, EngineEvent::Error(err.clone(), None));
logger.log(EngineEvent::Error(err.clone(), None));
return Err(err);
}
@@ -356,16 +356,13 @@ impl DOKS {
match env::var_os("VAULT_SECRET_ID") {
Some(secret_id) => context.insert("vault_secret_id", secret_id.to_str().unwrap()),
None => self.logger().log(
LogLevel::Error,
EngineEvent::Error(
EngineError::new_missing_required_env_variable(
event_details,
"VAULT_SECRET_ID".to_string(),
),
None,
None => self.logger().log(EngineEvent::Error(
EngineError::new_missing_required_env_variable(
event_details,
"VAULT_SECRET_ID".to_string(),
),
),
None,
)),
}
}
None => {
@@ -463,13 +460,10 @@ impl DOKS {
)),
self.context.execution_id(),
));
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing DOKS cluster deployment.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing DOKS cluster deployment.".to_string()),
));
// upgrade cluster instead if required
match self.get_kubeconfig_file() {
@@ -485,28 +479,22 @@ impl DOKS {
return self.upgrade_with_status(x);
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes cluster upgrade not required".to_string()),
),
)
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes cluster upgrade not required".to_string()),
))
}
Err(e) => {
self.logger().log(LogLevel::Error, EngineEvent::Error(e, None));
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"Error detected, upgrade won't occurs, but standard deployment.".to_string(),
),
self.logger().log(EngineEvent::Error(e, None));
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(
"Error detected, upgrade won't occurs, but standard deployment.".to_string(),
),
);
));
}
},
Err(_) => self.logger().log(LogLevel::Info, EngineEvent::Deploying(event_details.clone(), EventMessage::new_from_safe("Kubernetes cluster upgrade not required, config file is not found and cluster have certainly never been deployed before".to_string())))
Err(_) => self.logger().log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe("Kubernetes cluster upgrade not required, config file is not found and cluster have certainly never been deployed before".to_string())))
};
@@ -542,13 +530,10 @@ impl DOKS {
));
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Deploying DOKS cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deploying DOKS cluster.".to_string()),
));
self.send_to_customer(
format!("Deploying DOKS {} cluster deployment with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
@@ -562,13 +547,10 @@ impl DOKS {
for entry in x.clone() {
if entry.starts_with(item) {
match terraform_exec(temp_dir.as_str(), vec!["state", "rm", &entry]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(format!("successfully removed {}", &entry)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("successfully removed {}", &entry)),
)),
Err(e) => {
return Err(EngineError::new_terraform_cannot_remove_entry_out(
event_details,
@@ -581,18 +563,17 @@ impl DOKS {
}
}
}
Err(e) => self.logger().log(
LogLevel::Warning,
EngineEvent::Error(EngineError::new_terraform_state_does_not_exist(event_details.clone(), e), None),
),
Err(e) => self.logger().log(EngineEvent::Error(
EngineError::new_terraform_state_does_not_exist(event_details.clone(), e),
None,
)),
};
// Logs bucket
if let Err(e) = self.spaces.create_bucket(self.logs_bucket_name().as_str()) {
let error =
EngineError::new_object_storage_cannot_create_bucket_error(event_details, self.logs_bucket_name(), e);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
@@ -610,13 +591,10 @@ impl DOKS {
format!("Kubernetes {} nodes have been successfully created", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes nodes have been successfully created".to_string()),
),
)
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes nodes have been successfully created".to_string()),
))
}
Err(e) => {
return Err(EngineError::new_k8s_node_not_ready(event_details, e));
@@ -668,13 +646,10 @@ impl DOKS {
let chart_prefix_path = &temp_dir;
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing chart configuration to be deployed".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing chart configuration to be deployed".to_string()),
));
let helm_charts_to_deploy = do_helm_charts(
format!("{}/qovery-tf-config.json", &temp_dir).as_str(),
&charts_prerequisites,
@@ -761,39 +736,29 @@ impl DOKS {
let (kubeconfig_path, _) = self.get_kubeconfig_file()?;
let environment_variables: Vec<(&str, &str)> = self.cloud_provider.credentials_environment_variables();
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Create)),
EventMessage::new_from_safe("DOKS.create_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Create)),
EventMessage::new_from_safe("DOKS.create_error() called.".to_string()),
));
match kubectl_exec_get_events(kubeconfig_path, None, environment_variables) {
Ok(ok_line) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(event_details, EventMessage::new(ok_line, None)),
),
Err(err) => self.logger().log(
LogLevel::Error,
EngineEvent::Deploying(
event_details,
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
),
),
Ok(ok_line) => self
.logger()
.log(EngineEvent::Warning(event_details, EventMessage::new(ok_line, None))),
Err(err) => self.logger().log(EngineEvent::Warning(
event_details,
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
)),
};
Ok(())
}
fn upgrade_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Upgrade)),
EventMessage::new_from_safe("DOKS.upgrade_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Upgrade)),
EventMessage::new_from_safe("DOKS.upgrade_error() called.".to_string()),
));
Ok(())
}
@@ -803,13 +768,10 @@ impl DOKS {
}
fn downgrade_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Downgrade)),
EventMessage::new_from_safe("DOKS.downgrade_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Downgrade)),
EventMessage::new_from_safe("DOKS.downgrade_error() called.".to_string()),
));
Ok(())
}
@@ -819,13 +781,10 @@ impl DOKS {
}
fn pause_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Pausing(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("DOKS.pause_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("DOKS.pause_error() called.".to_string()),
));
Ok(())
}
@@ -838,13 +797,10 @@ impl DOKS {
format!("Preparing to delete DOKS cluster {} with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Preparing to delete DOKS cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing to delete DOKS cluster.".to_string()),
));
let temp_dir = match self.get_temp_dir(event_details.clone()) {
Ok(dir) => dir,
@@ -890,27 +846,19 @@ impl DOKS {
self.id()
);
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform apply before running a delete.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform apply before running a delete.".to_string()),
));
if let Err(e) = cmd::terraform::terraform_init_validate_plan_apply(temp_dir.as_str(), false) {
// An issue occurred during the apply before destroy of Terraform, it may be expected if you're resuming a destroy
self.logger().log(
LogLevel::Error,
EngineEvent::Error(
EngineError::new_terraform_error_while_executing_pipeline(event_details.clone(), e),
None,
),
);
self.logger().log(EngineEvent::Error(
EngineError::new_terraform_error_while_executing_pipeline(event_details.clone(), e),
None,
));
};
let kubeconfig_path = &self.get_kubeconfig_file_path()?;
@@ -923,10 +871,10 @@ impl DOKS {
self.name(),
self.id()
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message.to_string())),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(message.to_string()),
));
self.send_to_customer(&message, &listeners_helper);
let all_namespaces = kubectl_exec_get_all_namespaces(
@@ -939,13 +887,10 @@ impl DOKS {
let namespaces_as_str = namespace_vec.iter().map(std::ops::Deref::deref).collect();
let namespaces_to_delete = get_firsts_namespaces_to_delete(namespaces_as_str);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting non Qovery namespaces".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting non Qovery namespaces".to_string()),
));
for namespace_to_delete in namespaces_to_delete.iter() {
match cmd::kubectl::kubectl_exec_delete_namespace(
@@ -953,28 +898,22 @@ impl DOKS {
namespace_to_delete,
self.cloud_provider().credentials_environment_variables(),
) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Namespace `{}` deleted successfully.",
namespace_to_delete
)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Namespace `{}` deleted successfully.",
namespace_to_delete
)),
)),
Err(e) => {
if !(e.message().contains("not found")) {
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete the namespace `{}`",
namespace_to_delete
)),
),
);
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete the namespace `{}`",
namespace_to_delete
)),
));
}
}
}
@@ -985,13 +924,10 @@ impl DOKS {
"Error while getting all namespaces for Kubernetes cluster {}",
self.name_with_id(),
);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.message())),
),
);
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.message())),
));
}
}
@@ -1001,10 +937,8 @@ impl DOKS {
self.id()
);
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
// delete custom metrics api to avoid stale namespaces on deletion
let helm = Helm::new(&kubeconfig_path, &self.cloud_provider.credentials_environment_variables())
@@ -1021,13 +955,10 @@ impl DOKS {
self.logger(),
)?;
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed helm charts".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed helm charts".to_string()),
));
let qovery_namespaces = get_qovery_managed_namespaces();
for qovery_namespace in qovery_namespaces.iter() {
@@ -1038,34 +969,25 @@ impl DOKS {
for chart in charts_to_delete {
let chart_info = ChartInfo::new_from_release_name(&chart.name, &chart.namespace);
match helm.uninstall(&chart_info, &[]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
)),
Err(e) => {
let message_safe = format!("Can't delete chart `{}`", chart.name);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
))
}
}
}
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed namespaces".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed namespaces".to_string()),
));
for qovery_namespace in qovery_namespaces.iter() {
let deletion = cmd::kubectl::kubectl_exec_delete_namespace(
@@ -1074,90 +996,64 @@ impl DOKS {
self.cloud_provider().credentials_environment_variables(),
);
match deletion {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Namespace {} is fully deleted", qovery_namespace)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Namespace {} is fully deleted", qovery_namespace)),
)),
Err(e) => {
if !(e.message().contains("not found")) {
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete namespace {}.",
qovery_namespace
)),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(format!("Can't delete namespace {}.", qovery_namespace)),
))
}
}
}
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Delete all remaining deployed helm applications".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Delete all remaining deployed helm applications".to_string()),
));
match helm.list_release(None, &[]) {
Ok(helm_charts) => {
for chart in helm_charts {
let chart_info = ChartInfo::new_from_release_name(&chart.name, &chart.namespace);
match helm.uninstall(&chart_info, &[]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
)),
Err(e) => {
let message_safe = format!("Error deleting chart `{}`", chart.name);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
))
}
}
}
}
Err(e) => {
let message_safe = "Unable to get helm list";
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe.to_string(), Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe.to_string(), Some(e.to_string())),
))
}
}
};
let message = format!("Deleting Kubernetes cluster {}/{}", self.name(), self.id());
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform destroy".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform destroy".to_string()),
));
match retry::retry(Fibonacci::from_millis(60000).take(3), || {
match cmd::terraform::terraform_init_validate_destroy(temp_dir.as_str(), false) {
@@ -1170,13 +1066,10 @@ impl DOKS {
format!("Kubernetes cluster {}/{} successfully deleted", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details,
EventMessage::new_from_safe("Kubernetes cluster successfully deleted".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe("Kubernetes cluster successfully deleted".to_string()),
));
Ok(())
}
Err(Operation { error, .. }) => Err(EngineError::new_terraform_error_while_executing_destroy_pipeline(
@@ -1191,13 +1084,10 @@ impl DOKS {
}
fn delete_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Delete)),
EventMessage::new_from_safe("DOKS.delete_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Delete)),
EventMessage::new_from_safe("DOKS.delete_error() called.".to_string()),
));
Ok(())
}
@@ -1279,16 +1169,13 @@ impl Kubernetes for DOKS {
match File::open(&local_kubeconfig_generated) {
Ok(_) => Some(local_kubeconfig_generated),
Err(err) => {
self.logger().log(
LogLevel::Debug,
EngineEvent::Debug(
self.get_event_details(stage),
EventMessage::new(
err.to_string(),
Some(format!("Error, couldn't open {} file", &local_kubeconfig_generated,)),
),
self.logger().log(EngineEvent::Debug(
self.get_event_details(stage),
EventMessage::new(
err.to_string(),
Some(format!("Error, couldn't open {} file", &local_kubeconfig_generated,)),
),
);
));
None
}
}
@@ -1427,13 +1314,10 @@ impl Kubernetes for DOKS {
.as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Start preparing DOKS cluster upgrade process".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Start preparing DOKS cluster upgrade process".to_string()),
));
let temp_dir = self.get_temp_dir(event_details.clone())?;
@@ -1447,7 +1331,7 @@ impl Kubernetes for DOKS {
self.cloud_provider().credentials_environment_variables(),
event_details.stage().clone(),
) {
self.logger().log(LogLevel::Error, EngineEvent::Error(e.clone(), None));
self.logger().log(EngineEvent::Error(e.clone(), None));
return Err(e);
}
@@ -1458,13 +1342,10 @@ impl Kubernetes for DOKS {
format!("Preparing workers nodes for upgrade for Kubernetes cluster {}", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing workers nodes for upgrade for Kubernetes cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing workers nodes for upgrade for Kubernetes cluster.".to_string()),
));
let upgrade_doks_version = match get_do_latest_doks_slug_from_api(self.cloud_provider.token(), self.version()) {
Ok(version) => match version {
@@ -1519,13 +1400,10 @@ impl Kubernetes for DOKS {
format!("Upgrading Kubernetes {} nodes", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Upgrading Kubernetes nodes.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Upgrading Kubernetes nodes.".to_string()),
));
match terraform_init_validate_plan_apply(temp_dir.as_str(), self.context.is_dry_run_deploy()) {
Ok(_) => match self.check_workers_on_upgrade(kubernetes_upgrade_status.requested_version.to_string()) {
@@ -1534,15 +1412,10 @@ impl Kubernetes for DOKS {
format!("Kubernetes {} nodes have been successfully upgraded", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details,
EventMessage::new_from_safe(
"Kubernetes nodes have been successfully upgraded.".to_string(),
),
),
);
self.logger().log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe("Kubernetes nodes have been successfully upgraded.".to_string()),
));
}
Err(e) => {
return Err(EngineError::new_k8s_node_not_ready_with_requested_version(

45
src/cloud_provider/digitalocean/router.rs
View File

@@ -12,7 +12,7 @@ use crate::cmd::helm;
use crate::cmd::helm::Timeout;
use crate::errors::EngineError;
use crate::events::{EngineEvent, EnvironmentStep, EventMessage, Stage, ToTransmitter, Transmitter};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{Context, Listen, Listener, Listeners};
use ::function_name::named;
@@ -202,27 +202,21 @@ impl Service for RouterDo {
Some(hostname) => context.insert("external_ingress_hostname_default", hostname.as_str()),
None => {
// TODO(benjaminch): Handle better this one via a proper error eventually
self.logger().log(
LogLevel::Warning,
EngineEvent::Warning(
event_details,
EventMessage::new_from_safe(
"Error while trying to get Load Balancer hostname from Kubernetes cluster".to_string(),
),
self.logger().log(EngineEvent::Warning(
event_details,
EventMessage::new_from_safe(
"Error while trying to get Load Balancer hostname from Kubernetes cluster".to_string(),
),
);
));
}
},
_ => {
// FIXME really?
// TODO(benjaminch): Handle better this one via a proper error eventually
self.logger().log(
LogLevel::Warning,
EngineEvent::Warning(
event_details,
EventMessage::new_from_safe("Can't fetch external ingress hostname.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
event_details,
EventMessage::new_from_safe("Can't fetch external ingress hostname.".to_string()),
));
}
}
@@ -396,19 +390,16 @@ impl Create for RouterDo {
}
Ok(err) | Err(err) => {
// TODO(benjaminch): Handle better this one via a proper error eventually
self.logger().log(
LogLevel::Warning,
EngineEvent::Warning(
event_details.clone(),
EventMessage::new(
format!(
"Invalid CNAME for {}. Might not be an issue if user is using a CDN.",
domain_to_check.domain,
),
Some(err.to_string()),
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(
format!(
"Invalid CNAME for {}. Might not be an issue if user is using a CDN.",
domain_to_check.domain,
),
Some(err.to_string()),
),
);
));
}
}
}

158
src/cloud_provider/kubernetes.rs
View File

@@ -31,7 +31,7 @@ use crate::errors::{CommandError, EngineError};
use crate::events::Stage::Infrastructure;
use crate::events::{EngineEvent, EventDetails, EventMessage, GeneralStep, InfrastructureStep, Stage, Transmitter};
use crate::fs::workspace_directory;
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::ProgressLevel::Info;
use crate::models::{
Action, Context, Listen, ListenersHelper, ProgressInfo, ProgressLevel, ProgressScope, QoveryIdentifier, StringPath,
@@ -97,16 +97,13 @@ pub trait Kubernetes: Listen {
match File::open(&local_kubeconfig_generated) {
Ok(_) => Some(local_kubeconfig_generated),
Err(err) => {
self.logger().log(
LogLevel::Debug,
EngineEvent::Debug(
self.get_event_details(stage.clone()),
EventMessage::new(
err.to_string(),
Some(format!("Error, couldn't open {} file", &local_kubeconfig_generated,)),
),
self.logger().log(EngineEvent::Debug(
self.get_event_details(stage.clone()),
EventMessage::new(
err.to_string(),
Some(format!("Error, couldn't open {} file", &local_kubeconfig_generated,)),
),
);
));
None
}
}
@@ -136,8 +133,7 @@ pub trait Kubernetes: Listen {
self.get_event_details(stage),
err.into(),
);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
}
@@ -151,8 +147,7 @@ pub trait Kubernetes: Listen {
self.get_event_details(stage),
CommandError::new_from_safe_message(format!("Error getting file metadata, error: {}", err,)),
);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
};
@@ -164,8 +159,7 @@ pub trait Kubernetes: Listen {
self.get_event_details(stage),
CommandError::new_from_safe_message(format!("Error setting file permissions, error: {}", err,)),
);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
@@ -195,8 +189,7 @@ pub trait Kubernetes: Listen {
)),
);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
@@ -790,20 +783,17 @@ where
for object in cert_manager_objects {
// check resource exist first
if let Err(e) = kubectl_exec_count_all_objects(&kubernetes_config, object, envs.clone()) {
logger.log(
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(
format!(
"Encountering issues while trying to get objects kind {}: {:?}",
object,
e.message()
),
None,
logger.log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(
format!(
"Encountering issues while trying to get objects kind {}: {:?}",
object,
e.message()
),
None,
),
);
));
continue;
}
@@ -813,13 +803,10 @@ where
|| match kubectl_delete_objects_in_all_namespaces(&kubernetes_config, object, envs.clone()) {
Ok(_) => OperationResult::Ok(()),
Err(e) => {
logger.log(
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(format!("Failed to delete all {} objects, retrying...", object,), None),
),
);
logger.log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(format!("Failed to delete all {} objects, retrying...", object,), None),
));
OperationResult::Retry(e)
}
},
@@ -1052,10 +1039,7 @@ fn check_kubernetes_upgrade_status(
match compare_kubernetes_cluster_versions_for_upgrade(&deployed_masters_version, &wished_version) {
Ok(x) => {
if let Some(msg) = x.message {
logger.log(
LogLevel::Info,
EngineEvent::Deploying(event_details.clone(), EventMessage::new_from_safe(msg)),
);
logger.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(msg)));
};
if x.older_version_detected {
older_masters_version_detected = x.older_version_detected;
@@ -1078,15 +1062,12 @@ fn check_kubernetes_upgrade_status(
// check workers versions
if deployed_workers_version.is_empty() {
logger.log(
LogLevel::Warning,
EngineEvent::Deploying(
event_details,
EventMessage::new_from_safe(
"No worker nodes found, can't check if upgrade is required for workers".to_string(),
),
logger.log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe(
"No worker nodes found, can't check if upgrade is required for workers".to_string(),
),
);
));
return Ok(KubernetesUpgradeStatus {
required_upgrade_on,
@@ -1130,22 +1111,19 @@ fn check_kubernetes_upgrade_status(
}
}
logger.log(
LogLevel::Info,
EngineEvent::Deploying(
event_details,
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
),
},
}),
),
);
logger.log(EngineEvent::Info(
event_details,
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
),
},
}),
));
Ok(KubernetesUpgradeStatus {
required_upgrade_on,
@@ -1330,42 +1308,33 @@ where
match action {
Action::Create => {
listeners_helper.deployment_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Deploying(
EventDetails::clone_changing_stage(
event_details,
Stage::Infrastructure(InfrastructureStep::Create),
),
event_message,
logger.log(EngineEvent::Info(
EventDetails::clone_changing_stage(
event_details,
Stage::Infrastructure(InfrastructureStep::Create),
),
);
event_message,
));
}
Action::Pause => {
listeners_helper.pause_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Pausing(
EventDetails::clone_changing_stage(
event_details,
Stage::Infrastructure(InfrastructureStep::Pause),
),
event_message,
logger.log(EngineEvent::Info(
EventDetails::clone_changing_stage(
event_details,
Stage::Infrastructure(InfrastructureStep::Pause),
),
);
event_message,
));
}
Action::Delete => {
listeners_helper.delete_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Deleting(
EventDetails::clone_changing_stage(
event_details,
Stage::Infrastructure(InfrastructureStep::Delete),
),
event_message,
logger.log(EngineEvent::Info(
EventDetails::clone_changing_stage(
event_details,
Stage::Infrastructure(InfrastructureStep::Delete),
),
);
event_message,
));
}
Action::Nothing => {} // should not happens
};
@@ -1414,10 +1383,7 @@ pub fn validate_k8s_required_cpu_and_burstable(
context_id,
));
logger.log(
LogLevel::Warning,
EngineEvent::Warning(event_details, EventMessage::new_from_safe(message)),
);
logger.log(EngineEvent::Warning(event_details, EventMessage::new_from_safe(message)));
set_cpu_burst = total_cpu.clone();
}

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

@@ -23,7 +23,7 @@ use crate::dns_provider::DnsProvider;
use crate::errors::{CommandError, EngineError};
use crate::events::Stage::Infrastructure;
use crate::events::{EngineEvent, EnvironmentStep, EventDetails, EventMessage, InfrastructureStep, Stage, Transmitter};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{
Action, Context, Features, Listen, Listener, Listeners, ListenersHelper, QoveryIdentifier, ToHelmString,
};
@@ -173,7 +173,7 @@ impl Kapsule {
e,
);
logger.log(LogLevel::Error, EngineEvent::Error(err.clone(), None));
logger.log(EngineEvent::Error(err.clone(), None));
return Err(err);
}
@@ -388,20 +388,17 @@ impl Kapsule {
fn check_missing_nodegroup_info<T>(&self, item: &Option<T>, name: &str) -> Result<(), ScwNodeGroupErrors> {
let event_details = self.get_event_details(Infrastructure(InfrastructureStep::LoadConfiguration));
self.logger.log(
LogLevel::Error,
EngineEvent::Error(
EngineError::new_missing_workers_group_info_error(
event_details,
CommandError::new_from_safe_message(format!(
"Missing node pool info {} for cluster {}",
name,
self.context.cluster_id()
)),
),
None,
self.logger.log(EngineEvent::Error(
EngineError::new_missing_workers_group_info_error(
event_details,
CommandError::new_from_safe_message(format!(
"Missing node pool info {} for cluster {}",
name,
self.context.cluster_id()
)),
),
);
None,
));
if item.is_none() {
return Err(ScwNodeGroupErrors::MissingNodePoolInfo);
@@ -528,16 +525,13 @@ impl Kapsule {
match env::var_os("VAULT_SECRET_ID") {
Some(secret_id) => context.insert("vault_secret_id", secret_id.to_str().unwrap()),
None => self.logger().log(
LogLevel::Error,
EngineEvent::Error(
EngineError::new_missing_required_env_variable(
event_details,
"VAULT_SECRET_ID".to_string(),
),
None,
None => self.logger().log(EngineEvent::Error(
EngineError::new_missing_required_env_variable(
event_details,
"VAULT_SECRET_ID".to_string(),
),
),
None,
)),
}
}
None => {
@@ -587,13 +581,10 @@ impl Kapsule {
format!("Preparing SCW {} cluster deployment with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger.log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing SCW cluster deployment.".to_string()),
),
);
self.logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing SCW cluster deployment.".to_string()),
));
// upgrade cluster instead if required
match self.get_kubeconfig_file() {
@@ -609,28 +600,18 @@ impl Kapsule {
return self.upgrade_with_status(x);
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes cluster upgrade not required".to_string()),
),
)
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes cluster upgrade not required".to_string()),
))
}
Err(e) => {
self.logger().log(LogLevel::Error, EngineEvent::Error(e, None));
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"Error detected, upgrade won't occurs, but standard deployment.".to_string(),
),
),
);
self.logger().log(EngineEvent::Error(e, Some(EventMessage::new_from_safe(
"Error detected, upgrade won't occurs, but standard deployment.".to_string(),
))));
}
},
Err(_) => self.logger().log(LogLevel::Info, EngineEvent::Deploying(event_details.clone(), EventMessage::new_from_safe("Kubernetes cluster upgrade not required, config file is not found and cluster have certainly never been deployed before".to_string())))
Err(_) => self.logger().log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe("Kubernetes cluster upgrade not required, config file is not found and cluster have certainly never been deployed before".to_string())))
};
@@ -666,13 +647,10 @@ impl Kapsule {
));
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Deploying SCW cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deploying SCW cluster.".to_string()),
));
self.send_to_customer(
format!("Deploying SCW {} cluster deployment with id {}", self.name(), self.id()).as_str(),
@@ -687,13 +665,10 @@ impl Kapsule {
for entry in x.clone() {
if entry.starts_with(item) {
match terraform_exec(temp_dir.as_str(), vec!["state", "rm", &entry]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(format!("successfully removed {}", &entry)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("successfully removed {}", &entry)),
)),
Err(e) => {
return Err(EngineError::new_terraform_cannot_remove_entry_out(
event_details,
@@ -706,21 +681,18 @@ impl Kapsule {
}
}
}
Err(e) => self.logger().log(
LogLevel::Warning,
EngineEvent::Error(EngineError::new_terraform_state_does_not_exist(event_details.clone(), e), None),
),
Err(e) => self.logger().log(EngineEvent::Error(
EngineError::new_terraform_state_does_not_exist(event_details.clone(), e),
None,
)),
};
// TODO(benjaminch): move this elsewhere
// Create object-storage buckets
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Create Qovery managed object storage buckets".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Create Qovery managed object storage buckets".to_string()),
));
if let Err(e) = self
.object_storage
.create_bucket(self.kubeconfig_bucket_name().as_str())
@@ -730,8 +702,7 @@ impl Kapsule {
self.kubeconfig_bucket_name(),
e,
);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
@@ -739,8 +710,7 @@ impl Kapsule {
if let Err(e) = self.object_storage.create_bucket(self.logs_bucket_name().as_str()) {
let error =
EngineError::new_object_storage_cannot_create_bucket_error(event_details, self.logs_bucket_name(), e);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
@@ -764,8 +734,7 @@ impl Kapsule {
kubeconfig_name.to_string(),
e,
);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
@@ -790,15 +759,12 @@ impl Kapsule {
Some(c),
))
}
ScwNodeGroupErrors::ClusterDoesNotExists(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"cluster do not exists, no node groups can be retrieved for upgrade check".to_string(),
),
ScwNodeGroupErrors::ClusterDoesNotExists(_) => self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(
"cluster do not exists, no node groups can be retrieved for upgrade check".to_string(),
),
),
)),
ScwNodeGroupErrors::MultipleClusterFound => {
let msg = "multiple clusters found, can't match the correct node groups".to_string();
return Err(EngineError::new_multiple_cluster_found_expected_one_error(
@@ -806,15 +772,12 @@ impl Kapsule {
CommandError::new(msg.clone(), Some(msg)),
));
}
ScwNodeGroupErrors::NoNodePoolFound(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"cluster exists, but no node groups found for upgrade check".to_string(),
),
ScwNodeGroupErrors::NoNodePoolFound(_) => self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(
"cluster exists, but no node groups found for upgrade check".to_string(),
),
),
)),
ScwNodeGroupErrors::MissingNodePoolInfo => {
let msg = "Error with Scaleway API while trying to retrieve node pool info".to_string();
return Err(EngineError::new_missing_api_info_from_cloud_provider_error(
@@ -834,33 +797,27 @@ impl Kapsule {
};
// ensure all node groups are in ready state Scaleway side
self.logger.log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"ensuring all groups nodes are in ready state from the Scaleway API".to_string(),
),
self.logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(
"ensuring all groups nodes are in ready state from the Scaleway API".to_string(),
),
);
));
for ng in current_nodegroups {
let res = retry::retry(
// retry 10 min max per nodegroup until they are ready
Fixed::from_millis(15000).take(40),
|| {
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(format!(
"checking node group {}/{:?}, current status: {:?}",
&ng.name,
&ng.id.as_ref().unwrap_or(&"unknown".to_string()),
&ng.status
)),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!(
"checking node group {}/{:?}, current status: {:?}",
&ng.name,
&ng.id.as_ref().unwrap_or(&"unknown".to_string()),
&ng.status
)),
));
let pool_id = match &ng.id {
None => {
let msg =
@@ -883,15 +840,13 @@ impl Kapsule {
event_details.clone(),
Some(c),
);
self.logger
.log(LogLevel::Error, EngineEvent::Error(current_error.clone(), None));
self.logger.log(EngineEvent::Error(current_error.clone(), None));
OperationResult::Retry(current_error)
}
ScwNodeGroupErrors::ClusterDoesNotExists(c) => {
let current_error =
EngineError::new_no_cluster_found_error(event_details.clone(), c);
self.logger
.log(LogLevel::Error, EngineEvent::Error(current_error.clone(), None));
self.logger.log(EngineEvent::Error(current_error.clone(), None));
OperationResult::Retry(current_error)
}
ScwNodeGroupErrors::MultipleClusterFound => {
@@ -914,8 +869,7 @@ impl Kapsule {
event_details.clone(),
Some(c),
);
self.logger
.log(LogLevel::Error, EngineEvent::Error(current_error.clone(), None));
self.logger.log(EngineEvent::Error(current_error.clone(), None));
OperationResult::Retry(current_error)
}
}
@@ -944,15 +898,12 @@ impl Kapsule {
}
}
}
self.logger.log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(
"all node groups for this cluster are ready from cloud provider API".to_string(),
),
self.logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(
"all node groups for this cluster are ready from cloud provider API".to_string(),
),
);
));
// ensure all nodes are ready on Kubernetes
match self.check_workers_on_create() {
@@ -961,13 +912,10 @@ impl Kapsule {
format!("Kubernetes {} nodes have been successfully created", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes nodes have been successfully created".to_string()),
),
)
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Kubernetes nodes have been successfully created".to_string()),
))
}
Err(e) => {
return Err(EngineError::new_k8s_node_not_ready(event_details, e));
@@ -1009,13 +957,10 @@ impl Kapsule {
self.options.clone(),
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing chart configuration to be deployed".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing chart configuration to be deployed".to_string()),
));
let helm_charts_to_deploy = scw_helm_charts(
format!("{}/qovery-tf-config.json", &temp_dir).as_str(),
&charts_prerequisites,
@@ -1039,39 +984,29 @@ impl Kapsule {
let (kubeconfig_path, _) = self.get_kubeconfig_file()?;
let environment_variables: Vec<(&str, &str)> = self.cloud_provider.credentials_environment_variables();
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Create)),
EventMessage::new_from_safe("SCW.create_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Create)),
EventMessage::new_from_safe("SCW.create_error() called.".to_string()),
));
match kubectl_exec_get_events(kubeconfig_path, None, environment_variables) {
Ok(ok_line) => self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(event_details, EventMessage::new_from_safe(ok_line)),
),
Err(err) => self.logger().log(
LogLevel::Error,
EngineEvent::Deploying(
event_details,
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
),
),
Ok(ok_line) => self
.logger()
.log(EngineEvent::Info(event_details, EventMessage::new_from_safe(ok_line))),
Err(err) => self.logger().log(EngineEvent::Warning(
event_details,
EventMessage::new("Error trying to get kubernetes events".to_string(), Some(err.message())),
)),
};
Ok(())
}
fn upgrade_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Upgrade)),
EventMessage::new_from_safe("SCW.upgrade_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Upgrade)),
EventMessage::new_from_safe("SCW.upgrade_error() called.".to_string()),
));
Ok(())
}
@@ -1081,13 +1016,10 @@ impl Kapsule {
}
fn downgrade_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deploying(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Downgrade)),
EventMessage::new_from_safe("SCW.downgrade_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Downgrade)),
EventMessage::new_from_safe("SCW.downgrade_error() called.".to_string()),
));
Ok(())
}
@@ -1101,13 +1033,10 @@ impl Kapsule {
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Pausing(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("Preparing SCW cluster pause.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("Preparing SCW cluster pause.".to_string()),
));
let temp_dir = self.get_temp_dir(event_details.clone())?;
@@ -1159,8 +1088,7 @@ impl Kapsule {
}
Err(e) => {
let error = EngineError::new_terraform_state_does_not_exist(event_details, e);
self.logger()
.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
self.logger().log(EngineEvent::Error(error.clone(), None));
return Err(error);
}
};
@@ -1214,7 +1142,7 @@ impl Kapsule {
match wait_engine_job_finish {
Ok(_) => {
self.logger().log(LogLevel::Info, EngineEvent::Pausing(event_details.clone(), EventMessage::new_from_safe("No current running jobs on the Engine, infrastructure pause is allowed to start".to_string())));
self.logger().log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe("No current running jobs on the Engine, infrastructure pause is allowed to start".to_string())));
}
Err(Operation { error, .. }) => {
return Err(error)
@@ -1224,7 +1152,7 @@ impl Kapsule {
}
}
}
false => self.logger().log(LogLevel::Warning, EngineEvent::Pausing(event_details.clone(), EventMessage::new_from_safe("The Engines are running Client side, but metric history flag is disabled. You will encounter issues during cluster lifecycles if you do not enable metric history".to_string()))),
false => self.logger().log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe("Engines are running Client side, but metric history flag is disabled. You will encounter issues during cluster lifecycles if you do not enable metric history".to_string()))),
}
}
@@ -1238,22 +1166,17 @@ impl Kapsule {
format!("Pausing SCW {} cluster deployment with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Pausing(
event_details.clone(),
EventMessage::new_from_safe("Pausing SCW cluster deployment.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Pausing SCW cluster deployment.".to_string()),
));
match terraform_exec(temp_dir.as_str(), terraform_args) {
Ok(_) => {
let message = format!("Kubernetes cluster {} successfully paused", self.name());
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Pausing(event_details, EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details, EventMessage::new_from_safe(message)));
Ok(())
}
Err(e) => Err(EngineError::new_terraform_error_while_executing_pipeline(event_details, e)),
@@ -1261,13 +1184,10 @@ impl Kapsule {
}
fn pause_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Pausing(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("SCW.pause_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Pause)),
EventMessage::new_from_safe("SCW.pause_error() called.".to_string()),
));
Ok(())
}
@@ -1281,13 +1201,10 @@ impl Kapsule {
format!("Preparing to delete SCW cluster {} with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Preparing to delete SCW cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing to delete SCW cluster.".to_string()),
));
let temp_dir = self.get_temp_dir(event_details.clone())?;
@@ -1329,27 +1246,19 @@ impl Kapsule {
self.id()
);
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform apply before running a delete.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform apply before running a delete.".to_string()),
));
if let Err(e) = cmd::terraform::terraform_init_validate_plan_apply(temp_dir.as_str(), false) {
// An issue occurred during the apply before destroy of Terraform, it may be expected if you're resuming a destroy
self.logger().log(
LogLevel::Error,
EngineEvent::Error(
EngineError::new_terraform_error_while_executing_pipeline(event_details.clone(), e),
None,
),
);
self.logger().log(EngineEvent::Error(
EngineError::new_terraform_error_while_executing_pipeline(event_details.clone(), e),
None,
));
};
let kubeconfig_path = &self.get_kubeconfig_file_path()?;
@@ -1362,10 +1271,10 @@ impl Kapsule {
self.name(),
self.id()
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message.to_string())),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(message.to_string()),
));
self.send_to_customer(&message, &listeners_helper);
let all_namespaces = kubectl_exec_get_all_namespaces(
@@ -1378,13 +1287,10 @@ impl Kapsule {
let namespaces_as_str = namespace_vec.iter().map(std::ops::Deref::deref).collect();
let namespaces_to_delete = get_firsts_namespaces_to_delete(namespaces_as_str);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting non Qovery namespaces".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting non Qovery namespaces".to_string()),
));
for namespace_to_delete in namespaces_to_delete.iter() {
match cmd::kubectl::kubectl_exec_delete_namespace(
@@ -1392,28 +1298,22 @@ impl Kapsule {
namespace_to_delete,
self.cloud_provider().credentials_environment_variables(),
) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Namespace `{}` deleted successfully.",
namespace_to_delete
)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Namespace `{}` deleted successfully.",
namespace_to_delete
)),
)),
Err(e) => {
if !(e.message().contains("not found")) {
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete the namespace `{}`",
namespace_to_delete
)),
),
);
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete the namespace `{}`",
namespace_to_delete
)),
));
}
}
}
@@ -1424,13 +1324,10 @@ impl Kapsule {
"Error while getting all namespaces for Kubernetes cluster {}",
self.name_with_id(),
);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.message())),
),
);
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.message())),
));
}
}
@@ -1440,10 +1337,8 @@ impl Kapsule {
self.id()
);
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
// delete custom metrics api to avoid stale namespaces on deletion
let helm = Helm::new(&kubeconfig_path, &self.cloud_provider.credentials_environment_variables())
@@ -1460,13 +1355,10 @@ impl Kapsule {
self.logger(),
)?;
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed helm charts".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed helm charts".to_string()),
));
let qovery_namespaces = get_qovery_managed_namespaces();
for qovery_namespace in qovery_namespaces.iter() {
@@ -1477,34 +1369,25 @@ impl Kapsule {
for chart in charts_to_delete {
let chart_info = ChartInfo::new_from_release_name(&chart.name, &chart.namespace);
match helm.uninstall(&chart_info, &[]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
)),
Err(e) => {
let message_safe = format!("Can't delete chart `{}`", chart.name);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
))
}
}
}
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed namespaces".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Deleting Qovery managed namespaces".to_string()),
));
for qovery_namespace in qovery_namespaces.iter() {
let deletion = cmd::kubectl::kubectl_exec_delete_namespace(
@@ -1513,90 +1396,64 @@ impl Kapsule {
self.cloud_provider().credentials_environment_variables(),
);
match deletion {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Namespace {} is fully deleted", qovery_namespace)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Namespace {} is fully deleted", qovery_namespace)),
)),
Err(e) => {
if !(e.message().contains("not found")) {
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Can't delete namespace {}.",
qovery_namespace
)),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(format!("Can't delete namespace {}.", qovery_namespace)),
))
}
}
}
}
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Delete all remaining deployed helm applications".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Delete all remaining deployed helm applications".to_string()),
));
match helm.list_release(None, &[]) {
Ok(helm_charts) => {
for chart in helm_charts {
let chart_info = ChartInfo::new_from_release_name(&chart.name, &chart.namespace);
match helm.uninstall(&chart_info, &[]) {
Ok(_) => self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
),
),
Ok(_) => self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!("Chart `{}` deleted", chart.name)),
)),
Err(e) => {
let message_safe = format!("Error deleting chart `{}`", chart.name);
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe, Some(e.to_string())),
))
}
}
}
}
Err(e) => {
let message_safe = "Unable to get helm list";
self.logger().log(
LogLevel::Error,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(message_safe.to_string(), Some(e.to_string())),
),
)
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(message_safe.to_string(), Some(e.to_string())),
))
}
}
};
let message = format!("Deleting Kubernetes cluster {}/{}", self.name(), self.id());
self.send_to_customer(&message, &listeners_helper);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
self.logger()
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform destroy".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Running Terraform destroy".to_string()),
));
match retry::retry(Fibonacci::from_millis(60000).take(3), || {
match cmd::terraform::terraform_init_validate_destroy(temp_dir.as_str(), false) {
@@ -1609,13 +1466,10 @@ impl Kapsule {
format!("Kubernetes cluster {}/{} successfully deleted", self.name(), self.id()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deleting(
event_details,
EventMessage::new_from_safe("Kubernetes cluster successfully deleted".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe("Kubernetes cluster successfully deleted".to_string()),
));
Ok(())
}
Err(Operation { error, .. }) => Err(EngineError::new_terraform_error_while_executing_destroy_pipeline(
@@ -1630,13 +1484,10 @@ impl Kapsule {
}
fn delete_error(&self) -> Result<(), EngineError> {
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Delete)),
EventMessage::new_from_safe("SCW.delete_error() called.".to_string()),
),
);
self.logger().log(EngineEvent::Warning(
self.get_event_details(Stage::Infrastructure(InfrastructureStep::Delete)),
EventMessage::new_from_safe("SCW.delete_error() called.".to_string()),
));
Ok(())
}
@@ -1743,13 +1594,10 @@ impl Kubernetes for Kapsule {
.as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Start preparing SCW cluster upgrade process".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Start preparing SCW cluster upgrade process".to_string()),
));
let temp_dir = self.get_temp_dir(event_details.clone())?;
@@ -1763,7 +1611,7 @@ impl Kubernetes for Kapsule {
self.cloud_provider().credentials_environment_variables(),
Stage::Infrastructure(InfrastructureStep::Upgrade),
) {
self.logger().log(LogLevel::Error, EngineEvent::Error(e.clone(), None));
self.logger().log(EngineEvent::Error(e.clone(), None));
return Err(e);
}
@@ -1774,13 +1622,10 @@ impl Kubernetes for Kapsule {
format!("Preparing nodes for upgrade for Kubernetes cluster {}", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Preparing nodes for upgrade for Kubernetes cluster.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Preparing nodes for upgrade for Kubernetes cluster.".to_string()),
));
context.insert(
"kubernetes_cluster_version",
@@ -1817,13 +1662,10 @@ impl Kubernetes for Kapsule {
format!("Upgrading Kubernetes {} nodes", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe("Upgrading Kubernetes nodes.".to_string()),
),
);
self.logger().log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe("Upgrading Kubernetes nodes.".to_string()),
));
match terraform_init_validate_plan_apply(temp_dir.as_str(), self.context.is_dry_run_deploy()) {
Ok(_) => match self.check_workers_on_upgrade(kubernetes_upgrade_status.requested_version.to_string()) {
@@ -1832,15 +1674,10 @@ impl Kubernetes for Kapsule {
format!("Kubernetes {} nodes have been successfully upgraded", self.name()).as_str(),
&listeners_helper,
);
self.logger().log(
LogLevel::Info,
EngineEvent::Deploying(
event_details,
EventMessage::new_from_safe(
"Kubernetes nodes have been successfully upgraded.".to_string(),
),
),
);
self.logger().log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe("Kubernetes nodes have been successfully upgraded.".to_string()),
));
}
Err(e) => {
return Err(EngineError::new_k8s_node_not_ready_with_requested_version(

21
src/cloud_provider/scaleway/router.rs
View File

@@ -12,7 +12,7 @@ use crate::cmd::helm;
use crate::cmd::helm::Timeout;
use crate::errors::EngineError;
use crate::events::{EngineEvent, EnvironmentStep, EventMessage, Stage, ToTransmitter, Transmitter};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{Context, Listen, Listener, Listeners};
use ::function_name::named;
@@ -340,19 +340,16 @@ impl Create for RouterScw {
}
Ok(err) | Err(err) => {
// TODO(benjaminch): Handle better this one via a proper error eventually
self.logger().log(
LogLevel::Warning,
EngineEvent::Warning(
event_details.clone(),
EventMessage::new(
format!(
"Invalid CNAME for {}. Might not be an issue if user is using a CDN.",
domain_to_check.domain,
),
Some(err.to_string()),
self.logger().log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new(
format!(
"Invalid CNAME for {}. Might not be an issue if user is using a CDN.",
domain_to_check.domain,
),
Some(err.to_string()),
),
);
));
}
}
}

173
src/cloud_provider/service.rs
View File

@@ -21,7 +21,7 @@ use crate::cmd::kubectl::{kubectl_exec_delete_secret, kubectl_exec_scale_replica
use crate::cmd::structs::LabelsContent;
use crate::errors::{CommandError, EngineError};
use crate::events::{EngineEvent, EnvironmentStep, EventDetails, EventMessage, Stage, ToTransmitter};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::ProgressLevel::Info;
use crate::models::{
Context, DatabaseMode, Listen, Listeners, ListenersHelper, ProgressInfo, ProgressLevel, ProgressScope,
@@ -310,17 +310,14 @@ where
match get_stateless_resource_information_for_user(kubernetes, environment, service, event_details) {
Ok(lines) => lines,
Err(err) => {
logger.log(
LogLevel::Error,
EngineEvent::Error(
err,
Some(EventMessage::new_from_safe(format!(
"error while retrieving debug logs from {} {}",
service.service_type().name(),
service.name_with_id(),
))),
),
);
logger.log(EngineEvent::Error(
err,
Some(EventMessage::new_from_safe(format!(
"error while retrieving debug logs from {} {}",
service.service_type().name(),
service.name_with_id(),
))),
));
Vec::new()
}
@@ -573,17 +570,14 @@ where
let environment = target.environment;
if service.is_managed_service() {
logger.log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Deploying managed {} `{}`",
service.service_type().name(),
service.name_with_id()
)),
),
);
logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Deploying managed {} `{}`",
service.service_type().name(),
service.name_with_id()
)),
));
let context = service.tera_context(target)?;
@@ -634,17 +628,14 @@ where
.map_err(|e| EngineError::new_terraform_error_while_executing_pipeline(event_details.clone(), e))?;
} else {
// use helm
logger.log(
LogLevel::Info,
EngineEvent::Deploying(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Deploying containerized {} `{}` on Kubernetes cluster",
service.service_type().name(),
service.name_with_id()
)),
),
);
logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(format!(
"Deploying containerized {} `{}` on Kubernetes cluster",
service.service_type().name(),
service.name_with_id()
)),
));
let context = service.tera_context(target)?;
let kubernetes_config_file_path = kubernetes.get_kubeconfig_file_path()?;
@@ -815,20 +806,17 @@ where
match crate::cmd::terraform::terraform_init_validate_destroy(workspace_dir.as_str(), true) {
Ok(_) => {
logger.log(
LogLevel::Info,
EngineEvent::Deleting(
event_details,
EventMessage::new_from_safe("Deleting secret containing tfstates".to_string()),
),
);
logger.log(EngineEvent::Info(
event_details,
EventMessage::new_from_safe("Deleting secret containing tfstates".to_string()),
));
let _ =
delete_terraform_tfstate_secret(kubernetes, environment.namespace(), &get_tfstate_name(service));
}
Err(e) => {
let engine_err = EngineError::new_terraform_error_while_executing_destroy_pipeline(event_details, e);
logger.log(LogLevel::Error, EngineEvent::Error(engine_err.clone(), None));
logger.log(EngineEvent::Error(engine_err.clone(), None));
return Err(engine_err);
}
@@ -892,10 +880,10 @@ where
version.as_str()
);
logger.log(
LogLevel::Info,
EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message.to_string())),
);
logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(message.to_string()),
));
let progress_info = ProgressInfo::new(
service.progress_scope(),
@@ -949,7 +937,7 @@ where
service.version(),
);
logger.log(LogLevel::Error, EngineEvent::Error(error.clone(), None));
logger.log(EngineEvent::Error(error.clone(), None));
Err(error)
}
@@ -1011,24 +999,15 @@ where
match action {
CheckAction::Deploy => {
listeners_helper.deployment_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Deploying(event_details.clone(), EventMessage::new_from_safe(message)),
);
logger.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
}
CheckAction::Pause => {
listeners_helper.pause_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Pausing(event_details.clone(), EventMessage::new_from_safe(message)),
);
logger.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
}
CheckAction::Delete => {
listeners_helper.delete_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Deleting(event_details.clone(), EventMessage::new_from_safe(message)),
);
logger.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message)));
}
}
@@ -1047,19 +1026,16 @@ where
kubernetes.context().execution_id(),
);
logger.log(
LogLevel::Error,
EngineEvent::Error(
err.clone(),
Some(EventMessage::new_from_safe(format!(
"{} error with {} {} , id: {}",
action_verb,
service.service_type().name(),
service.name(),
service.id(),
))),
),
);
logger.log(EngineEvent::Error(
err.clone(),
Some(EventMessage::new_from_safe(format!(
"{} error with {} {} , id: {}",
action_verb,
service.service_type().name(),
service.name(),
service.id(),
))),
));
match action {
CheckAction::Deploy => listeners_helper.deployment_error(progress_info),
@@ -1081,10 +1057,10 @@ where
kubernetes.context().execution_id(),
);
logger.log(
LogLevel::Debug,
EngineEvent::Debug(event_details.clone(), EventMessage::new_from_safe(debug_logs_string)),
);
logger.log(EngineEvent::Debug(
event_details.clone(),
EventMessage::new_from_safe(debug_logs_string),
));
match action {
CheckAction::Deploy => listeners_helper.deployment_error(progress_info),
@@ -1315,42 +1291,33 @@ where
match action {
Action::Create => {
listeners_helper.deployment_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Deploying(
EventDetails::clone_changing_stage(
event_details,
Stage::Environment(EnvironmentStep::Deploy),
),
event_message,
logger.log(EngineEvent::Info(
EventDetails::clone_changing_stage(
event_details,
Stage::Environment(EnvironmentStep::Deploy),
),
);
event_message,
));
}
Action::Pause => {
listeners_helper.pause_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Pausing(
EventDetails::clone_changing_stage(
event_details,
Stage::Environment(EnvironmentStep::Pause),
),
event_message,
logger.log(EngineEvent::Info(
EventDetails::clone_changing_stage(
event_details,
Stage::Environment(EnvironmentStep::Pause),
),
);
event_message,
));
}
Action::Delete => {
listeners_helper.delete_in_progress(progress_info);
logger.log(
LogLevel::Info,
EngineEvent::Deleting(
EventDetails::clone_changing_stage(
event_details,
Stage::Environment(EnvironmentStep::Delete),
),
event_message,
logger.log(EngineEvent::Info(
EventDetails::clone_changing_stage(
event_details,
Stage::Environment(EnvironmentStep::Delete),
),
);
event_message,
));
}
Action::Nothing => {} // should not happens
};

44
src/cloud_provider/utilities.rs
View File

@@ -4,7 +4,7 @@ use std::collections::HashMap;
use crate::errors::{CommandError, EngineError};
use crate::events::{EngineEvent, EventDetails, EventMessage};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{Listeners, ListenersHelper, ProgressInfo, ProgressLevel, ProgressScope};
use chrono::Duration;
use core::option::Option::{None, Some};
@@ -455,10 +455,10 @@ pub fn check_domain_for(
resolver
};
logger.log(
LogLevel::Info,
EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message.to_string())),
);
logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(message.to_string()),
));
let fixed_iterable = Fixed::from_millis(3000).take(100);
let check_result = retry::retry(fixed_iterable, || match next_resolver().lookup_ip(domain) {
@@ -466,10 +466,10 @@ pub fn check_domain_for(
Err(err) => {
let x = format!("Domain resolution check for '{}' is still in progress...", domain);
logger.log(
LogLevel::Info,
EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(x.to_string())),
);
logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(x.to_string()),
));
listener_helper.deployment_in_progress(ProgressInfo::new(
ProgressScope::Environment {
@@ -488,10 +488,10 @@ pub fn check_domain_for(
Ok(_) => {
let x = format!("Domain {} is ready! ⚡️", domain);
logger.log(
LogLevel::Info,
EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(message.to_string())),
);
logger.log(EngineEvent::Info(
event_details.clone(),
EventMessage::new_from_safe(message.to_string()),
));
listener_helper.deployment_in_progress(ProgressInfo::new(
ProgressScope::Environment {
@@ -509,10 +509,10 @@ pub fn check_domain_for(
domain
);
logger.log(
LogLevel::Warning,
EngineEvent::Warning(event_details.clone(), EventMessage::new_from_safe(message.to_string())),
);
logger.log(EngineEvent::Warning(
event_details.clone(),
EventMessage::new_from_safe(message.to_string()),
));
listener_helper.deployment_in_progress(ProgressInfo::new(
ProgressScope::Environment {
@@ -552,14 +552,8 @@ pub fn print_action(
) {
let msg = format!("{}.{}.{} called for {}", cloud_provider_name, struct_name, fn_name, item_name);
match fn_name.contains("error") {
true => logger.log(
LogLevel::Warning,
EngineEvent::Warning(event_details, EventMessage::new_from_safe(msg)),
),
false => logger.log(
LogLevel::Info,
EngineEvent::Info(event_details, EventMessage::new_from_safe(msg)),
),
true => logger.log(EngineEvent::Warning(event_details, EventMessage::new_from_safe(msg))),
false => logger.log(EngineEvent::Info(event_details, EventMessage::new_from_safe(msg))),
}
}

63
src/events/io.rs
View File

@@ -25,41 +25,6 @@ pub enum EngineEvent {
error: EngineError,
message: Option<EventMessage>,
},
#[deprecated(note = "event status is carried by EventDetails directly")]
Waiting {
details: EventDetails,
message: EventMessage,
},
#[deprecated(note = "event status is carried by EventDetails directly")]
Deploying {
details: EventDetails,
message: EventMessage,
},
#[deprecated(note = "event status is carried by EventDetails directly")]
Pausing {
details: EventDetails,
message: EventMessage,
},
#[deprecated(note = "event status is carried by EventDetails directly")]
Deleting {
details: EventDetails,
message: EventMessage,
},
#[deprecated(note = "event status is carried by EventDetails directly")]
Deployed {
details: EventDetails,
message: EventMessage,
},
#[deprecated(note = "event status is carried by EventDetails directly")]
Paused {
details: EventDetails,
message: EventMessage,
},
#[deprecated(note = "event status is carried by EventDetails directly")]
Deleted {
details: EventDetails,
message: EventMessage,
},
}
impl From<events::EngineEvent> for EngineEvent {
@@ -81,34 +46,6 @@ impl From<events::EngineEvent> for EngineEvent {
error: EngineError::from(e),
message: m.map(EventMessage::from),
},
events::EngineEvent::Waiting(d, m) => EngineEvent::Waiting {
details: EventDetails::from(d),
message: EventMessage::from(m),
},
events::EngineEvent::Deploying(d, m) => EngineEvent::Deploying {
details: EventDetails::from(d),
message: EventMessage::from(m),
},
events::EngineEvent::Pausing(d, m) => EngineEvent::Pausing {
details: EventDetails::from(d),
message: EventMessage::from(m),
},
events::EngineEvent::Deleting(d, m) => EngineEvent::Deleting {
details: EventDetails::from(d),
message: EventMessage::from(m),
},
events::EngineEvent::Deployed(d, m) => EngineEvent::Deployed {
details: EventDetails::from(d),
message: EventMessage::from(m),
},
events::EngineEvent::Paused(d, m) => EngineEvent::Paused {
details: EventDetails::from(d),
message: EventMessage::from(m),
},
events::EngineEvent::Deleted(d, m) => EngineEvent::Deleted {
details: EventDetails::from(d),
message: EventMessage::from(m),
},
}
}
}

37
src/events/mod.rs
View File

@@ -22,29 +22,6 @@ pub enum EngineEvent {
Warning(EventDetails, EventMessage),
/// Error: represents an error event.
Error(EngineError, Option<EventMessage>),
/// Waiting: represents an engine waiting event.
///
/// Engine is waiting for a task to be done.
#[deprecated(note = "event status is carried by EventDetails directly")]
Waiting(EventDetails, EventMessage),
/// Deploying: represents an engine deploying event.
#[deprecated(note = "event status is carried by EventDetails directly")]
Deploying(EventDetails, EventMessage),
/// Pausing: represents an engine pausing event.
#[deprecated(note = "event status is carried by EventDetails directly")]
Pausing(EventDetails, EventMessage),
/// Deleting: represents an engine deleting event.
#[deprecated(note = "event status is carried by EventDetails directly")]
Deleting(EventDetails, EventMessage),
/// Deployed: represents an engine deployed event.
#[deprecated(note = "event status is carried by EventDetails directly")]
Deployed(EventDetails, EventMessage),
/// Paused: represents an engine paused event.
#[deprecated(note = "event status is carried by EventDetails directly")]
Paused(EventDetails, EventMessage),
/// Deleted: represents an engine deleted event.
#[deprecated(note = "event status is carried by EventDetails directly")]
Deleted(EventDetails, EventMessage),
}
impl EngineEvent {
@@ -55,13 +32,6 @@ impl EngineEvent {
EngineEvent::Info(details, _message) => details,
EngineEvent::Warning(details, _message) => details,
EngineEvent::Error(engine_error, _message) => engine_error.event_details(),
EngineEvent::Waiting(details, _message) => details,
EngineEvent::Deploying(details, _message) => details,
EngineEvent::Pausing(details, _message) => details,
EngineEvent::Deleting(details, _message) => details,
EngineEvent::Deployed(details, _message) => details,
EngineEvent::Paused(details, _message) => details,
EngineEvent::Deleted(details, _message) => details,
}
}
@@ -72,13 +42,6 @@ impl EngineEvent {
EngineEvent::Info(_details, message) => message.message(message_verbosity),
EngineEvent::Warning(_details, message) => message.message(message_verbosity),
EngineEvent::Error(engine_error, _message) => engine_error.message(),
EngineEvent::Waiting(_details, message) => message.message(message_verbosity),
EngineEvent::Deploying(_details, message) => message.message(message_verbosity),
EngineEvent::Pausing(_details, message) => message.message(message_verbosity),
EngineEvent::Deleting(_details, message) => message.message(message_verbosity),
EngineEvent::Deployed(_details, message) => message.message(message_verbosity),
EngineEvent::Paused(_details, message) => message.message(message_verbosity),
EngineEvent::Deleted(_details, message) => message.message(message_verbosity),
}
}
}

45
src/logger.rs
View File

@@ -1,16 +1,8 @@
use crate::events::{EngineEvent, EventMessageVerbosity};
use tracing;
#[derive(Debug, Clone)]
pub enum LogLevel {
Debug,
Info,
Warning,
Error,
}
pub trait Logger: Send + Sync {
fn log(&self, log_level: LogLevel, event: EngineEvent);
fn log(&self, event: EngineEvent);
fn clone_dyn(&self) -> Box<dyn Logger>;
}
@@ -37,7 +29,7 @@ impl Default for StdIoLogger {
}
impl Logger for StdIoLogger {
fn log(&self, log_level: LogLevel, event: EngineEvent) {
fn log(&self, event: EngineEvent) {
let event_details = event.get_details();
let stage = event_details.stage();
let execution_id = event_details.execution_id().to_string();
@@ -63,11 +55,11 @@ impl Logger for StdIoLogger {
transmitter = event_details.transmitter().to_string().as_str(),
)
.in_scope(|| {
match log_level {
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)),
match event {
EngineEvent::Debug(_, _) => debug!("{}", event.message(EventMessageVerbosity::FullDetails)),
EngineEvent::Info(_, _) => info!("{}", event.message(EventMessageVerbosity::FullDetails)),
EngineEvent::Warning(_, _) => warn!("{}", event.message(EventMessageVerbosity::FullDetails)),
EngineEvent::Error(_, _) => error!("{}", event.message(EventMessageVerbosity::FullDetails)),
};
});
}
@@ -91,7 +83,6 @@ mod tests {
use uuid::Uuid;
struct TestCase<'a> {
log_level: LogLevel,
event: EngineEvent,
description: &'a str,
}
@@ -115,7 +106,6 @@ mod tests {
let test_cases = vec![
TestCase {
log_level: LogLevel::Error,
event: EngineEvent::Error(
EngineError::new_unknown(
EventDetails::new(
@@ -141,8 +131,7 @@ mod tests {
description: "Error event",
},
TestCase {
log_level: LogLevel::Info,
event: EngineEvent::Deploying(
event: EngineEvent::Info(
EventDetails::new(
Some(Kind::Scw),
orga_id.clone(),
@@ -157,8 +146,7 @@ mod tests {
description: "Deploying info event",
},
TestCase {
log_level: LogLevel::Debug,
event: EngineEvent::Pausing(
event: EngineEvent::Debug(
EventDetails::new(
Some(Kind::Scw),
orga_id.clone(),
@@ -173,8 +161,7 @@ mod tests {
description: "Pausing application debug event",
},
TestCase {
log_level: LogLevel::Warning,
event: EngineEvent::Pausing(
event: EngineEvent::Warning(
EventDetails::new(
Some(Kind::Scw),
orga_id.clone(),
@@ -194,15 +181,15 @@ mod tests {
for tc in test_cases {
// execute:
logger.log(tc.log_level.clone(), tc.event.clone());
logger.log(tc.event.clone());
// validate:
assert!(
logs_contain(match tc.log_level {
LogLevel::Debug => "DEBUG",
LogLevel::Info => "INFO",
LogLevel::Warning => "WARN",
LogLevel::Error => "ERROR",
logs_contain(match tc.event {
EngineEvent::Debug(_, _) => "DEBUG",
EngineEvent::Info(_, _) => "INFO",
EngineEvent::Warning(_, _) => "WARN",
EngineEvent::Error(_, _) => "ERROR",
}),
"{}",
tc.description

24
src/transaction.rs
View File

@@ -11,7 +11,7 @@ use crate::container_registry::to_engine_error;
use crate::engine::{EngineConfig, EngineConfigError};
use crate::errors::{EngineError, Tag};
use crate::events::{EngineEvent, EnvironmentStep, EventDetails, EventMessage, Stage, Transmitter};
use crate::logger::{LogLevel, Logger};
use crate::logger::Logger;
use crate::models::{EnvironmentError, ListenersHelper, ProgressInfo, ProgressLevel, ProgressScope, QoveryIdentifier};
pub struct Transaction<'a> {
@@ -211,13 +211,8 @@ impl<'a> Transaction<'a> {
ListenersHelper::new(self.engine.build_platform().listeners()).deployment_in_progress(progress_info);
let event_details = build_event_details();
self.logger.log(
match build_result.is_ok() {
true => LogLevel::Info,
false => LogLevel::Error,
},
EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(msg)),
);
self.logger
.log(EngineEvent::Info(event_details.clone(), EventMessage::new_from_safe(msg)));
// Abort if it was an error
let _ = build_result.map_err(|err| crate::build_platform::to_engine_error(event_details, err))?;
@@ -331,15 +326,10 @@ impl<'a> Transaction<'a> {
match self.build_and_push_applications(applications, &option) {
Ok(apps) => apps,
Err(engine_err) => {
self.logger.log(
LogLevel::Error,
EngineEvent::Error(
engine_err.clone(),
Some(EventMessage::new_from_safe(
"ROLLBACK STARTED! an error occurred".to_string(),
)),
),
);
self.logger.log(EngineEvent::Error(
engine_err.clone(),
Some(EventMessage::new_from_safe("ROLLBACK STARTED! an error occurred".to_string())),
));
return if engine_err.tag() == &Tag::TaskCancellationRequested {
TransactionResult::Canceled