// 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");
}
}