Delete namespace (#195)

Delete a namespace and all resources within it.

Author: byrnedo

.sqlx/query-176ad85b2b9a88831e77f8c12481814efb1b5985081ffb1c46e9d596b03246f9.json

@@ -28,6 +28,14 @@ pub enum DeleteCommands {
     Service(DeleteResourceArgs),
     ClusterIssuer(DeleteResourceArgs),
     Cluster(DeleteClusterArgs),
+    Namespace(DeleteNamespaceArgs),
+}
+
+#[derive(Debug, Args)]
+pub struct DeleteNamespaceArgs {
+    name: String,
+    #[command(flatten)]
+    config: ConfigFileArgs,
 }
 
 #[derive(Debug, Args)]
@@ -81,6 +89,17 @@ impl<D: DeleteDeps> Delete<D> {
                     .await?
             }
             DeleteCommands::Cluster(args) => self.delete_cluster(args).await?,
+            DeleteCommands::Namespace(args) => {
+                self.delete_resource(
+                    ResourceType::Namespace,
+                    DeleteResourceArgs {
+                        name: args.name.clone(),
+                        namespace: args.name,
+                        config: args.config,
+                    },
+                )
+                .await?
+            }
         }
         Ok(())
     }

src/delete.rs

@@ -153,6 +153,7 @@ impl TryFrom<&SupportedResources> for ObjectListItem {
             SupportedResources::Secret(s) => &s.metadata,
             SupportedResources::Service(s) => &s.metadata,
             SupportedResources::ClusterIssuer(i) => &i.metadata,
+            SupportedResources::Namespace(ns) => &ns.metadata,
         };
 
         let name = get_skate_label_value(&meta.labels, &SkateLabels::Name).ok_or("no name")?;

src/object_list_item.rs

@@ -855,6 +855,7 @@ impl DefaultScheduler {
             SupportedResources::Secret(secret) => Self::plan_secret(state, secret),
             SupportedResources::Service(service) => Self::plan_service(state, service),
             SupportedResources::ClusterIssuer(issuer) => Self::plan_cluster_issuer(state, issuer),
+            SupportedResources::Namespace(_ns) => todo!(),
         }
     }
 

src/scheduler.rs

@@ -3,6 +3,7 @@ use k8s_openapi::api::core::v1::Pod;
 
 pub(crate) struct PrioritySort {}
 
+#[allow(unused)]
 pub fn pod_priority(pod: &Pod) -> i32 {
     pod.spec
         .as_ref()

src/scheduler/priority_sort.rs

@@ -101,6 +101,7 @@ async fn apply_supported_resource<D: ApplyDeps>(
             let ctrl = ClusterIssuerController::new(deps.get_db(), ingress_ctrl);
             ctrl.apply(issuer).await?;
         }
+        SupportedResources::Namespace(_) => {}
     }
     Ok(())
 }

src/skatelet/apply.rs

@@ -142,6 +142,24 @@ pub async fn list_resources_by_type(
     Ok(resources)
 }
 
+pub async fn list_resources_by_namespace(
+    db: impl SqliteExecutor<'_>,
+    ns: &str,
+) -> super::Result<Vec<Resource>> {
+    let resources = sqlx::query_as!(
+        Resource,
+        r#" SELECT id as "id!: String", name as "name!: String", namespace as "namespace!: String", resource_type, manifest as "manifest!: serde_json::Value",  hash as "hash!: String", created_at as "created_at!: DateTime<Local>", updated_at as "updated_at!: DateTime<Local>", generation
+            FROM resources
+            WHERE namespace = $1
+        "#,
+        ns
+    )
+        .fetch_all(db)
+        .await?;
+
+    Ok(resources)
+}
+
 pub async fn list_resources(db: impl SqliteExecutor<'_>) -> super::Result<Vec<Resource>> {
     let resources = sqlx::query_as!(
         Resource,
@@ -191,6 +209,12 @@ pub enum ResourceType {
     ClusterIssuer,
     #[strum(serialize = "nodes", serialize = "node", to_string = "node")]
     Node,
+    #[strum(
+        serialize = "namespaces",
+        serialize = "namespace",
+        to_string = "namespace"
+    )]
+    Namespace,
 }
 
 impl From<String> for ResourceType {

src/skatelet/database/resource.rs

@@ -2,13 +2,12 @@ use crate::skatelet::apply::StdinCommand;
 use crate::supported_resources::SupportedResources;
 use crate::supported_resources::SupportedResources::{ClusterIssuer, CronJob, Ingress, Service};
 use clap::{Args, Subcommand};
+use k8s_openapi::api::batch::v1::CronJob as K8sCronJob;
+use k8s_openapi::api::core::v1::{Namespace, Secret};
 use std::collections::BTreeMap;
 use std::io;
 use std::io::Read;
 
-use k8s_openapi::api::batch::v1::CronJob as K8sCronJob;
-use k8s_openapi::api::core::v1::Secret;
-
 use crate::controllers::clusterissuer::ClusterIssuerController;
 use crate::controllers::cronjob::CronjobController;
 use crate::controllers::daemonset::DaemonSetController;
@@ -21,6 +20,7 @@ use crate::deps::{With, WithDB};
 use crate::errors::SkateError;
 use crate::exec::ShellExec;
 use crate::skatelet::VAR_PATH;
+use crate::skatelet::database::resource::list_resources_by_namespace;
 use crate::spec;
 use crate::util::SkateLabels;
 use k8s_openapi::api::core::v1::Service as K8sService;
@@ -46,6 +46,7 @@ pub enum DeleteResourceCommands {
     Daemonset(DeleteResourceArgs),
     Service(DeleteResourceArgs),
     Clusterissuer(DeleteResourceArgs),
+    Namespace(DeleteResourceArgs),
 }
 
 #[derive(Debug, Args, Clone)]
@@ -101,6 +102,10 @@ impl<D: DeleteDeps> Deleter<D> {
                 self.delete_cluster_issuer(args.clone(), resource_args.clone())
                     .await
             }
+            DeleteResourceCommands::Namespace(resource_args) => {
+                self.delete_namespace(args.clone(), resource_args.clone())
+                    .await
+            }
         }
     }
 
@@ -243,6 +248,23 @@ impl<D: DeleteDeps> Deleter<D> {
         Ok(())
     }
 
+    async fn delete_namespace(
+        &self,
+        delete_args: DeleteArgs,
+        resource_args: DeleteResourceArgs,
+    ) -> Result<(), SkateError> {
+        self.manifest_delete(
+            &SupportedResources::Namespace(Namespace {
+                metadata: Self::deletion_metadata(resource_args),
+                spec: None,
+                status: None,
+            }),
+            delete_args.termination_grace_period,
+        )
+        .await?;
+        Ok(())
+    }
+
     async fn manifest_delete(
         &self,
         object: &SupportedResources,
@@ -291,6 +313,25 @@ impl<D: DeleteDeps> Deleter<D> {
                 let ctrl = ClusterIssuerController::new(self.deps.get_db(), ingress_controller);
                 ctrl.delete(issuer).await?;
             }
+            SupportedResources::Namespace(ns) => {
+                // find all resources within the ns in the db
+                // run manifest delete on all of those
+                // report any errors
+                let name = match &ns.metadata.name {
+                    Some(n) => n,
+                    None => return Err(SkateError::String("no metadata name".to_string())),
+                };
+                let resources =
+                    list_resources_by_namespace(&self.deps.get_db(), name.as_str()).await?;
+
+                for resource in resources {
+                    let str_manifest = serde_yaml::to_string(&resource.manifest)?;
+                    let object: serde_yaml::Value = serde_yaml::from_str(&str_manifest)?;
+                    let object = SupportedResources::try_from(&object)?;
+                    println!("deleting {} {}", resource.resource_type, resource.name);
+                    Box::pin(self.manifest_delete(&object, grace_period)).await?;
+                }
+            }
         }
         Ok(())
     }

src/skatelet/delete.rs

@@ -534,7 +534,7 @@ impl ClusterState {
         &mut self,
         filter_node: Option<&str>,
         filter_types: &[ResourceType],
-    ) -> Vec<MutCatalogueItem> {
+    ) -> Vec<MutCatalogueItem<'_>> {
         self.nodes
             .iter_mut()
             .filter(|n| filter_node.is_none() || n.node_name == filter_node.unwrap())
@@ -559,7 +559,7 @@ impl ClusterState {
         filter_types: &[ResourceType],
         namespace: Option<&str>,
         name: Option<&str>,
-    ) -> Vec<CatalogueItem> {
+    ) -> Vec<CatalogueItem<'_, '_, '_, '_>> {
         let mut map: HashMap<String, CatalogueItem> = HashMap::new();
 
         for node in &self.nodes {

src/state/state.rs

@@ -8,7 +8,7 @@ use anyhow::anyhow;
 use k8s_openapi::Resource;
 use k8s_openapi::api::apps::v1::{DaemonSet, Deployment};
 use k8s_openapi::api::batch::v1::CronJob;
-use k8s_openapi::api::core::v1::{Pod, PodTemplateSpec, Secret, Service};
+use k8s_openapi::api::core::v1::{Namespace, Pod, PodTemplateSpec, Secret, Service};
 use k8s_openapi::api::networking::v1::Ingress;
 use k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
 use serde::{Deserialize, Serialize};
@@ -35,6 +35,8 @@ pub enum SupportedResources {
     Service(Service),
     #[strum(serialize = "ClusterIssuer")]
     ClusterIssuer(ClusterIssuer),
+    #[strum(serialize = "Namespace")]
+    Namespace(Namespace),
 }
 
 impl Into<ResourceType> for &SupportedResources {
@@ -48,6 +50,7 @@ impl Into<ResourceType> for &SupportedResources {
             SupportedResources::Secret(_) => ResourceType::Secret,
             SupportedResources::Service(_) => ResourceType::Service,
             SupportedResources::ClusterIssuer(_) => ResourceType::ClusterIssuer,
+            SupportedResources::Namespace(_) => ResourceType::Namespace,
         }
     }
 }
@@ -99,14 +102,14 @@ impl TryFrom<&Value> for SupportedResources {
                     let clusterissuer: ClusterIssuer = serde::Deserialize::deserialize(value)?;
                     Ok(SupportedResources::ClusterIssuer(clusterissuer))
                 } else {
-                    Err(anyhow!(format!("version: {}, kind {}", api_version, kind))
-                        .context("unsupported resource type")
-                        .into())
+                    Err(anyhow!(format!(
+                        "unsupported resource: version {}, kind {}",
+                        api_version, kind
+                    ))
+                    .into())
                 }
             }
-            _ => Err(anyhow!("missing 'kind' and 'apiVersion' fields")
-                .context("unsupported resource type")
-                .into()),
+            _ => Err(anyhow!("resource missing 'kind' and 'apiVersion' fields").into()),
         }
     }
 }
@@ -122,6 +125,7 @@ impl SupportedResources {
             SupportedResources::Secret(s) => metadata_name(s),
             SupportedResources::Service(s) => metadata_name(s),
             SupportedResources::ClusterIssuer(c) => metadata_name(c),
+            SupportedResources::Namespace(n) => metadata_name(n),
         }
     }
 
@@ -243,6 +247,7 @@ impl SupportedResources {
             SupportedResources::Secret(_) => false,
             SupportedResources::Service(_) => false,
             SupportedResources::ClusterIssuer(_) => false,
+            SupportedResources::Namespace(_) => false,
         }
     }
     fn fixup_pod_template(
@@ -501,6 +506,10 @@ impl SupportedResources {
                 issuer.metadata = Self::fixup_metadata(issuer.metadata.clone(), None)?;
                 resource
             }
+            SupportedResources::Namespace(ref mut ns) => {
+                ns.metadata = Self::fixup_metadata(ns.metadata.clone(), None)?;
+                resource
+            }
         };
         Ok(resource)
     }