public virtual void SetupCluster()
{
Configuration conf = SetupCommonConfig();
// Dial down the retention of extra edits and checkpoints. This is to
// help catch regressions of HDFS-4238 (SBN should not purge shared edits)
conf.SetInt(DFSConfigKeys.DfsNamenodeNumCheckpointsRetainedKey, 1);
conf.SetInt(DFSConfigKeys.DfsNamenodeNumExtraEditsRetainedKey, 0);
int retryCount = 0;
while (true)
{
try
{
int basePort = 10060 + random.Next(100) * 2;
MiniDFSNNTopology topology = new MiniDFSNNTopology().AddNameservice(new MiniDFSNNTopology.NSConf
("ns1").AddNN(new MiniDFSNNTopology.NNConf("nn1").SetHttpPort(basePort)).AddNN(new
MiniDFSNNTopology.NNConf("nn2").SetHttpPort(basePort + 1)));
cluster = new MiniDFSCluster.Builder(conf).NnTopology(topology).NumDataNodes(1).Build
();
cluster.WaitActive();
nn0 = cluster.GetNameNode(0);
nn1 = cluster.GetNameNode(1);
fs = HATestUtil.ConfigureFailoverFs(cluster, conf);
cluster.TransitionToActive(0);
++retryCount;
break;
}
catch (BindException)
{
Log.Info("Set up MiniDFSCluster failed due to port conflicts, retry " + retryCount
+ " times");
}
}
}
public virtual void SetupCluster()
{
conf = new Configuration();
conf.SetInt(DFSConfigKeys.DfsHaTaileditsPeriodKey, 1);
HAUtil.SetAllowStandbyReads(conf, true);
fsHelper = new FileSystemTestHelper();
string testRoot = fsHelper.GetTestRootDir();
testRootDir = new FilePath(testRoot).GetAbsoluteFile();
conf.Set(DFSConfigKeys.DfsEncryptionKeyProviderUri, JavaKeyStoreProvider.SchemeName
+ "://file" + new Path(testRootDir.ToString(), "test.jks").ToUri());
cluster = new MiniDFSCluster.Builder(conf).NnTopology(MiniDFSNNTopology.SimpleHATopology
()).NumDataNodes(1).Build();
cluster.WaitActive();
cluster.TransitionToActive(0);
fs = (DistributedFileSystem)HATestUtil.ConfigureFailoverFs(cluster, conf);
DFSTestUtil.CreateKey(TestKey, cluster, 0, conf);
DFSTestUtil.CreateKey(TestKey, cluster, 1, conf);
nn0 = cluster.GetNameNode(0);
nn1 = cluster.GetNameNode(1);
dfsAdmin0 = new HdfsAdmin(cluster.GetURI(0), conf);
dfsAdmin1 = new HdfsAdmin(cluster.GetURI(1), conf);
KeyProviderCryptoExtension nn0Provider = cluster.GetNameNode(0).GetNamesystem().GetProvider
();
fs.GetClient().SetKeyProvider(nn0Provider);
}
/// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException"/>
/// <exception cref="System.IO.IOException"/>
/// <exception cref="Sharpen.URISyntaxException"/>
/// <exception cref="System.Exception"/>
private void AssertCanStartHANameNodes(MiniDFSCluster cluster, Configuration conf
, string path)
{
// Now should be able to start both NNs. Pass "false" here so that we don't
// try to waitActive on all NNs, since the second NN doesn't exist yet.
cluster.RestartNameNode(0, false);
cluster.RestartNameNode(1, true);
// Make sure HA is working.
cluster.GetNameNode(0).GetRpcServer().TransitionToActive(new HAServiceProtocol.StateChangeRequestInfo
(HAServiceProtocol.RequestSource.RequestByUser));
FileSystem fs = null;
try
{
Path newPath = new Path(path);
fs = HATestUtil.ConfigureFailoverFs(cluster, conf);
NUnit.Framework.Assert.IsTrue(fs.Mkdirs(newPath));
HATestUtil.WaitForStandbyToCatchUp(cluster.GetNameNode(0), cluster.GetNameNode(1)
);
NUnit.Framework.Assert.IsTrue(NameNodeAdapter.GetFileInfo(cluster.GetNameNode(1),
newPath.ToString(), false).IsDir());
}
finally
{
if (fs != null)
{
fs.Close();
}
}
}
/// <summary>Sets the required configurations for performing failover.</summary>
public static void SetFailoverConfigurations(MiniDFSCluster cluster, Configuration
conf, string logicalName, int nsIndex)
{
IPEndPoint nnAddr1 = cluster.GetNameNode(2 * nsIndex).GetNameNodeAddress();
IPEndPoint nnAddr2 = cluster.GetNameNode(2 * nsIndex + 1).GetNameNodeAddress();
SetFailoverConfigurations(conf, logicalName, nnAddr1, nnAddr2);
}
public virtual void TestSingleFailedEditsDirOnFlush()
{
NUnit.Framework.Assert.IsTrue(DoAnEdit());
// Invalidate one edits journal.
InvalidateEditsDirAtIndex(0, true, false);
// The NN has not terminated (no ExitException thrown)
NUnit.Framework.Assert.IsTrue(DoAnEdit());
// A single journal failure should not result in a call to terminate
NUnit.Framework.Assert.IsFalse(cluster.GetNameNode().IsInSafeMode());
}
/// <summary>
/// Test that, if there are no blocks in the filesystem,
/// the NameNode doesn't enter the "safemode extension" period.
/// </summary>
/// <exception cref="System.IO.IOException"/>
public virtual void TestNoExtensionIfNoBlocks()
{
cluster.GetConfiguration(0).SetInt(DFSConfigKeys.DfsNamenodeSafemodeExtensionKey,
60000);
cluster.RestartNameNode();
// Even though we have safemode extension set high, we should immediately
// exit safemode on startup because there are no blocks in the namespace.
string status = cluster.GetNameNode().GetNamesystem().GetSafemode();
NUnit.Framework.Assert.AreEqual(string.Empty, status);
}
/// <exception cref="System.IO.IOException"/>
private void StartCluster()
{
conf = new HdfsConfiguration();
conf.SetInt("dfs.blocksize", 1024 * 1024);
cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(ReplFactor).Build();
cluster.WaitActive();
fs = cluster.GetFileSystem();
nn = cluster.GetNameNode(0);
NUnit.Framework.Assert.IsNotNull(nn);
dn0 = cluster.GetDataNodes()[0];
NUnit.Framework.Assert.IsNotNull(dn0);
blockPoolId = cluster.GetNameNode(0).GetNamesystem().GetBlockPoolId();
}
/// <exception cref="System.IO.IOException"/>
private void RestartStandby()
{
cluster.ShutdownNameNode(1);
// Set the safemode extension to be lengthy, so that the tests
// can check the safemode message after the safemode conditions
// have been achieved, without being racy.
cluster.GetConfiguration(1).SetInt(DFSConfigKeys.DfsNamenodeSafemodeExtensionKey,
30000);
cluster.GetConfiguration(1).SetInt(DFSConfigKeys.DfsHaTaileditsPeriodKey, 1);
cluster.RestartNameNode(1);
nn1 = cluster.GetNameNode(1);
NUnit.Framework.Assert.AreEqual(nn1.GetNamesystem().GetTransactionsSinceLastLogRoll
(), 0L);
}
/// <summary>Signal the maps/reduces to start.</summary>
/// <exception cref="System.IO.IOException"/>
/// <exception cref="Sharpen.TimeoutException"/>
internal static void SignalTasks(MiniDFSCluster dfs, FileSystem fileSys, string mapSignalFile
, string reduceSignalFile, int replication)
{
try
{
WriteFile(dfs.GetNameNode(), fileSys.GetConf(), new Path(mapSignalFile), (short)replication
);
WriteFile(dfs.GetNameNode(), fileSys.GetConf(), new Path(reduceSignalFile), (short
)replication);
}
catch (Exception)
{
}
}
public virtual void SetupCluster()
{
Configuration conf = new Configuration();
conf.SetInt(DFSConfigKeys.DfsHaTaileditsPeriodKey, 1);
HAUtil.SetAllowStandbyReads(conf, true);
cluster = new MiniDFSCluster.Builder(conf).NnTopology(MiniDFSNNTopology.SimpleHATopology
()).NumDataNodes(1).WaitSafeMode(false).Build();
cluster.WaitActive();
nn0 = cluster.GetNameNode(0);
nn1 = cluster.GetNameNode(1);
fs = HATestUtil.ConfigureFailoverFs(cluster, conf);
cluster.TransitionToActive(0);
}
/// <exception cref="System.Exception"/>
private void TestUpgrade(TestBootstrapStandbyWithQJM.UpgradeState state)
{
cluster.TransitionToActive(0);
Configuration confNN1 = cluster.GetConfiguration(1);
FilePath current = cluster.GetNameNode(1).GetFSImage().GetStorage().GetStorageDir
(0).GetCurrentDir();
FilePath tmp = cluster.GetNameNode(1).GetFSImage().GetStorage().GetStorageDir(0).
GetPreviousTmp();
// shut down nn1
cluster.ShutdownNameNode(1);
// make NN0 in upgrade state
FSImage fsImage0 = cluster.GetNameNode(0).GetNamesystem().GetFSImage();
Whitebox.SetInternalState(fsImage0, "isUpgradeFinalized", false);
switch (state)
{
case TestBootstrapStandbyWithQJM.UpgradeState.Recover:
{
// rename the current directory to previous.tmp in nn1
NNStorage.Rename(current, tmp);
break;
}
case TestBootstrapStandbyWithQJM.UpgradeState.Format:
{
// rename the current directory to a random name so it's not formatted
FilePath wrongPath = new FilePath(current.GetParentFile(), "wrong");
NNStorage.Rename(current, wrongPath);
break;
}
default:
{
break;
}
}
int rc = BootstrapStandby.Run(new string[] { "-force" }, confNN1);
NUnit.Framework.Assert.AreEqual(0, rc);
// Should have copied over the namespace from the standby
FSImageTestUtil.AssertNNHasCheckpoints(cluster, 1, ImmutableList.Of(0));
FSImageTestUtil.AssertNNFilesMatch(cluster);
// make sure the NN1 is in upgrade state, i.e., the previous directory has
// been successfully created
cluster.RestartNameNode(1);
NUnit.Framework.Assert.IsFalse(cluster.GetNameNode(1).GetNamesystem().IsUpgradeFinalized
());
}
public virtual void SetUp()
{
cluster = new MiniDFSCluster.Builder(Conf).Build();
cluster.WaitActive();
cluster.GetNameNode();
fs = cluster.GetFileSystem();
}
public virtual void TestStorageReportHasStorageTypeAndState()
{
// Make sure we are not testing with the default type, that would not
// be a very good test.
NUnit.Framework.Assert.AreNotSame(storageType, StorageType.Default);
NameNode nn = cluster.GetNameNode();
DataNode dn = cluster.GetDataNodes()[0];
// Insert a spy object for the NN RPC.
DatanodeProtocolClientSideTranslatorPB nnSpy = DataNodeTestUtils.SpyOnBposToNN(dn
, nn);
// Trigger a heartbeat so there is an interaction with the spy
// object.
DataNodeTestUtils.TriggerHeartbeat(dn);
// Verify that the callback passed in the expected parameters.
ArgumentCaptor <StorageReport[]> captor = ArgumentCaptor.ForClass <StorageReport[]>
();
Org.Mockito.Mockito.Verify(nnSpy).SendHeartbeat(Matchers.Any <DatanodeRegistration
>(), captor.Capture(), Matchers.AnyLong(), Matchers.AnyLong(), Matchers.AnyInt()
, Matchers.AnyInt(), Matchers.AnyInt(), Org.Mockito.Mockito.Any <VolumeFailureSummary
>());
StorageReport[] reports = captor.GetValue();
foreach (StorageReport report in reports)
{
Assert.AssertThat(report.GetStorage().GetStorageType(), IS.Is(storageType));
Assert.AssertThat(report.GetStorage().GetState(), IS.Is(DatanodeStorage.State.Normal
));
}
}
public virtual void Test()
{
// make sure JT starts
Configuration jobConf = new JobConf(mrCluster.GetConfig());
// provide namenodes names for the job to get the delegation tokens for
//String nnUri = dfsCluster.getNameNode().getUri(namenode).toString();
NameNode nn = dfsCluster.GetNameNode();
URI nnUri = NameNode.GetUri(nn.GetNameNodeAddress());
jobConf.Set(JobContext.JobNamenodes, nnUri + "," + nnUri.ToString());
jobConf.Set("mapreduce.job.credentials.json", "keys.json");
// using argument to pass the file name
string[] args = new string[] { "-m", "1", "-r", "1", "-mt", "1", "-rt", "1" };
int res = -1;
try
{
res = ToolRunner.Run(jobConf, new CredentialsTestJob(), args);
}
catch (Exception e)
{
System.Console.Out.WriteLine("Job failed with" + e.GetLocalizedMessage());
Sharpen.Runtime.PrintStackTrace(e, System.Console.Out);
NUnit.Framework.Assert.Fail("Job failed");
}
NUnit.Framework.Assert.AreEqual("dist job res is not 0", res, 0);
}
public static void Setup()
{
string currentUser = Runtime.GetProperty("user.name");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(currentUser), "*");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(currentUser), "*");
ProxyUsers.RefreshSuperUserGroupsConfiguration(config);
cluster = new MiniDFSCluster.Builder(config).NumDataNodes(1).Build();
cluster.WaitActive();
hdfs = cluster.GetFileSystem();
nn = cluster.GetNameNode();
// Use emphral port in case tests are running in parallel
config.SetInt("nfs3.mountd.port", 0);
config.SetInt("nfs3.server.port", 0);
// Start nfs
Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3 nfs3 = new Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3
(config);
nfs3.StartServiceInternal(false);
nfsd = (RpcProgramNfs3)nfs3.GetRpcProgram();
securityHandler = Org.Mockito.Mockito.Mock <SecurityHandler>();
Org.Mockito.Mockito.When(securityHandler.GetUser()).ThenReturn(Runtime.GetProperty
("user.name"));
}
public static void SetUp()
{
conf = new Configuration();
conf.SetBoolean(DFSConfigKeys.DfsWebhdfsEnabledKey, true);
conf.Set(DFSConfigKeys.DfsHttpPolicyKey, HttpConfig.Policy.HttpsOnly.ToString());
conf.Set(DFSConfigKeys.DfsNamenodeHttpsAddressKey, "localhost:0");
conf.Set(DFSConfigKeys.DfsDatanodeHttpsAddressKey, "localhost:0");
FilePath @base = new FilePath(Basedir);
FileUtil.FullyDelete(@base);
@base.Mkdirs();
keystoresDir = new FilePath(Basedir).GetAbsolutePath();
sslConfDir = KeyStoreTestUtil.GetClasspathDir(typeof(TestHttpsFileSystem));
KeyStoreTestUtil.SetupSSLConfig(keystoresDir, sslConfDir, conf, false);
cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(1).Build();
cluster.WaitActive();
OutputStream os = cluster.GetFileSystem().Create(new Path("/test"));
os.Write(23);
os.Close();
IPEndPoint addr = cluster.GetNameNode().GetHttpsAddress();
nnAddr = NetUtils.GetHostPortString(addr);
conf.Set(DFSConfigKeys.DfsNamenodeHttpsAddressKey, nnAddr);
}
/* Helper function to create a key in the Key Provider. */
/// <exception cref="Sharpen.NoSuchAlgorithmException"/>
/// <exception cref="System.IO.IOException"/>
private void CreateAKey(string keyName, Configuration conf)
{
KeyProvider provider = dfsCluster.GetNameNode().GetNamesystem().GetProvider();
KeyProvider.Options options = KeyProvider.Options(conf);
provider.CreateKey(keyName, options);
provider.Flush();
}
public static void SetUp()
{
cluster = (new MiniDFSCluster.Builder(conf)).NumDataNodes(1).Build();
nnAddress = cluster.GetNameNode().GetNameNodeAddress();
DataNode dn = cluster.GetDataNodes()[0];
dnAddress = new IPEndPoint(dn.GetDatanodeId().GetIpAddr(), dn.GetIpcPort());
}
/// <exception cref="System.IO.IOException"/>
internal static void CheckPath(MiniDFSCluster cluster, FileSystem fileSys)
{
IPEndPoint add = cluster.GetNameNode().GetNameNodeAddress();
// Test upper/lower case
fileSys.CheckPath(new Path("hdfs://" + StringUtils.ToUpperCase(add.GetHostName())
+ ":" + add.Port));
}
public virtual void SetupCluster()
{
SecurityUtilTestHelper.SetTokenServiceUseIp(true);
conf.SetBoolean(DFSConfigKeys.DfsNamenodeDelegationTokenAlwaysUseKey, true);
conf.Set(CommonConfigurationKeysPublic.HadoopSecurityAuthToLocal, "RULE:[2:$1@$0](JobTracker@.*FOO.COM)s/@.*//"
+ "DEFAULT");
cluster = new MiniDFSCluster.Builder(conf).NnTopology(MiniDFSNNTopology.SimpleHATopology
()).NumDataNodes(0).Build();
cluster.WaitActive();
string logicalName = HATestUtil.GetLogicalHostname(cluster);
HATestUtil.SetFailoverConfigurations(cluster, conf, logicalName, 0);
nn0 = cluster.GetNameNode(0);
nn1 = cluster.GetNameNode(1);
fs = HATestUtil.ConfigureFailoverFs(cluster, conf);
dfs = (DistributedFileSystem)fs;
cluster.TransitionToActive(0);
dtSecretManager = NameNodeAdapter.GetDtSecretManager(nn0.GetNamesystem());
}
/// <exception cref="System.IO.IOException"/>
internal Suite(MiniDFSCluster cluster, int nNameNodes, int nDataNodes)
{
this.cluster = cluster;
clients = new ClientProtocol[nNameNodes];
for (int i = 0; i < nNameNodes; i++)
{
clients[i] = cluster.GetNameNode(i).GetRpcServer();
}
replication = (short)Math.Max(1, nDataNodes - 1);
}
public virtual void TestReplicationError()
{
// create a file of replication factor of 1
Path fileName = new Path("/test.txt");
int fileLen = 1;
DFSTestUtil.CreateFile(fs, fileName, 1, (short)1, 1L);
DFSTestUtil.WaitReplication(fs, fileName, (short)1);
// get the block belonged to the created file
LocatedBlocks blocks = NameNodeAdapter.GetBlockLocations(cluster.GetNameNode(), fileName
.ToString(), 0, (long)fileLen);
NUnit.Framework.Assert.AreEqual("Should only find 1 block", blocks.LocatedBlockCount
(), 1);
LocatedBlock block = blocks.Get(0);
// bring up a second datanode
cluster.StartDataNodes(conf, 1, true, null, null);
cluster.WaitActive();
int sndNode = 1;
DataNode datanode = cluster.GetDataNodes()[sndNode];
// replicate the block to the second datanode
IPEndPoint target = datanode.GetXferAddress();
Socket s = Sharpen.Extensions.CreateSocket(target.Address, target.Port);
// write the header.
DataOutputStream @out = new DataOutputStream(s.GetOutputStream());
DataChecksum checksum = DataChecksum.NewDataChecksum(DataChecksum.Type.Crc32, 512
);
new Sender(@out).WriteBlock(block.GetBlock(), StorageType.Default, BlockTokenSecretManager
.DummyToken, string.Empty, new DatanodeInfo[0], new StorageType[0], null, BlockConstructionStage
.PipelineSetupCreate, 1, 0L, 0L, 0L, checksum, CachingStrategy.NewDefaultStrategy
(), false, false, null);
@out.Flush();
// close the connection before sending the content of the block
@out.Close();
// the temporary block & meta files should be deleted
string bpid = cluster.GetNamesystem().GetBlockPoolId();
FilePath storageDir = cluster.GetInstanceStorageDir(sndNode, 0);
FilePath dir1 = MiniDFSCluster.GetRbwDir(storageDir, bpid);
storageDir = cluster.GetInstanceStorageDir(sndNode, 1);
FilePath dir2 = MiniDFSCluster.GetRbwDir(storageDir, bpid);
while (dir1.ListFiles().Length != 0 || dir2.ListFiles().Length != 0)
{
Sharpen.Thread.Sleep(100);
}
// then increase the file's replication factor
fs.SetReplication(fileName, (short)2);
// replication should succeed
DFSTestUtil.WaitReplication(fs, fileName, (short)1);
// clean up the file
fs.Delete(fileName, false);
}
public virtual void StartCluster()
{
conf = new HdfsConfiguration();
cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(DnCount).Build();
fs = cluster.GetFileSystem();
singletonNn = cluster.GetNameNode();
singletonDn = cluster.GetDataNodes()[0];
bpos = singletonDn.GetAllBpOs()[0];
actor = bpos.GetBPServiceActors()[0];
storageUuid = singletonDn.GetFSDataset().GetVolumes()[0].GetStorageID();
}
public virtual void Setup()
{
conf = new HdfsConfiguration();
conf.SetLong(DFSConfigKeys.DfsBlockSizeKey, BlockSize);
conf.SetBoolean(DFSConfigKeys.DfsNamenodeEnableRetryCacheKey, true);
conf.SetBoolean(DFSConfigKeys.DfsNamenodeAclsEnabledKey, true);
cluster = new MiniDFSCluster.Builder(conf).Build();
cluster.WaitActive();
nnRpc = cluster.GetNameNode().GetRpcServer();
filesystem = cluster.GetFileSystem();
}
private int GetBlockCount()
{
NUnit.Framework.Assert.IsNotNull("Null cluster", mc);
NUnit.Framework.Assert.IsNotNull("No Namenode in cluster", mc.GetNameNode());
FSNamesystem namesystem = mc.GetNamesystem();
NUnit.Framework.Assert.IsNotNull("Null Namesystem in cluster", namesystem);
NUnit.Framework.Assert.IsNotNull("Null Namesystem.blockmanager", namesystem.GetBlockManager
());
return((int)namesystem.GetBlocksTotal());
}
/// <summary>Restart the cluster, optionally saving a new checkpoint.</summary>
/// <param name="checkpoint">boolean true to save a new checkpoint</param>
/// <param name="aclsEnabled">if true, ACL support is enabled</param>
/// <exception cref="System.Exception">if restart fails</exception>
private void Restart(bool checkpoint, bool aclsEnabled)
{
NameNode nameNode = cluster.GetNameNode();
if (checkpoint)
{
NameNodeAdapter.EnterSafeMode(nameNode, false);
NameNodeAdapter.SaveNamespace(nameNode);
}
Shutdown();
InitCluster(false, aclsEnabled);
}
public virtual void TestStaleNodes()
{
// Set two datanodes as stale
for (int i = 0; i < 2; i++)
{
DataNode dn = cluster.GetDataNodes()[i];
DataNodeTestUtils.SetHeartbeatsDisabledForTests(dn, true);
long staleInterval = Conf.GetLong(DFSConfigKeys.DfsNamenodeStaleDatanodeIntervalKey
, DFSConfigKeys.DfsNamenodeStaleDatanodeIntervalDefault);
DatanodeDescriptor dnDes = cluster.GetNameNode().GetNamesystem().GetBlockManager(
).GetDatanodeManager().GetDatanode(dn.GetDatanodeId());
DFSTestUtil.ResetLastUpdatesWithOffset(dnDes, -(staleInterval + 1));
}
// Let HeartbeatManager to check heartbeat
BlockManagerTestUtil.CheckHeartbeat(cluster.GetNameNode().GetNamesystem().GetBlockManager
());
MetricsAsserts.AssertGauge("StaleDataNodes", 2, MetricsAsserts.GetMetrics(NsMetrics
));
// Reset stale datanodes
for (int i_1 = 0; i_1 < 2; i_1++)
{
DataNode dn = cluster.GetDataNodes()[i_1];
DataNodeTestUtils.SetHeartbeatsDisabledForTests(dn, false);
DatanodeDescriptor dnDes = cluster.GetNameNode().GetNamesystem().GetBlockManager(
).GetDatanodeManager().GetDatanode(dn.GetDatanodeId());
DFSTestUtil.ResetLastUpdatesWithOffset(dnDes, 0);
}
// Let HeartbeatManager to refresh
BlockManagerTestUtil.CheckHeartbeat(cluster.GetNameNode().GetNamesystem().GetBlockManager
());
MetricsAsserts.AssertGauge("StaleDataNodes", 0, MetricsAsserts.GetMetrics(NsMetrics
));
}
/// <summary>Get edits filename</summary>
/// <returns>edits file name for cluster</returns>
/// <exception cref="System.IO.IOException"/>
private string GetEditsFilename(CheckpointSignature sig)
{
FSImage image = cluster.GetNameNode().GetFSImage();
// it was set up to only have ONE StorageDirectory
IEnumerator <Storage.StorageDirectory> it = image.GetStorage().DirIterator(NNStorage.NameNodeDirType
.Edits);
Storage.StorageDirectory sd = it.Next();
FilePath ret = NNStorage.GetFinalizedEditsFile(sd, 1, sig.curSegmentTxId - 1);
System.Diagnostics.Debug.Assert(ret.Exists(), "expected " + ret + " exists");
return(ret.GetAbsolutePath());
}
private void AddCrmThreads(MiniDFSCluster cluster, List <Sharpen.Thread> crmThreads
)
{
for (int nn = 0; nn <= 1; nn++)
{
Sharpen.Thread thread = cluster.GetNameNode(nn).GetNamesystem().GetCacheManager()
.GetCacheReplicationMonitor();
if (thread != null)
{
crmThreads.AddItem(thread);
}
}
}
public virtual void TestWithCheckpoint()
{
Path path = new Path("/test");
DoWriteAndAbort(fs, path);
fs.Delete(new Path("/test/test"), true);
NameNode nameNode = cluster.GetNameNode();
NameNodeAdapter.EnterSafeMode(nameNode, false);
NameNodeAdapter.SaveNamespace(nameNode);
NameNodeAdapter.LeaveSafeMode(nameNode);
cluster.RestartNameNode(true);
// read snapshot file after restart
string test2snapshotPath = Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot
.GetSnapshotPath(path.ToString(), "s1/test/test2");
DFSTestUtil.ReadFile(fs, new Path(test2snapshotPath));
string test3snapshotPath = Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot
.GetSnapshotPath(path.ToString(), "s1/test/test3");
DFSTestUtil.ReadFile(fs, new Path(test3snapshotPath));
}