controller 0.59.0

Tembo Operator for Postgres
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use crate::{apis::coredb_types::CoreDB, Context, Error};
use k8s_openapi::api::core::v1::Service;
use kube::{api::ListParams, Api, ResourceExt};
use std::sync::Arc;
use tracing::{debug, error};

// Delete the postgres-exporter service from the cluster
pub async fn delete_postgres_exporter_service(
    cdb: &CoreDB,
    ctx: Arc<Context>,
) -> Result<(), Error> {
    let client = ctx.client.clone();
    let ns = cdb.namespace().unwrap();
    let service_api: Api<Service> = Api::namespaced(client, &ns);

    // Define the label selector based on your service labels
    let label_selector =
        "app=postgres-exporter,component=metrics,coredb.io/name=".to_owned() + &cdb.name_any();
    let lp = ListParams::default().labels(&label_selector);

    // List services with specified labels
    let services = service_api.list(&lp).await?;

    // Delete the service
    for service in services {
        if let Some(service_name) = service.metadata.name {
            match service_api.delete(&service_name, &Default::default()).await {
                Ok(_) => {
                    debug!(
                        "Deleted Service: {}, for instance {}",
                        service_name,
                        cdb.name_any()
                    );
                }
                Err(e) => {
                    error!(
                        "Error deleting Service: {}, for instance {}",
                        e,
                        cdb.name_any()
                    );
                    return Err(Error::KubeError(e));
                }
            }
        } else {
            println!("Found a service without a name, skipping...");
        }
    }

    Ok(())
}

// #[instrument(skip(cdb, ctx), fields(instance_name = %cdb.name_any()))]
// pub async fn reconcile_prometheus_exporter_service(cdb: &CoreDB, ctx: Arc<Context>) -> Result<(), Error> {
//     let client = ctx.client.clone();
//     let ns = cdb.namespace().unwrap();
//     let name = cdb.name_any() + "-metrics";
//     let svc_api: Api<Service> = Api::namespaced(client, &ns);
//     let oref = cdb.controller_owner_ref(&()).unwrap();
//
//     if !(cdb.spec.postgresExporterEnabled) {
//         // check if service exists and delete it
//         let _o = svc_api.delete(&name, &Default::default()).await;
//         return Ok(());
//     }
//
//     let mut selector_labels: BTreeMap<String, String> = BTreeMap::new();
//     selector_labels.insert("app".to_owned(), "postgres-exporter".to_string());
//     selector_labels.insert("coredb.io/name".to_owned(), cdb.name_any());
//     selector_labels.insert("component".to_owned(), "metrics".to_string());
//
//     let mut labels = selector_labels.clone();
//     labels.insert("component".to_owned(), "metrics".to_owned());
//
//     let metrics_svc: Service = Service {
//         metadata: ObjectMeta {
//             name: Some(name.to_owned()),
//             namespace: Some(ns.to_owned()),
//             labels: Some(labels),
//             owner_references: Some(vec![oref]),
//             ..ObjectMeta::default()
//         },
//         spec: Some(ServiceSpec {
//             ports: Some(vec![ServicePort {
//                 port: 80,
//                 name: Some("metrics".to_string()),
//                 target_port: Some(IntOrString::String("metrics".to_string())),
//                 ..ServicePort::default()
//             }]),
//             selector: Some(selector_labels),
//             ..ServiceSpec::default()
//         }),
//         ..Service::default()
//     };
//
//     let ps = PatchParams::apply("cntrlr").force();
//     let _o = svc_api
//         .patch(&name, &ps, &Patch::Apply(&metrics_svc))
//         .await
//         .map_err(Error::KubeError)?;
//
//     Ok(())
// }