/// <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();
}
public override void FromInputStream(DataInputStream reader)
{
ProtocolVersion = reader.ReadInt();
HasDeviceGuid = reader.ReadBoolean();
if (HasDeviceGuid)
{
//We have a device GUID
DeviceGuid = Guid.Parse(reader.ReadUTF().ToUpper());
}
}
public void Invoke(HttpSessionState session, DataInputStream input)
{
_result = HttpProcessor.GetClient <AskServiceSoapClient>(session).SubmitQuestion(
input.ReadString(),
input.ReadString(),
input.ReadString(),
input.ReadInt32(),
input.ReadInt32(),
input.ReadStringArray(),
input.ReadInt32(),
input.ReadBoolean());
}
/* (non-Javadoc)
* @see org.gogpsproject.Streamable#write(java.io.DataOutputStream)
*/
public void read(DataInputStream dai, bool oldVersion)
{
int v = 1;
if (!oldVersion)
{
v = dai.ReadInt();
}
if (v == 1)
{
health = dai.ReadLong();
utcA1 = dai.ReadDouble();
utcA0 = dai.ReadDouble();
utcTOW = dai.ReadLong();
utcWNT = dai.ReadInt();
utcLS = dai.ReadInt();
utcWNF = dai.ReadInt();
utcDN = dai.ReadInt();
utcLSF = dai.ReadInt();
for (int i = 0; i < alpha.Count(); i++)
{
alpha[i] = dai.ReadFloat();
}
for (int i = 0; i < beta.Count(); i++)
{
beta[i] = dai.ReadFloat();
}
validHealth = dai.ReadBoolean();
validUTC = dai.ReadBoolean();
validKlobuchar = dai.ReadBoolean();
long l = dai.ReadLong();
refTime = new Time(l > 0 ? l : JavaSystem.CurrentTimeMillis());
}
else
{
throw new IOException("Unknown format version:" + v);
}
}
private static MetadataJavaField ReadJavaField(this DataInputStream stream)
{
var field = new MetadataJavaField
{
Name = stream.ReadUtfAndIntern(), Type = stream.ReadUtfAndIntern(),
AccessFlags = stream.ReadAccessFlagsParameter()
};
var hasConstantValue = stream.ReadBoolean();
if (hasConstantValue)
{
field.ConstantValue = stream.ReadArray(stream.ReadByte);
}
return(field);
}
protected internal virtual void Read(DataInputStream file)
{
try
{
int size = file.ReadInt();
index = new HashIndex <string>();
for (int i = 0; i < size; i++)
{
string tag = file.ReadUTF();
bool inClosed = file.ReadBoolean();
index.Add(tag);
if (inClosed)
{
closed.Add(tag);
}
}
}
catch (IOException e)
{
Sharpen.Runtime.PrintStackTrace(e);
}
}
/// <exception cref="System.IO.IOException"/>
private void ProcessFileDiff(DataInputStream @in, ImageVisitor v, string currentINodeName
)
{
int snapshotId = @in.ReadInt();
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotFileDiff, ImageVisitor.ImageElement
.SnapshotDiffSnapshotid, snapshotId);
v.Visit(ImageVisitor.ImageElement.SnapshotFileSize, @in.ReadLong());
if (@in.ReadBoolean())
{
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotInodeFileAttributes);
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.OptimizeSnapshotInodes,
imageVersion))
{
ProcessINodeFileAttributes(@in, v, currentINodeName);
}
else
{
ProcessINode(@in, v, true, currentINodeName, true);
}
v.LeaveEnclosingElement();
}
v.LeaveEnclosingElement();
}
public override void FromInputStream(DataInputStream reader)
{
Globals.status = reader.ReadBoolean();
Debug.WriteLine("RECEBIDO. " + Globals.status.ToString());
}
/// <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();
}
/* (non-Javadoc)
* @see ImageLoader#processImage(java.io.DataInputStream, ImageVisitor, boolean)
*/
/// <exception cref="System.IO.IOException"/>
public override void LoadImage(DataInputStream @in, ImageVisitor v, bool skipBlocks
)
{
bool done = false;
try
{
v.Start();
v.VisitEnclosingElement(ImageVisitor.ImageElement.FsImage);
imageVersion = @in.ReadInt();
if (!CanLoadVersion(imageVersion))
{
throw new IOException("Cannot process fslayout version " + imageVersion);
}
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.AddLayoutFlags, imageVersion
))
{
LayoutFlags.Read(@in);
}
v.Visit(ImageVisitor.ImageElement.ImageVersion, imageVersion);
v.Visit(ImageVisitor.ImageElement.NamespaceId, @in.ReadInt());
long numInodes = @in.ReadLong();
v.Visit(ImageVisitor.ImageElement.GenerationStamp, @in.ReadLong());
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.SequentialBlockId, imageVersion
))
{
v.Visit(ImageVisitor.ImageElement.GenerationStampV2, @in.ReadLong());
v.Visit(ImageVisitor.ImageElement.GenerationStampV1Limit, @in.ReadLong());
v.Visit(ImageVisitor.ImageElement.LastAllocatedBlockId, @in.ReadLong());
}
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.StoredTxids, imageVersion
))
{
v.Visit(ImageVisitor.ImageElement.TransactionId, @in.ReadLong());
}
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.AddInodeId, imageVersion
))
{
v.Visit(ImageVisitor.ImageElement.LastInodeId, @in.ReadLong());
}
bool supportSnapshot = NameNodeLayoutVersion.Supports(LayoutVersion.Feature.Snapshot
, imageVersion);
if (supportSnapshot)
{
v.Visit(ImageVisitor.ImageElement.SnapshotCounter, @in.ReadInt());
int numSnapshots = @in.ReadInt();
v.Visit(ImageVisitor.ImageElement.NumSnapshotsTotal, numSnapshots);
for (int i = 0; i < numSnapshots; i++)
{
ProcessSnapshot(@in, v);
}
}
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.FsimageCompression, imageVersion
))
{
bool isCompressed = @in.ReadBoolean();
v.Visit(ImageVisitor.ImageElement.IsCompressed, isCompressed.ToString());
if (isCompressed)
{
string codecClassName = Text.ReadString(@in);
v.Visit(ImageVisitor.ImageElement.CompressCodec, codecClassName);
CompressionCodecFactory codecFac = new CompressionCodecFactory(new Configuration(
));
CompressionCodec codec = codecFac.GetCodecByClassName(codecClassName);
if (codec == null)
{
throw new IOException("Image compression codec not supported: " + codecClassName);
}
@in = new DataInputStream(codec.CreateInputStream(@in));
}
}
ProcessINodes(@in, v, numInodes, skipBlocks, supportSnapshot);
subtreeMap.Clear();
dirNodeMap.Clear();
ProcessINodesUC(@in, v, skipBlocks);
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.DelegationToken, imageVersion
))
{
ProcessDelegationTokens(@in, v);
}
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.Caching, imageVersion))
{
ProcessCacheManagerState(@in, v);
}
v.LeaveEnclosingElement();
// FSImage
done = true;
}
finally
{
if (done)
{
v.Finish();
}
else
{
v.FinishAbnormally();
}
}
}
public bool FileReadBool()
{
return(InputStream.ReadBoolean());
}
