public async Task PrespoolAllowsParallel() { var stopwatch = new Stopwatch(); stopwatch.Start(); var taskToPrespool = EnumerableAsync.YieldAsync <Func <int, Task> >( async(yieldAsync) => { var tasks = Enumerable.Range(0, 100).Select(async(i) => { await Task.Run(() => Thread.Sleep(1000)); await yieldAsync(i); }); await Task.WhenAll(tasks); return; }); // Test fails without this line taskToPrespool = taskToPrespool.PrespoolAsync(); int total = 0; await taskToPrespool.ForAllAsync( async (i) => { await Task.FromResult(false); total += i; }); stopwatch.Stop(); Assert.IsTrue(stopwatch.ElapsedMilliseconds < 25000); Assert.AreEqual(4950, total); }
public override Task <IEnumerableAsync <IPackageSearchMetadata> > ListAsync(string searchTerm, bool prerelease, bool allVersions, bool includeDelisted, ILogger logger, CancellationToken token) { SearchFilter filter; if (allVersions) { filter = new SearchFilter(includePrerelease: prerelease, filter: null) { OrderBy = SearchOrderBy.Id, IncludeDelisted = includeDelisted }; } else if (prerelease) { filter = new SearchFilter(includePrerelease: true, filter: SearchFilterType.IsAbsoluteLatestVersion) { OrderBy = SearchOrderBy.Id, IncludeDelisted = includeDelisted }; } else { filter = new SearchFilter(includePrerelease: false, filter: SearchFilterType.IsLatestVersion) { OrderBy = SearchOrderBy.Id, IncludeDelisted = includeDelisted }; } IEnumerableAsync <IPackageSearchMetadata> enumerable = new EnumerableAsync <IPackageSearchMetadata>(_localPackageSearchResource, searchTerm, filter, logger, token); return(Task.FromResult(enumerable)); }
async Task RunForSymRTC( IEnumerableAsync <Sym.Message[]> messages, LogSourcePostprocessorInput postprocessorInput ) { IPrefixMatcher matcher = postprocessing.CreatePrefixMatcher(); var logMessages = messages.MatchTextPrefixes(matcher).Multiplex(); Sym.IMeetingsStateInspector symMeetingsStateInspector = new Sym.MeetingsStateInspector(matcher); Sym.IMediaStateInspector symMediaStateInspector = new Sym.MediaStateInspector(matcher, symMeetingsStateInspector); var symMeetingEvents = symMeetingsStateInspector.GetEvents(logMessages); var symMediagEvents = symMediaStateInspector.GetEvents(logMessages); matcher.Freeze(); var events = postprocessorInput.TemplatesTracker.TrackTemplates(EnumerableAsync.Merge( symMeetingEvents, symMediagEvents )); var serialize = postprocessing.StateInspector.SavePostprocessorOutput( events, null, evtTrigger => TextLogEventTrigger.Make((Sym.Message)evtTrigger), postprocessorInput ); await Task.WhenAll(serialize, logMessages.Open()); }
async Task RunForSpringServiceLog( IEnumerableAsync <SVC.Message[]> input, LogSourcePostprocessorInput postprocessorInput ) { var inputMultiplexed = input.Multiplex(); var messagingEventsSource = postprocessing.Timeline.CreateMessagingEventsSource(); var messagingEvents = messagingEventsSource.GetEvents( ((SVC.IMessagingEvents) new SVC.MessagingEvents()).GetEvents(inputMultiplexed)); var eofEvents = postprocessing.Timeline.CreateEndOfTimelineEventSource <SVC.Message>() .GetEvents(inputMultiplexed); var events = EnumerableAsync.Merge( messagingEvents, eofEvents ); var serialize = postprocessing.Timeline.CreatePostprocessorOutputBuilder() .SetEvents(events) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.Make((SVC.Message)evtTrigger)) .Build(postprocessorInput); await Task.WhenAll(serialize, inputMultiplexed.Open()); }
async static Task RunForSymRTC( IEnumerableAsync <Sym.Message[]> input, string outputFileName, CancellationToken cancellation, ICodepathTracker templatesTracker, XAttribute contentsEtagAttr ) { IPrefixMatcher matcher = new PrefixMatcher(); var logMessages = Sym.Helpers.MatchPrefixes(input, matcher).Multiplex(); Sym.IMeetingsStateInspector symMeetingsStateInspector = new Sym.MeetingsStateInspector(matcher); var symMeetingEvents = symMeetingsStateInspector.GetEvents(logMessages); matcher.Freeze(); var events = EnumerableAsync.Merge( symMeetingEvents.Select(ConvertTriggers <Sym.Message>) ).ToFlatList(); await Task.WhenAll(events, logMessages.Open()); if (cancellation.IsCancellationRequested) { return; } if (templatesTracker != null) { (await events).ForEach(e => templatesTracker.RegisterUsage(e.TemplateId)); } StateInspectorOutput.SerializePostprocessorOutput(await events, null, contentsEtagAttr).Save(outputFileName); }
async Task RunForSymLog( IEnumerableAsync <Sym.Message[]> input, LogSourcePostprocessorInput postprocessorInput ) { IPrefixMatcher matcher = postprocessing.CreatePrefixMatcher(); var inputMultiplexed = input.Multiplex(); var symEvents = RunForSymMessages(matcher, inputMultiplexed, postprocessorInput.TemplatesTracker, out var symLog); var endOfTimelineEventSource = postprocessing.Timeline.CreateEndOfTimelineEventSource <Sym.Message>(); var messagingEventsSource = postprocessing.Timeline.CreateMessagingEventsSource(); var messagingEvents = messagingEventsSource.GetEvents( ((Sym.IMessagingEvents) new Sym.MessagingEvents()).GetEvents(inputMultiplexed)); var eofEvts = endOfTimelineEventSource.GetEvents(inputMultiplexed); matcher.Freeze(); var events = EnumerableAsync.Merge( symEvents, messagingEvents, eofEvts ); var serialize = postprocessing.Timeline.CreatePostprocessorOutputBuilder() .SetEvents(events) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.Make((Sym.Message)evtTrigger)) .Build(postprocessorInput); await Task.WhenAll(serialize, symLog.Open(), inputMultiplexed.Open()); }
public async Task EnumerableAsyncGerenicTests() { var rand = new Random(); var items = EnumerableAsync.YieldAsync <TestDelegateAsync> ( async(yield) => { for (int i = 0; i < 100; i++) { await Task.Run(() => Thread.Sleep(rand.Next() % 20)); var yieldTask = yield(i, "foo", new List <int>()); try { await yieldTask; } catch (Exception ex) { throw ex; } } await yield(110, "bar", new List <int>()); await yield(111, "food", new List <int>()); await yield(112, "barf", new List <int>()); }); int count = 0; await items.ForAllAsync( async (a, b, c) => { await Task.Run(() => Thread.Sleep(rand.Next() % 30)); await Task.FromResult(true); count++; }); Assert.AreEqual(103, count); }
public async Task PrespoolMaintainOrder() { var stopwatch = new Stopwatch(); var taskToPrespool = EnumerableAsync.YieldAsync <Func <int, Task> >( async(yieldAsync) => { for (int i = 0; i < 100; i++) { await Task.Run(() => Thread.Sleep(10)); await yieldAsync(i); } return; }); // Test fails without this line taskToPrespool = taskToPrespool.PrespoolAsync(); await Task.Run(() => Thread.Sleep(1000)); stopwatch.Start(); int index = -1; await taskToPrespool.ForAllAsync( async (i) => { await Task.FromResult(false); Assert.IsTrue(index < i); index = i; }); stopwatch.Stop(); Assert.IsTrue(stopwatch.ElapsedMilliseconds < 500); }
private static async Task <List <Event> > RunForSymMessages( IPrefixMatcher matcher, IEnumerableAsync <Sym.Message[]> messages ) { Sym.IMeetingsStateInspector symMeetingsStateInsector = new Sym.MeetingsStateInspector(matcher); Sym.IMediaStateInspector symMediaStateInsector = new Sym.MediaStateInspector(matcher); Sym.ITimelineEvents symTimelineEvents = new Sym.TimelineEvents(matcher); var symLog = Sym.Helpers.MatchPrefixes(messages, matcher).Multiplex(); var symMeetingStateEvents = symMeetingsStateInsector.GetEvents(symLog); var symMediaStateEvents = symMediaStateInsector.GetEvents(symLog); var symMeetingEvents = (new InspectedObjectsLifetimeEventsSource(e => e.ObjectType == Sym.MeetingsStateInspector.MeetingTypeInfo || e.ObjectType == Sym.MeetingsStateInspector.MeetingSessionTypeInfo || e.ObjectType == Sym.MeetingsStateInspector.MeetingRemoteParticipantTypeInfo )).GetEvents(symMeetingStateEvents); var symMediaEvents = (new InspectedObjectsLifetimeEventsSource(e => e.ObjectType == Sym.MediaStateInspector.LocalScreenTypeInfo || e.ObjectType == Sym.MediaStateInspector.LocalAudioTypeInfo || e.ObjectType == Sym.MediaStateInspector.LocalVideoTypeInfo )).GetEvents(symMediaStateEvents); var events = EnumerableAsync.Merge( symMeetingEvents, symMediaEvents, symTimelineEvents.GetEvents(symLog) ).ToFlatList(); await Task.WhenAll(events, symLog.Open()); return(events.Result); }
async Task RunForWiresharkDpmlMessages( IEnumerableAsync <Pdml.Message[]> input, LogSourcePostprocessorInput postprocessorInput ) { var logMessages = input.Multiplex(); Pdml.ITimelineEvents networkEvents = new Pdml.TimelineEvents(); var endOfTimelineEventSource = postprocessing.Timeline.CreateEndOfTimelineEventSource <Pdml.Message>(); var networkEvts = networkEvents.GetEvents(logMessages); var eofEvts = endOfTimelineEventSource.GetEvents(logMessages); var events = EnumerableAsync.Merge( networkEvts, eofEvts ); var serialize = postprocessing.Timeline.CreatePostprocessorOutputBuilder() .SetEvents(events) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.Make((Pdml.Message)evtTrigger)) .Build(postprocessorInput); await Task.WhenAll(serialize, logMessages.Open()); }
async Task RunForChromeDebug( IEnumerableAsync <ChromeDebugLog.Message[]> input, LogSourcePostprocessorInput postprocessorInput ) { var multiplexedInput = input.Multiplex(); var matcher = postprocessing.CreatePrefixMatcher(); var extensionSources = pluginModel.ChromeDebugLogMessagingEventSources.Select(src => src( matcher, multiplexedInput, postprocessorInput.TemplatesTracker)).ToArray(); var events = EnumerableAsync.Merge(extensionSources.Select(s => s.Events).ToArray()); var serialize = postprocessing.SequenceDiagram.CreatePostprocessorOutputBuilder() .SetMessagingEvents(events) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.FromUnknownTrigger(evtTrigger)) .Build(postprocessorInput); var tasks = new List <Task>(); tasks.Add(serialize); tasks.AddRange(extensionSources.SelectMany(s => s.MultiplexingEnumerables.Select(e => e.Open()))); tasks.Add(multiplexedInput.Open()); await Task.WhenAll(tasks); }
async Task RunForChromeDebug( IEnumerableAsync <CDL.Message[]> input, LogSourcePostprocessorInput postprocessorInput ) { var multiplexedInput = input.Multiplex(); IPrefixMatcher matcher = postprocessing.CreatePrefixMatcher(); var extensionSources = pluginModel.ChromeDebugLogTimeLineEventSources.Select(src => src( matcher, multiplexedInput, postprocessorInput.TemplatesTracker)).ToArray(); var events = postprocessorInput.TemplatesTracker.TrackTemplates(EnumerableAsync.Merge(extensionSources.Select(s => s.Events).ToArray())); matcher.Freeze(); var serialize = postprocessing.Timeline.SavePostprocessorOutput( events, null, evtTrigger => TextLogEventTrigger.FromUnknownTrigger(evtTrigger), postprocessorInput ); var tasks = new List <Task>(); tasks.Add(serialize); tasks.AddRange(extensionSources.SelectMany(s => s.MultiplexingEnumerables.Select(e => e.Open()))); tasks.Add(multiplexedInput.Open()); await Task.WhenAll(tasks); }
async Task RunForWebRTCDump( IEnumerableAsync <WRD.Message[]> inputMessages, LogSourcePostprocessorInput postprocessorInput ) { IPrefixMatcher matcher = postprocessing.CreatePrefixMatcher(); var logMessages = WRD.Helpers.MatchPrefixes(inputMessages, matcher).Multiplex(); WRD.IWebRtcStateInspector webRtcStateInspector = new WRD.WebRtcStateInspector(matcher); var webRtcEvts = webRtcStateInspector.GetEvents(logMessages); matcher.Freeze(); var events = postprocessorInput.TemplatesTracker.TrackTemplates(EnumerableAsync.Merge( webRtcEvts )); var serialize = postprocessing.StateInspector.SavePostprocessorOutput( events, null, evtTrigger => TextLogEventTrigger.Make((WRD.Message)evtTrigger), postprocessorInput ); await Task.WhenAll(serialize, logMessages.Open()); }
public async Task EnumerableAsyncBrakedTests() { var rand = new Random(); var yieldCount = 0; var items = EnumerableAsync.YieldAsync <TestDelegateAsync>( async(yield) => { for (int i = 0; i < 100; i++) { yieldCount++; await yield(i, "foo", new List <int>()); } }); int count = 0; var culledItems = items.TakeAsync(50); await culledItems.ForAllAsync( async (a, b, c) => { await Task.Run(() => Thread.Sleep(rand.Next() % 20)); count++; }); Assert.AreEqual(50, count); Assert.AreEqual(51, yieldCount); }
async static Task RunForHttpArchive( IEnumerableAsync <HAR.Message[]> input, string outputFileName, CancellationToken cancellation, ICodepathTracker templatesTracker, XAttribute contentsEtagAttr ) { HAR.ITimelineEvents timelineEvents = new HAR.TimelineEvents(); var events = EnumerableAsync.Merge( timelineEvents.GetEvents(input) ) .ToFlatList(); await events; if (cancellation.IsCancellationRequested) { return; } if (templatesTracker != null) { (await events).ForEach(e => templatesTracker.RegisterUsage(e.TemplateId)); } TimelinePostprocessorOutput.SerializePostprocessorOutput( await events, null, evtTrigger => TextLogEventTrigger.Make((HAR.Message)evtTrigger), contentsEtagAttr ).SaveToFileOrToStdOut(outputFileName); }
async Task RunForChromeDebug(LogSourcePostprocessorInput input) { var reader = new CDL.Reader(postprocessing.TextLogParser, input.CancellationToken).Read(input.OpenLogFile, s => s.Dispose(), input.ProgressHandler); var multiplexedInput = reader.Multiplex(); IPrefixMatcher prefixMatcher = postprocessing.CreatePrefixMatcher(); var matchedMessages = multiplexedInput.MatchTextPrefixes(prefixMatcher).Multiplex(); var webRtcStateInspector = new CDL.WebRtcStateInspector(prefixMatcher); var processIdDetector = new CDL.ProcessIdDetector(); var nodeDetectionTokenTask = (new CDL.NodeDetectionTokenSource(processIdDetector, webRtcStateInspector)).GetToken(matchedMessages); var matcher = postprocessing.CreatePrefixMatcher(); var extensionSources = pluginModel.ChromeDebugLogMessagingEventSources.Select(src => src( matcher, multiplexedInput, input.TemplatesTracker)).ToArray(); var events = EnumerableAsync.Merge(extensionSources.Select(s => s.Events).ToArray()); var serialize = postprocessing.Correlation.CreatePostprocessorOutputBuilder() .SetSameNodeDetectionToken(nodeDetectionTokenTask) .SetMessagingEvents(events) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.FromUnknownTrigger(evtTrigger)) .Build(input); var tasks = new List <Task>(); tasks.Add(serialize); tasks.AddRange(extensionSources.SelectMany(s => s.MultiplexingEnumerables.Select(e => e.Open()))); tasks.Add(matchedMessages.Open()); tasks.Add(multiplexedInput.Open()); await Task.WhenAll(tasks); }
public static IEnumerableAsync <CloudTable> GetTables(this CloudTableClient tableClient) { var ranOnce = false; var continuationToken = default(TableContinuationToken); return(EnumerableAsync.YieldBatch <CloudTable>( async(yieldReturn, yieldBreak) => { if (continuationToken.IsDefaultOrNull()) { if (ranOnce) { return yieldBreak; } } ranOnce = true; var segment = await tableClient.ListTablesSegmentedAsync(continuationToken); continuationToken = segment.ContinuationToken; if (!segment.Results.Any()) { return yieldBreak; } return yieldReturn(segment.Results.ToArray()); })); }
static IEnumerableAsync <Checkpoint> EnumCheckpoints( ITextAccessIterator tai, PlainTextMatcher matcher, ProgressAndCancellation progressAndCancellation, LJTraceSource trace) { return(EnumerableAsync.Produce <Checkpoint>(async yieldAsync => { var advanceTime = new Stopwatch(); long advancesCount = 0; var matchingTime = new Stopwatch(); long matchCount = 0; for (; ;) { StringSlice buf = new StringSlice(tai.CurrentBuffer); for (int startIdx = 0; ;) { matchingTime.Start(); var match = matcher.Match(buf, startIdx); matchingTime.Stop(); ++matchCount; if (!match.HasValue) { break; } await yieldAsync.YieldAsync(new Checkpoint() { Position = tai.CharIndexToPosition(match.Value.MatchBegin), EndPosition = tai.CharIndexToPosition(match.Value.MatchEnd), IsMatch = true }); startIdx = match.Value.MatchEnd; progressAndCancellation.CheckTextIterationCancellation(); } advanceTime.Start(); bool stop = !await tai.Advance(Math.Max(0, tai.CurrentBuffer.Length - matcher.MaxMatchLength)); advanceTime.Stop(); ++advancesCount; if (stop) { break; } await yieldAsync.YieldAsync(new Checkpoint() { EndPosition = tai.CharIndexToPosition(0), IsMatch = false }); progressAndCancellation.CheckTextIterationCancellation(); } trace.Info("Stats: text buffer matching time: {0} ({1} times)", matchingTime.Elapsed, matchCount); trace.Info("Stats: text buffer advance time: {0}/{1}={2}", advanceTime.Elapsed, advancesCount, TimeSpan.FromTicks(advanceTime.ElapsedTicks / Math.Max(1, advancesCount))); })); }
private IEnumerableAsync <StorageDelegateAsync> FindByParentIdSomeNotFound(Guid parentId) { var items = EnumerableAsync.YieldAsync <StorageDelegateAsync>( async(yield) => { await Task.FromResult(true); throw new Exception("NotFoundStorage"); }); return(items); }
static IEnumerableAsync <FileRange.Range> IterateMatchRanges( IEnumerableAsync <Checkpoint> checkpoints, long threshhold, ProgressAndCancellation progressAndCancellation) { return(EnumerableAsync.Produce <FileRange.Range>(async yieldAsync => { FileRange.Range?lastMatch = null; await checkpoints.ForEach(async checkpoint => { if (lastMatch == null) { if (checkpoint.IsMatch) { lastMatch = new FileRange.Range(checkpoint.Position, checkpoint.EndPosition); } else { progressAndCancellation.continuationToken.NextPosition = checkpoint.EndPosition; progressAndCancellation.HandleTextIterationProgress(checkpoint.EndPosition); } } else { FileRange.Range lastMatchVal = lastMatch.Value; if (checkpoint.Position - lastMatchVal.End < threshhold) { if (checkpoint.IsMatch) { lastMatch = new FileRange.Range(lastMatchVal.Begin, checkpoint.EndPosition); } } else { await yieldAsync.YieldAsync(lastMatchVal); progressAndCancellation.continuationToken.NextPosition = checkpoint.EndPosition; progressAndCancellation.HandleTextIterationProgress(checkpoint.EndPosition); if (checkpoint.IsMatch) { lastMatch = new FileRange.Range(checkpoint.Position, checkpoint.EndPosition); } else { lastMatch = null; } } } return true; }); if (lastMatch != null) { await yieldAsync.YieldAsync(lastMatch.Value); } })); }
private IEnumerableAsync <Event[]> RunForClientMessages( IEnumerableAsync <Cli.Message[]> messages ) { Cli.IMessagingEvents messagingEvents = new Cli.MessagingEvents(); var events = EnumerableAsync.Merge( messagingEvents.GetEvents(messages) ); return(events); }
Chromium.EventsSource <Event, Chromium.ChromeDebugLog.Message> .Factory IPostprocessorsFactory.CreateChromeDebugLogEventsSourceFactory() { return((matcher, messages, tracker) => { var symEvents = RunForClientMessages( new Cli.Reader(postprocessing.TextLogParser, CancellationToken.None).FromChromeDebugLog(messages) ); var events = EnumerableAsync.Merge( symEvents ); return new Chromium.EventsSource <Event, Chromium.ChromeDebugLog.Message>(events); }); }
async Task RunForSpringServiceLog(LogSourcePostprocessorInput input) { var reader = new SpringServiceLog.Reader(postprocessingModel.TextLogParser, input.CancellationToken).Read(input.LogFileName, input.ProgressHandler); SVC.IMessagingEvents messagingEvents = new SVC.MessagingEvents(); var events = EnumerableAsync.Merge( messagingEvents.GetEvents(reader) ); await postprocessingModel.Correlation.CreatePostprocessorOutputBuilder() .SetMessagingEvents(events) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.Make((SVC.Message)evtTrigger)) .Build(input); }
async static Task RunForChromeDebug( IEnumerableAsync <CDL.Message[]> input, string outputFileName, CancellationToken cancellation, ICodepathTracker templatesTracker, XAttribute contentsEtagAttr ) { var multiplexedInput = input.Multiplex(); IPrefixMatcher matcher = new PrefixMatcher(); var logMessages = CDL.Helpers.MatchPrefixes(multiplexedInput, matcher).Multiplex(); Sym.IMeetingsStateInspector symMeetingsStateInsector = new Sym.MeetingsStateInspector(matcher); var symLog = Sym.Helpers.MatchPrefixes((new Sym.Reader()).FromChromeDebugLog(multiplexedInput), matcher).Multiplex(); var symMeetingStateEvents = symMeetingsStateInsector.GetEvents(symLog); var symMeetingEvents = (new InspectedObjectsLifetimeEventsSource(e => e.ObjectType == Sym.MeetingsStateInspector.MeetingTypeInfo || e.ObjectType == Sym.MeetingsStateInspector.MeetingSessionTypeInfo )).GetEvents(symMeetingStateEvents); matcher.Freeze(); var events = EnumerableAsync.Merge( symMeetingEvents ) .ToFlatList(); await Task.WhenAll(events, symLog.Open(), /*logMessages.Open(),*/ multiplexedInput.Open()); if (cancellation.IsCancellationRequested) { return; } if (templatesTracker != null) { (await events).ForEach(e => templatesTracker.RegisterUsage(e.TemplateId)); } TimelinePostprocessorOutput.SerializePostprocessorOutput( await events, null, evtTrigger => TextLogEventTrigger.Make((Sym.Message)evtTrigger), contentsEtagAttr ).SaveToFileOrToStdOut(outputFileName); }
async Task RunForHttpArchive( IEnumerableAsync <HAR.Message[]> input, LogSourcePostprocessorInput postprocessorInput ) { HAR.ITimelineEvents timelineEvents = new HAR.TimelineEvents(); var events = EnumerableAsync.Merge( postprocessorInput.TemplatesTracker.TrackTemplates(timelineEvents.GetEvents(input)) ); await postprocessing.Timeline.CreatePostprocessorOutputBuilder() .SetEvents(events) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.Make((HAR.Message)evtTrigger)) .Build(postprocessorInput); }
async Task RunForHttpArchive( IEnumerableAsync <HAR.Message[]> input, LogSourcePostprocessorInput postprocessorInput ) { HAR.IMessagingEvents messagingEvents = new HAR.MessagingEvents(); var events = EnumerableAsync.Merge( messagingEvents.GetEvents(input) ); await postprocessing.SequenceDiagram.CreatePostprocessorOutputBuilder() .SetMessagingEvents(events) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.Make((HAR.Message)evtTrigger)) .Build(postprocessorInput); }
async Task RunForChromeDriver(LogSourcePostprocessorInput input) { var reader = (new CD.Reader(postprocessing.TextLogParser, input.CancellationToken)).Read(input.LogFileName, input.ProgressHandler); IPrefixMatcher prefixMatcher = postprocessing.CreatePrefixMatcher(); var matchedMessages = reader.MatchTextPrefixes(prefixMatcher).Multiplex(); var nodeDetectionTokenTask = (new CD.NodeDetectionTokenSource(new CD.ProcessIdDetector(prefixMatcher), prefixMatcher)).GetToken(matchedMessages); var noMessagingEvents = EnumerableAsync.Empty <M.Event[]>(); var serialize = postprocessing.Correlation.CreatePostprocessorOutputBuilder() .SetSameNodeDetectionToken(nodeDetectionTokenTask) .SetTriggersConverter(evtTrigger => TextLogEventTrigger.Make((CD.Message)evtTrigger)) .Build(input); await Task.WhenAll( matchedMessages.Open(), serialize ); }
async Task RunForChromeDebug( IEnumerableAsync <CDL.Message[]> inputMessages, LogSourcePostprocessorInput postprocessorInput ) { var inputMultiplexed = inputMessages.Multiplex(); IPrefixMatcher matcher = postprocessing.CreatePrefixMatcher(); var logMessages = inputMultiplexed.MatchTextPrefixes(matcher).Multiplex(); CDL.IWebRtcStateInspector webRtcStateInspector = new CDL.WebRtcStateInspector(matcher); var webRtcEvts = webRtcStateInspector.GetEvents(logMessages); var extensionSources = pluginModel .ChromeDebugStateEventSources.Select( source => source(matcher, inputMultiplexed, postprocessorInput.TemplatesTracker) ) .ToArray(); var eventSources = new List <IEnumerableAsync <Event[]> > { webRtcEvts }; eventSources.AddRange(extensionSources.Select(s => s.Events)); matcher.Freeze(); var events = postprocessorInput.TemplatesTracker.TrackTemplates(EnumerableAsync.Merge(eventSources.ToArray())); var serialize = postprocessing.StateInspector.SavePostprocessorOutput( events, null, evtTrigger => TextLogEventTrigger.FromUnknownTrigger(evtTrigger), postprocessorInput ); var tasks = new List <Task>(); tasks.Add(serialize); tasks.AddRange(extensionSources.SelectMany(s => s.MultiplexingEnumerables.Select(e => e.Open()))); tasks.Add(logMessages.Open()); tasks.Add(inputMultiplexed.Open()); await Task.WhenAll(tasks); }
public static IEnumerableAsync <Adapter> FindAll(string resourceType) { if (resourceType.IsNullOrWhiteSpace()) { return(EnumerableAsync.Empty <Adapter>()); } return(AzureStorageRepository.Connection( azureStorageRepository => { var whereResourceTypeQuery = TableQuery.GenerateFilterCondition("ResourceType", QueryComparisons.Equal, resourceType); var adapterQuery = new TableQuery <AdapterDocument>().Where(whereResourceTypeQuery); return azureStorageRepository .FindAllAsync(adapterQuery) .Select(Convert); })); }
private IEnumerableAsync <StorageDelegateAsync> FindByParentId(Guid parentId) { var items = EnumerableAsync.YieldAsync <StorageDelegateAsync>( async(yield) => { var tasks = new List <Task>(); for (int i = 0; i < 100; i++) { await yield(i, "foo"); } await yield(110, "bar"); await yield(111, "food"); await yield(112, "barf"); }); return(items); }