public virtual void TestFinalizedRwrReplicas()
{
if (Log.IsDebugEnabled())
{
Log.Debug("Running " + GenericTestUtils.GetMethodName());
}
// rbw and finalized replicas have the same length
ReplicaRecoveryInfo replica1 = new ReplicaRecoveryInfo(BlockId, ReplicaLen1, GenStamp
- 1, HdfsServerConstants.ReplicaState.Finalized);
ReplicaRecoveryInfo replica2 = new ReplicaRecoveryInfo(BlockId, ReplicaLen1, GenStamp
- 2, HdfsServerConstants.ReplicaState.Rwr);
InterDatanodeProtocol dn1 = Org.Mockito.Mockito.Mock <InterDatanodeProtocol>();
InterDatanodeProtocol dn2 = Org.Mockito.Mockito.Mock <InterDatanodeProtocol>();
TestSyncReplicas(replica1, replica2, dn1, dn2, ReplicaLen1);
Org.Mockito.Mockito.Verify(dn1).UpdateReplicaUnderRecovery(block, RecoveryId, BlockId
, ReplicaLen1);
Org.Mockito.Mockito.Verify(dn2, Org.Mockito.Mockito.Never()).UpdateReplicaUnderRecovery
(block, RecoveryId, BlockId, ReplicaLen1);
// rbw replica has a different length from the finalized one
replica1 = new ReplicaRecoveryInfo(BlockId, ReplicaLen1, GenStamp - 1, HdfsServerConstants.ReplicaState
.Finalized);
replica2 = new ReplicaRecoveryInfo(BlockId, ReplicaLen2, GenStamp - 2, HdfsServerConstants.ReplicaState
.Rbw);
dn1 = Org.Mockito.Mockito.Mock <InterDatanodeProtocol>();
dn2 = Org.Mockito.Mockito.Mock <InterDatanodeProtocol>();
TestSyncReplicas(replica1, replica2, dn1, dn2, ReplicaLen1);
Org.Mockito.Mockito.Verify(dn1).UpdateReplicaUnderRecovery(block, RecoveryId, BlockId
, ReplicaLen1);
Org.Mockito.Mockito.Verify(dn2, Org.Mockito.Mockito.Never()).UpdateReplicaUnderRecovery
(block, RecoveryId, BlockId, ReplicaLen1);
}
public virtual void TestFinalizedReplicas()
{
if (Log.IsDebugEnabled())
{
Log.Debug("Running " + GenericTestUtils.GetMethodName());
}
ReplicaRecoveryInfo replica1 = new ReplicaRecoveryInfo(BlockId, ReplicaLen1, GenStamp
- 1, HdfsServerConstants.ReplicaState.Finalized);
ReplicaRecoveryInfo replica2 = new ReplicaRecoveryInfo(BlockId, ReplicaLen1, GenStamp
- 2, HdfsServerConstants.ReplicaState.Finalized);
InterDatanodeProtocol dn1 = Org.Mockito.Mockito.Mock <InterDatanodeProtocol>();
InterDatanodeProtocol dn2 = Org.Mockito.Mockito.Mock <InterDatanodeProtocol>();
TestSyncReplicas(replica1, replica2, dn1, dn2, ReplicaLen1);
Org.Mockito.Mockito.Verify(dn1).UpdateReplicaUnderRecovery(block, RecoveryId, BlockId
, ReplicaLen1);
Org.Mockito.Mockito.Verify(dn2).UpdateReplicaUnderRecovery(block, RecoveryId, BlockId
, ReplicaLen1);
// two finalized replicas have different length
replica1 = new ReplicaRecoveryInfo(BlockId, ReplicaLen1, GenStamp - 1, HdfsServerConstants.ReplicaState
.Finalized);
replica2 = new ReplicaRecoveryInfo(BlockId, ReplicaLen2, GenStamp - 2, HdfsServerConstants.ReplicaState
.Finalized);
try
{
TestSyncReplicas(replica1, replica2, dn1, dn2, ReplicaLen1);
NUnit.Framework.Assert.Fail("Two finalized replicas should not have different lengthes!"
);
}
catch (IOException e)
{
NUnit.Framework.Assert.IsTrue(e.Message.StartsWith("Inconsistent size of finalized replicas. "
));
}
}
public virtual void BlockLengthHintIsPropagated()
{
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
Configuration conf = new HdfsConfiguration();
TestWriteBlockGetsBlockLengthHint.FsDatasetChecker.SetFactory(conf);
conf.SetLong(DFSConfigKeys.DfsBlockSizeKey, DefaultBlockLength);
conf.SetInt(DFSConfigKeys.DfsDatanodeScanPeriodHoursKey, -1);
MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(1).Build();
try
{
cluster.WaitActive();
// FsDatasetChecker#createRbw asserts during block creation if the test
// fails.
DFSTestUtil.CreateFile(cluster.GetFileSystem(), path, 4096, ExpectedBlockLength,
ExpectedBlockLength, (short)1, unchecked ((int)(0x1BAD5EED)));
}
finally
{
// Buffer size.
cluster.Shutdown();
}
}
/// <exception cref="System.Exception"/>
public virtual void TestDatanodeRollingUpgradeWithRollback()
{
try
{
StartCluster();
// Create files in DFS.
Path testFile1 = new Path("/" + GenericTestUtils.GetMethodName() + ".01.dat");
DFSTestUtil.CreateFile(fs, testFile1, FileSize, ReplFactor, Seed);
string fileContents1 = DFSTestUtil.ReadFile(fs, testFile1);
StartRollingUpgrade();
FilePath blockFile = GetBlockForFile(testFile1, true);
FilePath trashFile = GetTrashFileForBlock(blockFile, false);
DeleteAndEnsureInTrash(testFile1, blockFile, trashFile);
// Now perform a rollback to restore DFS to the pre-rollback state.
RollbackRollingUpgrade();
// Ensure that block was restored from trash
EnsureTrashRestored(blockFile, trashFile);
// Ensure that files exist and restored file contents are the same.
System.Diagnostics.Debug.Assert((fs.Exists(testFile1)));
string fileContents2 = DFSTestUtil.ReadFile(fs, testFile1);
Assert.AssertThat(fileContents1, IS.Is(fileContents2));
}
finally
{
ShutdownCluster();
}
}
public virtual void TestRamDiskShortCircuitRead()
{
StartUpCluster(ReplFactor, new StorageType[] { StorageType.RamDisk, StorageType.Default }, 2 * BlockSize - 1, true);
// 1 replica + delta, SCR read
string MethodName = GenericTestUtils.GetMethodName();
int Seed = unchecked ((int)(0xFADED));
Path path = new Path("/" + MethodName + ".dat");
MakeRandomTestFile(path, BlockSize, true, Seed);
EnsureFileReplicasOnStorageType(path, StorageType.RamDisk);
// Sleep for a short time to allow the lazy writer thread to do its job
Sharpen.Thread.Sleep(3 * LazyWriterIntervalSec * 1000);
//assertThat(verifyReadRandomFile(path, BLOCK_SIZE, SEED), is(true));
FSDataInputStream fis = fs.Open(path);
// Verify SCR read counters
try
{
fis = fs.Open(path);
byte[] buf = new byte[BufferLength];
fis.Read(0, buf, 0, BufferLength);
HdfsDataInputStream dfsis = (HdfsDataInputStream)fis;
NUnit.Framework.Assert.AreEqual(BufferLength, dfsis.GetReadStatistics().GetTotalBytesRead
());
NUnit.Framework.Assert.AreEqual(BufferLength, dfsis.GetReadStatistics().GetTotalShortCircuitBytesRead
());
}
finally
{
fis.Close();
fis = null;
}
}
public virtual void TestFallbackToDiskPartial()
{
StartUpCluster(true, 2);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
MakeTestFile(path, BlockSize * 5, true);
// Sleep for a short time to allow the lazy writer thread to do its job
Sharpen.Thread.Sleep(6 * LazyWriterIntervalSec * 1000);
TriggerBlockReport();
int numBlocksOnRamDisk = 0;
int numBlocksOnDisk = 0;
long fileLength = client.GetFileInfo(path.ToString()).GetLen();
LocatedBlocks locatedBlocks = client.GetLocatedBlocks(path.ToString(), 0, fileLength
);
foreach (LocatedBlock locatedBlock in locatedBlocks.GetLocatedBlocks())
{
if (locatedBlock.GetStorageTypes()[0] == StorageType.RamDisk)
{
numBlocksOnRamDisk++;
}
else
{
if (locatedBlock.GetStorageTypes()[0] == StorageType.Default)
{
numBlocksOnDisk++;
}
}
}
// Since eviction is asynchronous, depending on the timing of eviction
// wrt writes, we may get 2 or less blocks on RAM disk.
System.Diagnostics.Debug.Assert((numBlocksOnRamDisk <= 2));
System.Diagnostics.Debug.Assert((numBlocksOnDisk >= 3));
}
public virtual void TestConcurrentRead()
{
StartUpCluster(true, 2);
string MethodName = GenericTestUtils.GetMethodName();
Path path1 = new Path("/" + MethodName + ".dat");
int Seed = unchecked ((int)(0xFADED));
int NumTasks = 5;
MakeRandomTestFile(path1, BlockSize, true, Seed);
EnsureFileReplicasOnStorageType(path1, StorageType.RamDisk);
//Read from multiple clients
CountDownLatch latch = new CountDownLatch(NumTasks);
AtomicBoolean testFailed = new AtomicBoolean(false);
Runnable readerRunnable = new _Runnable_564(this, path1, Seed, testFailed, latch);
Sharpen.Thread[] threads = new Sharpen.Thread[NumTasks];
for (int i = 0; i < NumTasks; i++)
{
threads[i] = new Sharpen.Thread(readerRunnable);
threads[i].Start();
}
Sharpen.Thread.Sleep(500);
for (int i_1 = 0; i_1 < NumTasks; i_1++)
{
Uninterruptibles.JoinUninterruptibly(threads[i_1]);
}
NUnit.Framework.Assert.IsFalse(testFailed.Get());
}
/// <exception cref="System.IO.IOException"/>
public virtual void TestWithLimitedSpace()
{
// Cluster with just enough space for a full block + meta.
StartCluster(BlockSize, 1, 2 * BlockSize - 1);
string methodName = GenericTestUtils.GetMethodName();
Path file1 = new Path("/" + methodName + ".01.dat");
Path file2 = new Path("/" + methodName + ".02.dat");
// Create two files.
FSDataOutputStream os1 = null;
FSDataOutputStream os2 = null;
try
{
os1 = fs.Create(file1);
os2 = fs.Create(file2);
// Write one byte to the first file.
byte[] data = new byte[1];
os1.Write(data);
os1.Hsync();
// Try to write one byte to the second file.
// The block allocation must fail.
thrown.Expect(typeof(RemoteException));
os2.Write(data);
os2.Hsync();
}
finally
{
if (os1 != null)
{
os1.Close();
}
}
}
/// <summary>
/// Similar to BlockReport_03() but works with two DNs
/// Test writes a file and closes it.
/// </summary>
/// <remarks>
/// Similar to BlockReport_03() but works with two DNs
/// Test writes a file and closes it.
/// The second datanode is started in the cluster.
/// As soon as the replication process is completed test finds a block from
/// the second DN and sets its GS to be < of original one.
/// this is the markBlockAsCorrupt case 3 so we expect one pending deletion
/// Block report is forced and the check for # of currupted blocks is performed.
/// Another block is chosen and its length is set to a lesser than original.
/// A check for another corrupted block is performed after yet another
/// BlockReport
/// </remarks>
/// <exception cref="System.IO.IOException">in case of an error</exception>
/// <exception cref="System.Exception"/>
public virtual void BlockReport_07()
{
string MethodName = GenericTestUtils.GetMethodName();
Path filePath = new Path("/" + MethodName + ".dat");
int DnN1 = DnN0 + 1;
// write file and start second node to be "older" than the original
WriteFile(MethodName, FileSize, filePath);
StartDNandWait(filePath, true);
// all blocks belong to the same file, hence same BP
DataNode dn = cluster.GetDataNodes()[DnN1];
string poolId = cluster.GetNamesystem().GetBlockPoolId();
DatanodeRegistration dnR = dn.GetDNRegistrationForBP(poolId);
StorageBlockReport[] reports = GetBlockReports(dn, poolId, true, false);
SendBlockReports(dnR, poolId, reports);
PrintStats();
Assert.AssertThat("Wrong number of corrupt blocks", cluster.GetNamesystem().GetCorruptReplicaBlocks
(), IS.Is(0L));
Assert.AssertThat("Wrong number of PendingDeletion blocks", cluster.GetNamesystem
().GetPendingDeletionBlocks(), IS.Is(1L));
Assert.AssertThat("Wrong number of PendingReplication blocks", cluster.GetNamesystem
().GetPendingReplicationBlocks(), IS.Is(0L));
reports = GetBlockReports(dn, poolId, false, true);
SendBlockReports(dnR, poolId, reports);
PrintStats();
Assert.AssertThat("Wrong number of corrupt blocks", cluster.GetNamesystem().GetCorruptReplicaBlocks
(), IS.Is(1L));
Assert.AssertThat("Wrong number of PendingDeletion blocks", cluster.GetNamesystem
().GetPendingDeletionBlocks(), IS.Is(1L));
Assert.AssertThat("Wrong number of PendingReplication blocks", cluster.GetNamesystem
().GetPendingReplicationBlocks(), IS.Is(0L));
PrintStats();
}
public virtual void Pipeline_01()
{
string MethodName = GenericTestUtils.GetMethodName();
if (Log.IsDebugEnabled())
{
Log.Debug("Running " + MethodName);
}
Path filePath = new Path("/" + MethodName + ".dat");
DFSTestUtil.CreateFile(fs, filePath, FileSize, ReplFactor, rand.NextLong());
if (Log.IsDebugEnabled())
{
Log.Debug("Invoking append but doing nothing otherwise...");
}
FSDataOutputStream ofs = fs.Append(filePath);
ofs.WriteBytes("Some more stuff to write");
((DFSOutputStream)ofs.GetWrappedStream()).Hflush();
IList <LocatedBlock> lb = cluster.GetNameNodeRpc().GetBlockLocations(filePath.ToString
(), FileSize - 1, FileSize).GetLocatedBlocks();
string bpid = cluster.GetNamesystem().GetBlockPoolId();
foreach (DataNode dn in cluster.GetDataNodes())
{
Replica r = DataNodeTestUtils.FetchReplicaInfo(dn, bpid, lb[0].GetBlock().GetBlockId
());
NUnit.Framework.Assert.IsTrue("Replica on DN " + dn + " shouldn't be null", r !=
null);
NUnit.Framework.Assert.AreEqual("Should be RBW replica on " + dn + " after sequence of calls append()/write()/hflush()"
, HdfsServerConstants.ReplicaState.Rbw, r.GetState());
}
ofs.Close();
}
public virtual void TestConcurrentWrites()
{
StartUpCluster(true, 9);
string MethodName = GenericTestUtils.GetMethodName();
int Seed = unchecked ((int)(0xFADED));
int NumWriters = 4;
int NumWriterPaths = 5;
Path[][] paths = new Path[][] { new Path[NumWriterPaths], new Path[NumWriterPaths
], new Path[NumWriterPaths], new Path[NumWriterPaths] };
for (int i = 0; i < NumWriters; i++)
{
paths[i] = new Path[NumWriterPaths];
for (int j = 0; j < NumWriterPaths; j++)
{
paths[i][j] = new Path("/" + MethodName + ".Writer" + i + ".File." + j + ".dat");
}
}
CountDownLatch latch = new CountDownLatch(NumWriters);
AtomicBoolean testFailed = new AtomicBoolean(false);
ExecutorService executor = Executors.NewFixedThreadPool(ThreadpoolSize);
for (int i_1 = 0; i_1 < NumWriters; i_1++)
{
Runnable writer = new TestLazyPersistFiles.WriterRunnable(this, i_1, paths[i_1],
Seed, latch, testFailed);
executor.Execute(writer);
}
Sharpen.Thread.Sleep(3 * LazyWriterIntervalSec * 1000);
TriggerBlockReport();
// Stop executor from adding new tasks to finish existing threads in queue
latch.Await();
Assert.AssertThat(testFailed.Get(), IS.Is(false));
}
public virtual void TestRamDiskEvictionIsLru()
{
int NumPaths = 5;
StartUpCluster(true, NumPaths + EvictionLowWatermark);
string MethodName = GenericTestUtils.GetMethodName();
Path[] paths = new Path[NumPaths * 2];
for (int i = 0; i < paths.Length; i++)
{
paths[i] = new Path("/" + MethodName + "." + i + ".dat");
}
for (int i_1 = 0; i_1 < NumPaths; i_1++)
{
MakeTestFile(paths[i_1], BlockSize, true);
}
// Sleep for a short time to allow the lazy writer thread to do its job.
Sharpen.Thread.Sleep(3 * LazyWriterIntervalSec * 1000);
for (int i_2 = 0; i_2 < NumPaths; ++i_2)
{
EnsureFileReplicasOnStorageType(paths[i_2], StorageType.RamDisk);
}
// Open the files for read in a random order.
AList <int> indexes = new AList <int>(NumPaths);
for (int i_3 = 0; i_3 < NumPaths; ++i_3)
{
indexes.AddItem(i_3);
}
Collections.Shuffle(indexes);
for (int i_4 = 0; i_4 < NumPaths; ++i_4)
{
Log.Info("Touching file " + paths[indexes[i_4]]);
DFSTestUtil.ReadFile(fs, paths[indexes[i_4]]);
}
// Create an equal number of new files ensuring that the previous
// files are evicted in the same order they were read.
for (int i_5 = 0; i_5 < NumPaths; ++i_5)
{
MakeTestFile(paths[i_5 + NumPaths], BlockSize, true);
TriggerBlockReport();
Sharpen.Thread.Sleep(3000);
EnsureFileReplicasOnStorageType(paths[i_5 + NumPaths], StorageType.RamDisk);
EnsureFileReplicasOnStorageType(paths[indexes[i_5]], StorageType.Default);
for (int j = i_5 + 1; j < NumPaths; ++j)
{
EnsureFileReplicasOnStorageType(paths[indexes[j]], StorageType.RamDisk);
}
}
VerifyRamDiskJMXMetric("RamDiskBlocksWrite", NumPaths * 2);
VerifyRamDiskJMXMetric("RamDiskBlocksWriteFallback", 0);
VerifyRamDiskJMXMetric("RamDiskBytesWrite", BlockSize * NumPaths * 2);
VerifyRamDiskJMXMetric("RamDiskBlocksReadHits", NumPaths);
VerifyRamDiskJMXMetric("RamDiskBlocksEvicted", NumPaths);
VerifyRamDiskJMXMetric("RamDiskBlocksEvictedWithoutRead", 0);
VerifyRamDiskJMXMetric("RamDiskBlocksDeletedBeforeLazyPersisted", 0);
}
public virtual void TestPlacementOnRamDisk()
{
StartUpCluster(true, -1);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
MakeTestFile(path, BlockSize, true);
EnsureFileReplicasOnStorageType(path, StorageType.RamDisk);
}
public virtual void TestFallbackToDisk()
{
StartUpCluster(false, -1);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
MakeTestFile(path, BlockSize, true);
EnsureFileReplicasOnStorageType(path, StorageType.Default);
}
/// <summary>Test write a file, verifies and closes it.</summary>
/// <remarks>
/// Test write a file, verifies and closes it. Then the length of the blocks
/// are messed up and BlockReport is forced.
/// The modification of blocks' length has to be ignored
/// </remarks>
/// <exception cref="System.IO.IOException">on an error</exception>
public virtual void BlockReport_01()
{
string MethodName = GenericTestUtils.GetMethodName();
Path filePath = new Path("/" + MethodName + ".dat");
AList <Block> blocks = PrepareForRide(filePath, MethodName, FileSize);
if (Log.IsDebugEnabled())
{
Log.Debug("Number of blocks allocated " + blocks.Count);
}
long[] oldLengths = new long[blocks.Count];
int tempLen;
for (int i = 0; i < blocks.Count; i++)
{
Block b = blocks[i];
if (Log.IsDebugEnabled())
{
Log.Debug("Block " + b.GetBlockName() + " before\t" + "Size " + b.GetNumBytes());
}
oldLengths[i] = b.GetNumBytes();
if (Log.IsDebugEnabled())
{
Log.Debug("Setting new length");
}
tempLen = rand.Next(BlockSize);
b.Set(b.GetBlockId(), tempLen, b.GetGenerationStamp());
if (Log.IsDebugEnabled())
{
Log.Debug("Block " + b.GetBlockName() + " after\t " + "Size " + b.GetNumBytes());
}
}
// all blocks belong to the same file, hence same BP
DataNode dn = cluster.GetDataNodes()[DnN0];
string poolId = cluster.GetNamesystem().GetBlockPoolId();
DatanodeRegistration dnR = dn.GetDNRegistrationForBP(poolId);
StorageBlockReport[] reports = GetBlockReports(dn, poolId, false, false);
SendBlockReports(dnR, poolId, reports);
IList <LocatedBlock> blocksAfterReport = DFSTestUtil.GetAllBlocks(fs.Open(filePath
));
if (Log.IsDebugEnabled())
{
Log.Debug("After mods: Number of blocks allocated " + blocksAfterReport.Count);
}
for (int i_1 = 0; i_1 < blocksAfterReport.Count; i_1++)
{
ExtendedBlock b = blocksAfterReport[i_1].GetBlock();
NUnit.Framework.Assert.AreEqual("Length of " + i_1 + "th block is incorrect", oldLengths
[i_1], b.GetNumBytes());
}
}
public virtual void TestPolicyPropagation()
{
StartUpCluster(false, -1);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
MakeTestFile(path, 0, true);
// Stat the file and check that the lazyPersist flag is returned back.
HdfsFileStatus status = client.GetFileInfo(path.ToString());
Assert.AssertThat(status.GetStoragePolicy(), IS.Is(LazyPersistPolicyId));
}
public virtual void TestQuotaByStorageTypePersistenceInFsImage()
{
string MethodName = GenericTestUtils.GetMethodName();
Path testDir = new Path(dir, MethodName);
Path createdFile1 = new Path(testDir, "created_file1.data");
dfs.Mkdirs(testDir);
// set storage policy on testDir to ONESSD
dfs.SetStoragePolicy(testDir, HdfsConstants.OnessdStoragePolicyName);
// set quota by storage type on testDir
long SsdQuota = Blocksize * 4;
dfs.SetQuotaByStorageType(testDir, StorageType.Ssd, SsdQuota);
INode testDirNode = fsdir.GetINode4Write(testDir.ToString());
NUnit.Framework.Assert.IsTrue(testDirNode.IsDirectory());
NUnit.Framework.Assert.IsTrue(testDirNode.IsQuotaSet());
// Create file of size 2 * BLOCKSIZE under testDir
long file1Len = Blocksize * 2;
int bufLen = Blocksize / 16;
DFSTestUtil.CreateFile(dfs, createdFile1, bufLen, file1Len, Blocksize, Replication
, seed);
// Verify SSD consumed before namenode restart
long ssdConsumed = testDirNode.AsDirectory().GetDirectoryWithQuotaFeature().GetSpaceConsumed
().GetTypeSpaces().Get(StorageType.Ssd);
NUnit.Framework.Assert.AreEqual(file1Len, ssdConsumed);
// Restart the namenode with checkpoint to make sure fsImage is correct
dfs.SetSafeMode(HdfsConstants.SafeModeAction.SafemodeEnter);
dfs.SaveNamespace();
dfs.SetSafeMode(HdfsConstants.SafeModeAction.SafemodeLeave);
cluster.RestartNameNode(true);
RefreshClusterState();
INode testDirNodeAfterNNRestart = fsdir.GetINode4Write(testDir.ToString());
NUnit.Framework.Assert.IsTrue(testDirNode.IsDirectory());
NUnit.Framework.Assert.IsTrue(testDirNode.IsQuotaSet());
QuotaCounts qc = testDirNodeAfterNNRestart.GetQuotaCounts();
NUnit.Framework.Assert.AreEqual(SsdQuota, qc.GetTypeSpace(StorageType.Ssd));
foreach (StorageType t in StorageType.GetTypesSupportingQuota())
{
if (t != StorageType.Ssd)
{
NUnit.Framework.Assert.AreEqual(HdfsConstants.QuotaReset, qc.GetTypeSpace(t));
}
}
long ssdConsumedAfterNNRestart = testDirNodeAfterNNRestart.AsDirectory().GetDirectoryWithQuotaFeature
().GetSpaceConsumed().GetTypeSpaces().Get(StorageType.Ssd);
NUnit.Framework.Assert.AreEqual(file1Len, ssdConsumedAfterNNRestart);
}
/// <summary>
/// Support for layout version change with rolling upgrade was
/// added by HDFS-6800 and HDFS-6981.
/// </summary>
/// <exception cref="System.Exception"/>
public virtual void TestWithLayoutChangeAndFinalize()
{
long seed = unchecked ((int)(0x600DF00D));
try
{
StartCluster();
Path[] paths = new Path[3];
FilePath[] blockFiles = new FilePath[3];
// Create two files in DFS.
for (int i = 0; i < 2; ++i)
{
paths[i] = new Path("/" + GenericTestUtils.GetMethodName() + "." + i + ".dat");
DFSTestUtil.CreateFile(fs, paths[i], BlockSize, (short)2, seed);
}
StartRollingUpgrade();
// Delete the first file. The DN will save its block files in trash.
blockFiles[0] = GetBlockForFile(paths[0], true);
FilePath trashFile0 = GetTrashFileForBlock(blockFiles[0], false);
DeleteAndEnsureInTrash(paths[0], blockFiles[0], trashFile0);
// Restart the DN with a new layout version to trigger layout upgrade.
Log.Info("Shutting down the Datanode");
MiniDFSCluster.DataNodeProperties dnprop = cluster.StopDataNode(0);
DFSTestUtil.AddDataNodeLayoutVersion(DataNodeLayoutVersion.CurrentLayoutVersion -
1, "Test Layout for TestDataNodeRollingUpgrade");
Log.Info("Restarting the DataNode");
cluster.RestartDataNode(dnprop, true);
cluster.WaitActive();
dn0 = cluster.GetDataNodes()[0];
Log.Info("The DN has been restarted");
NUnit.Framework.Assert.IsFalse(trashFile0.Exists());
NUnit.Framework.Assert.IsFalse(dn0.GetStorage().GetBPStorage(blockPoolId).IsTrashAllowed
(blockFiles[0]));
// Ensure that the block file for the first file was moved from 'trash' to 'previous'.
NUnit.Framework.Assert.IsTrue(IsBlockFileInPrevious(blockFiles[0]));
NUnit.Framework.Assert.IsFalse(IsTrashRootPresent());
// Delete the second file. Ensure that its block file is in previous.
blockFiles[1] = GetBlockForFile(paths[1], true);
fs.Delete(paths[1], false);
NUnit.Framework.Assert.IsTrue(IsBlockFileInPrevious(blockFiles[1]));
NUnit.Framework.Assert.IsFalse(IsTrashRootPresent());
// Finalize and ensure that neither block file exists in trash or previous.
FinalizeRollingUpgrade();
NUnit.Framework.Assert.IsFalse(IsTrashRootPresent());
NUnit.Framework.Assert.IsFalse(IsBlockFileInPrevious(blockFiles[0]));
NUnit.Framework.Assert.IsFalse(IsBlockFileInPrevious(blockFiles[1]));
}
finally
{
ShutdownCluster();
}
}
public virtual void TestPolicyNotSetByDefault()
{
StartUpCluster(false, -1);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
MakeTestFile(path, 0, false);
// Stat the file and check that the LAZY_PERSIST policy is not
// returned back.
HdfsFileStatus status = client.GetFileInfo(path.ToString());
Assert.AssertThat(status.GetStoragePolicy(), IsNot.Not(LazyPersistPolicyId));
}
// return the initial state of the configuration
/// <summary>
/// Test for the case where one of the DNs in the pipeline is in the
/// process of doing a block report exactly when the block is closed.
/// </summary>
/// <remarks>
/// Test for the case where one of the DNs in the pipeline is in the
/// process of doing a block report exactly when the block is closed.
/// In this case, the block report becomes delayed until after the
/// block is marked completed on the NN, and hence it reports an RBW
/// replica for a COMPLETE block. Such a report should not be marked
/// corrupt.
/// This is a regression test for HDFS-2791.
/// </remarks>
/// <exception cref="System.Exception"/>
public virtual void TestOneReplicaRbwReportArrivesAfterBlockCompleted()
{
CountDownLatch brFinished = new CountDownLatch(1);
GenericTestUtils.DelayAnswer delayer = new _DelayAnswer_579(brFinished, Log);
// inform the test that our block report went through.
string MethodName = GenericTestUtils.GetMethodName();
Path filePath = new Path("/" + MethodName + ".dat");
// Start a second DN for this test -- we're checking
// what happens when one of the DNs is slowed for some reason.
ReplFactor = 2;
StartDNandWait(null, false);
NameNode nn = cluster.GetNameNode();
FSDataOutputStream @out = fs.Create(filePath, ReplFactor);
try
{
AppendTestUtil.Write(@out, 0, 10);
@out.Hflush();
// Set up a spy so that we can delay the block report coming
// from this node.
DataNode dn = cluster.GetDataNodes()[0];
DatanodeProtocolClientSideTranslatorPB spy = DataNodeTestUtils.SpyOnBposToNN(dn,
nn);
Org.Mockito.Mockito.DoAnswer(delayer).When(spy).BlockReport(Org.Mockito.Mockito.AnyObject
<DatanodeRegistration>(), Org.Mockito.Mockito.AnyString(), Org.Mockito.Mockito.AnyObject
<StorageBlockReport[]>(), Org.Mockito.Mockito.AnyObject <BlockReportContext>());
// Force a block report to be generated. The block report will have
// an RBW replica in it. Wait for the RPC to be sent, but block
// it before it gets to the NN.
dn.ScheduleAllBlockReport(0);
delayer.WaitForCall();
}
finally
{
IOUtils.CloseStream(@out);
}
// Now that the stream is closed, the NN will have the block in COMPLETE
// state.
delayer.Proceed();
brFinished.Await();
// Verify that no replicas are marked corrupt, and that the
// file is still readable.
BlockManagerTestUtil.UpdateState(nn.GetNamesystem().GetBlockManager());
NUnit.Framework.Assert.AreEqual(0, nn.GetNamesystem().GetCorruptReplicaBlocks());
DFSTestUtil.ReadFile(fs, filePath);
// Ensure that the file is readable even from the DN that we futzed with.
cluster.StopDataNode(1);
DFSTestUtil.ReadFile(fs, filePath);
}
public virtual void TestDnRestartWithUnsavedReplicas()
{
StartUpCluster(true, 1);
FsDatasetTestUtil.StopLazyWriter(cluster.GetDataNodes()[0]);
string MethodName = GenericTestUtils.GetMethodName();
Path path1 = new Path("/" + MethodName + ".01.dat");
MakeTestFile(path1, BlockSize, true);
EnsureFileReplicasOnStorageType(path1, StorageType.RamDisk);
Log.Info("Restarting the DataNode");
cluster.RestartDataNode(0, true);
cluster.WaitActive();
// Ensure that the replica is still on transient storage.
EnsureFileReplicasOnStorageType(path1, StorageType.RamDisk);
}
public virtual void TestBlockHasMultipleReplicasOnSameDN()
{
string filename = MakeFileName(GenericTestUtils.GetMethodName());
Path filePath = new Path(filename);
// Write out a file with a few blocks.
DFSTestUtil.CreateFile(fs, filePath, BlockSize, BlockSize * NumBlocks, BlockSize,
NumDatanodes, seed);
// Get the block list for the file with the block locations.
LocatedBlocks locatedBlocks = client.GetLocatedBlocks(filePath.ToString(), 0, BlockSize
* NumBlocks);
// Generate a fake block report from one of the DataNodes, such
// that it reports one copy of each block on either storage.
DataNode dn = cluster.GetDataNodes()[0];
DatanodeRegistration dnReg = dn.GetDNRegistrationForBP(bpid);
StorageBlockReport[] reports = new StorageBlockReport[cluster.GetStoragesPerDatanode
()];
AList <Replica> blocks = new AList <Replica>();
foreach (LocatedBlock locatedBlock in locatedBlocks.GetLocatedBlocks())
{
Block localBlock = locatedBlock.GetBlock().GetLocalBlock();
blocks.AddItem(new FinalizedReplica(localBlock, null, null));
}
BlockListAsLongs bll = BlockListAsLongs.Encode(blocks);
for (int i = 0; i < cluster.GetStoragesPerDatanode(); ++i)
{
FsVolumeSpi v = dn.GetFSDataset().GetVolumes()[i];
DatanodeStorage dns = new DatanodeStorage(v.GetStorageID());
reports[i] = new StorageBlockReport(dns, bll);
}
// Should not assert!
cluster.GetNameNodeRpc().BlockReport(dnReg, bpid, reports, new BlockReportContext
(1, 0, Runtime.NanoTime()));
// Get the block locations once again.
locatedBlocks = client.GetLocatedBlocks(filename, 0, BlockSize * NumBlocks);
// Make sure that each block has two replicas, one on each DataNode.
foreach (LocatedBlock locatedBlock_1 in locatedBlocks.GetLocatedBlocks())
{
DatanodeInfo[] locations = locatedBlock_1.GetLocations();
Assert.AssertThat(locations.Length, IS.Is((int)NumDatanodes));
Assert.AssertThat(locations[0].GetDatanodeUuid(), CoreMatchers.Not(locations[1].GetDatanodeUuid
()));
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void VerifyIncrementalBlockReports(bool splitReports)
{
// Get the block list for the file with the block locations.
LocatedBlocks blocks = CreateFileGetBlocks(GenericTestUtils.GetMethodName());
// We will send 'fake' incremental block reports to the NN that look
// like they originated from DN 0.
StorageReceivedDeletedBlocks[] reports = new StorageReceivedDeletedBlocks[dn0.GetFSDataset
().GetVolumes().Count];
// Lie to the NN that one block on each storage has been deleted.
for (int i = 0; i < reports.Length; ++i)
{
FsVolumeSpi volume = dn0.GetFSDataset().GetVolumes()[i];
bool foundBlockOnStorage = false;
ReceivedDeletedBlockInfo[] rdbi = new ReceivedDeletedBlockInfo[1];
// Find the first block on this storage and mark it as deleted for the
// report.
foreach (LocatedBlock block in blocks.GetLocatedBlocks())
{
if (block.GetStorageIDs()[0].Equals(volume.GetStorageID()))
{
rdbi[0] = new ReceivedDeletedBlockInfo(block.GetBlock().GetLocalBlock(), ReceivedDeletedBlockInfo.BlockStatus
.DeletedBlock, null);
foundBlockOnStorage = true;
break;
}
}
NUnit.Framework.Assert.IsTrue(foundBlockOnStorage);
reports[i] = new StorageReceivedDeletedBlocks(volume.GetStorageID(), rdbi);
if (splitReports)
{
// If we are splitting reports then send the report for this storage now.
StorageReceivedDeletedBlocks[] singletonReport = new StorageReceivedDeletedBlocks
[] { reports[i] };
cluster.GetNameNodeRpc().BlockReceivedAndDeleted(dn0Reg, poolId, singletonReport);
}
}
if (!splitReports)
{
// Send a combined report.
cluster.GetNameNodeRpc().BlockReceivedAndDeleted(dn0Reg, poolId, reports);
}
// Make sure that the deleted block from each storage was picked up
// by the NameNode.
Assert.AssertThat(cluster.GetNamesystem().GetMissingBlocksCount(), IS.Is((long)reports
.Length));
}
public virtual void TestErrorReplicas()
{
if (Log.IsDebugEnabled())
{
Log.Debug("Running " + GenericTestUtils.GetMethodName());
}
DataNode spyDN = Org.Mockito.Mockito.Spy(dn);
Org.Mockito.Mockito.DoThrow(new IOException()).When(spyDN).InitReplicaRecovery(Matchers.Any
<BlockRecoveryCommand.RecoveringBlock>());
Daemon d = spyDN.RecoverBlocks("fake NN", InitRecoveringBlocks());
d.Join();
Org.Mockito.Mockito.Verify(spyDN, Org.Mockito.Mockito.Never()).SyncBlock(Matchers.Any
<BlockRecoveryCommand.RecoveringBlock>(), Matchers.AnyListOf <DataNode.BlockRecord
>());
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="System.Exception"/>
private void DoShortCircuitReadAfterEvictionTest()
{
string MethodName = GenericTestUtils.GetMethodName();
Path path1 = new Path("/" + MethodName + ".01.dat");
Path path2 = new Path("/" + MethodName + ".02.dat");
int Seed = unchecked ((int)(0xFADED));
MakeRandomTestFile(path1, BlockSize, true, Seed);
// Verify short-circuit read from RAM_DISK.
EnsureFileReplicasOnStorageType(path1, StorageType.RamDisk);
FilePath metaFile = cluster.GetBlockMetadataFile(0, DFSTestUtil.GetFirstBlock(fs,
path1));
NUnit.Framework.Assert.IsTrue(metaFile.Length() <= BlockMetadataHeader.GetHeaderSize
());
NUnit.Framework.Assert.IsTrue(VerifyReadRandomFile(path1, BlockSize, Seed));
// Sleep for a short time to allow the lazy writer thread to do its job.
Sharpen.Thread.Sleep(3 * LazyWriterIntervalSec * 1000);
// Verify short-circuit read from RAM_DISK once again.
EnsureFileReplicasOnStorageType(path1, StorageType.RamDisk);
metaFile = cluster.GetBlockMetadataFile(0, DFSTestUtil.GetFirstBlock(fs, path1));
NUnit.Framework.Assert.IsTrue(metaFile.Length() <= BlockMetadataHeader.GetHeaderSize
());
NUnit.Framework.Assert.IsTrue(VerifyReadRandomFile(path1, BlockSize, Seed));
// Create another file with a replica on RAM_DISK, which evicts the first.
MakeRandomTestFile(path2, BlockSize, true, Seed);
Sharpen.Thread.Sleep(3 * LazyWriterIntervalSec * 1000);
TriggerBlockReport();
// Verify short-circuit read still works from DEFAULT storage. This time,
// we'll have a checksum written during lazy persistence.
EnsureFileReplicasOnStorageType(path1, StorageType.Default);
metaFile = cluster.GetBlockMetadataFile(0, DFSTestUtil.GetFirstBlock(fs, path1));
NUnit.Framework.Assert.IsTrue(metaFile.Length() > BlockMetadataHeader.GetHeaderSize
());
NUnit.Framework.Assert.IsTrue(VerifyReadRandomFile(path1, BlockSize, Seed));
// In the implementation of legacy short-circuit reads, any failure is
// trapped silently, reverts back to a remote read, and also disables all
// subsequent legacy short-circuit reads in the ClientContext. If the test
// uses legacy, then assert that it didn't get disabled.
ClientContext clientContext = client.GetClientContext();
if (clientContext.GetUseLegacyBlockReaderLocal())
{
NUnit.Framework.Assert.IsFalse(clientContext.GetDisableLegacyBlockReaderLocal());
}
}
public virtual void TestRamDiskNotChosenByDefault()
{
StartUpCluster(true, -1);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
try
{
MakeTestFile(path, BlockSize, false);
NUnit.Framework.Assert.Fail("Block placement to RAM_DISK should have failed without lazyPersist flag"
);
}
catch (Exception t)
{
Log.Info("Got expected exception ", t);
}
}
public virtual void TestPolicyPersistenceInFsImage()
{
StartUpCluster(false, -1);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
MakeTestFile(path, 0, true);
// checkpoint
fs.SetSafeMode(HdfsConstants.SafeModeAction.SafemodeEnter);
fs.SaveNamespace();
fs.SetSafeMode(HdfsConstants.SafeModeAction.SafemodeLeave);
cluster.RestartNameNode(true);
// Stat the file and check that the lazyPersist flag is returned back.
HdfsFileStatus status = client.GetFileInfo(path.ToString());
Assert.AssertThat(status.GetStoragePolicy(), IS.Is(LazyPersistPolicyId));
}
public virtual void TestDeleteBeforePersist()
{
StartUpCluster(true, -1);
string MethodName = GenericTestUtils.GetMethodName();
FsDatasetTestUtil.StopLazyWriter(cluster.GetDataNodes()[0]);
Path path = new Path("/" + MethodName + ".dat");
MakeTestFile(path, BlockSize, true);
LocatedBlocks locatedBlocks = EnsureFileReplicasOnStorageType(path, StorageType.RamDisk
);
// Delete before persist
client.Delete(path.ToString(), false);
NUnit.Framework.Assert.IsFalse(fs.Exists(path));
Assert.AssertThat(VerifyDeletedBlocks(locatedBlocks), IS.Is(true));
VerifyRamDiskJMXMetric("RamDiskBlocksDeletedBeforeLazyPersisted", 1);
}
public virtual void TestTruncateIsDenied()
{
StartUpCluster(true, -1);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
MakeTestFile(path, BlockSize, true);
try
{
client.Truncate(path.ToString(), BlockSize / 2);
NUnit.Framework.Assert.Fail("Truncate to LazyPersist file did not fail as expected"
);
}
catch (Exception t)
{
Log.Info("Got expected exception ", t);
}
}
public virtual void TestLazyPersistBlocksAreSaved()
{
StartUpCluster(true, -1);
string MethodName = GenericTestUtils.GetMethodName();
Path path = new Path("/" + MethodName + ".dat");
// Create a test file
MakeTestFile(path, BlockSize * 10, true);
LocatedBlocks locatedBlocks = EnsureFileReplicasOnStorageType(path, StorageType.RamDisk
);
// Sleep for a short time to allow the lazy writer thread to do its job
Sharpen.Thread.Sleep(6 * LazyWriterIntervalSec * 1000);
Log.Info("Verifying copy was saved to lazyPersist/");
// Make sure that there is a saved copy of the replica on persistent
// storage.
EnsureLazyPersistBlocksAreSaved(locatedBlocks);
}