/// <summary>
/// Creates a private container with the given name
/// </summary>
/// <param name="containerName"></param>
/// <returns></returns>
public async Task<bool> CreateContainerAsync(string containerName, bool isPublic)
{
// Create the container if it doesn't exist.
blobContainer = blobClient.GetContainerReference(containerName);
if (isPublic)
{
var returnData = await blobContainer.CreateIfNotExistsAsync();
if (returnData)
await blobContainer.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
return returnData;
}
return await blobContainer.CreateIfNotExistsAsync();
}
public async Task Init( string name, IProviderRuntime providerRuntime, IProviderConfiguration config )
{
Log = providerRuntime.GetLogger( this.GetType().Name );
try
{
ConfigureJsonSerializerSettings( config );
if( !config.Properties.ContainsKey( "DataConnectionString" ) )
{
throw new BadProviderConfigException(
"The DataConnectionString setting has not been configured in the cloud role. Please add a DataConnectionString setting with a valid Azure Storage connection string." );
}
else
{
var account = CloudStorageAccount.Parse( config.Properties[ "DataConnectionString" ] );
var blobClient = account.CreateCloudBlobClient();
var containerName = config.Properties.ContainsKey( "ContainerName" ) ? config.Properties[ "ContainerName" ] : "grainstate";
container = blobClient.GetContainerReference( containerName );
await container.CreateIfNotExistsAsync();
}
}
catch( Exception ex )
{
Log.Error( 0, ex.ToString(), ex );
throw;
}
}
/// <summary> Initialization function for this storage provider. </summary>
/// <see cref="IProvider.Init"/>
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Log = providerRuntime.GetLogger("Storage.AzureBlobStorage");
try
{
this.Name = name;
ConfigureJsonSerializerSettings(config);
if (!config.Properties.ContainsKey("DataConnectionString")) throw new BadProviderConfigException("The DataConnectionString setting has not been configured in the cloud role. Please add a DataConnectionString setting with a valid Azure Storage connection string.");
var account = CloudStorageAccount.Parse(config.Properties["DataConnectionString"]);
var blobClient = account.CreateCloudBlobClient();
var containerName = config.Properties.ContainsKey("ContainerName") ? config.Properties["ContainerName"] : "grainstate";
container = blobClient.GetContainerReference(containerName);
await container.CreateIfNotExistsAsync().ConfigureAwait(false);
Log.Info((int)AzureProviderErrorCode.AzureBlobProvider_InitProvider, "Init: Name={0} ServiceId={1} {2}", name, providerRuntime.ServiceId.ToString(), string.Join(" ", FormatPropertyMessage(config)));
Log.Info((int)AzureProviderErrorCode.AzureBlobProvider_ParamConnectionString, "AzureBlobStorage Provider is using DataConnectionString: {0}", ConfigUtilities.PrintDataConnectionInfo(config.Properties["DataConnectionString"]));
}
catch (Exception ex)
{
Log.Error((int)AzureProviderErrorCode.AzureBlobProvider_InitProvider, ex.ToString(), ex);
throw;
}
}
/// <summary>
///
/// </summary>
public void Setup()
{
Account = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["AzureStorage"]);
CloudBlobClient client = Account.CreateCloudBlobClient();
Container = client.GetContainerReference(containerName);
Container.CreateIfNotExistsAsync();
}
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
try
{
var account = CloudStorageAccount.Parse(config.Properties["DataConnectionString"]);
var blobClient = account.CreateCloudBlobClient();
var containerName = config.Properties.ContainsKey("ContainerName") ? config.Properties["ContainerName"] : "grainstate";
container = blobClient.GetContainerReference(containerName);
await container.CreateIfNotExistsAsync();
}
catch (Exception ex)
{
Log.Error(0, ex.ToString());
}
}
public FileHandler(CloudStorageAccount storageAccount, ImageTestContext context)
{
// Retrieve storage account from connection string.
_storageAccount = storageAccount;
// Create the blob client.
_blobClient = _storageAccount.CreateCloudBlobClient();
// Retrieve reference to a previously created container.
_container = _blobClient.GetContainerReference("pictures");
_container.CreateIfNotExistsAsync();
_db = context;
imageSizes = new List<ImageSize>
{
new ImageSize { Size = Sizes.thumb, width = 80 },
new ImageSize { Size = Sizes.small, width = 360 },
new ImageSize { Size = Sizes.medium, width = 640 },
new ImageSize { Size = Sizes.large, width = 1024 }
};
}
/// <summary>
/// Calls shared access signature samples for both containers and blobs.
/// </summary>
/// <param name="container">A CloudBlobContainer object.</param>
/// <returns>A Task object.</returns>
private static async Task CallSasSamples(CloudBlobContainer container)
{
const string BlobName1 = "sasBlob1.txt";
const string BlobContent1 = "Blob created with an ad-hoc SAS granting write permissions on the container.";
const string BlobName2 = "sasBlob2.txt";
const string BlobContent2 = "Blob created with a SAS based on a stored access policy granting write permissions on the container.";
const string BlobName3 = "sasBlob3.txt";
const string BlobContent3 = "Blob created with an ad-hoc SAS granting create/write permissions to the blob.";
const string BlobName4 = "sasBlob4.txt";
const string BlobContent4 = "Blob created with a SAS based on a stored access policy granting create/write permissions to the blob.";
string sharedAccessPolicyName = "sample-policy-" + DateTime.Now.Ticks.ToString();
// Create the container if it does not already exist.
await container.CreateIfNotExistsAsync();
// Create a new shared access policy on the container.
// The access policy may be optionally used to provide constraints for
// shared access signatures on the container and the blob.
await CreateSharedAccessPolicyAsync(container, sharedAccessPolicyName);
// Generate an ad-hoc SAS URI for the container with write and list permissions.
string adHocContainerSAS = GetContainerSasUri(container);
// Test the SAS. The write and list operations should succeed, and
// the read and delete operations should fail with error code 403 (Forbidden).
await TestContainerSASAsync(adHocContainerSAS, BlobName1, BlobContent1);
// Generate a SAS URI for the container, using the stored access policy to set constraints on the SAS.
string sharedPolicyContainerSAS = GetContainerSasUri(container, sharedAccessPolicyName);
// Test the SAS. The write, read, list, and delete operations should all succeed.
await TestContainerSASAsync(sharedPolicyContainerSAS, BlobName2, BlobContent2);
// Generate an ad-hoc SAS URI for a blob within the container. The ad-hoc SAS has create, write, and read permissions.
string adHocBlobSAS = GetBlobSasUri(container, BlobName3, null);
// Test the SAS. The create, write, and read operations should succeed, and
// the delete operation should fail with error code 403 (Forbidden).
await TestBlobSASAsync(adHocBlobSAS, BlobContent3);
// Generate a SAS URI for a blob within the container, using the stored access policy to set constraints on the SAS.
string sharedPolicyBlobSAS = GetBlobSasUri(container, BlobName4, sharedAccessPolicyName);
// Test the SAS. The create, write, read, and delete operations should all succeed.
await TestBlobSASAsync(sharedPolicyBlobSAS, BlobContent4);
}
private async Task <(bool, string)> UploadToBlob(string filename, byte[] imageBuffer = null, Stream stream = null)
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = null;
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer cloudBlobContainer = null;
string storageConnectionString = _configuration["storageconnectionstring"];
// Check whether the connection string can be parsed.
if (Microsoft.WindowsAzure.Storage.CloudStorageAccount.TryParse(storageConnectionString, out storageAccount))
{
try
{
// Create the CloudBlobClient that represents the Blob storage endpoint for the storage account.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
// Create a container called 'uploadblob' and append a GUID value to it to make the name unique.
cloudBlobContainer = cloudBlobClient.GetContainerReference("womeninworkforce");// ("uploadblob" + Guid.NewGuid().ToString());
await cloudBlobContainer.CreateIfNotExistsAsync();
// Set the permissions so the blobs are public.
BlobContainerPermissions permissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
await cloudBlobContainer.SetPermissionsAsync(permissions);
// Get a reference to the blob address, then upload the file to the blob.
CloudBlockBlob cloudBlockBlob = cloudBlobContainer.GetBlockBlobReference(filename);
List <Task> tasks = new List <Task>();
int count = 0;
if (imageBuffer != null)
{
// OPTION A: use imageBuffer (converted from memory stream)
await cloudBlockBlob.UploadFromByteArrayAsync(imageBuffer, 0, imageBuffer.Length);
//tasks.Add(cloudBlockBlob.UploadFromByteArrayAsync(imageBuffer, 0, options, null).ContinueWith((t) =>
//{
// sem.Release();
// Interlocked.Increment(ref completed_count);
//}));
//count++;
}
else if (stream != null)
{
// OPTION B: pass in memory stream directly
await cloudBlockBlob.UploadFromStreamAsync(stream);
}
else
{
return(false, null);
}
return(true, cloudBlockBlob.SnapshotQualifiedStorageUri.PrimaryUri.ToString());
}
catch (Microsoft.WindowsAzure.Storage.StorageException ex)
{
return(false, null);
}
finally
{
// OPTIONAL: Clean up resources, e.g. blob container
//if (cloudBlobContainer != null)
//{
// await cloudBlobContainer.DeleteIfExistsAsync();
//}
}
}
else
{
return(false, null);
}
}
private static async Task TryCreateContainer(CloudBlobContainer container, CancellationToken cancellationToken)
{
//
// 2013-03-29
//
// HACK!
//
// "The magnitude of this hack compares favorably with that of the national debt" (c) Microsoft
//
while (true)
{
try
{
await container.CreateIfNotExistsAsync(cancellationToken);
break;
}
catch (StorageException exception)
{
RequestResult requestInformation = exception.RequestInformation;
var statusCode = (HttpStatusCode)requestInformation.HttpStatusCode;
if (statusCode != HttpStatusCode.Conflict)
{
throw;
}
}
}
}
public async Task CloudBlobClientListBlobsSegmentedWithPrefixAsync()
{
string name = "bb" + GetRandomContainerName();
DelegatingHandlerImpl delegatingHandlerImpl = new DelegatingHandlerImpl(new DelegatingHandlerImpl());
CloudBlobClient blobClient = GenerateCloudBlobClient(delegatingHandlerImpl);
CloudBlobContainer rootContainer = blobClient.GetRootContainerReference();
CloudBlobContainer container = blobClient.GetContainerReference(name);
try
{
await rootContainer.CreateIfNotExistsAsync();
await container.CreateAsync();
List <string> blobNames = await CreateBlobsAsync(container, 3, BlobType.BlockBlob);
List <string> rootBlobNames = await CreateBlobsAsync(rootContainer, 2, BlobType.BlockBlob);
BlobResultSegment results;
BlobContinuationToken token = null;
do
{
results = await blobClient.ListBlobsSegmentedAsync("bb", token);
token = results.ContinuationToken;
foreach (CloudBlockBlob blob in results.Results)
{
await blob.DeleteAsync();
rootBlobNames.Remove(blob.Name);
}
}while (token != null);
Assert.AreEqual(0, rootBlobNames.Count);
results = await blobClient.ListBlobsSegmentedAsync("bb", token);
Assert.AreEqual(0, results.Results.Count());
Assert.IsNull(results.ContinuationToken);
results = await blobClient.ListBlobsSegmentedAsync(name, token);
Assert.AreEqual(0, results.Results.Count());
Assert.IsNull(results.ContinuationToken);
token = null;
do
{
results = await blobClient.ListBlobsSegmentedAsync(name + "/", token);
token = results.ContinuationToken;
foreach (CloudBlockBlob blob in results.Results)
{
Assert.IsTrue(blobNames.Remove(blob.Name));
}
}while (token != null);
Assert.AreEqual(0, blobNames.Count);
Assert.AreNotEqual(0, delegatingHandlerImpl.CallCount);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
/// <summary>
/// Puts the lease on the given container in an unleased state (either available or broken).
/// </summary>
/// <param name="container">The container with the lease.</param>
internal static async Task SetUnleasedStateAsync(CloudBlobContainer container)
{
if (!await container.CreateIfNotExistsAsync())
{
OperationContext operationContext = new OperationContext();
try
{
await container.BreakLeaseAsync(TimeSpan.Zero, null, null, operationContext);
}
catch (Exception)
{
if (operationContext.LastResult.ExtendedErrorInformation.ErrorCode == BlobErrorCodeStrings.LeaseAlreadyBroken ||
operationContext.LastResult.ExtendedErrorInformation.ErrorCode == BlobErrorCodeStrings.LeaseNotPresentWithLeaseOperation)
{
}
else
{
throw;
}
}
}
}
/// <summary>
/// Basic operations to work with block blobs
/// </summary>
/// <returns>Task<returns>
private static async Task BasicStorageBlockBlobOperationsWithAccountSASAsync()
{
const string imageToUpload = "HelloWorld.png";
string blockBlobContainerName = "demoblockblobcontainer-" + Guid.NewGuid();
// Call GetAccountSASToken to get a sasToken based on the Storage Account Key
string sasToken = GetAccountSASToken();
// Create an AccountSAS from the SASToken
StorageCredentials accountSAS = new StorageCredentials(sasToken);
//Informational: Print the Account SAS Signature and Token
Console.WriteLine();
Console.WriteLine("Account SAS Signature: " + accountSAS.SASSignature);
Console.WriteLine("Account SAS Token: " + accountSAS.SASToken);
Console.WriteLine();
// Create a container for organizing blobs within the storage account.
Console.WriteLine("1. Creating Container using Account SAS");
// Get the Container Uri by passing the Storage Account and the container Name
Uri ContainerUri = GetContainerSASUri(blockBlobContainerName);
// Create a CloudBlobContainer by using the Uri and the sasToken
CloudBlobContainer container = new CloudBlobContainer(ContainerUri, new StorageCredentials(sasToken));
try
{
await container.CreateIfNotExistsAsync();
}
catch (StorageException)
{
Console.WriteLine("If you are running with the default configuration please make sure you have started the storage emulator. Press the Windows key and type Azure Storage to select and run it from the list of applications - then restart the sample.");
Console.ReadLine();
throw;
}
// To view the uploaded blob in a browser, you have two options. The first option is to use a Shared Access Signature (SAS) token to delegate
// access to the resource. See the documentation links at the top for more information on SAS. The second approach is to set permissions
// to allow public access to blobs in this container. Uncomment the line below to use this approach. Then you can view the image
// using: https://[InsertYourStorageAccountNameHere].blob.core.windows.net/democontainer/HelloWorld.png
// await container.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
// Upload a BlockBlob to the newly created container
Console.WriteLine("2. Uploading BlockBlob");
CloudBlockBlob blockBlob = container.GetBlockBlobReference(imageToUpload);
await blockBlob.UploadFromFileAsync(imageToUpload, FileMode.Open);
// List all the blobs in the container
Console.WriteLine("3. List Blobs in Container");
foreach (IListBlobItem blob in container.ListBlobs())
{
// Blob type will be CloudBlockBlob, CloudPageBlob or CloudBlobDirectory
// Use blob.GetType() and cast to appropriate type to gain access to properties specific to each type
Console.WriteLine("- {0} (type: {1})", blob.Uri, blob.GetType());
}
// Download a blob to your file system
Console.WriteLine("4. Download Blob from {0}", blockBlob.Uri.AbsoluteUri);
await blockBlob.DownloadToFileAsync(string.Format("./CopyOf{0}", imageToUpload), FileMode.Create);
// Create a read-only snapshot of the blob
Console.WriteLine("5. Create a read-only snapshot of the blob");
CloudBlockBlob blockBlobSnapshot = await blockBlob.CreateSnapshotAsync(null, null, null, null);
// Clean up after the demo
Console.WriteLine("6. Delete block Blob and all of its snapshots");
await blockBlob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, null, null);
Console.WriteLine("7. Delete Container");
await container.DeleteIfExistsAsync();
}
public static async Task WriteToBlob(CloudBlobContainer container, string content, string name)
{
await container.CreateIfNotExistsAsync();
var blob = container.GetBlockBlobReference(name);
Trace.TraceInformation(String.Format("Writing report to {0}", blob.Uri.AbsoluteUri));
blob.Properties.ContentType = "application/json";
await blob.UploadTextAsync(content);
Trace.TraceInformation(String.Format("Wrote report to {0}", blob.Uri.AbsoluteUri));
}
private async Task Archive(CloudBlobContainer destinationContainer)
{
var cursorJObject = await GetJObject(destinationContainer, CursorBlobName);
var cursorDateTime = cursorJObject[CursorDateTimeKey].Value<DateTime>();
JobEventSourceLog.CursorData(cursorDateTime.ToString(DateTimeFormatSpecifier));
JobEventSourceLog.GatheringPackagesToArchiveFromDB(PackageDatabase.DataSource, PackageDatabase.InitialCatalog);
List<PackageRef> packages;
using (var connection = await PackageDatabase.ConnectTo())
{
packages = (await connection.QueryAsync<PackageRef>(@"
SELECT pr.Id, p.NormalizedVersion AS Version, p.Hash, p.LastEdited, p.Published
FROM Packages p
INNER JOIN PackageRegistrations pr ON p.PackageRegistrationKey = pr.[Key]
WHERE Published > @cursorDateTime OR LastEdited > @cursorDateTime", new { cursorDateTime = cursorDateTime }))
.ToList();
}
JobEventSourceLog.GatheredPackagesToArchiveFromDB(packages.Count, PackageDatabase.DataSource, PackageDatabase.InitialCatalog);
var archiveSet = packages
.AsParallel()
.Select(r => Tuple.Create(StorageHelpers.GetPackageBlobName(r.Id, r.Version), StorageHelpers.GetPackageBackupBlobName(r.Id, r.Version, r.Hash)))
.ToList();
//if (!WhatIf)
{
await destinationContainer.CreateIfNotExistsAsync();
}
if (archiveSet.Count > 0)
{
JobEventSourceLog.StartingArchive(archiveSet.Count);
foreach (var archiveItem in archiveSet)
{
await ArchivePackage(archiveItem.Item1, archiveItem.Item2, SourceContainer, destinationContainer);
}
var maxLastEdited = packages.Max(p => p.LastEdited);
var maxPublished = packages.Max(p => p.Published);
// Time is ever increasing after all, simply store the max of published and lastEdited as cursorDateTime
var newCursorDateTime = maxLastEdited > maxPublished ? new DateTime(maxLastEdited.Value.Ticks, DateTimeKind.Utc) : new DateTime(maxPublished.Value.Ticks, DateTimeKind.Utc);
var newCursorDateTimeString = newCursorDateTime.ToString(DateTimeFormatSpecifier);
JobEventSourceLog.NewCursorData(newCursorDateTimeString);
cursorJObject[CursorDateTimeKey] = newCursorDateTimeString;
await SetJObject(destinationContainer, CursorBlobName, cursorJObject);
}
}
private async Task CreateCloudBlobContainerAsync()
{
if (_container == null && _containerName != null)
{
_container = _blobClient.GetContainerReference(_containerName);
await _container.CreateIfNotExistsAsync();
}
}
private async Task InitializeAsync()
{
_blobContainer = _blobClient.GetContainerReference(_containerName);
if (await _blobContainer.CreateIfNotExistsAsync())
{
Logger.Info(
"Created blob container {0} in account {1} for poison messages",
_containerName,
_storageAccount.BlobStorageUri);
}
}
/// <summary>
/// Get a list of valid page ranges for a page blob
/// </summary>
/// <param name="container"></param>
/// <returns>A Task object.</returns>
private static async Task PageRangesSample(CloudBlobContainer container)
{
BlobRequestOptions requestOptions = new BlobRequestOptions { RetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 3) };
await container.CreateIfNotExistsAsync(requestOptions, null);
Console.WriteLine("Create Page Blob");
CloudPageBlob pageBlob = container.GetPageBlobReference("blob1");
pageBlob.Create(4 * 1024);
Console.WriteLine("Write Pages to Blob");
byte[] buffer = GetRandomBuffer(1024);
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
pageBlob.WritePages(memoryStream, 512);
}
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
pageBlob.WritePages(memoryStream, 3 * 1024);
}
Console.WriteLine("Get Page Ranges");
IEnumerable<PageRange> pageRanges = pageBlob.GetPageRanges();
foreach (PageRange pageRange in pageRanges)
{
Console.WriteLine(pageRange.ToString());
}
// Clean up after the demo. This line is not strictly necessary as the container is deleted in the next call.
// It is included for the purposes of the example.
Console.WriteLine("Delete page blob");
await pageBlob.DeleteIfExistsAsync();
Console.WriteLine();
}
/// <summary>
/// Basic operations to work with block blobs
/// </summary>
/// <returns>A Task object.</returns>
private static async Task BasicStorageBlockBlobOperationsWithAccountSASAsync()
{
const string ImageToUpload = "HelloWorld.png";
string containerName = ContainerPrefix + Guid.NewGuid();
// Get an account SAS token.
string sasToken = GetAccountSASToken();
// Use the account SAS token to create authentication credentials.
StorageCredentials accountSAS = new StorageCredentials(sasToken);
// Informational: Print the Account SAS Signature and Token.
Console.WriteLine();
Console.WriteLine("Account SAS Signature: " + accountSAS.SASSignature);
Console.WriteLine("Account SAS Token: " + accountSAS.SASToken);
Console.WriteLine();
// Get the URI for the container.
Uri containerUri = GetContainerUri(containerName);
// Get a reference to a container using the URI and the SAS token.
CloudBlobContainer container = new CloudBlobContainer(containerUri, accountSAS);
try
{
// Create a container for organizing blobs within the storage account.
Console.WriteLine("1. Creating Container using Account SAS");
await container.CreateIfNotExistsAsync();
}
catch (StorageException e)
{
Console.WriteLine(e.ToString());
Console.WriteLine("If you are running with the default configuration, please make sure you have started the storage emulator. Press the Windows key and type Azure Storage to select and run it from the list of applications - then restart the sample.");
Console.ReadLine();
throw;
}
try
{
// To view the uploaded blob in a browser, you have two options. The first option is to use a Shared Access Signature (SAS) token to delegate
// access to the resource. See the documentation links at the top for more information on SAS. The second approach is to set permissions
// to allow public access to blobs in this container. Uncomment the line below to use this approach. Then you can view the image
// using: https://[InsertYourStorageAccountNameHere].blob.core.windows.net/democontainer/HelloWorld.png
// await container.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
// Upload a BlockBlob to the newly created container
Console.WriteLine("2. Uploading BlockBlob");
CloudBlockBlob blockBlob = container.GetBlockBlobReference(ImageToUpload);
await blockBlob.UploadFromFileAsync(ImageToUpload);
// List all the blobs in the container
Console.WriteLine("3. List Blobs in Container");
BlobContinuationToken token = null;
do
{
BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(token);
token = resultSegment.ContinuationToken;
foreach (IListBlobItem blob in resultSegment.Results)
{
// Blob type will be CloudBlockBlob, CloudPageBlob or CloudBlobDirectory
Console.WriteLine("{0} (type: {1}", blob.Uri, blob.GetType());
}
}
while (token != null);
// Download a blob to your file system
Console.WriteLine("4. Download Blob from {0}", blockBlob.Uri.AbsoluteUri);
await blockBlob.DownloadToFileAsync(string.Format("./CopyOf{0}", ImageToUpload), FileMode.Create);
// Create a read-only snapshot of the blob
Console.WriteLine("5. Create a read-only snapshot of the blob");
CloudBlockBlob blockBlobSnapshot = await blockBlob.CreateSnapshotAsync(null, null, null, null);
// Delete the blob and its snapshots.
Console.WriteLine("6. Delete block Blob and all of its snapshots");
await blockBlob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, null, null);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
throw;
}
finally
{
// Clean up after the demo.
// Note that it is not necessary to delete all of the blobs in the container first; they will be deleted
// with the container.
Console.WriteLine("7. Delete Container");
await container.DeleteIfExistsAsync();
}
}
static async Task CopyContainer(CloudBlobContainer sourceContainer, CloudBlobContainer destContainer)
{
await sourceContainer.FetchAttributesAsync();
var access = await sourceContainer.GetPermissionsAsync();
await destContainer.CreateIfNotExistsAsync(access.PublicAccess, null, null);
await destContainer.SetPermissionsAsync(access);
destContainer.Metadata.Clear();
foreach (var metadatum in sourceContainer.Metadata)
{
destContainer.Metadata.Add(metadatum);
}
await destContainer.SetMetadataAsync();
}
/// <summary>
/// Return a task that asynchronously create a container if it doesn't exist.
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="accessType">Blob container public access type</param>
/// <param name="requestOptions">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously create a container if it doesn't exist.</returns>
public Task<bool> CreateContainerIfNotExistsAsync(CloudBlobContainer container, BlobContainerPublicAccessType accessType, BlobRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
return container.CreateIfNotExistsAsync(accessType, requestOptions, operationContext, cancellationToken);
}
// Create a CSV file and save to Blob storage with the Headers required for our Azure Function processing
// A new request telemetry is created
// The request is part of the parent request (since)
public void CreateBlob(string fileName)
{
///////////////////////////////////////////////////
// Grab existing
///////////////////////////////////////////////////
Microsoft.ApplicationInsights.TelemetryClient telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
telemetryClient.Context.User.AuthenticatedUserId = "*****@*****.**";
string traceoperation = null;
string traceparent = null;
System.Console.WriteLine("telemetryClient.Context.Operation.Id: " + telemetryClient.Context.Operation.Id);
System.Console.WriteLine("telemetryClient.Context.Session.Id: " + telemetryClient.Context.Session.Id);
System.Console.WriteLine("telemetryClient.Context.Operation.ParentId: " + telemetryClient.Context.Operation.ParentId);
Microsoft.ApplicationInsights.DataContracts.RequestTelemetry requestTelemetry = new Microsoft.ApplicationInsights.DataContracts.RequestTelemetry();
requestTelemetry.Name = "Create Blob: " + fileName;
//requestTelemetry.Source = requestContext.Replace("appId=",string.Empty);
requestTelemetry.Timestamp = System.DateTimeOffset.Now;
requestTelemetry.Context.Operation.Id = traceoperation;
requestTelemetry.Context.Operation.ParentId = traceparent;
requestTelemetry.Context.User.AuthenticatedUserId = "*****@*****.**";
using (var requestBlock = telemetryClient.StartOperation<Microsoft.ApplicationInsights.DataContracts.RequestTelemetry>(requestTelemetry))
{
///////////////////////////////////////////////////
// Request Telemetry
///////////////////////////////////////////////////
requestBlock.Telemetry.Context.User.AuthenticatedUserId = "*****@*****.**";
if (!string.IsNullOrWhiteSpace(traceoperation))
{
// Use the existing common operation id
requestBlock.Telemetry.Context.Operation.Id = traceoperation;
System.Console.WriteLine("[Use existing] traceoperation: " + traceoperation);
}
else
{
// Set the traceoperation (we did not know it until now)
traceoperation = requestBlock.Telemetry.Context.Operation.Id;
System.Console.WriteLine("[Set the] traceoperation = requestBlock.Telemetry.Context.Operation.Id: " + traceoperation);
}
if (!string.IsNullOrWhiteSpace(traceparent))
{
// Use the existing traceparent
requestBlock.Telemetry.Context.Operation.ParentId = traceparent;
System.Console.WriteLine("[Use existing] traceparent: " + traceparent);
}
else
{
traceparent = requestBlock.Telemetry.Id;
System.Console.WriteLine("[Set the] traceparent = requestBlock.Telemetry.Id: " + traceparent);
}
// Store future parent id
traceparent = requestBlock.Telemetry.Id;
System.Console.WriteLine("traceparent = requestBlock.Telemetry.Id: " + traceparent);
///////////////////////////////////////////////////
// Create Dependency for future Azure Function processing
// NOTE: I trick it by giving a Start Time Offset of Now.AddSeconds(1), so it sorts correctly in the Azure Portal UI
///////////////////////////////////////////////////
string operationName = "Dependency: Blob Event";
// Set the target so it points to the "dependent" app insights account app id
// string target = "03-disttrace-func-blob | cid-v1:676560d0-81fb-4e5b-bfdd-7da1ad11c866"
string target = "03-disttrace-func-blob | cid-v1:" + System.Environment.GetEnvironmentVariable("ai_03_disttrace_web_app_appkey");
string dependencyName = "Dependency Name: Azure Function Blob Trigger";
Microsoft.ApplicationInsights.DataContracts.DependencyTelemetry dependencyTelemetry =
new Microsoft.ApplicationInsights.DataContracts.DependencyTelemetry(
operationName, target, dependencyName,
"02-disttrace-web-app", System.DateTimeOffset.Now.AddSeconds(1), System.TimeSpan.FromSeconds(2), "200", true);
dependencyTelemetry.Context.Operation.Id = traceoperation;
dependencyTelemetry.Context.Operation.ParentId = requestBlock.Telemetry.Id;
// Store future parent id
traceparent = dependencyTelemetry.Id;
System.Console.WriteLine("traceparent = dependencyTelemetry.Id: " + traceparent);
telemetryClient.TrackDependency(dependencyTelemetry);
///////////////////////////////////////////////////
// Blob code
///////////////////////////////////////////////////
string containerName = "appinsightstest";
string storageConnectionString = System.Environment.GetEnvironmentVariable("ai_storage_key");
CloudStorageAccount storageAccount = null;
System.Console.WriteLine("storageConnectionString: " + storageConnectionString);
CloudStorageAccount.TryParse(storageConnectionString, out storageAccount);
System.Collections.Generic.List<string> list = new System.Collections.Generic.List<string>();
list.Add("id,date");
for (int i = 1; i <= 50000; i++)
{
list.Add(i.ToString() + "," + string.Format("{0:MM/dd/yyyy}", System.DateTime.Now));
}
var text = string.Join("\n", list.ToArray());
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient();
blobStorage.DefaultRequestOptions.RetryPolicy = new Microsoft.WindowsAzure.Storage.RetryPolicies.LinearRetry(System.TimeSpan.FromSeconds(1), 10);
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobStorage.GetContainerReference(containerName);
container.CreateIfNotExistsAsync().Wait();
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blob = container.GetBlockBlobReference(fileName);
///////////////////////////////////////////////////
// Set the blob's meta data
// We need the values from the dependency
///////////////////////////////////////////////////
// Request-Context: appId=cid-v1:{The App Id of the current App Insights Account}
string requestContext = "appId=cid-v1:" + System.Environment.GetEnvironmentVariable("ai_02_disttrace_web_app_appkey");
System.Console.WriteLine("Blob Metadata -> requestContext: " + requestContext);
blob.Metadata.Add("RequestContext", requestContext);
// Request-Id / traceparent: {parent request/operation id} (e.g. the Track Dependency)
System.Console.WriteLine("Blob Metadata -> RequestId: " + traceparent);
blob.Metadata.Add("RequestId", traceparent);
System.Console.WriteLine("Blob Metadata -> traceparent: " + traceparent);
blob.Metadata.Add("traceparent", traceparent);
// Traceoperation {common operation id} (e.g. same operation id for all requests in this telemetry pipeline)
System.Console.WriteLine("Blob Metadata -> traceoperation: " + traceoperation);
blob.Metadata.Add("traceoperation", traceoperation);
using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(text)))
{
blob.UploadFromStreamAsync(memoryStream).Wait();
}
requestTelemetry.ResponseCode = "200";
requestTelemetry.Success = true;
telemetryClient.StopOperation(requestBlock);
} // using
///////////////////////////////////////////////////
// For Debugging
///////////////////////////////////////////////////
telemetryClient.Flush();
} // Create Blob