com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException Java Examples

/**
 * Fetches table metadata by first doing a DescribeTable on the given table table, falling back to case
 * insensitive resolution if the table isn't found.
 *
 * @param tableName the case insensitive table name
 * @return the table's metadata
 */
public DynamoDBTable getTableMetadata(String tableName)
        throws TimeoutException
{
    try {
        return DDBTableUtils.getTable(tableName, invoker, ddbClient);
    }
    catch (ResourceNotFoundException e) {
        Optional<String> caseInsensitiveMatch = tryCaseInsensitiveSearch(tableName);
        if (caseInsensitiveMatch.isPresent()) {
            return DDBTableUtils.getTable(caseInsensitiveMatch.get(), invoker, ddbClient);
        }
        else {
            throw e;
        }
    }
}
 

/**
 * Fetches table schema by first doing a Scan on the given table name, falling back to case insensitive
 * resolution if the table isn't found.  Delegates actual schema derivation to {@link
 * DDBTableUtils#peekTableForSchema}.
 *
 * @param tableName the case insensitive table name
 * @return the table's schema
 */
public Schema getTableSchema(String tableName)
        throws TimeoutException
{
    try {
        return DDBTableUtils.peekTableForSchema(tableName, invoker, ddbClient);
    }
    catch (ResourceNotFoundException e) {
        Optional<String> caseInsensitiveMatch = tryCaseInsensitiveSearch(tableName);
        if (caseInsensitiveMatch.isPresent()) {
            return DDBTableUtils.peekTableForSchema(caseInsensitiveMatch.get(), invoker, ddbClient);
        }
        else {
            throw e;
        }
    }
}
 

public void waitForTableDeleted(String tableName, long waitTimeSeconds) throws InterruptedException {
    
    if(waitTimeSeconds < 0) {
        throw new IllegalArgumentException("Invalid waitTimeSeconds " + waitTimeSeconds);
    }
    
    long startTimeMs = System.currentTimeMillis();
    long elapsedMs = 0;
    do {
        try {
            DescribeTableResult describe = client.describeTable(new DescribeTableRequest().withTableName(tableName));
            String status = describe.getTable().getTableStatus();
            if(! TableStatus.DELETING.toString().equals(status)) {
                throw new ResourceInUseException("Table " + tableName + " is " + status + ", and waiting for it to not exist is only useful if it is DELETING.");
            }
        } catch (ResourceNotFoundException e) {
            return;
        }
        Thread.sleep(10 * 1000);
        elapsedMs = System.currentTimeMillis() - startTimeMs; 
    } while(elapsedMs / 1000.0 < waitTimeSeconds);
    
    throw new ResourceInUseException("Table " + tableName + " was not deleted after " + waitTimeSeconds + " seconds.");
}
 

public void setupTable() {
	setupGeoDataManager();

	GeoDataManagerConfiguration config = geoDataManager.getGeoDataManagerConfiguration();
	DescribeTableRequest describeTableRequest = new DescribeTableRequest().withTableName(config.getTableName());

	try {
		config.getDynamoDBClient().describeTable(describeTableRequest);

		if (status == Status.NOT_STARTED) {
			status = Status.READY;
		}
	} catch (ResourceNotFoundException e) {
		SchoolDataLoader schoolDataLoader = new SchoolDataLoader();
		schoolDataLoader.start();
	}

}
 

public AbstractDynamoDBRecordWriter(JobConf jobConf, Progressable progressable) {
  this.progressable = progressable;

  client = new DynamoDBClient(jobConf);
  tableName = jobConf.get(DynamoDBConstants.OUTPUT_TABLE_NAME);
  if (tableName == null) {
    throw new ResourceNotFoundException("No output table name was specified.");
  }


  deletionMode = jobConf.getBoolean(DynamoDBConstants.DELETION_MODE, DynamoDBConstants.DEFAULT_DELETION_MODE);

  IopsCalculator iopsCalculator = new WriteIopsCalculator(createJobClient(jobConf), client,
      tableName);
  iopsController = new IopsController(iopsCalculator, DEFAULT_AVERAGE_ITEM_SIZE_IN_BYTES,
      DynamoDBOperationType.WRITE);
  permissibleWritesPerSecond = iopsController.getTargetItemsPerSecond();
  log.info("Number of allocated item writes per second: " + permissibleWritesPerSecond);

  // Hive may not have a valid Reporter and pass in null progressable
  // TODO Check whether this would happen when excluding Hive
  if (progressable instanceof Reporter) {
    reporter = (Reporter) progressable;
  }
}
 

/**
 * Flush batch of data to DynamoDB
 *
 * @param mapper mapper associated with the batch
 * @param batch batch of data to write to DynamoDB
 */
private void flushBatch(DynamoDBMapper mapper, Deque<DynamoDBItem<?>> batch) {
    long currentTimeMillis = System.currentTimeMillis();
    List<FailedBatch> failed = mapper.batchSave(batch);
    for (FailedBatch failedBatch : failed) {
        if (failedBatch.getException() instanceof ResourceNotFoundException) {
            // Table did not exist. Try writing everything again.
            retryFlushAfterCreatingTable(mapper, batch, failedBatch);
            break;
        } else {
            logger.debug("Batch failed with {}. Retrying next with exponential back-off",
                    failedBatch.getException().getMessage());
            new ExponentialBackoffRetry(failedBatch.getUnprocessedItems()).run();
        }
    }
    if (failed.isEmpty()) {
        logger.debug("flushBatch ended with {} items in {} ms: {}", batch.size(),
                System.currentTimeMillis() - currentTimeMillis, batch);
    } else {
        logger.warn(
                "flushBatch ended with {} items in {} ms: {}. There were some failed batches that were retried -- check logs for ERRORs to see if writes were successful",
                batch.size(), System.currentTimeMillis() - currentTimeMillis, batch);
    }
}
 

@Before
public void setup() {
    dynamoDbIad = buildDynamoDbClient(Regions.US_EAST_1);
    iadTable = new Table(dynamoDbIad, INVENTORY_TABLE_IAD);
    dynamoDbPdx = buildDynamoDbClient(Regions.US_WEST_2);
    pdxTable = new Table(dynamoDbIad, INVENTORY_TABLE_PDX);
    try {
        dynamoDbIad.deleteTable(INVENTORY_TABLE_IAD);
        for (String tableName : dynamoDbIad.listTables().getTableNames()) {
            if (tableName.contains(CRR_INTEGRATION_TEST)) {
                dynamoDbIad.deleteTable(tableName); //KCL lease table used in test
                break;
            }
        }
        dynamoDbPdx.deleteTable(INVENTORY_TABLE_PDX);
    } catch(ResourceNotFoundException e) {
        //do nothing
    }
}
 

public void setupTable() {
	setupGeoDataManager();

	GeoDataManagerConfiguration config = geoDataManager.getGeoDataManagerConfiguration();
	DescribeTableRequest describeTableRequest = new DescribeTableRequest().withTableName(config.getTableName());

	try {
		config.getDynamoDBClient().describeTable(describeTableRequest);

		if (status == Status.NOT_STARTED) {
			status = Status.READY;
		}
	} catch (ResourceNotFoundException e) {
		PhotoLocationsTable photoLocationsTable = new PhotoLocationsTable();
		photoLocationsTable.start();
	}

}
 

/**
 * Helper method to determine if an Amazon DynamoDB table exists.
 * 
 * @param client
 *        The {@link AmazonDynamoDBClient} with Amazon DynamoDB read privileges
 * @param tableName
 *        The Amazon DynamoDB table to check for
 * @return true if the Amazon DynamoDB table exists, otherwise return false
 */
private static boolean tableExists(AmazonDynamoDBClient client, String tableName) {
    DescribeTableRequest describeTableRequest = new DescribeTableRequest();
    describeTableRequest.setTableName(tableName);
    try {
        client.describeTable(describeTableRequest);
        return true;
    } catch (ResourceNotFoundException e) {
        return false;
    }
}
 

/**
 * Verifies that the table exists with the specified schema, and creates it if it does not exist.
 * 
 * @param tableName
 * @param definitions
 * @param keySchema
 * @param localIndexes
 * @param provisionedThroughput
 * @param waitTimeSeconds
 * @throws InterruptedException 
 */
public void verifyOrCreateTable(
    String tableName, 
    List<AttributeDefinition> definitions, 
    List<KeySchemaElement> keySchema,
    List<LocalSecondaryIndex> localIndexes,
    ProvisionedThroughput provisionedThroughput,
    Long waitTimeSeconds) throws InterruptedException {
    
    if(waitTimeSeconds != null && waitTimeSeconds < 0) {
        throw new IllegalArgumentException("Invalid waitTimeSeconds " + waitTimeSeconds);
    }
    
    String status = null;
    try {
        status = verifyTableExists(tableName, definitions, keySchema, localIndexes);
    } catch(ResourceNotFoundException e) {
        status = client.createTable(new CreateTableRequest()
            .withTableName(tableName)
            .withAttributeDefinitions(definitions)
            .withKeySchema(keySchema)
            .withLocalSecondaryIndexes(localIndexes)
            .withProvisionedThroughput(provisionedThroughput)).getTableDescription().getTableStatus();
    }
    
    if(waitTimeSeconds != null && ! TableStatus.ACTIVE.toString().equals(status)) {
        waitForTableActive(tableName, definitions, keySchema, localIndexes, waitTimeSeconds);
    }
}
 

protected List<KeySchemaElement> getTableSchema(String tableName) throws ResourceNotFoundException {
    List<KeySchemaElement> schema = tableSchemaCache.get(tableName);
    if(schema == null) {
        DescribeTableResult result = client.describeTable(new DescribeTableRequest().withTableName(tableName));
        schema = Collections.unmodifiableList(result.getTable().getKeySchema());
        tableSchemaCache.put(tableName, schema);
    }
    return schema;
}
 

private boolean sleep() {
    try {
        long sleepTime;
        if (retry == 1 && lastException != null && lastException instanceof ResourceNotFoundException) {
            sleepTime = WAIT_ON_FIRST_RESOURCE_NOT_FOUND_MILLIS;
        } else {
            sleepTime = WAIT_MILLIS_IN_RETRIES[retry];
        }
        Thread.sleep(sleepTime);
        return true;
    } catch (InterruptedException e) {
        logger.debug("Interrupted while writing data!");
        return false;
    }
}
 

@Override
public void run() {
    logger.debug("Error storing object to dynamo, unprocessed items: {}. Retrying with exponential back-off",
            unprocessedItems);
    lastException = null;
    while (!unprocessedItems.isEmpty() && retry < WAIT_MILLIS_IN_RETRIES.length) {
        if (!sleep()) {
            // Interrupted
            return;
        }
        retry++;
        try {
            BatchWriteItemOutcome outcome = DynamoDBPersistenceService.this.db.getDynamoDB()
                    .batchWriteItemUnprocessed(unprocessedItems);
            unprocessedItems = outcome.getUnprocessedItems();
            lastException = null;
        } catch (AmazonServiceException e) {
            if (e instanceof ResourceNotFoundException) {
                logger.debug(
                        "DynamoDB query raised unexpected exception: {}. This might happen if table was recently created",
                        e.getMessage());
            } else {
                logger.debug("DynamoDB query raised unexpected exception: {}.", e.getMessage());
            }
            lastException = e;
            continue;
        }
    }
    if (unprocessedItems.isEmpty()) {
        logger.debug("After {} retries successfully wrote all unprocessed items", retry);
    } else {
        logger.warn(
                "Even after retries failed to write some items. Last exception: {} {}, unprocessed items: {}",
                lastException == null ? "null" : lastException.getClass().getName(),
                lastException == null ? "null" : lastException.getMessage(), unprocessedItems);
    }
}
 

protected boolean doesTableExist(String tableName) {
    try {
        DescribeTableRequest request = new DescribeTableRequest().withTableName(tableName);
        DescribeTableResult result = ddb.describeTable(request);
        return (result != null && "ACTIVE".equals(result.getTable().getTableStatus()));
    } catch (ResourceNotFoundException e) {
        return false;
    }
}
 

protected boolean doesTableExist(String tableName) {
    try {
        DescribeTableRequest request = new DescribeTableRequest().withTableName(tableName);
        DescribeTableResult result = ddb.describeTable(request);
        return (result != null && "ACTIVE".equals(result.getTable().getTableStatus()));
    } catch (ResourceNotFoundException e) {
        return false;
    }
}
 

@Test
public void getNoSqlTableResourceNotFound() {
    when(dynamoDb.deleteTable(argThat((ArgumentMatcher<String>) argument -> true))).thenThrow(new ResourceNotFoundException("not found"));
    NoSqlTableDeleteResponse result = underTest.deleteNoSqlTable(new NoSqlTableDeleteRequest());
    assertNull(result.getId());
    assertNull(result.getTableStatus());
    assertEquals(ResponseStatus.RESOURCE_NOT_FOUND, result.getStatus());
}
 

@Test
public void getNoSqlTableMetaDataResourceNotFound() {
    when(dynamoDb.describeTable(argThat((ArgumentMatcher<String>) argument -> true))).thenThrow(new ResourceNotFoundException("not found"));
    NoSqlTableMetadataResponse result = underTest.getNoSqlTableMetaData(new NoSqlTableMetadataRequest());
    assertNull(result.getId());
    assertNull(result.getTableStatus());
    assertEquals(ResponseStatus.RESOURCE_NOT_FOUND, result.getStatus());
}
 

@Test
public void testTableDoesNotExist() {
    EasyMock.expect(dynamoDB.describeTable(tableName)).andThrow(new ResourceNotFoundException(""));
    PowerMock.replayAll();
    assertFalse(DynamoDBManager.doesTableExist(dynamoDB, tableName));
    PowerMock.verifyAll();
}
 

@Test
public void testCreateTableTableDoesNotExist() {
    final Collection<AttributeDefinition> ads = Arrays.asList(new AttributeDefinition("Hash", ScalarAttributeType.S));
    final Collection<KeySchemaElement> kses = Arrays.asList(new KeySchemaElement("Hash", KeyType.HASH));
    final TableDescription description = new TableDescription().withAttributeDefinitions(ads).withKeySchema(kses)
        .withTableName(tableName);
    final CreateTableResult cTR = new CreateTableResult().withTableDescription(description);
    EasyMock.expect(dynamoDB.describeTable(tableName)).andThrow(new ResourceNotFoundException(null));
    final CreateTableRequest request = new CreateTableRequest().withAttributeDefinitions(ads).withKeySchema(kses)
        .withTableName(tableName);
    EasyMock.expect(dynamoDB.createTable(request)).andReturn(cTR);
    PowerMock.replayAll();
    assertEquals(description, DynamoDBManager.createTable(dynamoDB, request));
    PowerMock.verifyAll();
}
 

/**
 * Creates DynamoDB table. If the table already exists, it validates the key schema. If the key schemas match, a
 * warning is logged, otherwise an exception is raised.
 *
 * @param dynamoDB
 *            {@link AmazonDynamoDB} used to create the table specified in the request.
 * @param request
 *            Request for creating a table.
 * @return TableDescription of the existing table or newly created table
 */
public static TableDescription createTable(final AmazonDynamoDB dynamoDB, final CreateTableRequest request) {
    try {
        final DescribeTableResult result = dynamoDB.describeTable(request.getTableName());
        if (!request.getKeySchema().equals(result.getTable().getKeySchema())) {
            throw new IllegalStateException("Table " + request.getTableName()
                + " already exists and has an invalid schema");
        }
        LOGGER.warning("Table " + request.getTableName() + " already exists");
        return result.getTable();
    } catch (final ResourceNotFoundException e) {
        return dynamoDB.createTable(request).getTableDescription();
    }
}
 

private boolean tableExists(String tableName) {
  try {
    dynamoDBClient.describeTable(tableName);
    return true;
  } catch (ResourceNotFoundException e) {
    if (LOG.isDebugEnabled()) {
      LOG.debug("Table '{}' did not exist.", tableName, e);
    }
    return false;
  }
}
 

private boolean leaseTableExists() {
  DescribeTableRequest request = new DescribeTableRequest();
  request.setTableName(conf.applicationName);
  DescribeTableResult result;
  try {
    result = dynamoDBClient.describeTable(request);
  } catch (ResourceNotFoundException e) {
    LOG.debug("Lease table '{}' does not exist", conf.applicationName);
    return false;
  }

  TableStatus tableStatus = TableStatus.fromValue(result.getTable().getTableStatus());
  LOG.debug("Lease table exists and is in '{}' state", tableStatus);
  return tableStatus == TableStatus.ACTIVE;
}
 

private BackendException processDynamoDbApiException(final Throwable e, final String apiName, final String tableName) {
    Preconditions.checkArgument(apiName != null);
    Preconditions.checkArgument(!apiName.isEmpty());
    final String prefix;
    if (tableName == null) {
        prefix = apiName;
    } else {
        prefix = String.format("%s_%s", apiName, tableName);
    }
    final String message = String.format("%s %s", prefix, e.getMessage());
    if (e instanceof ResourceNotFoundException) {
        return new BackendNotFoundException(String.format("%s; table not found", message), e);
    } else if (e instanceof ConditionalCheckFailedException) {
        return new PermanentLockingException(message, e);
    } else if (e instanceof AmazonServiceException) {
        if (e.getMessage() != null
            && (e.getMessage().contains(HASH_RANGE_KEY_SIZE_LIMIT) || e.getMessage().contains(UPDATE_ITEM_SIZE_LIMIT))) {
            return new PermanentBackendException(message, e);
        } else {
            return new TemporaryBackendException(message, e);
        }
    } else if (e instanceof AmazonClientException) { //all client exceptions are retriable by default
        return new TemporaryBackendException(message, e);
    } else if (e instanceof SocketException) { //sometimes this doesn't get caught by SDK
        return new TemporaryBackendException(message, e);
    }
    // unknown exception type
    return new PermanentBackendException(message, e);
}
 

@Test
public void testDeleteTableWithWait() throws Exception {
    // Create fake responses from AWS.
    TableDescription deletingDescription = constructTableDescription(TableStatus.DELETING);
    DescribeTableResult mockDescribeResult = new DescribeTableResult().withTable(deletingDescription);

    // Delete the table. First response the table is still deleting, the second response the table has deleted
    // and the ResourceNotFoundException is thrown.
    when(mockDynamoDBClient.describeTable(tableName)).thenReturn(mockDescribeResult).thenThrow(
            new ResourceNotFoundException("Table not found"));
    dynamoDB.delete();

    verify(mockDynamoDBClient, times(1)).deleteTable(tableName);
    verify(mockDynamoDBClient, times(2)).describeTable(tableName);
}
 

private static void cleanUpDynamoDBTables(Regions testRegion, String testResourcePrefix, Date createdBeforeThreshold,
                                          AWSCredentialsProvider awsCredentials) {
    LOG.info("Cleaning DynamoDB...");
    AmazonDynamoDB dynamoDBClient = AmazonDynamoDBClientBuilder.standard()
            .withCredentials(awsCredentials)
            .withRegion(testRegion)
            .build();

    List<String> tableNames = dynamoDBClient.listTables().getTableNames();
    for (String tableName: tableNames) {
        if (!tableName.startsWith(testResourcePrefix)) {
            continue;
        }
        LOG.info(String.format("Checking if table %s needs cleaning...", tableName));

        try {
            TableDescription desc = dynamoDBClient.describeTable(tableName).getTable();
            if (!desc.getTableName().equals(TableStatus.DELETING.toString()) &&
                    desc.getCreationDateTime() != null &&
                    desc.getCreationDateTime().before(createdBeforeThreshold)) {
                LOG.info("Cleaning up table: " + tableName);
                dynamoDBClient.deleteTable(tableName);
            }
        } catch (ResourceNotFoundException e) {
            LOG.info("Looks like table was already cleaned up: " + tableName);
        }
    }
}
 

public static boolean groupExists(SecretsGroupManager secretsGroupManager, SecretsGroupIdentifier identifier) {
    try {
        secretsGroupManager.info(identifier);
        return true;
    } catch (NoSuchElementException | ResourceNotFoundException | NoSuchEntityException e) {
        return false;
    }
}
 

private Store getCurrentStore(SecretsGroupIdentifier group, ReadWriteLock readWriteLock) {
    if (userConfig.getLocalFilePath(group).isPresent()) {
        // TODO: load encryptor once
        final KMSEncryptor kmsEncryptor = getEncryptor(group);
        return new File(userConfig.getLocalFilePath(group).get(), kmsEncryptor, new FileEncryptionContext(group), readWriteLock);
    }
    try {
        DynamoDB dynamoDB = DynamoDB.fromCredentials(awsCredentials, clientConfiguration, group, readWriteLock);
        return dynamoDB;
    } catch (ResourceNotFoundException e) {
        throw new DoesNotExistException("No storage backend found!", e);
    }
}
 

private Optional<TableDescription> describeTable() {
    try {
        DescribeTableResult result = client.describeTable(tableName);
        return Optional.of(result.getTable());
    } catch (ResourceNotFoundException e) {
        return Optional.empty();
    }

}
 

@Test(expected = IllegalStateException.class)
public void testWaitForTableToBecomeActiveTableDoesNotExist() {
    EasyMock.expect(dynamoDB.describeTable(tableName)).andThrow(new ResourceNotFoundException(null));
    PowerMock.replayAll();
    DynamoDBManager.waitForTableToBecomeActive(dynamoDB, tableName);
}
 

@Override
protected List<KeySchemaElement> getTableSchema(String tableName) throws ResourceNotFoundException {
    return keySchema;
}