io.fabric8.kubernetes.api.builder.VisitableBuilder Java Examples

@Override
public List<HasMetadata> get() {
    if (fromServer) {
        List<HasMetadata> result = new ArrayList<>();
        for (HasMetadata meta : acceptVisitors(asHasMetadata(item, true), visitors)) {
            ResourceHandler<HasMetadata, ? extends VisitableBuilder> h = handlerOf(meta);
            HasMetadata reloaded = h.reload(client, config, meta.getMetadata().getNamespace(), meta);
            if (reloaded != null) {
                HasMetadata edited = reloaded;
                //Let's apply any visitor that might have been specified.
                for (Visitor v : visitors) {
                    h.edit(edited).accept(v).build();
                }
                result.add(reloaded);
            }
        }
        return result;
    } else {
        return acceptVisitors(asHasMetadata(item, true), visitors);
    }
}
 

@Override
public HasMetadata get() {
  if (fromServer) {
    HasMetadata meta = acceptVisitors(asHasMetadata(item), visitors);
    ResourceHandler<HasMetadata, ? extends VisitableBuilder> h = handlerOf(meta);
    HasMetadata reloaded = h.reload(client, config, meta.getMetadata().getNamespace(), meta);
    if (reloaded != null) {
      HasMetadata edited = reloaded;
      //Let's apply any visitor that might have been specified.
      for (Visitor v : visitors) {
        edited = h.edit(edited).accept(v).build();
      }
      return edited;
    }
    return null;
  } else {
    return acceptVisitors(asHasMetadata(item), visitors);
  }
}
 

@Override
public void visit(VisitableBuilder builder) {
  Optional<ObjectMeta> objectMeta = getMetadata(builder);
  if (!objectMeta.isPresent()) {
    return;
  }
  if (Strings.isNullOrEmpty(taskName)
      || objectMeta.map(m -> m.getName()).filter(s -> s.equals(taskName)).isPresent()) {
    builder.accept(taskVisitor);
  }
}
 

private static List<HasMetadata> acceptVisitors(List<HasMetadata> list, List<Visitor> visitors) {
  List<HasMetadata> result = new ArrayList<>();
  for (HasMetadata item : list) {
    ResourceHandler<HasMetadata, HasMetadataVisitiableBuilder> h = handlerOf(item);
    VisitableBuilder<HasMetadata, ?> builder = h.edit(item);

    //Let's apply any visitor that might have been specified.
    for (Visitor v : visitors) {
      builder.accept(v);
    }
    result.add(builder.build());
  }
  return result;
}
 

private static HasMetadata acceptVisitors(HasMetadata item, List<Visitor> visitors) {
  ResourceHandler<HasMetadata, HasMetadataVisitiableBuilder> h = handlerOf(item);
  VisitableBuilder<HasMetadata, ?> builder = h.edit(item);

  //Let's apply any visitor that might have been specified.
  for (Visitor v : visitors) {
    builder.accept(v);
  }
  return builder.build();
}
 

private <T extends HasMetadata, V extends VisitableBuilder<T, V>> T create(T resource) {
  ResourceHandler<T, V> handler = Handlers.get(resource.getKind(), resource.getApiVersion());
  if (handler != null) {
    return handler.create(client, config, namespace, resource);
  }
  throw new IllegalStateException("Could not find handler");
}
 

private static List<HasMetadata> acceptVisitors(List<HasMetadata> list, List<Visitor> visitors) {
    List<HasMetadata> result = new ArrayList<>();
    for (HasMetadata item : list) {
        ResourceHandler<HasMetadata, HasMetadataVisitiableBuilder> h = handlerOf(item);
        VisitableBuilder<HasMetadata, ?> builder = h.edit(item);

        //Let's apply any visitor that might have been specified.
        for (Visitor v : visitors) {
            builder.accept(v);
        }
        result.add(builder.build());
    }
    return result;
}
 

/**
 * Create a {@link Predicate} that checks that a resource builder doesn't match the name and kind.
 * @param kind The specified kind.
 * @param name The specified name.
 * @return The predicate.
 */
public static Predicate<VisitableBuilder<? extends HasMetadata, ?>> matching(String apiVersion, String kind, String name) {
  return new Predicate<VisitableBuilder<? extends HasMetadata, ?>>() {
    @Override
    public Boolean apply(VisitableBuilder<? extends HasMetadata, ?> builder) {
      HasMetadata item = builder.build();
      ObjectMeta metadata = item.getMetadata();
      return apiVersion.equals(item.getApiVersion()) &&
        kind != null && kind.equals(item.getKind()) &&
        name != null && name.equals(metadata.getName());
    }
  };
}
 

@Override
public void visit(VisitableBuilder builder) {
  Optional<ObjectMeta> objectMeta = getMetadata(builder);
  if (!objectMeta.isPresent()) {
    return;
  }
  if (Strings.isNullOrEmpty(pipelineName)
      || objectMeta.map(m -> m.getName()).filter(s -> s.equals(pipelineName)).isPresent()) {
    builder.accept(pipelineVisitor);
  }
}
 

@Override
public void visit(VisitableBuilder builder) {
  Optional<ObjectMeta> objectMeta = getMetadata(builder);
  if (!objectMeta.isPresent()) {
    return;
  }
  if (Strings.isNullOrEmpty(name)) {
    builder.accept(visitor.withMetadata(objectMeta.get()));
  } else if (objectMeta.map(m -> m.getName()).filter(s -> s.equals(name)).isPresent()) {
    builder.accept(visitor.withMetadata(objectMeta.get()));
  }
}
 

@Override
public void visit(VisitableBuilder builder) {
  Optional<ObjectMeta> objectMeta = getMetadata(builder);
  if (!objectMeta.isPresent()) {
    return;
  }
  if (Strings.isNullOrEmpty(deploymentName) || objectMeta.map(m -> m.getName()).filter(s -> s.equals(deploymentName)).isPresent()) {
    builder.accept(deploymentVisitor);
  }
}
 

@Override
public void visit(VisitableBuilder builder) {
  Optional<ObjectMeta> objectMeta = getMetadata(builder);
  if (!objectMeta.isPresent()) {
    return;
  }
  if (Strings.isNullOrEmpty(taskName) || objectMeta.map(m -> m.getName()).filter(s -> s.equals(taskName)).isPresent()) {
    builder.accept(deploymentVisitor);
  }
}
 

public static <T extends HasMetadata, V extends VisitableBuilder<T, V>> ResourceHandler<T, V> get(String kind, String apiVersion, ClassLoader classLoader) {
 return get(new ResourceHandler.Key(kind.toLowerCase(Locale.ROOT), apiVersion), classLoader);
}
 

public static <T extends HasMetadata, V extends VisitableBuilder<T, V>> ResourceHandler<T, V> get(String kind, String apiVersion) {
  return get(kind, apiVersion, Thread.currentThread().getContextClassLoader());
}
 

public static <T extends HasMetadata, V extends VisitableBuilder<T, V>> void unregister(ResourceHandler<T,V> handler) {
  RESOURCE_HANDLER_MAP.remove(new ResourceHandler.Key(handler.getKind().toLowerCase(Locale.ROOT), handler.getApiVersion()));
}
 

public static <T extends HasMetadata, V extends VisitableBuilder<T, V>> void register(ResourceHandler<T,V> handler) {
  RESOURCE_HANDLER_MAP.put(new ResourceHandler.Key(handler.getKind().toLowerCase(Locale.ROOT), handler.getApiVersion()), handler);
}
 

public static <T extends HasMetadata, V extends VisitableBuilder<T, V>> ResourceHandler<T, V> get(ResourceHandler.Key key) {
  return get(key, Thread.currentThread().getContextClassLoader());
}
 

public DefaultConfiguration(VisitableBuilder<C, ?> builder) {
  super(builder);
}
 

public ConfigurationSupplier (VisitableBuilder<C, ?> builder, boolean explicit) {
  this.builder = builder; 
  this.explicit = explicit;
}
 

public ConfigurationSupplier (VisitableBuilder<C, ?> builder) {
  this(builder, false);
}
 

public PropertyConfiguration(VisitableBuilder<C, ?> builder) {
  super(builder, true);
}
 

public AnnotationConfiguration(VisitableBuilder<C, ?> builder) {
  super(builder, true);
}
 

/**
 * Create a {@link Predicate} that checks that a resource builder doesn't match the name and kind.
 * @param HasMetadata The specified resource.
 * @return The predicate.
 */
public static Predicate<VisitableBuilder<? extends HasMetadata, ?>> matching(HasMetadata candidate) {
  return matching(candidate.getApiVersion(), candidate.getKind(), candidate.getMetadata().getName());
}