io.fabric8.kubernetes.client.utils.ResourceCompare Maven / Gradle / Ivy

Go to download
/**
 * Copyright (C) 2015 Red Hat, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.fabric8.kubernetes.client.utils;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.fabric8.kubernetes.api.model.KubernetesList;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ResourceCompare {
  private ResourceCompare() {}

  private static TypeReference> TYPE_REF = new TypeReference>(){};

  private static final String METADATA = "metadata";
  private static final String SPEC = "spec";
  private static final String ITEMS = "items";


  /**
   * This method returns true when left Kubernetes resource contains
   * all data that's present in right Kubernetes resource, this method
   * won't consider fields that are missing in right parameters. Values
   * which are present in right would only be compared.
   *
   * @param left kubernetes resource (fetched from cluster)
   * @param right kubernetes resource (provided as input by user)
   * @param  type for kubernetes resource
   *
   * @return boolean value whether both resources are actually equal or not
   */
  public static   boolean equals(T left, T right) {
    ObjectMapper jsonMapper = Serialization.jsonMapper();
    if (left == null && right == null) {
      return true;
    } else if (left == null) {
      return false;
    } else if (right == null) {
      return false;
    }
    Map leftJson = jsonMapper.convertValue(left, TYPE_REF);
    Map rightJson = jsonMapper.convertValue(right, TYPE_REF);

    if (left instanceof KubernetesList) {
      return compareKubernetesList(leftJson, rightJson);
    } else {
      return compareKubernetesResource(leftJson, rightJson);
    }
  }

  public static boolean compareKubernetesList(Map leftJson, Map rightJson) {
    List> leftItems = (List>)leftJson.get(ITEMS);
    List> rightItems = (List>)rightJson.get(ITEMS);

    if (leftItems != null && rightItems != null) {
      if (leftItems.size() != rightItems.size()) {
        return false;
      }

      for (int i = 0; i < rightItems.size(); i++) {
        if (!compareKubernetesResource(leftItems.get(i), rightItems.get(i))) {
          return false;
        }
      }
    } else return leftItems != null;
    return true;
  }

  public static boolean compareKubernetesResource(Map leftJson, Map rightJson) {
    return isEqualMetadata(leftJson, rightJson) &&
      isEqualSpec(leftJson, rightJson);
  }

  private static boolean isEqualMetadata(Map leftMap, Map rightMap) {
    Map leftMetadata = (Map) leftMap.get(METADATA);
    Map rightMetadata = (Map) rightMap.get(METADATA);

    if (leftMetadata == null && rightMetadata == null) {
      return true;
    } else if (leftMetadata != null && rightMetadata == null) {
      return true;
    } else if (leftMetadata == null) {
      return false;
    }

    return isLeftMapSupersetOfRight(leftMetadata, rightMetadata);
  }

  private static boolean isEqualSpec(Map leftMap, Map rightMap) {
    Map leftSpec = (Map) leftMap.get(SPEC);
    Map rightSpec = (Map) rightMap.get(SPEC);

    if (leftSpec == null && rightSpec == null) {
      return true;
    } else if (leftSpec != null && rightSpec == null) {
      return true;
    } else if (leftSpec == null) {
      return false;
    }

    return isLeftMapSupersetOfRight(leftSpec, rightSpec);
  }

  /**
   * Iterates via keys of right map to see if they are present in left map
   *
   * @param leftMap a hashmap of string, object
   * @param rightMap a hashmap of string, object
   * @return boolean value indicating whether left contains all keys and values of right map or not
   */
  private static boolean isLeftMapSupersetOfRight(Map leftMap, Map rightMap) {
    for (Map.Entry entry : rightMap.entrySet()) {
      if (!leftMap.containsKey(entry.getKey())) {
        return false;
      }

      if (!leftMap.get(entry.getKey()).equals(entry.getValue())) {
        return false;
      }
    }
    return true;
  }
}