private void setMaxBytesPerSec(ByteSizeValue maxBytesPerSec) {
   this.maxBytesPerSec = maxBytesPerSec;
   if (maxBytesPerSec.getBytes() <= 0) {
     rateLimiter = null;
   } else if (rateLimiter != null) {
     rateLimiter.setMBPerSec(maxBytesPerSec.getMbFrac());
   } else {
     rateLimiter = new SimpleRateLimiter(maxBytesPerSec.getMbFrac());
   }
 }
예제 #2
0
  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }

    ByteSizeValue sizeValue = (ByteSizeValue) o;

    return getBytes() == sizeValue.getBytes();
  }
예제 #3
0
 private void slowDownRecovery(ByteSizeValue shardSize) {
   long chunkSize = Math.max(1, shardSize.getBytes() / 10);
   assertTrue(
       client()
           .admin()
           .cluster()
           .prepareUpdateSettings()
           .setTransientSettings(
               Settings.builder()
                   // one chunk per sec..
                   .put(
                       RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey(),
                       chunkSize,
                       ByteSizeUnit.BYTES)
                   // small chunks
                   .put(
                       CHUNK_SIZE_SETTING.getKey(),
                       new ByteSizeValue(chunkSize, ByteSizeUnit.BYTES)))
           .get()
           .isAcknowledged());
 }
  @Inject
  public RecoverySettings(Settings settings, ClusterSettings clusterSettings) {
    super(settings);

    this.retryDelayStateSync = INDICES_RECOVERY_RETRY_DELAY_STATE_SYNC_SETTING.get(settings);
    // doesn't have to be fast as nodes are reconnected every 10s by default (see
    // InternalClusterService.ReconnectToNodes)
    // and we want to give the master time to remove a faulty node
    this.retryDelayNetwork = INDICES_RECOVERY_RETRY_DELAY_NETWORK_SETTING.get(settings);

    this.internalActionTimeout = INDICES_RECOVERY_INTERNAL_ACTION_TIMEOUT_SETTING.get(settings);
    this.internalActionLongTimeout =
        INDICES_RECOVERY_INTERNAL_LONG_ACTION_TIMEOUT_SETTING.get(settings);

    this.activityTimeout = INDICES_RECOVERY_ACTIVITY_TIMEOUT_SETTING.get(settings);
    this.maxBytesPerSec = INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.get(settings);
    if (maxBytesPerSec.getBytes() <= 0) {
      rateLimiter = null;
    } else {
      rateLimiter = new SimpleRateLimiter(maxBytesPerSec.getMbFrac());
    }

    logger.debug("using max_bytes_per_sec[{}]", maxBytesPerSec);

    clusterSettings.addSettingsUpdateConsumer(
        INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING, this::setMaxBytesPerSec);
    clusterSettings.addSettingsUpdateConsumer(
        INDICES_RECOVERY_RETRY_DELAY_STATE_SYNC_SETTING, this::setRetryDelayStateSync);
    clusterSettings.addSettingsUpdateConsumer(
        INDICES_RECOVERY_RETRY_DELAY_NETWORK_SETTING, this::setRetryDelayNetwork);
    clusterSettings.addSettingsUpdateConsumer(
        INDICES_RECOVERY_INTERNAL_ACTION_TIMEOUT_SETTING, this::setInternalActionTimeout);
    clusterSettings.addSettingsUpdateConsumer(
        INDICES_RECOVERY_INTERNAL_LONG_ACTION_TIMEOUT_SETTING, this::setInternalActionLongTimeout);
    clusterSettings.addSettingsUpdateConsumer(
        INDICES_RECOVERY_ACTIVITY_TIMEOUT_SETTING, this::setActivityTimeout);
  }
예제 #5
0
 private static String renderValue(RestRequest request, Object value) {
   if (value == null) {
     return null;
   }
   if (value instanceof ByteSizeValue) {
     ByteSizeValue v = (ByteSizeValue) value;
     String resolution = request.param("bytes");
     if ("b".equals(resolution)) {
       return Long.toString(v.getBytes());
     } else if ("k".equals(resolution) || "kb".equals(resolution)) {
       return Long.toString(v.getKb());
     } else if ("m".equals(resolution) || "mb".equals(resolution)) {
       return Long.toString(v.getMb());
     } else if ("g".equals(resolution) || "gb".equals(resolution)) {
       return Long.toString(v.getGb());
     } else if ("t".equals(resolution) || "tb".equals(resolution)) {
       return Long.toString(v.getTb());
     } else if ("p".equals(resolution) || "pb".equals(resolution)) {
       return Long.toString(v.getPb());
     } else {
       return v.toString();
     }
   }
   if (value instanceof SizeValue) {
     SizeValue v = (SizeValue) value;
     String resolution = request.param("size");
     if ("".equals(resolution)) {
       return Long.toString(v.singles());
     } else if ("k".equals(resolution)) {
       return Long.toString(v.kilo());
     } else if ("m".equals(resolution)) {
       return Long.toString(v.mega());
     } else if ("g".equals(resolution)) {
       return Long.toString(v.giga());
     } else if ("t".equals(resolution)) {
       return Long.toString(v.tera());
     } else if ("p".equals(resolution)) {
       return Long.toString(v.peta());
     } else {
       return v.toString();
     }
   }
   if (value instanceof TimeValue) {
     TimeValue v = (TimeValue) value;
     String resolution = request.param("time");
     if ("nanos".equals(resolution)) {
       return Long.toString(v.nanos());
     } else if ("micros".equals(resolution)) {
       return Long.toString(v.micros());
     } else if ("ms".equals(resolution)) {
       return Long.toString(v.millis());
     } else if ("s".equals(resolution)) {
       return Long.toString(v.seconds());
     } else if ("m".equals(resolution)) {
       return Long.toString(v.minutes());
     } else if ("h".equals(resolution)) {
       return Long.toString(v.hours());
     } else if ("d".equals(resolution)) {
       return Long.toString(v.days());
     } else {
       return v.toString();
     }
   }
   // Add additional built in data points we can render based on request parameters?
   return value.toString();
 }