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