com.amazonaws.AmazonServiceException.ErrorType Java Examples

protected AmazonServiceException getSampleAwsServiceException() {
    final AmazonServiceException testServiceException = new AmazonServiceException("Test AWS Service Exception");
    testServiceException.setErrorCode("8673509");
    testServiceException.setErrorMessage("This request cannot be serviced right now.");
    testServiceException.setErrorType(ErrorType.Service);
    testServiceException.setServiceName("Dynamo DB");
    testServiceException.setRequestId("TestRequestId-1234567890");

    return testServiceException;
}
 

@Test
public void getObjectWithInvalidKey() {
  s3.createBucket("b");
  try {
    s3.getObject("b", "a");
  } catch (final AmazonServiceException e) {
    assertThat(e.getStatusCode(), is(404));
    assertThat(e.getErrorCode(), is("NoSuchKey"));
    assertThat(e.getErrorType(), is(ErrorType.Client));
  }
}
 

protected AmazonServiceException getSampleAwsServiceException() {
    final AmazonServiceException testServiceException = new AmazonServiceException("Test AWS Service Exception");
    testServiceException.setErrorCode("8673509");
    testServiceException.setErrorMessage("This request cannot be serviced right now.");
    testServiceException.setErrorType(ErrorType.Service);
    testServiceException.setServiceName("Dynamo DB");
    testServiceException.setRequestId("TestRequestId-1234567890");

    return testServiceException;
}
 

public void deliver(String from, String to, InputStream inputStream) throws IOException {
    AmazonSimpleEmailService client;
    if (cmd.hasOption("r")) {
        client = AmazonSimpleEmailServiceClientBuilder.standard().withRegion(cmd.getOptionValue("r")).build();
    } else {
        client = AmazonSimpleEmailServiceClientBuilder.standard().build();
    }
    byte[] msg = IOUtils.toByteArray(inputStream);
    RawMessage rawMessage =
            new RawMessage(ByteBuffer.wrap(msg));
    SendRawEmailRequest rawEmailRequest =
            new SendRawEmailRequest(rawMessage).withSource(from)
                                               .withDestinations(to);
    if (cmd.hasOption("a")) {
        rawEmailRequest = rawEmailRequest.withSourceArn(cmd.getOptionValue("a"));
    }
    if (cmd.hasOption("f")) {
        rawEmailRequest = rawEmailRequest.withFromArn(cmd.getOptionValue("f"));
    }
    if (cmd.hasOption("t")) {
        rawEmailRequest = rawEmailRequest.withReturnPathArn(cmd.getOptionValue("t"));
    }
    if (cmd.hasOption("c")) {
        rawEmailRequest = rawEmailRequest.withConfigurationSetName(cmd.getOptionValue("c"));
    }
    try {
        client.sendRawEmail(rawEmailRequest);
    } catch (AmazonSimpleEmailServiceException e) {
        if(e.getErrorType() == ErrorType.Client) {
            // If it's a client error, return a permanent error
            throw new RejectException(e.getMessage());
        } else {
            throw new RejectException(451, e.getMessage());
        }
    }
}
 

@Test
public void getObjectWithInvalidBucket() {
  try {
    s3.getObject("b", "a");
  } catch (final AmazonServiceException e) {
    assertThat(e.getStatusCode(), is(404));
    assertThat(e.getErrorCode(), is("NoSuchBucket"));
    assertThat(e.getErrorType(), is(ErrorType.Client));
  }
}
 

@Test
public void listObjectsFailsIfNoBucket() {
  try {
    s3.listObjects("b");
  } catch (final AmazonServiceException e) {
    assertThat(e.getStatusCode(), is(404));
    assertThat(e.getErrorCode(), is("NoSuchBucket"));
    assertThat(e.getErrorType(), is(ErrorType.Client));
  }
}
 

private S3ObjectInfo getObject(final String key) {
  final S3ObjectInfo info = getObjectOrNull(key);
  if (info == null) {
    final AmazonServiceException e = new AmazonServiceException("The specified key does not exist");
    e.setErrorCode("NoSuchKey");
    e.setErrorType(ErrorType.Client);
    e.setServiceName("Amazon S3");
    e.setStatusCode(404);
    throw e;
  }
  return info;
}
 

private BucketInfo getBucketInfo(final String name) {
  final BucketInfo info = getBucketInfoOrNull(name);
  if (info == null) {
    final AmazonServiceException e = new AmazonServiceException("The specified bucket does not exist");
    e.setStatusCode(404);
    e.setErrorType(ErrorType.Client);
    e.setServiceName("Amazon S3");
    e.setErrorCode("NoSuchBucket");
    throw e;
  }
  return info;
}
 

@Test
public void shouldHandleServiceErrorForGetBacklogBytes() {
  shouldHandleGetBacklogBytesError(
      newAmazonServiceException(ErrorType.Service), TransientKinesisException.class);
}
 

@Test
public void testIsRecoverableExceptionWithExpiredIteratorException() {
	final ExpiredIteratorException ex = new ExpiredIteratorException("asdf");
	ex.setErrorType(ErrorType.Client);
	assertFalse(KinesisProxy.isRecoverableException(ex));
}
 

@Test
public void testIsRecoverableExceptionWithServiceException() {
	final AmazonServiceException ex = new AmazonServiceException("asdf");
	ex.setErrorType(ErrorType.Service);
	assertTrue(KinesisProxy.isRecoverableException(ex));
}
 

@Test
public void testIsRecoverableExceptionWithProvisionedThroughputExceeded() {
	final ProvisionedThroughputExceededException ex = new ProvisionedThroughputExceededException("asdf");
	ex.setErrorType(ErrorType.Client);
	assertTrue(KinesisProxy.isRecoverableException(ex));
}
 

private AmazonServiceException newAmazonServiceException(ErrorType errorType) {
  AmazonServiceException exception = new AmazonServiceException("");
  exception.setErrorType(errorType);
  return exception;
}
 

@Test
public void shouldHandleClientErrorForGetBacklogBytes() {
  shouldHandleGetBacklogBytesError(
      newAmazonServiceException(ErrorType.Client), RuntimeException.class);
}
 

@Test
public void testIsRecoverableExceptionWithProvisionedThroughputExceeded() {
	final ProvisionedThroughputExceededException ex = new ProvisionedThroughputExceededException("asdf");
	ex.setErrorType(ErrorType.Client);
	assertTrue(KinesisProxy.isRecoverableException(ex));
}
 

@Test
public void shouldHandleClientErrorForShardListing() {
  shouldHandleShardListingError(
      newAmazonServiceException(ErrorType.Client), RuntimeException.class);
}
 

@Test
public void shouldHandleServiceErrorForShardListing() {
  shouldHandleShardListingError(
      newAmazonServiceException(ErrorType.Service), TransientKinesisException.class);
}
 

@Test
public void shouldHandleClientErrorForGetShardIterator() {
  shouldHandleGetShardIteratorError(
      newAmazonServiceException(ErrorType.Client), RuntimeException.class);
}
 

@Test
public void shouldHandleServiceErrorForGetShardIterator() {
  shouldHandleGetShardIteratorError(
      newAmazonServiceException(ErrorType.Service), TransientKinesisException.class);
}
 

@Test
public void testIsRecoverableExceptionWithExpiredIteratorException() {
	final ExpiredIteratorException ex = new ExpiredIteratorException("asdf");
	ex.setErrorType(ErrorType.Client);
	assertFalse(KinesisProxy.isRecoverableException(ex));
}
 

@Test
public void testIsRecoverableExceptionWithServiceException() {
	final AmazonServiceException ex = new AmazonServiceException("asdf");
	ex.setErrorType(ErrorType.Service);
	assertTrue(KinesisProxy.isRecoverableException(ex));
}
 

@Test
public void testIsRecoverableExceptionWithProvisionedThroughputExceeded() {
	final ProvisionedThroughputExceededException ex = new ProvisionedThroughputExceededException("asdf");
	ex.setErrorType(ErrorType.Client);
	assertTrue(KinesisProxy.isRecoverableException(ex));
}
 

@Test
public void testIsRecoverableExceptionWithExpiredIteratorException() {
	final ExpiredIteratorException ex = new ExpiredIteratorException("asdf");
	ex.setErrorType(ErrorType.Client);
	assertFalse(KinesisProxy.isRecoverableException(ex));
}
 

@Test
public void testIsRecoverableExceptionWithServiceException() {
	final AmazonServiceException ex = new AmazonServiceException("asdf");
	ex.setErrorType(ErrorType.Service);
	assertTrue(KinesisProxy.isRecoverableException(ex));
}