Java TimeValue.millis方法代码示例

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
public void onRefreshSettings(Settings settings) {
    TimeValue newPublishTimeout = settings.getAsTime(PUBLISH_TIMEOUT,
            DiscoverySettings.this.settings.getAsTime(PUBLISH_TIMEOUT, DEFAULT_PUBLISH_TIMEOUT));
    if (newPublishTimeout.millis() != publishTimeout.millis()) {
        logger.info("updating [{}] from [{}] to [{}]", PUBLISH_TIMEOUT, publishTimeout, newPublishTimeout);
        publishTimeout = newPublishTimeout;
    }
    String newNoMasterBlockValue = settings.get(NO_MASTER_BLOCK);
    if (newNoMasterBlockValue != null) {
        ClusterBlock newNoMasterBlock = parseNoMasterBlock(newNoMasterBlockValue);
        if (newNoMasterBlock != noMasterBlock) {
            noMasterBlock = newNoMasterBlock;
        }
    }
    Boolean newPublishDiff = settings.getAsBoolean(PUBLISH_DIFF_ENABLE,
            DiscoverySettings.this.settings.getAsBoolean(PUBLISH_DIFF_ENABLE, DEFAULT_PUBLISH_DIFF_ENABLE));
    if (newPublishDiff != publishDiff) {
        logger.info("updating [{}] from [{}] to [{}]", PUBLISH_DIFF_ENABLE, publishDiff, newPublishDiff);
        publishDiff = newPublishDiff;
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public DefaultSearchContext(long id, ShardSearchRequest request, SearchShardTarget shardTarget,
                            Engine.Searcher engineSearcher, IndexService indexService, IndexShard indexShard,
                            ScriptService scriptService, PageCacheRecycler pageCacheRecycler,
                            BigArrays bigArrays, Counter timeEstimateCounter, ParseFieldMatcher parseFieldMatcher,
                            TimeValue timeout
) {
    super(parseFieldMatcher, request);
    this.id = id;
    this.request = request;
    this.searchType = request.searchType();
    this.shardTarget = shardTarget;
    this.engineSearcher = engineSearcher;
    this.scriptService = scriptService;
    this.pageCacheRecycler = pageCacheRecycler;
    // SearchContexts use a BigArrays that can circuit break
    this.bigArrays = bigArrays.withCircuitBreaking();
    this.dfsResult = new DfsSearchResult(id, shardTarget);
    this.queryResult = new QuerySearchResult(id, shardTarget);
    this.fetchResult = new FetchSearchResult(id, shardTarget);
    this.indexShard = indexShard;
    this.indexService = indexService;
    this.searcher = new ContextIndexSearcher(engineSearcher, indexService.cache().query(), indexShard.getQueryCachingPolicy());
    this.timeEstimateCounter = timeEstimateCounter;
    this.timeoutInMillis = timeout.millis();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Sets a connect timeout for this connection profile
 */
public void setConnectTimeout(TimeValue connectTimeout) {
    if (connectTimeout.millis() < 0) {
        throw new IllegalArgumentException("connectTimeout must be non-negative but was: " + connectTimeout);
    }
    this.connectTimeout = connectTimeout;
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Sets a handshake timeout for this connection profile
 */
public void setHandshakeTimeout(TimeValue handshakeTimeout) {
    if (handshakeTimeout.millis() < 0) {
        throw new IllegalArgumentException("handshakeTimeout must be non-negative but was: " + handshakeTimeout);
    }
    this.handshakeTimeout = handshakeTimeout;
}
 

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

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public static Setting<TimeValue> timeSetting(String key, Function<Settings, TimeValue> defaultValue, TimeValue minValue,
                                             Property... properties) {
    return new Setting<>(key, (s) -> defaultValue.apply(s).getStringRep(), (s) -> {
        TimeValue timeValue = TimeValue.parseTimeValue(s, null, key);
        if (timeValue.millis() < minValue.millis()) {
            throw new IllegalArgumentException("Failed to parse value [" + s + "] for setting [" + key + "] must be >= " + minValue);
        }
        return timeValue;
    }, properties);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public Set<ClusterBlock> waitForNoBlocksOnNode(TimeValue timeout, Client nodeClient) throws InterruptedException {
    long start = System.currentTimeMillis();
    Set<ClusterBlock> blocks;
    do {
        blocks = nodeClient.admin().cluster().prepareState().setLocal(true).execute().actionGet()
                .getState().blocks().global(ClusterBlockLevel.METADATA_WRITE);
    }
    while (!blocks.isEmpty() && (System.currentTimeMillis() - start) < timeout.millis());
    return blocks;
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void waitForBlock(String node, String repository, TimeValue timeout) throws InterruptedException {
    long start = System.currentTimeMillis();
    RepositoriesService repositoriesService = internalCluster().getInstance(RepositoriesService.class, node);
    MockRepository mockRepository = (MockRepository) repositoriesService.repository(repository);
    while (System.currentTimeMillis() - start < timeout.millis()) {
        if (mockRepository.blocked()) {
            return;
        }
        Thread.sleep(100);
    }
    fail("Timeout!!!");
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public SnapshotInfo waitForCompletion(String repository, String snapshotName, TimeValue timeout) throws InterruptedException {
    long start = System.currentTimeMillis();
    while (System.currentTimeMillis() - start < timeout.millis()) {
        List<SnapshotInfo> snapshotInfos = client().admin().cluster().prepareGetSnapshots(repository).setSnapshots(snapshotName).get().getSnapshots();
        assertThat(snapshotInfos.size(), equalTo(1));
        if (snapshotInfos.get(0).state().completed()) {
            // Make sure that snapshot clean up operations are finished
            ClusterStateResponse stateResponse = client().admin().cluster().prepareState().get();
            SnapshotsInProgress snapshotsInProgress = stateResponse.getState().custom(SnapshotsInProgress.TYPE);
            if (snapshotsInProgress == null) {
                return snapshotInfos.get(0);
            } else {
                boolean found = false;
                for (SnapshotsInProgress.Entry entry : snapshotsInProgress.entries()) {
                    final Snapshot curr = entry.snapshot();
                    if (curr.getRepository().equals(repository) && curr.getSnapshotId().getName().equals(snapshotName)) {
                        found = true;
                        break;
                    }
                }
                if (found == false) {
                    return snapshotInfos.get(0);
                }
            }
        }
        Thread.sleep(100);
    }
    fail("Timeout!!!");
    return null;
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Inject
public OsService(Settings settings, OsProbe probe) {
    super(settings);
    this.probe = probe;

    TimeValue refreshInterval = settings.getAsTime("monitor.os.refresh_interval", TimeValue.timeValueSeconds(1));

    this.info = probe.osInfo();
    this.info.refreshInterval = refreshInterval.millis();
    this.info.allocatedProcessors = EsExecutors.boundedNumberOfProcessors(settings);

    osStatsCache = new OsStatsCache(refreshInterval, probe.osStats());
    logger.debug("Using probe [{}] with refresh_interval [{}]", probe, refreshInterval);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Inject
public ProcessService(Settings settings, ProcessProbe probe) {
    super(settings);
    this.probe = probe;

    final TimeValue refreshInterval = settings.getAsTime("monitor.process.refresh_interval", TimeValue.timeValueSeconds(1));
    processStatsCache = new ProcessStatsCache(refreshInterval, probe.processStats());
    this.info = probe.processInfo();
    this.info.refreshInterval = refreshInterval.millis();
    logger.debug("Using probe [{}] with refresh_interval [{}]", probe, refreshInterval);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Wait for the next cluster state which satisfies statePredicate
 *
 * @param listener        callback listener
 * @param statePredicate predicate to check whether cluster state changes are relevant and the callback should be called
 * @param timeOutValue    a timeout for waiting. If null the global observer timeout will be used.
 */
public void waitForNextChange(Listener listener, Predicate<ClusterState> statePredicate, @Nullable TimeValue timeOutValue) {
    listener = new ContextPreservingListener(listener, contextHolder.newRestorableContext(false));
    if (observingContext.get() != null) {
        throw new ElasticsearchException("already waiting for a cluster state change");
    }

    Long timeoutTimeLeftMS;
    if (timeOutValue == null) {
        timeOutValue = this.timeOutValue;
        if (timeOutValue != null) {
            long timeSinceStartMS = TimeValue.nsecToMSec(System.nanoTime() - startTimeNS);
            timeoutTimeLeftMS = timeOutValue.millis() - timeSinceStartMS;
            if (timeoutTimeLeftMS <= 0L) {
                // things have timeout while we were busy -> notify
                logger.trace("observer timed out. notifying listener. timeout setting [{}], time since start [{}]", timeOutValue, new TimeValue(timeSinceStartMS));
                // update to latest, in case people want to retry
                timedOut = true;
                lastObservedState.set(new StoredState(clusterService.state()));
                listener.onTimeout(timeOutValue);
                return;
            }
        } else {
            timeoutTimeLeftMS = null;
        }
    } else {
        this.startTimeNS = System.nanoTime();
        this.timeOutValue = timeOutValue;
        timeoutTimeLeftMS = timeOutValue.millis();
        timedOut = false;
    }

    // sample a new state. This state maybe *older* than the supplied state if we are called from an applier,
    // which wants to wait for something else to happen
    ClusterState newState = clusterService.state();
    if (lastObservedState.get().isOlderOrDifferentMaster(newState) && statePredicate.test(newState)) {
        // good enough, let's go.
        logger.trace("observer: sampled state accepted by predicate ({})", newState);
        lastObservedState.set(new StoredState(newState));
        listener.onNewClusterState(newState);
    } else {
        logger.trace("observer: sampled state rejected by predicate ({}). adding listener to ClusterService", newState);
        final ObservingContext context = new ObservingContext(listener, statePredicate);
        if (!observingContext.compareAndSet(null, context)) {
            throw new ElasticsearchException("already waiting for a cluster state change");
        }
        clusterService.addTimeoutListener(timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS), clusterStateListener);
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public Builder(TimeValue interval) {
    this.unit = null;
    if (interval.millis() < 1)
        throw new IllegalArgumentException("Zero or negative time interval not supported");
    this.interval = interval.millis();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private static TimeValue checkDelay(TimeValue delay) {
    if (delay.millis() > Integer.MAX_VALUE) {
        throw new IllegalArgumentException("delay must be <= " + Integer.MAX_VALUE + " ms");
    }
    return delay;
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public GoogleCloudStorageRepository(RepositoryMetaData metadata, Environment environment,
                                    NamedXContentRegistry namedXContentRegistry,
                                    GoogleCloudStorageService storageService) throws Exception {
    super(metadata, environment.settings(), namedXContentRegistry);

    String bucket = getSetting(BUCKET, metadata);
    String application = getSetting(APPLICATION_NAME, metadata);
    String serviceAccount = getSetting(SERVICE_ACCOUNT, metadata);

    String basePath = BASE_PATH.get(metadata.settings());
    if (Strings.hasLength(basePath)) {
        BlobPath path = new BlobPath();
        for (String elem : basePath.split("/")) {
            path = path.add(elem);
        }
        this.basePath = path;
    } else {
        this.basePath = BlobPath.cleanPath();
    }

    TimeValue connectTimeout = null;
    TimeValue readTimeout = null;

    TimeValue timeout = HTTP_CONNECT_TIMEOUT.get(metadata.settings());
    if ((timeout != null) && (timeout.millis() != NO_TIMEOUT.millis())) {
        connectTimeout = timeout;
    }

    timeout = HTTP_READ_TIMEOUT.get(metadata.settings());
    if ((timeout != null) && (timeout.millis() != NO_TIMEOUT.millis())) {
        readTimeout = timeout;
    }

    this.compress = getSetting(COMPRESS, metadata);
    this.chunkSize = getSetting(CHUNK_SIZE, metadata);

    logger.debug("using bucket [{}], base_path [{}], chunk_size [{}], compress [{}], application [{}]",
            bucket, basePath, chunkSize, compress, application);

    Storage client = storageService.createClient(serviceAccount, application, connectTimeout, readTimeout);
    this.blobStore = new GoogleCloudStorageBlobStore(settings, bucket, client);
}