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