public async Task<string> GetETagAsync(IStorageBlob blob, CancellationToken cancellationToken)
{
try
{
await blob.FetchAttributesAsync(cancellationToken);
}
catch (StorageException exception)
{
// Note that specific exception codes are not available for FetchAttributes, which makes a HEAD request.
if (exception.IsNotFound())
{
// Blob does not exist.
return null;
}
else if (exception.IsOk())
{
// If the blob type is incorrect (block vs. page) a 200 OK is returned but the SDK throws an
// exception.
return null;
}
else
{
throw;
}
}
return blob.Properties.ETag;
}
public AzureAcmeAccountStore(
IOptions <AzureAcmeAccountStoreOptions> options,
IStorageBlob <StorageBlobOptions> storage)
{
_options = options.Value ?? throw new ArgumentNullException(nameof(options));
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
}
public ObjectValueBinder(IStorageBlob blob, WatchableCloudBlobStream stream,
ICloudBlobStreamBinder <TValue> objectBinder)
{
_blob = blob;
_stream = stream;
_objectBinder = objectBinder;
}
private async Task NotifyRegistrationsAsync(IStorageBlob blob, ICollection <IStorageBlob> failedNotifications,
CancellationToken cancellationToken)
{
IStorageBlobContainer container = blob.Container;
ContainerScanInfo containerScanInfo;
// Blob written notifications are host-wide, so filter out things that aren't in the container list.
if (!_scanInfo.TryGetValue(container, out containerScanInfo))
{
return;
}
foreach (ITriggerExecutor <IStorageBlob> registration in containerScanInfo.Registrations)
{
cancellationToken.ThrowIfCancellationRequested();
FunctionResult result = await registration.ExecuteAsync(blob, cancellationToken);
if (!result.Succeeded)
{
// If notification failed, try again on the next iteration.
failedNotifications.Add(blob);
}
}
}
// Populate the List<> with blob logs for the given prefix.
// http://blogs.msdn.com/b/windowsazurestorage/archive/2011/08/03/windows-azure-storage-logging-using-logs-to-track-storage-requests.aspx
private static async Task GetLogsWithPrefixAsync(List <IStorageBlob> selectedLogs, IStorageBlobClient blobClient,
string prefix, CancellationToken cancellationToken)
{
// List the blobs using the prefix
IEnumerable <IStorageListBlobItem> blobs = await blobClient.ListBlobsAsync(prefix,
useFlatBlobListing : true, blobListingDetails : BlobListingDetails.Metadata,
cancellationToken : cancellationToken);
// iterate through each blob and figure the start and end times in the metadata
// Type cast to IStorageBlob is safe due to useFlatBlobListing: true above.
foreach (IStorageBlob item in blobs)
{
IStorageBlob log = item as IStorageBlob;
if (log != null)
{
// we will exclude the file if the file does not have log entries in the interested time range.
string logType = log.Metadata[LogType];
bool hasWrites = logType.Contains("write");
if (hasWrites)
{
selectedLogs.Add(log);
}
}
}
}
public static async Task <bool> TryFetchAttributesAsync(this IStorageBlob blob,
CancellationToken cancellationToken)
{
if (blob == null)
{
throw new ArgumentNullException("blob");
}
try
{
await blob.FetchAttributesAsync(cancellationToken);
return(true);
}
catch (StorageException exception)
{
// Remember specific error codes are not available for Fetch (HEAD request).
if (exception.IsNotFound())
{
return(false);
}
else if (exception.IsOk())
{
// If the blob type is incorrect (block vs. page) a 200 OK is returned but the SDK throws an
// exception.
return(false);
}
else
{
throw;
}
}
}
public async Task <IValueProvider> BindAsync(IStorageBlob blob, ValueBindingContext context)
{
WatchableCloudBlobStream watchableStream = await WriteBlobArgumentBinding.BindStreamAsync(blob,
context, _blobWrittenWatcherGetter.Value);
return(new WriteStreamValueBinder(blob, watchableStream));
}
public void ExecuteAsync_IfLeasedReceiptBecameCompleted_ReleasesLeaseAndReturnsTrue()
{
// Arrange
IStorageBlob blob = CreateBlobReference();
IBlobPathSource input = CreateBlobPath(blob);
IBlobETagReader eTagReader = CreateStubETagReader("ETag");
Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock();
int calls = 0;
mock.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>()))
.Returns(() =>
{
int call = calls++;
return(Task.FromResult(call == 0 ? BlobReceipt.Incomplete : BlobReceipt.Complete));
});
mock.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult("LeaseId"));
mock.Setup(m => m.ReleaseLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0))
.Verifiable();
IBlobReceiptManager receiptManager = mock.Object;
ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager);
// Act
Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None);
// Assert
task.WaitUntilCompleted();
mock.Verify();
Assert.True(task.Result);
}
public void ExecuteAsync_IfIncompleteBlobReceiptExists_TriesToAcquireLease()
{
// Arrange
IStorageBlob blob = CreateBlobReference();
IBlobPathSource input = CreateBlobPath(blob);
IBlobETagReader eTagReader = CreateStubETagReader("ETag");
Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock();
mock.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(BlobReceipt.Incomplete));
mock.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <string>(null))
.Verifiable();
IBlobReceiptManager receiptManager = mock.Object;
ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager);
// Act
Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None);
// Assert
task.GetAwaiter().GetResult();
mock.Verify();
}
public async Task <string> GetETagAsync(IStorageBlob blob, CancellationToken cancellationToken)
{
try
{
await blob.FetchAttributesAsync(cancellationToken);
}
catch (StorageException exception)
{
// Note that specific exception codes are not available for FetchAttributes, which makes a HEAD request.
if (exception.IsNotFound())
{
// Blob does not exist.
return(null);
}
else if (exception.IsOk())
{
// If the blob type is incorrect (block vs. page) a 200 OK is returned but the SDK throws an
// exception.
return(null);
}
else
{
throw;
}
}
return(blob.Properties.ETag);
}
public AzureCertificateStore(
IOptions <AzureCertificateStoreOptions> options,
IStorageBlob <StorageBlobOptions> storage)
{
_options = options.Value;
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
}
public void ExecuteAsync_IfTryAcquireLeaseSucceeds_ReadsLatestReceipt()
{
// Arrange
IStorageBlob blob = CreateBlobReference();
IBlobPathSource input = CreateBlobPath(blob);
IBlobETagReader eTagReader = CreateStubETagReader("ETag");
Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock();
int calls = 0;
mock.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>()))
.Returns(() =>
{
return(Task.FromResult(calls++ == 0 ? BlobReceipt.Incomplete : BlobReceipt.Complete));
});
mock.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult("LeaseId"));
mock.Setup(m => m.ReleaseLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
IBlobReceiptManager receiptManager = mock.Object;
ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager);
// Act
Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None);
// Assert
task.GetAwaiter().GetResult();
Assert.Equal(2, calls);
}
public AzureBlobStorageHealthCheck(
IStorageBlob <StorageBlobOptions> storageBlob,
IOptionsMonitor <StorageBlobOptions> storageBlobOptionsMonitor,
ILogger <AzureBlobStorageHealthCheck> logger)
{
_storageBlob = storageBlob ?? throw new ArgumentNullException(nameof(storageBlob));
_storageBlobOptionsMonitor = storageBlobOptionsMonitor ?? throw new ArgumentNullException(nameof(storageBlobOptionsMonitor));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public static BlobPath ToBlobPath(this IStorageBlob blob)
{
if (blob == null)
{
throw new ArgumentNullException("blob");
}
return(new BlobPath(blob.Container.Name, blob.Name));
}
public static bool Exists(this IStorageBlob blob)
{
if (blob == null)
{
throw new ArgumentNullException("blob");
}
return(blob.ExistsAsync(CancellationToken.None).GetAwaiter().GetResult());
}
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 void ExecuteAsync_IfLeasedIncompleteReceipt_EnqueuesMessageMarksCompletedReleasesLeaseAndReturnsTrue()
{
// Arrange
string expectedFunctionId = "FunctionId";
string expectedETag = "ETag";
IStorageBlob blob = CreateBlobReference("container", "blob");
IBlobPathSource input = CreateBlobPath(blob);
IBlobETagReader eTagReader = CreateStubETagReader(expectedETag);
Mock <IBlobReceiptManager> managerMock = CreateReceiptManagerReferenceMock();
managerMock
.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(BlobReceipt.Incomplete));
managerMock
.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult("LeaseId"));
managerMock
.Setup(m => m.MarkCompletedAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0))
.Verifiable();
managerMock
.Setup(m => m.ReleaseLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0))
.Verifiable();
IBlobReceiptManager receiptManager = managerMock.Object;
Mock <IBlobTriggerQueueWriter> queueWriterMock = new Mock <IBlobTriggerQueueWriter>(MockBehavior.Strict);
queueWriterMock
.Setup(w => w.EnqueueAsync(It.IsAny <BlobTriggerMessage>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
IBlobTriggerQueueWriter queueWriter = queueWriterMock.Object;
ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(expectedFunctionId, input, eTagReader,
receiptManager, queueWriter);
// Act
Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None);
// Assert
task.WaitUntilCompleted();
queueWriterMock
.Verify(
w => w.EnqueueAsync(It.Is <BlobTriggerMessage>(m =>
m != null && m.FunctionId == expectedFunctionId && m.BlobType == StorageBlobType.BlockBlob &&
m.BlobName == blob.Name && m.ContainerName == blob.Container.Name && m.ETag == expectedETag),
It.IsAny <CancellationToken>()),
Times.Once());
managerMock.Verify();
Assert.True(task.Result);
}
private static async Task <DateTime?> GetBlobModifiedUtcTimeAsync(IStorageBlob blob, CancellationToken cancellationToken)
{
if (!await blob.ExistsAsync(cancellationToken))
{
return(null); // no blob, no time.
}
var lastModified = blob.Properties.LastModified;
return(lastModified.HasValue ? (DateTime?)lastModified.Value.UtcDateTime : null);
}
public BlobValueProvider(IStorageBlob blob, object value, Type valueType)
{
if (value != null && !valueType.IsAssignableFrom(value.GetType()))
{
throw new InvalidOperationException("value is not of the correct type.");
}
_blob = blob;
_value = value;
_valueType = valueType;
}
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 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 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 AzureStorageModelLoader(
IStorageBlob <StorageBlobOptions> storageBlob,
ILogger <AzureStorageModelLoader> logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_storageBlob = storageBlob ?? throw new ArgumentNullException(nameof(storageBlob));
LoadFunc = (options, cancellationToken) => LoadModelResult(options, cancellationToken);
_reloadToken = new ReloadToken();
_stopping = new CancellationTokenSource();
}
public static string DownloadText(this IStorageBlob blob)
{
if (blob == null)
{
throw new ArgumentNullException("blob");
}
using (Stream stream = blob.OpenReadAsync(CancellationToken.None).GetAwaiter().GetResult())
using (TextReader reader = new StreamReader(stream, StrictEncodings.Utf8))
{
return(reader.ReadToEnd());
}
}
public BlobWatchableDisposableValueProvider(IStorageBlob blob, object value, Type valueType, IWatcher watcher,
IDisposable disposable)
{
if (value != null && !valueType.IsAssignableFrom(value.GetType()))
{
throw new InvalidOperationException("value is not of the correct type.");
}
_blob = blob;
_value = value;
_valueType = valueType;
_watcher = watcher;
_disposable = disposable;
}
public BlobWatchableDisposableValueProvider(IStorageBlob blob, object value, Type valueType, IWatcher watcher,
IDisposable disposable)
{
if (value != null && !valueType.IsAssignableFrom(value.GetType()))
{
throw new InvalidOperationException("value is not of the correct type.");
}
_blob = blob;
_value = value;
_valueType = valueType;
_watcher = watcher;
_disposable = disposable;
}
public void ExecuteAsync_IfBlobDoesNotExist_ReturnsTrue()
{
// Arrange
IStorageBlob blob = CreateBlobReference();
IBlobPathSource input = CreateBlobPath(blob);
IBlobETagReader eTagReader = CreateStubETagReader(null);
ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader);
// Act
Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None);
// Assert
Assert.True(task.Result);
}
public void ExecuteAsync_IfCompletedBlobReceiptExists_ReturnsSuccessfulResult()
{
// Arrange
IStorageBlob blob = CreateBlobReference();
IBlobPathSource input = CreateBlobPath(blob);
IBlobETagReader eTagReader = CreateStubETagReader("ETag");
IBlobReceiptManager receiptManager = CreateCompletedReceiptManager();
ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager);
// Act
Task <FunctionResult> task = product.ExecuteAsync(blob, CancellationToken.None);
// Assert
Assert.True(task.Result.Succeeded);
}
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 <IValueProvider> BindAsync(BindingContext context)
{
BlobPath boundPath = _path.Bind(context.BindingData);
IStorageBlobContainer container = _client.GetContainerReference(boundPath.ContainerName);
if (_argumentBinding.Access != FileAccess.Read)
{
await container.CreateIfNotExistsAsync(context.CancellationToken);
}
Type argumentType = _argumentBinding.ValueType;
string blobName = boundPath.BlobName;
IStorageBlob blob = await container.GetBlobReferenceForArgumentTypeAsync(blobName, argumentType, context.CancellationToken);
return(await BindBlobAsync(blob, context.ValueContext));
}
public AzureStorageMSModelLoader(
IOptions <MLOptions> contextOptions,
IStorageBlob <StorageBlobOptions> storageBlob,
ILogger <AzureStorageMSModelLoader> logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
if (contextOptions.Value?.MLContext == null)
{
throw new ArgumentNullException(nameof(contextOptions));
}
_mlContext = contextOptions.Value.MLContext;
_reloadToken = new ModelReloadToken();
_stopping = new CancellationTokenSource();
_storageBlob = storageBlob ?? throw new ArgumentNullException(nameof(storageBlob));
}
public static Task <IStorageBlob> GetBlobReferenceForArgumentTypeAsync(this IStorageBlobContainer container,
string blobName, Type argumentType, CancellationToken cancellationToken)
{
if (argumentType == typeof(CloudBlockBlob))
{
IStorageBlob blob = container.GetBlockBlobReference(blobName);
return(Task.FromResult(blob));
}
else if (argumentType == typeof(CloudPageBlob))
{
IStorageBlob blob = container.GetPageBlobReference(blobName);
return(Task.FromResult(blob));
}
else
{
return(GetExistingOrNewBlockBlobReferenceAsync(container, blobName, cancellationToken));
}
}
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));
}
private IReadOnlyDictionary <string, object> CreateBindingData(IStorageBlob value)
{
Dictionary <string, object> bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
bindingData.Add("BlobTrigger", value.GetBlobPath());
IReadOnlyDictionary <string, object> bindingDataFromPath = _path.CreateBindingData(value.ToBlobPath());
if (bindingDataFromPath != null)
{
foreach (KeyValuePair <string, object> item in bindingDataFromPath)
{
// In case of conflict, binding data from the value type overrides the built-in binding data above.
bindingData[item.Key] = item.Value;
}
}
return(bindingData);
}
private static async Task<string> ReadBlobAsync(IStorageBlob blob, CancellationToken cancellationToken)
{
// Beware! Blob.DownloadText does not strip the BOM!
try
{
using (var stream = await blob.OpenReadAsync(cancellationToken))
using (StreamReader sr = new StreamReader(stream, detectEncodingFromByteOrderMarks: true))
{
cancellationToken.ThrowIfCancellationRequested();
string data = await sr.ReadToEndAsync();
return data;
}
}
catch
{
return null;
}
}
/// <summary>
/// Given a log file (as a blob), parses it and return a collection of log entries matching version 1.0
/// of the Storage Analytics Log Format.
/// </summary>
/// <param name="blob">Object representing a cloud blob with Storage Analytics log content.</param>
/// <param name="cancellationToken">A token to monitor for cancellation request.</param>
/// <returns>Collection of successfully parsed log entries.</returns>
/// <exception cref="FormatException">If unable to parse a line in given log.</exception>
/// <seealso cref="StorageAnalyticsLogEntry"/>
/// <remarks>
/// The method scans log file lines one at a time.
/// First it attempts to detect a line format version and throws an exception if failed to do so.
/// It skips all lines with version different than supported one, i.e. 1.0.
/// Then it calls TryParseLogEntry to create a log entry out of every line of supported version and throws
/// an exception if the parse method returns null.
/// </remarks>
public async Task <IEnumerable <StorageAnalyticsLogEntry> > ParseLogAsync(IStorageBlob blob,
CancellationToken cancellationToken)
{
List <StorageAnalyticsLogEntry> entries = new List <StorageAnalyticsLogEntry>();
using (TextReader tr = new StreamReader(await blob.OpenReadAsync(cancellationToken)))
{
for (int lineNumber = 1; ; lineNumber++)
{
cancellationToken.ThrowIfCancellationRequested();
string line = await tr.ReadLineAsync();
if (line == null)
{
break;
}
Version version = TryParseVersion(line);
if (version == null)
{
string message = String.Format(CultureInfo.CurrentCulture,
"Unable to detect a version of log entry on line {1} of Storage Analytics log file '{0}'.",
blob.Name, lineNumber);
throw new FormatException(message);
}
if (version == SupportedVersion)
{
StorageAnalyticsLogEntry entry = TryParseLogEntry(line);
if (entry == null)
{
string message = String.Format(CultureInfo.CurrentCulture,
"Unable to parse the log entry on line {1} of Storage Analytics log file '{0}'.",
blob.Name, lineNumber);
throw new FormatException(message);
}
entries.Add(entry);
}
}
}
return(entries);
}
/// <summary>
/// Given a log file (as a blob), parses it and return a collection of log entries matching version 1.0
/// of the Storage Analytics Log Format.
/// </summary>
/// <param name="blob">Object representing a cloud blob with Storage Analytics log content.</param>
/// <param name="cancellationToken">A token to monitor for cancellation request.</param>
/// <returns>Collection of successfully parsed log entries.</returns>
/// <exception cref="FormatException">If unable to parse a line in given log.</exception>
/// <seealso cref="StorageAnalyticsLogEntry"/>
/// <remarks>
/// The method scans log file lines one at a time.
/// First it attempts to detect a line format version and throws an exception if failed to do so.
/// It skips all lines with version different than supported one, i.e. 1.0.
/// Then it calls TryParseLogEntry to create a log entry out of every line of supported version and throws
/// an exception if the parse method returns null.
/// </remarks>
public async Task<IEnumerable<StorageAnalyticsLogEntry>> ParseLogAsync(IStorageBlob blob,
CancellationToken cancellationToken)
{
List<StorageAnalyticsLogEntry> entries = new List<StorageAnalyticsLogEntry>();
using (TextReader tr = new StreamReader(await blob.OpenReadAsync(cancellationToken)))
{
for (int lineNumber = 1;; lineNumber++)
{
cancellationToken.ThrowIfCancellationRequested();
string line = await tr.ReadLineAsync();
if (line == null)
{
break;
}
Version version = TryParseVersion(line);
if (version == null)
{
string message = String.Format(CultureInfo.CurrentCulture,
"Unable to detect a version of log entry on line {1} of Storage Analytics log file '{0}'.",
blob.Name, lineNumber);
throw new FormatException(message);
}
if (version == supportedVersion)
{
StorageAnalyticsLogEntry entry = TryParseLogEntry(line);
if (entry == null)
{
string message = String.Format(CultureInfo.CurrentCulture,
"Unable to parse the log entry on line {1} of Storage Analytics log file '{0}'.",
blob.Name, lineNumber);
throw new FormatException(message);
}
entries.Add(entry);
}
}
}
return entries;
}
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 static async Task<Guid?> GetWriterAsync(IStorageBlob blob, CancellationToken cancellationToken)
{
if (!await blob.TryFetchAttributesAsync(cancellationToken))
{
return null;
}
if (!blob.Metadata.ContainsKey(BlobMetadataKeys.ParentId))
{
return null;
}
string val = blob.Metadata[BlobMetadataKeys.ParentId];
Guid result;
if (Guid.TryParse(val, out result))
{
return result;
}
return null;
}
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));
}
private static async Task<DateTime?> GetBlobModifiedUtcTimeAsync(IStorageBlob blob, CancellationToken cancellationToken)
{
if (!await blob.ExistsAsync(cancellationToken))
{
return null; // no blob, no time.
}
var lastModified = blob.Properties.LastModified;
return lastModified.HasValue ? (DateTime?)lastModified.Value.UtcDateTime : null;
}
public Task<Guid?> GetWriterAsync(IStorageBlob blob, CancellationToken cancellationToken)
{
return BlobCausalityManager.GetWriterAsync(blob, cancellationToken);
}
public TextWriterValueBinder(IStorageBlob blob, WatchableCloudBlobStream stream, TextWriter value)
{
_blob = blob;
_stream = stream;
_value = value;
}
public WriteStreamValueBinder(IStorageBlob blob, WatchableCloudBlobStream stream)
{
_blob = blob;
_stream = stream;
}
public BlobCommittedAction(IStorageBlob blob, IBlobWrittenWatcher blobWrittenWatcher)
{
_blob = blob;
_blobWrittenWatcher = blobWrittenWatcher;
}
private async Task NotifyRegistrationsAsync(IStorageBlob blob, ICollection<IStorageBlob> failedNotifications, CancellationToken cancellationToken)
{
IStorageBlobContainer container = blob.Container;
ContainerScanInfo containerScanInfo;
// Blob written notifications are host-wide, so filter out things that aren't in the container list.
if (!_scanInfo.TryGetValue(container, out containerScanInfo))
{
return;
}
foreach (ITriggerExecutor<IStorageBlob> registration in containerScanInfo.Registrations)
{
cancellationToken.ThrowIfCancellationRequested();
FunctionResult result = await registration.ExecuteAsync(blob, cancellationToken);
if (!result.Succeeded)
{
// If notification failed, try again on the next iteration.
failedNotifications.Add(blob);
}
}
}
private Task<IValueProvider> BindBlobAsync(IStorageBlob value, ValueBindingContext context)
{
return _argumentBinding.BindAsync(value, context);
}
private IReadOnlyDictionary<string, object> CreateBindingData(IStorageBlob value)
{
Dictionary<string, object> bindingData = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
bindingData.Add("BlobTrigger", value.GetBlobPath());
IReadOnlyDictionary<string, object> bindingDataFromPath = _path.CreateBindingData(value.ToBlobPath());
if (bindingDataFromPath != null)
{
foreach (KeyValuePair<string, object> item in bindingDataFromPath)
{
// In case of conflict, binding data from the value type overrides the built-in binding data above.
bindingData[item.Key] = item.Value;
}
}
return bindingData;
}
private static IBlobPathSource CreateBlobPath(IStorageBlob blob)
{
return new FixedBlobPathSource(blob.ToBlobPath());
}
public void Notify(IStorageBlob blobWritten)
{
ThrowIfDisposed();
_blobsFoundFromScanOrNotification.Enqueue(blobWritten);
}
private async Task NotifyRegistrationsAsync(IStorageBlob blob, CancellationToken cancellationToken)
{
IStorageBlobContainer container = blob.Container;
// Log listening is client-wide and blob written notifications are host-wide, so filter out things that
// aren't in the container list.
if (!_registrations.ContainsKey(container))
{
return;
}
foreach (ITriggerExecutor<IStorageBlob> registration in _registrations[container])
{
cancellationToken.ThrowIfCancellationRequested();
FunctionResult result = await registration.ExecuteAsync(blob, cancellationToken);
if (!result.Succeeded)
{
// If notification failed, try again on the next iteration.
_blobsFoundFromScanOrNotification.Enqueue(blob);
}
}
}
public void Notify(IStorageBlob blobWritten)
{
_blobWrittenNotifications.Enqueue(blobWritten);
}
public async Task<IValueProvider> BindAsync(IStorageBlob blob, ValueBindingContext context)
{
WatchableCloudBlobStream watchableStream = await WriteBlobArgumentBinding.BindStreamAsync(blob, context, _blobWrittenWatcherGetter.Value);
return new ByteArrayValueBinder(blob, watchableStream);
}
public ByteArrayValueBinder(IStorageBlob blob, WatchableCloudBlobStream stream)
{
_blob = blob;
_stream = stream;
}
