Java ByteSizeValue.parseBytesSizeValue方法代码示例

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
public void testTranslogFlushSizeThreshold() {
    ByteSizeValue translogFlushThresholdSize = new ByteSizeValue(Math.abs(randomInt()));
    ByteSizeValue actualValue = ByteSizeValue.parseBytesSizeValue(translogFlushThresholdSize.toString(),
        IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey());
    IndexMetaData metaData = newIndexMeta("index", Settings.builder()
        .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
        .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), translogFlushThresholdSize.toString())
        .build());
    IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY);
    assertEquals(actualValue, settings.getFlushThresholdSize());
    ByteSizeValue newTranslogFlushThresholdSize = new ByteSizeValue(Math.abs(randomInt()));
    ByteSizeValue actualNewTranslogFlushThresholdSize = ByteSizeValue.parseBytesSizeValue(newTranslogFlushThresholdSize.toString(),
        IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey());
    settings.updateIndexMetaData(newIndexMeta("index", Settings.builder()
        .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), newTranslogFlushThresholdSize.toString()).build()));
    assertEquals(actualNewTranslogFlushThresholdSize, settings.getFlushThresholdSize());
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
/**
 * Attempts to parse the watermark into a {@link ByteSizeValue}, returning
 * a ByteSizeValue of 0 bytes if the value cannot be parsed.
 */
private ByteSizeValue thresholdBytesFromWatermark(String watermark, String settingName) {
    try {
        return ByteSizeValue.parseBytesSizeValue(watermark, settingName);
    } 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 ByteSizeValue.parseBytesSizeValue("0b", settingName);
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
/**
 * 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;
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
public static ByteSizeValue parseByteSize(String s, ByteSizeValue minValue, ByteSizeValue maxValue, String key) {
    ByteSizeValue value = ByteSizeValue.parseBytesSizeValue(s, key);
    if (value.getBytes() < minValue.getBytes()) {
        throw new IllegalArgumentException("Failed to parse value [" + s + "] for setting [" + key + "] must be >= " + minValue);
    }
    if (value.getBytes() > maxValue.getBytes()) {
        throw new IllegalArgumentException("Failed to parse value [" + s + "] for setting [" + key + "] must be <= " + maxValue);
    }
    return value;
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
public void testDefaults() {
    ClusterSettings nss = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
    DiskThresholdSettings diskThresholdSettings = new DiskThresholdSettings(Settings.EMPTY, nss);

    ByteSizeValue zeroBytes = ByteSizeValue.parseBytesSizeValue("0b", "test");
    assertEquals(zeroBytes, diskThresholdSettings.getFreeBytesThresholdHigh());
    assertEquals(10.0D, diskThresholdSettings.getFreeDiskThresholdHigh(), 0.0D);
    assertEquals(zeroBytes, diskThresholdSettings.getFreeBytesThresholdLow());
    assertEquals(15.0D, diskThresholdSettings.getFreeDiskThresholdLow(), 0.0D);
    assertEquals(60L, diskThresholdSettings.getRerouteInterval().seconds());
    assertTrue(diskThresholdSettings.isEnabled());
    assertTrue(diskThresholdSettings.includeRelocations());
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
@Override
protected ByteSizeValue visitStringLiteral(StringLiteral node, Object[] context) {
    try {
        return ByteSizeValue.parseBytesSizeValue(node.getValue(), DEFAULT_VALUE.toString());
    } catch (ElasticsearchParseException e) {
        throw new IllegalArgumentException(
                String.format(Locale.ENGLISH, "Invalid byte size value '%s'", node.getValue()));
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
/** updates {@link #versionMapSize} based on current setting and {@link #indexingBufferSize} */
private void updateVersionMapSize() {
    if (versionMapSizeSetting.endsWith("%")) {
        double percent = Double.parseDouble(versionMapSizeSetting.substring(0, versionMapSizeSetting.length() - 1));
        versionMapSize = new ByteSizeValue((long) ((double) indexingBufferSize.bytes() * (percent / 100)));
    } else {
        versionMapSize = ByteSizeValue.parseBytesSizeValue(versionMapSizeSetting, INDEX_VERSION_MAP_SIZE);
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
/**
 * Attempts to parse the watermark into a {@link ByteSizeValue}, returning
 * a ByteSizeValue of 0 bytes if the value cannot be parsed.
 */
public ByteSizeValue thresholdBytesFromWatermark(String watermark, String settingName) {
    try {
        return ByteSizeValue.parseBytesSizeValue(watermark, settingName);
    } 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 ByteSizeValue.parseBytesSizeValue("0b", settingName);
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
/**
 * 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;
        }
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入方法依赖的package包/类
public static Setting<ByteSizeValue> byteSizeSetting(String key, Setting<ByteSizeValue> fallbackSetting,
                                                     Property... properties) {
    return new Setting<>(key, fallbackSetting, (s) -> ByteSizeValue.parseBytesSizeValue(s, key), properties);
}