private AvailabilityResultAsyncCollector CreateAvailabilityResultAsyncCollector(AvailabilityTestResultAttribute attribute, ValueBindingContext valueBindingContext)
{
// A function is defined as an Availability Test iff is has a return value marked with [AvailabilityTestResult].
// If that is the case, this method will be invoked as some point to construct a collector for the return value.
// Depending on the kind of the function, this will happen in different ways:
//
// - For .Net functions (in-proc), this method runs BEFORE function filters:
// a) We will register this function as an Availability Test in the Functions registry (this is a NoOp for all,
// except the very first invocation).
// b) We will create new invocation state bag and register it with the Invocations registry.
// c) We will instantiate a result collector and attach it to the state bag.
// d) Later on, BEFORE the function body runs, the runtime execute the pre-function filter. At that point we will:
// ~ Initialize an Availablity Test Scope and attach it to the invocation state bag;
// ~ Link the results collector and the test scope.
// e) Subsequently, AFTER the function body runs the result will be set in one of two ways:
// ~ If no error: the runtime will add the return value to the result collector -> the collector will Complete the Test Scope;
// ~ If error/exception: the runtime will invoke the post-function filter -> the filter will Complete the Test Scope.
//
// - For non-.Net functions (out-of-proc), this method runs AFTER function filters (and, potentially, even AFTER the function body has completed):
// a) Registering this function as an Availability Test in the Functions registry will be a NoOp.
// b) We will receive an existing invocation state bag; the Availablity Test Scope will be already set in the state bag.
// c&d) We will instantiate a result collector and link it with the test scope right away; we will attach the collector to the state bag.
// e) The results will be set in a simillar manner as for .Net described above.
Validate.NotNull(attribute, nameof(attribute));
Validate.NotNull(valueBindingContext, nameof(valueBindingContext));
string functionName = valueBindingContext.FunctionContext.MethodName;
using (_log.BeginScope(LogMonikers.Scopes.CreateForTestInvocation(functionName)))
{
// Register this Function as an Availability Test (NoOp for all invocations of this method, except the very first one):
_availabilityTestRegistry.Functions.Register(functionName, attribute, _log);
// Register this particular invocation of this function:
Guid functionInstanceId = valueBindingContext.FunctionInstanceId;
AvailabilityTestInvocationState invocationState = _availabilityTestRegistry.Invocations.GetOrRegister(functionInstanceId, _log);
// Create the result collector:
var resultCollector = new AvailabilityResultAsyncCollector();
// If the test scope is already set (out-of-proc function), then link it with the collector:
bool isTestScopeInitialized = invocationState.TryGetTestScope(out AvailabilityTestScope testScope);
if (isTestScopeInitialized)
{
resultCollector.Initialize(testScope);
}
// Attache the collector to the invocation state bag:
invocationState.AttachResultCollector(resultCollector);
// Done:
return(resultCollector);
}
}
public bool TryGetResultCollector(out AvailabilityResultAsyncCollector resultCollector)
{
resultCollector = _resultCollector;
return(resultCollector != null);
}
public void AttachResultCollector(AvailabilityResultAsyncCollector resultCollector)
{
Validate.NotNull(resultCollector, nameof(resultCollector));
_resultCollector = resultCollector;
}
private Task <IAsyncCollector <bool> > CreateBoolAsyncCollector(AvailabilityTestResultAttribute attribute, ValueBindingContext valueBindingContext)
{
AvailabilityResultAsyncCollector resultCollector = CreateAvailabilityResultAsyncCollector(attribute, valueBindingContext);
return(Task.FromResult <IAsyncCollector <bool> >(resultCollector));
}