import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
@Test
public void testRun_retryOnTransientFailure() throws Exception {
  persistResource(makeHostResource("ns1.cat.lol", "1.2.3.4"));
  WhoisServer server = newWhoisServer("ns1.cat.lol");
  WhoisResponse expectedResponse =
      server.whoisReader.readCommand(server.input, clock.nowUtc()).executeQuery(clock.nowUtc());

  WhoisReader mockReader = mock(WhoisReader.class);
  WhoisCommand mockCommand = mock(WhoisCommand.class);
  when(mockReader.readCommand(any(Reader.class), any(DateTime.class))).thenReturn(mockCommand);
  when(mockCommand.executeQuery(any(DateTime.class)))
      .thenThrow(new DatastoreFailureException("Expected transient exception #1"))
      .thenThrow(new DatastoreTimeoutException("Expected transient exception #2"))
      .thenReturn(expectedResponse);

  server.whoisReader = mockReader;
  server.run();
  assertThat(response.getPayload()).isEqualTo(loadFile("whois_server_nameserver.txt"));
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
@Test
public void testTransact_datastoreTimeoutException_noManifest_retries() {
  assertThat(ofy().transact(new Work<Integer>() {

    int count = 0;

    @Override
    public Integer run() {
      // We don't write anything in this transaction, so there is no commit log manifest.
      // Therefore it's always safe to retry since nothing got written.
      count++;
      if (count == 3) {
        return count;
      }
      throw new DatastoreTimeoutException("");
    }})).isEqualTo(3);
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
@Test
public void testTransact_datastoreTimeoutException_manifestNotWrittenToDatastore_retries() {
  assertThat(ofy().transact(new Work<Integer>() {

    int count = 0;

    @Override
    public Integer run() {
      // There will be something in the manifest now, but it won't be committed if we throw.
      ofy().save().entity(someObject);
      count++;
      if (count == 3) {
        return count;
      }
      throw new DatastoreTimeoutException("");
    }})).isEqualTo(3);
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
private CheckedTransaction beginTransaction(final TransactionOptions options)
    throws PermanentFailure, RetryableFailure {
  return safeRun(new Evaluater<CheckedTransaction>() {
    @Override public CheckedTransaction run() {
      Transaction rawTransaction = datastore.beginTransaction(options);
      // NOTE(ohler): Calling rawTransaction.getId() forces TransactionImpl to
      // wait for the result of the beginTransaction RPC.  We do this here to
      // get the DatastoreTimeoutException (in the case of a timeout) right
      // away rather than at some surprising time later in
      // TransactionImpl.toString() or similar.
      //
      // Hopefully, TransactionImpl will be fixed to eliminate the need for
      // this.
      try {
        rawTransaction.getId();
      } catch (DatastoreTimeoutException e) {
        // We don't log transaction itself because I'm worried its toString()
        // might fail.  TODO(ohler): confirm this.
        log.log(Level.WARNING, "Failed to begin transaction", e);
        // Now we need to roll back the transaction (even though it doesn't
        // actually exist), otherwise TransactionCleanupFilter will try to
        // roll it back, which is bad because it's not prepared for the crash
        // that we catch below.
        try {
          rawTransaction.rollback();
          throw new Error("Rollback of nonexistent transaction did not fail");
        } catch (DatastoreTimeoutException e2) {
          log.log(Level.INFO, "Rollback of nonexistent transaction failed as expected", e2);
        }
        throw e;
      }
      CheckedTransaction checkedTransaction = new CheckedTransactionImpl(rawTransaction);
      log.info("Begun transaction " + checkedTransaction);
      return checkedTransaction;
    }
  });
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
/**
 * Transact with commit logs and retry with exponential backoff.
 *
 * <p>This method is broken out from {@link #transactNew(Work)} for testing purposes.
 */
@VisibleForTesting
<R> R transactCommitLoggedWork(CommitLoggedWork<R> work) {
  long baseRetryMillis = getBaseOfyRetryDuration().getMillis();
  for (long attempt = 0, sleepMillis = baseRetryMillis;
      true;
      attempt++, sleepMillis *= 2) {
    try {
      ofy().transactNew(work);
      return work.getResult();
    } catch (TransientFailureException
        | TimestampInversionException
        | DatastoreTimeoutException
        | DatastoreFailureException e) {
      // TransientFailureExceptions come from task queues and always mean nothing committed.
      // TimestampInversionExceptions are thrown by our code and are always retryable as well.
      // However, Datastore exceptions might get thrown even if the transaction succeeded.
      if ((e instanceof DatastoreTimeoutException || e instanceof DatastoreFailureException)
          && checkIfAlreadySucceeded(work)) {
        return work.getResult();
      }
      if (attempt == NUM_RETRIES) {
        throw e;  // Give up.
      }
      sleeper.sleepUninterruptibly(Duration.millis(sleepMillis));
      logger.infofmt(e, "Retrying %s, attempt %s", e.getClass().getSimpleName(), attempt);
    }
  }
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
@Test
public void testTransact_datastoreTimeoutException_manifestWrittenToDatastore_returnsSuccess() {
  // A work unit that throws if it is ever retried.
  VoidWork work = new VoidWork() {
    boolean firstCallToVrun = true;

    @Override
    public void vrun() {
      if (firstCallToVrun) {
        firstCallToVrun = false;
        ofy().save().entity(someObject);
        return;
      }
      fail("Shouldn't have retried.");
    }};
  // A commit logged work that throws on the first attempt to get its result.
  CommitLoggedWork<Void> commitLoggedWork = new CommitLoggedWork<Void>(work, new SystemClock()) {
    boolean firstCallToGetResult = true;

    @Override
    public Void getResult() {
      if (firstCallToGetResult) {
        firstCallToGetResult = false;
        throw new DatastoreTimeoutException("");
      }
      return null;
    }};
  // Despite the DatastoreTimeoutException in the first call to getResult(), this should succeed
  // without retrying. If a retry is triggered, the test should fail due to the call to fail().
  ofy().transactCommitLoggedWork(commitLoggedWork);
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
@Override
public void saveSession(String key, SessionData data) throws Retryable {
  try {
    datastore.put(createEntityForSession(key, data));
  } catch (DatastoreTimeoutException e) {
    throw new Retryable(e);
  }
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public byte[] makeSyncCall(
    ApiProxy.Environment environment, String packageName, String methodName, byte[] request)
    throws ApiProxyException {
  if (packageName.equals("datastore_v3") && timeoutCount > 0) {
    timeoutCount--;
    throw new DatastoreTimeoutException("Timeout");
  }
  return delegate.makeSyncCall(environment, packageName, methodName, request);
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
public Future<byte[]> makeAsyncCall(
    ApiProxy.Environment environment,
    String packageName,
    String methodName,
    byte[] request,
    ApiProxy.ApiConfig apiConfig) {
  if (packageName.equals("datastore_v3") && timeoutCount > 0) {
    timeoutCount--;
    throw new DatastoreTimeoutException("Timeout");
  }
  return delegate.makeAsyncCall(environment, packageName, methodName, request, apiConfig);
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
private CheckedTransaction beginTransaction(final TransactionOptions options)
    throws PermanentFailure, RetryableFailure {
  return safeRun(new Evaluater<CheckedTransaction>() {
    @Override
    public CheckedTransaction run() {
      Transaction rawTransaction = datastore.beginTransaction(options);
      // NOTE(ohler): Calling rawTransaction.getId() forces TransactionImpl to
      // wait for the result of the beginTransaction RPC. We do this here to
      // get the DatastoreTimeoutException (in the case of a timeout) right
      // away rather than at some surprising time later in
      // TransactionImpl.toString() or similar.
      //
      // Hopefully, TransactionImpl will be fixed to eliminate the need for
      // this.
      try {
        rawTransaction.getId();
      } catch (DatastoreTimeoutException e) {
        // We don't log transaction itself because I'm worried its toString()
        // might fail. TODO(ohler): confirm this.
        log.log(Level.WARNING, "Failed to begin transaction", e);
        // Now we need to roll back the transaction (even though it doesn't
        // actually exist), otherwise TransactionCleanupFilter will try to
        // roll it back, which is bad because it's not prepared for the crash
        // that we catch below.
        try {
          rawTransaction.rollback();
          throw new Error("Rollback of nonexistent transaction did not fail");
        } catch (DatastoreTimeoutException e2) {
          log.log(Level.INFO, "Rollback of nonexistent transaction failed as expected", e2);
        }
        throw e;
      }
      CheckedTransaction checkedTransaction = new CheckedTransactionImpl(rawTransaction);
      log.info("Begun transaction " + checkedTransaction);
      return checkedTransaction;
    }
  });
}
 

import com.google.appengine.api.datastore.DatastoreTimeoutException; //导入依赖的package包/类
@Test
public void testTransactNewReadOnly_datastoreTimeoutException_retries() {
  doReadOnlyRetryTest(new DatastoreTimeoutException(""));
}