Clean checkstyle

Author: rjeberhard

json-schema/src/main/java/oracle/kubernetes/json/SchemaGenerator.java

@@ -421,7 +421,7 @@ private void generateObjectTypeIn(Map<String, Object> result, Class<?> type) {
       result.put("type", "string");
       result.put("format", "date-time");
     } else {
-      Map<String, Object> properties = new HashMap<>();
+      final Map<String, Object> properties = new HashMap<>();
       List<String> requiredFields = new ArrayList<>();
       result.put("type", "object");
       if (includeAdditionalProperties) result.put("additionalProperties", "false");

operator/src/main/java/oracle/kubernetes/operator/Main.java

@@ -422,6 +422,13 @@ private static Collection<String> getTargetNamespaces(String tnValue, String nam
     return targetNamespaces;
   }
 
+  private static Collection<String> getTargetNamespaces() {
+    return getTargetNamespaces(
+            Optional.ofNullable(System.getenv("OPERATOR_TARGET_NAMESPACES"))
+                    .orElse(tuningAndConfig.get("targetNamespaces")),
+            operatorNamespace);
+  }
+
   private static void startRestServer(String principal, Collection<String> targetNamespaces)
       throws Exception {
     RestServer.create(new RestConfigImpl(principal, targetNamespaces));
@@ -504,13 +511,6 @@ private static String computeOperatorNamespace() {
     return Optional.ofNullable(System.getenv("OPERATOR_NAMESPACE")).orElse("default");
   }
 
-  private static Collection<String> getTargetNamespaces() {
-    return getTargetNamespaces(
-        Optional.ofNullable(System.getenv("OPERATOR_TARGET_NAMESPACES"))
-            .orElse(tuningAndConfig.get("targetNamespaces")),
-        operatorNamespace);
-  }
-
   private static class DomainListStep extends ResponseStep<DomainList> {
     private final String ns;
 

operator/src/main/java/oracle/kubernetes/operator/calls/SynchronousCallDispatcher.java

@@ -1,3 +1,7 @@
+// Copyright 2017, 2019, Oracle Corporation and/or its affiliates.  All rights reserved.
+// Licensed under the Universal Permissive License v 1.0 as shown at
+// http://oss.oracle.com/licenses/upl.
+
 package oracle.kubernetes.operator.calls;
 
 import io.kubernetes.client.ApiClient;

operator/src/main/java/oracle/kubernetes/operator/helpers/CheckFactory.java

@@ -0,0 +1,45 @@
+// Copyright 2019, Oracle Corporation and/or its affiliates.  All rights reserved.
+// Licensed under the Universal Permissive License v 1.0 as shown at
+// http://oss.oracle.com/licenses/upl.
+
+package oracle.kubernetes.operator.helpers;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+class CheckFactory {
+  static <T> CompatibilityCheck create(String description, List<T> expected, List<T> actual) {
+    if (canBeMap(expected) && canBeMap(actual))
+      return new CompatibleMaps<>(description, asMap(expected), asMap(actual));
+    else return new CompatibleSets<>(description, expected, actual);
+  }
+
+  private static <T> boolean canBeMap(List<T> list) {
+    return asMap(list) != null;
+  }
+
+  private static <T> Map<String, T> asMap(List<T> values) {
+    if (values == null) return Collections.emptyMap();
+    Map<String, T> result = new HashMap<>();
+    for (T value : values) {
+      String key = getKey(value);
+      if (key == null) return null;
+      result.put(key, value);
+    }
+
+    return result;
+  }
+
+  private static <T> String getKey(T value) {
+    try {
+      Method getKey = value.getClass().getDeclaredMethod("getName");
+      return (String) getKey.invoke(value);
+    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+      return null;
+    }
+  }
+}

operator/src/main/java/oracle/kubernetes/operator/helpers/CollectiveCompatibility.java

@@ -0,0 +1,57 @@
+// Copyright 2019, Oracle Corporation and/or its affiliates.  All rights reserved.
+// Licensed under the Universal Permissive License v 1.0 as shown at
+// http://oss.oracle.com/licenses/upl.
+
+package oracle.kubernetes.operator.helpers;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+abstract class CollectiveCompatibility implements CompatibilityCheck {
+  protected List<CompatibilityCheck> checks = new ArrayList<>();
+
+  void add(CompatibilityCheck check) {
+    checks.add(check);
+  }
+
+  protected <T> void add(String description, T expected, T actual) {
+    add(new Equality(description, expected, actual));
+  }
+
+  void addAll(Collection<CompatibilityCheck> checks) {
+    this.checks.addAll(checks);
+  }
+
+  @Override
+  public boolean isCompatible() {
+    for (CompatibilityCheck check : checks) if (!check.isCompatible()) return false;
+
+    return true;
+  }
+
+  @Override
+  public String getIncompatibility() {
+    final List<String> reasons = new ArrayList<>();
+    for (CompatibilityCheck check : checks)
+      if (!check.isCompatible()) reasons.add(getIndent() + check.getIncompatibility());
+    return reasons.isEmpty() ? null : getHeader() + String.join("\n", reasons);
+  }
+
+  <T> void addSets(String description, List<T> expected, List<T> actual) {
+    add(CheckFactory.create(description, expected, actual));
+  }
+
+  @SuppressWarnings("SameParameterValue")
+  <T> void addSetsIgnoring(String description, List<T> expected, List<T> actual, String... keys) {
+    add(CheckFactory.create(description, expected, actual).ignoring(keys));
+  }
+
+  String getHeader() {
+    return "";
+  }
+
+  String getIndent() {
+    return "";
+  }
+}

operator/src/main/java/oracle/kubernetes/operator/helpers/CompatibilityCheck.java

@@ -0,0 +1,15 @@
+// Copyright 2019, Oracle Corporation and/or its affiliates.  All rights reserved.
+// Licensed under the Universal Permissive License v 1.0 as shown at
+// http://oss.oracle.com/licenses/upl.
+
+package oracle.kubernetes.operator.helpers;
+
+interface CompatibilityCheck {
+  boolean isCompatible();
+
+  String getIncompatibility();
+
+  default CompatibilityCheck ignoring(String... keys) {
+    return this;
+  }
+}

operator/src/main/java/oracle/kubernetes/operator/helpers/CompatibleMaps.java

@@ -0,0 +1,69 @@
+// Copyright 2019, Oracle Corporation and/or its affiliates.  All rights reserved.
+// Licensed under the Universal Permissive License v 1.0 as shown at
+// http://oss.oracle.com/licenses/upl.
+
+package oracle.kubernetes.operator.helpers;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import static oracle.kubernetes.operator.helpers.PodCompatibility.getMissingElements;
+
+class CompatibleMaps<K, V> implements CompatibilityCheck {
+  private final String description;
+  private final Map<K, V> expected;
+  private final Map<K, V> actual;
+  private List<String> ignoredKeys = new ArrayList<>();
+
+  CompatibleMaps(String description, Map<K, V> expected, Map<K, V> actual) {
+    this.description = description;
+    this.expected = expected;
+    this.actual = actual;
+  }
+
+  @Override
+  public boolean isCompatible() {
+    for (K key : expected.keySet()) if (isKeyToCheck(key) && isIncompatible(key)) return false;
+    return true;
+  }
+
+  private boolean isKeyToCheck(K key) {
+    return !ignoredKeys.contains(key.toString());
+  }
+
+  private boolean isIncompatible(K key) {
+    return !actual.containsKey(key) || valuesDiffer(key);
+  }
+
+  private boolean valuesDiffer(K key) {
+    return !Objects.equals(expected.get(key), actual.get(key));
+  }
+
+  @Override
+  public String getIncompatibility() {
+    StringBuilder sb = new StringBuilder();
+
+    Set<K> missingKeys = getMissingElements(expected.keySet(), actual.keySet());
+    if (!missingKeys.isEmpty())
+      sb.append(String.format("actual %s has no entry for '%s'%n", description, missingKeys));
+
+    for (K key : expected.keySet())
+      if (isKeyToCheck(key) && actual.containsKey(key) && valuesDiffer(key))
+        sb.append(
+            String.format(
+                "actual %s has entry '%s' with value '%s' rather than '%s'%n",
+                description, key, actual.get(key), expected.get(key)));
+
+    return sb.toString();
+  }
+
+  @Override
+  public CompatibilityCheck ignoring(String... keys) {
+    ignoredKeys.addAll(Arrays.asList(keys));
+    return this;
+  }
+}

operator/src/main/java/oracle/kubernetes/operator/helpers/CompatibleSets.java

@@ -0,0 +1,34 @@
+// Copyright 2019, Oracle Corporation and/or its affiliates.  All rights reserved.
+// Licensed under the Universal Permissive License v 1.0 as shown at
+// http://oss.oracle.com/licenses/upl.
+
+package oracle.kubernetes.operator.helpers;
+
+import java.util.Collection;
+
+import static oracle.kubernetes.operator.helpers.PodCompatibility.asSet;
+import static oracle.kubernetes.operator.helpers.PodCompatibility.getMissingElements;
+
+class CompatibleSets<T> implements CompatibilityCheck {
+  private String description;
+  private final Collection<T> expected;
+  private final Collection<T> actual;
+
+  CompatibleSets(String description, Collection<T> expected, Collection<T> actual) {
+    this.description = description;
+    this.expected = expected;
+    this.actual = actual;
+  }
+
+  @Override
+  public boolean isCompatible() {
+    if (expected == actual) return true;
+    return asSet(actual).containsAll(asSet(expected));
+  }
+
+  @Override
+  public String getIncompatibility() {
+    return String.format(
+        "actual %s does not have %s", description, getMissingElements(expected, actual));
+  }
+}

operator/src/main/java/oracle/kubernetes/operator/helpers/ConflictRetry.java

@@ -15,6 +15,9 @@
 public interface ConflictRetry<T> {
 
   /**
+   * The latest version of the kubernetes object for passing to the kubernetes API, or null if the
+   * API should not be retried.
+   *
    * @return The latest version of the kubernetes object for passing to the kubernetes API, or null
    *     if the API should not be retried.
    */

operator/src/main/java/oracle/kubernetes/operator/helpers/DomainPresenceInfo.java

@@ -188,6 +188,10 @@ private V1ObjectMeta getMetadata(V1Pod pod) {
     return pod == null ? null : pod.getMetadata();
   }
 
+  private V1ObjectMeta getMetadata(V1Service service) {
+    return service == null ? null : service.getMetadata();
+  }
+  
   /**
    * Computes the result of a delete attempt. If the current pod is newer than the one associated
    * with the delete event, returns it; otherwise returns null, thus deleting the value.
@@ -209,6 +213,18 @@ private V1Pod getNewerCurrentOrNull(V1Pod pod, V1Pod event) {
     return KubernetesUtils.isFirstNewer(getMetadata(pod), getMetadata(event)) ? pod : null;
   }
 
+  /**
+   * Computes the result of a delete attempt. If the current service is newer than the one
+   * associated with the delete event, returns it; otherwise returns null, thus deleting the value.
+   *
+   * @param service the current service
+   * @param event the service associated with the delete event
+   * @return the new value for the service.
+   */
+  private V1Service getNewerCurrentOrNull(V1Service service, V1Service event) {
+    return KubernetesUtils.isFirstNewer(getMetadata(service), getMetadata(event)) ? service : null;
+  }
+
   /**
    * Removes the pod associated with the specified server name, if any.
    *
@@ -277,18 +293,6 @@ boolean deleteServerServiceFromEvent(String serverName, V1Service event) {
     return deletedService != null;
   }
 
-  /**
-   * Computes the result of a delete attempt. If the current service is newer than the one
-   * associated with the delete event, returns it; otherwise returns null, thus deleting the value.
-   *
-   * @param service the current service
-   * @param event the service associated with the delete event
-   * @return the new value for the service.
-   */
-  private V1Service getNewerCurrentOrNull(V1Service service, V1Service event) {
-    return KubernetesUtils.isFirstNewer(getMetadata(service), getMetadata(event)) ? service : null;
-  }
-
   void removeClusterService(String clusterName) {
     clusters.remove(clusterName);
   }
@@ -328,10 +332,6 @@ private V1Service getNewerService(V1Service first, V1Service second) {
     return KubernetesUtils.isFirstNewer(getMetadata(first), getMetadata(second)) ? first : second;
   }
 
-  private V1ObjectMeta getMetadata(V1Service service) {
-    return service == null ? null : service.getMetadata();
-  }
-
   public V1Service getExternalService(String serverName) {
     return getSko(serverName).getExternalService().get();
   }