Merge pull request #39 from maheshrayas/ignore-kube-saver

feat: Ignore downscale/upscale if ignore annotation is set

src/downscaler/resource/common.rs

@@ -23,80 +23,105 @@ pub struct ScalingMachinery {
 }
 
 impl ScalingMachinery {
+ fn should_downscale(&self) -> bool {
+ if let Some(annotations) = self.annotations.as_ref() {
+ if let Some(is_downscaled) = annotations.get("kubesaver.com/is_downscaled") {
+ if is_downscaled == "false" {
+ return true;
+ }
+ }
+ }
+ false
+ }
+
+ fn should_upscale(&self) -> Option<i32> {
+ if let Some(annotations) = self.annotations.as_ref() {
+ if let Some(is_downscaled) = annotations.get("kubesaver.com/is_downscaled") {
+ if is_downscaled == "true" {
+ if let Some(original_count) = annotations.get("kubesaver.com/original_count") {
+ if let Ok(scale_up) = original_count.parse::<i32>() {
+ return Some(scale_up);
+ }
+ }
+ }
+ }
+ }
+ None
+ }
+
+ async fn action_for_downscale(&self, c: Client) -> Result<Option<ScaledResources>, Error> {
+ info!("downscaling {} : {}", &self.resource_type, &self.name);
+ let patch_result = self
+ .patching(
+ c.clone(),
+ &self.original_replicas,
+ self.tobe_replicas,
+ "true",
+ self.scale_state.clone(),
+ )
+ .await?;
+ Ok(Some(patch_result))
+ }
+
+ async fn action_for_upscale(
+ &self,
+ c: Client,
+ scale_up: i32,
+ ) -> Result<Option<ScaledResources>, Error> {
+ info!("upscaling {} : {}", &self.resource_type, &self.name);
+ let patch_result = self
+ .patching(
+ c.clone(),
+ &scale_up.to_string(),
+ Some(scale_up),
+ "false",
+ self.scale_state.clone(),
+ )
+ .await?;
+ Ok(Some(patch_result))
+ }
+
+ fn should_downscale_first_time(&self) -> bool {
+ self.annotations.is_none()
+ || self
+ .annotations
+ .as_ref()
+ .map_or(true, |a| a.get("kubesaver.com/is_downscaled").is_none())
+ }
+
  pub async fn scaling_machinery(
  &self,
  c: Client,
  is_uptime: bool,
  ) -> Result<Option<ScaledResources>, Error> {
+ // check if the resource has an annotation kubesaver.com/ignore:"true"
+ if let Some(ignore_annotations) = self
+ .annotations
+ .as_ref()
+ .and_then(|a| a.get("kubesaver.com/ignore"))
+ {
+ if ignore_annotations.eq("true") {
+ return Ok(None);
+ }
+ }
  if !is_uptime {
- // check if the resource has annotations
- if self.annotations.is_none()
- || self
- .annotations
- .to_owned()
- .unwrap()
- .get("kubesaver.com/is_downscaled")
- .is_none()
- {
- // first time action
- info!("downscaling {} : {}", &self.resource_type, &self.name,);
- return Ok(Some(
- self.patching(
+ if self.should_downscale_first_time() {
+ info!("downscaling {} : {}", &self.resource_type, &self.name);
+ let patch_result = self
+ .patching(
  c.clone(),
  &self.original_replicas,
  self.tobe_replicas,
  "true",
  self.scale_state.clone(),
  )
- .await?,
- ));
- } else if let Some(x) = self
- .annotations
- .as_ref()
- .unwrap()
- .get("kubesaver.com/is_downscaled")
- {
- // if the resources are already upscaled by the kube-saver and now its the time to be downscaled
- if x == "false" {
- info!("downscaling {} : {}", &self.resource_type, &self.name);
- return Ok(Some(
- self.patching(
- c.clone(),
- &self.original_replicas,
- self.tobe_replicas,
- "true",
- self.scale_state.clone(),
- )
- .await?,
- ));
- }
- }
- } else {
- // its a uptime
- // should be up and running
- // check if annotation is true
- let y = self.annotations.as_ref().unwrap();
- if let Some(x) = y.get("kubesaver.com/is_downscaled") {
- let scale_up: i32 = y
- .get("kubesaver.com/original_count")
- .unwrap()
- .parse()
- .unwrap();
- if x == "true" {
- info!("upscaling {} : {} ", &self.resource_type, &self.name);
- // this is needed becoz the next day I want to downscale after the end time
- return Ok(Some(
- self.patching(
- c.clone(),
- &scale_up.to_string(), // after scaleup, keep the kubesaver.com/original_count as the real non-zero count.
- Some(scale_up),
- "false",
- self.scale_state.clone(),
- )
- .await?,
- ));
- }
+ .await?;
+ return Ok(Some(patch_result));
+ } else if self.should_downscale() {
+ return self.action_for_downscale(c.clone()).await;
  }
+ } else if let Some(scale_up) = self.should_upscale() {
+ return self.action_for_upscale(c, scale_up).await;
  }
  Ok(None)
  }

tests/data/test-ignore-downscale-14.yaml

@@ -0,0 +1,30 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+ name: kuber14
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ namespace: kuber14
+ name: test-kuber14-deploy1
+ annotations:
+ kubesaver.com/ignore: "true"
+ labels:
+ app: go-app-kuber14
+spec:
+ replicas: 2
+ selector:
+ matchLabels:
+ app: go-app
+ template:
+ metadata:
+ labels:
+ app: go-app
+ spec:
+ containers:
+ - name: go-app
+ image: maheshrayas/goapp:1.0
+ ports:
+ - containerPort: 8090
+---

tests/downscaler/processor.rs

@@ -348,3 +348,19 @@ async fn test4_hpa_scale_all_resources_replicas_1() {
  //Deployment must be scaled back to original replicas
  assert_eq!(d.spec.unwrap().replicas, Some(3));
 }
+
+#[tokio::test]
+async fn test5_check_if_ignored() {
+ let f = File::open("tests/rules/rules14.yaml").unwrap();
+ let r: Rules = serde_yaml::from_reader(f).unwrap();
+ let client = Client::try_default()
+ .await
+ .expect("Failed to read kubeconfig");
+ r.process_rules(client.clone(), None, None, SCALED_STATE.clone())
+ .await
+ .ok();
+ // kube-saver must ignore
+ let api: Api<Deployment> = Api::namespaced(client.clone(), "kuber14");
+ let d = api.get("test-kuber14-deploy1").await.unwrap();
+ assert_eq!(d.spec.unwrap().replicas, Some(2));
+}

tests/rules/rules14.yaml

@@ -0,0 +1,7 @@
+rules:
+ - id: rules-downscale-kuber14
+ uptime: Mon-Sun 22:59-23:00 Australia/Sydney
+ jmespath: "metadata.name == 'kuber14'"
+ resource:
+ - Namespace
+ replicas: 0