public static HttpRequestMessage GetBlobRequest(BlobContext context, string containerName, string blobName, AccessCondition accessCondition)
{
bool valid = BlobTests.ContainerNameValidator(containerName) &&
BlobTests.BlobNameValidator(blobName) &&
BlobTests.LeaseIdValidator(accessCondition);
Uri uri = BlobTests.ConstructGetUri(context.Address, containerName, blobName);
HttpRequestMessage request = null;
OperationContext opContext = new OperationContext();
try
{
request = BlobHttpRequestMessageFactory.Get(uri, context.Timeout, null /* snapshot */, accessCondition, null, opContext, SharedKeyCanonicalizer.Instance, context.Credentials);
}
catch (InvalidOperationException)
{
if (valid)
{
Assert.Fail();
}
}
if (valid)
{
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Get, request.Method);
BlobTestUtils.RangeHeader(request, null);
BlobTestUtils.LeaseIdHeader(request, accessCondition == null ? null : accessCondition.LeaseId);
}
return(request);
}
/// <summary>
/// Constructs a web request to delete a blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="deleteSnapshotsOption">A set of options indicating whether to delete only blobs, only snapshots, or both.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Delete(Uri uri, int?timeout, DateTimeOffset?snapshot, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
if ((snapshot != null) && (deleteSnapshotsOption != DeleteSnapshotsOption.None))
{
throw new InvalidOperationException(string.Format(SR.DeleteSnapshotsNotValidError, "deleteSnapshotsOption", "snapshot"));
}
UriQueryBuilder builder = new UriQueryBuilder();
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
HttpRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, builder, content, operationContext);
switch (deleteSnapshotsOption)
{
case DeleteSnapshotsOption.None:
break; // nop
case DeleteSnapshotsOption.IncludeSnapshots:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.IncludeSnapshotsValue);
break;
case DeleteSnapshotsOption.DeleteSnapshotsOnly:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.SnapshotsOnlyValue);
break;
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
public async static void AcquireAndReleaseLeaseTest(BlobContext context, string containerName, string blobName)
{
CloudStorageAccount account = new CloudStorageAccount(new StorageCredentials(context.Account, context.Key), false);
CloudBlobClient client = new CloudBlobClient(new Uri(context.Address), account.Credentials);
CloudBlobContainer container = client.GetContainerReference(containerName);
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
BlobTestBase.UploadText(blob, "Text sent to cloud", Encoding.UTF8);
// acquire a release on the blob and check LeaseStatus to be "locked"
OperationContext opContext = new OperationContext();
HttpRequestMessage blobRequest = BlobHttpRequestMessageFactory.Lease(
blob.Uri,
context.Timeout,
LeaseAction.Acquire,
null /* proposed lease ID */,
60 /* lease duration */,
null /* break period */,
null /* access condition */,
null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
string leaseId = null;
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(blobRequest, context))
{
leaseId = HttpResponseParsers.GetHeader(response, "x-ms-lease-id");
Assert.AreEqual <HttpStatusCode>(response.StatusCode, HttpStatusCode.Created);
}
blob.FetchAttributes();
Assert.AreEqual <LeaseStatus>(blob.Properties.LeaseStatus, LeaseStatus.Locked);
// release the release on the blob and check LeaseStatus to be "unlocked"
opContext = new OperationContext();
blobRequest = BlobHttpRequestMessageFactory.Lease(
blob.Uri,
context.Timeout,
LeaseAction.Release,
null /* proposed lease ID */,
null /* lease duration */,
null /* break period */,
AccessCondition.GenerateLeaseCondition(leaseId),
null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(blobRequest, context))
{
Assert.AreEqual <HttpStatusCode>(response.StatusCode, HttpStatusCode.OK);
}
blob.FetchAttributes();
Assert.AreEqual <LeaseStatus>(blob.Properties.LeaseStatus, LeaseStatus.Unlocked);
blob.Delete();
}
/// <summary>
/// Constructs a web request to return the user-defined metadata for the blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage GetMetadata(Uri uri, int?timeout, DateTimeOffset?snapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
HttpRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, builder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to return the blob's system properties.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static StorageRequestMessage GetProperties(Uri uri, int?timeout, DateTimeOffset?snapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
UriQueryBuilder builder = new UriQueryBuilder();
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
StorageRequestMessage request = HttpRequestMessageFactory.GetProperties(uri, timeout, builder, content, operationContext, canonicalizer, credentials);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to return the list of blocks for a block blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="typesOfBlocks">The types of blocks to include in the list: committed, uncommitted, or both.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage GetBlockList(Uri uri, int?timeout, DateTimeOffset?snapshot, BlockListingFilter typesOfBlocks, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
builder.Add("blocklisttype", typesOfBlocks.ToString());
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Generates and validates a request to break a lease.
/// </summary>
/// <param name="context">The blob context.</param>
/// <param name="containerName">The container name.</param>
/// <param name="blobName">The blob name.</param>
/// <param name="breakPeriod">The break period.</param>
/// <returns>A web request for the operation.</returns>
public static HttpRequestMessage BreakLeaseRequest(BlobContext context, string containerName, string blobName, int?breakPeriod, AccessCondition accessCondition)
{
HttpRequestMessage request;
OperationContext opContext = new OperationContext();
if (blobName != null)
{
// blob lease
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
request = BlobHttpRequestMessageFactory.Lease(
uri,
context.Timeout,
LeaseAction.Break,
null /* proposed lease ID */,
null /* lease duration */,
breakPeriod,
accessCondition,
null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
}
else
{
// container lease
Uri uri = BlobClientTests.ConstructUri(context.Address, containerName);
request = ContainerHttpRequestMessageFactory.Lease(
uri,
context.Timeout,
LeaseAction.Break,
null /* proposed lease ID */,
null /* lease duration */,
breakPeriod,
accessCondition,
null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
}
Assert.IsNotNull(request);
Assert.AreEqual(HttpMethod.Put, request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.LeaseIdHeader(request, null);
BlobTestUtils.LeaseActionHeader(request, "break");
BlobTestUtils.LeaseDurationHeader(request, null);
BlobTestUtils.ProposedLeaseIdHeader(request, null);
BlobTestUtils.BreakPeriodHeader(request, breakPeriod.HasValue ? breakPeriod.Value.ToString() : null);
return(request);
}
public static HttpRequestMessage PutBlockListRequest(BlobContext context, string containerName, string blobName, BlobProperties blobProperties, AccessCondition accessCondition)
{
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
HttpRequestMessage request = null;
OperationContext opContext = new OperationContext();
request = BlobHttpRequestMessageFactory.PutBlockList(uri, context.Timeout, blobProperties, accessCondition, null, opContext, SharedKeyCanonicalizer.Instance, context.Credentials);
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Put, request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.ContentLanguageHeader(request, null);
BlobTestUtils.ContentMd5Header(request, null);
return(request);
}
/// <summary>
/// Generates a web request to use to acquire, renew, change, release or break the lease for the container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval, in seconds.</param>
/// <param name="action">The lease action to perform.</param>
/// <param name="proposedLeaseId">A lease ID to propose for the result of an acquire or change operation,
/// or null if no ID is proposed for an acquire operation. This should be null for renew, release, and break operations.</param>
/// <param name="leaseDuration">The lease duration, in seconds, for acquire operations.
/// If this is -1 then an infinite duration is specified. This should be null for renew, change, release, and break operations.</param>
/// <param name="leaseBreakPeriod">The amount of time to wait, in seconds, after a break operation before the lease is broken.
/// If this is null then the default time is used. This should be null for acquire, renew, change, and release operations.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage Lease(Uri uri, int? timeout, LeaseAction action, string proposedLeaseId, int? leaseDuration, int? leaseBreakPeriod, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
UriQueryBuilder builder = GetContainerUriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "lease");
StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials);
// Add Headers
BlobHttpRequestMessageFactory.AddLeaseAction(request, action);
BlobHttpRequestMessageFactory.AddLeaseDuration(request, leaseDuration);
BlobHttpRequestMessageFactory.AddProposedLeaseId(request, proposedLeaseId);
BlobHttpRequestMessageFactory.AddLeaseBreakPeriod(request, leaseBreakPeriod);
request.ApplyAccessCondition(accessCondition);
return request;
}
public static HttpRequestMessage GetBlockListRequest(BlobContext context, string containerName, string blobName, BlockListingFilter typesOfBlocks, AccessCondition accessCondition)
{
Uri uri = BlobClientTests.ConstructUri(context.Address, containerName, blobName);
OperationContext opContext = new OperationContext();
HttpRequestMessage request = BlobHttpRequestMessageFactory.GetBlockList(uri, context.Timeout, null /* snapshot */, typesOfBlocks, accessCondition, null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Get, request.Method);
BlobTestUtils.RangeHeader(request, null);
BlobTestUtils.LeaseIdHeader(request, null);
return(request);
}
public static HttpRequestMessage PutBlobRequest(BlobContext context, string containerName, string blobName,
BlobProperties properties, BlobType blobType, byte[] content, long pageBlobSize, AccessCondition accessCondition)
{
bool valid = BlobTests.ContainerNameValidator(containerName) &&
BlobTests.BlobNameValidator(blobName) &&
BlobTests.PutPropertiesValidator(properties) &&
BlobTestUtils.ContentValidator(content);
bool fatal = !BlobTests.PutPropertiesValidator(properties);
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
HttpRequestMessage request = null;
OperationContext opContext = new OperationContext();
try
{
request = BlobHttpRequestMessageFactory.Put(uri, context.Timeout, properties, blobType, pageBlobSize, null, accessCondition, null, opContext, SharedKeyCanonicalizer.Instance, context.Credentials);
if (fatal)
{
Assert.Fail();
}
}
catch (InvalidOperationException)
{
if (valid)
{
Assert.Fail();
}
}
if (valid)
{
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Put, request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.ContentTypeHeader(request, null);
BlobTestUtils.ContentDispositionHeader(request, properties.ContentDisposition);
BlobTestUtils.ContentEncodingHeader(request, properties.ContentEncoding);
BlobTestUtils.ContentLanguageHeader(request, null);
BlobTestUtils.ContentMd5Header(request, null);
BlobTestUtils.CacheControlHeader(request, null);
BlobTestUtils.BlobTypeHeader(request, properties.BlobType);
BlobTestUtils.BlobSizeHeader(request, (properties.BlobType == BlobType.PageBlob) ? properties.Length : (long?)null);
}
return(request);
}
/// <summary>
/// Generates a web request to use to acquire, renew, change, release or break the lease for the blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval, in seconds.</param>
/// <param name="action">The lease action to perform.</param>
/// <param name="proposedLeaseId">A lease ID to propose for the result of an acquire or change operation,
/// or null if no ID is proposed for an acquire operation. This should be null for renew, release, and break operations.</param>
/// <param name="leaseDuration">The lease duration, in seconds, for acquire operations.
/// If this is -1 then an infinite duration is specified. This should be null for renew, change, release, and break operations.</param>
/// <param name="leaseBreakPeriod">The amount of time to wait, in seconds, after a break operation before the lease is broken.
/// If this is null then the default time is used. This should be null for acquire, renew, change, and release operations.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Lease(Uri uri, int?timeout, LeaseAction action, string proposedLeaseId, int?leaseDuration, int?leaseBreakPeriod, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "lease");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
// Add lease headers
BlobHttpRequestMessageFactory.AddLeaseAction(request, action);
BlobHttpRequestMessageFactory.AddLeaseDuration(request, leaseDuration);
BlobHttpRequestMessageFactory.AddProposedLeaseId(request, proposedLeaseId);
BlobHttpRequestMessageFactory.AddLeaseBreakPeriod(request, leaseBreakPeriod);
return(request);
}
/// <summary>
/// Constructs a web request to return the list of valid page ranges for a page blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="offset">The starting offset of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param>
/// <param name="count">The length of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage GetPageRanges(Uri uri, int?timeout, DateTimeOffset?snapshot, long?offset, long?count, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
if (offset.HasValue)
{
CommonUtility.AssertNotNull("count", count);
}
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "pagelist");
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext);
AddRange(request, offset, count);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to return the list of page ranges that differ between a specified snapshot and this object.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="previousSnapshotTime">A <see cref="DateTimeOffset"/> representing the snapshot timestamp to use as the starting point for the diff. If this CloudPageBlob represents a snapshot, the previousSnapshotTime parameter must be prior to the current snapshot timestamp.</param>
/// <param name="offset">The starting offset of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param>
/// <param name="count">The length of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage GetPageRangesDiff(Uri uri, int?timeout, DateTimeOffset?snapshot, DateTimeOffset previousSnapshotTime, long?offset, long?count, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
if (offset.HasValue)
{
CommonUtility.AssertNotNull("count", count);
}
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "pagelist");
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
builder.Add("prevsnapshot", Request.ConvertDateTimeToSnapshotString(previousSnapshotTime));
StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials);
AddRange(request, offset, count);
request.ApplyAccessCondition(accessCondition);
return(request);
}
public async Task ClearPageRangeScenarioTest(string containerName, string blobName, HttpStatusCode?expectedError)
{
// 1. Create Sparse Page Blob
int blobSize = 128 * 1024;
BlobProperties properties = new BlobProperties()
{
BlobType = BlobType.PageBlob
};
Uri uri = BlobTests.ConstructPutUri(BlobContext.Address, containerName, blobName);
OperationContext opContext = new OperationContext();
HttpRequestMessage webRequest = BlobHttpRequestMessageFactory.Put(uri, BlobContext.Timeout, properties, BlobType.PageBlob, blobSize, null, null, null, opContext, null, null);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(webRequest, BlobContext))
{
BlobTests.PutBlobResponse(response, BlobContext, expectedError);
}
// 2. Now upload some page ranges
for (int m = 0; m * 512 * 4 < blobSize; m++)
{
int startOffset = 512 * 4 * m;
int length = 512;
PageRange range = new PageRange(startOffset, startOffset + length - 1);
opContext = new OperationContext();
HttpRequestMessage pageRequest = BlobHttpRequestMessageFactory.PutPage(uri, BlobContext.Timeout, range, PageWrite.Update, null, null, opContext, null, null);
HttpRequestHandler.SetContentLength(pageRequest, 512);
byte[] content = new byte[length];
random.NextBytes(content);
pageRequest.Content = new ByteArrayContent(content);
using (HttpResponseMessage pageResponse = await BlobTestUtils.GetResponse(pageRequest, BlobContext))
{
}
}
// 3. Now do a Get Page Ranges
List <PageRange> pageRanges = new List <PageRange>();
opContext = new OperationContext();
HttpRequestMessage pageRangeRequest = BlobHttpRequestMessageFactory.GetPageRanges(uri, BlobContext.Timeout, null, null, null, null, null, opContext, null, null);
using (HttpResponseMessage pageRangeResponse = await BlobTestUtils.GetResponse(pageRangeRequest, BlobContext))
{
var ranges = await GetPageRangesResponse.ParseAsync(HttpResponseParsers.GetResponseStream(pageRangeResponse), CancellationToken.None);
pageRanges.AddRange(ranges);
}
// 4. Now Clear some pages
bool skipFlag = false;
foreach (PageRange pRange in pageRanges)
{
skipFlag = !skipFlag;
if (skipFlag)
{
continue;
}
opContext = new OperationContext();
HttpRequestMessage clearPageRequest = BlobHttpRequestMessageFactory.PutPage(uri, BlobContext.Timeout, pRange, PageWrite.Clear, null, null, opContext, null, null);
HttpRequestHandler.SetContentLength(clearPageRequest, 0);
using (HttpResponseMessage clearResponse = await BlobTestUtils.GetResponse(clearPageRequest, BlobContext))
{
}
}
// 5. Get New Page ranges and verify
List <PageRange> newPageRanges = new List <PageRange>();
opContext = new OperationContext();
HttpRequestMessage newPageRangeRequest = BlobHttpRequestMessageFactory.GetPageRanges(uri, BlobContext.Timeout, null, null, null, null, null, opContext, null, null);
using (HttpResponseMessage newPageRangeResponse = await BlobTestUtils.GetResponse(newPageRangeRequest, BlobContext))
{
var ranges = await GetPageRangesResponse.ParseAsync(HttpResponseParsers.GetResponseStream(newPageRangeResponse), CancellationToken.None);
newPageRanges.AddRange(ranges);
}
Assert.AreEqual(pageRanges.Count(), newPageRanges.Count() * 2);
for (int l = 0; l < newPageRanges.Count(); l++)
{
Assert.AreEqual(pageRanges[2 * l].StartOffset, newPageRanges[l].StartOffset);
Assert.AreEqual(pageRanges[2 * l].EndOffset, newPageRanges[l].EndOffset);
}
}
