Java ByteSizeValue类代码示例

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

    Settings newSettings = Settings.builder()
        .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED_SETTING.getKey(), false)
        .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_INCLUDE_RELOCATIONS_SETTING.getKey(), false)
        .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey(), "70%")
        .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK_SETTING.getKey(), "500mb")
        .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_REROUTE_INTERVAL_SETTING.getKey(), "30s")
        .build();
    nss.applySettings(newSettings);

    assertEquals(ByteSizeValue.parseBytesSizeValue("0b", "test"), diskThresholdSettings.getFreeBytesThresholdHigh());
    assertEquals(30.0D, diskThresholdSettings.getFreeDiskThresholdHigh(), 0.0D);
    assertEquals(ByteSizeValue.parseBytesSizeValue("500mb", "test"), diskThresholdSettings.getFreeBytesThresholdLow());
    assertEquals(0.0D, diskThresholdSettings.getFreeDiskThresholdLow(), 0.0D);
    assertEquals(30L, diskThresholdSettings.getRerouteInterval().seconds());
    assertFalse(diskThresholdSettings.isEnabled());
    assertFalse(diskThresholdSettings.includeRelocations());
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
public NodeInfo(Version version, Build build, DiscoveryNode node, @Nullable Settings settings,
                @Nullable OsInfo os, @Nullable ProcessInfo process, @Nullable JvmInfo jvm, @Nullable ThreadPoolInfo threadPool,
                @Nullable TransportInfo transport, @Nullable HttpInfo http, @Nullable PluginsAndModules plugins,
                @Nullable IngestInfo ingest, @Nullable ByteSizeValue totalIndexingBuffer) {
    super(node);
    this.version = version;
    this.build = build;
    this.settings = settings;
    this.os = os;
    this.process = process;
    this.jvm = jvm;
    this.threadPool = threadPool;
    this.transport = transport;
    this.http = http;
    this.plugins = plugins;
    this.ingest = ingest;
    this.totalIndexingBuffer = totalIndexingBuffer;
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
@Override
public void onRefreshSettings(Settings settings) {
    String rateLimitingType = settings.get(INDEX_STORE_THROTTLE_TYPE, IndexStore.this.rateLimitingType);
    if (!rateLimitingType.equals(IndexStore.this.rateLimitingType)) {
        logger.info("updating index.store.throttle.type from [{}] to [{}]", IndexStore.this.rateLimitingType, rateLimitingType);
        if (rateLimitingType.equalsIgnoreCase("node")) {
            IndexStore.this.rateLimitingType = rateLimitingType;
            IndexStore.this.nodeRateLimiting = true;
        } else {
            StoreRateLimiting.Type.fromString(rateLimitingType);
            IndexStore.this.rateLimitingType = rateLimitingType;
            IndexStore.this.nodeRateLimiting = false;
            IndexStore.this.rateLimiting.setType(rateLimitingType);
        }
    }

    ByteSizeValue rateLimitingThrottle = settings.getAsBytesSize(INDEX_STORE_THROTTLE_MAX_BYTES_PER_SEC, IndexStore.this.rateLimitingThrottle);
    if (!rateLimitingThrottle.equals(IndexStore.this.rateLimitingThrottle)) {
        logger.info("updating index.store.throttle.max_bytes_per_sec from [{}] to [{}], note, type is [{}]", IndexStore.this.rateLimitingThrottle, rateLimitingThrottle, IndexStore.this.rateLimitingType);
        IndexStore.this.rateLimitingThrottle = rateLimitingThrottle;
        IndexStore.this.rateLimiting.setMaxRate(rateLimitingThrottle);
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
@Inject
public TranslogService(ShardId shardId, IndexSettingsService indexSettingsService, ThreadPool threadPool, IndexShard indexShard) {
    super(shardId, indexSettingsService.getSettings());
    this.threadPool = threadPool;
    this.indexSettingsService = indexSettingsService;
    this.indexShard = indexShard;
    this.flushThresholdOperations = indexSettings.getAsInt(INDEX_TRANSLOG_FLUSH_THRESHOLD_OPS, indexSettings.getAsInt("index.translog.flush_threshold", 50000));
    this.flushThresholdSize = indexSettings.getAsBytesSize(INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE, new ByteSizeValue(100, ByteSizeUnit.MB));
    this.flushThresholdPeriod = indexSettings.getAsTime(INDEX_TRANSLOG_FLUSH_THRESHOLD_PERIOD, TimeValue.timeValueMinutes(10));
    this.interval = indexSettings.getAsTime(INDEX_TRANSLOG_FLUSH_INTERVAL, timeValueMillis(5000));
    this.disableFlush = indexSettings.getAsBoolean(INDEX_TRANSLOG_DISABLE_FLUSH, false);
    logger.debug("interval [{}], flush_threshold_ops [{}], flush_threshold_size [{}], flush_threshold_period [{}]", interval, flushThresholdOperations, flushThresholdSize, flushThresholdPeriod);

    this.future = threadPool.schedule(interval, ThreadPool.Names.SAME, new TranslogBasedFlush());

    indexSettingsService.addListener(applySettings);
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
BulkProcessor(Client client, BackoffPolicy backoffPolicy, Listener listener, @Nullable String name, int concurrentRequests, int bulkActions, ByteSizeValue bulkSize, @Nullable TimeValue flushInterval) {
    this.bulkActions = bulkActions;
    this.bulkSize = bulkSize.bytes();

    this.bulkRequest = new BulkRequest();
    this.bulkRequestHandler = (concurrentRequests == 0) ? BulkRequestHandler.syncHandler(client, backoffPolicy, listener) : BulkRequestHandler.asyncHandler(client, backoffPolicy, listener, concurrentRequests);

    if (flushInterval != null) {
        this.scheduler = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(1, EsExecutors.daemonThreadFactory(client.settings(), (name != null ? "[" + name + "]" : "") + "bulk_processor"));
        this.scheduler.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
        this.scheduler.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
        this.scheduledFuture = this.scheduler.scheduleWithFixedDelay(new Flush(), flushInterval.millis(), flushInterval.millis(), TimeUnit.MILLISECONDS);
    } else {
        this.scheduler = null;
        this.scheduledFuture = null;
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
public void testBulkProcessorFlush() throws Exception {
    final CountDownLatch latch = new CountDownLatch(1);
    BulkProcessorTestListener listener = new BulkProcessorTestListener(latch);

    int numDocs = randomIntBetween(10, 100);

    try (BulkProcessor processor = BulkProcessor.builder(client(), listener).setName("foo")
            //let's make sure that this bulk won't be automatically flushed
            .setConcurrentRequests(randomIntBetween(0, 10)).setBulkActions(numDocs + randomIntBetween(1, 100))
            .setFlushInterval(TimeValue.timeValueHours(24)).setBulkSize(new ByteSizeValue(1, ByteSizeUnit.GB)).build()) {

        MultiGetRequestBuilder multiGetRequestBuilder = indexDocs(client(), processor, numDocs);

        assertThat(latch.await(randomInt(500), TimeUnit.MILLISECONDS), equalTo(false));
        //we really need an explicit flush as none of the bulk thresholds was reached
        processor.flush();
        latch.await();

        assertThat(listener.beforeCounts.get(), equalTo(1));
        assertThat(listener.afterCounts.get(), equalTo(1));
        assertThat(listener.bulkFailures.size(), equalTo(0));
        assertResponseItems(listener.bulkItems, numDocs);
        assertMultiGetResponse(multiGetRequestBuilder.get(), numDocs);
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
private TranslogWriter(
    final ChannelFactory channelFactory,
    final ShardId shardId,
    final Checkpoint initialCheckpoint,
    final FileChannel channel,
    final Path path,
    final ByteSizeValue bufferSize,
    final LongSupplier globalCheckpointSupplier) throws IOException {
    super(initialCheckpoint.generation, channel, path, channel.position());
    this.shardId = shardId;
    this.channelFactory = channelFactory;
    this.outputStream = new BufferedChannelOutputStream(java.nio.channels.Channels.newOutputStream(channel), bufferSize.bytesAsInt());
    this.lastSyncedCheckpoint = initialCheckpoint;
    this.totalOffset = initialCheckpoint.offset;
    assert initialCheckpoint.minSeqNo == SequenceNumbersService.NO_OPS_PERFORMED : initialCheckpoint.minSeqNo;
    this.minSeqNo = initialCheckpoint.minSeqNo;
    assert initialCheckpoint.maxSeqNo == SequenceNumbersService.NO_OPS_PERFORMED : initialCheckpoint.maxSeqNo;
    this.maxSeqNo = initialCheckpoint.maxSeqNo;
    this.globalCheckpointSupplier = globalCheckpointSupplier;
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
/**
 * Constructs a new instance of file info
 *
 * @param name         file name as stored in the blob store
 * @param metaData  the files meta data
 * @param partSize     size of the single chunk
 */
public FileInfo(String name, StoreFileMetaData metaData, ByteSizeValue partSize) {
    this.name = name;
    this.metadata = metaData;

    long partBytes = Long.MAX_VALUE;
    if (partSize != null) {
        partBytes = partSize.getBytes();
    }

    long totalLength = metaData.length();
    long numberOfParts = totalLength / partBytes;
    if (totalLength % partBytes > 0) {
        numberOfParts++;
    }
    if (numberOfParts == 0) {
        numberOfParts++;
    }
    this.numberOfParts = numberOfParts;
    this.partSize = partSize;
    this.partBytes = partBytes;
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
private Table buildTable(final RestRequest request, final NodesStatsResponse nodeStatses) {
    Table table = getTableWithHeader(request);

    for (NodeStats nodeStats: nodeStatses.getNodes()) {
        if (nodeStats.getIndices().getFieldData().getFields() != null) {
            for (ObjectLongCursor<String> cursor : nodeStats.getIndices().getFieldData().getFields()) {
                table.startRow();
                table.addCell(nodeStats.getNode().getId());
                table.addCell(nodeStats.getNode().getHostName());
                table.addCell(nodeStats.getNode().getHostAddress());
                table.addCell(nodeStats.getNode().getName());
                table.addCell(cursor.key);
                table.addCell(new ByteSizeValue(cursor.value));
                table.endRow();
            }
        }
    }

    return table;
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
/**
 * Utility method which computes total memory by adding
 * FieldData, Percolate, Segments (memory, index writer, version map)
 */
public ByteSizeValue getTotalMemory() {
    long size = 0;
    if (this.getFieldData() != null) {
        size += this.getFieldData().getMemorySizeInBytes();
    }
    if (this.getQueryCache() != null) {
        size += this.getQueryCache().getMemorySizeInBytes();
    }
    if (this.getPercolate() != null) {
        size += this.getPercolate().getMemorySizeInBytes();
    }
    if (this.getSegments() != null) {
        size += this.getSegments().getMemoryInBytes() +
                this.getSegments().getIndexWriterMemoryInBytes() +
                this.getSegments().getVersionMapMemoryInBytes();
    }

    return new ByteSizeValue(size);
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
@Override
public void onRefreshSettings(Settings settings) {
    String rateLimitingType = settings.get(INDICES_STORE_THROTTLE_TYPE,
            IndicesStore.this.settings.get(INDICES_STORE_THROTTLE_TYPE, DEFAULT_RATE_LIMITING_TYPE));
    // try and parse the type
    StoreRateLimiting.Type.fromString(rateLimitingType);
    if (!rateLimitingType.equals(IndicesStore.this.rateLimitingType)) {
        logger.info("updating indices.store.throttle.type from [{}] to [{}]", IndicesStore.this.rateLimitingType, rateLimitingType);
        IndicesStore.this.rateLimitingType = rateLimitingType;
        IndicesStore.this.rateLimiting.setType(rateLimitingType);
    }

    ByteSizeValue rateLimitingThrottle = settings.getAsBytesSize(
            INDICES_STORE_THROTTLE_MAX_BYTES_PER_SEC,
            IndicesStore.this.settings.getAsBytesSize(
                    INDICES_STORE_THROTTLE_MAX_BYTES_PER_SEC,
                    DEFAULT_INDICES_STORE_THROTTLE_MAX_BYTES_PER_SEC));
    if (!rateLimitingThrottle.equals(IndicesStore.this.rateLimitingThrottle)) {
        logger.info("updating indices.store.throttle.max_bytes_per_sec from [{}] to [{}], note, type is [{}]", IndicesStore.this.rateLimitingThrottle, rateLimitingThrottle, IndicesStore.this.rateLimitingType);
        IndicesStore.this.rateLimitingThrottle = rateLimitingThrottle;
        IndicesStore.this.rateLimiting.setMaxRate(rateLimitingThrottle);
    }
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
private Bootstrap createBootstrap() {
    final Bootstrap bootstrap = new Bootstrap();
    bootstrap.group(new NioEventLoopGroup(workerCount, daemonThreadFactory(settings, TRANSPORT_CLIENT_BOSS_THREAD_NAME_PREFIX)));
    bootstrap.channel(NioSocketChannel.class);

    bootstrap.handler(getClientChannelInitializer());

    bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, Math.toIntExact(defaultConnectionProfile.getConnectTimeout().millis()));
    bootstrap.option(ChannelOption.TCP_NODELAY, TCP_NO_DELAY.get(settings));
    bootstrap.option(ChannelOption.SO_KEEPALIVE, TCP_KEEP_ALIVE.get(settings));

    final ByteSizeValue tcpSendBufferSize = TCP_SEND_BUFFER_SIZE.get(settings);
    if (tcpSendBufferSize.getBytes() > 0) {
        bootstrap.option(ChannelOption.SO_SNDBUF, Math.toIntExact(tcpSendBufferSize.getBytes()));
    }

    final ByteSizeValue tcpReceiveBufferSize = TCP_RECEIVE_BUFFER_SIZE.get(settings);
    if (tcpReceiveBufferSize.getBytes() > 0) {
        bootstrap.option(ChannelOption.SO_RCVBUF, Math.toIntExact(tcpReceiveBufferSize.getBytes()));
    }

    bootstrap.option(ChannelOption.RCVBUF_ALLOCATOR, recvByteBufAllocator);

    final boolean reuseAddress = TCP_REUSE_ADDRESS.get(settings);
    bootstrap.option(ChannelOption.SO_REUSEADDR, reuseAddress);

    bootstrap.validate();

    return bootstrap;
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
/**
 * Prepare the bulk request. Called on the generic thread pool after some preflight checks have been done one the SearchResponse and any
 * delay has been slept. Uses the generic thread pool because reindex is rare enough not to need its own thread pool and because the
 * thread may be blocked by the user script.
 */
void prepareBulkRequest(TimeValue thisBatchStartTime, ScrollableHitSource.Response response) {
    if (task.isCancelled()) {
        finishHim(null);
        return;
    }
    if (response.getHits().isEmpty()) {
        refreshAndFinish(emptyList(), emptyList(), false);
        return;
    }
    task.countBatch();
    List<? extends ScrollableHitSource.Hit> hits = response.getHits();
    if (mainRequest.getSize() != SIZE_ALL_MATCHES) {
        // Truncate the hits if we have more than the request size
        long remaining = max(0, mainRequest.getSize() - task.getSuccessfullyProcessed());
        if (remaining < hits.size()) {
            hits = hits.subList(0, (int) remaining);
        }
    }
    BulkRequest request = buildBulk(hits);
    if (request.requests().isEmpty()) {
        /*
         * If we noop-ed the entire batch then just skip to the next batch or the BulkRequest would fail validation.
         */
        startNextScroll(thisBatchStartTime, 0);
        return;
    }
    request.timeout(mainRequest.getTimeout());
    request.waitForActiveShards(mainRequest.getWaitForActiveShards());
    if (logger.isDebugEnabled()) {
        logger.debug("sending [{}] entry, [{}] bulk request", request.requests().size(),
                new ByteSizeValue(request.estimatedSizeInBytes()));
    }
    sendBulkRequest(thisBatchStartTime, request);
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
@Override
public String toString() {
    return "[" + this.name +
            ",limit=" + this.limit + "/" + new ByteSizeValue(this.limit) +
            ",estimated=" + this.estimated + "/" + new ByteSizeValue(this.estimated) +
            ",overhead=" + this.overhead + ",tripped=" + this.trippedCount + "]";
}
 

import org.elasticsearch.common.unit.ByteSizeValue; //导入依赖的package包/类
private void setInFlightRequestsBreakerLimit(ByteSizeValue newInFlightRequestsMax, Double newInFlightRequestsOverhead) {
    BreakerSettings newInFlightRequestsSettings = new BreakerSettings(CircuitBreaker.IN_FLIGHT_REQUESTS, newInFlightRequestsMax.getBytes(),
        newInFlightRequestsOverhead, HierarchyCircuitBreakerService.this.inFlightRequestsSettings.getType());
    registerBreaker(newInFlightRequestsSettings);
    HierarchyCircuitBreakerService.this.inFlightRequestsSettings = newInFlightRequestsSettings;
    logger.info("Updated breaker settings for in-flight requests: {}", newInFlightRequestsSettings);
}