com.yahoo.container.core.DiagnosticsConfig Maven / Gradle / Ivy

Go to download
/**
 * This file is generated from a config definition file.
 * ------------   D O   N O T   E D I T !   ------------
 */

package com.yahoo.container.core;

import java.util.*;
import java.nio.file.Path;
import edu.umd.cs.findbugs.annotations.NonNull;
import com.yahoo.config.*;

/**
 * This class represents the root node of diagnostics
 *
 * Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 */
public final class DiagnosticsConfig extends ConfigInstance {

  public final static String CONFIG_DEF_MD5 = "2c61b837b514e26e0a603c382b9a2fac";
  public final static String CONFIG_DEF_NAME = "diagnostics";
  public final static String CONFIG_DEF_NAMESPACE = "container.core";
  public final static String CONFIG_DEF_VERSION = "";
  public final static String[] CONFIG_DEF_SCHEMA = {
    "namespace=container.core",
    "timeoutfraction double default=0.1",
    "minimumqps int default=1",
    "shutdown bool default=false",
    "disabled bool default=false"
  };

  public static String getDefMd5()       { return CONFIG_DEF_MD5; }
  public static String getDefName()      { return CONFIG_DEF_NAME; }
  public static String getDefNamespace() { return CONFIG_DEF_NAMESPACE; }
  public static String getDefVersion()   { return CONFIG_DEF_VERSION; }

  public interface Producer extends ConfigInstance.Producer {
    void getConfig(Builder builder);
  }

  public static class Builder implements ConfigInstance.Builder {
    private Set __uninitialized = new HashSet();

    private Double timeoutfraction = null;
    private Integer minimumqps = null;
    private Boolean shutdown = null;
    private Boolean disabled = null;

    public Builder() { }

    public Builder(DiagnosticsConfig config) {
      timeoutfraction(config.timeoutfraction());
      minimumqps(config.minimumqps());
      shutdown(config.shutdown());
      disabled(config.disabled());
    }

    private Builder override(Builder __superior) {
      if (__superior.timeoutfraction != null)
        timeoutfraction(__superior.timeoutfraction);
      if (__superior.minimumqps != null)
        minimumqps(__superior.minimumqps);
      if (__superior.shutdown != null)
        shutdown(__superior.shutdown);
      if (__superior.disabled != null)
        disabled(__superior.disabled);
      return this;
    }

    public Builder timeoutfraction(double __value) {
      timeoutfraction = __value;
      return this;
    }

    private Builder timeoutfraction(String __value) {
      return timeoutfraction(Double.valueOf(__value));
    }

    public Builder minimumqps(int __value) {
      minimumqps = __value;
      return this;
    }

    private Builder minimumqps(String __value) {
      return minimumqps(Integer.valueOf(__value));
    }

    public Builder shutdown(boolean __value) {
      shutdown = __value;
      return this;
    }

    private Builder shutdown(String __value) {
      return shutdown(Boolean.valueOf(__value));
    }

    public Builder disabled(boolean __value) {
      disabled = __value;
      return this;
    }

    private Builder disabled(String __value) {
      return disabled(Boolean.valueOf(__value));
    }

    @java.lang.Override
    public final boolean dispatchGetConfig(ConfigInstance.Producer producer) {
      if (producer instanceof Producer) {
        ((Producer)producer).getConfig(this);
        return true;
      }
      return false;
    }

    @java.lang.Override
    public final String getDefMd5()       { return CONFIG_DEF_MD5; }
    @java.lang.Override
    public final String getDefName()      { return CONFIG_DEF_NAME; }
    @java.lang.Override
    public final String getDefNamespace() { return CONFIG_DEF_NAMESPACE; }
  }

  // The fraction of queries to time out over a period of 10s to consider
  // the system in breakdown.
  private final DoubleNode timeoutfraction;
  // Minimum QPS to consider the system in breakdown.
  private final IntegerNode minimumqps;
  // Whether to shut down process if in a deadlock situation
  private final BooleanNode shutdown;
  // Whether to totally disable the detector. Alternative to system property
  // which works better in tests.
  private final BooleanNode disabled;

  public DiagnosticsConfig(Builder builder) {
    this(builder, true);
  }

  private DiagnosticsConfig(Builder builder, boolean throwIfUninitialized) {
    if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
      throw new IllegalArgumentException("The following builder parameters for " +
          "diagnostics must be initialized: " + builder.__uninitialized);

    timeoutfraction = (builder.timeoutfraction == null) ?
        new DoubleNode(0.1D) : new DoubleNode(builder.timeoutfraction);
    minimumqps = (builder.minimumqps == null) ?
        new IntegerNode(1) : new IntegerNode(builder.minimumqps);
    shutdown = (builder.shutdown == null) ?
        new BooleanNode(false) : new BooleanNode(builder.shutdown);
    disabled = (builder.disabled == null) ?
        new BooleanNode(false) : new BooleanNode(builder.disabled);
  }

  /**
   * @return diagnostics.timeoutfraction
   */
  public double timeoutfraction() {
    return timeoutfraction.value();
  }

  /**
   * @return diagnostics.minimumqps
   */
  public int minimumqps() {
    return minimumqps.value();
  }

  /**
   * @return diagnostics.shutdown
   */
  public boolean shutdown() {
    return shutdown.value();
  }

  /**
   * @return diagnostics.disabled
   */
  public boolean disabled() {
    return disabled.value();
  }

  private ChangesRequiringRestart getChangesRequiringRestart(DiagnosticsConfig newConfig) {
    ChangesRequiringRestart changes = new ChangesRequiringRestart("diagnostics");
    return changes;
  }

  private static boolean containsFieldsFlaggedWithRestart() {
    return false;
  }


}