private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
CloudBlob SASblob;
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = container.GetBlockBlobReference(blob.Name);
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = container.GetPageBlobReference(blob.Name);
}
else
{
SASblob = container.GetAppendBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
else
{
SASblob = new CloudAppendBlob(credentials.TransformUri(blob.Uri));
}
}
HttpStatusCode failureCode = sasToken == null ? HttpStatusCode.NotFound : HttpStatusCode.Forbidden;
// We want to ensure that 'create', 'add', and 'write' permissions all allow for correct writing of blobs, as is reasonable.
if (((permissions & SharedAccessBlobPermissions.Create) == SharedAccessBlobPermissions.Create) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
if (blob.BlobType == BlobType.PageBlob)
{
CloudPageBlob SASpageBlob = (CloudPageBlob)SASblob;
SASpageBlob.Create(512);
CloudPageBlob pageBlob = (CloudPageBlob)blob;
byte[] buffer = new byte[512];
buffer[0] = 2; // random data
if (((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASpageBlob.UploadFromByteArray(buffer, 0, 512);
}
else
{
TestHelper.ExpectedException(
() => SASpageBlob.UploadFromByteArray(buffer, 0, 512),
"pageBlob SAS token without Write perms should not allow for writing/adding",
failureCode);
pageBlob.UploadFromByteArray(buffer, 0, 512);
}
}
else if (blob.BlobType == BlobType.BlockBlob)
{
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
UploadText(SASblob, "blob", Encoding.UTF8);
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"Block blob SAS token without Write or perms should not allow for writing",
failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
}
else // append blob
{
// If the sas token contains Feb 2012, append won't be accepted
if (sasToken.Contains(Constants.VersionConstants.February2012))
{
UploadText(blob, "blob", Encoding.UTF8);
}
else
{
CloudAppendBlob SASAppendBlob = SASblob as CloudAppendBlob;
SASAppendBlob.CreateOrReplace();
byte[] textAsBytes = Encoding.UTF8.GetBytes("blob");
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
if (((permissions & SharedAccessBlobPermissions.Add) == SharedAccessBlobPermissions.Add) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASAppendBlob.AppendBlock(stream, null);
}
else
{
TestHelper.ExpectedException(
() => SASAppendBlob.AppendBlock(stream, null),
"Append blob SAS token without Write or Add perms should not allow for writing/adding",
failureCode);
stream.Seek(0, SeekOrigin.Begin);
((CloudAppendBlob)blob).AppendBlock(stream, null);
}
}
}
}
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"UploadText SAS does not allow for writing/adding",
((blob.BlobType == BlobType.AppendBlob) && (sasToken != null) && (sasToken.Contains(Constants.VersionConstants.February2012))) ? HttpStatusCode.BadRequest : failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
failureCode);
}
}
// need to have written to the blob to read from it.
if (((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read))
{
SASblob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASblob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASblob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASblob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASblob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASblob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => SASblob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
SASblob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => SASblob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
SASblob.Delete();
}
else
{
TestHelper.ExpectedException(
() => SASblob.Delete(),
"Delete blob while SAS does not allow for deleting",
failureCode);
}
}
internal StorageBlob.ICloudBlob CopyBlobAndWaitForComplete(CloudBlobUtil blobUtil)
{
string destBlobName = Utility.GenNameString("copystate");
StorageBlob.ICloudBlob destBlob = default(StorageBlob.ICloudBlob);
Test.Info("Copy Blob using storage client");
if (blobUtil.Blob.BlobType == StorageBlob.BlobType.BlockBlob)
{
StorageBlob.CloudBlockBlob blockBlob = blobUtil.Container.GetBlockBlobReference(destBlobName);
blockBlob.StartCopyFromBlob((StorageBlob.CloudBlockBlob)blobUtil.Blob);
destBlob = blockBlob;
}
else
{
StorageBlob.CloudPageBlob pageBlob = blobUtil.Container.GetPageBlobReference(destBlobName);
pageBlob.StartCopyFromBlob((StorageBlob.CloudPageBlob)blobUtil.Blob);
destBlob = pageBlob;
}
CloudBlobUtil.WaitForCopyOperationComplete(destBlob);
Test.Assert(destBlob.CopyState.Status == StorageBlob.CopyStatus.Success, String.Format("The blob copy using storage client should be success, actually it's {0}", destBlob.CopyState.Status));
return(destBlob);
}
public void Initialize()
{
vmPowershellCmdlets = new ServiceManagementCmdletTestHelper();
vmPowershellCmdlets.ImportAzurePublishSettingsFile();
defaultAzureSubscription = vmPowershellCmdlets.SetDefaultAzureSubscription(Resource.DefaultSubscriptionName);
Assert.AreEqual(Resource.DefaultSubscriptionName, defaultAzureSubscription.SubscriptionName);
storageAccountKey = vmPowershellCmdlets.GetAzureStorageAccountKey(defaultAzureSubscription.CurrentStorageAccount);
Assert.AreEqual(defaultAzureSubscription.CurrentStorageAccount, storageAccountKey.StorageAccountName);
destination = string.Format(@"http://{0}.blob.core.windows.net/vhdstore/{1}", defaultAzureSubscription.CurrentStorageAccount, Utilities.GetUniqueShortName("PSTestAzureVhd"));
patchDestination = string.Format(@"http://{0}.blob.core.windows.net/vhdstore/{1}", defaultAzureSubscription.CurrentStorageAccount, Utilities.GetUniqueShortName("PSTestAzureVhd"));
destinationSasUri = string.Format(@"http://{0}.blob.core.windows.net/vhdstore/{1}", defaultAzureSubscription.CurrentStorageAccount, Utilities.GetUniqueShortName("PSTestAzureVhd"));
patchDestinationSasUri = string.Format(@"http://{0}.blob.core.windows.net/vhdstore/{1}", defaultAzureSubscription.CurrentStorageAccount, Utilities.GetUniqueShortName("PSTestAzureVhd"));
var destinationBlob = new CloudPageBlob(new Uri(destinationSasUri), new StorageCredentials(storageAccountKey.StorageAccountName, storageAccountKey.Primary));
var patchDestinationBlob = new CloudPageBlob(new Uri(patchDestinationSasUri), new StorageCredentials(storageAccountKey.StorageAccountName, storageAccountKey.Primary));
var policy = new SharedAccessBlobPolicy()
{
Permissions =
SharedAccessBlobPermissions.Delete |
SharedAccessBlobPermissions.Read |
SharedAccessBlobPermissions.Write |
SharedAccessBlobPermissions.List,
SharedAccessExpiryTime = DateTime.UtcNow + TimeSpan.FromHours(1)
};
var destinationBlobToken = destinationBlob.GetSharedAccessSignature(policy);
var patchDestinationBlobToken = patchDestinationBlob.GetSharedAccessSignature(policy);
destinationSasUri += destinationBlobToken;
patchDestinationSasUri += patchDestinationBlobToken;
blobUrlRoot = string.Format(@"http://{0}.blob.core.windows.net/", defaultAzureSubscription.CurrentStorageAccount);
perfFile = "perf.csv";
}
public async Task FillFromBlobAsync(CloudPageBlob blob)
{
using (var stream = blob.OpenRead())
{
stream.Seek(this.GetBaseAddress(), SeekOrigin.Begin);
await stream.ReadAsync(_data, 0, AzurePageBlob.PageSize);
}
}
public void FillFromBlob(CloudPageBlob blob)
{
using (var stream = blob.OpenRead())
{
stream.Seek(this.GetBaseAddress(), SeekOrigin.Begin);
stream.Read(_data, 0, AzurePageBlob.PageSize);
}
}
internal PageBlobWriter(
TransferScheduler scheduler,
SyncTransferController controller,
CancellationToken cancellationToken)
: base(scheduler, controller, cancellationToken)
{
this.pageBlob = this.TransferJob.Destination.Blob as CloudPageBlob;
}
public FakeStoragePageBlob(MemoryBlobStore store, string blobName, IStorageBlobContainer parent)
{
_store = store;
_blobName = blobName;
_parent = parent;
_containerName = parent.Name;
_metadata = new Dictionary<string, string>();
_sdkObject = new CloudPageBlob(new Uri("http://localhost/" + _containerName + "/" + blobName));
}
public PageBlobReader(
TransferScheduler scheduler,
SyncTransferController controller,
CancellationToken cancellationToken)
:base(scheduler, controller, cancellationToken)
{
pageBlob = this.SharedTransferData.TransferJob.Source.Blob as CloudPageBlob;
Debug.Assert(null != this.pageBlob, "Initializing a PageBlobReader, the source location should be a CloudPageBlob instance.");
}
public BlobSynchronizer(UploadContext context, int maxParallelism)
{
this.context = context;
this.md5Hash = context.Md5HashOfLocalVhd;
this.dataWithRanges = context.UploadableDataWithRanges;
this.dataToUpload = context.UploadableDataSize;
this.alreadyUploadedData = context.AlreadyUploadedDataSize;
this.blob = context.DestinationBlob;
this.maxParallelism = maxParallelism;
}
protected BlobCreatorBase(FileInfo localVhd, BlobUri blobDestination, ICloudPageBlobObjectFactory blobObjectFactory, bool overWrite)
{
this.localVhd = localVhd;
this.blobObjectFactory = blobObjectFactory;
this.destination = new Uri(blobDestination.BlobPath);
this.blobDestination = blobDestination;
this.overWrite = overWrite;
this.destinationBlob = blobObjectFactory.Create(blobDestination);
this.requestOptions = this.blobObjectFactory.CreateRequestOptions();
}
public static void Init(CloudPageBlob blob)
{
if (ls == null)
{
ms = new MemoryStream();
var geoIpFileStream = blob.OpenRead();
geoIpFileStream.CopyTo(ms);
ls = new LookupService(ms);
}
}
/// <summary>
/// create a new page blob with random properties and metadata
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="blobName">blob name</param>
/// <returns>ICloudBlob object</returns>
public StorageBlob.ICloudBlob CreatePageBlob(StorageBlob.CloudBlobContainer container, string blobName)
{
StorageBlob.CloudPageBlob pageBlob = container.GetPageBlobReference(blobName);
int size = random.Next(1, 10) * PageBlobUnitSize;
pageBlob.Create(size);
byte[] buffer = new byte[size];
string md5sum = Convert.ToBase64String(Helper.GetMD5(buffer));
pageBlob.Properties.ContentMD5 = md5sum;
GenerateBlobPropertiesAndMetaData(pageBlob);
Test.Info(string.Format("create page blob '{0}' in container '{1}'", blobName, container.Name));
return(pageBlob);
}
public BlobHandle(BlobUri blobUri, string storageAccountKey)
{
this.blobUri = blobUri;
this.storageAccountKey = storageAccountKey;
var blobClient = new CloudBlobClient(new Uri(this.blobUri.BaseUri), new StorageCredentials(this.blobUri.StorageAccountName, this.storageAccountKey));
this.container = blobClient.GetContainerReference(this.blobUri.BlobContainerName);
this.container.FetchAttributes();
this.pageBlob = this.container.GetPageBlobReference(blobUri.BlobName);
this.blobRequestOptions = new BlobRequestOptions
{
ServerTimeout = TimeSpan.FromMinutes(5),
RetryPolicy = new LinearRetry(TimeSpan.FromMinutes(1), 3)
};
this.pageBlob.FetchAttributes(new AccessCondition(), blobRequestOptions);
}
private static async Task TestAccessAsync(BlobContainerPublicAccessType accessType, CloudBlobContainer container, CloudBlob inputBlob)
{
StorageCredentials credentials = new StorageCredentials();
container = new CloudBlobContainer(container.Uri, credentials);
CloudPageBlob blob = new CloudPageBlob(inputBlob.Uri, credentials);
OperationContext context = new OperationContext();
BlobRequestOptions options = new BlobRequestOptions();
if (accessType.Equals(BlobContainerPublicAccessType.Container))
{
await blob.FetchAttributesAsync();
await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context);
await container.FetchAttributesAsync();
}
else if (accessType.Equals(BlobContainerPublicAccessType.Blob))
{
await blob.FetchAttributesAsync();
await TestHelper.ExpectedExceptionAsync(
async () => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context),
context,
"List blobs while public access does not allow for listing",
HttpStatusCode.NotFound);
await TestHelper.ExpectedExceptionAsync(
async () => await container.FetchAttributesAsync(null, options, context),
context,
"Fetch container attributes while public access does not allow",
HttpStatusCode.NotFound);
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await blob.FetchAttributesAsync(null, options, context),
context,
"Fetch blob attributes while public access does not allow",
HttpStatusCode.NotFound);
await TestHelper.ExpectedExceptionAsync(
async () => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context),
context,
"List blobs while public access does not allow for listing",
HttpStatusCode.NotFound);
await TestHelper.ExpectedExceptionAsync(
async () => await container.FetchAttributesAsync(null, options, context),
context,
"Fetch container attributes while public access does not allow",
HttpStatusCode.NotFound);
}
}
private static void TestAccessTask(BlobContainerPublicAccessType accessType, CloudBlobContainer container, CloudBlob inputBlob)
{
StorageCredentials credentials = new StorageCredentials();
container = new CloudBlobContainer(container.Uri, credentials);
CloudPageBlob blob = new CloudPageBlob(inputBlob.Uri, credentials);
if (accessType.Equals(BlobContainerPublicAccessType.Container))
{
blob.FetchAttributesAsync().Wait();
BlobContinuationToken token = null;
do
{
BlobResultSegment results = container.ListBlobsSegmented(token);
results.Results.ToArray();
token = results.ContinuationToken;
}
while (token != null);
container.FetchAttributesAsync().Wait();
}
else if (accessType.Equals(BlobContainerPublicAccessType.Blob))
{
blob.FetchAttributesAsync().Wait();
TestHelper.ExpectedExceptionTask(
container.ListBlobsSegmentedAsync(null),
"List blobs while public access does not allow for listing",
HttpStatusCode.NotFound);
TestHelper.ExpectedExceptionTask(
container.FetchAttributesAsync(),
"Fetch container attributes while public access does not allow",
HttpStatusCode.NotFound);
}
else
{
TestHelper.ExpectedExceptionTask(
blob.FetchAttributesAsync(),
"Fetch blob attributes while public access does not allow",
HttpStatusCode.NotFound);
TestHelper.ExpectedExceptionTask(
container.ListBlobsSegmentedAsync(null),
"List blobs while public access does not allow for listing",
HttpStatusCode.NotFound);
TestHelper.ExpectedExceptionTask(
container.FetchAttributesAsync(),
"Fetch container attributes while public access does not allow",
HttpStatusCode.NotFound);
}
}
/// <summary>
/// Initializes a new instance of the BlobWriteStream class for a page blob.
/// </summary>
/// <param name="pageBlob">Blob reference to write to.</param>
/// <param name="pageBlobSize">Size of the page blob.</param>
/// <param name="createNew">Use <c>true</c> if the page blob is newly created, <c>false</c> otherwise.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. If <c>null</c>, no condition is used.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <param name="transform">The ICryptoTransform function for the request.</param>
internal BlobEncryptedWriteStream(CloudPageBlob pageBlob, long pageBlobSize, bool createNew, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, ICryptoTransform transform)
{
CommonUtility.AssertNotNull("transform", transform);
if (options.EncryptionPolicy.EncryptionMode != BlobEncryptionMode.FullBlob)
{
throw new InvalidOperationException(SR.InvalidEncryptionMode, null);
}
// Since this is done on the copy of the options object that the client lib maintains and not on the user's options object and is done after getting
// the transform function, it should be fine. Setting this ensures that an error is not thrown when PutPage is called internally from the write method on the stream.
options.SkipEncryptionPolicyValidation = true;
this.transform = transform;
this.writeStream = new BlobWriteStream(pageBlob, pageBlobSize, createNew, accessCondition, options, operationContext) { IgnoreFlush = true };
this.cryptoStream = new CryptoStream(this.writeStream, transform, CryptoStreamMode.Write);
}
async Task LeaderMethod(CancellationToken token, CloudPageBlob blob) {
var processors = Environment.ProcessorCount;
int parallelism = processors / 2;
if (parallelism < 1) {
parallelism = 1;
}
_log.Information("Node is a leader with {processors} processors. Setting parallelism to {parallelism}",
processors,
parallelism);
using (var scheduler = MessageWriteScheduler.Create(_account, parallelism)) {
try {
_log.Information("Message write scheduler created");
_api.EnableDirectWrites(scheduler);
// tell the world who is the leader
await _info.WriteToBlob(_account);
// sleep till cancelled
await Task.Delay(-1, token);
}
catch (OperationCanceledException) {
// expect this exception to be thrown in normal circumstances or check the cancellation token, because
// if the lease can't be renewed, the token will signal a cancellation request.
_log.Information("Shutting down the scheduler");
// shutdown the scheduler
_api.DisableDirectWrites();
var shutdown = scheduler.Shutdown();
if (shutdown.Wait(5000)) {
_log.Information("Scheduler is down");
} else {
_log.Error("Scheduler failed to shutdown in time");
}
}
finally {
_api.DisableDirectWrites();
_log.Information("This node is no longer a leader");
}
}
}
private static void TestAccess(BlobContainerPublicAccessType accessType, CloudBlobContainer container, CloudBlob inputBlob)
{
StorageCredentials credentials = new StorageCredentials();
container = new CloudBlobContainer(container.Uri, credentials);
CloudPageBlob blob = new CloudPageBlob(inputBlob.Uri, credentials);
if (accessType.Equals(BlobContainerPublicAccessType.Container))
{
blob.FetchAttributes();
container.ListBlobs().ToArray();
container.FetchAttributes();
}
else if (accessType.Equals(BlobContainerPublicAccessType.Blob))
{
blob.FetchAttributes();
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while public access does not allow for listing",
HttpStatusCode.NotFound);
TestHelper.ExpectedException(
() => container.FetchAttributes(),
"Fetch container attributes while public access does not allow",
HttpStatusCode.NotFound);
}
else
{
TestHelper.ExpectedException(
() => blob.FetchAttributes(),
"Fetch blob attributes while public access does not allow",
HttpStatusCode.NotFound);
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while public access does not allow for listing",
HttpStatusCode.NotFound);
TestHelper.ExpectedException(
() => container.FetchAttributes(),
"Fetch container attributes while public access does not allow",
HttpStatusCode.NotFound);
}
}
private static void HandleUserInput(CloudBlobContainer container, CloudPageBlob pageBlob)
{
Console.WriteLine("Save file? Y/N");
var result = Console.ReadLine();
if (String.IsNullOrEmpty(result))
{
return;
}
switch (result.ToLower())
{
case "y":
{
_blobDownloader.SavePageBlob(container, pageBlob);
} break;
default:
{
Console.WriteLine("welp");
break;
}
}
}
public string StartCopyFromBlob(CloudPageBlob source, AccessCondition sourceAccessCondition = null, AccessCondition destAccessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
return this.StartCopyFromBlob(CloudBlobSharedImpl.SourceBlobToUri(source), sourceAccessCondition, destAccessCondition, options, operationContext);
}
public virtual Task<string> StartCopyAsync(CloudPageBlob source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return this.StartCopyAsync(CloudBlob.SourceBlobToUri(source), sourceAccessCondition, destAccessCondition, options, operationContext, cancellationToken);
}
public virtual Task<string> StartCopyAsync(CloudPageBlob source)
{
return this.StartCopyAsync(CloudBlob.SourceBlobToUri(source));
}
/// <summary>
/// Implementation for the CreateSnapshot method.
/// </summary>
/// <param name="metadata">A collection of name-value pairs defining the metadata of the snapshot, or <c>null</c>.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the blob. If <c>null</c>, no condition is used.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that creates the snapshot.</returns>
/// <remarks>If the <c>metadata</c> parameter is <c>null</c> then no metadata is associated with the request.</remarks>
private RESTCommand<CloudPageBlob> CreateSnapshotImpl(IDictionary<string, string> metadata, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<CloudPageBlob> putCmd = new RESTCommand<CloudPageBlob>(this.ServiceClient.Credentials, this.attributes.StorageUri);
options.ApplyToStorageCommand(putCmd);
putCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) =>
{
StorageRequestMessage msg = BlobHttpRequestMessageFactory.Snapshot(uri, serverTimeout, accessCondition, cnt, ctx, this.ServiceClient.GetCanonicalizer(), this.ServiceClient.Credentials);
if (metadata != null)
{
BlobHttpRequestMessageFactory.AddMetadata(msg, metadata);
}
return msg;
};
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, null /* retVal */, cmd, ex);
DateTimeOffset snapshotTime = NavigationHelper.ParseSnapshotTime(BlobHttpResponseParsers.GetSnapshotTime(resp));
CloudPageBlob snapshot = new CloudPageBlob(this.Name, snapshotTime, this.Container);
snapshot.attributes.Metadata = new Dictionary<string, string>(metadata ?? this.Metadata);
snapshot.attributes.Properties = new BlobProperties(this.Properties);
CloudBlob.UpdateETagLMTLengthAndSequenceNumber(snapshot.attributes, resp, false);
return snapshot;
};
return putCmd;
}
internal BlobWriteStream(CloudPageBlob pageBlob, long pageBlobSize, bool createNew, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: base(pageBlob, pageBlobSize, createNew, accessCondition, options, operationContext)
{
throw new System.NotImplementedException();
}
public void SetAzureBlobContentByContainerWithMismatchBlobTypeTest()
{
AddTestBlobs();
string bloburi = "http://127.0.0.1/account/container20/blob8";
CloudPageBlob blob = new CloudPageBlob(new Uri(bloburi));
string fileName = @"c:\Windows\System32\cmd.exe";
AssertThrows<ArgumentException>(() => command.SetAzureBlobContent(fileName, blob, false),
String.Format(Resources.BlobTypeMismatch, blob.Name, BlobType.BlockBlob));
}
public async Task StoreBlobContentMD5TestAsync()
{
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = false,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob1 = container.GetBlockBlobReference("blob1");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
await blob1.FetchAttributesAsync();
Assert.IsNotNull(blob1.Properties.ContentMD5);
blob1 = container.GetBlockBlobReference("blob2");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null);
}
await blob1.FetchAttributesAsync();
Assert.IsNull(blob1.Properties.ContentMD5);
blob1 = container.GetBlockBlobReference("blob3");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream);
}
await blob1.FetchAttributesAsync();
Assert.IsNotNull(blob1.Properties.ContentMD5);
CloudPageBlob blob2 = container.GetPageBlobReference("blob4");
blob2 = container.GetPageBlobReference("blob4");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
await blob2.FetchAttributesAsync();
Assert.IsNotNull(blob2.Properties.ContentMD5);
blob2 = container.GetPageBlobReference("blob5");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null);
}
await blob2.FetchAttributesAsync();
Assert.IsNull(blob2.Properties.ContentMD5);
blob2 = container.GetPageBlobReference("blob6");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream);
}
await blob2.FetchAttributesAsync();
Assert.IsNull(blob2.Properties.ContentMD5);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
private string GetAzureVmSasUri(string vmImageName)
{
string mediaLinkUri = null;
Uri uri = null;
StorageManagementClient storageClient = null;
string storageAccountName = null;
StorageAccountGetKeysResponse getKeysResponse = null;
ErrorRecord er = null;
StorageCredentials credentials = null;
SharedAccessBlobPolicy accessPolicy = null;
CloudPageBlob pageBlob = null;
string sas = null;
mediaLinkUri = GetImageUri(vmImageName);
uri = new Uri(mediaLinkUri);
storageClient = new StorageManagementClient(this.Client.Credentials, this.Client.BaseUri);
storageAccountName = uri.Authority.Split('.')[0];
getKeysResponse = storageClient.StorageAccounts.GetKeys(storageAccountName);
if (getKeysResponse.StatusCode != System.Net.HttpStatusCode.OK)
{
er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
String.Format(Commands_RemoteApp.GettingStorageAccountKeyErrorFormat, getKeysResponse.StatusCode.ToString()),
String.Empty,
Client.TemplateImages,
ErrorCategory.ConnectionError
);
ThrowTerminatingError(er);
}
credentials = new StorageCredentials(storageAccountName, getKeysResponse.SecondaryKey);
accessPolicy = new SharedAccessBlobPolicy();
pageBlob = new CloudPageBlob(uri, credentials);
accessPolicy.Permissions = SharedAccessBlobPermissions.Read;
accessPolicy.SharedAccessStartTime = DateTime.Now;
accessPolicy.SharedAccessExpiryTime = DateTime.Now.AddHours(12);
sas = pageBlob.GetSharedAccessSignature(accessPolicy);
if (sas == null)
{
er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
Commands_RemoteApp.FailedToGetSasUriError,
String.Empty,
Client.TemplateImages,
ErrorCategory.ConnectionError
);
ThrowTerminatingError(er);
}
return mediaLinkUri + sas;
}
public Task<string> StartCopyAsync(CloudPageBlob source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return AsyncExtensions.TaskFromApm(this.BeginStartCopy, this.EndStartCopy, source, sourceAccessCondition, destAccessCondition, options, operationContext, cancellationToken);
}
public Task<string> StartCopyAsync(CloudPageBlob source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, OperationContext operationContext)
{
return this.StartCopyAsync(source, sourceAccessCondition, destAccessCondition, options, operationContext, CancellationToken.None);
}
private static async Task TestAccessAsync(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, ICloudBlob blob)
{
OperationContext operationContext = new OperationContext();
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(container.Uri, credentials);
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else
{
blob = container.GetPageBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(blob.Uri, credentials);
}
else
{
blob = new CloudPageBlob(blob.Uri, credentials);
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
await container.ListBlobsSegmentedAsync(null);
}
else
{
await TestHelper.ExpectedExceptionAsync(
async() => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.None, null, null, null, operationContext),
operationContext,
"List blobs while SAS does not allow for listing",
HttpStatusCode.NotFound);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
await blob.FetchAttributesAsync();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, blob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, blob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, blob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, blob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, blob.Properties.ContentType);
}
}
}
else
{
await TestHelper.ExpectedExceptionAsync(
async() => await blob.FetchAttributesAsync(null, null, operationContext),
operationContext,
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
await blob.SetMetadataAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(null, null, operationContext),
operationContext,
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
await blob.DeleteAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async() => await blob.DeleteAsync(DeleteSnapshotsOption.None, null, null, operationContext),
operationContext,
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.NotFound);
}
}
public ICancellableAsyncResult BeginStartCopyFromBlob(CloudPageBlob source, AsyncCallback callback, object state)
{
return this.BeginStartCopyFromBlob(CloudBlobSharedImpl.SourceBlobToUri(source), callback, state);
}
public void SetAzureBlobContentByContainerWithInvalidNameTest()
{
ICloudBlob blob = null;
string fileName = @"c:\Windows\System32\cmd.exe";
string bloburi = "http://127.0.0.1/account/test/";
blob = new CloudPageBlob(new Uri(bloburi));
AssertThrows<ArgumentException>(() => command.SetAzureBlobContent(fileName, blob, false),
String.Format(Resources.InvalidBlobName, blob.Name));
}
public ICancellableAsyncResult BeginStartCopyFromBlob(CloudPageBlob source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
return this.BeginStartCopyFromBlob(CloudBlobSharedImpl.SourceBlobToUri(source), sourceAccessCondition, destAccessCondition, options, operationContext, callback, state);
}
/// <summary>
/// Implementation for the CreateSnapshot method.
/// </summary>
/// <param name="metadata">A collection of name-value pairs defining the metadata of the snapshot, or null.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the blob. If <c>null</c>, no condition is used.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that creates the snapshot.</returns>
/// <remarks>If the <c>metadata</c> parameter is <c>null</c> then no metadata is associated with the request.</remarks>
private RESTCommand<CloudPageBlob> CreateSnapshotImpl(IDictionary<string, string> metadata, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<CloudPageBlob> putCmd = new RESTCommand<CloudPageBlob>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Snapshot(uri, serverTimeout, accessCondition, ctx);
putCmd.SetHeaders = (r, ctx) =>
{
if (metadata != null)
{
BlobHttpWebRequestFactory.AddMetadata(r, metadata);
}
};
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, null /* retVal */, cmd, ex, ctx);
DateTimeOffset snapshotTime = NavigationHelper.ParseSnapshotTime(BlobHttpResponseParsers.GetSnapshotTime(resp));
CloudPageBlob snapshot = new CloudPageBlob(this.Name, snapshotTime, this.Container);
snapshot.attributes.Metadata = new Dictionary<string, string>(metadata ?? this.Metadata);
snapshot.attributes.Properties = new BlobProperties(this.Properties);
CloudBlobSharedImpl.ParseSizeAndLastModified(snapshot.attributes, resp);
return snapshot;
};
return putCmd;
}
public HostedAzurePageBlob(CloudPageBlob cloudPageBlob)
{
_cloudPageBlob = cloudPageBlob;
}
public async Task DisableContentMD5ValidationTestAsync()
{
byte[] buffer = new byte[1024];
Random random = new Random();
random.NextBytes(buffer);
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
DisableContentMD5Validation = true,
StoreBlobContentMD5 = true,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
DisableContentMD5Validation = false,
StoreBlobContentMD5 = true,
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
using (Stream stream = new NonSeekableMemoryStream(buffer))
{
await blockBlob.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
using (Stream stream = new MemoryStream())
{
await blockBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, null);
await blockBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
blockBlob.Properties.ContentMD5 = "MDAwMDAwMDA=";
await blockBlob.SetPropertiesAsync();
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await blockBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext),
opContext,
"Downloading a blob with invalid MD5 should fail",
HttpStatusCode.OK);
await blockBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream;
TestHelper.ExpectedException <IOException>(
() =>
{
int read;
do
{
read = blobStreamForRead.Read(buffer, 0, buffer.Length);
}while (read > 0);
},
"Downloading a blob with invalid MD5 should fail");
}
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
}
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
using (Stream stream = new MemoryStream(buffer))
{
await pageBlob.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
using (Stream stream = new MemoryStream())
{
await pageBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, null);
await pageBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
pageBlob.Properties.ContentMD5 = "MDAwMDAwMDA=";
await pageBlob.SetPropertiesAsync();
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await pageBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext),
opContext,
"Downloading a blob with invalid MD5 should fail",
HttpStatusCode.OK);
await pageBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream;
TestHelper.ExpectedException <IOException>(
() =>
{
int read;
do
{
read = blobStreamForRead.Read(buffer, 0, buffer.Length);
}while (read > 0);
},
"Downloading a blob with invalid MD5 should fail");
}
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}