/// <summary>
/// Find the corresponding snapshot whose deleted list contains the given
/// inode.
/// </summary>
/// <returns>
/// the id of the snapshot.
/// <see cref="Snapshot.NoSnapshotId"/>
/// if the
/// given inode is not in any of the snapshot.
/// </returns>
public virtual int FindSnapshotDeleted(INode child)
{
IList <DirectoryWithSnapshotFeature.DirectoryDiff> diffList = AsList();
for (int i = diffList.Count - 1; i >= 0; i--)
{
DirectoryWithSnapshotFeature.ChildrenDiff diff = diffList[i].diff;
int d = diff.SearchIndex(Diff.ListType.Deleted, child.GetLocalNameBytes());
if (d >= 0 && diff.GetList(Diff.ListType.Deleted)[d] == child)
{
return(diffList[i].GetSnapshotId());
}
}
return(Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot.NoSnapshotId);
}
/// <summary>
/// Recursively compute the difference between snapshots under a given
/// directory/file.
/// </summary>
/// <param name="snapshotRoot">The directory where snapshots were taken.</param>
/// <param name="node">The directory/file under which the diff is computed.</param>
/// <param name="parentPath">
/// Relative path (corresponding to the snapshot root) of
/// the node's parent.
/// </param>
/// <param name="diffReport">data structure used to store the diff.</param>
private void ComputeDiffRecursively(INodeDirectory snapshotRoot, INode node, IList
<byte[]> parentPath, SnapshotDiffInfo diffReport)
{
Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot earlierSnapshot = diffReport
.IsFromEarlier() ? diffReport.GetFrom() : diffReport.GetTo();
Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot laterSnapshot = diffReport
.IsFromEarlier() ? diffReport.GetTo() : diffReport.GetFrom();
byte[][] relativePath = Sharpen.Collections.ToArray(parentPath, new byte[parentPath
.Count][]);
if (node.IsDirectory())
{
DirectoryWithSnapshotFeature.ChildrenDiff diff = new DirectoryWithSnapshotFeature.ChildrenDiff
();
INodeDirectory dir = node.AsDirectory();
DirectoryWithSnapshotFeature sf = dir.GetDirectoryWithSnapshotFeature();
if (sf != null)
{
bool change = sf.ComputeDiffBetweenSnapshots(earlierSnapshot, laterSnapshot, diff
, dir);
if (change)
{
diffReport.AddDirDiff(dir, relativePath, diff);
}
}
ReadOnlyList <INode> children = dir.GetChildrenList(earlierSnapshot.GetId());
foreach (INode child in children)
{
byte[] name = child.GetLocalNameBytes();
bool toProcess = diff.SearchIndex(Diff.ListType.Deleted, name) < 0;
if (!toProcess && child is INodeReference.WithName)
{
byte[][] renameTargetPath = FindRenameTargetPath(snapshotRoot, (INodeReference.WithName
)child, laterSnapshot == null ? Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot
.CurrentStateId : laterSnapshot.GetId());
if (renameTargetPath != null)
{
toProcess = true;
diffReport.SetRenameTarget(child.GetId(), renameTargetPath);
}
}
if (toProcess)
{
parentPath.AddItem(name);
ComputeDiffRecursively(snapshotRoot, child, parentPath, diffReport);
parentPath.Remove(parentPath.Count - 1);
}
}
}
else
{
if (node.IsFile() && node.AsFile().IsWithSnapshot())
{
INodeFile file = node.AsFile();
bool change = file.GetFileWithSnapshotFeature().ChangedBetweenSnapshots(file, earlierSnapshot
, laterSnapshot);
if (change)
{
diffReport.AddFileDiff(file, relativePath);
}
}
}
}
