public virtual void TestClientSideException()
{
Configuration conf = new HdfsConfiguration();
MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(0).Build();
NNStorage mockStorage = Org.Mockito.Mockito.Mock <NNStorage>();
IList <FilePath> localPath = Collections.SingletonList(new FilePath("/xxxxx-does-not-exist/blah"
));
try
{
Uri fsName = DFSUtil.GetInfoServer(cluster.GetNameNode().GetServiceRpcAddress(),
conf, DFSUtil.GetHttpClientScheme(conf)).ToURL();
string id = "getimage=1&txid=0";
TransferFsImage.GetFileClient(fsName, id, localPath, mockStorage, false);
NUnit.Framework.Assert.Fail("Didn't get an exception!");
}
catch (IOException ioe)
{
Org.Mockito.Mockito.Verify(mockStorage).ReportErrorOnFile(localPath[0]);
NUnit.Framework.Assert.IsTrue("Unexpected exception: " + StringUtils.StringifyException
(ioe), ioe.Message.Contains("Unable to download to any storage"));
}
finally
{
cluster.Shutdown();
}
}
/// <summary>Test to verify the read timeout</summary>
/// <exception cref="System.Exception"/>
public virtual void TestGetImageTimeout()
{
HttpServer2 testServer = HttpServerFunctionalTest.CreateServer("hdfs");
try
{
testServer.AddServlet("ImageTransfer", ImageServlet.PathSpec, typeof(TestTransferFsImage.TestImageTransferServlet
));
testServer.Start();
Uri serverURL = HttpServerFunctionalTest.GetServerURL(testServer);
TransferFsImage.timeout = 2000;
try
{
TransferFsImage.GetFileClient(serverURL, "txid=1", null, null, false);
NUnit.Framework.Assert.Fail("TransferImage Should fail with timeout");
}
catch (SocketTimeoutException e)
{
NUnit.Framework.Assert.AreEqual("Read should timeout", "Read timed out", e.Message
);
}
}
finally
{
if (testServer != null)
{
testServer.Stop();
}
}
}
/// <exception cref="System.Exception"/>
public Void Run()
{
long txid = parsedParams.GetTxId();
NNStorage.NameNodeFile nnf = parsedParams.GetNameNodeFile();
if (!nnImage.AddToCheckpointing(txid))
{
response.SendError(HttpServletResponse.ScConflict, "Either current namenode is checkpointing or another"
+ " checkpointer is already in the process of " + "uploading a checkpoint made at transaction ID "
+ txid);
return(null);
}
try
{
if (nnImage.GetStorage().FindImageFile(nnf, txid) != null)
{
response.SendError(HttpServletResponse.ScConflict, "Either current namenode has checkpointed or "
+ "another checkpointer already uploaded an " + "checkpoint for txid " + txid);
return(null);
}
InputStream stream = request.GetInputStream();
try
{
long start = Time.MonotonicNow();
MD5Hash downloadImageDigest = TransferFsImage.HandleUploadImageRequest(request, txid
, nnImage.GetStorage(), stream, parsedParams.GetFileSize(), ImageServlet.GetThrottler
(conf));
nnImage.SaveDigestAndRenameCheckpointImage(nnf, txid, downloadImageDigest);
if (metrics != null)
{
long elapsed = Time.MonotonicNow() - start;
metrics.AddPutImage(elapsed);
}
nnImage.PurgeOldStorage(nnf);
}
finally
{
stream.Close();
}
}
finally
{
nnImage.RemoveFromCheckpointing(txid);
}
return(null);
}
/// <exception cref="System.IO.IOException"/>
private void ServeFile(FilePath file)
{
FileInputStream fis = new FileInputStream(file);
try
{
ImageServlet.SetVerificationHeadersForGet(response, file);
ImageServlet.SetFileNameHeaders(response, file);
if (!file.Exists())
{
throw new FileNotFoundException(file.ToString());
}
TransferFsImage.CopyFileToStream(response.GetOutputStream(), file, fis, ImageServlet
.GetThrottler(conf));
}
finally
{
IOUtils.CloseStream(fis);
}
}
/// <summary>Test to verify the timeout of Image upload</summary>
/// <exception cref="System.Exception"/>
public virtual void TestImageUploadTimeout()
{
Configuration conf = new HdfsConfiguration();
NNStorage mockStorage = Org.Mockito.Mockito.Mock <NNStorage>();
HttpServer2 testServer = HttpServerFunctionalTest.CreateServer("hdfs");
try
{
testServer.AddServlet("ImageTransfer", ImageServlet.PathSpec, typeof(TestTransferFsImage.TestImageTransferServlet
));
testServer.Start();
Uri serverURL = HttpServerFunctionalTest.GetServerURL(testServer);
// set the timeout here, otherwise it will take default.
TransferFsImage.timeout = 2000;
FilePath tmpDir = new FilePath(new FileSystemTestHelper().GetTestRootDir());
tmpDir.Mkdirs();
FilePath mockImageFile = FilePath.CreateTempFile("image", string.Empty, tmpDir);
FileOutputStream imageFile = new FileOutputStream(mockImageFile);
imageFile.Write(Sharpen.Runtime.GetBytesForString("data"));
imageFile.Close();
Org.Mockito.Mockito.When(mockStorage.FindImageFile(Org.Mockito.Mockito.Any <NNStorage.NameNodeFile
>(), Org.Mockito.Mockito.AnyLong())).ThenReturn(mockImageFile);
Org.Mockito.Mockito.When(mockStorage.ToColonSeparatedString()).ThenReturn("storage:info:string"
);
try
{
TransferFsImage.UploadImageFromStorage(serverURL, conf, mockStorage, NNStorage.NameNodeFile
.Image, 1L);
NUnit.Framework.Assert.Fail("TransferImage Should fail with timeout");
}
catch (SocketTimeoutException e)
{
NUnit.Framework.Assert.AreEqual("Upload should timeout", "Read timed out", e.Message
);
}
}
finally
{
testServer.Stop();
}
}
public virtual void TestClientSideExceptionOnJustOneDir()
{
Configuration conf = new HdfsConfiguration();
MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(0).Build();
NNStorage mockStorage = Org.Mockito.Mockito.Mock <NNStorage>();
IList <FilePath> localPaths = ImmutableList.Of(new FilePath("/xxxxx-does-not-exist/blah"
), new FilePath(TestDir, "testfile"));
try
{
Uri fsName = DFSUtil.GetInfoServer(cluster.GetNameNode().GetServiceRpcAddress(),
conf, DFSUtil.GetHttpClientScheme(conf)).ToURL();
string id = "getimage=1&txid=0";
TransferFsImage.GetFileClient(fsName, id, localPaths, mockStorage, false);
Org.Mockito.Mockito.Verify(mockStorage).ReportErrorOnFile(localPaths[0]);
NUnit.Framework.Assert.IsTrue("The valid local file should get saved properly", localPaths
[1].Length() > 0);
}
finally
{
cluster.Shutdown();
}
}
/// <exception cref="System.Exception"/>
public bool Run()
{
dstImage.GetStorage().cTime = sig.cTime;
if (sig.mostRecentCheckpointTxId == dstImage.GetStorage().GetMostRecentCheckpointTxId
())
{
Org.Apache.Hadoop.Hdfs.Server.Namenode.SecondaryNameNode.Log.Info("Image has not changed. Will not download image."
);
}
else
{
Org.Apache.Hadoop.Hdfs.Server.Namenode.SecondaryNameNode.Log.Info("Image has changed. Downloading updated image from NN."
);
MD5Hash downloadedHash = TransferFsImage.DownloadImageToStorage(nnHostPort, sig.mostRecentCheckpointTxId
, dstImage.GetStorage(), true);
dstImage.SaveDigestAndRenameCheckpointImage(NNStorage.NameNodeFile.Image, sig.mostRecentCheckpointTxId
, downloadedHash);
}
foreach (RemoteEditLog log in manifest.GetLogs())
{
TransferFsImage.DownloadEditsToStorage(nnHostPort, log, dstImage.GetStorage());
}
return(dstImage.GetLastAppliedTxId() < sig.mostRecentCheckpointTxId);
}
/// <summary>Create a new checkpoint</summary>
/// <exception cref="System.IO.IOException"/>
internal virtual void DoCheckpoint()
{
BackupImage bnImage = GetFSImage();
NNStorage bnStorage = bnImage.GetStorage();
long startTime = Time.MonotonicNow();
bnImage.FreezeNamespaceAtNextRoll();
NamenodeCommand cmd = GetRemoteNamenodeProxy().StartCheckpoint(backupNode.GetRegistration
());
CheckpointCommand cpCmd = null;
switch (cmd.GetAction())
{
case NamenodeProtocol.ActShutdown:
{
Shutdown();
throw new IOException("Name-node " + backupNode.nnRpcAddress + " requested shutdown."
);
}
case NamenodeProtocol.ActCheckpoint:
{
cpCmd = (CheckpointCommand)cmd;
break;
}
default:
{
throw new IOException("Unsupported NamenodeCommand: " + cmd.GetAction());
}
}
bnImage.WaitUntilNamespaceFrozen();
CheckpointSignature sig = cpCmd.GetSignature();
// Make sure we're talking to the same NN!
sig.ValidateStorageInfo(bnImage);
long lastApplied = bnImage.GetLastAppliedTxId();
Log.Debug("Doing checkpoint. Last applied: " + lastApplied);
RemoteEditLogManifest manifest = GetRemoteNamenodeProxy().GetEditLogManifest(bnImage
.GetLastAppliedTxId() + 1);
bool needReloadImage = false;
if (!manifest.GetLogs().IsEmpty())
{
RemoteEditLog firstRemoteLog = manifest.GetLogs()[0];
// we don't have enough logs to roll forward using only logs. Need
// to download and load the image.
if (firstRemoteLog.GetStartTxId() > lastApplied + 1)
{
Log.Info("Unable to roll forward using only logs. Downloading " + "image with txid "
+ sig.mostRecentCheckpointTxId);
MD5Hash downloadedHash = TransferFsImage.DownloadImageToStorage(backupNode.nnHttpAddress
, sig.mostRecentCheckpointTxId, bnStorage, true);
bnImage.SaveDigestAndRenameCheckpointImage(NNStorage.NameNodeFile.Image, sig.mostRecentCheckpointTxId
, downloadedHash);
lastApplied = sig.mostRecentCheckpointTxId;
needReloadImage = true;
}
if (firstRemoteLog.GetStartTxId() > lastApplied + 1)
{
throw new IOException("No logs to roll forward from " + lastApplied);
}
// get edits files
foreach (RemoteEditLog log in manifest.GetLogs())
{
TransferFsImage.DownloadEditsToStorage(backupNode.nnHttpAddress, log, bnStorage);
}
if (needReloadImage)
{
Log.Info("Loading image with txid " + sig.mostRecentCheckpointTxId);
FilePath file = bnStorage.FindImageFile(NNStorage.NameNodeFile.Image, sig.mostRecentCheckpointTxId
);
bnImage.ReloadFromImageFile(file, backupNode.GetNamesystem());
}
RollForwardByApplyingLogs(manifest, bnImage, backupNode.GetNamesystem());
}
long txid = bnImage.GetLastAppliedTxId();
backupNode.namesystem.WriteLock();
try
{
backupNode.namesystem.SetImageLoaded();
if (backupNode.namesystem.GetBlocksTotal() > 0)
{
backupNode.namesystem.SetBlockTotal();
}
bnImage.SaveFSImageInAllDirs(backupNode.GetNamesystem(), txid);
bnStorage.WriteAll();
}
finally
{
backupNode.namesystem.WriteUnlock();
}
if (cpCmd.NeedToReturnImage())
{
TransferFsImage.UploadImageFromStorage(backupNode.nnHttpAddress, conf, bnStorage,
NNStorage.NameNodeFile.Image, txid);
}
GetRemoteNamenodeProxy().EndCheckpoint(backupNode.GetRegistration(), sig);
if (backupNode.GetRole() == HdfsServerConstants.NamenodeRole.Backup)
{
bnImage.ConvergeJournalSpool();
}
backupNode.SetRegistration();
// keep registration up to date
long imageSize = bnImage.GetStorage().GetFsImageName(txid).Length();
Log.Info("Checkpoint completed in " + (Time.MonotonicNow() - startTime) / 1000 +
" seconds." + " New Image Size: " + imageSize);
}
public virtual bool DoCheckpoint()
{
checkpointImage.EnsureCurrentDirExists();
NNStorage dstStorage = checkpointImage.GetStorage();
// Tell the namenode to start logging transactions in a new edit file
// Returns a token that would be used to upload the merged image.
CheckpointSignature sig = namenode.RollEditLog();
bool loadImage = false;
bool isFreshCheckpointer = (checkpointImage.GetNamespaceID() == 0);
bool isSameCluster = (dstStorage.VersionSupportsFederation(NameNodeLayoutVersion.
Features) && sig.IsSameCluster(checkpointImage)) || (!dstStorage.VersionSupportsFederation
(NameNodeLayoutVersion.Features) && sig.NamespaceIdMatches(checkpointImage));
if (isFreshCheckpointer || (isSameCluster && !sig.StorageVersionMatches(checkpointImage
.GetStorage())))
{
// if we're a fresh 2NN, or if we're on the same cluster and our storage
// needs an upgrade, just take the storage info from the server.
dstStorage.SetStorageInfo(sig);
dstStorage.SetClusterID(sig.GetClusterID());
dstStorage.SetBlockPoolID(sig.GetBlockpoolID());
loadImage = true;
}
sig.ValidateStorageInfo(checkpointImage);
// error simulation code for junit test
CheckpointFaultInjector.GetInstance().AfterSecondaryCallsRollEditLog();
RemoteEditLogManifest manifest = namenode.GetEditLogManifest(sig.mostRecentCheckpointTxId
+ 1);
// Fetch fsimage and edits. Reload the image if previous merge failed.
loadImage |= DownloadCheckpointFiles(fsName, checkpointImage, sig, manifest) | checkpointImage
.HasMergeError();
try
{
DoMerge(sig, manifest, loadImage, checkpointImage, namesystem);
}
catch (IOException ioe)
{
// A merge error occurred. The in-memory file system state may be
// inconsistent, so the image and edits need to be reloaded.
checkpointImage.SetMergeError();
throw;
}
// Clear any error since merge was successful.
checkpointImage.ClearMergeError();
//
// Upload the new image into the NameNode. Then tell the Namenode
// to make this new uploaded image as the most current image.
//
long txid = checkpointImage.GetLastAppliedTxId();
TransferFsImage.UploadImageFromStorage(fsName, conf, dstStorage, NNStorage.NameNodeFile
.Image, txid);
// error simulation code for junit test
CheckpointFaultInjector.GetInstance().AfterSecondaryUploadsNewImage();
Log.Warn("Checkpoint done. New Image Size: " + dstStorage.GetFsImageName(txid).Length
());
if (legacyOivImageDir != null && !legacyOivImageDir.IsEmpty())
{
try
{
checkpointImage.SaveLegacyOIVImage(namesystem, legacyOivImageDir, new Canceler());
}
catch (IOException e)
{
Log.Warn("Failed to write legacy OIV image: ", e);
}
}
return(loadImage);
}
