///////////////////////////////////////
// Writable
///////////////////////////////////////
/// <exception cref="System.IO.IOException"/>
public virtual void Write(DataOutput @out)
{
lock (this)
{
jobid.Write(@out);
@out.WriteFloat(setupProgress);
@out.WriteFloat(mapProgress);
@out.WriteFloat(reduceProgress);
@out.WriteFloat(cleanupProgress);
WritableUtils.WriteEnum(@out, runState);
@out.WriteLong(startTime);
Text.WriteString(@out, user);
WritableUtils.WriteEnum(@out, priority);
Text.WriteString(@out, schedulingInfo);
@out.WriteLong(finishTime);
@out.WriteBoolean(isRetired);
Text.WriteString(@out, historyFile);
Text.WriteString(@out, jobName);
Text.WriteString(@out, trackingUrl);
Text.WriteString(@out, jobFile);
@out.WriteBoolean(isUber);
// Serialize the job's ACLs
@out.WriteInt(jobACLs.Count);
foreach (KeyValuePair <JobACL, AccessControlList> entry in jobACLs)
{
WritableUtils.WriteEnum(@out, entry.Key);
entry.Value.Write(@out);
}
}
}
/// <summary>
/// Serialize a
/// <see cref="INodeDirectory"/>
/// </summary>
/// <param name="node">The node to write</param>
/// <param name="out">
/// The
/// <see cref="System.IO.DataOutput"/>
/// where the fields are written
/// </param>
/// <exception cref="System.IO.IOException"/>
public static void WriteINodeDirectory(INodeDirectory node, DataOutput @out)
{
WriteLocalName(node, @out);
@out.WriteLong(node.GetId());
@out.WriteShort(0);
// replication
@out.WriteLong(node.GetModificationTime());
@out.WriteLong(0);
// access time
@out.WriteLong(0);
// preferred block size
@out.WriteInt(-1);
// # of blocks
WriteQuota(node.GetQuotaCounts(), @out);
if (node.IsSnapshottable())
{
@out.WriteBoolean(true);
}
else
{
@out.WriteBoolean(false);
@out.WriteBoolean(node.IsWithSnapshot());
}
WritePermissionStatus(node, @out);
}
// do not store locations of last block
/// <summary>
/// Serialize a
/// <see cref="INodeFile"/>
/// node
/// </summary>
/// <param name="node">The node to write</param>
/// <param name="out">
/// The
/// <see cref="System.IO.DataOutputStream"/>
/// where the fields are written
/// </param>
/// <param name="writeBlock">Whether to write block information</param>
/// <exception cref="System.IO.IOException"/>
public static void WriteINodeFile(INodeFile file, DataOutput @out, bool writeUnderConstruction
)
{
WriteLocalName(file, @out);
@out.WriteLong(file.GetId());
@out.WriteShort(file.GetFileReplication());
@out.WriteLong(file.GetModificationTime());
@out.WriteLong(file.GetAccessTime());
@out.WriteLong(file.GetPreferredBlockSize());
WriteBlocks(file.GetBlocks(), @out);
SnapshotFSImageFormat.SaveFileDiffList(file, @out);
if (writeUnderConstruction)
{
if (file.IsUnderConstruction())
{
@out.WriteBoolean(true);
FileUnderConstructionFeature uc = file.GetFileUnderConstructionFeature();
WriteString(uc.GetClientName(), @out);
WriteString(uc.GetClientMachine(), @out);
}
else
{
@out.WriteBoolean(false);
}
}
WritePermissionStatus(file, @out);
}
public void Write(bool?value, DataOutput stream)
{
bool isNull = value == null;
stream.WriteBoolean(isNull);
if (!isNull)
{
stream.WriteBoolean(value.Value);
}
}
public static void WriteValue(DateTimeEx value, DataOutput output)
{
if (value == null)
{
output.WriteBoolean(true);
return;
}
output.WriteBoolean(false);
output.WriteUTF(value.TimeZone.Id);
output.WriteLong(value.UtcMillis);
}
public void Write(string @object, DataOutput stream)
{
if (@object != null)
{
stream.WriteBoolean(true);
stream.WriteUTF(@object);
}
else
{
stream.WriteBoolean(false);
}
}
public static void WriteOptionalArray(
int[] ints,
DataOutput output)
{
if (ints == null) {
output.WriteBoolean(false);
return;
}
output.WriteBoolean(true);
WriteArray(ints, output);
}
public void Write(
DateTime? @object,
DataOutput output)
{
if (@object == null)
{
output.WriteBoolean(false);
}
else
{
output.WriteBoolean(true);
DIODateTimeSerde.WriteInternal(@object.Value, output);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void Write(DataOutput @out)
{
@out.WriteBoolean(shouldDie);
if (t != null)
{
@out.WriteBoolean(true);
@out.WriteBoolean(t.IsMapTask());
t.Write(@out);
}
else
{
@out.WriteBoolean(false);
}
}
public void Write(
IDictionary <string, object> @object,
DataOutput output,
byte[] unitKey,
EventBeanCollatedWriter writer)
{
if (@object == null)
{
output.WriteBoolean(false);
return;
}
output.WriteBoolean(true);
Write(@object, output);
}
public void ToData(DataOutput output)
{
if (m_initialized)
{
output.WriteBoolean(m_cacheableBoolean);
output.WriteInt32(m_cacheableInt32);
output.WriteArrayLen(m_cacheableInt32Array.Length);
foreach (int item in m_cacheableInt32Array)
{
output.WriteInt32(item);
}
output.WriteUTF(m_cacheableFileName);
output.WriteUTF(m_CacheableStringASCII);
output.WriteArrayLen(m_cacheableStringArray.Length);
foreach (string item in m_cacheableStringArray)
{
output.WriteUTF(item);
}
output.WriteDictionary((System.Collections.IDictionary)m_cacheableHashMap);
output.WriteArrayLen(m_cacheableVector.Count);
foreach (object item in m_cacheableVector)
{
output.WriteObject(item);
}
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void Write(DataOutput @out)
{
Text.WriteString(@out, name);
@out.WriteBoolean(isBlacklisted);
Text.WriteString(@out, reasonForBlacklist);
Text.WriteString(@out, blacklistReport);
}
/// <summary>
/// Serialize a
/// <see cref="INodeReference"/>
/// node
/// </summary>
/// <exception cref="System.IO.IOException"/>
private static void WriteINodeReference(INodeReference @ref, DataOutput @out, bool
writeUnderConstruction, SnapshotFSImageFormat.ReferenceMap referenceMap)
{
WriteLocalName(@ref, @out);
@out.WriteLong(@ref.GetId());
@out.WriteShort(0);
// replication
@out.WriteLong(0);
// modification time
@out.WriteLong(0);
// access time
@out.WriteLong(0);
// preferred block size
@out.WriteInt(-3);
// # of blocks
bool isWithName = @ref is INodeReference.WithName;
@out.WriteBoolean(isWithName);
if (!isWithName)
{
Preconditions.CheckState(@ref is INodeReference.DstReference);
// dst snapshot id
@out.WriteInt(((INodeReference.DstReference)@ref).GetDstSnapshotId());
}
else
{
@out.WriteInt(((INodeReference.WithName)@ref).GetLastSnapshotId());
}
INodeReference.WithCount withCount = (INodeReference.WithCount)@ref.GetReferredINode
();
referenceMap.WriteINodeReferenceWithCount(withCount, @out, writeUnderConstruction
);
}
public override void Write(
DateTimeOffset? @object,
DataOutput output,
byte[] unitKey,
EventBeanCollatedWriter writer)
{
if (@object == null)
{
output.WriteBoolean(false);
}
else
{
output.WriteBoolean(true);
DIODateTimeOffsetSerde.WriteInternal(@object.Value, output);
}
}
/// <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);
}
}
/// <summary>Write sigma to DataOutput</summary>
/// <exception cref="System.IO.IOException"/>
public static void Write(Summation sigma, DataOutput @out)
{
SummationWritable.ArithmeticProgressionWritable.Write(sigma.N, @out);
SummationWritable.ArithmeticProgressionWritable.Write(sigma.E, @out);
double v = sigma.GetValue();
if (v == null)
{
@out.WriteBoolean(false);
}
else
{
@out.WriteBoolean(true);
@out.WriteDouble(v);
}
}
public override void Write(
bool @object,
DataOutput output,
byte[] pageFullKey,
EventBeanCollatedWriter writer)
{
output.WriteBoolean(@object);
}
/// <exception cref="System.IO.IOException"/>
public virtual void Write(DataOutput @out)
{
@out.WriteBoolean(reset);
@out.WriteInt(events.Length);
foreach (TaskCompletionEvent @event in events)
{
@event.Write(@out);
}
}
//////////////////////////////////////////////
// Writable
//////////////////////////////////////////////
/// <exception cref="System.IO.IOException"/>
public virtual void Write(DataOutput @out)
{
taskId.Write(@out);
WritableUtils.WriteVInt(@out, idWithinJob);
@out.WriteBoolean(isMap);
WritableUtils.WriteEnum(@out, status);
WritableUtils.WriteString(@out, taskTrackerHttp);
WritableUtils.WriteVInt(@out, taskRunTime);
WritableUtils.WriteVInt(@out, eventId);
}
public void Write(long? @object, DataOutput stream)
{
bool isNull = @object == null;
stream.WriteBoolean(isNull);
if (!isNull)
{
stream.WriteLong(@object.Value);
}
}
public void Write(
char? @object,
DataOutput stream)
{
var isNull = @object == null;
stream.WriteBoolean(isNull);
if (!isNull) {
stream.WriteChar(@object.Value);
}
}
public void Write(
object[] @object,
DataOutput output,
byte[] unitKey,
EventBeanCollatedWriter writer)
{
output.WriteBoolean(@object != null);
if (@object != null) {
DIOJsonSerdeHelper.WriteArray(@object, output);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void Write(DataOutput @out)
{
@out.WriteBoolean(isBlockTokenEnabled);
@out.WriteLong(keyUpdateInterval);
@out.WriteLong(tokenLifetime);
currentKey.Write(@out);
@out.WriteInt(allKeys.Length);
for (int i = 0; i < allKeys.Length; i++)
{
allKeys[i].Write(@out);
}
}
public void Write(
BigInteger?bigInteger,
DataOutput stream)
{
bool isNull = bigInteger == null;
stream.WriteBoolean(isNull);
if (!isNull)
{
DIOBigIntegerUtil.WriteBigInt(bigInteger.Value, stream);
}
}
public void Write(
decimal? @object,
DataOutput stream)
{
bool isNull = @object == null;
stream.WriteBoolean(isNull);
if (!isNull)
{
stream.WriteDecimal(@object.Value);
}
}
private void WriteInternal(bool[] @object, DataOutput output)
{
if (@object == null)
{
output.WriteInt(-1);
return;
}
output.WriteInt(@object.Length);
foreach (bool i in @object)
{
output.WriteBoolean(i);
}
}
/// <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);
}
private void WriteArray(bool[] array, DataOutput output)
{
if (array == null)
{
output.WriteInt(-1);
return;
}
output.WriteInt(array.Length);
foreach (bool i in array)
{
output.WriteBoolean(i);
}
}
public void ToDelta(DataOutput DataOut)
{
lock (this)
{
DataOut.WriteBoolean(m_f1set);
if (m_f1set)
{
DataOut.WriteInt32(m_field1);
}
DataOut.WriteBoolean(m_f2set);
if (m_f2set)
{
DataOut.WriteInt32(m_field2);
}
DataOut.WriteBoolean(m_f3set);
if (m_f3set)
{
DataOut.WriteInt32(m_field3);
}
reset();
}
}
/// <summary>GenericCounter ::= keyName isDistinctDisplayName [displayName] value</summary>
/// <exception cref="System.IO.IOException"/>
public override void Write(DataOutput @out)
{
lock (this)
{
Text.WriteString(@out, name);
bool distinctDisplayName = !name.Equals(displayName);
@out.WriteBoolean(distinctDisplayName);
if (distinctDisplayName)
{
Text.WriteString(@out, displayName);
}
WritableUtils.WriteVLong(@out, value);
}
}
