public SingletonValueProviderTests()
{
_attribute = new SingletonAttribute("TestScope");
SingletonManager singletonManager = new SingletonManager(null, null, null, null, new FixedHostIdProvider(TestHostId));
_method = GetType().GetMethod("TestJob", BindingFlags.Static | BindingFlags.Public);
_lockId = SingletonManager.FormatLockId(_method, SingletonScope.Function, TestHostId, _attribute.ScopeId);
_valueProvider = new SingletonValueProvider(_method, "TestScope", TestInstanceId, _attribute, singletonManager);
}
public SingletonValueProviderTests()
{
_attribute = new SingletonAttribute("TestScope");
SingletonManager singletonManager = new SingletonManager();
_method = GetType().GetMethod("TestJob", BindingFlags.Static | BindingFlags.Public);
_lockId = SingletonManager.FormatLockId(_method, _attribute.Scope);
_valueProvider = new SingletonValueProvider(_method, "TestScope", TestInstanceId, _attribute, singletonManager);
}
public SingletonValueProviderTests()
{
_attribute = new SingletonAttribute("TestScope");
SingletonManager singletonManager = new SingletonManager();
_method = GetType().GetMethod("TestJob", BindingFlags.Static | BindingFlags.Public);
_lockId = SingletonManager.FormatLockId(_method, _attribute.Scope);
_valueProvider = new SingletonValueProvider(_method, "TestScope", TestInstanceId, _attribute, singletonManager);
}
public SingletonValueProviderTests()
{
_attribute = new SingletonAttribute("TestScope");
SingletonManager singletonManager = new SingletonManager(null, null, null, null, new FixedHostIdProvider(TestHostId));
_method = GetType().GetMethod("TestJob", BindingFlags.Static | BindingFlags.Public);
_lockId = SingletonManager.FormatLockId(_method, SingletonScope.Function, TestHostId, _attribute.ScopeId);
_valueProvider = new SingletonValueProvider(_method, "TestScope", TestInstanceId, _attribute, singletonManager);
}
public void ToInvokeString_ReturnsExpectedValue()
{
SingletonAttribute attribute = new SingletonAttribute();
SingletonValueProvider localValueProvider = new SingletonValueProvider(_method, attribute.Scope, TestInstanceId, attribute, new SingletonManager());
SingletonLock singletonLock = (SingletonLock)localValueProvider.GetValue();
Assert.Equal("Scope: default", localValueProvider.ToInvokeString());
attribute = new SingletonAttribute(@"{Region}\{Zone}");
localValueProvider = new SingletonValueProvider(_method, @"Central\3", TestInstanceId, attribute, new SingletonManager());
singletonLock = (SingletonLock)localValueProvider.GetValue();
Assert.Equal(@"Scope: Central\3", localValueProvider.ToInvokeString());
}
public void ToInvokeString_ReturnsExpectedValue()
{
SingletonAttribute attribute = new SingletonAttribute();
SingletonValueProvider localValueProvider = new SingletonValueProvider(_method, attribute.Scope, TestInstanceId, attribute, new SingletonManager());
SingletonLock singletonLock = (SingletonLock)localValueProvider.GetValue();
Assert.Equal("Scope: default", localValueProvider.ToInvokeString());
attribute = new SingletonAttribute(@"{Region}\{Zone}");
localValueProvider = new SingletonValueProvider(_method, @"Central\3", TestInstanceId, attribute, new SingletonManager());
singletonLock = (SingletonLock)localValueProvider.GetValue();
Assert.Equal(@"Scope: Central\3", localValueProvider.ToInvokeString());
}
public async Task ToInvokeString_ReturnsExpectedValue()
{
SingletonManager singletonManager = new SingletonManager(null, null, null, null, null, new FixedHostIdProvider(TestHostId));
SingletonAttribute attribute = new SingletonAttribute();
SingletonValueProvider localValueProvider = new SingletonValueProvider(_method, attribute.ScopeId, TestInstanceId, attribute, singletonManager);
SingletonLock singletonLock = (SingletonLock)(await localValueProvider.GetValueAsync());
Assert.Equal("ScopeId: (null)", localValueProvider.ToInvokeString());
attribute = new SingletonAttribute(@"{Region}\{Zone}");
localValueProvider = new SingletonValueProvider(_method, @"Central\3", TestInstanceId, attribute, singletonManager);
singletonLock = (SingletonLock)(await localValueProvider.GetValueAsync());
Assert.Equal(@"ScopeId: Central\3", localValueProvider.ToInvokeString());
}
public async Task <IReadOnlyDictionary <string, IValueProvider> > BindAsync(ValueBindingContext context, IDictionary <string, object> parameters)
{
Dictionary <string, IValueProvider> results = new Dictionary <string, IValueProvider>();
// Supplied bindings can be direct parameters or route parameters.
BindingContext bindingContext = NewBindingContext(context, null, parameters);
// bind Singleton if specified
SingletonAttribute singletonAttribute = SingletonManager.GetFunctionSingletonOrNull(_descriptor.Method, isTriggered: false);
if (singletonAttribute != null)
{
string boundScopeId = _singletonManager.GetBoundScopeId(singletonAttribute.ScopeId);
IValueProvider singletonValueProvider = new SingletonValueProvider(_descriptor.Method, boundScopeId, context.FunctionInstanceId.ToString(), singletonAttribute, _singletonManager);
results.Add(SingletonValueProvider.SingletonParameterName, singletonValueProvider);
}
foreach (KeyValuePair <string, IBinding> item in _bindings)
{
string name = item.Key;
IBinding binding = item.Value;
IValueProvider valueProvider;
try
{
if (parameters != null && parameters.ContainsKey(name))
{
valueProvider = await binding.BindAsync(parameters[name], context);
}
else
{
valueProvider = await binding.BindAsync(bindingContext);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
valueProvider = new BindingExceptionValueProvider(name, exception);
}
results.Add(name, valueProvider);
}
return(results);
}
public async Task<IReadOnlyDictionary<string, IValueProvider>> BindAsync(ValueBindingContext context, IDictionary<string, object> parameters)
{
Dictionary<string, IValueProvider> results = new Dictionary<string, IValueProvider>();
// Supplied bindings can be direct parameters or route parameters.
BindingContext bindingContext = NewBindingContext(context, null, parameters);
// bind Singleton if specified
SingletonAttribute singletonAttribute = SingletonManager.GetFunctionSingletonOrNull(_descriptor.Method, isTriggered: false);
if (singletonAttribute != null)
{
string boundScopeId = _singletonManager.GetBoundScopeId(singletonAttribute.ScopeId);
IValueProvider singletonValueProvider = new SingletonValueProvider(_descriptor.Method, boundScopeId, context.FunctionInstanceId.ToString(), singletonAttribute, _singletonManager);
results.Add(SingletonValueProvider.SingletonParameterName, singletonValueProvider);
}
foreach (KeyValuePair<string, IBinding> item in _bindings)
{
string name = item.Key;
IBinding binding = item.Value;
IValueProvider valueProvider;
try
{
if (parameters != null && parameters.ContainsKey(name))
{
valueProvider = await binding.BindAsync(parameters[name], context);
}
else
{
valueProvider = await binding.BindAsync(bindingContext);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
valueProvider = new BindingExceptionValueProvider(name, exception);
}
results.Add(name, valueProvider);
}
return results;
}
public async Task SingletonWatcher_GetStatus_ReturnsExpectedValue()
{
Mock <SingletonManager> mockSingletonManager = new Mock <SingletonManager>(MockBehavior.Strict, null, null, null, null, null, new FixedHostIdProvider(TestHostId), null);
mockSingletonManager.Setup(p => p.GetLockOwnerAsync(_attribute, _lockId, CancellationToken.None)).ReturnsAsync("someotherguy");
SingletonValueProvider localValueProvider = new SingletonValueProvider(_method, _attribute.ScopeId, TestInstanceId, _attribute, mockSingletonManager.Object);
SingletonLock localSingletonLock = (SingletonLock)(await localValueProvider.GetValueAsync());
// set start time before _minimumWaitForFirstOwnerCheck in SingletonValueProvider
DateTime startTime = DateTime.UtcNow - TimeSpan.FromSeconds(11);
DateTime endTime = DateTime.UtcNow + TimeSpan.FromSeconds(2);
DateTime releaseTime = endTime + TimeSpan.FromSeconds(1);
// before lock is called
SingletonValueProvider.SingletonWatcher watcher = (SingletonValueProvider.SingletonWatcher)localValueProvider.Watcher;
SingletonParameterLog log = (SingletonParameterLog)watcher.GetStatus();
Assert.Null(log.LockOwner);
Assert.False(log.LockAcquired);
Assert.Null(log.LockDuration);
Assert.Null(log.TimeToAcquireLock);
// in the process of locking
localSingletonLock.AcquireStartTime = startTime;
log = (SingletonParameterLog)watcher.GetStatus();
Assert.Equal("someotherguy", log.LockOwner);
Assert.False(log.LockAcquired);
Assert.Null(log.LockDuration);
Assert.NotNull(log.TimeToAcquireLock);
// lock acquired but not released
localSingletonLock.AcquireEndTime = endTime;
log = (SingletonParameterLog)watcher.GetStatus();
Assert.Null(log.LockOwner);
Assert.True(log.LockAcquired);
Assert.NotNull(log.LockDuration);
Assert.Equal(endTime - startTime, log.TimeToAcquireLock);
// lock released
localSingletonLock.ReleaseTime = releaseTime;
log = (SingletonParameterLog)watcher.GetStatus();
Assert.Null(log.LockOwner);
Assert.True(log.LockAcquired);
Assert.Equal(releaseTime - endTime, log.LockDuration);
Assert.Equal(endTime - startTime, log.TimeToAcquireLock);
}
public async Task<IReadOnlyDictionary<string, IValueProvider>> BindAsync(ValueBindingContext context, IDictionary<string, object> parameters)
{
Dictionary<string, IValueProvider> results = new Dictionary<string, IValueProvider>();
BindingContext bindingContext = new BindingContext(context, null);
// bind Singleton if specified
SingletonAttribute singletonAttribute = _descriptor.Method.GetCustomAttribute<SingletonAttribute>();
if (singletonAttribute != null)
{
IValueProvider singletonValueProvider = new SingletonValueProvider(_descriptor.Method, singletonAttribute.Scope, context.FunctionInstanceId.ToString(), singletonAttribute, _singletonManager);
results.Add(SingletonValueProvider.SingletonParameterName, singletonValueProvider);
}
foreach (KeyValuePair<string, IBinding> item in _bindings)
{
string name = item.Key;
IBinding binding = item.Value;
IValueProvider valueProvider;
try
{
if (parameters != null && parameters.ContainsKey(name))
{
valueProvider = await binding.BindAsync(parameters[name], context);
}
else
{
valueProvider = await binding.BindAsync(bindingContext);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
valueProvider = new BindingExceptionValueProvider(name, exception);
}
results.Add(name, valueProvider);
}
return results;
}
public void SingletonWatcher_GetStatus_ReturnsExpectedValue()
{
Mock<SingletonManager> mockSingletonManager = new Mock<SingletonManager>(MockBehavior.Strict, null, null, null, null, new FixedHostIdProvider(TestHostId), null);
mockSingletonManager.Setup(p => p.GetLockOwnerAsync(_attribute, _lockId, CancellationToken.None)).ReturnsAsync("someotherguy");
SingletonValueProvider localValueProvider = new SingletonValueProvider(_method, _attribute.ScopeId, TestInstanceId, _attribute, mockSingletonManager.Object);
SingletonLock localSingletonLock = (SingletonLock)localValueProvider.GetValue();
DateTime startTime = DateTime.Now;
DateTime endTime = startTime + TimeSpan.FromSeconds(2);
DateTime releaseTime = endTime + TimeSpan.FromSeconds(1);
// before lock is called
SingletonValueProvider.SingletonWatcher watcher = (SingletonValueProvider.SingletonWatcher)localValueProvider.Watcher;
SingletonParameterLog log = (SingletonParameterLog)watcher.GetStatus();
Assert.Null(log.LockOwner);
Assert.False(log.LockAcquired);
Assert.Null(log.LockDuration);
Assert.Null(log.TimeToAcquireLock);
// in the process of locking
localSingletonLock.AcquireStartTime = startTime;
log = (SingletonParameterLog)watcher.GetStatus();
Assert.Equal("someotherguy", log.LockOwner);
Assert.False(log.LockAcquired);
Assert.Null(log.LockDuration);
Assert.NotNull(log.TimeToAcquireLock);
// lock acquired but not released
localSingletonLock.AcquireEndTime = endTime;
log = (SingletonParameterLog)watcher.GetStatus();
Assert.Null(log.LockOwner);
Assert.True(log.LockAcquired);
Assert.NotNull(log.LockDuration);
Assert.Equal(endTime - startTime, log.TimeToAcquireLock);
// lock released
localSingletonLock.ReleaseTime = releaseTime;
log = (SingletonParameterLog)watcher.GetStatus();
Assert.Null(log.LockOwner);
Assert.True(log.LockAcquired);
Assert.Equal(releaseTime - endTime, log.LockDuration);
Assert.Equal(endTime - startTime, log.TimeToAcquireLock);
}
private async Task <IReadOnlyDictionary <string, IValueProvider> > BindCoreAsync(ValueBindingContext context, object value, IDictionary <string, object> parameters)
{
Dictionary <string, IValueProvider> valueProviders = new Dictionary <string, IValueProvider>();
IValueProvider triggerProvider;
IReadOnlyDictionary <string, object> bindingData;
try
{
ITriggerData triggerData = await _triggerBinding.BindAsync(value, context);
triggerProvider = triggerData.ValueProvider;
bindingData = triggerData.BindingData;
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
triggerProvider = new BindingExceptionValueProvider(_triggerParameterName, exception);
bindingData = null;
}
valueProviders.Add(_triggerParameterName, triggerProvider);
BindingContext bindingContext = FunctionBinding.NewBindingContext(context, bindingData, parameters);
// Bind Singleton if specified
SingletonAttribute singletonAttribute = SingletonManager.GetFunctionSingletonOrNull(_descriptor.Method, isTriggered: true);
if (singletonAttribute != null)
{
string boundScopeId = _singletonManager.GetBoundScopeId(singletonAttribute.ScopeId, bindingData);
IValueProvider singletonValueProvider = new SingletonValueProvider(_descriptor.Method, boundScopeId, context.FunctionInstanceId.ToString(), singletonAttribute, _singletonManager);
valueProviders.Add(SingletonValueProvider.SingletonParameterName, singletonValueProvider);
}
foreach (KeyValuePair <string, IBinding> item in _nonTriggerBindings)
{
string name = item.Key;
IBinding binding = item.Value;
IValueProvider valueProvider;
try
{
if (parameters != null && parameters.ContainsKey(name))
{
valueProvider = await binding.BindAsync(parameters[name], context);
}
else
{
valueProvider = await binding.BindAsync(bindingContext);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
valueProvider = new BindingExceptionValueProvider(name, exception);
}
valueProviders.Add(name, valueProvider);
}
return(valueProviders);
}
public LifetimeService(SingletonValueProvider singletonValueProvider, TransientValueProvider transientValueProvider, ScopedValueProvider scopedValueProvider)
{
_singletonValueProvider = singletonValueProvider;
_transientValueProvider = transientValueProvider;
_scopedValueProvider = scopedValueProvider;
}
private async Task <IReadOnlyDictionary <string, IValueProvider> > BindCoreAsync(ValueBindingContext context, object value, IDictionary <string, object> parameters)
{
Dictionary <string, IValueProvider> valueProviders = new Dictionary <string, IValueProvider>();
IValueProvider triggerProvider;
IReadOnlyDictionary <string, object> bindingData;
IValueBinder triggerReturnValueProvider = null;
try
{
ITriggerData triggerData = await _triggerBinding.BindAsync(value, context);
triggerProvider = triggerData.ValueProvider;
bindingData = triggerData.BindingData;
triggerReturnValueProvider = (triggerData as TriggerData)?.ReturnValueProvider;
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
triggerProvider = new BindingExceptionValueProvider(_triggerParameterName, exception);
bindingData = null;
}
valueProviders.Add(_triggerParameterName, triggerProvider);
// Bind Singleton if specified
SingletonAttribute singletonAttribute = SingletonManager.GetFunctionSingletonOrNull(_descriptor, isTriggered: true);
if (singletonAttribute != null)
{
string boundScopeId = _singletonManager.GetBoundScopeId(singletonAttribute.ScopeId, bindingData);
IValueProvider singletonValueProvider = new SingletonValueProvider(_descriptor, boundScopeId, context.FunctionInstanceId.ToString(), singletonAttribute, _singletonManager);
valueProviders.Add(SingletonValueProvider.SingletonParameterName, singletonValueProvider);
}
BindingContext bindingContext = FunctionBinding.NewBindingContext(context, bindingData, parameters);
foreach (KeyValuePair <string, IBinding> item in _nonTriggerBindings)
{
string name = item.Key;
IBinding binding = item.Value;
IValueProvider valueProvider;
try
{
if (parameters != null && parameters.ContainsKey(name))
{
valueProvider = await binding.BindAsync(parameters[name], context);
}
else
{
valueProvider = await binding.BindAsync(bindingContext);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
valueProvider = new BindingExceptionValueProvider(name, exception);
}
valueProviders.Add(name, valueProvider);
}
// Triggers can optionally process the return values of functions. They do so by declaring
// a "$return" key in their binding data dictionary and mapping it to an IValueBinder.
// An explicit return binding takes precedence over an implicit trigger binding.
if (!valueProviders.ContainsKey(FunctionIndexer.ReturnParamName))
{
if (triggerReturnValueProvider != null)
{
valueProviders.Add(FunctionIndexer.ReturnParamName, triggerReturnValueProvider);
}
}
return(valueProviders);
}
