Java Sleeper.DEFAULT属性代码示例

@Override
public Optional<URI> run(RunSpec runSpec) {
  Sleeper retrySleeper = Sleeper.DEFAULT;
  BackOff backoff = BACKOFF_FACTORY.backoff();

  while (true) {
    try {
      final Pod pod = client.pods().create(createPod(runSpec));
      final String podName = pod.getMetadata().getName();
      LOG.info("Created pod {}", podName);

      Optional<URI> uri = blockUntilComplete(podName);
      client.pods().withName(podName).delete();
      return uri;
    } catch (KubernetesClientException kce) {
      try {
        long sleep = backoff.nextBackOffMillis();
        if (sleep == BackOff.STOP) {
          // Rethrow last error, to be included as a cause in the catch below.
          LOG.error("Failed to create Kubernetes pod", kce);
          throw new KubernetesClientException("Failed to create Kubernetes pod", kce);
        } else {
          LOG.warn("Kubernetes creation attempt failed, sleeping before retrying", kce);
          retrySleeper.sleep(sleep);
        }
      } catch (IOException | InterruptedException ioe) {
        throw new RuntimeException(
            String.format("Failed to create Kubernetes pod when trying to sleep: %s", ioe.getMessage()), ioe);
      }
    } catch (InterruptedException ie) {
      throw new RuntimeException("Interrupted while blocking", ie);
    }
  }
}
 

/**
 * @param additionalIgnoredResponseCodes a list of HTTP status codes that should not be logged.
 * @param responseInterceptor HttpResponseInterceptor to be applied on all requests. May be null.
 */
public RetryHttpRequestInitializer(
    Collection<Integer> additionalIgnoredResponseCodes,
    @Nullable HttpResponseInterceptor responseInterceptor) {
  this(NanoClock.SYSTEM, Sleeper.DEFAULT, additionalIgnoredResponseCodes,
      responseInterceptor);
}
 

@Override
public Job pollJob(JobReference jobRef, int maxAttempts)
    throws InterruptedException {
  BackOff backoff =
      BackOffAdapter.toGcpBackOff(
          FluentBackoff.DEFAULT
              .withMaxRetries(maxAttempts)
              .withInitialBackoff(Duration.millis(10))
              .withMaxBackoff(Duration.standardSeconds(1))
              .backoff());
  Sleeper sleeper = Sleeper.DEFAULT;
  try {
    do {
      Job job = getJob(jobRef);
      if (job != null) {
        JobStatus status = job.getStatus();
        if (status != null && status.getState() != null
            && (status.getState().equals("DONE") || status.getState().equals("FAILED"))) {
          return job;
        }
      }
    } while (BackOffUtils.next(sleeper, backoff));
  } catch (IOException e) {
    return null;
  }
  return null;
}
 

private static void upload(String classpathElement, String target, Path targetPath)
    throws IOException, InterruptedException {
  ArrayList<OpenOption> options = new ArrayList<>();
  options.add(WRITE);
  options.add(CREATE_NEW);
  if ("gs".equals(targetPath.toUri().getScheme())) {
    options.add(withMimeType(BINARY));
  }

  // Upload file, retrying on failure.
  Sleeper retrySleeper = Sleeper.DEFAULT;
  BackOff backoff = BACKOFF_FACTORY.backoff();
  while (true) {
    try {
      LOG.debug("Uploading classpath element {} to {}", classpathElement, target);
      try (WritableByteChannel writer = java.nio.file.Files.newByteChannel(targetPath,
          options.toArray(new OpenOption[options.size()]))) {
        copyContent(classpathElement, writer);
      }
      break;
    } catch (IOException e) {
      if (ERROR_EXTRACTOR.accessDenied(e)) {
        String errorMessage = String.format(
            "Uploaded failed due to permissions error, will NOT retry staging "
            + "of classpath %s. Please verify credentials are valid and that you have "
            + "write access to %s. Stale credentials can be resolved by executing "
            + "'gcloud auth login'.", classpathElement, target);
        LOG.error(errorMessage);
        throw new IOException(errorMessage, e);
      }
      long sleep = backoff.nextBackOffMillis();
      if (sleep == BackOff.STOP) {
        // Rethrow last error, to be included as a cause in the catch below.
        LOG.error("Upload failed, will NOT retry staging of classpath: {}",
            classpathElement, e);
        throw e;
      } else {
        LOG.warn("Upload attempt failed, sleeping before retrying staging of classpath: {}",
            classpathElement, e);
        retrySleeper.sleep(sleep);
      }
    }
  }
}
 

public RetryHttpInitializerWrapper(Credential wrappedCredential) {
    this(wrappedCredential, Sleeper.DEFAULT, TimeValue.timeValueMillis(ExponentialBackOff.DEFAULT_MAX_ELAPSED_TIME_MILLIS));
}
 

public RetryHttpInitializerWrapper(Credential wrappedCredential) {
	this(wrappedCredential, Sleeper.DEFAULT);
}
 

public RetryHttpInitializerWrapper(Credential wrappedCredential) {
  this(wrappedCredential, Sleeper.DEFAULT);
}
 

/**
 * Polls job until it is completed.
 *
 * @param bigquery the Bigquery instance to poll.
 * @param projectId the project that is polling.
 * @param jobReference the job to poll.
 * @param progressable to get progress of task.
 *
 * @throws IOException on IO Error.
 * @throws InterruptedException on sleep interrupt.
 */
public static void waitForJobCompletion(
    Bigquery bigquery,
    String projectId,
    JobReference jobReference,
    Progressable progressable)
    throws IOException, InterruptedException {

  Sleeper sleeper = Sleeper.DEFAULT;
  BackOff pollBackOff =
      new ExponentialBackOff.Builder()
          .setMaxIntervalMillis(POLL_WAIT_INTERVAL_MAX_MILLIS)
          .setInitialIntervalMillis(POLL_WAIT_INITIAL_MILLIS)
          .setMaxElapsedTimeMillis(POLL_WAIT_MAX_ELAPSED_MILLIS)
          .build();

  // Get starting time.
  long startTime = System.currentTimeMillis();
  long elapsedTime = 0;
  boolean notDone = true;

  // While job is incomplete continue to poll.
  while (notDone) {
    BackOff operationBackOff = new ExponentialBackOff.Builder().build();
    Get get = bigquery.jobs().get(projectId, jobReference.getJobId());
    
    Job pollJob = ResilientOperation.retry(
        ResilientOperation.getGoogleRequestCallable(get),
        operationBackOff,
        RetryDeterminer.RATE_LIMIT_ERRORS,
        IOException.class,
        sleeper);

    elapsedTime = System.currentTimeMillis() - startTime;
    LOG.debug("Job status ({} ms) {}: {}", elapsedTime, jobReference.getJobId(),
        pollJob.getStatus().getState());
    if (pollJob.getStatus().getState().equals("DONE")) {
      notDone = false;
      if (pollJob.getStatus().getErrorResult() != null) {
        throw new IOException(pollJob.getStatus().getErrorResult().getMessage());
      }
    } else {
      long millisToWait = pollBackOff.nextBackOffMillis();
      if (millisToWait == BackOff.STOP) {
        throw new IOException(
            String.format(
                "Job %s failed to complete after %s millis.",
                jobReference.getJobId(),
                elapsedTime));
      }
      // Pause execution for the configured duration before polling job status again.
      Thread.sleep(millisToWait);
      // Call progress to ensure task doesn't time out.
      progressable.progress();
    }
  }
}
 

public RetryHttpInitializerWrapper(GoogleCredential wrappedCredential) {
  this(wrappedCredential, Sleeper.DEFAULT);
}
 

/**
 * A constructor.
 *
 * @param wrappedCredential Credential which will be wrapped and used for providing auth header.
 */
public RetryHttpInitializerWrapper(final Credential wrappedCredential) {
  this(wrappedCredential, Sleeper.DEFAULT);
}
 

/**
 * A constructor.
 *
 * @param wrappedCredential Credential which will be wrapped and
 * used for providing auth header.
 */
public RetryHttpInitializerWrapper(final Credential wrappedCredential) {
    this(wrappedCredential, Sleeper.DEFAULT);
}
 

/**
 * Initialize variables for retry.
 *
 * @param wrappedCredential Google Credentials for retry.
 */
public RetryHttpInitializerWrapper(final Credential wrappedCredential) {
  this.wrappedCredential = wrappedCredential;
  this.sleeper = Sleeper.DEFAULT;
}
 

/**
 * A constructor using the default Sleeper.
 *
 * @param wrappedCredential
 *          the credential used to authenticate with a Google Cloud Platform project
 */
public RetryHttpInitializerWrapper(Credential wrappedCredential) {
  this(wrappedCredential, Sleeper.DEFAULT);
}
 

/**
 * Constructs a {@code ReportDownloader} object for a
 * {@link ReportServiceInterface} and a report job id that the the class works
 * on.
 *
 * @param reportService the ReportService stub to make calls to
 * @param reportJobId the report job ID
 */
public ReportDownloader(ReportServiceInterface reportService, long reportJobId) {
  this(reportService, reportJobId, Sleeper.DEFAULT);
}