/// <summary>Test listing snapshots under a snapshottable directory</summary>
/// <exception cref="System.Exception"/>
public virtual void TestListSnapshots()
{
Path snapshotsPath = new Path(dir, ".snapshot");
FileStatus[] stats = null;
// special case: snapshots of root
stats = hdfs.ListStatus(new Path("/.snapshot"));
// should be 0 since root's snapshot quota is 0
NUnit.Framework.Assert.AreEqual(0, stats.Length);
// list before set dir as snapshottable
try
{
stats = hdfs.ListStatus(snapshotsPath);
NUnit.Framework.Assert.Fail("expect SnapshotException");
}
catch (IOException e)
{
GenericTestUtils.AssertExceptionContains("Directory is not a snapshottable directory: "
+ dir.ToString(), e);
}
// list before creating snapshots
hdfs.AllowSnapshot(dir);
stats = hdfs.ListStatus(snapshotsPath);
NUnit.Framework.Assert.AreEqual(0, stats.Length);
// list while creating snapshots
int snapshotNum = 5;
for (int sNum = 0; sNum < snapshotNum; sNum++)
{
hdfs.CreateSnapshot(dir, "s_" + sNum);
stats = hdfs.ListStatus(snapshotsPath);
NUnit.Framework.Assert.AreEqual(sNum + 1, stats.Length);
for (int i = 0; i <= sNum; i++)
{
NUnit.Framework.Assert.AreEqual("s_" + i, stats[i].GetPath().GetName());
}
}
// list while deleting snapshots
for (int sNum_1 = snapshotNum - 1; sNum_1 > 0; sNum_1--)
{
hdfs.DeleteSnapshot(dir, "s_" + sNum_1);
stats = hdfs.ListStatus(snapshotsPath);
NUnit.Framework.Assert.AreEqual(sNum_1, stats.Length);
for (int i = 0; i < sNum_1; i++)
{
NUnit.Framework.Assert.AreEqual("s_" + i, stats[i].GetPath().GetName());
}
}
// remove the last snapshot
hdfs.DeleteSnapshot(dir, "s_0");
stats = hdfs.ListStatus(snapshotsPath);
NUnit.Framework.Assert.AreEqual(0, stats.Length);
}
public virtual void TestDiffReportWithRenameAndSnapshotDeletion()
{
Path root = new Path("/");
Path foo = new Path(root, "foo");
Path bar = new Path(foo, "bar");
DFSTestUtil.CreateFile(hdfs, bar, Blocksize, Replication, seed);
SnapshotTestHelper.CreateSnapshot(hdfs, root, "s0");
// rename /foo to /foo2
Path foo2 = new Path(root, "foo2");
hdfs.Rename(foo, foo2);
// now /foo/bar becomes /foo2/bar
Path bar2 = new Path(foo2, "bar");
// delete snapshot s0 so that the withNameList inside of the WithCount node
// of foo becomes empty
hdfs.DeleteSnapshot(root, "s0");
// create snapshot s1 and rename bar again
SnapshotTestHelper.CreateSnapshot(hdfs, root, "s1");
Path bar3 = new Path(foo2, "bar-new");
hdfs.Rename(bar2, bar3);
// we always put modification on the file before rename
VerifyDiffReport(root, "s1", string.Empty, new SnapshotDiffReport.DiffReportEntry
(SnapshotDiffReport.DiffType.Modify, DFSUtil.String2Bytes(string.Empty)), new SnapshotDiffReport.DiffReportEntry
(SnapshotDiffReport.DiffType.Modify, DFSUtil.String2Bytes("foo2")), new SnapshotDiffReport.DiffReportEntry
(SnapshotDiffReport.DiffType.Rename, DFSUtil.String2Bytes("foo2/bar"), DFSUtil.String2Bytes
("foo2/bar-new")));
}
/// <exception cref="System.Exception"/>
public virtual void TestQuotaByStorageTypeWithSnapshot()
{
Path sub1 = new Path(dir, "Sub1");
dfs.Mkdirs(sub1);
// Setup ONE_SSD policy and SSD quota of 4 * BLOCKSIZE on sub1
dfs.SetStoragePolicy(sub1, HdfsConstants.OnessdStoragePolicyName);
dfs.SetQuotaByStorageType(sub1, StorageType.Ssd, 4 * Blocksize);
INode sub1Node = fsdir.GetINode4Write(sub1.ToString());
NUnit.Framework.Assert.IsTrue(sub1Node.IsDirectory());
NUnit.Framework.Assert.IsTrue(sub1Node.IsQuotaSet());
// Create file1 of size 2 * BLOCKSIZE under sub1
Path file1 = new Path(sub1, "file1");
long file1Len = 2 * Blocksize;
DFSTestUtil.CreateFile(dfs, file1, file1Len, Replication, seed);
// Create snapshot on sub1 named s1
SnapshotTestHelper.CreateSnapshot(dfs, sub1, "s1");
// Verify sub1 SSD usage is unchanged after creating snapshot s1
long ssdConsumed = sub1Node.AsDirectory().GetDirectoryWithQuotaFeature().GetSpaceConsumed
().GetTypeSpaces().Get(StorageType.Ssd);
NUnit.Framework.Assert.AreEqual(file1Len, ssdConsumed);
// Delete file1
dfs.Delete(file1, false);
// Verify sub1 SSD usage is unchanged due to the existence of snapshot s1
ssdConsumed = sub1Node.AsDirectory().GetDirectoryWithQuotaFeature().GetSpaceConsumed
().GetTypeSpaces().Get(StorageType.Ssd);
NUnit.Framework.Assert.AreEqual(file1Len, ssdConsumed);
QuotaCounts counts1 = new QuotaCounts.Builder().Build();
sub1Node.ComputeQuotaUsage(fsn.GetBlockManager().GetStoragePolicySuite(), counts1
, true);
NUnit.Framework.Assert.AreEqual(sub1Node.DumpTreeRecursively().ToString(), file1Len
, counts1.GetTypeSpaces().Get(StorageType.Ssd));
ContentSummary cs1 = dfs.GetContentSummary(sub1);
NUnit.Framework.Assert.AreEqual(cs1.GetSpaceConsumed(), file1Len * Replication);
NUnit.Framework.Assert.AreEqual(cs1.GetTypeConsumed(StorageType.Ssd), file1Len);
NUnit.Framework.Assert.AreEqual(cs1.GetTypeConsumed(StorageType.Disk), file1Len *
2);
// Delete the snapshot s1
dfs.DeleteSnapshot(sub1, "s1");
// Verify sub1 SSD usage is fully reclaimed and changed to 0
ssdConsumed = sub1Node.AsDirectory().GetDirectoryWithQuotaFeature().GetSpaceConsumed
().GetTypeSpaces().Get(StorageType.Ssd);
NUnit.Framework.Assert.AreEqual(0, ssdConsumed);
QuotaCounts counts2 = new QuotaCounts.Builder().Build();
sub1Node.ComputeQuotaUsage(fsn.GetBlockManager().GetStoragePolicySuite(), counts2
, true);
NUnit.Framework.Assert.AreEqual(sub1Node.DumpTreeRecursively().ToString(), 0, counts2
.GetTypeSpaces().Get(StorageType.Ssd));
ContentSummary cs2 = dfs.GetContentSummary(sub1);
NUnit.Framework.Assert.AreEqual(cs2.GetSpaceConsumed(), 0);
NUnit.Framework.Assert.AreEqual(cs2.GetTypeConsumed(StorageType.Ssd), 0);
NUnit.Framework.Assert.AreEqual(cs2.GetTypeConsumed(StorageType.Disk), 0);
}
public virtual void TestSuccessiveSnapshotXAttrChanges()
{
// First snapshot
FileSystem.Mkdirs(hdfs, path, FsPermission.CreateImmutable((short)0x1c0));
hdfs.SetXAttr(path, name1, value1);
SnapshotTestHelper.CreateSnapshot(hdfs, path, snapshotName);
IDictionary <string, byte[]> xattrs = hdfs.GetXAttrs(snapshotPath);
NUnit.Framework.Assert.AreEqual(1, xattrs.Count);
Assert.AssertArrayEquals(value1, xattrs[name1]);
// Second snapshot
hdfs.SetXAttr(path, name1, newValue1);
hdfs.SetXAttr(path, name2, value2);
SnapshotTestHelper.CreateSnapshot(hdfs, path, snapshotName2);
xattrs = hdfs.GetXAttrs(snapshotPath2);
NUnit.Framework.Assert.AreEqual(2, xattrs.Count);
Assert.AssertArrayEquals(newValue1, xattrs[name1]);
Assert.AssertArrayEquals(value2, xattrs[name2]);
// Third snapshot
hdfs.SetXAttr(path, name1, value1);
hdfs.RemoveXAttr(path, name2);
SnapshotTestHelper.CreateSnapshot(hdfs, path, snapshotName3);
xattrs = hdfs.GetXAttrs(snapshotPath3);
NUnit.Framework.Assert.AreEqual(1, xattrs.Count);
Assert.AssertArrayEquals(value1, xattrs[name1]);
// Check that the first and second snapshots'
// XAttrs have stayed constant
xattrs = hdfs.GetXAttrs(snapshotPath);
NUnit.Framework.Assert.AreEqual(1, xattrs.Count);
Assert.AssertArrayEquals(value1, xattrs[name1]);
xattrs = hdfs.GetXAttrs(snapshotPath2);
NUnit.Framework.Assert.AreEqual(2, xattrs.Count);
Assert.AssertArrayEquals(newValue1, xattrs[name1]);
Assert.AssertArrayEquals(value2, xattrs[name2]);
// Remove the second snapshot and verify the first and
// third snapshots' XAttrs have stayed constant
hdfs.DeleteSnapshot(path, snapshotName2);
xattrs = hdfs.GetXAttrs(snapshotPath);
NUnit.Framework.Assert.AreEqual(1, xattrs.Count);
Assert.AssertArrayEquals(value1, xattrs[name1]);
xattrs = hdfs.GetXAttrs(snapshotPath3);
NUnit.Framework.Assert.AreEqual(1, xattrs.Count);
Assert.AssertArrayEquals(value1, xattrs[name1]);
hdfs.DeleteSnapshot(path, snapshotName);
hdfs.DeleteSnapshot(path, snapshotName3);
}
public virtual void TestSnapshots()
{
cluster.GetNamesystem().GetSnapshotManager().SetAllowNestedSnapshots(true);
MetricsAsserts.AssertGauge("Snapshots", 0, MetricsAsserts.GetMetrics(NsMetrics));
MetricsAsserts.AssertCounter("CreateSnapshotOps", 0L, MetricsAsserts.GetMetrics(NnMetrics
));
// Create a snapshot for a non-snapshottable directory, thus should not
// change the metrics
try
{
hdfs.CreateSnapshot(sub1, "s1");
}
catch (Exception)
{
}
MetricsAsserts.AssertGauge("Snapshots", 0, MetricsAsserts.GetMetrics(NsMetrics));
MetricsAsserts.AssertCounter("CreateSnapshotOps", 1L, MetricsAsserts.GetMetrics(NnMetrics
));
// Create snapshot for sub1
hdfs.AllowSnapshot(sub1);
hdfs.CreateSnapshot(sub1, "s1");
MetricsAsserts.AssertGauge("Snapshots", 1, MetricsAsserts.GetMetrics(NsMetrics));
MetricsAsserts.AssertCounter("CreateSnapshotOps", 2L, MetricsAsserts.GetMetrics(NnMetrics
));
hdfs.CreateSnapshot(sub1, "s2");
MetricsAsserts.AssertGauge("Snapshots", 2, MetricsAsserts.GetMetrics(NsMetrics));
MetricsAsserts.AssertCounter("CreateSnapshotOps", 3L, MetricsAsserts.GetMetrics(NnMetrics
));
hdfs.GetSnapshotDiffReport(sub1, "s1", "s2");
MetricsAsserts.AssertCounter("SnapshotDiffReportOps", 1L, MetricsAsserts.GetMetrics
(NnMetrics));
// Create snapshot for a directory under sub1
Path subsub1 = new Path(sub1, "sub1sub1");
Path subfile = new Path(subsub1, "file");
DFSTestUtil.CreateFile(hdfs, subfile, 1024, Replication, seed);
hdfs.AllowSnapshot(subsub1);
hdfs.CreateSnapshot(subsub1, "s11");
MetricsAsserts.AssertGauge("Snapshots", 3, MetricsAsserts.GetMetrics(NsMetrics));
MetricsAsserts.AssertCounter("CreateSnapshotOps", 4L, MetricsAsserts.GetMetrics(NnMetrics
));
// delete snapshot
hdfs.DeleteSnapshot(sub1, "s2");
MetricsAsserts.AssertGauge("Snapshots", 2, MetricsAsserts.GetMetrics(NsMetrics));
MetricsAsserts.AssertCounter("DeleteSnapshotOps", 1L, MetricsAsserts.GetMetrics(NnMetrics
));
// rename snapshot
hdfs.RenameSnapshot(sub1, "s1", "NewS1");
MetricsAsserts.AssertGauge("Snapshots", 2, MetricsAsserts.GetMetrics(NsMetrics));
MetricsAsserts.AssertCounter("RenameSnapshotOps", 1L, MetricsAsserts.GetMetrics(NnMetrics
));
}
public virtual void TearDown()
{
if (fs.Exists(new Path("/sub1")))
{
if (fs.Exists(new Path("/sub1/.snapshot")))
{
foreach (FileStatus st in fs.ListStatus(new Path("/sub1/.snapshot")))
{
fs.DeleteSnapshot(new Path("/sub1"), st.GetPath().GetName());
}
fs.DisallowSnapshot(new Path("/sub1"));
}
fs.Delete(new Path("/sub1"), true);
}
}
/// <exception cref="System.IO.IOException"/>
private void DoTestMultipleSnapshots(bool saveNamespace)
{
Path path = new Path("/test");
DoWriteAndAbort(fs, path);
fs.CreateSnapshot(path, "s2");
fs.Delete(new Path("/test/test"), true);
fs.DeleteSnapshot(path, "s2");
cluster.TriggerBlockReports();
if (saveNamespace)
{
NameNode nameNode = cluster.GetNameNode();
NameNodeAdapter.EnterSafeMode(nameNode, false);
NameNodeAdapter.SaveNamespace(nameNode);
NameNodeAdapter.LeaveSafeMode(nameNode);
}
cluster.RestartNameNode(true);
}
/// <summary>Testing a special case with snapshots.</summary>
/// <remarks>
/// Testing a special case with snapshots. When the following steps happen:
/// <pre>
/// 1. Take snapshot s1 on dir.
/// 2. Create new dir and files under subsubDir, which is descendant of dir.
/// 3. Take snapshot s2 on dir.
/// 4. Delete subsubDir.
/// 5. Delete snapshot s2.
/// </pre>
/// When we merge the diff from s2 to s1 (since we deleted s2), we need to make
/// sure all the files/dirs created after s1 should be destroyed. Otherwise
/// we may save these files/dirs to the fsimage, and cause FileNotFound
/// Exception while loading fsimage.
/// </remarks>
/// <exception cref="System.Exception"/>
public virtual void TestSaveLoadImageAfterSnapshotDeletion()
{
// create initial dir and subdir
Path dir = new Path("/dir");
Path subDir = new Path(dir, "subdir");
Path subsubDir = new Path(subDir, "subsubdir");
hdfs.Mkdirs(subsubDir);
// take snapshots on subdir and dir
SnapshotTestHelper.CreateSnapshot(hdfs, dir, "s1");
// create new dir under initial dir
Path newDir = new Path(subsubDir, "newdir");
Path newFile = new Path(newDir, "newfile");
hdfs.Mkdirs(newDir);
DFSTestUtil.CreateFile(hdfs, newFile, Blocksize, Replication, seed);
// create another snapshot
SnapshotTestHelper.CreateSnapshot(hdfs, dir, "s2");
// delete subsubdir
hdfs.Delete(subsubDir, true);
// delete snapshot s2
hdfs.DeleteSnapshot(dir, "s2");
// restart cluster
cluster.Shutdown();
cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(Replication).Format(false
).Build();
cluster.WaitActive();
fsn = cluster.GetNamesystem();
hdfs = cluster.GetFileSystem();
// save namespace to fsimage
hdfs.SetSafeMode(HdfsConstants.SafeModeAction.SafemodeEnter);
hdfs.SaveNamespace();
hdfs.SetSafeMode(HdfsConstants.SafeModeAction.SafemodeLeave);
cluster.Shutdown();
cluster = new MiniDFSCluster.Builder(conf).Format(false).NumDataNodes(Replication
).Build();
cluster.WaitActive();
fsn = cluster.GetNamesystem();
hdfs = cluster.GetFileSystem();
}
/// <summary>for snapshot file.</summary>
/// <exception cref="System.Exception"/>
public virtual void TestSnapshotPathINodes()
{
// Create a snapshot for the dir, and check the inodes for the path
// pointing to a snapshot file
hdfs.AllowSnapshot(sub1);
hdfs.CreateSnapshot(sub1, "s1");
// The path when accessing the snapshot file of file1 is
// /TestSnapshot/sub1/.snapshot/s1/file1
string snapshotPath = sub1.ToString() + "/.snapshot/s1/file1";
string[] names = INode.GetPathNames(snapshotPath);
byte[][] components = INode.GetPathComponents(names);
INodesInPath nodesInPath = INodesInPath.Resolve(fsdir.rootDir, components, false);
// Length of inodes should be (components.length - 1), since we will ignore
// ".snapshot"
NUnit.Framework.Assert.AreEqual(nodesInPath.Length(), components.Length - 1);
// SnapshotRootIndex should be 3: {root, Testsnapshot, sub1, s1, file1}
Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot snapshot = GetSnapshot(nodesInPath
, "s1", 3);
AssertSnapshot(nodesInPath, true, snapshot, 3);
// Check the INode for file1 (snapshot file)
INode snapshotFileNode = nodesInPath.GetLastINode();
AssertINodeFile(snapshotFileNode, file1);
NUnit.Framework.Assert.IsTrue(snapshotFileNode.GetParent().IsWithSnapshot());
// Call getExistingPathINodes and request only one INode.
nodesInPath = INodesInPath.Resolve(fsdir.rootDir, components, false);
NUnit.Framework.Assert.AreEqual(nodesInPath.Length(), components.Length - 1);
AssertSnapshot(nodesInPath, true, snapshot, 3);
// Check the INode for file1 (snapshot file)
AssertINodeFile(nodesInPath.GetLastINode(), file1);
// Resolve the path "/TestSnapshot/sub1/.snapshot"
string dotSnapshotPath = sub1.ToString() + "/.snapshot";
names = INode.GetPathNames(dotSnapshotPath);
components = INode.GetPathComponents(names);
nodesInPath = INodesInPath.Resolve(fsdir.rootDir, components, false);
// The number of INodes returned should still be components.length
// since we put a null in the inode array for ".snapshot"
NUnit.Framework.Assert.AreEqual(nodesInPath.Length(), components.Length);
// No SnapshotRoot dir is included in the resolved inodes
AssertSnapshot(nodesInPath, true, snapshot, -1);
// The last INode should be null, the last but 1 should be sub1
NUnit.Framework.Assert.IsNull(nodesInPath.GetLastINode());
NUnit.Framework.Assert.AreEqual(nodesInPath.GetINode(-2).GetFullPathName(), sub1.
ToString());
NUnit.Framework.Assert.IsTrue(nodesInPath.GetINode(-2).IsDirectory());
string[] invalidPathComponent = new string[] { "invalidDir", "foo", ".snapshot",
"bar" };
Path invalidPath = new Path(invalidPathComponent[0]);
for (int i = 1; i < invalidPathComponent.Length; i++)
{
invalidPath = new Path(invalidPath, invalidPathComponent[i]);
try
{
hdfs.GetFileStatus(invalidPath);
NUnit.Framework.Assert.Fail();
}
catch (FileNotFoundException fnfe)
{
System.Console.Out.WriteLine("The exception is expected: " + fnfe);
}
}
hdfs.DeleteSnapshot(sub1, "s1");
hdfs.DisallowSnapshot(sub1);
}
/// <summary>Test deleting a file with snapshots.</summary>
/// <remarks>
/// Test deleting a file with snapshots. Need to check the blocksMap to make
/// sure the corresponding record is updated correctly.
/// </remarks>
/// <exception cref="System.Exception"/>
public virtual void TestDeletionWithSnapshots()
{
Path file0 = new Path(sub1, "file0");
Path file1 = new Path(sub1, "file1");
Path sub2 = new Path(sub1, "sub2");
Path file2 = new Path(sub2, "file2");
Path file3 = new Path(sub1, "file3");
Path file4 = new Path(sub1, "file4");
Path file5 = new Path(sub1, "file5");
// Create file under sub1
DFSTestUtil.CreateFile(hdfs, file0, 4 * Blocksize, Replication, seed);
DFSTestUtil.CreateFile(hdfs, file1, 2 * Blocksize, Replication, seed);
DFSTestUtil.CreateFile(hdfs, file2, 3 * Blocksize, Replication, seed);
{
// Normal deletion
INodeFile f2 = AssertBlockCollection(file2.ToString(), 3, fsdir, blockmanager);
BlockInfoContiguous[] blocks = f2.GetBlocks();
hdfs.Delete(sub2, true);
// The INode should have been removed from the blocksMap
foreach (BlockInfoContiguous b in blocks)
{
NUnit.Framework.Assert.IsNull(blockmanager.GetBlockCollection(b));
}
}
// Create snapshots for sub1
string[] snapshots = new string[] { "s0", "s1", "s2" };
DFSTestUtil.CreateFile(hdfs, file3, 5 * Blocksize, Replication, seed);
SnapshotTestHelper.CreateSnapshot(hdfs, sub1, snapshots[0]);
DFSTestUtil.CreateFile(hdfs, file4, 1 * Blocksize, Replication, seed);
SnapshotTestHelper.CreateSnapshot(hdfs, sub1, snapshots[1]);
DFSTestUtil.CreateFile(hdfs, file5, 7 * Blocksize, Replication, seed);
SnapshotTestHelper.CreateSnapshot(hdfs, sub1, snapshots[2]);
{
// set replication so that the inode should be replaced for snapshots
INodeFile f1 = AssertBlockCollection(file1.ToString(), 2, fsdir, blockmanager);
NUnit.Framework.Assert.AreSame(typeof(INodeFile), f1.GetType());
hdfs.SetReplication(file1, (short)2);
f1 = AssertBlockCollection(file1.ToString(), 2, fsdir, blockmanager);
NUnit.Framework.Assert.IsTrue(f1.IsWithSnapshot());
NUnit.Framework.Assert.IsFalse(f1.IsUnderConstruction());
}
// Check the block information for file0
INodeFile f0 = AssertBlockCollection(file0.ToString(), 4, fsdir, blockmanager);
BlockInfoContiguous[] blocks0 = f0.GetBlocks();
// Also check the block information for snapshot of file0
Path snapshotFile0 = SnapshotTestHelper.GetSnapshotPath(sub1, "s0", file0.GetName
());
AssertBlockCollection(snapshotFile0.ToString(), 4, fsdir, blockmanager);
// Delete file0
hdfs.Delete(file0, true);
// Make sure the blocks of file0 is still in blocksMap
foreach (BlockInfoContiguous b_1 in blocks0)
{
NUnit.Framework.Assert.IsNotNull(blockmanager.GetBlockCollection(b_1));
}
AssertBlockCollection(snapshotFile0.ToString(), 4, fsdir, blockmanager);
// Compare the INode in the blocksMap with INodes for snapshots
string s1f0 = SnapshotTestHelper.GetSnapshotPath(sub1, "s1", file0.GetName()).ToString
();
AssertBlockCollection(s1f0, 4, fsdir, blockmanager);
// Delete snapshot s1
hdfs.DeleteSnapshot(sub1, "s1");
// Make sure the first block of file0 is still in blocksMap
foreach (BlockInfoContiguous b_2 in blocks0)
{
NUnit.Framework.Assert.IsNotNull(blockmanager.GetBlockCollection(b_2));
}
AssertBlockCollection(snapshotFile0.ToString(), 4, fsdir, blockmanager);
try
{
INodeFile.ValueOf(fsdir.GetINode(s1f0), s1f0);
NUnit.Framework.Assert.Fail("Expect FileNotFoundException when identifying the INode in a deleted Snapshot"
);
}
catch (IOException e)
{
GenericTestUtils.AssertExceptionContains("File does not exist: " + s1f0, e);
}
}
/// <summary>
/// Create a snapshot for /test/foo and create another snapshot for
/// /test/foo/bar.
/// </summary>
/// <remarks>
/// Create a snapshot for /test/foo and create another snapshot for
/// /test/foo/bar. Files created before the snapshots should appear in both
/// snapshots and the files created after the snapshots should not appear in
/// any of the snapshots.
/// </remarks>
/// <exception cref="System.Exception"/>
public virtual void TestNestedSnapshots()
{
cluster.GetNamesystem().GetSnapshotManager().SetAllowNestedSnapshots(true);
Path foo = new Path("/testNestedSnapshots/foo");
Path bar = new Path(foo, "bar");
Path file1 = new Path(bar, "file1");
DFSTestUtil.CreateFile(hdfs, file1, Blocksize, Replication, Seed);
Print("create file " + file1);
string s1name = "foo-s1";
Path s1path = SnapshotTestHelper.GetSnapshotRoot(foo, s1name);
hdfs.AllowSnapshot(foo);
Print("allow snapshot " + foo);
hdfs.CreateSnapshot(foo, s1name);
Print("create snapshot " + s1name);
string s2name = "bar-s2";
Path s2path = SnapshotTestHelper.GetSnapshotRoot(bar, s2name);
hdfs.AllowSnapshot(bar);
Print("allow snapshot " + bar);
hdfs.CreateSnapshot(bar, s2name);
Print("create snapshot " + s2name);
Path file2 = new Path(bar, "file2");
DFSTestUtil.CreateFile(hdfs, file2, Blocksize, Replication, Seed);
Print("create file " + file2);
AssertFile(s1path, s2path, file1, true, true, true);
AssertFile(s1path, s2path, file2, true, false, false);
//test root
string rootStr = "/";
Path rootPath = new Path(rootStr);
hdfs.AllowSnapshot(rootPath);
Print("allow snapshot " + rootStr);
Path rootSnapshot = hdfs.CreateSnapshot(rootPath);
Print("create snapshot " + rootSnapshot);
hdfs.DeleteSnapshot(rootPath, rootSnapshot.GetName());
Print("delete snapshot " + rootSnapshot);
hdfs.DisallowSnapshot(rootPath);
Print("disallow snapshot " + rootStr);
//change foo to non-snapshottable
hdfs.DeleteSnapshot(foo, s1name);
hdfs.DisallowSnapshot(foo);
//test disallow nested snapshots
cluster.GetNamesystem().GetSnapshotManager().SetAllowNestedSnapshots(false);
try
{
hdfs.AllowSnapshot(rootPath);
NUnit.Framework.Assert.Fail();
}
catch (SnapshotException se)
{
AssertNestedSnapshotException(se, "subdirectory");
}
try
{
hdfs.AllowSnapshot(foo);
NUnit.Framework.Assert.Fail();
}
catch (SnapshotException se)
{
AssertNestedSnapshotException(se, "subdirectory");
}
Path sub1Bar = new Path(bar, "sub1");
Path sub2Bar = new Path(sub1Bar, "sub2");
hdfs.Mkdirs(sub2Bar);
try
{
hdfs.AllowSnapshot(sub1Bar);
NUnit.Framework.Assert.Fail();
}
catch (SnapshotException se)
{
AssertNestedSnapshotException(se, "ancestor");
}
try
{
hdfs.AllowSnapshot(sub2Bar);
NUnit.Framework.Assert.Fail();
}
catch (SnapshotException se)
{
AssertNestedSnapshotException(se, "ancestor");
}
}