HADOOP-15636. Follow-up from HADOOP-14918; restoring test under new name. Contributed by Gabor Bota.
This commit is contained in:
Sean Mackrory
parent
ed9d60e888
commit
59adeb8d7f
|
|
@ -0,0 +1,649 @@
|
|||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.apache.hadoop.fs.s3a.s3guard;
|
||||
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
import java.net.URI;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
|
||||
import com.amazonaws.services.dynamodbv2.document.Item;
|
||||
import com.amazonaws.services.dynamodbv2.document.PrimaryKey;
|
||||
import com.amazonaws.services.dynamodbv2.document.Table;
|
||||
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughputDescription;
|
||||
import com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException;
|
||||
import com.amazonaws.services.dynamodbv2.model.TableDescription;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import org.apache.commons.collections.CollectionUtils;
|
||||
import org.apache.hadoop.fs.contract.s3a.S3AContract;
|
||||
import org.apache.hadoop.fs.s3a.Constants;
|
||||
import org.apache.hadoop.fs.s3a.Tristate;
|
||||
|
||||
import org.apache.hadoop.io.IOUtils;
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.Assume;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import org.apache.hadoop.conf.Configuration;
|
||||
import org.apache.hadoop.fs.FileStatus;
|
||||
import org.apache.hadoop.fs.Path;
|
||||
import org.apache.hadoop.fs.s3a.S3AFileStatus;
|
||||
import org.apache.hadoop.fs.s3a.S3AFileSystem;
|
||||
import org.apache.hadoop.security.UserGroupInformation;
|
||||
|
||||
import static org.apache.hadoop.fs.s3a.Constants.*;
|
||||
import static org.apache.hadoop.fs.s3a.S3ATestUtils.*;
|
||||
import static org.apache.hadoop.fs.s3a.s3guard.PathMetadataDynamoDBTranslation.*;
|
||||
import static org.apache.hadoop.fs.s3a.s3guard.DynamoDBMetadataStore.*;
|
||||
import static org.apache.hadoop.test.LambdaTestUtils.*;
|
||||
|
||||
/**
|
||||
* Test that {@link DynamoDBMetadataStore} implements {@link MetadataStore}.
|
||||
*
|
||||
* In this integration test, we use a real AWS DynamoDB. A
|
||||
* {@link DynamoDBMetadataStore} object is created in the @BeforeClass method,
|
||||
* and shared for all test in the @BeforeClass method. You will be charged
|
||||
* bills for AWS S3 or DynamoDB when you run these tests.
|
||||
*
|
||||
* According to the base class, every test case will have independent contract
|
||||
* to create a new {@link S3AFileSystem} instance and initializes it.
|
||||
* A table will be created and shared between the tests,
|
||||
*/
|
||||
public class ITestDynamoDBMetadataStore extends MetadataStoreTestBase {
|
||||
private static final Logger LOG =
|
||||
LoggerFactory.getLogger(ITestDynamoDBMetadataStore.class);
|
||||
public static final PrimaryKey
|
||||
VERSION_MARKER_PRIMARY_KEY = createVersionMarkerPrimaryKey(
|
||||
DynamoDBMetadataStore.VERSION_MARKER);
|
||||
|
||||
private S3AFileSystem fileSystem;
|
||||
private S3AContract s3AContract;
|
||||
|
||||
private URI fsUri;
|
||||
|
||||
private String bucket;
|
||||
|
||||
private static DynamoDBMetadataStore ddbmsStatic;
|
||||
|
||||
private static String TEST_DYNAMODB_TABLE_NAME;
|
||||
|
||||
/**
|
||||
* Create a path under the test path provided by
|
||||
* the FS contract.
|
||||
* @param filepath path string in
|
||||
* @return a path qualified by the test filesystem
|
||||
*/
|
||||
protected Path path(String filepath) {
|
||||
return getFileSystem().makeQualified(
|
||||
new Path(s3AContract.getTestPath(), filepath));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setUp() throws Exception {
|
||||
Configuration conf = prepareTestConfiguration(new Configuration());
|
||||
assertThatDynamoMetadataStoreImpl(conf);
|
||||
Assume.assumeTrue("Test DynamoDB table name should be set to run "
|
||||
+ "integration tests.", TEST_DYNAMODB_TABLE_NAME != null);
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, TEST_DYNAMODB_TABLE_NAME);
|
||||
|
||||
s3AContract = new S3AContract(conf);
|
||||
s3AContract.init();
|
||||
|
||||
fileSystem = (S3AFileSystem) s3AContract.getTestFileSystem();
|
||||
assume("No test filesystem", s3AContract.isEnabled());
|
||||
assertNotNull("No test filesystem", fileSystem);
|
||||
fsUri = fileSystem.getUri();
|
||||
bucket = fileSystem.getBucket();
|
||||
|
||||
try{
|
||||
super.setUp();
|
||||
} catch (FileNotFoundException e){
|
||||
LOG.warn("MetadataStoreTestBase setup failed. Waiting for table to be "
|
||||
+ "deleted before trying again.");
|
||||
ddbmsStatic.getTable().waitForDelete();
|
||||
super.setUp();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClassSetup() throws IOException {
|
||||
Configuration conf = prepareTestConfiguration(new Configuration());
|
||||
assertThatDynamoMetadataStoreImpl(conf);
|
||||
TEST_DYNAMODB_TABLE_NAME = conf.get(S3GUARD_DDB_TEST_TABLE_NAME_KEY);
|
||||
Assume.assumeTrue("Test DynamoDB table name should be set to run "
|
||||
+ "integration tests.", TEST_DYNAMODB_TABLE_NAME != null);
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, TEST_DYNAMODB_TABLE_NAME);
|
||||
|
||||
LOG.debug("Creating static ddbms which will be shared between tests.");
|
||||
ddbmsStatic = new DynamoDBMetadataStore();
|
||||
ddbmsStatic.initialize(conf);
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void afterClassTeardown() {
|
||||
LOG.debug("Destroying static DynamoDBMetadataStore.");
|
||||
if (ddbmsStatic != null) {
|
||||
try {
|
||||
ddbmsStatic.destroy();
|
||||
} catch (Exception e) {
|
||||
LOG.warn("Failed to destroy tables in teardown", e);
|
||||
}
|
||||
IOUtils.closeStream(ddbmsStatic);
|
||||
ddbmsStatic = null;
|
||||
}
|
||||
}
|
||||
|
||||
private static void assertThatDynamoMetadataStoreImpl(Configuration conf){
|
||||
Assume.assumeTrue("Test only applies when DynamoDB is used for S3Guard",
|
||||
conf.get(Constants.S3_METADATA_STORE_IMPL).equals(
|
||||
Constants.S3GUARD_METASTORE_DYNAMO));
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void tearDown() throws Exception {
|
||||
LOG.info("Removing data from ddbms table in teardown.");
|
||||
// The following is a way to be sure the table will be cleared and there
|
||||
// will be no leftovers after the test.
|
||||
PathMetadata meta = ddbmsStatic.get(strToPath("/"));
|
||||
if (meta != null){
|
||||
for (DescendantsIterator desc = new DescendantsIterator(ddbmsStatic, meta);
|
||||
desc.hasNext();) {
|
||||
ddbmsStatic.forgetMetadata(desc.next().getPath());
|
||||
}
|
||||
}
|
||||
|
||||
fileSystem.close();
|
||||
}
|
||||
|
||||
/**
|
||||
* Each contract has its own S3AFileSystem and DynamoDBMetadataStore objects.
|
||||
*/
|
||||
private class DynamoDBMSContract extends AbstractMSContract {
|
||||
|
||||
DynamoDBMSContract(Configuration conf) {
|
||||
}
|
||||
|
||||
DynamoDBMSContract() {
|
||||
this(new Configuration());
|
||||
}
|
||||
|
||||
@Override
|
||||
public S3AFileSystem getFileSystem() {
|
||||
return ITestDynamoDBMetadataStore.this.fileSystem;
|
||||
}
|
||||
|
||||
@Override
|
||||
public DynamoDBMetadataStore getMetadataStore() {
|
||||
return ITestDynamoDBMetadataStore.ddbmsStatic;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public DynamoDBMSContract createContract() {
|
||||
return new DynamoDBMSContract();
|
||||
}
|
||||
|
||||
@Override
|
||||
public DynamoDBMSContract createContract(Configuration conf) {
|
||||
return new DynamoDBMSContract(conf);
|
||||
}
|
||||
|
||||
@Override
|
||||
FileStatus basicFileStatus(Path path, int size, boolean isDir)
|
||||
throws IOException {
|
||||
String owner = UserGroupInformation.getCurrentUser().getShortUserName();
|
||||
return isDir
|
||||
? new S3AFileStatus(true, path, owner)
|
||||
: new S3AFileStatus(size, getModTime(), path, BLOCK_SIZE, owner);
|
||||
}
|
||||
|
||||
private DynamoDBMetadataStore getDynamoMetadataStore() throws IOException {
|
||||
return (DynamoDBMetadataStore) getContract().getMetadataStore();
|
||||
}
|
||||
|
||||
private S3AFileSystem getFileSystem() {
|
||||
return this.fileSystem;
|
||||
}
|
||||
|
||||
/**
|
||||
* This tests that after initialize() using an S3AFileSystem object, the
|
||||
* instance should have been initialized successfully, and tables are ACTIVE.
|
||||
*/
|
||||
@Test
|
||||
public void testInitialize() throws IOException {
|
||||
final S3AFileSystem s3afs = this.fileSystem;
|
||||
final String tableName = "testInitialize";
|
||||
final Configuration conf = s3afs.getConf();
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, tableName);
|
||||
try (DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(s3afs);
|
||||
verifyTableInitialized(tableName, ddbms.getDynamoDB());
|
||||
assertNotNull(ddbms.getTable());
|
||||
assertEquals(tableName, ddbms.getTable().getTableName());
|
||||
String expectedRegion = conf.get(S3GUARD_DDB_REGION_KEY,
|
||||
s3afs.getBucketLocation(bucket));
|
||||
assertEquals("DynamoDB table should be in configured region or the same" +
|
||||
" region as S3 bucket",
|
||||
expectedRegion,
|
||||
ddbms.getRegion());
|
||||
ddbms.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This tests that after initialize() using a Configuration object, the
|
||||
* instance should have been initialized successfully, and tables are ACTIVE.
|
||||
*/
|
||||
@Test
|
||||
public void testInitializeWithConfiguration() throws IOException {
|
||||
final String tableName = "testInitializeWithConfiguration";
|
||||
final Configuration conf = getFileSystem().getConf();
|
||||
conf.unset(S3GUARD_DDB_TABLE_NAME_KEY);
|
||||
String savedRegion = conf.get(S3GUARD_DDB_REGION_KEY,
|
||||
getFileSystem().getBucketLocation());
|
||||
conf.unset(S3GUARD_DDB_REGION_KEY);
|
||||
try (DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(conf);
|
||||
fail("Should have failed because the table name is not set!");
|
||||
} catch (IllegalArgumentException ignored) {
|
||||
}
|
||||
// config table name
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, tableName);
|
||||
try (DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(conf);
|
||||
fail("Should have failed because as the region is not set!");
|
||||
} catch (IllegalArgumentException ignored) {
|
||||
}
|
||||
// config region
|
||||
conf.set(S3GUARD_DDB_REGION_KEY, savedRegion);
|
||||
try (DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(conf);
|
||||
verifyTableInitialized(tableName, ddbms.getDynamoDB());
|
||||
assertNotNull(ddbms.getTable());
|
||||
assertEquals(tableName, ddbms.getTable().getTableName());
|
||||
assertEquals("Unexpected key schema found!",
|
||||
keySchema(),
|
||||
ddbms.getTable().describe().getKeySchema());
|
||||
ddbms.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test that for a large batch write request, the limit is handled correctly.
|
||||
*/
|
||||
@Test
|
||||
public void testBatchWrite() throws IOException {
|
||||
final int[] numMetasToDeleteOrPut = {
|
||||
-1, // null
|
||||
0, // empty collection
|
||||
1, // one path
|
||||
S3GUARD_DDB_BATCH_WRITE_REQUEST_LIMIT, // exact limit of a batch request
|
||||
S3GUARD_DDB_BATCH_WRITE_REQUEST_LIMIT + 1 // limit + 1
|
||||
};
|
||||
DynamoDBMetadataStore ms = getDynamoMetadataStore();
|
||||
for (int numOldMetas : numMetasToDeleteOrPut) {
|
||||
for (int numNewMetas : numMetasToDeleteOrPut) {
|
||||
doTestBatchWrite(numOldMetas, numNewMetas, ms);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void doTestBatchWrite(int numDelete, int numPut,
|
||||
DynamoDBMetadataStore ms) throws IOException {
|
||||
Path path = new Path(
|
||||
"/ITestDynamoDBMetadataStore_testBatchWrite_" + numDelete + '_'
|
||||
+ numPut);
|
||||
final Path root = fileSystem.makeQualified(path);
|
||||
final Path oldDir = new Path(root, "oldDir");
|
||||
final Path newDir = new Path(root, "newDir");
|
||||
LOG.info("doTestBatchWrite: oldDir={}, newDir={}", oldDir, newDir);
|
||||
|
||||
ms.put(new PathMetadata(basicFileStatus(oldDir, 0, true)));
|
||||
ms.put(new PathMetadata(basicFileStatus(newDir, 0, true)));
|
||||
|
||||
final List<PathMetadata> oldMetas = numDelete < 0 ? null :
|
||||
new ArrayList<>(numDelete);
|
||||
for (int i = 0; i < numDelete; i++) {
|
||||
oldMetas.add(new PathMetadata(
|
||||
basicFileStatus(new Path(oldDir, "child" + i), i, true)));
|
||||
}
|
||||
final List<PathMetadata> newMetas = numPut < 0 ? null :
|
||||
new ArrayList<>(numPut);
|
||||
for (int i = 0; i < numPut; i++) {
|
||||
newMetas.add(new PathMetadata(
|
||||
basicFileStatus(new Path(newDir, "child" + i), i, false)));
|
||||
}
|
||||
|
||||
Collection<Path> pathsToDelete = null;
|
||||
if (oldMetas != null) {
|
||||
// put all metadata of old paths and verify
|
||||
ms.put(new DirListingMetadata(oldDir, oldMetas, false));
|
||||
assertEquals(0, ms.listChildren(newDir).withoutTombstones().numEntries());
|
||||
assertTrue(CollectionUtils
|
||||
.isEqualCollection(oldMetas, ms.listChildren(oldDir).getListing()));
|
||||
|
||||
pathsToDelete = new ArrayList<>(oldMetas.size());
|
||||
for (PathMetadata meta : oldMetas) {
|
||||
pathsToDelete.add(meta.getFileStatus().getPath());
|
||||
}
|
||||
}
|
||||
|
||||
// move the old paths to new paths and verify
|
||||
ms.move(pathsToDelete, newMetas);
|
||||
assertEquals(0, ms.listChildren(oldDir).withoutTombstones().numEntries());
|
||||
if (newMetas != null) {
|
||||
assertTrue(CollectionUtils
|
||||
.isEqualCollection(newMetas, ms.listChildren(newDir).getListing()));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInitExistingTable() throws IOException {
|
||||
final DynamoDBMetadataStore ddbms = getDynamoMetadataStore();
|
||||
final String tableName = ddbms.getTable().getTableName();
|
||||
verifyTableInitialized(tableName, ddbms.getDynamoDB());
|
||||
// create existing table
|
||||
ddbms.initTable();
|
||||
verifyTableInitialized(tableName, ddbms.getDynamoDB());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the low level version check code.
|
||||
*/
|
||||
@Test
|
||||
public void testItemVersionCompatibility() throws Throwable {
|
||||
verifyVersionCompatibility("table",
|
||||
createVersionMarker(VERSION_MARKER, VERSION, 0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test that a version marker entry without the version number field
|
||||
* is rejected as incompatible with a meaningful error message.
|
||||
*/
|
||||
@Test
|
||||
public void testItemLacksVersion() throws Throwable {
|
||||
intercept(IOException.class, E_NOT_VERSION_MARKER,
|
||||
() -> verifyVersionCompatibility("table",
|
||||
new Item().withPrimaryKey(
|
||||
createVersionMarkerPrimaryKey(VERSION_MARKER))));
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete the version marker and verify that table init fails.
|
||||
*/
|
||||
@Test
|
||||
public void testTableVersionRequired() throws Exception {
|
||||
String tableName = "testTableVersionRequired";
|
||||
Configuration conf = getFileSystem().getConf();
|
||||
int maxRetries = conf.getInt(S3GUARD_DDB_MAX_RETRIES,
|
||||
S3GUARD_DDB_MAX_RETRIES_DEFAULT);
|
||||
conf.setInt(S3GUARD_DDB_MAX_RETRIES, 3);
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, tableName);
|
||||
|
||||
try(DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(conf);
|
||||
Table table = verifyTableInitialized(tableName, ddbms.getDynamoDB());
|
||||
table.deleteItem(VERSION_MARKER_PRIMARY_KEY);
|
||||
|
||||
// create existing table
|
||||
intercept(IOException.class, E_NO_VERSION_MARKER,
|
||||
() -> ddbms.initTable());
|
||||
|
||||
conf.setInt(S3GUARD_DDB_MAX_RETRIES, maxRetries);
|
||||
ddbms.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the version value to a different number and verify that
|
||||
* table init fails.
|
||||
*/
|
||||
@Test
|
||||
public void testTableVersionMismatch() throws Exception {
|
||||
String tableName = "testTableVersionMismatch";
|
||||
Configuration conf = getFileSystem().getConf();
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, tableName);
|
||||
|
||||
try(DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(conf);
|
||||
Table table = verifyTableInitialized(tableName, ddbms.getDynamoDB());
|
||||
table.deleteItem(VERSION_MARKER_PRIMARY_KEY);
|
||||
Item v200 = createVersionMarker(VERSION_MARKER, 200, 0);
|
||||
table.putItem(v200);
|
||||
|
||||
// create existing table
|
||||
intercept(IOException.class, E_INCOMPATIBLE_VERSION,
|
||||
() -> ddbms.initTable());
|
||||
ddbms.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Test that initTable fails with IOException when table does not exist and
|
||||
* table auto-creation is disabled.
|
||||
*/
|
||||
@Test
|
||||
public void testFailNonexistentTable() throws IOException {
|
||||
final String tableName = "testFailNonexistentTable";
|
||||
final S3AFileSystem s3afs = getFileSystem();
|
||||
final Configuration conf = s3afs.getConf();
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, tableName);
|
||||
conf.unset(S3GUARD_DDB_TABLE_CREATE_KEY);
|
||||
try (DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(s3afs);
|
||||
fail("Should have failed as table does not exist and table auto-creation"
|
||||
+ " is disabled");
|
||||
} catch (IOException ignored) {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test cases about root directory as it is not in the DynamoDB table.
|
||||
*/
|
||||
@Test
|
||||
public void testRootDirectory() throws IOException {
|
||||
final DynamoDBMetadataStore ddbms = getDynamoMetadataStore();
|
||||
Path rootPath = new Path(new Path(fsUri), "/");
|
||||
verifyRootDirectory(ddbms.get(rootPath), true);
|
||||
|
||||
ddbms.put(new PathMetadata(new S3AFileStatus(true,
|
||||
new Path(rootPath, "foo"),
|
||||
UserGroupInformation.getCurrentUser().getShortUserName())));
|
||||
verifyRootDirectory(ddbms.get(rootPath), false);
|
||||
}
|
||||
|
||||
private void verifyRootDirectory(PathMetadata rootMeta, boolean isEmpty) {
|
||||
assertNotNull(rootMeta);
|
||||
final FileStatus status = rootMeta.getFileStatus();
|
||||
assertNotNull(status);
|
||||
assertTrue(status.isDirectory());
|
||||
// UNKNOWN is always a valid option, but true / false should not contradict
|
||||
if (isEmpty) {
|
||||
assertNotSame("Should not be marked non-empty",
|
||||
Tristate.FALSE,
|
||||
rootMeta.isEmptyDirectory());
|
||||
} else {
|
||||
assertNotSame("Should not be marked empty",
|
||||
Tristate.TRUE,
|
||||
rootMeta.isEmptyDirectory());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test that when moving nested paths, all its ancestors up to destination
|
||||
* root will also be created.
|
||||
* Here is the directory tree before move:
|
||||
* <pre>
|
||||
* testMovePopulateAncestors
|
||||
* ├── a
|
||||
* │ └── b
|
||||
* │ └── src
|
||||
* │ ├── dir1
|
||||
* │ │ └── dir2
|
||||
* │ └── file1.txt
|
||||
* └── c
|
||||
* └── d
|
||||
* └── dest
|
||||
*</pre>
|
||||
* As part of rename(a/b/src, d/c/dest), S3A will enumerate the subtree at
|
||||
* a/b/src. This test verifies that after the move, the new subtree at
|
||||
* 'dest' is reachable from the root (i.e. c/ and c/d exist in the table.
|
||||
* DynamoDBMetadataStore depends on this property to do recursive delete
|
||||
* without a full table scan.
|
||||
*/
|
||||
@Test
|
||||
public void testMovePopulatesAncestors() throws IOException {
|
||||
final DynamoDBMetadataStore ddbms = getDynamoMetadataStore();
|
||||
final String testRoot = "/testMovePopulatesAncestors";
|
||||
final String srcRoot = testRoot + "/a/b/src";
|
||||
final String destRoot = testRoot + "/c/d/e/dest";
|
||||
|
||||
final Path nestedPath1 = strToPath(srcRoot + "/file1.txt");
|
||||
ddbms.put(new PathMetadata(basicFileStatus(nestedPath1, 1024, false)));
|
||||
final Path nestedPath2 = strToPath(srcRoot + "/dir1/dir2");
|
||||
ddbms.put(new PathMetadata(basicFileStatus(nestedPath2, 0, true)));
|
||||
|
||||
// We don't put the destRoot path here, since put() would create ancestor
|
||||
// entries, and we want to ensure that move() does it, instead.
|
||||
|
||||
// Build enumeration of src / dest paths and do the move()
|
||||
final Collection<Path> fullSourcePaths = Lists.newArrayList(
|
||||
strToPath(srcRoot),
|
||||
strToPath(srcRoot + "/dir1"),
|
||||
strToPath(srcRoot + "/dir1/dir2"),
|
||||
strToPath(srcRoot + "/file1.txt")
|
||||
);
|
||||
final Collection<PathMetadata> pathsToCreate = Lists.newArrayList(
|
||||
new PathMetadata(basicFileStatus(strToPath(destRoot),
|
||||
0, true)),
|
||||
new PathMetadata(basicFileStatus(strToPath(destRoot + "/dir1"),
|
||||
0, true)),
|
||||
new PathMetadata(basicFileStatus(strToPath(destRoot + "/dir1/dir2"),
|
||||
0, true)),
|
||||
new PathMetadata(basicFileStatus(strToPath(destRoot + "/file1.txt"),
|
||||
1024, false))
|
||||
);
|
||||
|
||||
ddbms.move(fullSourcePaths, pathsToCreate);
|
||||
|
||||
// assert that all the ancestors should have been populated automatically
|
||||
assertCached(testRoot + "/c");
|
||||
assertCached(testRoot + "/c/d");
|
||||
assertCached(testRoot + "/c/d/e");
|
||||
assertCached(destRoot /* /c/d/e/dest */);
|
||||
|
||||
// Also check moved files while we're at it
|
||||
assertCached(destRoot + "/dir1");
|
||||
assertCached(destRoot + "/dir1/dir2");
|
||||
assertCached(destRoot + "/file1.txt");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testProvisionTable() throws IOException {
|
||||
final String tableName = "testProvisionTable";
|
||||
Configuration conf = getFileSystem().getConf();
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, tableName);
|
||||
|
||||
try(DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(conf);
|
||||
DynamoDB dynamoDB = ddbms.getDynamoDB();
|
||||
final ProvisionedThroughputDescription oldProvision =
|
||||
dynamoDB.getTable(tableName).describe().getProvisionedThroughput();
|
||||
ddbms.provisionTable(oldProvision.getReadCapacityUnits() * 2,
|
||||
oldProvision.getWriteCapacityUnits() * 2);
|
||||
ddbms.initTable();
|
||||
final ProvisionedThroughputDescription newProvision =
|
||||
dynamoDB.getTable(tableName).describe().getProvisionedThroughput();
|
||||
LOG.info("Old provision = {}, new provision = {}", oldProvision,
|
||||
newProvision);
|
||||
assertEquals(oldProvision.getReadCapacityUnits() * 2,
|
||||
newProvision.getReadCapacityUnits().longValue());
|
||||
assertEquals(oldProvision.getWriteCapacityUnits() * 2,
|
||||
newProvision.getWriteCapacityUnits().longValue());
|
||||
ddbms.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDeleteTable() throws Exception {
|
||||
final String tableName = "testDeleteTable";
|
||||
Path testPath = new Path(new Path(fsUri), "/" + tableName);
|
||||
final S3AFileSystem s3afs = getFileSystem();
|
||||
final Configuration conf = s3afs.getConf();
|
||||
conf.set(S3GUARD_DDB_TABLE_NAME_KEY, tableName);
|
||||
try (DynamoDBMetadataStore ddbms = new DynamoDBMetadataStore()) {
|
||||
ddbms.initialize(s3afs);
|
||||
// we can list the empty table
|
||||
ddbms.listChildren(testPath);
|
||||
DynamoDB dynamoDB = ddbms.getDynamoDB();
|
||||
ddbms.destroy();
|
||||
verifyTableNotExist(tableName, dynamoDB);
|
||||
|
||||
// delete table once more; be ResourceNotFoundException swallowed silently
|
||||
ddbms.destroy();
|
||||
verifyTableNotExist(tableName, dynamoDB);
|
||||
try {
|
||||
// we can no longer list the destroyed table
|
||||
ddbms.listChildren(testPath);
|
||||
fail("Should have failed after the table is destroyed!");
|
||||
} catch (IOException ignored) {
|
||||
}
|
||||
ddbms.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This validates the table is created and ACTIVE in DynamoDB.
|
||||
*
|
||||
* This should not rely on the {@link DynamoDBMetadataStore} implementation.
|
||||
* Return the table
|
||||
*/
|
||||
private Table verifyTableInitialized(String tableName, DynamoDB dynamoDB) {
|
||||
final Table table = dynamoDB.getTable(tableName);
|
||||
final TableDescription td = table.describe();
|
||||
assertEquals(tableName, td.getTableName());
|
||||
assertEquals("ACTIVE", td.getTableStatus());
|
||||
return table;
|
||||
}
|
||||
|
||||
/**
|
||||
* This validates the table is not found in DynamoDB.
|
||||
*
|
||||
* This should not rely on the {@link DynamoDBMetadataStore} implementation.
|
||||
*/
|
||||
private void verifyTableNotExist(String tableName, DynamoDB dynamoDB) throws
|
||||
Exception{
|
||||
intercept(ResourceNotFoundException.class,
|
||||
() -> dynamoDB.getTable(tableName).describe());
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue