/// <summary>
/// Called when the current file is closed.
/// </summary>
protected override void CloseCurrentFile()
{
_writer.Write((byte)0);
base.CloseCurrentFile();
_writer.Dispose();
_writer = null;
}
public void reading_and_writing_CKExceptionData_with_BinaryWriter_and_BinaryReader()
{
var dataE0 = CKExceptionData.CreateFrom(ThrowAggregatedException());
var dataE1 = CKExceptionData.CreateFrom(ThrowSimpleException("Test Message"));
var dataE2 = CKExceptionData.CreateFrom(ThrowLoaderException());
var dataE3 = CKExceptionData.CreateFrom(ThrowExceptionWithInner());
var dataE4 = CKExceptionData.CreateFrom(ThrowTwoInnerExceptions());
using (var mem = new MemoryStream())
{
CKBinaryWriter w = new CKBinaryWriter(mem);
dataE0.Write(w);
dataE1.Write(w);
dataE2.Write(w);
dataE3.Write(w);
dataE4.Write(w);
mem.Position = 0;
var r = new CKBinaryReader(mem);
var data0 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data0.ToString().Should().Be(dataE0.ToString());
var data1 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data1.ToString().Should().Be(dataE1.ToString());
var data2 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data2.ToString().Should().Be(dataE2.ToString());
var data3 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data3.ToString().Should().Be(dataE3.ToString());
var data4 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data4.ToString().Should().Be(dataE4.ToString());
}
}
static void DoWriteCloseGroup(CKBinaryWriter w, StreamLogType t, LogLevel level, DateTimeStamp closeTime, IReadOnlyList <ActivityLogGroupConclusion>?conclusions)
{
if (conclusions != null && conclusions.Count > 0)
{
t |= StreamLogType.HasConclusions;
}
if (closeTime.Uniquifier != 0)
{
t |= StreamLogType.HasUniquifier;
}
WriteLogTypeAndLevel(w, t, level);
w.Write(closeTime.TimeUtc.ToBinary());
if (closeTime.Uniquifier != 0)
{
w.Write(closeTime.Uniquifier);
}
if ((t & StreamLogType.HasConclusions) != 0)
{
Debug.Assert(conclusions != null);
w.WriteNonNegativeSmallInt32(conclusions.Count);
foreach (ActivityLogGroupConclusion c in conclusions)
{
w.Write(c.Tag.ToString());
w.Write(c.Text);
}
}
}
/// <summary>
/// Binary writes a log entry.
/// </summary>
/// <param name="w">Binary writer to use.</param>
/// <param name="isOpenGroup">True if this the opening of a group. False for a line.</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="text">Text of the log entry.</param>
/// <param name="logTime">Time stamp of the log entry.</param>
/// <param name="tags">Tags of the log entry</param>
/// <param name="ex">Exception of the log entry.</param>
/// <param name="fileName">Source file name of the log entry</param>
/// <param name="lineNumber">Source line number of the log entry</param>
static public void WriteLog(CKBinaryWriter w, bool isOpenGroup, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData ex, string fileName, int lineNumber)
{
if (w == null)
{
throw new ArgumentNullException("w");
}
DoWriteLog(w, isOpenGroup ? StreamLogType.TypeOpenGroup : StreamLogType.TypeLine, level, logTime, text, tags, ex, fileName, lineNumber);
}
/// <summary>
/// Binary writes a closing entry.
/// </summary>
/// <param name="w">Binary writer to use.</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="closeTime">Time stamp of the group closing.</param>
/// <param name="conclusions">Group conclusions.</param>
static public void WriteCloseGroup(CKBinaryWriter w, LogLevel level, DateTimeStamp closeTime, IReadOnlyList <ActivityLogGroupConclusion> conclusions)
{
if (w == null)
{
throw new ArgumentNullException("w");
}
DoWriteCloseGroup(w, StreamLogType.TypeGroupClosed, level, closeTime, conclusions);
}
/// <summary>
/// Called when a new file is created.
/// </summary>
/// <returns>The created stream.</returns>
protected override Stream OpenNewFile()
{
Stream s = base.OpenNewFile();
_writer = new CKBinaryWriter(s);
_writer.Write(LogReader.FileHeader);
_writer.Write(LogReader.CurrentStreamVersion);
return(s);
}
public void basic_types_writing_and_reading()
{
using (var mem = new MemoryStream())
{
var sShared = Guid.NewGuid().ToString();
using (var w = new CKBinaryWriter(mem, Encoding.UTF8, true))
{
w.WriteNullableString(DefString);
w.Write(DefInt32);
w.Write(DefUInt32);
w.Write(DefInt64);
w.Write(DefUInt64);
w.Write(DefInt16);
w.Write(DefUInt16);
w.Write(DefByte);
w.Write(DefSByte);
w.Write(DefDateTime);
w.Write(DefTimeSpan);
w.WriteSharedString(sShared);
w.Write(DefDateTimeOffset);
w.Write(DefGuid);
w.Write(DefDouble);
w.Write(DefSingle);
w.Write(DefChar);
w.Write(DefBoolean);
w.WriteSharedString(sShared);
}
mem.Position = 0;
using (var r = new CKBinaryReader(mem, Encoding.UTF8, true))
{
r.ReadNullableString().Should().Be(DefString);
r.ReadInt32().Should().Be(DefInt32);
r.ReadUInt32().Should().Be(DefUInt32);
r.ReadInt64().Should().Be(DefInt64);
r.ReadUInt64().Should().Be(DefUInt64);
r.ReadInt16().Should().Be(DefInt16);
r.ReadUInt16().Should().Be(DefUInt16);
r.ReadByte().Should().Be(DefByte);
r.ReadSByte().Should().Be(DefSByte);
r.ReadDateTime().Should().Be(DefDateTime);
r.ReadTimeSpan().Should().Be(DefTimeSpan);
r.ReadSharedString().Should().Be(sShared);
r.ReadDateTimeOffset().Should().Be(DefDateTimeOffset);
r.ReadGuid().Should().Be(DefGuid);
r.ReadDouble().Should().Be(DefDouble);
r.ReadSingle().Should().Be(DefSingle);
r.ReadChar().Should().Be(DefChar);
r.ReadBoolean().Should().Be(DefBoolean);
r.ReadSharedString().Should().Be(sShared);
}
}
}
/// <summary>
/// Binary writes a multicast closing entry.
/// </summary>
/// <param name="w">Binary writer to use.</param>
/// <param name="monitorId">Identifier of the monitor.</param>
/// <param name="previousEntryType">Log type of the previous entry in the monitor..</param>
/// <param name="previousLogTime">Time stamp of the previous entry in the monitor.</param>
/// <param name="depth">Depth of the group (number of opened groups above).</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="closeTime">Time stamp of the group closing.</param>
/// <param name="conclusions">Group conclusions.</param>
static public void WriteCloseGroup(CKBinaryWriter w, Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousLogTime, int depth, LogLevel level, DateTimeStamp closeTime, IReadOnlyList <ActivityLogGroupConclusion> conclusions)
{
if (w == null)
{
throw new ArgumentNullException("w");
}
StreamLogType type = StreamLogType.TypeGroupClosed | StreamLogType.IsMultiCast;
type = UpdateTypeWithPrevious(type, previousEntryType, ref previousLogTime);
DoWriteCloseGroup(w, type, level, closeTime, conclusions);
WriteMulticastFooter(w, monitorId, previousEntryType, previousLogTime, depth);
}
void ComputeSize(GrandOutputEventInfo logEvent, bool increment)
{
using (MemoryStream m = new MemoryStream())
using (CKBinaryWriter w = new CKBinaryWriter(m))
{
logEvent.Entry.WriteLogEntry(w);
if (increment)
{
Interlocked.Add(ref SizeHandled, (int)m.Position);
}
}
}
/// <summary>
/// Binary writes a multicast log entry.
/// </summary>
/// <param name="w">Binary writer to use.</param>
/// <param name="monitorId">Identifier of the monitor.</param>
/// <param name="previousEntryType">Log type of the previous entry in the monitor..</param>
/// <param name="previousLogTime">Time stamp of the previous entry in the monitor.</param>
/// <param name="depth">Depth of the line (number of opened groups above).</param>
/// <param name="isOpenGroup">True if this the opening of a group. False for a line.</param>
/// <param name="text">Text of the log entry.</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="logTime">Time stamp of the log entry.</param>
/// <param name="tags">Tags of the log entry</param>
/// <param name="ex">Exception of the log entry.</param>
/// <param name="fileName">Source file name of the log entry</param>
/// <param name="lineNumber">Source line number of the log entry</param>
static public void WriteLog(CKBinaryWriter w, Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousLogTime, int depth, bool isOpenGroup, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData ex, string fileName, int lineNumber)
{
if (w == null)
{
throw new ArgumentNullException("w");
}
StreamLogType type = StreamLogType.IsMultiCast | (isOpenGroup ? StreamLogType.TypeOpenGroup : StreamLogType.TypeLine);
type = UpdateTypeWithPrevious(type, previousEntryType, ref previousLogTime);
DoWriteLog(w, type, level, logTime, text, tags, ex, fileName, lineNumber);
WriteMulticastFooter(w, monitorId, previousEntryType, previousLogTime, depth);
}
public void LogEntry_write_and_read_back()
{
var exInner = new CKExceptionData("message", "typeof(exception)", "assemblyQualifiedName", "stackTrace", null, "fileName", "fusionLog", null, null);
var ex2 = new CKExceptionData("message2", "typeof(exception2)", "assemblyQualifiedName2", "stackTrace2", exInner, "fileName2", "fusionLog2", null, null);
var exL = new CKExceptionData("loader-message", "typeof(loader-exception)", "loader-assemblyQualifiedName", "loader-stackTrace", null, "loader-fileName", "loader-fusionLog", null, null);
var exAgg = new CKExceptionData("agg-message", "typeof(agg-exception)", "agg-assemblyQualifiedName", "agg-stackTrace", ex2, "fileName", "fusionLog", null, new[] { ex2, exL });
var prevLog = DateTimeStamp.UtcNow;
ILogEntry e1 = LogEntry.CreateLog("Text1", new DateTimeStamp(DateTime.UtcNow, 42), LogLevel.Info, "c:\\test.cs", 3712, ActivityMonitor.Tags.CreateDependentToken, exAgg);
ILogEntry e2 = LogEntry.CreateMulticastLog("GOId", "3712", LogEntryType.Line, prevLog, 5, "Text2", DateTimeStamp.UtcNow, LogLevel.Fatal, null, 3712, ActivityMonitor.Tags.CreateDependentToken, exAgg);;
using (var mem = new MemoryStream())
using (var w = new CKBinaryWriter(mem))
{
w.Write(LogReader.CurrentStreamVersion);
e1.WriteLogEntry(w);
e2.WriteLogEntry(w);
w.Write((byte)0);
w.Flush();
byte[] versionBytes = new byte[4];
mem.Position = 0;
mem.Read(versionBytes, 0, 4);
BitConverter.ToInt32(versionBytes, 0).Should().Be(LogReader.CurrentStreamVersion);
using (var reader = new LogReader(mem, LogReader.CurrentStreamVersion, 4))
{
reader.MoveNext().Should().BeTrue();
reader.Current.Text.Should().Be(e1.Text);
reader.Current.LogLevel.Should().Be(e1.LogLevel);
reader.Current.LogTime.Should().Be(e1.LogTime);
reader.Current.FileName.Should().Be(e1.FileName);
reader.Current.LineNumber.Should().Be(e1.LineNumber);
reader.Current.Exception.ExceptionTypeAssemblyQualifiedName.Should().Be(e1.Exception.ExceptionTypeAssemblyQualifiedName);
reader.Current.Exception.ToString().Should().Be(e1.Exception.ToString());
reader.MoveNext().Should().BeTrue();
reader.CurrentMulticast.GrandOutputId.Should().Be("GOId");
reader.CurrentMulticast.MonitorId.Should().Be("3712");
reader.CurrentMulticast.PreviousEntryType.Should().Be(LogEntryType.Line);
reader.CurrentMulticast.PreviousLogTime.Should().Be(prevLog);
reader.Current.Text.Should().Be(e2.Text);
reader.Current.LogTime.Should().Be(e2.LogTime);
reader.Current.FileName.Should().BeNull();
reader.Current.LineNumber.Should().Be(0, "Since no file name is set, line number is 0.");
reader.Current.Exception.ExceptionTypeAssemblyQualifiedName.Should().Be(e2.Exception.ExceptionTypeAssemblyQualifiedName);
reader.Current.Exception.ToString().Should().Be(e2.Exception.ToString());
reader.MoveNext().Should().BeFalse();
reader.BadEndOfFileMarker.Should().BeFalse();
}
}
}
public void object_pool_work()
{
using (var mem = new MemoryStream())
{
var sA = new String('A', 100);
var sB = new String('B', 100);
using (var w = new CKBinaryWriter(mem, Encoding.UTF8, true))
{
var pool = new CKBinaryWriter.ObjectPool <string>(w, StringComparer.InvariantCultureIgnoreCase);
var p = mem.Position;
p.Should().Be(0);
pool.MustWrite(sA).Should().BeTrue();
w.Write(sA);
pool.MustWrite(sB).Should().BeTrue();
w.Write(sB);
var delta = mem.Position - p;
p = mem.Position;
delta.Should().Be(1 + 1 + sA.Length + 1 + 1 + sB.Length, "Marker byte + small length + UTF8 ascii string");
for (int i = 0; i < 50; ++i)
{
pool.MustWrite(sA).Should().BeFalse();
pool.MustWrite(sB).Should().BeFalse();
pool.MustWrite(sA.ToLowerInvariant()).Should().BeFalse();
pool.MustWrite(sB.ToLowerInvariant()).Should().BeFalse();
}
delta = mem.Position - p;
delta.Should().Be(50 * 4 * (1 + 1), "Marker byte + NonNegativeSmallInt32 that is actuall one byte...");
}
mem.Position = 0;
using (var r = new CKBinaryReader(mem, Encoding.UTF8, true))
{
var pool = new CKBinaryReader.ObjectPool <string>(r);
string rA = pool.TryRead(out rA).SetReadResult(r.ReadString());
rA.Should().Be(sA);
string rB = pool.Read((state, reader) => reader.ReadString());
rB.Should().Be(sB);
for (int i = 0; i < 50; ++i)
{
pool.TryRead(out var rA2).Success.Should().BeTrue();
rA2.Should().Be(rA);
pool.Read((state, reader) => reader.ReadString()).Should().Be(rB);
pool.Read((state, reader) => reader.ReadString()).Should().Be(rA);
pool.Read((state, reader) => reader.ReadString()).Should().Be(rB);
}
}
}
}
public void LogEntryReadWrite()
{
var exInner = new CKExceptionData("message", "typeof(exception)", "assemblyQualifiedName", "stackTrace", null, "fileName", "fusionLog", null, null);
var ex2 = new CKExceptionData("message2", "typeof(exception2)", "assemblyQualifiedName2", "stackTrace2", exInner, "fileName2", "fusionLog2", null, null);
var exL = new CKExceptionData("loader-message", "typeof(loader-exception)", "loader-assemblyQualifiedName", "loader-stackTrace", null, "loader-fileName", "loader-fusionLog", null, null);
var exAgg = new CKExceptionData("agg-message", "typeof(agg-exception)", "agg-assemblyQualifiedName", "agg-stackTrace", ex2, "fileName", "fusionLog", null, new[] { ex2, exL });
var prevLog = DateTimeStamp.UtcNow;
ILogEntry e1 = LogEntry.CreateLog("Text1", new DateTimeStamp(DateTime.UtcNow, 42), LogLevel.Info, "c:\\test.cs", 3712, ActivityMonitor.Tags.CreateDependentActivity, exAgg);
ILogEntry e2 = LogEntry.CreateMulticastLog(Guid.Empty, LogEntryType.Line, prevLog, 5, "Text2", DateTimeStamp.UtcNow, LogLevel.Fatal, null, 3712, ActivityMonitor.Tags.CreateDependentActivity, exAgg);
using (var mem = new MemoryStream())
using (var w = new CKBinaryWriter(mem))
{
w.Write(LogReader.CurrentStreamVersion);
e1.WriteLogEntry(w);
e2.WriteLogEntry(w);
w.Write((byte)0);
w.Flush();
byte[] versionBytes = new byte[4];
mem.Position = 0;
mem.Read(versionBytes, 0, 4);
Assert.That(BitConverter.ToInt32(versionBytes, 0), Is.EqualTo(LogReader.CurrentStreamVersion));
using (var reader = new LogReader(mem, LogReader.CurrentStreamVersion, 4))
{
Assert.That(reader.MoveNext());
Assert.That(reader.Current.Text, Is.EqualTo(e1.Text));
Assert.That(reader.Current.LogLevel, Is.EqualTo(e1.LogLevel));
Assert.That(reader.Current.LogTime, Is.EqualTo(e1.LogTime));
Assert.That(reader.Current.FileName, Is.EqualTo(e1.FileName));
Assert.That(reader.Current.LineNumber, Is.EqualTo(e1.LineNumber));
Assert.That(reader.Current.Exception.ExceptionTypeAssemblyQualifiedName, Is.EqualTo(e1.Exception.ExceptionTypeAssemblyQualifiedName));
Assert.That(reader.Current.Exception.ToString(), Is.EqualTo(e1.Exception.ToString()));
Assert.That(reader.MoveNext());
Assert.That(reader.CurrentMulticast.PreviousEntryType, Is.EqualTo(LogEntryType.Line));
Assert.That(reader.CurrentMulticast.PreviousLogTime, Is.EqualTo(prevLog));
Assert.That(reader.Current.Text, Is.EqualTo(e2.Text));
Assert.That(reader.Current.LogTime, Is.EqualTo(e2.LogTime));
Assert.That(reader.Current.FileName, Is.Null);
Assert.That(reader.Current.LineNumber, Is.EqualTo(0), "Since no file name is set, line number is 0.");
Assert.That(reader.Current.Exception.ExceptionTypeAssemblyQualifiedName, Is.EqualTo(e2.Exception.ExceptionTypeAssemblyQualifiedName));
Assert.That(reader.Current.Exception.ToString(), Is.EqualTo(e2.Exception.ToString()));
Assert.That(reader.MoveNext(), Is.False);
Assert.That(reader.BadEndOfFileMarker, Is.False);
}
}
}
static void WriteMulticastFooter(CKBinaryWriter w, Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousStamp, int depth)
{
w.Write(monitorId.ToByteArray());
w.WriteNonNegativeSmallInt32(depth);
if (previousStamp.IsKnown)
{
w.Write(previousStamp.TimeUtc.ToBinary());
if (previousStamp.Uniquifier != 0)
{
w.Write(previousStamp.Uniquifier);
}
w.Write((byte)previousEntryType);
}
}
static PackageDB CloneBySerialization(PackageDB db)
{
using (var m = new MemoryStream())
{
using (var w = new CKBinaryWriter(m, Encoding.UTF8, true))
{
db.Write(w);
}
m.Position = 0;
using (var r = new CKBinaryReader(m, Encoding.UTF8, true))
{
return(new PackageDB(r));
}
}
}
static void DoWriteLog(CKBinaryWriter w, StreamLogType t, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData?ex, string?fileName, int lineNumber)
{
if (tags != null && !tags.IsEmpty)
{
t |= StreamLogType.HasTags;
}
if (ex != null)
{
t |= StreamLogType.HasException;
if (text == ex.Message)
{
t |= StreamLogType.IsTextTheExceptionMessage;
}
}
if (fileName != null)
{
t |= StreamLogType.HasFileName;
}
if (logTime.Uniquifier != 0)
{
t |= StreamLogType.HasUniquifier;
}
WriteLogTypeAndLevel(w, t, level);
w.Write(logTime.TimeUtc.ToBinary());
if (logTime.Uniquifier != 0)
{
w.Write(logTime.Uniquifier);
}
if ((t & StreamLogType.HasTags) != 0)
{
w.Write(tags !.ToString());
}
if ((t & StreamLogType.HasFileName) != 0)
{
Debug.Assert(fileName != null);
w.Write(fileName);
w.WriteNonNegativeSmallInt32(lineNumber);
}
if ((t & StreamLogType.HasException) != 0)
{
ex !.Write(w);
}
if ((t & StreamLogType.IsTextTheExceptionMessage) == 0)
{
w.Write(text);
}
}
/// <summary>
/// Binary writes a multicast closing entry.
/// </summary>
/// <param name="w">Binary writer to use.</param>
/// <param name="grandOutputId">Identifier of the GrandOutput.</param>
/// <param name="monitorId">Identifier of the monitor.</param>
/// <param name="previousEntryType">Log type of the previous entry in the monitor..</param>
/// <param name="previousLogTime">Time stamp of the previous entry in the monitor.</param>
/// <param name="depth">Depth of the group (number of opened groups above).</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="closeTime">Time stamp of the group closing.</param>
/// <param name="conclusions">Group conclusions.</param>
static public void WriteCloseGroup(CKBinaryWriter w,
string grandOutputId,
string monitorId,
LogEntryType previousEntryType,
DateTimeStamp previousLogTime,
int depth,
LogLevel level,
DateTimeStamp closeTime,
IReadOnlyList <ActivityLogGroupConclusion>?conclusions)
{
Throw.CheckNotNullArgument(w);
StreamLogType type = StreamLogType.TypeGroupClosed | StreamLogType.IsMultiCast;
type = UpdateTypeWithPrevious(type, previousEntryType, ref previousLogTime);
DoWriteCloseGroup(w, type, level, closeTime, conclusions);
WriteMulticastFooter(w, grandOutputId, monitorId, previousEntryType, previousLogTime, depth);
}
public override void WriteLogEntry(CKBinaryWriter w)
{
Debug.Assert(Text != null, "Only LE(MC)CloseGroup has a null Text.");
LogEntry.WriteLog(w,
_grandOutputId,
_monitorId,
_previousEntryType,
_previousLogTime,
_depth,
true,
LogLevel,
LogTime,
Text,
Tags,
Exception,
FileName,
LineNumber);
}
static int ReadWrite(Action <ICKBinaryWriter> writer, Action <ICKBinaryReader> reader = null)
{
using (var mem = new MemoryStream())
{
using (var w = new CKBinaryWriter(mem, Encoding.UTF8, true))
{
writer(w);
}
int pos = (int)mem.Position;
if (reader != null)
{
mem.Position = 0;
using (var r = new CKBinaryReader(mem, Encoding.UTF8, true))
{
reader(r);
}
mem.Position.Should().Be(pos, $"Written {pos} bytes should be the same as read bytes count but found {mem.Position} bytes.");
}
return(pos);
}
}
/// <summary>
/// Binary writes a multicast log entry.
/// </summary>
/// <param name="w">Binary writer to use.</param>
/// <param name="grandOutputId">Identifier of the GrandOutput.</param>
/// <param name="monitorId">Identifier of the monitor.</param>
/// <param name="previousEntryType">Log type of the previous entry in the monitor..</param>
/// <param name="previousLogTime">Time stamp of the previous entry in the monitor.</param>
/// <param name="depth">Depth of the line (number of opened groups above).</param>
/// <param name="isOpenGroup">True if this the opening of a group. False for a line.</param>
/// <param name="text">Text of the log entry.</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="logTime">Time stamp of the log entry.</param>
/// <param name="tags">Tags of the log entry</param>
/// <param name="ex">Exception of the log entry.</param>
/// <param name="fileName">Source file name of the log entry</param>
/// <param name="lineNumber">Source line number of the log entry</param>
static public void WriteLog(CKBinaryWriter w,
string grandOutputId,
string monitorId,
LogEntryType previousEntryType,
DateTimeStamp previousLogTime,
int depth,
bool isOpenGroup,
LogLevel level,
DateTimeStamp logTime,
string text,
CKTrait tags,
CKExceptionData?ex,
string?fileName,
int lineNumber)
{
Throw.CheckNotNullArgument(w);
StreamLogType type = StreamLogType.IsMultiCast | (isOpenGroup ? StreamLogType.TypeOpenGroup : StreamLogType.TypeLine);
type = UpdateTypeWithPrevious(type, previousEntryType, ref previousLogTime);
DoWriteLog(w, type, level, logTime, text, tags, ex, fileName, lineNumber);
WriteMulticastFooter(w, grandOutputId, monitorId, previousEntryType, previousLogTime, depth);
}
SignResult DoSign(Action <Stream>?payloadWriter, ReadOnlySpan <byte> payload)
{
using var m = new MemoryStream(4096);
using var w = new CKBinaryWriter(m);
w.Write((byte)0); // Version.
KeyUsageInfo keyInfo;
int headerLength, payloadLength, signatureLength;
if (_key == null)
{
keyInfo = _local.GetNoKeyUsageInfo(null);
WriteStdClaims(w, keyInfo);
WritePayload(payloadWriter, payload, m, w, out headerLength, out payloadLength);
signatureLength = 0;
}
else
{
var(key, usage) = _key.GetActualKeyObject(true, null);
if (key == null)
{
return(new SignResult(usage, ReadOnlyMemory <byte> .Empty, 0, 0, 0));
}
keyInfo = usage;
WriteStdClaims(w, usage);
WritePayload(payloadWriter, payload, m, w, out headerLength, out payloadLength);
signatureLength = _algo.SignatureByteLength;
Span <byte> signature = signatureLength <= 256
? stackalloc byte[signatureLength]
: new byte[signatureLength];
_algo.Sign(key, m.GetBuffer().AsSpan(0, (int)m.Position), signature);
m.Write(signature);
}
var result = m.GetBuffer().AsMemory(0, (int)m.Position);
return(new SignResult(keyInfo, result, headerLength, payloadLength, signatureLength));
public void object_pool_with_write_marker()
{
using (var mem = new MemoryStream())
{
// Same string but in two different instances: the PureObjectRefEqualityComparer
// does its job.
var o1 = new String('B', 100);
var o2 = new String('B', 100);
using (var w = new CKBinaryWriter(mem, Encoding.UTF8, true))
{
var pool = new CKBinaryWriter.ObjectPool <string>(w, PureObjectRefEqualityComparer <string> .Default);
pool.MustWrite(o1, 3).Should().BeTrue();
w.Write(o1);
pool.MustWrite(o2, 255).Should().BeTrue();
w.Write(o2);
}
mem.Position = 0;
using (var r = new CKBinaryReader(mem, Encoding.UTF8, true))
{
var pool = new CKBinaryReader.ObjectPool <string>(r);
var state1 = pool.TryRead(out var s1);
s1.Should().BeNull();
state1.Success.Should().BeFalse();
state1.WriteMarker.Should().Be(3);
s1 = state1.SetReadResult(r.ReadString());
var state2 = pool.TryRead(out var s2);
s2.Should().BeNull();
state2.Success.Should().BeFalse();
state2.WriteMarker.Should().Be(255);
s2 = state2.SetReadResult(r.ReadString());
s1.Should().Be(o1).And.Be(o2);
s2.Should().Be(o1).And.Be(o2);
}
}
}
public virtual void WriteLogEntry(CKBinaryWriter w)
{
LogEntry.WriteCloseGroup(w, _level, _time, _conclusions);
}
/// <summary>
/// Writes this cache into a binary stream.
/// </summary>
/// <param name="w">The writer to use.</param>
public void Write(CKBinaryWriter w)
{
_db.Write(w);
}
public override void WriteLogEntry(CKBinaryWriter w)
{
LogEntry.WriteLog(w, _monitorId, _previousEntryType, _previousLogTime, _depth, true, LogLevel, LogTime, Text, Tags, Exception, FileName, LineNumber);
}
public TcpHandler(TcpHandlerConfiguration configuration)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_memoryStream = new MemoryStream();
_binaryWriter = new CKBinaryWriter(_memoryStream, Encoding.UTF8, true);
}
public override void WriteLogEntry(CKBinaryWriter w)
{
LogEntry.WriteCloseGroup(w, _monitorId, _previousEntryType, _previousLogTime, _depth, LogLevel, LogTime, Conclusions);
}
static void WritePayload(Action <Stream>?payloadWriter, ReadOnlySpan <byte> payload, MemoryStream m, CKBinaryWriter w, out int headerLength, out int payloadLength)
{
w.Flush();
headerLength = (int)m.Position;
if (payloadWriter != null)
{
payloadWriter(m);
}
else
{
m.Write(payload);
}
payloadLength = (int)m.Position - headerLength;
}
/// <summary>
/// Initializes a new <see cref="SimplePipeSenderActivityMonitorClient"/>.
/// </summary>
/// <param name="pipeHandlerName">The name of the server pipe.</param>
public SimplePipeSenderActivityMonitorClient(string pipeHandlerName)
{
_client = new AnonymousPipeClientStream(PipeDirection.Out, pipeHandlerName);
_writer = new CKBinaryWriter(_client);
_writer.Write(LogReader.CurrentStreamVersion);
}
public void reading_and_writing_CKExceptionData_with_BinaryWriter_and_BinaryReader()
{
var dataE0 = CKExceptionData.CreateFrom( ThrowAggregatedException() );
var dataE1 = CKExceptionData.CreateFrom( ThrowSimpleException( "Test Message" ) );
var dataE2 = CKExceptionData.CreateFrom( ThrowLoaderException() );
var dataE3 = CKExceptionData.CreateFrom( ThrowExceptionWithInner() );
var dataE4 = CKExceptionData.CreateFrom( ThrowTwoInnerExceptions() );
using( var mem = new MemoryStream() )
{
CKBinaryWriter w = new CKBinaryWriter( mem );
dataE0.Write( w );
dataE1.Write( w );
dataE2.Write( w );
dataE3.Write( w );
dataE4.Write( w );
mem.Position = 0;
var r = new CKBinaryReader( mem );
var data0 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data0.ToString(), dataE0.ToString() );
var data1 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data1.ToString(), dataE1.ToString() );
var data2 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data2.ToString(), dataE2.ToString() );
var data3 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data3.ToString(), dataE3.ToString() );
var data4 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data4.ToString(), dataE4.ToString() );
}
}
public virtual void WriteLogEntry(CKBinaryWriter w)
{
LogEntry.WriteLog(w, true, _level, _time, _text, _tags, _ex, _fileName, _lineNumber);
}