/// <exception cref="System.IO.IOException"/>
private int ProcessDirectory(DataInputStream @in, ImageVisitor v, bool skipBlocks
)
{
string parentName = FSImageSerialization.ReadString(@in);
return(ProcessChildren(@in, v, skipBlocks, parentName));
}
/// <exception cref="System.IO.IOException"/>
private void ProcessDirectoryDiff(DataInputStream @in, ImageVisitor v, string currentINodeName
)
{
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotDirDiff);
int snapshotId = @in.ReadInt();
v.Visit(ImageVisitor.ImageElement.SnapshotDiffSnapshotid, snapshotId);
v.Visit(ImageVisitor.ImageElement.SnapshotDirDiffChildrenSize, @in.ReadInt());
// process snapshotINode
bool useRoot = @in.ReadBoolean();
if (!useRoot)
{
if (@in.ReadBoolean())
{
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotInodeDirectoryAttributes
);
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.OptimizeSnapshotInodes,
imageVersion))
{
ProcessINodeDirectoryAttributes(@in, v, currentINodeName);
}
else
{
ProcessINode(@in, v, true, currentINodeName, true);
}
v.LeaveEnclosingElement();
}
}
// process createdList
int createdSize = @in.ReadInt();
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotDirDiffCreatedlist, ImageVisitor.ImageElement
.SnapshotDirDiffCreatedlistSize, createdSize);
for (int i = 0; i < createdSize; i++)
{
string createdNode = FSImageSerialization.ReadString(@in);
v.Visit(ImageVisitor.ImageElement.SnapshotDirDiffCreatedInode, createdNode);
}
v.LeaveEnclosingElement();
// process deletedList
int deletedSize = @in.ReadInt();
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotDirDiffDeletedlist, ImageVisitor.ImageElement
.SnapshotDirDiffDeletedlistSize, deletedSize);
for (int i_1 = 0; i_1 < deletedSize; i_1++)
{
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotDirDiffDeletedInode);
ProcessINode(@in, v, false, currentINodeName, true);
v.LeaveEnclosingElement();
}
v.LeaveEnclosingElement();
v.LeaveEnclosingElement();
}
/// <summary>
/// Serialize
/// <see cref="#deleted"/>
///
/// </summary>
/// <exception cref="System.IO.IOException"/>
private void WriteDeleted(DataOutput @out, SnapshotFSImageFormat.ReferenceMap referenceMap
)
{
IList <INode> deleted = GetList(Diff.ListType.Deleted);
@out.WriteInt(deleted.Count);
foreach (INode node in deleted)
{
FSImageSerialization.SaveINode2Image(node, @out, true, referenceMap);
}
}
/// <summary>Load the created list from fsimage.</summary>
/// <param name="parent">The directory that the created list belongs to.</param>
/// <param name="in">
/// The
/// <see cref="System.IO.DataInput"/>
/// to read.
/// </param>
/// <returns>The created list.</returns>
/// <exception cref="System.IO.IOException"/>
private static IList <INode> LoadCreatedList(INodeDirectory parent, DataInput @in)
{
// read the size of the created list
int createdSize = @in.ReadInt();
IList <INode> createdList = new AList <INode>(createdSize);
for (int i = 0; i < createdSize; i++)
{
byte[] createdNodeName = FSImageSerialization.ReadLocalName(@in);
INode created = LoadCreated(createdNodeName, parent);
createdList.AddItem(created);
}
return(createdList);
}
// DELEGATION_TOKENS
/// <summary>Process the INodes under construction section of the fsimage.</summary>
/// <param name="in">DataInputStream to process</param>
/// <param name="v">Visitor to walk over inodes</param>
/// <param name="skipBlocks">Walk over each block?</param>
/// <exception cref="System.IO.IOException"/>
private void ProcessINodesUC(DataInputStream @in, ImageVisitor v, bool skipBlocks
)
{
int numINUC = @in.ReadInt();
v.VisitEnclosingElement(ImageVisitor.ImageElement.InodesUnderConstruction, ImageVisitor.ImageElement
.NumInodesUnderConstruction, numINUC);
for (int i = 0; i < numINUC; i++)
{
v.VisitEnclosingElement(ImageVisitor.ImageElement.InodeUnderConstruction);
byte[] name = FSImageSerialization.ReadBytes(@in);
string n = Sharpen.Runtime.GetStringForBytes(name, "UTF8");
v.Visit(ImageVisitor.ImageElement.InodePath, n);
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.AddInodeId, imageVersion
))
{
long inodeId = @in.ReadLong();
v.Visit(ImageVisitor.ImageElement.InodeId, inodeId);
}
v.Visit(ImageVisitor.ImageElement.Replication, @in.ReadShort());
v.Visit(ImageVisitor.ImageElement.ModificationTime, FormatDate(@in.ReadLong()));
v.Visit(ImageVisitor.ImageElement.PreferredBlockSize, @in.ReadLong());
int numBlocks = @in.ReadInt();
ProcessBlocks(@in, v, numBlocks, skipBlocks);
ProcessPermission(@in, v);
v.Visit(ImageVisitor.ImageElement.ClientName, FSImageSerialization.ReadString(@in
));
v.Visit(ImageVisitor.ImageElement.ClientMachine, FSImageSerialization.ReadString(
@in));
// Skip over the datanode descriptors, which are still stored in the
// file but are not used by the datanode or loaded into memory
int numLocs = @in.ReadInt();
for (int j = 0; j < numLocs; j++)
{
@in.ReadShort();
@in.ReadLong();
@in.ReadLong();
@in.ReadLong();
@in.ReadInt();
FSImageSerialization.ReadString(@in);
FSImageSerialization.ReadString(@in);
WritableUtils.ReadEnum <DatanodeInfo.AdminStates>(@in);
}
v.LeaveEnclosingElement();
}
// INodeUnderConstruction
v.LeaveEnclosingElement();
}
/// <exception cref="System.IO.IOException"/>
private string ReadINodePath(DataInputStream @in, string parentName)
{
string pathName = FSImageSerialization.ReadString(@in);
if (parentName != null)
{
// local name
pathName = "/" + pathName;
if (!"/".Equals(parentName))
{
// children of non-root directory
pathName = parentName + pathName;
}
}
return(pathName);
}
/// <exception cref="System.IO.IOException"/>
internal override void Write(DataOutput @out, SnapshotFSImageFormat.ReferenceMap
referenceMap)
{
WriteSnapshot(@out);
@out.WriteLong(fileSize);
// write snapshotINode
if (snapshotINode != null)
{
@out.WriteBoolean(true);
FSImageSerialization.WriteINodeFileAttributes(snapshotINode, @out);
}
else
{
@out.WriteBoolean(false);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void WriteINodeReferenceWithCount(INodeReference.WithCount withCount
, DataOutput @out, bool writeUnderConstruction)
{
INode referred = withCount.GetReferredINode();
long id = withCount.GetId();
bool firstReferred = !referenceMap.Contains(id);
@out.WriteBoolean(firstReferred);
if (firstReferred)
{
FSImageSerialization.SaveINode2Image(referred, @out, writeUnderConstruction, this
);
referenceMap[id] = withCount;
}
else
{
@out.WriteLong(id);
}
}
/// <exception cref="System.IO.IOException"/>
internal override void Write(DataOutput @out, SnapshotFSImageFormat.ReferenceMap
referenceMap)
{
WriteSnapshot(@out);
@out.WriteInt(childrenSize);
// Write snapshotINode
@out.WriteBoolean(isSnapshotRoot);
if (!isSnapshotRoot)
{
if (snapshotINode != null)
{
@out.WriteBoolean(true);
FSImageSerialization.WriteINodeDirectoryAttributes(snapshotINode, @out);
}
else
{
@out.WriteBoolean(false);
}
}
// Write diff. Node need to write poseriorDiff, since diffs is a list.
diff.Write(@out, referenceMap);
}
/// <summary>Serialize the fields to out</summary>
/// <exception cref="System.IO.IOException"/>
internal virtual void Write(DataOutput @out)
{
@out.WriteInt(id);
// write root
FSImageSerialization.WriteINodeDirectory(root, @out);
}
/// <summary>Process an INode</summary>
/// <param name="in">image stream</param>
/// <param name="v">visitor</param>
/// <param name="skipBlocks">skip blocks or not</param>
/// <param name="parentName">the name of its parent node</param>
/// <param name="isSnapshotCopy">whether or not the inode is a snapshot copy</param>
/// <exception cref="System.IO.IOException"/>
private void ProcessINode(DataInputStream @in, ImageVisitor v, bool skipBlocks, string
parentName, bool isSnapshotCopy)
{
bool supportSnapshot = NameNodeLayoutVersion.Supports(LayoutVersion.Feature.Snapshot
, imageVersion);
bool supportInodeId = NameNodeLayoutVersion.Supports(LayoutVersion.Feature.AddInodeId
, imageVersion);
v.VisitEnclosingElement(ImageVisitor.ImageElement.Inode);
string pathName = ReadINodePath(@in, parentName);
v.Visit(ImageVisitor.ImageElement.InodePath, pathName);
long inodeId = INodeId.GrandfatherInodeId;
if (supportInodeId)
{
inodeId = @in.ReadLong();
v.Visit(ImageVisitor.ImageElement.InodeId, inodeId);
}
v.Visit(ImageVisitor.ImageElement.Replication, @in.ReadShort());
v.Visit(ImageVisitor.ImageElement.ModificationTime, FormatDate(@in.ReadLong()));
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.FileAccessTime, imageVersion
))
{
v.Visit(ImageVisitor.ImageElement.AccessTime, FormatDate(@in.ReadLong()));
}
v.Visit(ImageVisitor.ImageElement.BlockSize, @in.ReadLong());
int numBlocks = @in.ReadInt();
ProcessBlocks(@in, v, numBlocks, skipBlocks);
if (numBlocks >= 0)
{
// File
if (supportSnapshot)
{
// make sure subtreeMap only contains entry for directory
Sharpen.Collections.Remove(subtreeMap, inodeId);
// process file diffs
ProcessFileDiffList(@in, v, parentName);
if (isSnapshotCopy)
{
bool underConstruction = @in.ReadBoolean();
if (underConstruction)
{
v.Visit(ImageVisitor.ImageElement.ClientName, FSImageSerialization.ReadString(@in
));
v.Visit(ImageVisitor.ImageElement.ClientMachine, FSImageSerialization.ReadString(
@in));
}
}
}
ProcessPermission(@in, v);
}
else
{
if (numBlocks == -1)
{
// Directory
if (supportSnapshot && supportInodeId)
{
dirNodeMap[inodeId] = pathName;
}
v.Visit(ImageVisitor.ImageElement.NsQuota, numBlocks == -1 ? @in.ReadLong() : -1);
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.DiskspaceQuota, imageVersion
))
{
v.Visit(ImageVisitor.ImageElement.DsQuota, numBlocks == -1 ? @in.ReadLong() : -1);
}
if (supportSnapshot)
{
bool snapshottable = @in.ReadBoolean();
if (!snapshottable)
{
bool withSnapshot = @in.ReadBoolean();
v.Visit(ImageVisitor.ImageElement.IsWithsnapshotDir, bool.ToString(withSnapshot));
}
else
{
v.Visit(ImageVisitor.ImageElement.IsSnapshottableDir, bool.ToString(snapshottable
));
}
}
ProcessPermission(@in, v);
}
else
{
if (numBlocks == -2)
{
v.Visit(ImageVisitor.ImageElement.Symlink, Text.ReadString(@in));
ProcessPermission(@in, v);
}
else
{
if (numBlocks == -3)
{
// reference node
bool isWithName = @in.ReadBoolean();
int snapshotId = @in.ReadInt();
if (isWithName)
{
v.Visit(ImageVisitor.ImageElement.SnapshotLastSnapshotId, snapshotId);
}
else
{
v.Visit(ImageVisitor.ImageElement.SnapshotDstSnapshotId, snapshotId);
}
bool firstReferred = @in.ReadBoolean();
if (firstReferred)
{
// if a subtree is linked by multiple "parents", the corresponding dir
// must be referred by a reference node. we put the reference node into
// the subtreeMap here and let its value be false. when we later visit
// the subtree for the first time, we change the value to true.
subtreeMap[inodeId] = false;
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotRefInode);
ProcessINode(@in, v, skipBlocks, parentName, isSnapshotCopy);
v.LeaveEnclosingElement();
}
else
{
// referred inode
v.Visit(ImageVisitor.ImageElement.SnapshotRefInodeId, @in.ReadLong());
}
}
}
}
}
v.LeaveEnclosingElement();
}
