public void Should_write_header_at_start_of_rolling_log_files()
{
var headerWriter = new HeaderWriter(W3C_HEADER);
var logEvents = Some.LogEvents(3);
using (var temp = TempFolder.ForCaller())
{
var path = temp.AllocateFilename("txt");
// Use a rolling log file configuration with a 50-byte size limit, so we roll after writing the header and a single log event
using (var log = new LoggerConfiguration()
.WriteTo.File(path, rollOnFileSizeLimit: true, fileSizeLimitBytes: 50, hooks: headerWriter)
.CreateLogger())
{
log.WriteAll(logEvents);
}
// Get all the files the rolling file sink wrote
var files = Directory.GetFiles(temp.Path)
.OrderBy(p => p, StringComparer.OrdinalIgnoreCase)
.ToArray();
// We should have found a file for each entry in logEvents
files.Length.ShouldBe(logEvents.Length);
// Check each file to ensure it contains our header plus 1 log event
for (var i = 0; i < files.Length; i++)
{
var lines = files[i].ReadAllLines();
// File should contain our header line plus 1 log event
lines.Count.ShouldBe(2);
// Ensure the file starts with the header
lines[0].ShouldBe(W3C_HEADER);
// Ensure the log event was written as normal
lines[1].ShouldEndWith(logEvents[i].MessageTemplate.Text);
}
}
}
public void MutateIncoming(TransportMessage transportMessage)
{
var headers = transportMessage.Headers;
if (transportMessage.IsMessageOfTye <MessageToSend>())
{
var sendingText = HeaderWriter.ToFriendlyString <HeaderWriterReturn>(headers);
SnippetLogger.Write(
text: sendingText,
suffix: "Sending");
}
else
{
var returnText = HeaderWriter.ToFriendlyString <HeaderWriterReturn>(headers);
SnippetLogger.Write(
text: returnText,
suffix: "Returning");
ManualResetEvent.Set();
}
}
public void WriteTestMethod()
{
ushort _length = 16;
HeaderWriterTest _htw = new HeaderWriterTest(x => { });
HeaderWriter _hw = new HeaderWriter(_htw, _length);
_htw.Write((byte)0x1);
_htw.Write((byte)0x1);
_htw.Write((byte)0x1);
_htw.Write((byte)0x1);
_hw.WriteHeader((x, y) => { });
Assert.AreEqual <long>(_length + 4, _htw.Position);
_htw.Write((byte)0x1);
_htw.Write((byte)0x1);
_htw.Write((byte)0x1);
_htw.Write((byte)0x1);
Assert.AreEqual <long>(_length + 8, _htw.Position);
_hw.WriteHeader((x, y) => { });
Assert.AreEqual <long>(_length + 8, _htw.Position);
}
public void MutateIncoming(TransportMessage transportMessage)
{
var headers = transportMessage.Headers;
if (transportMessage.IsMessageOfTye <SendFromSagaMessage>())
{
var headerText = HeaderWriter.ToFriendlyString <HeaderWriterSaga>(headers);
SnippetLogger.Write(
text: headerText,
suffix: "Sending");
CountdownEvent.Signal();
return;
}
if (transportMessage.IsMessageOfTye <ReplyFromSagaMessage>())
{
var headerText = HeaderWriter.ToFriendlyString <HeaderWriterSaga>(headers);
SnippetLogger.Write(
text: headerText,
suffix: "Replying");
CountdownEvent.Signal();
return;
}
if (transportMessage.IsMessageOfTye <ReplyToOriginatorFromSagaMessage>())
{
var headerText = HeaderWriter.ToFriendlyString <HeaderWriterSaga>(headers);
SnippetLogger.Write(
text: headerText,
suffix: "ReplyingToOriginator");
CountdownEvent.Signal();
return;
}
if (transportMessage.IsMessageOfTye <TimeoutFromSaga>())
{
var headerText = HeaderWriter.ToFriendlyString <HeaderWriterSaga>(headers);
SnippetLogger.Write(
text: headerText,
suffix: "Timeout");
CountdownEvent.Signal();
}
}
public Task MutateIncoming(MutateIncomingTransportMessageContext context)
{
var headers = context.Headers;
if (context.IsMessageOfTye <MessageToSend>())
{
var sendingText = HeaderWriter.ToFriendlyString <HeaderWriterReturn>(headers);
SnippetLogger.Write(
text: sendingText,
suffix: "Sending");
}
else
{
var returnText = HeaderWriter.ToFriendlyString <HeaderWriterReturn>(headers);
SnippetLogger.Write(
text: returnText,
suffix: "Returning");
ManualResetEvent.Set();
}
return(Task.CompletedTask);
}
public Task MutateIncoming(MutateIncomingTransportMessageContext context)
{
if (context.IsMessageOfTye <MessageToReply>())
{
var headerText = HeaderWriter.ToFriendlyString <HeaderWriterReply>(context.Headers);
SnippetLogger.Write(
text: headerText,
suffix: "Replying",
version: "6");
ManualResetEvent.Set();
}
if (context.IsMessageOfTye <MessageToSend>())
{
var headerText = HeaderWriter.ToFriendlyString <HeaderWriterReply>(context.Headers);
SnippetLogger.Write(
text: headerText,
suffix: "Sending",
version: "6");
}
return(Task.FromResult(0));
}
void ProcessFile(string sourceFile, MarkdownProcessor markdownProcessor)
{
log($"Processing {sourceFile}");
var target = GetTargetFile(sourceFile, targetDirectory);
using (var reader = File.OpenText(sourceFile))
using (var writer = File.CreateText(target))
{
if (writeHeader)
{
HeaderWriter.WriteHeader(sourceFile, targetDirectory, writer);
}
var result = markdownProcessor.Apply(reader, writer);
var missing = result.MissingSnippets;
if (missing.Any())
{
throw new MissingSnippetsException(missing);
}
}
}
internal ExclusivePublication(
ClientConductor clientConductor,
string channel,
int streamId,
int sessionId,
IReadablePosition positionLimit,
LogBuffers logBuffers,
long registrationId)
{
var buffers = logBuffers.TermBuffers();
var logMetaDataBuffer = logBuffers.MetaDataBuffer();
for (var i = 0; i < LogBufferDescriptor.PARTITION_COUNT; i++)
{
_termAppenders[i] = new ExclusiveTermAppender(buffers[i], logMetaDataBuffer, i);
}
var termLength = logBuffers.TermLength();
MaxPayloadLength = LogBufferDescriptor.MtuLength(logMetaDataBuffer) - DataHeaderFlyweight.HEADER_LENGTH;
MaxMessageLength = FrameDescriptor.ComputeExclusiveMaxMessageLength(termLength);
_conductor = clientConductor;
Channel = channel;
StreamId = streamId;
SessionId = sessionId;
InitialTermId = LogBufferDescriptor.InitialTermId(logMetaDataBuffer);
_logMetaDataBuffer = logMetaDataBuffer;
RegistrationId = registrationId;
_positionLimit = positionLimit;
_logBuffers = logBuffers;
_positionBitsToShift = IntUtil.NumberOfTrailingZeros(termLength);
_headerWriter = new HeaderWriter(LogBufferDescriptor.DefaultFrameHeader(logMetaDataBuffer));
this._activePartitionIndex = LogBufferDescriptor.ActivePartitionIndex(logMetaDataBuffer);
long rawTail = _termAppenders[_activePartitionIndex].RawTail();
_termId = LogBufferDescriptor.TermId(rawTail);
_termOffset = LogBufferDescriptor.TermOffset(rawTail, termLength);
_termBeginPosition = LogBufferDescriptor.ComputeTermBeginPosition(_termId, _positionBitsToShift, InitialTermId);
}
public async Task <MemoryStream> SpeakToMemoryStreamWithHeaderAdded(string text)
{
var speechConfig = configuration.GetSection("CognitiveSpeech").Get <CognitiveSpeechConfig>();
var config = SpeechConfig.FromSubscription(speechConfig.SubscriptionKey, speechConfig.Region);
config.SetSpeechSynthesisOutputFormat(SpeechSynthesisOutputFormat.Riff16Khz16BitMonoPcm);
byte[] data = await SynthesisWithByteStreamToByteArrayAsync(ssmlFactory.CreateSsmlForText(text), config);
if (data == null)
{
return(null);
}
MemoryStream ms = new MemoryStream();
HeaderWriter.WriteHeader(ms, data.Length, 1, 16000);
ms.Write(data);
ms.Position = 0;
return(ms);
}
public void Can_Delete_Reference()
{
var parser = new HeaderParser(".\\Test.dacpac");
string fileName = string.Format("c:\\bloonblah{0}.dacpac", Guid.NewGuid().ToString().Replace("{", "").Replace("}", "").Replace("-", ""));
const string logicalName = "blooblah.dacpac";
const string externalParts = "[$(blooblah)]";
const string suppressMissingDependenciesErrors = "False";
var newCustomData = new CustomData("Reference", "SqlSchema");
newCustomData.AddMetadata("FileName", fileName);
newCustomData.AddMetadata("LogicalName", logicalName);
newCustomData.AddMetadata("ExternalParts", externalParts);
newCustomData.AddMetadata("SupressMissingDependenciesErrors", suppressMissingDependenciesErrors);
var writer = new HeaderWriter(".\\Test.dacpac", new DacHacFactory());
writer.AddCustomData(newCustomData);
writer.Close();
var actualItem = parser.GetCustomData()
.Where(
p =>
p.Category == "Reference" && p.Type == "SqlSchema" &&
p.Items.Any(item => item.Name == "FileName" && item.Value == fileName));
writer = new HeaderWriter(".\\Test.dacpac", new DacHacFactory());
writer.DeleteCustomData(newCustomData);
writer.Close();
actualItem = parser.GetCustomData()
.Where(
p =>
p.Category == "Reference" && p.Type == "SqlSchema" &&
p.Items.Any(item => item.Name == "FileName" && item.Value == fileName));
Assert.IsNotNull(actualItem);
}
/// <summary>
/// Open the stream for the provided ExecutionContext.
/// </summary>
/// <param name="executionContext">current step's ExecutionContext. Will be the
/// executionContext from the last run of the step on a restart.</param>
/// <exception cref="ItemStreamException"> </exception>
/// <exception cref="ArgumentException"> if execution context is null</exception>
public override void Open(ExecutionContext executionContext)
{
Assert.NotNull(Resource, "The resource must be set.");
Assert.IsTrue(!Resource.Exists() || (Resource.GetFileInfo().Attributes & FileAttributes.Directory) == 0,
"Cannot write write, resource is a directory: " + Resource);
if (_initialized)
{
return;
}
if (executionContext.ContainsKey(Restart) && (bool)executionContext.Get(Restart))
{
if ((executionContext.ContainsKey(WriteInProcess) && (bool)executionContext.Get(WriteInProcess)))
{
executionContext.Put(WriteInProcess, false);
if (executionContext.ContainsKey(ProcessWriterPreFix + GetExecutionContextKey(RestartDataName)))
{
RestoreWriteInProcessFrom(executionContext);
}
}
else
{
if (executionContext.ContainsKey(GetExecutionContextKey(RestartDataName)))
{
RestoreFrom(executionContext);
}
}
}
InitializeWriter();
if (_lastMarkedByteOffsetPosition == 0 && !_appending && HeaderWriter != null)
{
HeaderWriter.WriteHeader(_writer);
Write(LineSeparator);
}
}
public override void WriteToStream(System.IO.Stream stream)
{
UrlFrame frame = (UrlFrame)this.FrameToWrite;
List <Field> fields = new List <Field>();
// Declare the fields to write.
fields.Add(TextField.CreateTextField(frame.Url, EncodingScheme.Ascii));
// Write the header
int length = 0;
foreach (Field f in fields)
{
length += f.Length;
}
HeaderWriter.WriteHeader(stream, new FrameHeader(this.FrameID, length));
// Write the fields
foreach (Field f in fields)
{
f.WriteToStream(stream);
}
}
public void WriteHeaders(
IReadOnlyList <IMetric> metrics,
bool includeDescription,
string[] timingAllowOrigins,
string expectedServerTiming,
string expectedTimingAllowOrigin = null)
{
var headerWriter = new HeaderWriter(timingAllowOrigins);
var headers = new HeaderDictionary();
headerWriter.WriteHeaders(headers, includeDescription, metrics);
headers[HeaderWriter.ServerTimingHeaderName].ToString().Should().Be(expectedServerTiming);
if (expectedTimingAllowOrigin == null)
{
headers.ContainsKey(HeaderWriter.TimingAllowOriginHeaderName).Should().BeFalse();
}
else
{
headers[HeaderWriter.TimingAllowOriginHeaderName].ToString().Should().Be(expectedTimingAllowOrigin);
}
}
public override void WriteToStream(System.IO.Stream stream)
{
MusicCDIdentifierFrame frame = (MusicCDIdentifierFrame)this.FrameToWrite;
List <Field> fields = new List <Field>();
// Declare the fields to write.
fields.Add(new BinaryField(frame.Identifier, 0, frame.Identifier.Length));
// Write the header
int length = 0;
foreach (Field f in fields)
{
length += f.Length;
}
HeaderWriter.WriteHeader(stream, new FrameHeader(this.FrameID, length));
// Write the fields
foreach (Field f in fields)
{
f.WriteToStream(stream);
}
}
public static void WriteHeader(
CodeTextStorage storage,
TranslateContext translateContext,
PreparedInformations prepared)
{
var assemblyName = translateContext.Assembly.Name;
// Write assembly level common header.
HeaderWriter.WriteCommonHeader(
storage,
translateContext,
prepared,
assemblyName);
using (var _ = storage.EnterScope(assemblyName, false))
{
// Write public headers.
HeaderWriter.WriteHeaders(
storage,
translateContext,
prepared);
}
}
public void Should_write_header_to_non_empty_stream_is_required()
{
var headerWriter = new HeaderWriter(W3C_HEADER, true);
var logEvents = Some.LogEvents(3);
using (var temp = TempFolder.ForCaller())
{
var path = temp.AllocateFilename("txt");
// Write something to the start of the log file
System.IO.File.WriteAllText(path, "Myergen\n");
using (var log = new LoggerConfiguration()
.WriteTo.File(Path.Combine(path), hooks: headerWriter)
.CreateLogger())
{
log.WriteAll(logEvents);
}
// Read the contents of the file that was written
var lines = path.ReadAllLines();
// File should contain the content line, our header line, and the 3 log events,
lines.Count.ShouldBe(1 + 1 + logEvents.Length);
// Ensure the file contains the header
lines[1].ShouldBe(W3C_HEADER);
// Ensure all the log events were written as normal
for (var i = 0; i < logEvents.Length; i++)
{
lines[i + 2].ShouldEndWith(logEvents[i].MessageTemplate.Text);
}
}
}
public override void WriteToStream(System.IO.Stream stream)
{
TextFrame frame = (TextFrame)this.FrameToWrite;
List <Field> fields = new List <Field>();
// Declare the fields to write.
fields.Add(new SingleByteField((byte)this.Encoding));
fields.Add(TextField.CreateTextField(frame.Text, this.Encoding));
// Write the header
int length = 0;
foreach (Field f in fields)
{
length += f.Length;
}
HeaderWriter.WriteHeader(stream, new FrameHeader(this.FrameID, length));
// Write the fields
foreach (Field f in fields)
{
f.WriteToStream(stream);
}
}
public override void WriteToStream(System.IO.Stream stream)
{
PrivateFrame frame = (PrivateFrame)this.FrameToWrite;
List <Field> fields = new List <Field>();
// Declare the fields to write.
fields.Add(TextField.CreateTextField(frame.OwnerIdentifier, EncodingScheme.Ascii));
fields.Add(new BinaryField(frame.PrivateData, 0, frame.PrivateData.Length));
// Write the header
int length = 0;
foreach (Field f in fields)
{
length += f.Length;
}
HeaderWriter.WriteHeader(stream, new FrameHeader(this.FrameID, length));
// Write the fields
foreach (Field f in fields)
{
f.WriteToStream(stream);
}
}
internal Publication(
ClientConductor clientConductor,
string channel,
int streamId,
int sessionId,
IReadablePosition positionLimit,
LogBuffers logBuffers,
long originalRegistrationId,
long registrationId)
{
var buffers = logBuffers.TermBuffers();
var logMetaDataBuffer = logBuffers.MetaDataBuffer();
for (var i = 0; i < LogBufferDescriptor.PARTITION_COUNT; i++)
{
_termAppenders[i] = new TermAppender(buffers[i], logMetaDataBuffer, i);
}
var termLength = logBuffers.TermLength();
MaxPayloadLength = LogBufferDescriptor.MtuLength(logMetaDataBuffer) - DataHeaderFlyweight.HEADER_LENGTH;
MaxMessageLength = FrameDescriptor.ComputeMaxMessageLength(termLength);
_maxPossiblePosition = termLength * (1L << 31);
_conductor = clientConductor;
Channel = channel;
StreamId = streamId;
SessionId = sessionId;
InitialTermId = LogBufferDescriptor.InitialTermId(logMetaDataBuffer);
_logMetaDataBuffer = logMetaDataBuffer;
_originalRegistrationId = originalRegistrationId;
RegistrationId = registrationId;
_positionLimit = positionLimit;
_logBuffers = logBuffers;
_positionBitsToShift = IntUtil.NumberOfTrailingZeros(termLength);
_headerWriter = new HeaderWriter(LogBufferDescriptor.DefaultFrameHeader(logMetaDataBuffer));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="headerWriter">The HeaderWriter to use to write headers.</param>
/// <param name="valueWriters">The writers to use to restore values.</param>
/// <param name="footerWriter">The FooterWriter to write footers.</param>
public SaveControl(HeaderWriter headerWriter, ValueWriter valueWriters, FooterWriter footerWriter)
{
this.headerWriter = headerWriter;
this.valueWriters = valueWriters;
this.footerWriter = footerWriter;
}
public AppendLog(string filepath, int bufferSizeMb = 100)
{
var bufferSizeInBytes = BitUtil.FindNextPositivePowerOfTwo(bufferSizeMb * 1024 * 1024);
_logBuffers = new LogBuffers(filepath, bufferSizeInBytes);
for (int i = 0; i < PARTITION_COUNT; i++)
{
_termAppenders[i] = new TermAppender(_logBuffers.Buffers[i], _logBuffers.Buffers[i + PARTITION_COUNT]);
}
_termLengthMask = _logBuffers.TermLength - 1;
_positionBitsToShift = BitUtil.NumberOfTrailingZeros(_logBuffers.TermLength);
_initialTermId = InitialTermId(_logBuffers.LogMetaData);
//var defaultHeader = DefaultFrameHeader(_logBuffers.LogMetaData);
var defaultHeader = DataHeaderFlyweight.CreateDefaultHeader(0, 0, _initialTermId);
_headerWriter = new HeaderWriter(defaultHeader);
_subscriberPosition = Position;
Trace.Assert(_subscriberPosition == Position);
_cleaner = Task.Factory.StartNew(async() => {
try {
} finally {
while (!_cts.IsCancellationRequested)
{
// try to clean every second
await _cleanEvent.WaitAsync(1000);
CleanLogBuffer();
}
}
}, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default)
.ContinueWith(task => {
Console.WriteLine("AppendLog CleanLogBuffer should never throw exceptions" + Environment.NewLine + task.Exception);
Environment.FailFast("AppendLog CleanLogBuffer should never throw exceptions", task.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
_poller = Task.Factory.StartNew(() => {
try {
} finally {
var sw = new SpinWait();
while (!_cts.IsCancellationRequested)
{
var fragments = Poll();
if (fragments > 0)
{
sw.Reset();
}
else
{
sw.SpinOnce();
}
// TODO try waithandle as in IpcLongIncrementListener
//Thread.SpinWait(0);
}
}
}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default)
.ContinueWith(task => {
Console.WriteLine("AppendLog Poll should never throw exceptions" + Environment.NewLine + task.Exception);
Environment.FailFast("AppendLog Poll should never throw exceptions", task.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
}
public Task WriteHeaderDefaultHeader()
{
return(Verifier.Verify(HeaderWriter.WriteHeader("thePath", null, "\r\n")));
}
public Task WriteHeaderHeaderCustom()
{
return(Verifier.Verify(HeaderWriter.WriteHeader("thePath", @"line1\nline2", "\r\n")));
}
