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. "
));
}
}
private static void AssertEquals(ReplicaInfo originalInfo, ReplicaRecoveryInfo recoveryInfo
)
{
NUnit.Framework.Assert.AreEqual(originalInfo.GetBlockId(), recoveryInfo.GetBlockId
());
NUnit.Framework.Assert.AreEqual(originalInfo.GetGenerationStamp(), recoveryInfo.GetGenerationStamp
());
NUnit.Framework.Assert.AreEqual(originalInfo.GetBytesOnDisk(), recoveryInfo.GetNumBytes
());
NUnit.Framework.Assert.AreEqual(originalInfo.GetState(), recoveryInfo.GetOriginalReplicaState
());
}
public virtual void TestRBW_RWRReplicas()
{
if (Log.IsDebugEnabled())
{
Log.Debug("Running " + GenericTestUtils.GetMethodName());
}
ReplicaRecoveryInfo replica1 = new ReplicaRecoveryInfo(BlockId, ReplicaLen1, GenStamp
- 1, HdfsServerConstants.ReplicaState.Rbw);
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);
}
/// <summary>Sync two replicas</summary>
/// <exception cref="System.IO.IOException"/>
private void TestSyncReplicas(ReplicaRecoveryInfo replica1, ReplicaRecoveryInfo replica2
, InterDatanodeProtocol dn1, InterDatanodeProtocol dn2, long expectLen)
{
DatanodeInfo[] locs = new DatanodeInfo[] { Org.Mockito.Mockito.Mock <DatanodeInfo>
(), Org.Mockito.Mockito.Mock <DatanodeInfo>() };
BlockRecoveryCommand.RecoveringBlock rBlock = new BlockRecoveryCommand.RecoveringBlock
(block, locs, RecoveryId);
AList <DataNode.BlockRecord> syncList = new AList <DataNode.BlockRecord>(2);
DataNode.BlockRecord record1 = new DataNode.BlockRecord(DFSTestUtil.GetDatanodeInfo
("1.2.3.4", "bogus", 1234), dn1, replica1);
DataNode.BlockRecord record2 = new DataNode.BlockRecord(DFSTestUtil.GetDatanodeInfo
("1.2.3.4", "bogus", 1234), dn2, replica2);
syncList.AddItem(record1);
syncList.AddItem(record2);
Org.Mockito.Mockito.When(dn1.UpdateReplicaUnderRecovery((ExtendedBlock)Matchers.AnyObject
(), Matchers.AnyLong(), Matchers.AnyLong(), Matchers.AnyLong())).ThenReturn("storage1"
);
Org.Mockito.Mockito.When(dn2.UpdateReplicaUnderRecovery((ExtendedBlock)Matchers.AnyObject
(), Matchers.AnyLong(), Matchers.AnyLong(), Matchers.AnyLong())).ThenReturn("storage2"
);
dn.SyncBlock(rBlock, syncList);
}
public virtual void TestUpdateReplicaUnderRecovery()
{
MiniDFSCluster cluster = null;
try
{
cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(3).Build();
cluster.WaitActive();
string bpid = cluster.GetNamesystem().GetBlockPoolId();
//create a file
DistributedFileSystem dfs = cluster.GetFileSystem();
string filestr = "/foo";
Path filepath = new Path(filestr);
DFSTestUtil.CreateFile(dfs, filepath, 1024L, (short)3, 0L);
//get block info
LocatedBlock locatedblock = GetLastLocatedBlock(DFSClientAdapter.GetDFSClient(dfs
).GetNamenode(), filestr);
DatanodeInfo[] datanodeinfo = locatedblock.GetLocations();
NUnit.Framework.Assert.IsTrue(datanodeinfo.Length > 0);
//get DataNode and FSDataset objects
DataNode datanode = cluster.GetDataNode(datanodeinfo[0].GetIpcPort());
NUnit.Framework.Assert.IsTrue(datanode != null);
//initReplicaRecovery
ExtendedBlock b = locatedblock.GetBlock();
long recoveryid = b.GetGenerationStamp() + 1;
long newlength = b.GetNumBytes() - 1;
FsDatasetSpi <object> fsdataset = DataNodeTestUtils.GetFSDataset(datanode);
ReplicaRecoveryInfo rri = fsdataset.InitReplicaRecovery(new BlockRecoveryCommand.RecoveringBlock
(b, null, recoveryid));
//check replica
ReplicaInfo replica = FsDatasetTestUtil.FetchReplicaInfo(fsdataset, bpid, b.GetBlockId
());
NUnit.Framework.Assert.AreEqual(HdfsServerConstants.ReplicaState.Rur, replica.GetState
());
//check meta data before update
FsDatasetImpl.CheckReplicaFiles(replica);
{
//case "THIS IS NOT SUPPOSED TO HAPPEN"
//with (block length) != (stored replica's on disk length).
//create a block with same id and gs but different length.
ExtendedBlock tmp = new ExtendedBlock(b.GetBlockPoolId(), rri.GetBlockId(), rri.GetNumBytes
() - 1, rri.GetGenerationStamp());
try
{
//update should fail
fsdataset.UpdateReplicaUnderRecovery(tmp, recoveryid, tmp.GetBlockId(), newlength
);
NUnit.Framework.Assert.Fail();
}
catch (IOException ioe)
{
System.Console.Out.WriteLine("GOOD: getting " + ioe);
}
}
//update
string storageID = fsdataset.UpdateReplicaUnderRecovery(new ExtendedBlock(b.GetBlockPoolId
(), rri), recoveryid, rri.GetBlockId(), newlength);
NUnit.Framework.Assert.IsTrue(storageID != null);
}
finally
{
if (cluster != null)
{
cluster.Shutdown();
}
}
}
public virtual void TestInitReplicaRecovery()
{
long firstblockid = 10000L;
long gs = 7777L;
long length = 22L;
ReplicaMap map = new ReplicaMap(this);
string bpid = "BP-TEST";
Block[] blocks = new Block[5];
for (int i = 0; i < blocks.Length; i++)
{
blocks[i] = new Block(firstblockid + i, length, gs);
map.Add(bpid, CreateReplicaInfo(blocks[i]));
}
{
//normal case
Block b = blocks[0];
ReplicaInfo originalInfo = map.Get(bpid, b);
long recoveryid = gs + 1;
ReplicaRecoveryInfo recoveryInfo = FsDatasetImpl.InitReplicaRecovery(bpid, map, blocks
[0], recoveryid, DFSConfigKeys.DfsDatanodeXceiverStopTimeoutMillisDefault);
AssertEquals(originalInfo, recoveryInfo);
ReplicaUnderRecovery updatedInfo = (ReplicaUnderRecovery)map.Get(bpid, b);
NUnit.Framework.Assert.AreEqual(originalInfo.GetBlockId(), updatedInfo.GetBlockId
());
NUnit.Framework.Assert.AreEqual(recoveryid, updatedInfo.GetRecoveryID());
//recover one more time
long recoveryid2 = gs + 2;
ReplicaRecoveryInfo recoveryInfo2 = FsDatasetImpl.InitReplicaRecovery(bpid, map,
blocks[0], recoveryid2, DFSConfigKeys.DfsDatanodeXceiverStopTimeoutMillisDefault
);
AssertEquals(originalInfo, recoveryInfo2);
ReplicaUnderRecovery updatedInfo2 = (ReplicaUnderRecovery)map.Get(bpid, b);
NUnit.Framework.Assert.AreEqual(originalInfo.GetBlockId(), updatedInfo2.GetBlockId
());
NUnit.Framework.Assert.AreEqual(recoveryid2, updatedInfo2.GetRecoveryID());
//case RecoveryInProgressException
try
{
FsDatasetImpl.InitReplicaRecovery(bpid, map, b, recoveryid, DFSConfigKeys.DfsDatanodeXceiverStopTimeoutMillisDefault
);
NUnit.Framework.Assert.Fail();
}
catch (RecoveryInProgressException ripe)
{
System.Console.Out.WriteLine("GOOD: getting " + ripe);
}
}
{
// BlockRecoveryFI_01: replica not found
long recoveryid = gs + 1;
Block b = new Block(firstblockid - 1, length, gs);
ReplicaRecoveryInfo r = FsDatasetImpl.InitReplicaRecovery(bpid, map, b, recoveryid
, DFSConfigKeys.DfsDatanodeXceiverStopTimeoutMillisDefault);
NUnit.Framework.Assert.IsNull("Data-node should not have this replica.", r);
}
{
// BlockRecoveryFI_02: "THIS IS NOT SUPPOSED TO HAPPEN" with recovery id < gs
long recoveryid = gs - 1;
Block b = new Block(firstblockid + 1, length, gs);
try
{
FsDatasetImpl.InitReplicaRecovery(bpid, map, b, recoveryid, DFSConfigKeys.DfsDatanodeXceiverStopTimeoutMillisDefault
);
NUnit.Framework.Assert.Fail();
}
catch (IOException ioe)
{
System.Console.Out.WriteLine("GOOD: getting " + ioe);
}
}
{
// BlockRecoveryFI_03: Replica's gs is less than the block's gs
long recoveryid = gs + 1;
Block b = new Block(firstblockid, length, gs + 1);
try
{
FsDatasetImpl.InitReplicaRecovery(bpid, map, b, recoveryid, DFSConfigKeys.DfsDatanodeXceiverStopTimeoutMillisDefault
);
NUnit.Framework.Assert.Fail("InitReplicaRecovery should fail because replica's "
+ "gs is less than the block's gs");
}
catch (IOException e)
{
e.Message.StartsWith("replica.getGenerationStamp() < block.getGenerationStamp(), block="
);
}
}
}
