public void Flush_should_wait_until_current_events_are_written()
        {
            var iterationBlocker = new TaskCompletionSource <bool>();

            singleFileWorker.WritePendingEventsAsync(
                Arg.Any <IEventsWriterProvider>(),
                Arg.Any <ConcurrentBoundedQueue <LogEventInfo> >(),
                Arg.Any <LogEventInfo[]>(),
                Arg.Any <AtomicLong>(),
                Arg.Any <AtomicLong>(),
                Arg.Any <CancellationToken>())
            .Returns(iterationBlocker.Task);
            muxer.TryAdd(CreateEventInfo(), true);

            var flushTask = muxer.FlushAsync();

            flushTask.Wait(50);
            flushTask.IsCompleted.Should().BeFalse();

            Task.Run(() => iterationBlocker.TrySetResult(true));
            flushTask.Wait(10.Seconds());
            flushTask.IsCompleted.Should().BeTrue();

            singleFileWorker.Received().WritePendingEventsAsync(
                Arg.Any <IEventsWriterProvider>(),
                Arg.Is <ConcurrentBoundedQueue <LogEventInfo> >(q => q.Count == 1),
                Arg.Any <LogEventInfo[]>(),
                Arg.Any <AtomicLong>(),
                Arg.Any <AtomicLong>(),
                Arg.Any <CancellationToken>());
        }
        public void TestSetup()
        {
            eventsWriter = Substitute.For <IEventsWriter>();

            eventsWriterProvider = Substitute.For <IEventsWriterProvider>();
            eventsWriterProvider.ObtainWriterAsync(Arg.Any <CancellationToken>()).Returns(Task.FromResult(eventsWriter));

            writerProviderFactory = Substitute.For <IEventsWriterProviderFactory>();
            writerProviderFactory.CreateProvider(Arg.Any <FilePath>(), Arg.Do <Func <FileLogSettings> >(x => settingsInsideMuxer = x)).Returns(eventsWriterProvider);

            singleFileWorker = Substitute.For <ISingleFileWorker>();
            singleFileWorker.WritePendingEventsAsync(
                Arg.Any <IEventsWriterProvider>(),
                Arg.Any <ConcurrentBoundedQueue <LogEventInfo> >(),
                Arg.Any <LogEventInfo[]>(),
                Arg.Any <AtomicLong>(),
                Arg.Any <AtomicLong>(),
                Arg.Any <CancellationToken>())
            .Returns(Task.FromResult(true));

            muxer = new SingleFileMuxer(writerProviderFactory, singleFileWorker, new FileLogSettings());
        }
Example #3
0
        private async Task WorkerRoutineAsync()
        {
            while (!workerCancellation.IsCancellationRequested)
            {
                try
                {
                    var currentWaiters = DrainFlushWaiters();

                    var iterationResult = await worker.WritePendingEventsAsync(
                        writerProvider,
                        eventsQueue.Value,
                        eventsBuffer.Value,
                        eventsLostCurrently,
                        eventsLostSinceLastIteration,
                        workerCancellation.Token)
                                          .ConfigureAwait(false);

                    SignalFlushWaiters(currentWaiters, iterationResult);
                }
                catch (OperationCanceledException)
                {
                    return;
                }
                catch (Exception error)
                {
                    SafeConsole.ReportError($"Failure in writing log events to file '{settings.FilePath}':", error);

                    await Task.Delay(100).ConfigureAwait(false);
                }

                await Task.WhenAny(
                    eventsQueue.Value.TryWaitForNewItemsAsync(NewEventsTimeout),
                    flushSignal.WaitAsync(),
                    workerCancellationWaiter.Task)
                .ConfigureAwait(false);

                flushSignal.Reset();
            }
        }