public async Task ReadNoTable()
{
ILogReader reader = LogFactory.NewReader(this);
Assert.Empty(_tables); // no tables yet.
var segmentDef = await reader.GetFunctionDefinitionsAsync(null, null);
Assert.Empty(segmentDef.Results);
var segmentTimeline = await reader.GetActiveContainerTimelineAsync(DateTime.MinValue, DateTime.MaxValue, null);
Assert.Empty(segmentTimeline.Results);
var segmentRecent = await reader.GetRecentFunctionInstancesAsync(new RecentFunctionQuery
{
FunctionId = FunctionId.Parse("abc"),
Start = DateTime.MinValue,
End = DateTime.MaxValue,
MaximumResults = 1000
}, null);
Assert.Empty(segmentRecent.Results);
var item = await reader.LookupFunctionInstanceAsync(Guid.NewGuid());
Assert.Null(item);
}
public void Direct()
{
string str = "ab-def%:x$";
var f = FunctionId.Parse(str);
Assert.Equal(str, f.ToString());
}
FunctionStatistics IFunctionStatisticsReader.Lookup(string functionId)
{
var theTask = Task.Run(() => LookupAsync(FunctionId.Parse(functionId)));
var retVal = theTask.GetAwaiter().GetResult();
return(retVal);
}
IResultSegment <RecentInvocationEntry> IRecentInvocationIndexByFunctionReader.Read(string functionId, int maximumResults, string continuationToken)
{
var theTask = Task.Run(() => Read3Async(FunctionId.Parse(functionId), maximumResults, continuationToken));
var retVal = theTask.GetAwaiter().GetResult();
return(retVal);
}
public async Task <IHttpActionResult> GetRecentInvocationsTimeline(
string functionId,
[FromUri] PagingInfo pagingInfo,
DateTime?start = null,
DateTime?end = null)
{
if (end == null)
{
end = DateTime.UtcNow;
}
if (start == null)
{
start = end.Value.AddDays(-7);
}
if (pagingInfo == null)
{
return(BadRequest());
}
var segment = await _reader.GetAggregateStatsAsync(FunctionId.Parse(functionId), start.Value, end.Value, null);
var entities = segment.Results;
var result = Array.ConvertAll(entities, entity => new
{
StartBucket = entity.TimeBucket,
Start = entity.Time,
TotalPass = entity.TotalPass,
TotalFail = entity.TotalFail,
TotalRun = entity.TotalRun
});
return(Ok(result));
}
private async Task <IResultSegment <RecentInvocationEntry> > Read2Async(int maximumResults, string continuationToken)
{
var endTime = FromContinuationToken(continuationToken, DateTime.MaxValue);
var snapshots = await GetSnapshotsAsync();
string[] functionIds = Array.ConvertAll(snapshots, x => x.Id);
Task <Segment <IRecentFunctionEntry> >[] queryTasks = Array.ConvertAll(
functionIds,
functionId => _reader.GetRecentFunctionInstancesAsync(new RecentFunctionQuery
{
FunctionId = FunctionId.Parse(functionId),
MaximumResults = maximumResults,
Start = DateTime.MinValue,
End = endTime
}, null));
Segment <IRecentFunctionEntry>[] queries = await Task.WhenAll(queryTasks);
IRecentFunctionEntry[][] results = Array.ConvertAll(queries, query => query.Results);
// Merge and sort
List <IRecentFunctionEntry> flatListEntities = new List <IRecentFunctionEntry>();
foreach (var set in results)
{
flatListEntities.AddRange(set);
}
var entityValues = flatListEntities.ToArray();
var keys = Array.ConvertAll(entityValues, x => DescendingTime(x.StartTime)); // sort descending by time, most recent at top
Array.Sort(keys, entityValues);
int available = entityValues.Length;
entityValues = entityValues.Take(maximumResults).ToArray();
string continuationToken2 = null;
if (available > maximumResults)
{
var lastDate = entityValues[entityValues.Length - 1].StartTime.DateTime;
lastDate.AddTicks(-1); // Descending timescale.
continuationToken2 = ToContinuationToken(lastDate);
}
var finalValues = Array.ConvertAll(entityValues, entity => Convert(entity));
return(new ResultSegment <RecentInvocationEntry>(finalValues, continuationToken2));
}
