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"))); }