Merge pull request #2212 from yue9944882/cherrypick-15-regen-openapi

Cherrypick release-15 #2206: Automated Generate from openapi release-1.23

Author: k8s-ci-robot

examples/examples-release-15/src/main/java/io/kubernetes/client/examples/YamlExample.java

@@ -22,8 +22,6 @@
 import io.kubernetes.client.openapi.models.V1PodBuilder;
 import io.kubernetes.client.openapi.models.V1Service;
 import io.kubernetes.client.openapi.models.V1ServiceBuilder;
-import io.kubernetes.client.openapi.models.V1ServicePort;
-import io.kubernetes.client.openapi.models.V1ServiceSpec;
 import io.kubernetes.client.util.Config;
 import io.kubernetes.client.util.Yaml;
 import java.io.File;
@@ -63,10 +61,10 @@ public static void main(String[] args) throws IOException, ApiException, ClassNo
             .withName("aservice")
             .endMetadata()
             .withNewSpec()
-            .withSessionAffinity(V1ServiceSpec.SessionAffinityEnum.CLIENTIP)
-            .withType(V1ServiceSpec.TypeEnum.NODEPORT)
+            .withSessionAffinity("ClientIP")
+            .withType("NodePort")
             .addNewPort()
-            .withProtocol(V1ServicePort.ProtocolEnum.TCP)
+            .withProtocol("TCP")
             .withName("client")
             .withPort(8008)
             .withNodePort(8080)

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

@@ -12,15 +12,10 @@
 */
 package io.kubernetes.client.extended.kubectl;
 
-import static io.kubernetes.client.openapi.models.V1Taint.EffectEnum.NOEXECUTE;
-import static io.kubernetes.client.openapi.models.V1Taint.EffectEnum.NOSCHEDULE;
-import static io.kubernetes.client.openapi.models.V1Taint.EffectEnum.PREFERNOSCHEDULE;
-
 import io.kubernetes.client.extended.kubectl.exception.KubectlException;
 import io.kubernetes.client.openapi.ApiException;
 import io.kubernetes.client.openapi.apis.CoreV1Api;
 import io.kubernetes.client.openapi.models.V1Node;
-import io.kubernetes.client.openapi.models.V1Taint;
 import io.kubernetes.client.util.taints.Taints;
 import io.kubernetes.client.util.taints.Taints.TaintsBuilder;
 import java.io.IOException;
@@ -89,15 +84,15 @@ private V1Node executeInternal() throws KubectlException, ApiException, IOExcept
     return v1.replaceNode(name, node, null, null, null, null);
   }
 
-  private V1Taint.EffectEnum makeEffect(String effect) throws KubectlException {
-    if (effect.equals(NOSCHEDULE.toString())) {
-      return NOSCHEDULE;
+  private Taints.Effect makeEffect(String effect) throws KubectlException {
+    if (effect.equals(Taints.Effect.NO_SCHEDULE.toString())) {
+      return Taints.Effect.NO_SCHEDULE;
     }
-    if (effect.equals(PREFERNOSCHEDULE.toString())) {
-      return PREFERNOSCHEDULE;
+    if (effect.equals(Taints.Effect.PREFER_NO_SCHEDULE.toString())) {
+      return Taints.Effect.PREFER_NO_SCHEDULE;
     }
-    if (effect.equals(NOEXECUTE.toString())) {
-      return NOEXECUTE;
+    if (effect.equals(Taints.Effect.NO_EXECUTE.toString())) {
+      return Taints.Effect.NO_EXECUTE;
     }
     throw new KubectlException("Unknown effect: " + effect);
   }

fluent/src/main/java/io/kubernetes/client/fluent/BaseFluent.java

@@ -14,22 +14,26 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import java.util.stream.Collectors;
 
-public class BaseFluent<F extends io.kubernetes.client.fluent.Fluent<F>>
-    implements io.kubernetes.client.fluent.Fluent<F>, io.kubernetes.client.fluent.Visitable<F> {
-  public static final java.lang.String VISIT = "visit";
-  public final io.kubernetes.client.fluent.VisitableMap _visitables = new VisitableMap();
+public class BaseFluent<F extends Fluent<F>>
+    implements io.kubernetes.client.fluent.Fluent<F>, Visitable<F> {
+  public static final String VISIT = "visit";
+  public final VisitableMap _visitables = new VisitableMap();
 
-  public static <T> io.kubernetes.client.fluent.VisitableBuilder<T, ?> builderOf(T item) {
+  public static <T> VisitableBuilder<T, ?> builderOf(T item) {
     if (item instanceof Editable) {
       Object editor = ((Editable) item).edit();
       if (editor instanceof VisitableBuilder) {
         return (VisitableBuilder<T, ?>) editor;
       }
     }
+
     try {
       return (VisitableBuilder<T, ?>)
           Class.forName(item.getClass().getName() + "Builder")
@@ -40,118 +44,91 @@ public class BaseFluent<F extends io.kubernetes.client.fluent.Fluent<F>>
     }
   }
 
-  public static <T> java.util.List<T> build(
+  public static <T> List<T> build(
       java.util.List<? extends io.kubernetes.client.fluent.Builder<? extends T>> list) {
     return list == null
         ? null
         : new ArrayList<T>(list.stream().map(Builder::build).collect(Collectors.toList()));
   }
 
-  public static <T> java.util.List<T> build(
+  public static <T> Set<T> build(
       java.util.Set<? extends io.kubernetes.client.fluent.Builder<? extends T>> set) {
     return set == null
         ? null
-        : new ArrayList<>(set.stream().map(Builder::build).collect(Collectors.toList()));
+        : new LinkedHashSet<T>(set.stream().map(Builder::build).collect(Collectors.toSet()));
   }
 
   public static <T> java.util.List<T> aggregate(java.util.List<? extends T>... lists) {
     return new ArrayList(
         Arrays.stream(lists).filter(Objects::nonNull).collect(Collectors.toList()));
   }
 
-  public static <T> java.util.Set<T> aggregate(java.util.Set<? extends T>[] sets) {
+  public static <T> java.util.Set<T> aggregate(java.util.Set<? extends T>... sets) {
     return new LinkedHashSet(
         Arrays.stream(sets).filter(Objects::nonNull).collect(Collectors.toSet()));
   }
 
-  public static <V extends io.kubernetes.client.fluent.Visitor<?>, F> java.lang.Boolean canVisit(
-      V visitor, F fluent) {
-    if (visitor instanceof TypedVisitor) {
-      if (!((TypedVisitor) visitor).getType().isAssignableFrom(fluent.getClass())) {
-        return false;
-      }
-    }
-    if (visitor instanceof PathAwareTypedVisitor) {
-      PathAwareTypedVisitor pathAwareTypedVisitor = (PathAwareTypedVisitor) visitor;
-      Class parentType = pathAwareTypedVisitor.getParentType();
-      Class actaulParentType = pathAwareTypedVisitor.getActualParentType();
-      if (!parentType.isAssignableFrom(actaulParentType)) {
-        return false;
-      }
-    }
-    return hasCompatibleVisitMethod(visitor, fluent);
-  }
-
-  public static <V, F> java.lang.Boolean hasCompatibleVisitMethod(V visitor, F fluent) {
-    for (java.lang.reflect.Method method : visitor.getClass().getMethods()) {
-      if (!method.getName().equals(VISIT) || method.getParameterTypes().length != 1) {
-        continue;
-      }
-      Class visitorType = method.getParameterTypes()[0];
-      if (visitorType.isAssignableFrom(fluent.getClass())) {
-        return true;
-      } else {
-        return false;
-      }
-    }
-    return false;
-  }
-
-  public F accept(io.kubernetes.client.fluent.Visitor... visitors) {
-    return isPathAwareVisitorArray(visitors)
-        ? acceptPathAware(asPathAwareVisitorArray(visitors))
-        : acceptInternal(visitors);
+  public F accept(Visitor... visitors) {
+    return accept(Collections.emptyList(), visitors);
   }
 
-  public <V> F accept(java.lang.Class<V> type, io.kubernetes.client.fluent.Visitor<V> visitor) {
+  public <V> F accept(Class<V> type, io.kubernetes.client.fluent.Visitor<V> visitor) {
     return accept(
-        new TypedVisitor<V>() {
+        Collections.emptyList(),
+        new Visitor<V>() {
           @Override
           public Class<V> getType() {
             return type;
           }
 
+          @Override
+          public void visit(List<Object> path, V element) {
+            visitor.visit(path, element);
+          }
+
           @Override
           public void visit(V element) {
             visitor.visit(element);
           }
         });
   }
 
-  public F acceptInternal(io.kubernetes.client.fluent.Visitor<?>... visitors) {
-    for (Visitor visitor : visitors) {
-      for (Visitable visitable : _visitables) {
-        visitable.accept(visitor);
-      }
-
-      if (canVisit(visitor, this)) {
-        visitor.visit(this);
-      }
+  public F accept(java.util.List<Object> path, io.kubernetes.client.fluent.Visitor... visitors) {
+    Arrays.stream(visitors)
+        .map(v -> VisitorListener.wrap(v))
+        .filter(v -> ((Visitor) v).canVisit(path, this))
+        .sorted((l, r) -> ((Visitor) r).order() - ((Visitor) l).order())
+        .forEach(
+            v -> {
+              ((Visitor) v).visit(path, this);
+            });
+
+    List<Object> copyOfPath = path != null ? new ArrayList(path) : new ArrayList<>();
+    copyOfPath.add(this);
+    List<Object> newPath = Collections.unmodifiableList(copyOfPath);
+
+    for (Visitable visitable : _visitables) {
+      Arrays.stream(visitors)
+          .filter(v -> v.getType() != null && v.getType().isAssignableFrom(visitable.getClass()))
+          .forEach(v -> visitable.accept(newPath, v));
+      Arrays.stream(visitors)
+          .filter(v -> v.getType() == null || !v.getType().isAssignableFrom(visitable.getClass()))
+          .forEach(v -> visitable.accept(newPath, v));
     }
     return (F) this;
   }
 
-  private F acceptPathAware(
-      io.kubernetes.client.fluent.PathAwareTypedVisitor<?, ?>... pathAwareTypedVisitors) {
-    return acceptInternal(
-        Arrays.stream(pathAwareTypedVisitors)
-            .map(p -> p.next(this))
-            .toArray(size -> new PathAwareTypedVisitor[size]));
-  }
-
-  private static boolean isPathAwareVisitorArray(
-      io.kubernetes.client.fluent.Visitor<?>[] visitors) {
-    return !Arrays.stream(visitors)
-        .filter(v -> !(v instanceof PathAwareTypedVisitor))
-        .findAny()
-        .isPresent();
+  public int hashCode() {
+    final int prime = 31;
+    int result = 1;
+    result = prime * result + 0;
+    return result;
   }
 
-  private static io.kubernetes.client.fluent.PathAwareTypedVisitor<?, ?>[] asPathAwareVisitorArray(
-      io.kubernetes.client.fluent.Visitor<?>[] visitors) {
-    return Arrays.stream(visitors)
-        .filter(v -> v instanceof PathAwareTypedVisitor)
-        .map(v -> (PathAwareTypedVisitor) v)
-        .toArray(size -> new PathAwareTypedVisitor[size]);
+  public boolean equals(java.lang.Object obj) {
+    if (this == obj) return true;
+    if (obj == null) return false;
+    if (getClass() != obj.getClass()) return false;
+    return true;
   }
 }

fluent/src/main/java/io/kubernetes/client/fluent/Builder.java

@@ -12,7 +12,7 @@
 */
 package io.kubernetes.client.fluent;
 
-@java.lang.FunctionalInterface
+@FunctionalInterface
 public interface Builder<T> {
   T build();
 }

fluent/src/main/java/io/kubernetes/client/fluent/DelegatingVisitor.java

@@ -0,0 +1,46 @@
+/*
+Copyright 2022 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.fluent;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+public class DelegatingVisitor<T> implements Visitor<T> {
+  DelegatingVisitor(Class<T> type, io.kubernetes.client.fluent.Visitor<T> delegate) {
+    this.type = type;
+    this.delegate = delegate;
+  }
+
+  private final java.lang.Class<T> type;
+  private final io.kubernetes.client.fluent.Visitor<T> delegate;
+
+  public java.lang.Class<T> getType() {
+    return type;
+  }
+
+  public void visit(T target) {
+    delegate.visit(target);
+  }
+
+  public int order() {
+    return delegate.order();
+  }
+
+  public void visit(List<Object> path, T target) {
+    delegate.visit(path, target);
+  }
+
+  public <F> Predicate<java.util.List<java.lang.Object>> getRequirement() {
+    return delegate.getRequirement();
+  }
+}

fluent/src/main/java/io/kubernetes/client/fluent/Fluent.java

@@ -12,4 +12,4 @@
 */
 package io.kubernetes.client.fluent;
 
-public interface Fluent<F extends io.kubernetes.client.fluent.Fluent<F>> {}
+public interface Fluent<F extends Fluent<F>> {}

fluent/src/main/java/io/kubernetes/client/fluent/PathAwareTypedVisitor.java

@@ -12,49 +12,33 @@
 */
 package io.kubernetes.client.fluent;
 
-import java.util.ArrayList;
 import java.util.List;
 
-public class PathAwareTypedVisitor<V, P> extends io.kubernetes.client.fluent.TypedVisitor<V> {
-  PathAwareTypedVisitor(java.util.List<java.lang.Object> path) {
-    this.path = path;
-    this.delegate = this;
-    this.parentType = (Class<P>) getTypeArguments(PathAwareTypedVisitor.class, getClass()).get(1);
+public class PathAwareTypedVisitor<V, P> extends TypedVisitor<V> {
+  PathAwareTypedVisitor() {
+    List<Class> args = Visitors.getTypeArguments(PathAwareTypedVisitor.class, getClass());
+    if (args == null || args.isEmpty()) {
+      throw new IllegalStateException(
+          "Could not determine type arguments for path aware typed visitor.");
+    }
+    this.type = (Class<V>) args.get(0);
+    this.parentType = (Class<P>) args.get(1);
   }
 
-  PathAwareTypedVisitor(
-      java.util.List<java.lang.Object> path,
-      io.kubernetes.client.fluent.PathAwareTypedVisitor<V, P> delegate) {
-    this.path = path;
-    this.delegate = this;
-    this.parentType =
-        (Class<P>) getTypeArguments(PathAwareTypedVisitor.class, delegate.getClass()).get(1);
-  }
-
-  java.util.List<java.lang.Object> path;
-  io.kubernetes.client.fluent.PathAwareTypedVisitor<V, P> delegate;
-  java.lang.Class<P> parentType;
+  private final Class<V> type;
+  private final java.lang.Class<P> parentType;
 
-  public void visit(V element) {
-    delegate.path = path;
-    delegate.visit(element);
-  }
-
-  io.kubernetes.client.fluent.PathAwareTypedVisitor<V, P> next(java.lang.Object item) {
-    List<Object> path = new ArrayList<Object>(this.path);
-    path.add(item);
-    return new PathAwareTypedVisitor<V, P>(path, this);
-  }
+  public void visit(V element) {}
 
-  P getParent() {
-    return path.size() - 2 >= 0 ? (P) path.get(path.size() - 2) : null;
+  public void visit(List<Object> path, V element) {
+    visit(element);
   }
 
-  java.lang.Class<P> getParentType() {
-    return parentType != null ? parentType : delegate.getParentType();
+  public P getParent(java.util.List<java.lang.Object> path) {
+    return path.size() - 1 >= 0 ? (P) path.get(path.size() - 1) : null;
   }
 
-  protected java.lang.Class<?> getActualParentType() {
-    return path.size() - 2 >= 0 ? path.get(path.size() - 2).getClass() : Void.class;
+  public java.lang.Class<P> getParentType() {
+    return parentType;
   }
 }