org.elasticsearch.common.unit.RatioValue Java Examples

/**
 * Try to extract and parse value from settings for given key.
 * First it tries to parse it as a RatioValue (pct) then as byte size value.
 * It assigns parsed value to corresponding argument references (passed via array hack).
 * If parsing fails the method fires exception, however, this should not happen - we rely on Elasticsearch
 * to already have parsed and validated these values before. Unless we screwed something up...
 */
private void parseValue(Settings s, String key, Long[] bytesPointer, Double[] pctPointer) {
    String value = s.get(key);
    if (value != null && pctPointer[0] == null) {
        try {
            pctPointer[0] = RatioValue.parseRatioValue(s.get(key, null)).getAsPercent();
        } catch (SettingsException | ElasticsearchParseException | NullPointerException e1) {
            if (bytesPointer[0] == null) {
                try {
                    bytesPointer[0] = s.getAsBytesSize(key, null).getBytes();
                } catch (SettingsException | ElasticsearchParseException | NullPointerException e2) {
                    // TODO(lvlcek): log.debug("This went wrong, but 'Keep Calm and Carry On'")
                    // We should avoid using logs in this class (due to perf impact), instead we should
                    // consider moving this logic to some static helper class/method going forward.
                }
            }
        }
    }
}
 

/**
 * Attempts to parse the watermark into a percentage, returning 100.0% if
 * it cannot be parsed.
 */
public double thresholdPercentageFromWatermark(String watermark) {
    try {
        return RatioValue.parseRatioValue(watermark).getAsPercent();
    } catch (ElasticsearchParseException ex) {
        // NOTE: this is not end-user leniency, since up above we check that it's a valid byte or percentage, and then store the two cases separately
        return 100.0;
    }
}
 

/**
 * Checks if a watermark string is a valid percentage or byte size value,
 * returning true if valid, false if invalid.
 */
public boolean validWatermarkSetting(String watermark, String settingName) {
    try {
        RatioValue.parseRatioValue(watermark);
        return true;
    } catch (ElasticsearchParseException e) {
        try {
            ByteSizeValue.parseBytesSizeValue(watermark, settingName);
            return true;
        } catch (ElasticsearchParseException ex) {
            return false;
        }
    }
}
 

/**
 * Attempts to parse the watermark into a percentage, returning 100.0% if it can not be parsed and the specified lenient parameter is
 * true, otherwise throwing an {@link ElasticsearchParseException}.
 *
 * @param watermark the watermark to parse as a percentage
 * @param lenient true if lenient parsing should be applied
 * @return the parsed percentage
 */
private static double thresholdPercentageFromWatermark(String watermark, boolean lenient) {
    try {
        return RatioValue.parseRatioValue(watermark).getAsPercent();
    } catch (ElasticsearchParseException ex) {
        // NOTE: this is not end-user leniency, since up above we check that it's a valid byte or percentage, and then store the two
        // cases separately
        if (lenient) {
            return 100.0;
        }
        throw ex;
    }
}
 

/**
 * Checks if a watermark string is a valid percentage or byte size value,
 * @return the watermark value given
 */
private static String validWatermarkSetting(String watermark, String settingName) {
    try {
        RatioValue.parseRatioValue(watermark);
    } catch (ElasticsearchParseException e) {
        try {
            ByteSizeValue.parseBytesSizeValue(watermark, settingName);
        } catch (ElasticsearchParseException ex) {
            ex.addSuppressed(e);
            throw ex;
        }
    }
    return watermark;
}
 

/**
 * Returns the setting value (as a RatioValue) associated with the setting key. Provided values can
 * either be a percentage value (eg. 23%), or expressed as a floating point number (eg. 0.23). If
 * it does not exist, parses the default value provided.
 */
public RatioValue getAsRatio(String setting, String defaultValue) throws SettingsException {
    return RatioValue.parseRatioValue(get(setting, defaultValue));
}