Java TimeValue.timeValueMillis方法代码示例

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Returns TimeValue based on the given interval
 * Interval can be in minutes, seconds, mili seconds
 */
public static TimeValue getTimeValue(String interval, String defaultValue) {
    TimeValue timeValue = null;
    String timeInterval = interval != null ? interval : defaultValue;
    logger.trace("Time interval is [{}] ", timeInterval);
    if (timeInterval != null) {
        Integer time = Integer.valueOf(timeInterval.substring(0, timeInterval.length() - 1));
        String unit = timeInterval.substring(timeInterval.length() - 1);
        UnitEnum unitEnum = UnitEnum.fromString(unit);
        switch (unitEnum) {
            case MINUTE:
                timeValue = TimeValue.timeValueMinutes(time);
                break;
            case SECOND:
                timeValue = TimeValue.timeValueSeconds(time);
                break;
            case MILI_SECOND:
                timeValue = TimeValue.timeValueMillis(time);
                break;
            default:
                logger.error("Unit is incorrect, please check the Time Value unit: " + unit);
        }
    }
    return timeValue;
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testIOExceptionRetry() throws Exception {
    FailThenSuccessBackoffTransport fakeTransport =
            new FailThenSuccessBackoffTransport(HttpStatusCodes.STATUS_CODE_SERVER_ERROR, 1, true);

    MockGoogleCredential credential = RetryHttpInitializerWrapper.newMockCredentialBuilder()
            .build();
    MockSleeper mockSleeper = new MockSleeper();
    RetryHttpInitializerWrapper retryHttpInitializerWrapper = new RetryHttpInitializerWrapper(credential, mockSleeper,
        TimeValue.timeValueMillis(500));

    Compute client = new Compute.Builder(fakeTransport, new JacksonFactory(), null)
            .setHttpRequestInitializer(retryHttpInitializerWrapper)
            .setApplicationName("test")
            .build();

    HttpRequest request = client.getRequestFactory().buildRequest("Get", new GenericUrl("http://elasticsearch.com"), null);
    HttpResponse response = request.execute();

    assertThat(mockSleeper.getCount(), equalTo(1));
    assertThat(response.getStatusCode(), equalTo(200));
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testOnRejectionCausesCancellation() throws Exception {
    final TimeValue delay = TimeValue.timeValueMillis(10L);
    terminate(threadPool);
    threadPool = new ThreadPool(Settings.builder().put(Node.NODE_NAME_SETTING.getKey(), "fixed delay tests").build()) {
        @Override
        public ScheduledFuture<?> schedule(TimeValue delay, String executor, Runnable command) {
            if (command instanceof ReschedulingRunnable) {
                ((ReschedulingRunnable) command).onRejection(new EsRejectedExecutionException());
            } else {
                fail("this should only be called with a rescheduling runnable in this test");
            }
            return null;
        }
    };
    Runnable runnable = () -> {};
    ReschedulingRunnable reschedulingRunnable = new ReschedulingRunnable(runnable, delay, Names.GENERIC, threadPool);
    assertTrue(reschedulingRunnable.isCancelled());
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
public TimeValue next() {
    if (!hasNext()) {
        throw new NoSuchElementException("Only up to " + numberOfElements + " elements");
    }
    int result = start + 10 * ((int) Math.exp(0.8d * (currentlyConsumed)) - 1);
    currentlyConsumed++;
    return TimeValue.timeValueMillis(result);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testFindNextDelayedAllocation() {
    MockAllocationService allocation = createAllocationService(Settings.EMPTY, new DelayedShardsMockGatewayAllocator());
    final TimeValue delayTest1 = TimeValue.timeValueMillis(randomIntBetween(1, 200));
    final TimeValue delayTest2 = TimeValue.timeValueMillis(randomIntBetween(1, 200));
    final long expectMinDelaySettingsNanos = Math.min(delayTest1.nanos(), delayTest2.nanos());

    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test1").settings(settings(Version.CURRENT).put(UnassignedInfo.INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), delayTest1)).numberOfShards(1).numberOfReplicas(1))
            .put(IndexMetaData.builder("test2").settings(settings(Version.CURRENT).put(UnassignedInfo.INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), delayTest2)).numberOfShards(1).numberOfReplicas(1))
            .build();
    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
            .metaData(metaData)
            .routingTable(RoutingTable.builder().addAsNew(metaData.index("test1")).addAsNew(metaData.index("test2")).build()).build();
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2"))).build();
    clusterState = allocation.reroute(clusterState, "reroute");
    assertThat(UnassignedInfo.getNumberOfDelayedUnassigned(clusterState), equalTo(0));
    // starting primaries
    clusterState = allocation.applyStartedShards(clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING));
    // starting replicas
    clusterState = allocation.applyStartedShards(clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING));
    assertThat(clusterState.getRoutingNodes().unassigned().size() > 0, equalTo(false));
    // remove node2 and reroute
    final long baseTime = System.nanoTime();
    allocation.setNanoTimeOverride(baseTime);
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder(clusterState.nodes()).remove("node2")).build();
    clusterState = allocation.deassociateDeadNodes(clusterState, true, "reroute");

    final long delta = randomBoolean() ? 0 : randomInt((int) expectMinDelaySettingsNanos - 1);

    if (delta > 0) {
        allocation.setNanoTimeOverride(baseTime + delta);
        clusterState = allocation.reroute(clusterState, "time moved");
    }

    assertThat(UnassignedInfo.findNextDelayedAllocation(baseTime + delta, clusterState), equalTo(expectMinDelaySettingsNanos - delta));
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testDefault() {
    TimeValue defaultValue = TimeValue.timeValueMillis(randomIntBetween(0, 1000000));
    Setting<TimeValue> setting =
        Setting.positiveTimeSetting("my.time.value", defaultValue, Property.NodeScope);
    assertFalse(setting.isGroupSetting());
    String aDefault = setting.getDefaultRaw(Settings.EMPTY);
    assertEquals(defaultValue.millis() + "ms", aDefault);
    assertEquals(defaultValue.millis(), setting.get(Settings.EMPTY).millis());
    assertEquals(defaultValue, setting.getDefault(Settings.EMPTY));

    Setting<String> secondaryDefault =
        new Setting<>("foo.bar", (s) -> s.get("old.foo.bar", "some_default"), Function.identity(), Property.NodeScope);
    assertEquals("some_default", secondaryDefault.get(Settings.EMPTY));
    assertEquals("42", secondaryDefault.get(Settings.builder().put("old.foo.bar", 42).build()));

    Setting<String> secondaryDefaultViaSettings =
        new Setting<>("foo.bar", secondaryDefault, Function.identity(), Property.NodeScope);
    assertEquals("some_default", secondaryDefaultViaSettings.get(Settings.EMPTY));
    assertEquals("42", secondaryDefaultViaSettings.get(Settings.builder().put("old.foo.bar", 42).build()));

    // It gets more complicated when there are two settings objects....
    Settings hasFallback = Settings.builder().put("foo.bar", "o").build();
    Setting<String> fallsback =
            new Setting<>("foo.baz", secondaryDefault, Function.identity(), Property.NodeScope);
    assertEquals("o", fallsback.get(hasFallback));
    assertEquals("some_default", fallsback.get(Settings.EMPTY));
    assertEquals("some_default", fallsback.get(Settings.EMPTY, Settings.EMPTY));
    assertEquals("o", fallsback.get(Settings.EMPTY, hasFallback));
    assertEquals("o", fallsback.get(hasFallback, Settings.EMPTY));
    assertEquals("a", fallsback.get(
            Settings.builder().put("foo.bar", "a").build(),
            Settings.builder().put("foo.bar", "b").build()));
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testThatQueueSizeSerializationWorks() throws Exception {
    ThreadPool.Info info = new ThreadPool.Info("foo", threadPoolType, 1, 10,
            TimeValue.timeValueMillis(3000), SizeValue.parseSizeValue("10k"));
    output.setVersion(Version.CURRENT);
    info.writeTo(output);

    StreamInput input = output.bytes().streamInput();
    ThreadPool.Info newInfo = new ThreadPool.Info(input);

    assertThat(newInfo.getQueueSize().singles(), is(10000L));
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testThatNegativeQueueSizesCanBeSerialized() throws Exception {
    ThreadPool.Info info = new ThreadPool.Info("foo", threadPoolType, 1, 10, TimeValue.timeValueMillis(3000), null);
    output.setVersion(Version.CURRENT);
    info.writeTo(output);

    StreamInput input = output.bytes().streamInput();
    ThreadPool.Info newInfo = new ThreadPool.Info(input);

    assertThat(newInfo.getQueueSize(), is(nullValue()));
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
public TimeValue next() {
    if (!hasNext()) {
        throw new NoSuchElementException("Reached maximum amount of backoff iterations. Only " + maxIterations + " iterations allowed.");
    }
    int result = startValue + calculate(currentIterations);
    currentIterations++;
    return TimeValue.timeValueMillis(result);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testThatToXContentWritesInteger() throws Exception {
    ThreadPool.Info info = new ThreadPool.Info("foo", threadPoolType, 1, 10,
            TimeValue.timeValueMillis(3000), SizeValue.parseSizeValue("1k"));
    XContentBuilder builder = jsonBuilder();
    builder.startObject();
    info.toXContent(builder, ToXContent.EMPTY_PARAMS);
    builder.endObject();

    Map<String, Object> map = XContentHelper.convertToMap(builder.bytes(), false, builder.contentType()).v2();
    assertThat(map, hasKey("foo"));
    map = (Map<String, Object>) map.get("foo");
    assertThat(map, hasKey("queue_size"));
    assertThat(map.get("queue_size").toString(), is("1000"));
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testDoesNotRescheduleUntilExecutionFinished() throws Exception {
    final TimeValue delay = TimeValue.timeValueMillis(100L);
    final CountDownLatch startLatch = new CountDownLatch(1);
    final CountDownLatch pauseLatch = new CountDownLatch(1);
    ThreadPool threadPool = mock(ThreadPool.class);
    final Runnable runnable = () ->  {
        // notify that the runnable is started
        startLatch.countDown();
        try {
            // wait for other thread to un-pause
            pauseLatch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    };
    ReschedulingRunnable reschedulingRunnable = new ReschedulingRunnable(runnable, delay, Names.GENERIC, threadPool);
    // this call was made during construction of the runnable
    verify(threadPool, times(1)).schedule(delay, Names.GENERIC, reschedulingRunnable);

    // create a thread and start the runnable
    Thread runThread = new Thread() {
        @Override
        public void run() {
            reschedulingRunnable.run();
        }
    };
    runThread.start();

    // wait for the runnable to be started and ensure the runnable hasn't used the threadpool again
    startLatch.await();
    verifyNoMoreInteractions(threadPool);

    // un-pause the runnable and allow it to complete execution
    pauseLatch.countDown();
    runThread.join();

    // validate schedule was called again
    verify(threadPool, times(2)).schedule(delay, Names.GENERIC, reschedulingRunnable);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testClusterHealth() throws IOException {
    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).build();
    int pendingTasks = randomIntBetween(0, 200);
    int inFlight = randomIntBetween(0, 200);
    int delayedUnassigned = randomIntBetween(0, 200);
    TimeValue pendingTaskInQueueTime = TimeValue.timeValueMillis(randomIntBetween(1000, 100000));
    ClusterHealthResponse clusterHealth = new ClusterHealthResponse("bla", new String[] {MetaData.ALL}, clusterState, pendingTasks, inFlight, delayedUnassigned, pendingTaskInQueueTime);
    clusterHealth = maybeSerialize(clusterHealth);
    assertClusterHealth(clusterHealth);
    assertThat(clusterHealth.getNumberOfPendingTasks(), Matchers.equalTo(pendingTasks));
    assertThat(clusterHealth.getNumberOfInFlightFetch(), Matchers.equalTo(inFlight));
    assertThat(clusterHealth.getDelayedUnassignedShards(), Matchers.equalTo(delayedUnassigned));
    assertThat(clusterHealth.getTaskMaxWaitingTime().millis(), is(pendingTaskInQueueTime.millis()));
    assertThat(clusterHealth.getActiveShardsPercent(), is(allOf(greaterThanOrEqualTo(0.0), lessThanOrEqualTo(100.0))));
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testRetryWaitTooLong() throws Exception {
    TimeValue maxWaitTime = TimeValue.timeValueMillis(10);
    int maxRetryTimes = 50;

    FailThenSuccessBackoffTransport fakeTransport =
            new FailThenSuccessBackoffTransport(HttpStatusCodes.STATUS_CODE_SERVER_ERROR, maxRetryTimes);
    JsonFactory jsonFactory = new JacksonFactory();
    MockGoogleCredential credential = RetryHttpInitializerWrapper.newMockCredentialBuilder()
            .build();

    MockSleeper oneTimeSleeper = new MockSleeper() {
        @Override
        public void sleep(long millis) throws InterruptedException {
            Thread.sleep(maxWaitTime.getMillis());
            super.sleep(0); // important number, use this to get count
        }
    };

    RetryHttpInitializerWrapper retryHttpInitializerWrapper = new RetryHttpInitializerWrapper(credential, oneTimeSleeper, maxWaitTime);

    Compute client = new Compute.Builder(fakeTransport, jsonFactory, null)
            .setHttpRequestInitializer(retryHttpInitializerWrapper)
            .setApplicationName("test")
            .build();

    HttpRequest request1 = client.getRequestFactory().buildRequest("Get", new GenericUrl("http://elasticsearch.com"), null);
    try {
        request1.execute();
        fail("Request should fail if wait too long");
    } catch (HttpResponseException e) {
        assertThat(e.getStatusCode(), equalTo(HttpStatusCodes.STATUS_CODE_SERVER_ERROR));
        // should only retry once.
        assertThat(oneTimeSleeper.getCount(), lessThan(maxRetryTimes));
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Returns expected time to heal after disruption has been removed. Defaults to instant healing.
 */
public TimeValue expectedTimeToHeal() {
    return TimeValue.timeValueMillis(0);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
public TimeValue expectedTimeToHeal() {
    return TimeValue.timeValueMillis(0);
}