public async Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
HttpRequestMessage request = value as HttpRequestMessage;
if (request == null && value != null && value.GetType() == typeof(string))
{
// We've received an invoke string (e.g. from a Dashboard replay/invoke
// so convert to a request
request = FromInvokeString((string)value);
}
IValueProvider valueProvider = null;
IReadOnlyDictionary<string, object> bindingData = null;
string invokeString = ToInvokeString(request);
if (_isUserTypeBinding)
{
valueProvider = await CreateUserTypeValueProvider(request, invokeString);
if (_bindingDataProvider != null)
{
// the provider might be null if the Type is invalid, or if the Type
// has no public properties to bind to
bindingData = _bindingDataProvider.GetBindingData(valueProvider.GetValue());
}
}
else
{
valueProvider = new WebHookRequestValueBinder(_parameter, request, invokeString);
}
return new TriggerData(valueProvider, bindingData);
}
// Create a bindingContext.
// parameters takes precedence over existingBindingData.
internal static BindingContext NewBindingContext(
ValueBindingContext context,
IReadOnlyDictionary<string, object> existingBindingData,
IDictionary<string, object> parameters)
{
// if bindingData was a mutable dictionary, we could just add it.
// But since it's read-only, must create a new one.
Dictionary<string, object> bindingData = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
if (existingBindingData != null)
{
foreach (var kv in existingBindingData)
{
bindingData[kv.Key] = kv.Value;
}
}
if (parameters != null)
{
foreach (var kv in parameters)
{
bindingData[kv.Key] = kv.Value;
}
}
BindingContext bindingContext = new BindingContext(context, bindingData);
return bindingContext;
}
public async Task BindAsync_ReturnsExpectedTriggerData()
{
ParameterInfo parameter = GetType().GetMethod("TestTimerJob").GetParameters()[0];
MethodInfo methodInfo = (MethodInfo)parameter.Member;
string timerName = string.Format("{0}.{1}", methodInfo.DeclaringType.FullName, methodInfo.Name);
Mock<ScheduleMonitor> mockScheduleMonitor = new Mock<ScheduleMonitor>(MockBehavior.Strict);
ScheduleStatus status = new ScheduleStatus();
mockScheduleMonitor.Setup(p => p.GetStatusAsync(timerName)).ReturnsAsync(status);
TimerTriggerAttribute attribute = parameter.GetCustomAttribute<TimerTriggerAttribute>();
TimersConfiguration config = new TimersConfiguration();
config.ScheduleMonitor = mockScheduleMonitor.Object;
TestTraceWriter trace = new TestTraceWriter();
TimerTriggerBinding binding = new TimerTriggerBinding(parameter, attribute, config, trace);
// when we bind to a non-TimerInfo (e.g. in a Dashboard invocation) a new
// TimerInfo is created, with the ScheduleStatus populated
FunctionBindingContext functionContext = new FunctionBindingContext(Guid.NewGuid(), CancellationToken.None, trace);
ValueBindingContext context = new ValueBindingContext(functionContext, CancellationToken.None);
TriggerData triggerData = (TriggerData)(await binding.BindAsync("", context));
TimerInfo timerInfo = (TimerInfo)triggerData.ValueProvider.GetValue();
Assert.Same(status, timerInfo.ScheduleStatus);
// when we pass in a TimerInfo that is used
TimerInfo expected = new TimerInfo(attribute.Schedule, status);
triggerData = (TriggerData)(await binding.BindAsync(expected, context));
timerInfo = (TimerInfo)triggerData.ValueProvider.GetValue();
Assert.Same(expected, timerInfo);
}
public Task<IValueProvider> BindAsync(IStorageTable value, ValueBindingContext context)
{
CloudTable table = null;
if (value != null)
{
table = value.SdkObject;
}
return _binding.BindAsync(table, context);
}
public Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
// TODO: Perform any required conversions on the value
// E.g. convert from Dashboard invoke string to our trigger
// value type
SampleTriggerValue triggerValue = value as SampleTriggerValue;
IValueBinder valueBinder = new SampleValueBinder(_parameter, triggerValue);
return Task.FromResult<ITriggerData>(new TriggerData(valueBinder, GetBindingData(triggerValue)));
}
public async Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
if (value == null)
{
System.Diagnostics.Debugger.Break();
//value = CreateEntity();
}
return await BindAsync((RedisEntity)value, context);
}
public async Task<IValueProvider> BindAsync(IStorageBlob blob, ValueBindingContext context)
{
WatchableCloudBlobStream watchableStream = await WriteBlobArgumentBinding.BindStreamAsync(blob,
context, _blobWrittenWatcherGetter.Value);
const int DefaultBufferSize = 1024;
TextWriter writer = new StreamWriter(watchableStream, Encoding.UTF8, DefaultBufferSize, leaveOpen: true);
return new TextWriterValueBinder(blob, watchableStream, writer);
}
public Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
if (value == null || !_parameter.ParameterType.IsAssignableFrom(value.GetType()))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Unable to convert value to {0}.", _parameter.ParameterType));
}
IValueProvider valueProvider = new ValueBinder(value, _parameter.ParameterType);
return Task.FromResult<IValueProvider>(valueProvider);
}
public Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
IStorageTable table = null;
if (!_converter.TryConvert(value, out table))
{
throw new InvalidOperationException("Unable to convert value to IStorageTable.");
}
return BindTableAsync(table, context);
}
public async Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
ConversionResult<ServiceBusEntity> conversionResult = await _converter.TryConvertAsync(value, context.CancellationToken);
if (!conversionResult.Succeeded)
{
throw new InvalidOperationException("Unable to convert value to ServiceBusEntity.");
}
return await BindAsync(conversionResult.Result, context);
}
public async Task<IValueProvider> BindAsync(IStorageBlob blob, ValueBindingContext context)
{
WatchableReadStream watchableStream = await ReadBlobArgumentBinding.TryBindStreamAsync(blob, context);
if (watchableStream == null)
{
return BlobValueProvider.CreateWithNull<Stream>(blob);
}
return new BlobWatchableDisposableValueProvider(blob, watchableStream, typeof(Stream),
watcher: watchableStream, disposable: watchableStream);
}
public Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
IStorageQueue queue = null;
if (!_converter.TryConvert(value, out queue))
{
throw new InvalidOperationException("Unable to convert value to CloudQueue.");
}
return BindQueueAsync(queue, context);
}
public Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
IValueProvider provider = new JsonValueProvider(value, _parameter.ParameterType);
IReadOnlyDictionary<string, object> bindingData = (_bindingDataProvider != null)
? _bindingDataProvider.GetBindingData(provider.GetValue()) : null;
var result = new TriggerData(provider, bindingData);
return Task.FromResult<ITriggerData>(result);
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="valueContext">The value binding context.</param>
/// <param name="bindingData">The binding data.</param>
public BindingContext(ValueBindingContext valueContext, IReadOnlyDictionary<string, object> bindingData)
{
if (valueContext == null)
{
throw new ArgumentNullException("valueContext");
}
_valueContext = valueContext;
_bindingData = bindingData;
_functionContext = valueContext.FunctionContext;
_cancellationToken = valueContext.CancellationToken;
}
public Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
return BindInternalAsync(new ExecutionContext
{
InvocationId = context.FunctionInstanceId
});
}
public async Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
BlobPath path = null;
IStorageBlobContainer container = null;
if (TryConvert(value, _client, out container, out path))
{
return await BindBlobContainerAsync(container, new BlobContainerValueBindingContext(path, context));
}
throw new InvalidOperationException("Unable to convert value to CloudBlobContainer.");
}
public Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
TimerInfo timerInfo = value as TimerInfo;
if (timerInfo == null)
{
timerInfo = new TimerInfo(_attribute.Schedule);
}
IValueProvider valueProvider = new ValueProvider(timerInfo);
IReadOnlyDictionary<string, object> bindingData = CreateBindingData();
return Task.FromResult<ITriggerData>(new TriggerData(valueProvider, bindingData));
}
public Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
if (value != null && value.GetType() == typeof(string))
{
throw new NotSupportedException("ErrorTrigger does not support Dashboard invocation.");
}
TraceFilter triggerValue = (TraceFilter)value;
IValueBinder valueBinder = new ErrorValueBinder(_parameter, triggerValue);
TriggerData triggerData = new TriggerData(valueBinder, GetBindingData(triggerValue));
return Task.FromResult<ITriggerData>(triggerData);
}
public Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
TableEntityContext entityContext = null;
if (!_converter.TryConvert(value, out entityContext))
{
throw new InvalidOperationException("Unable to convert value to TableEntityContext.");
}
TableClient.ValidateAzureTableKeyValue(entityContext.PartitionKey);
TableClient.ValidateAzureTableKeyValue(entityContext.RowKey);
return BindEntityAsync(entityContext, context);
}
public Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
FileInfo fileInfo = value as FileInfo;
if (fileInfo == null && value.GetType() == typeof(string))
{
fileInfo = new FileInfo((string)value);
}
return Task.FromResult<IValueProvider>(new FileValueBinder(_parameter, _attribute, fileInfo));
}
public static async Task<WatchableCloudBlobStream> BindStreamAsync(IStorageBlob blob,
ValueBindingContext context, IBlobWrittenWatcher blobWrittenWatcher)
{
IStorageBlockBlob blockBlob = blob as IStorageBlockBlob;
if (blockBlob == null)
{
throw new InvalidOperationException("Cannot bind a page blob using an out string.");
}
BlobCausalityManager.SetWriter(blob.Metadata, context.FunctionInstanceId);
CloudBlobStream rawStream = await blockBlob.OpenWriteAsync(context.CancellationToken);
IBlobCommitedAction committedAction = new BlobCommittedAction(blob, blobWrittenWatcher);
return new WatchableCloudBlobStream(rawStream, committedAction);
}
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>();
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 async Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
TimerInfo timerInfo = value as TimerInfo;
if (timerInfo == null)
{
ScheduleStatus status = null;
if (_attribute.UseMonitor && _config.ScheduleMonitor != null)
{
status = await _config.ScheduleMonitor.GetStatusAsync(_timerName);
}
timerInfo = new TimerInfo(_attribute.Schedule, status);
}
IValueProvider valueProvider = new ValueProvider(timerInfo);
IReadOnlyDictionary<string, object> bindingData = CreateBindingData();
return new TriggerData(valueProvider, bindingData);
}
public async Task TryCreate_ReturnsTableArgumentBindingExtensionWrapper()
{
DefaultExtensionRegistry extensions = new DefaultExtensionRegistry();
FooBarTableArgumentBindingExtensionProvider fooBarExtensionProvider = new FooBarTableArgumentBindingExtensionProvider();
extensions.RegisterExtension<ITableArgumentBindingExtensionProvider>(fooBarExtensionProvider);
TableArgumentBindingExtensionProvider provider = new TableArgumentBindingExtensionProvider(extensions);
ITableArgumentBinding binding = provider.TryCreate(_parameters[0]);
Assert.Equal(typeof(TableArgumentBindingExtensionProvider.TableArgumentBindingExtension), binding.GetType());
Assert.Null(BoundTable);
CloudTable table = new CloudTable(new Uri("http://localhost:10000/test/table"));
IStorageTable storageTable = new StorageTable(table);
FunctionBindingContext functionContext = new FunctionBindingContext(Guid.NewGuid(), CancellationToken.None, new StringWriter());
ValueBindingContext context = new ValueBindingContext(functionContext, CancellationToken.None);
IValueProvider valueProvider = await binding.BindAsync(storageTable, context);
Assert.NotNull(valueProvider);
Assert.Same(table, BoundTable);
}
public static async Task<WatchableReadStream> TryBindStreamAsync(IStorageBlob blob, ValueBindingContext context)
{
Stream rawStream;
try
{
rawStream = await blob.OpenReadAsync(context.CancellationToken);
}
catch (StorageException exception)
{
// Testing generic error case since specific error codes are not available for FetchAttributes
// (HEAD request), including OpenRead.
if (!exception.IsNotFound())
{
throw;
}
return null;
}
return new WatchableReadStream(rawStream);
}
public async Task<IValueProvider> BindAsync(IStorageBlob blob, ValueBindingContext context)
{
WatchableReadStream watchableStream = await ReadBlobArgumentBinding.TryBindStreamAsync(blob, context);
if (watchableStream == null)
{
return BlobValueProvider.CreateWithNull<string>(blob);
}
string value;
ParameterLog status;
using (watchableStream)
using (TextReader reader = ReadBlobArgumentBinding.CreateTextReader(watchableStream))
{
context.CancellationToken.ThrowIfCancellationRequested();
value = await reader.ReadToEndAsync();
status = watchableStream.GetStatus();
}
return new BlobWatchableValueProvider(blob, value, typeof(string), new ImmutableWatcher(status));
}
public Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
FileSystemEventArgs fileEvent = value as FileSystemEventArgs;
if (fileEvent == null)
{
string filePath = value as string;
if (!string.IsNullOrEmpty(filePath))
{
// TODO: This only supports Created events. For Dashboard invocation, how can we
// handle Change events?
string directory = Path.GetDirectoryName(filePath);
string fileName = Path.GetFileName(filePath);
fileEvent = new FileSystemEventArgs(WatcherChangeTypes.Created, directory, fileName);
}
}
IValueBinder valueBinder = new FileValueBinder(_parameter, fileEvent);
IReadOnlyDictionary<string, object> bindingData = GetBindingData(fileEvent);
return Task.FromResult<ITriggerData>(new TriggerData(valueBinder, bindingData));
}
public async Task<IValueProvider> BindAsync(IStorageBlob blob, ValueBindingContext context)
{
WatchableReadStream watchableStream = await ReadBlobArgumentBinding.TryBindStreamAsync(blob, context);
if (watchableStream == null)
{
return BlobValueProvider.CreateWithNull<byte[]>(blob);
}
byte[] value;
ParameterLog status;
using (watchableStream)
using (MemoryStream outputStream = new MemoryStream())
{
const int DefaultBufferSize = 4096;
await watchableStream.CopyToAsync(outputStream, DefaultBufferSize);
value = outputStream.ToArray();
status = watchableStream.GetStatus();
}
return new BlobWatchableValueProvider(blob, value, typeof(byte[]), new ImmutableWatcher(status));
}
public async Task<IReadOnlyDictionary<string, IValueProvider>> BindAsync(ValueBindingContext context, IDictionary<string, object> parameters)
{
Dictionary<string, IValueProvider> results = new Dictionary<string, IValueProvider>();
IReadOnlyDictionary<string, object> bindingData = null;
BindingContext bindingContext = new BindingContext(context, bindingData);
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;
}
protected override async Task <IValueProvider> BuildAsync(TAttribute attrResolved, ValueBindingContext context)
{
// set FileAccess beofre calling into the converter. Don't want converters to need to deal with a null FileAccess.
SetFileAccessFromAttribute(attrResolved, _targetFileAccess);
var builder = this._parent._builder;
Func <Task <Stream> > buildStream = async() => (Stream) await builder(attrResolved, null, context);
BaseValueProvider valueProvider = (BaseValueProvider)Activator.CreateInstance(_typeValueProvider, _converter);
var invokeString = this.Cloner.GetInvokeString(attrResolved);
await valueProvider.InitAsync(buildStream, _userType, _parent, invokeString);
return(valueProvider);
}
protected override async Task <IValueProvider> BuildAsync(TAttribute attrResolved, ValueBindingContext context)
{
string invokeString = Cloner.GetInvokeString(attrResolved);
IValueBinder valueBinder = await _builder(attrResolved, _parameter.ParameterType);
return(new Wrapper(valueBinder, invokeString));
}
private static IAsyncCollector <TCore> GetCollector <TCollector, TCore>(object userContext, ValueBindingContext context)
{
return(Activator.CreateInstance(typeof(TCollector), userContext) as IAsyncCollector <TCore>);
}
protected abstract Task <IValueProvider> BuildAsync(TAttribute attrResolved, ValueBindingContext context);
