io.fabric8.kubernetes.client.dsl.internal.NamespaceVisitFromServerGetWatchDeleteRecreateWaitApplicableImpl 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.dsl.internal;

import io.fabric8.kubernetes.api.builder.TypedVisitor;
import io.fabric8.kubernetes.api.builder.VisitableBuilder;
import io.fabric8.kubernetes.api.builder.Visitor;
import io.fabric8.kubernetes.api.model.DeletionPropagation;
import io.fabric8.kubernetes.api.model.HasMetadata;
import io.fabric8.kubernetes.api.model.ListOptions;
import io.fabric8.kubernetes.api.model.ObjectMetaBuilder;
import io.fabric8.kubernetes.client.BaseClient;
import io.fabric8.kubernetes.client.ClientContext;
import io.fabric8.kubernetes.client.Handlers;
import io.fabric8.kubernetes.client.KubernetesClientException;
import io.fabric8.kubernetes.client.ResourceHandler;
import io.fabric8.kubernetes.client.Watch;
import io.fabric8.kubernetes.client.Watcher;
import io.fabric8.kubernetes.client.dsl.Applicable;
import io.fabric8.kubernetes.client.dsl.CascadingDeletable;
import io.fabric8.kubernetes.client.dsl.Deletable;
import io.fabric8.kubernetes.client.dsl.Gettable;
import io.fabric8.kubernetes.client.dsl.NamespaceVisitFromServerGetWatchDeleteRecreateWaitApplicable;
import io.fabric8.kubernetes.client.dsl.Readiable;
import io.fabric8.kubernetes.client.dsl.Resource;
import io.fabric8.kubernetes.client.dsl.VisitFromServerGetWatchDeleteRecreateWaitApplicable;
import io.fabric8.kubernetes.client.dsl.VisitFromServerWritable;
import io.fabric8.kubernetes.client.dsl.Waitable;
import io.fabric8.kubernetes.client.dsl.base.HasMetadataOperation;
import io.fabric8.kubernetes.client.dsl.base.OperationContext;
import io.fabric8.kubernetes.client.internal.readiness.Readiness;
import io.fabric8.kubernetes.client.utils.KubernetesResourceUtil;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

import static io.fabric8.kubernetes.client.utils.DeleteAndCreateHelper.deleteAndCreateItem;

/**
 * Resource like operation with specific namespace rules.
 * 
If the item has a namespace, it is the default (unlike other operations)
 * 
If the user call inNamespace, that will be used
 * 
else the default namespace from the config will be used
 */
public class NamespaceVisitFromServerGetWatchDeleteRecreateWaitApplicableImpl implements
  NamespaceVisitFromServerGetWatchDeleteRecreateWaitApplicable,
  Waitable,
  Readiable {

  private final NamespaceVisitOperationContext namespaceVisitOperationContext;
  private final OperationContext context;

  static class ChangeNamespace extends TypedVisitor {

    private final String explicitNamespace;

    ChangeNamespace(String explicitNamespace) {
      this.explicitNamespace = explicitNamespace;
    }

    @Override
    public void visit(ObjectMetaBuilder builder) {
      builder.withNamespace(explicitNamespace);
    }
  }

  public NamespaceVisitFromServerGetWatchDeleteRecreateWaitApplicableImpl(OperationContext context, NamespaceVisitOperationContext namespaceVisitOperationContext) {
    this.context = context;
    this.namespaceVisitOperationContext = namespaceVisitOperationContext;
  }

  public NamespaceVisitFromServerGetWatchDeleteRecreateWaitApplicableImpl(ClientContext clientContext, HasMetadata item) {
    this(HasMetadataOperationsImpl.defaultContext(clientContext).withItem(item), new NamespaceVisitOperationContext());
    handlerOf(item, this.context); // validate the handler
  }

  @Override
  public HasMetadata apply() {
    return createOrReplace();
  }

  @Override
  public HasMetadata createOrReplace() {
    if (namespaceVisitOperationContext.isDeletingExisting()) {
      return deleteAndCreateItem(get(), getResource());
    }
    return getResource().createOrReplace(get());
  }

  @Override
  public Waitable createOrReplaceAnd() {
    HasMetadata item = createOrReplace();
    return newInstance(context.withItem(item), namespaceVisitOperationContext);
  }

  @Override
  public Boolean delete() {
    return getResource().delete();
  }

  @Override
  public HasMetadata get() {
    if (!context.isReloadingFromServer()) {
      return (HasMetadata) context.getItem();
    }
    return getResource().get();
  }

  @Override
  public VisitFromServerGetWatchDeleteRecreateWaitApplicable inNamespace(String explicitNamespace) {
    HasMetadata item = acceptVisitors(get(), Collections.emptyList(), explicitNamespace, this.context);
    return newInstance(context.withItem(item).withNamespace(explicitNamespace), namespaceVisitOperationContext.withExplicitNamespace(explicitNamespace));
  }

  @Override
  public Gettable fromServer() {
    return getResource().fromServer();
  }

  @Override
  public Applicable deletingExisting() {
    return newInstance(context, namespaceVisitOperationContext.withDeletingExisting(true));
  }

  @Override
  public VisitFromServerGetWatchDeleteRecreateWaitApplicable accept(Visitor... visitors) {
    HasMetadata item = acceptVisitors(get(), Arrays.asList(visitors), namespaceVisitOperationContext.getExplicitNamespace(), this.context);
    return newInstance(context.withItem(item), namespaceVisitOperationContext);
  }

  @Override
  public CascadingDeletable withGracePeriod(long gracePeriodSeconds) {
    return newInstance(context.withGracePeriodSeconds(gracePeriodSeconds), namespaceVisitOperationContext);
  }

  @Override
  public CascadingDeletable withPropagationPolicy(DeletionPropagation propagationPolicy) {
    return newInstance(context.withPropagationPolicy(propagationPolicy), namespaceVisitOperationContext);
  }

  @Override
  public Deletable cascading(boolean cascading) {
    return getResource().cascading(cascading);
  }

  @Override
  public Waitable withWaitRetryBackoff(long initialBackoff, TimeUnit backoffUnit, double backoffMultiplier) {
    return this;
  }

  @Override
  public Watch watch(Watcher watcher) {
    return getResource().watch(watcher);
  }

  @Override
  public Watch watch(String resourceVersion, Watcher watcher) {
    return getResource().watch(resourceVersion, watcher);
  }

  @Override
  public Watch watch(ListOptions options, Watcher watcher) {
    return getResource().watch(options, watcher);
  }
  
  Resource getResource() {
    HasMetadata meta = (HasMetadata) context.getItem();
    ResourceHandler handler = handlerOf(meta, context);
    HasMetadataOperation> operation = handler.operation(context, null);
    return operation.newInstance(context).inNamespace(KubernetesResourceUtil.getNamespace(meta)).withName(KubernetesResourceUtil.getName(meta));
  }

  protected Readiness getReadiness() {
    return Readiness.getInstance();
  }

  @Override
  public final boolean isReady() {
    HasMetadata meta = fromServer().get();
    if (meta == null) {
      return false;
    }
    return getReadiness().isReady(meta);
  }

  @Override
  public HasMetadata waitUntilReady(long amount, TimeUnit timeUnit) {
    return getResource().waitUntilReady(amount, timeUnit);
  }

  @Override
  public VisitFromServerWritable dryRun(boolean isDryRun) {
    return newInstance(context.withDryRun(isDryRun), namespaceVisitOperationContext);
  }

  public NamespaceVisitFromServerGetWatchDeleteRecreateWaitApplicableImpl newInstance(OperationContext context, NamespaceVisitOperationContext namespaceVisitOperationContext) {
    return new NamespaceVisitFromServerGetWatchDeleteRecreateWaitApplicableImpl(context, namespaceVisitOperationContext);
  }
  
  @Override
  public HasMetadata waitUntilCondition(Predicate condition, long amount, TimeUnit timeUnit) {
    return getResource().waitUntilCondition(condition, amount, timeUnit);
  }
  
  @Override
  public  HasMetadata edit(Class visitorType, Visitor visitor) {
    return getResource().edit(visitorType, visitor);
  }
  
  @Override
  public HasMetadata edit(UnaryOperator function) {
    return getResource().edit(function);
  }
  
  @Override
  public HasMetadata edit(Visitor... visitors) {
    return getResource().edit(visitors);
  }
  
  @Override
  public HasMetadata accept(Consumer function) {
    return getResource().accept(function);
  }
  
  static HasMetadata acceptVisitors(HasMetadata item, List visitors, String explicitNamespace, OperationContext context) {
    ResourceHandler h = handlerOf(item, context);
    VisitableBuilder builder = h.edit(item);

    //Let's apply any visitor that might have been specified.
    for (Visitor v : visitors) {
      builder.accept(v);
    }
    if (explicitNamespace != null) {
      builder.accept(new ChangeNamespace(explicitNamespace));
    }
    return builder.build();
  }

  static > ResourceHandler handlerOf(T item, OperationContext context) {
    ResourceHandler result = Handlers.get(item, new BaseClient(context));
    if (result == null) {
      throw new KubernetesClientException("Could not find a registered handler for item: [" + item + "].");
    }
    return result;
  }

}