Java 类com.google.common.collect.DiscreteDomains 实例源码

/**
 * Helper method to restart instances of runnables.
 */
private void restartRunnableInstances(final String runnableName, @Nullable final Set<Integer> instanceIds,
                                      final Runnable completion) {
  instanceChangeExecutor.execute(new Runnable() {
    @Override
    public void run() {
      LOG.debug("Begin restart runnable {} instances.", runnableName);
      int runningCount = runningContainers.count(runnableName);
      Set<Integer> instancesToRemove = instanceIds == null ? null : ImmutableSet.copyOf(instanceIds);
      if (instancesToRemove == null) {
        instancesToRemove = Ranges.closedOpen(0, runningCount).asSet(DiscreteDomains.integers());
      }

      LOG.info("Restarting instances {} for runnable {}", instancesToRemove, runnableName);
      RunnableContainerRequest containerRequest =
        createRunnableContainerRequest(runnableName, instancesToRemove.size(), false);
      runnableContainerRequests.add(containerRequest);

      for (int instanceId : instancesToRemove) {
        LOG.debug("Stop instance {} for runnable {}", instanceId, runnableName);
        try {
          runningContainers.stopByIdAndWait(runnableName, instanceId);
        } catch (Exception ex) {
          // could be thrown if the container already stopped.
          LOG.info("Exception thrown when stopping instance {} probably already stopped.", instanceId);
        }
      }

      LOG.info("All instances in {} for runnable {} are stopped. Ready to provision",
               instancesToRemove, runnableName);

      // set the container request to be ready
      containerRequest.setReadyToBeProvisioned();

      // For all runnables that needs to re-request for containers, update the expected count timestamp
      // so that the EventHandler would be triggered with the right expiration timestamp.
      expectedContainers.updateRequestTime(Collections.singleton(runnableName));

      completion.run();
    }
  });
}

private List<Object> getValuesFromRange() {
  int rangeStart = config.getInt(RANGE_START_PROPERTY);
  int rangeEnd = config.getInt(RANGE_END_PROPERTY);

  return Lists.<Object>newArrayList(Ranges.closed(rangeStart, rangeEnd).asSet(DiscreteDomains.integers()));
}

@Override
public int run(String[] args) throws Exception {
  // going to generate a lot of random log messages
  final Random rand = new Random();

  // open the repository
  final DatasetRepository repo = DatasetRepositories.open("repo:file:/tmp/data");

  // data is written to the staging dataset
  final Dataset<GenericRecord> staging = repo.load("logs-staging");
  final DatasetWriter<GenericRecord> writer = staging.newWriter();

  // this is going to build our simple log records
  final GenericRecordBuilder builder = new GenericRecordBuilder(
      staging.getDescriptor().getSchema());

  // generate timestamps 1 second apart starting... now
  final Calendar now = Calendar.getInstance();
  final long yesterday = now.getTimeInMillis() - DAY_IN_MILLIS;

  try {
    writer.open();

    // generate 15,000 messages, each 5 seconds apart, starting 24 hours ago
    // this is a little less than 24 hours worth of messages
    for (int second : Ranges.closed(0, 15000).asSet(DiscreteDomains.integers())) {
      LOG.info("Generating log message " + second);

      builder.set("timestamp", yesterday + second * 5000);
      builder.set("component", "GenerateSimpleLogs");

      int level = rand.nextInt(LOG_LEVELS.length);
      builder.set("level", LOG_LEVELS[level]);
      builder.set("message", LOG_MESSAGES[level]);

      writer.write(builder.build());
    }
  } finally {
    writer.flush();
    writer.close();
  }

  return 0;
}

@Override
public int run(String[] args) throws Exception {
  // going to generate a lot of random log messages
  final Random rand = new Random();

  // data is written to the staging dataset
  Dataset<Record> staging = Datasets.load(
      "dataset:file:/tmp/data/logs_staging", Record.class);

  // this is going to build our simple log records
  GenericRecordBuilder builder = new GenericRecordBuilder(
      staging.getDescriptor().getSchema());

  // generate timestamps 1 second apart starting 1 day ago
  final Calendar now = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
  final long yesterday = now.getTimeInMillis() - DAY_IN_MILLIS;

  DatasetWriter<Record> writer = null;
  try {
    writer = staging.newWriter();

    // generate 15,000 messages, each 5 seconds apart, starting 24 hours ago
    // this is a little less than 24 hours worth of messages
    for (int second : Ranges.closed(0, 15000).asSet(DiscreteDomains.integers())) {
      LOG.info("Generating log message " + second);

      builder.set("timestamp", yesterday + second * 5000);
      builder.set("component", "GenerateSimpleLogs");

      int level = rand.nextInt(LOG_LEVELS.length);
      builder.set("level", LOG_LEVELS[level]);
      builder.set("message", LOG_MESSAGES[level]);

      writer.write(builder.build());
    }

    if (writer instanceof Flushable) {
      ((Flushable) writer).flush();
    }
  } finally {
    if (writer != null) {
      writer.close();
    }
  }

  return 0;
}