Refine search
@Override public RetryResult beforeEval(Exception exception) { if (exception instanceof DatastoreException) { DatastoreException e = getInnerException((DatastoreException) exception); if (e.getCode() == ABORTED_CODE || e.getReason() != null && e.getReason().equals("ABORTED")) { return Interceptor.RetryResult.RETRY; } } return Interceptor.RetryResult.CONTINUE_EVALUATION; }
/** * Throw a DatastoreException with {@code FAILED_PRECONDITION} reason and the {@code message} in a * nested exception. * * @throws DatastoreException every time */ static DatastoreException throwInvalidRequest(String massage, Object... params) { throw new DatastoreException( UNKNOWN_CODE, String.format(massage, params), "FAILED_PRECONDITION"); }
@Test public void testThrowInvalidRequest() throws Exception { try { DatastoreException.throwInvalidRequest("message %s %d", "a", 1); fail("Exception expected"); } catch (DatastoreException ex) { assertEquals("FAILED_PRECONDITION", ex.getReason()); assertEquals("message a 1", ex.getMessage()); } } }
com.google.datastore.v1.CommitResponse commit( final com.google.datastore.v1.CommitRequest requestPb) { try { return RetryHelper.runWithRetries( new Callable<com.google.datastore.v1.CommitResponse>() { @Override public com.google.datastore.v1.CommitResponse call() throws DatastoreException { return datastoreRpc.commit(requestPb); } }, retrySettings, EXCEPTION_HANDLER, getOptions().getClock()); } catch (RetryHelperException e) { throw DatastoreException.translateAndThrow(e); } }
@Test public void testDatastoreException() throws Exception { DatastoreException exception = new DatastoreException(10, "message", "ABORTED"); assertEquals(10, exception.getCode()); assertEquals("ABORTED", exception.getReason()); assertEquals("message", exception.getMessage()); assertTrue(exception.isRetryable()); exception = new DatastoreException(4, "message", "DEADLINE_EXCEEDED"); assertEquals(4, exception.getCode()); assertEquals("DEADLINE_EXCEEDED", exception.getReason()); assertEquals("message", exception.getMessage()); assertTrue(exception.isRetryable()); exception = new DatastoreException(14, "message", "UNAVAILABLE"); assertEquals(14, exception.getCode()); assertEquals("UNAVAILABLE", exception.getReason()); assertEquals("message", exception.getMessage()); assertTrue(exception.isRetryable()); exception = new DatastoreException(2, "message", "INTERNAL"); assertEquals(2, exception.getCode()); assertEquals("INTERNAL", exception.getReason()); assertEquals("message", exception.getMessage()); assertFalse(exception.isRetryable()); exception = new DatastoreException(cause); assertEquals(DatastoreException.UNKNOWN_CODE, exception.getCode()); assertNull(exception.getReason()); assertEquals("socketTimeoutMessage", exception.getMessage());
@Test public void testNonRetryableException() throws Exception { LookupRequest requestPb = LookupRequest.newBuilder().addKeys(KEY1.toPb()).build(); EasyMock.expect(rpcMock.lookup(requestPb)) .andThrow( new DatastoreException(DatastoreException.UNKNOWN_CODE, "denied", "PERMISSION_DENIED")) .times(1); EasyMock.replay(rpcFactoryMock, rpcMock); Datastore datastore = rpcMockOptions.getService(); thrown.expect(DatastoreException.class); thrown.expectMessage("denied"); datastore.get(KEY1); EasyMock.verify(rpcFactoryMock, rpcMock); }
if (Code.ABORTED.getNumber() == ex.getCode() || (Code.INVALID_ARGUMENT.getNumber() == ex.getCode() && ex.getMessage().contains("transaction closed"))) { log.warn("Retrying {} failure for {}: {}", ex.getReason(), work, ex); log.trace("Details of transaction failure", ex); try { throw new DatastoreException(ex.getCode(), "Failed retrying datastore " + ORIGINAL_TRIES + " times ", ex.getReason(), ex);
/** Example of adding a single entity. */ // [TARGET add(FullEntity)] // [VARIABLE "my_key_name"] public void addSingleEntity(String keyName) { // [START addSingleEntity] Key key = datastore.newKeyFactory().setKind("MyKind").newKey(keyName); Entity.Builder entityBuilder = Entity.newBuilder(key); entityBuilder.set("propertyName", "value"); Entity entity = entityBuilder.build(); try { datastore.add(entity); } catch (DatastoreException ex) { if ("ALREADY_EXISTS".equals(ex.getReason())) { // entity.getKey() already exists } } // [END addSingleEntity] }
public boolean isConflict() { if (getCause() != null && getCause() instanceof DatastoreException) { DatastoreException datastoreException = (DatastoreException) getCause(); return datastoreException.getCode() == 10; } else { return false; } }
@Test public void testTranslateAndThrow() throws Exception { Exception cause = new DatastoreException(14, "message", "UNAVAILABLE"); RetryHelper.RetryHelperException exceptionMock = createMock(RetryHelper.RetryHelperException.class); replay(exceptionMock); try { DatastoreException.translateAndThrow(exceptionMock); } catch (BaseServiceException ex) { assertEquals(14, ex.getCode()); replay(exceptionMock); try { DatastoreException.translateAndThrow(exceptionMock); } catch (BaseServiceException ex) { assertEquals(DatastoreException.UNKNOWN_CODE, ex.getCode());
throw DatastoreException.throwInvalidRequest( "Duplicate entity with the key %s", entity.getKey()); com.google.datastore.v1.Mutation.newBuilder().setInsert(entity.toPb()).build()); com.google.datastore.v1.CommitResponse commitResponse = commitMutation(mutationsPb); Iterator<com.google.datastore.v1.MutationResult> mutationResults = commitResponse.getMutationResultsList().iterator();
protected DatastoreException newInvalidRequest(String msg, Object... params) { return DatastoreException.throwInvalidRequest(String.format(msg, params)); }
public TransactionException(DatastoreException cause) { super(cause.getMessage(), cause); }
private com.google.datastore.v1.AllocateIdsResponse allocateIds( final com.google.datastore.v1.AllocateIdsRequest requestPb) { try { return RetryHelper.runWithRetries( new Callable<com.google.datastore.v1.AllocateIdsResponse>() { @Override public com.google.datastore.v1.AllocateIdsResponse call() throws DatastoreException { return datastoreRpc.allocateIds(requestPb); } }, retrySettings, EXCEPTION_HANDLER, getOptions().getClock()); } catch (RetryHelperException e) { throw DatastoreException.translateAndThrow(e); } }
@Test public void testRetryableException() throws Exception { LookupRequest requestPb = LookupRequest.newBuilder().addKeys(KEY1.toPb()).build(); LookupResponse responsePb = LookupResponse.newBuilder() .addFound(EntityResult.newBuilder().setEntity(ENTITY1.toPb())) .build(); EasyMock.expect(rpcMock.lookup(requestPb)) .andThrow(new DatastoreException(14, "UNAVAILABLE", "UNAVAILABLE", null)) .andReturn(responsePb); EasyMock.replay(rpcFactoryMock, rpcMock); Datastore datastore = rpcMockOptions.getService(); Entity entity = datastore.get(KEY1); assertEquals(ENTITY1, entity); EasyMock.verify(rpcFactoryMock, rpcMock); }
/** Example of adding multiple entities. */ // [TARGET add(FullEntity...)] // [VARIABLE "my_key_name1"] // [VARIABLE "my_key_name2"] public void batchAddEntities(String keyName1, String keyName2) { // [START batchAddEntities] Key key1 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName1); Entity.Builder entityBuilder1 = Entity.newBuilder(key1); entityBuilder1.set("propertyName", "value1"); Entity entity1 = entityBuilder1.build(); Key key2 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName2); Entity.Builder entityBuilder2 = Entity.newBuilder(key2); entityBuilder2.set("propertyName", "value2"); Entity entity2 = entityBuilder2.build(); try { datastore.add(entity1, entity2); } catch (DatastoreException ex) { if ("ALREADY_EXISTS".equals(ex.getReason())) { // at least one of entity1.getKey() and entity2.getKey() already exists } } // [END batchAddEntities] }