Merge pull request #1180 from yue9944882/model-mapper-refactor

Enhances and refactors model mapper

Author: k8s-ci-robot

util/src/main/java/io/kubernetes/client/util/ModelMapper.java

@@ -12,8 +12,13 @@
 */
 package io.kubernetes.client.util;
 
+import com.google.common.base.Objects;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.reflect.ClassPath;
+import io.kubernetes.client.Discovery;
+import io.kubernetes.client.common.KubernetesListObject;
+import io.kubernetes.client.common.KubernetesObject;
+import io.kubernetes.client.openapi.ApiException;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -31,12 +36,14 @@
  */
 public class ModelMapper {
 
-  private static Map<String, Class<?>> classes = new HashMap<>();
+  private static final Logger logger = LoggerFactory.getLogger(ModelMapper.class);
+
+  private static Map<GroupVersionKind, Class<?>> classes = new HashMap<>();
+  // Model's api-group prefix to kubernetes api-group
   private static Map<String, String> apiGroups = new HashMap<>();
+  // Model's api-version midfix to kubernetes api-version
   private static List<String> apiVersions = new ArrayList<>();
 
-  private static final Logger logger = LoggerFactory.getLogger(ModelMapper.class);
-
   static {
     try {
       initModelMap();
@@ -46,30 +53,114 @@ public class ModelMapper {
   }
 
   /**
-   * Add a mapping from API Group/version/kind to a Class to use when calling <code>load(...)
-   * </code> .
+   * Registering concrete model classes by its apiGroupVersion (e.g. "apps/v1") and kind (e.g.
+   * "Deployment").
    *
-   * <p>Shouldn't really be needed as most API Group/Version/Kind are loaded dynamically at startup.
+   * <p>Note that the the so-called apiGroupVersion equals to the "apiVersion" in the kubenretes
+   * resource yamls.
    */
   public static void addModelMap(String apiGroupVersion, String kind, Class<?> clazz) {
-    classes.put(apiGroupVersion + "/" + kind, clazz);
+    String[] parts = apiGroupVersion.split("/");
+    if (parts.length == 1) {
+      String version = apiGroupVersion;
+      addModelMap("", version, kind, clazz);
+    }
+    addModelMap(parts[0], parts[1], kind, clazz);
   }
 
-  public static Class<?> getApiTypeClass(String apiVersion, String kind) {
-    Class<?> clazz = (Class<?>) classes.get(apiVersion + "/" + kind);
-    if (clazz == null) {
-      // Attempt to detect class from version and kind alone
-      if (apiVersion.contains("/")) {
-        clazz = (Class<?>) classes.get(apiVersion.split("/")[1] + "/" + kind);
-      }
+  /**
+   * Registering concrete model classes by its group, version and kind (e.g. "apps", "v1",
+   * "Deployment")
+   *
+   * @param group the group
+   * @param version the version
+   * @param kind the kind
+   * @param clazz the clazz
+   */
+  public static void addModelMap(String group, String version, String kind, Class<?> clazz) {
+    classes.put(new GroupVersionKind(group, version, kind), clazz);
+  }
+
+  /**
+   * Gets the model classes by given apiGroupVersion (e.g. "apps/v1") and kind (e.g. "Deployment").
+   *
+   * @param apiGroupVersion the api version
+   * @param kind the kind
+   * @return the api type class
+   */
+  public static Class<?> getApiTypeClass(String apiGroupVersion, String kind) {
+    String[] parts = apiGroupVersion.split("/");
+    if (parts.length == 1) {
+      // legacy group
+      return getApiTypeClass("", apiGroupVersion, kind);
     }
-    return clazz;
+    return getApiTypeClass(parts[0], parts[1], kind);
   }
 
-  public static Map<String, Class<?>> getAllKnownClasses() {
+  /**
+   * Gets the model classes by given group, version and kind (e.g. "apps", ""v1", "Deployment").
+   *
+   * @param group the group
+   * @param version the version
+   * @param kind the kind
+   * @return the api type class
+   */
+  public static Class<?> getApiTypeClass(String group, String version, String kind) {
+    Class<?> clazz = classes.get(new GroupVersionKind(group, version, kind));
+    if (clazz != null) {
+      return clazz;
+    }
+    return classes.get(new GroupVersionKind(null, version, kind));
+  }
+
+  /**
+   * Returns all the registered model classes.
+   *
+   * @return the all known classes
+   */
+  public static Map<GroupVersionKind, Class<?>> getAllKnownClasses() {
     return ImmutableMap.copyOf(classes);
   }
 
+  /**
+   * Gets the GVK by the given model class.
+   *
+   * <p>Note: This method will run a loop over the registered models, consider use {@link
+   * ModelMapper#getAllKnownClasses} and build your own index for faster queries.
+   *
+   * @param clazz the clazz
+   * @return the group version kind by class
+   */
+  public static GroupVersionKind getGroupVersionKindByClass(Class<?> clazz) {
+    return classes.entrySet().stream()
+        .filter(e -> clazz.equals(e.getValue()))
+        .map(e -> e.getKey())
+        .findFirst()
+        .get();
+  }
+
+  /**
+   * Refreshes the model mapping by syncing up w/the api discovery info from the kubernetes
+   * apiserver.
+   *
+   * @param discovery the discovery
+   * @throws ApiException the api exception
+   */
+  public static void refresh(Discovery discovery) throws ApiException {
+    // TODO(yue9944882): integration test it
+    for (Discovery.APIResource apiResource : discovery.findAll()) {
+      for (String version : apiResource.getVersions()) {
+        Class<?> clazz = getApiTypeClass(apiResource.getGroup(), version, apiResource.getKind());
+        if (clazz == null) {
+          continue;
+        }
+        // sync up w/ the latest api discovery
+        classes.remove(getGroupVersionKindByClass(clazz));
+        addModelMap(apiResource.getGroup(), version, apiResource.getKind(), clazz);
+      }
+    }
+  }
+
   private static void initApiGroupMap() {
     apiGroups.put("Admissionregistration", "admissionregistration.k8s.io");
     apiGroups.put("Apiextensions", "apiextensions.k8s.io");
@@ -87,6 +178,7 @@ private static void initApiGroupMap() {
     apiGroups.put("Scheduling", "scheduling.k8s.io");
     apiGroups.put("Settings", "settings.k8s.io");
     apiGroups.put("Storage", "storage.k8s.io");
+    apiGroups.put("FlowControl", "flowcontrol.apiserver.k8s.io");
   }
 
   private static void initApiVersionList() {
@@ -100,20 +192,6 @@ private static void initApiVersionList() {
     apiVersions.add("V1");
   }
 
-  private static Pair<String, String> getApiVersion(String name) {
-    MutablePair<String, String> parts = new MutablePair<>();
-    for (String version : apiVersions) {
-      if (name.startsWith(version)) {
-        parts.left = version.toLowerCase();
-        parts.right = name.substring(version.length());
-        break;
-      }
-    }
-    if (parts.left == null) parts.right = name;
-
-    return parts;
-  }
-
   private static void initModelMap() throws IOException {
     initApiGroupMap();
     initApiVersionList();
@@ -122,29 +200,80 @@ private static void initModelMap() throws IOException {
     Set<ClassPath.ClassInfo> allClasses =
         cp.getTopLevelClasses("io.kubernetes.client.openapi.models");
 
-    for (ClassPath.ClassInfo clazz : allClasses) {
-      String modelName = "";
-      Pair<String, String> nameParts = getApiGroup(clazz.getSimpleName());
-      modelName += nameParts.getLeft() == null ? "" : nameParts.getLeft() + "/";
+    for (ClassPath.ClassInfo classInfo : allClasses) {
+      Class clazz = classInfo.load();
+      if (!KubernetesObject.class.isAssignableFrom(clazz)
+          && !KubernetesListObject.class.isAssignableFrom(clazz)) {
+        continue;
+      }
+
+      Pair<String, String> groupAndOther = getApiGroup(clazz.getSimpleName());
+      Pair<String, String> versionAndOther = getApiVersion(groupAndOther.getRight());
 
-      nameParts = getApiVersion(nameParts.getRight());
-      modelName += nameParts.getLeft() == null ? "" : nameParts.getLeft() + "/";
-      modelName += nameParts.getRight();
+      String group = groupAndOther.getLeft();
+      String version = versionAndOther.getLeft();
+      String kind = versionAndOther.getRight();
 
-      classes.put(modelName, clazz.load());
+      classes.put(new GroupVersionKind(group, version, kind), clazz);
     }
   }
 
   private static Pair<String, String> getApiGroup(String name) {
-    MutablePair<String, String> parts = new MutablePair<>();
-    for (Map.Entry<String, String> entry : apiGroups.entrySet()) {
-      if (name.startsWith(entry.getKey())) {
-        parts.left = entry.getValue();
-        parts.right = name.substring(entry.getKey().length());
-        break;
-      }
+    return apiGroups.entrySet().stream()
+        .filter(e -> name.startsWith(e.getKey()))
+        .map(e -> new MutablePair(e.getValue(), name.substring(e.getKey().length())))
+        .findFirst()
+        .orElse(new MutablePair(null, name));
+  }
+
+  private static Pair<String, String> getApiVersion(String name) {
+    return apiVersions.stream()
+        .filter(v -> name.startsWith(v))
+        .map(v -> new MutablePair(v.toLowerCase(), name.substring(v.length())))
+        .findFirst()
+        .orElse(new MutablePair(null, name));
+  }
+
+  public static class GroupVersionKind {
+
+    public GroupVersionKind(String group, String version, String kind) {
+      this.group = group;
+      this.version = version;
+      this.kind = kind;
+    }
+
+    private String group;
+    private String version;
+    private String kind;
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      GroupVersionKind that = (GroupVersionKind) o;
+      return Objects.equal(group, that.group)
+          && Objects.equal(version, that.version)
+          && Objects.equal(kind, that.kind);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(group, version, kind);
+    }
+
+    @Override
+    public String toString() {
+      return "GroupVersionKind{"
+          + "group='"
+          + group
+          + '\''
+          + ", version='"
+          + version
+          + '\''
+          + ", kind='"
+          + kind
+          + '\''
+          + '}';
     }
-    if (parts.left == null) parts.right = name;
-    return parts;
   }
 }

util/src/test/java/io/kubernetes/client/util/ModelMapperTest.java

@@ -0,0 +1,104 @@
+/*
+Copyright 2020 The Kubernetes Authors.
+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.kubernetes.client.util;
+
+import static org.junit.Assert.*;
+
+import io.kubernetes.client.Discovery;
+import io.kubernetes.client.openapi.ApiException;
+import io.kubernetes.client.openapi.models.V1Deployment;
+import io.kubernetes.client.openapi.models.V1Pod;
+import io.kubernetes.client.openapi.models.V1beta1CustomResourceDefinition;
+import java.io.IOException;
+import java.util.Map;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class ModelMapperTest {
+
+  @Test
+  public void testPrebuiltModelMapping() {
+
+    Map<ModelMapper.GroupVersionKind, Class<?>> maps = ModelMapper.getAllKnownClasses();
+    assertTrue(maps.size() > 0);
+
+    assertEquals(V1Pod.class, ModelMapper.getApiTypeClass("", "v1", "Pod"));
+    assertEquals(V1Pod.class, ModelMapper.getApiTypeClass("v1", "Pod"));
+
+    assertEquals(V1Deployment.class, ModelMapper.getApiTypeClass("", "v1", "Deployment"));
+    assertEquals(V1Deployment.class, ModelMapper.getApiTypeClass("apps/v1", "Deployment"));
+
+    assertEquals(
+        V1beta1CustomResourceDefinition.class,
+        ModelMapper.getApiTypeClass("apiextensions.k8s.io/v1beta1", "CustomResourceDefinition"));
+    assertEquals(
+        V1beta1CustomResourceDefinition.class,
+        ModelMapper.getApiTypeClass("apiextensions.k8s.io", "v1beta1", "CustomResourceDefinition"));
+  }
+
+  @Test
+  public void testAddingModel() {
+    Class objClass =
+        new Object() {
+          {
+          }
+        }.getClass();
+
+    ModelMapper.addModelMap("example.io", "v1", "Toss", objClass);
+
+    assertEquals(objClass, ModelMapper.getApiTypeClass("example.io/v1", "Toss"));
+    assertEquals(objClass, ModelMapper.getApiTypeClass("example.io", "v1", "Toss"));
+
+    assertNull(ModelMapper.getApiTypeClass("example.io/V1", "Toss"));
+    assertNull(ModelMapper.getApiTypeClass("example.io", "V1", "Toss"));
+
+    assertNull(ModelMapper.getApiTypeClass("example.io/v1", "Tofu"));
+    assertNull(ModelMapper.getApiTypeClass("example.io", "v1", "Tofu"));
+  }
+
+  @Test
+  public void testGetClassByKind() {
+    assertEquals(
+        new ModelMapper.GroupVersionKind(null, "v1", "Pod"),
+        ModelMapper.getGroupVersionKindByClass(V1Pod.class));
+
+    assertEquals(
+        new ModelMapper.GroupVersionKind(null, "v1", "Pod"),
+        ModelMapper.getGroupVersionKindByClass(V1Pod.class));
+    assertEquals(
+        new ModelMapper.GroupVersionKind(null, "v1", "Deployment"),
+        ModelMapper.getGroupVersionKindByClass(V1Deployment.class));
+    assertEquals(
+        new ModelMapper.GroupVersionKind(null, "v1beta1", "CustomResourceDefinition"),
+        ModelMapper.getGroupVersionKindByClass(V1beta1CustomResourceDefinition.class));
+  }
+
+  @Test
+  @Ignore
+  public void test() throws IOException, ApiException {
+    // TODO(yue9944882): move this to an integration test
+    Discovery discovery = new Discovery(ClientBuilder.defaultClient());
+    ModelMapper.refresh(discovery);
+
+    assertEquals(
+        new ModelMapper.GroupVersionKind("", "v1", "Pod"),
+        ModelMapper.getGroupVersionKindByClass(V1Pod.class));
+    assertEquals(
+        new ModelMapper.GroupVersionKind("apps", "v1", "Deployment"),
+        ModelMapper.getGroupVersionKindByClass(V1Deployment.class));
+    assertEquals(
+        new ModelMapper.GroupVersionKind(
+            "apiextensions.k8s.io", "v1beta1", "CustomResourceDefinition"),
+        ModelMapper.getGroupVersionKindByClass(V1beta1CustomResourceDefinition.class));
+  }
+}