feat : support kubectl rollout history for daemonset

Author: NeverRaR

extended/src/main/java/io/kubernetes/client/extended/kubectl/KubectlRolloutHistory.java

@@ -16,20 +16,32 @@
 import io.kubernetes.client.extended.kubectl.exception.KubectlException;
 import io.kubernetes.client.extended.kubectl.util.deployment.DeploymentHelper;
 import io.kubernetes.client.openapi.ApiException;
+import io.kubernetes.client.openapi.JSON;
 import io.kubernetes.client.openapi.apis.AppsV1Api;
+import io.kubernetes.client.openapi.models.V1ControllerRevision;
+import io.kubernetes.client.openapi.models.V1ControllerRevisionList;
+import io.kubernetes.client.openapi.models.V1DaemonSet;
 import io.kubernetes.client.openapi.models.V1Deployment;
 import io.kubernetes.client.openapi.models.V1ObjectMeta;
+import io.kubernetes.client.openapi.models.V1OwnerReference;
 import io.kubernetes.client.openapi.models.V1PodTemplateSpec;
 import io.kubernetes.client.openapi.models.V1ReplicaSet;
+import io.kubernetes.client.util.labels.LabelSelector;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 public class KubectlRolloutHistory<ApiType extends KubernetesObject>
     extends Kubectl.ResourceBuilder<ApiType, KubectlRolloutHistory<ApiType>>
     implements Kubectl.Executable<ApiType> {
 
+  @FunctionalInterface
+  public interface PodTemplateParser {
+    V1PodTemplateSpec parse(V1ControllerRevision history) throws ApiException;
+  }
+
   public static final String CHANGE_CAUSE_ANNOTATION = "kubernetes.io/change-cause";
 
   public V1PodTemplateSpec getTemplate() {
@@ -78,6 +90,10 @@ public ApiType execute() throws KubectlException {
         V1Deployment deployment = api.readNamespacedDeployment(name, namespace, null, null, null);
         deploymentViewHistory(deployment, api);
         return (ApiType) deployment;
+      } else if (apiTypeClass.equals(V1DaemonSet.class)) {
+        V1DaemonSet daemonSet = api.readNamespacedDaemonSet(name, namespace, null, null, null);
+        daemonSetViewHistory(daemonSet, api);
+        return (ApiType) daemonSet;
       } else {
         throw new KubectlException("Unsupported class for rollout history: " + apiTypeClass);
       }
@@ -154,8 +170,108 @@ private void deploymentViewHistory(V1Deployment deployment, AppsV1Api api) throw
     }
   }
 
+  private void daemonSetViewHistory(V1DaemonSet daemonSet, AppsV1Api api) throws ApiException {
+    LabelSelector selector = LabelSelector.parse(daemonSet.getSpec().getSelector());
+    List<V1ControllerRevision> historyList = controlledHistory(api, daemonSet, selector);
+    parseHistory(
+        historyList,
+        history -> {
+          V1DaemonSet dsOfHistory = applyDaemonSetHistory(daemonSet, history);
+          return dsOfHistory.getSpec().getTemplate();
+        });
+  }
+
+  private V1DaemonSet applyDaemonSetHistory(V1DaemonSet ds, V1ControllerRevision history) {
+    String dsJson = new JSON().serialize(ds);
+    String patch = new JSON().serialize(history.getData());
+    String patched = applyDirectivePatch(dsJson, patch);
+    return new JSON().deserialize(patched, V1DaemonSet.class);
+  }
+
+  private void parseHistory(List<V1ControllerRevision> historyList, PodTemplateParser parser)
+      throws ApiException {
+    Map<Long, V1ControllerRevision> historyInfo = new HashMap<>();
+    for (V1ControllerRevision history : historyList) {
+      historyInfo.put(history.getRevision(), history);
+    }
+
+    if (revision > 0) {
+      V1ControllerRevision history = historyInfo.get(revision);
+      if (history == null) {
+        throw new ApiException("unable to find the specified revision " + revision);
+      }
+      template = parser.parse(history);
+      return;
+    }
+
+    List<Long> revisions = new ArrayList<>(historyInfo.keySet());
+    revisions.sort(Long::compareTo);
+    for (Long revision : revisions) {
+      String changeCause =
+          historyInfo.get(revision).getMetadata().getAnnotations().get(CHANGE_CAUSE_ANNOTATION);
+      if (changeCause == null || changeCause.isEmpty()) {
+        changeCause = "<none>";
+      }
+      histories.add(new History(revision, changeCause));
+    }
+  }
+
+  // controlledHistories returns all ControllerRevisions in namespace that selected by selector and
+  // owned by accessor
+  private List<V1ControllerRevision> controlledHistory(
+      AppsV1Api api, KubernetesObject accessor, LabelSelector selector) throws ApiException {
+    List<V1ControllerRevision> result = new ArrayList<>();
+    V1ControllerRevisionList historyList =
+        api.listNamespacedControllerRevision(
+            namespace, null, null, null, null, selector.toString(), null, null, null, null, null);
+    for (V1ControllerRevision history : historyList.getItems()) {
+      if (isControlledBy(history, accessor)) {
+        result.add(history);
+      }
+    }
+    return result;
+  }
+
+  private boolean isControlledBy(KubernetesObject obj, KubernetesObject owner) {
+    Optional<V1OwnerReference> ref =
+        obj.getMetadata().getOwnerReferences().stream()
+            .filter(r -> r.getController() != null && r.getController())
+            .findAny();
+    return ref.map(
+            v1OwnerReference -> v1OwnerReference.getUid().equals(owner.getMetadata().getUid()))
+        .orElse(false);
+  }
+
   // getChangeCause returns the change-cause annotation of the input object
   private static String getChangeCause(V1ObjectMeta meta) {
     return meta.getAnnotations().get(CHANGE_CAUSE_ANNOTATION);
   }
+
+  // now we just support directive in merge
+  private static String applyDirectivePatch(String origin, String patch) {
+    // todo StrategicPatch?
+    Map<String, Object> patchMap = new JSON().deserialize(patch, Map.class);
+    Map<String, Object> specMap = (Map<String, Object>) patchMap.get("spec");
+    Map<String, Object> templateMap = (Map<String, Object>) specMap.get("template");
+    final String directiveMarker = "$patch";
+    Object directive = templateMap.get(directiveMarker);
+    if (directive == null) {
+      throw new IllegalArgumentException("not a directive patch");
+    }
+    if ("replace".equals(directive)) {
+      // If the patch contains "$patch: replace", don't merge it, just use the
+      // patch directly. Later on, we can add a single level replace that only
+      // affects the map that the $patch is in.
+      templateMap.remove(directiveMarker);
+      return new JSON().serialize(patchMap);
+    }
+    if ("delete".equals(directive)) {
+      // If the patch contains "$patch: delete", don't merge it, just return
+      //  an empty map.
+      specMap.put("template", new HashMap<>());
+      return new JSON().serialize(patchMap);
+    }
+    throw new IllegalArgumentException(
+        "unknown patch type: " + directive + " in map: " + templateMap);
+  }
 }