forked from NationTech/harmony
135 lines
3.6 KiB
Rust
135 lines
3.6 KiB
Rust
use async_trait::async_trait;
|
|
use serde::Serialize;
|
|
|
|
use crate::{
|
|
data::{Id, Version},
|
|
interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
|
|
inventory::Inventory,
|
|
maestro::Maestro,
|
|
score::{CloneBoxScore, Score},
|
|
topology::{HelmCommand, Topology, monitoring_alerting::MonitoringAlertingTopology},
|
|
};
|
|
|
|
use super::kube_prometheus::kube_prometheus_score;
|
|
|
|
#[derive(Debug)]
|
|
pub struct MonitoringAlertingStackScore {
|
|
pub monitoring_stack: Vec<Box<dyn Score<MonitoringAlertingTopology>>>,
|
|
pub namespace: String,
|
|
}
|
|
|
|
impl MonitoringAlertingStackScore {
|
|
pub fn new(
|
|
monitoring_stack: Vec<Box<dyn Score<MonitoringAlertingTopology>>>,
|
|
namespace: String,
|
|
) -> Self {
|
|
Self {
|
|
monitoring_stack,
|
|
namespace,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for MonitoringAlertingStackScore {
|
|
fn default() -> Self {
|
|
let ns = "monitoring";
|
|
Self {
|
|
monitoring_stack: vec![Box::new(kube_prometheus_score(ns))],
|
|
namespace: ns.to_string(),
|
|
}
|
|
}
|
|
}
|
|
impl Clone for MonitoringAlertingStackScore {
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
monitoring_stack: self
|
|
.monitoring_stack
|
|
.iter()
|
|
.map(|s| s.clone_box())
|
|
.collect(),
|
|
namespace: self.namespace.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Serialize for MonitoringAlertingStackScore {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
use serde::ser::SerializeStruct;
|
|
let mut s = serializer.serialize_struct("MonitoringAlertingStackScore", 1)?;
|
|
let monitoring_values: Vec<_> = self
|
|
.monitoring_stack
|
|
.iter()
|
|
.map(|m| m.serialize())
|
|
.collect();
|
|
s.serialize_field("monitoring", &monitoring_values)?;
|
|
s.end()
|
|
}
|
|
}
|
|
|
|
impl<T:Topology> Score<T> for MonitoringAlertingStackScore {
|
|
fn create_interpret(&self) -> Box<dyn Interpret<T>> {
|
|
Box::new(MonitoringAlertingStackInterpret {
|
|
score: MonitoringAlertingStackScore {
|
|
monitoring_stack: self
|
|
.monitoring_stack
|
|
.iter()
|
|
.map(|s| s.clone_box())
|
|
.collect(),
|
|
namespace: self.namespace.clone(),
|
|
},
|
|
})
|
|
}
|
|
|
|
fn name(&self) -> String {
|
|
format!("MonitoringAlertingStackScore")
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct MonitoringAlertingStackInterpret {
|
|
pub score: MonitoringAlertingStackScore,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl <T: Topology> Interpret<T> for MonitoringAlertingStackInterpret {
|
|
async fn execute(
|
|
&self,
|
|
_inventory: &Inventory,
|
|
_topology: &T,
|
|
) -> Result<Outcome, InterpretError> {
|
|
let inventory = Inventory::autoload();
|
|
let topology = MonitoringAlertingTopology::new();
|
|
let mut maestro = match Maestro::initialize(inventory, topology).await {
|
|
Ok(m) => m,
|
|
Err(e) => {
|
|
println!("failed to initialize Maestro: {}", e);
|
|
std::process::exit(1);
|
|
}
|
|
};
|
|
maestro.register_all(self.score.monitoring_stack.clone());
|
|
Ok(Outcome::success(format!(
|
|
"monitoring stack installed in {} namespace",
|
|
self.score.namespace
|
|
)))
|
|
}
|
|
|
|
fn get_name(&self) -> InterpretName {
|
|
todo!()
|
|
}
|
|
|
|
fn get_version(&self) -> Version {
|
|
todo!()
|
|
}
|
|
|
|
fn get_status(&self) -> InterpretStatus {
|
|
todo!()
|
|
}
|
|
|
|
fn get_children(&self) -> Vec<Id> {
|
|
todo!()
|
|
}
|
|
}
|