// For describing InvokeStrings. private async Task <ICloudBlob> ConvertFromInvokeString(DirectInvokeString input, Attribute attr, ValueBindingContext context) { var attrResolved = (BlobTriggerAttribute)attr; var account = _accountProvider.Get(attrResolved.Connection); var client = account.CreateCloudBlobClient(); BlobPath path = BlobPath.ParseAndValidate(input.Value); var container = client.GetContainerReference(path.ContainerName); var blob = await container.GetBlobReferenceFromServerAsync(path.BlobName); return(blob); }
private ParameterDescriptor ToParameterDescriptorForCollector(QueueAttribute attr, ParameterInfo parameter, INameResolver nameResolver, FileAccess access) { var account = _accountProvider.Get(attr.Connection, nameResolver); var accountName = account.Name; return(new QueueParameterDescriptor { Name = parameter.Name, AccountName = accountName, QueueName = NormalizeQueueName(attr, nameResolver), Access = access }); }
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context) { ParameterInfo parameter = context.Parameter; var blobTriggerAttribute = TypeUtility.GetResolvedAttribute <BlobTriggerAttribute>(context.Parameter); if (blobTriggerAttribute == null) { return(Task.FromResult <ITriggerBinding>(null)); } string resolvedCombinedPath = Resolve(blobTriggerAttribute.BlobPath); IBlobPathSource path = BlobPathSource.Create(resolvedCombinedPath); var hostAccount = _accountProvider.GetHost(); var dataAccount = _accountProvider.Get(blobTriggerAttribute.Connection, _nameResolver); // premium does not support blob logs, so disallow for blob triggers // $$$ // dataAccount.AssertTypeOneOf(StorageAccountType.GeneralPurpose, StorageAccountType.BlobOnly); ITriggerBinding binding = new BlobTriggerBinding(parameter, hostAccount, dataAccount, path, _hostIdProvider, _queueOptions, _blobsOptions, _exceptionHandler, _blobWrittenWatcherSetter, _messageEnqueuedWatcherSetter, _sharedContextProvider, _singletonManager, _loggerFactory); return(Task.FromResult(binding)); }
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context) { ParameterInfo parameter = context.Parameter; var queueTrigger = TypeUtility.GetResolvedAttribute <QueueTriggerAttribute>(context.Parameter); if (queueTrigger == null) { return(Task.FromResult <ITriggerBinding>(null)); } string queueName = Resolve(queueTrigger.QueueName); queueName = NormalizeAndValidate(queueName); ITriggerDataArgumentBinding <QueueMessage> argumentBinding = InnerProvider.TryCreate(parameter); if (argumentBinding == null) { throw new InvalidOperationException( "Can't bind QueueTrigger to type '" + parameter.ParameterType + "'."); } var account = _accountProvider.Get(queueTrigger.Connection, _nameResolver); // requires storage account with queue support //account.AssertTypeOneOf(StorageAccountType.GeneralPurpose); $$$ QueueServiceClient client = account.CreateQueueServiceClient(); var queue = client.GetQueueClient(queueName); ITriggerBinding binding = new QueueTriggerBinding(parameter.Name, client, queue, argumentBinding, _queueOptions, _exceptionHandler, _messageEnqueuedWatcherSetter, _loggerFactory, _queueProcessorFactory); return(Task.FromResult(binding)); }
public async Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var parameter = context.Parameter; var attribute = parameter.GetCustomAttribute <NuGetCatalogTriggerAttribute>(false); if (attribute == null) { return(null); } if (!IsSupportBindingType(parameter.ParameterType)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind NuGetCatalogTriggerAttribute to type '{0}'.", parameter.ParameterType)); } var account = _accountProvider.Get(attribute.Connection, _nameResolver); var blobClient = account.CreateCloudBlobClient(); var cursorContainer = blobClient.GetContainerReference(attribute.CursorContainer); await cursorContainer.CreateIfNotExistsAsync(); var cursorBlob = cursorContainer.GetBlockBlobReference(attribute.CursorBlobName); return(new NuGetCatalogTriggerBinding(parameter, attribute.ServiceIndexUrl, attribute.UseBatchProcessor, attribute.PreviousHours, cursorBlob, _loggerFactory)); }
protected override CloudBlobContainer GetContainer(string accountName) { var account = _storage.Get(accountName); var client = account.CreateCloudBlobClient(); var container = client.GetContainerReference(StorageBaseDistributedLockManager.DefaultContainerName); return(container); }
private Task <CloudFileClient> GetClientAsync( FileAttribute blobAttribute, CancellationToken cancellationToken) { var account = _accountProvider.Get(blobAttribute.Connection, _nameResolver); var client = account.SdkObject.CreateCloudFileClient(); return(Task.FromResult(client)); }
public Task <IBinding> TryCreateAsync(BindingProviderContext context) { ParameterInfo parameter = context.Parameter; if (parameter.ParameterType != typeof(CloudStorageAccount)) { return(Task.FromResult <IBinding>(null)); } var accountAttribute = TypeUtility.GetHierarchicalAttributeOrNull <StorageAccountAttribute>(parameter); var account = _accountProvider.Get(accountAttribute?.Account); var binding = new CloudStorageAccountBinding(parameter.Name, account.SdkObject); return(Task.FromResult <IBinding>(binding)); }
private IBinding TryCreate(BindingProviderContext context) { ParameterInfo parameter = context.Parameter; var tableAttribute = TypeUtility.GetResolvedAttribute <TableAttribute>(context.Parameter); if (tableAttribute == null) { return(null); } string tableName = Resolve(tableAttribute.TableName); var account = _accountProvider.Get(tableAttribute.Connection, _nameResolver); // requires storage account with table support // account.AssertTypeOneOf(StorageAccountType.GeneralPurpose); $$$ CloudTableClient client = account.CreateCloudTableClient(); bool bindsToEntireTable = tableAttribute.RowKey == null; IBinding binding; if (bindsToEntireTable) { // This should have been caught by the other rule-based binders. // We never expect this to get thrown. throw new InvalidOperationException("Can't bind Table to type '" + parameter.ParameterType + "'."); } else { string partitionKey = Resolve(tableAttribute.PartitionKey); string rowKey = Resolve(tableAttribute.RowKey); IBindableTableEntityPath path = BindableTableEntityPath.Create(tableName, partitionKey, rowKey); path.ValidateContractCompatibility(context.BindingDataContract); IArgumentBinding <TableEntityContext> argumentBinding = _entityBindingProvider.TryCreate(parameter); if (argumentBinding == null) { throw new InvalidOperationException("Can't bind Table entity to type '" + parameter.ParameterType + "'."); } binding = new TableEntityBinding(parameter.Name, argumentBinding, client, path); } return(binding); }
public async Task ProcessMessage( [QueueTrigger("requests-v1")] string message, ILogger logger) { var blobClient = _storageProvider.Get(null).CreateCloudBlobClient(); var blob = new CloudBlob(new Uri(message), blobClient); HttpRequestMessage request; using (var stream = await blob.OpenReadAsync()) request = await RequestSerialization.Deserialize(stream); HttpResponseMessage response; using (var client = _httpClientFactory.CreateClient()) response = await client.SendAsync(request); logger.LogInformation( (int)response.StatusCode + " " + request.Method + " " + request.RequestUri); if (!response.IsSuccessStatusCode) { throw new ApplicationException( request.Method + " " + request.RequestUri + " failed with status code " + (int)response.StatusCode); } try { await blob.DeleteAsync(); } catch (Exception e) { logger.LogWarning(e, "Failed to delete blob"); } }