private RESTCommand <NullType> SetServicePropertiesImpl(ServiceProperties properties, BlobRequestOptions requestOptions)
{
MemoryStream memoryStream = new MemoryStream();
try
{
properties.WriteServiceProperties(memoryStream);
}
catch (InvalidOperationException invalidOpException)
{
throw new ArgumentException(invalidOpException.Message, "properties");
}
RESTCommand <NullType> retCmd = new RESTCommand <NullType>(this.Credentials, this.BaseUri);
retCmd.ApplyRequestOptions(requestOptions);
retCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.SetServiceProperties(cmd.Uri, cmd.ServerTimeoutInSeconds, cnt, ctx);
retCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null /* md5 */, cmd, ctx);
retCmd.RetrieveResponseStream = true;
retCmd.Handler = this.AuthenticationHandler;
retCmd.BuildClient = HttpClientFactory.BuildHttpClient;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(System.Net.HttpStatusCode.Accepted, resp, null /* retVal */, cmd, ex, ctx);
retCmd.ApplyRequestOptions(requestOptions);
return(retCmd);
}
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <T, RESULT_TYPE>(TableQuery <T> query, TableContinuationToken token, CloudTableClient client, string tableName, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions) where T : ITableEntity, new()
{
Uri tempUri = NavigationHelper.AppendPathToUri(client.BaseUri, tableName);
UriQueryBuilder builder = query.GenerateQueryBuilder();
if (token != null)
{
token.ApplyToUriQueryBuilder(builder);
}
Uri reqUri = builder.AddToUri(tempUri);
RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, reqUri);
queryCmd.ApplyRequestOptions(requestOptions);
queryCmd.RetrieveResponseStream = true;
queryCmd.Handler = client.AuthenticationHandler;
queryCmd.BuildClient = HttpClientFactory.BuildHttpClient;
queryCmd.BuildRequest = (cmd, cnt, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableQuery(cmd.Uri, cmd.ServerTimeoutInSeconds, ctx);
queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp.StatusCode, null /* retVal */, cmd, ex);
queryCmd.PostProcessResponse = async(cmd, resp, ctx) =>
{
ResultSegment <RESULT_TYPE> resSeg = await TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE>(cmd.ResponseStream, resolver.Invoke, resp, ctx);
return(new TableQuerySegment <RESULT_TYPE>(resSeg));
};
return(queryCmd);
}
private static RESTCommand <TableResult> RetrieveImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand <TableResult> retrieveCmd = new RESTCommand <TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
retrieveCmd.ApplyRequestOptions(requestOptions);
TableResult result = new TableResult();
retrieveCmd.RetrieveResponseStream = true;
retrieveCmd.SignRequest = client.AuthenticationHandler.SignRequest;
retrieveCmd.BuildRequestDelegate = (uri, builder, timeout, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, ctx).Item1;
retrieveCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd);
retrieveCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
if (resp.StatusCode == HttpStatusCode.NotFound)
{
return(result);
}
result = TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx);
return(result);
};
return(retrieveCmd);
}
/// <summary>
/// Implements the FetchAttributes method. The attributes are updated immediately.
/// </summary>
/// <param name="blobUri">The URI of the blob.</param>
/// <param name="accessCondition">An 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 fetches the attributes.</returns>
private RESTCommand <ICloudBlob> GetBlobReferenceImpl(Uri blobUri, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand <ICloudBlob> getCmd = new RESTCommand <ICloudBlob>(this.Credentials, blobUri);
getCmd.ApplyRequestOptions(options);
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.GetProperties(uri, serverTimeout, null /* snapshot */, accessCondition, ctx);
getCmd.SignRequest = this.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
BlobAttributes attributes = new BlobAttributes();
attributes.Uri = blobUri;
CloudBlobSharedImpl.UpdateAfterFetchAttributes(attributes, resp, false);
switch (attributes.Properties.BlobType)
{
case BlobType.BlockBlob:
return(new CloudBlockBlob(attributes, this));
case BlobType.PageBlob:
return(new CloudPageBlob(attributes, this));
default:
throw new InvalidOperationException();
}
};
return(getCmd);
}
/// <summary>
/// Implementation of the StartCopyFromBlob method. Result is a BlobAttributes object derived from the response headers.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="source">The URI of the source blob.</param>
/// <param name="sourceAccessCondition">An object that represents the access conditions for the source blob. If null, no condition is used.</param>
/// <param name="destAccessCondition">An object that represents the access conditions for the destination blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> that starts to copy the blob.
/// </returns>
/// <exception cref="System.ArgumentException">sourceAccessCondition</exception>
internal static RESTCommand <string> StartCopyFromBlobImpl(ICloudBlob blob, BlobAttributes attributes, Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options)
{
if (sourceAccessCondition != null && !string.IsNullOrEmpty(sourceAccessCondition.LeaseId))
{
throw new ArgumentException(SR.LeaseConditionOnSource, "sourceAccessCondition");
}
RESTCommand <string> putCmd = new RESTCommand <string>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.CopyFrom(uri, serverTimeout, source, sourceAccessCondition, destAccessCondition, ctx);
putCmd.SetHeaders = (r, ctx) => BlobHttpWebRequestFactory.AddMetadata(r, attributes.Metadata);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, null /* retVal */, cmd, ex, ctx);
CopyState state = BlobHttpResponseParsers.GetCopyAttributes(resp);
attributes.Properties = BlobHttpResponseParsers.GetProperties(resp);
attributes.Metadata = BlobHttpResponseParsers.GetMetadata(resp);
attributes.CopyState = state;
return(state.CopyId);
};
return(putCmd);
}
private RESTCommand <NullType> SetServicePropertiesImpl(ServiceProperties properties, BlobRequestOptions requestOptions)
{
MemoryStream str = new MemoryStream();
try
{
properties.WriteServiceProperties(str);
}
catch (InvalidOperationException invalidOpException)
{
throw new ArgumentException(invalidOpException.Message, "properties");
}
str.Seek(0, SeekOrigin.Begin);
RESTCommand <NullType> retCmd = new RESTCommand <NullType>(this.Credentials, this.BaseUri);
retCmd.SendStream = str;
retCmd.BuildRequestDelegate = BlobHttpWebRequestFactory.SetServiceProperties;
retCmd.RecoveryAction = RecoveryActions.RewindStream;
retCmd.SignRequest = this.AuthenticationHandler.SignRequest;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(System.Net.HttpStatusCode.Accepted, resp, NullType.Value, cmd, ex, ctx);
retCmd.ApplyRequestOptions(requestOptions);
return(retCmd);
}
private static RESTCommand <TableResult> RetrieveImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand <TableResult> retrieveCmd = new RESTCommand <TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
retrieveCmd.ApplyRequestOptions(requestOptions);
TableResult result = new TableResult();
retrieveCmd.RetrieveResponseStream = true;
retrieveCmd.Handler = client.AuthenticationHandler;
retrieveCmd.BuildClient = HttpClientFactory.BuildHttpClient;
retrieveCmd.BuildRequest = (cmd, cnt, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd, cmd.ServerTimeoutInSeconds, operation, client, ctx);
retrieveCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
retrieveCmd.PostProcessResponse = (cmd, resp, ctx) =>
Task.Run(async() =>
{
if (resp.StatusCode == HttpStatusCode.NotFound)
{
return(result);
}
result = await TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx);
return(result);
});
return(retrieveCmd);
}
private static RESTCommand <TableResult> InsertImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand <TableResult> insertCmd = new RESTCommand <TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
insertCmd.ApplyRequestOptions(requestOptions);
TableResult result = new TableResult()
{
Result = operation.Entity
};
insertCmd.RetrieveResponseStream = true;
insertCmd.SignRequest = client.AuthenticationHandler.SignRequest;
insertCmd.BuildRequestDelegate = (uri, builder, timeout, ctx) =>
{
Tuple <HttpWebRequest, Stream> res = TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, ctx);
insertCmd.SendStream = res.Item2;
return(res.Item1);
};
insertCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd);
insertCmd.PostProcessResponse = (cmd, resp, ctx) => TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx);
return(insertCmd);
}
/// <summary>
/// Implements the Exists method. The attributes are updated immediately.
/// </summary>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that checks existence.</returns>
internal static RESTCommand <bool> ExistsImpl(ICloudBlob blob, BlobAttributes attributes, BlobRequestOptions options)
{
RESTCommand <bool> getCmd = new RESTCommand <bool>(blob.ServiceClient.Credentials, attributes.Uri);
getCmd.ApplyRequestOptions(options);
getCmd.Handler = blob.ServiceClient.AuthenticationHandler;
getCmd.BuildClient = HttpClientFactory.BuildHttpClient;
getCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.GetProperties(cmd.Uri, cmd.ServerTimeoutInSeconds, attributes.SnapshotTime, null /* accessCondition */, cnt, ctx);
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
if (resp.StatusCode == HttpStatusCode.NotFound)
{
return(false);
}
if (resp.StatusCode == HttpStatusCode.PreconditionFailed)
{
return(true);
}
return(HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, true, cmd, ex, ctx));
};
return(getCmd);
}
/// <summary>
/// Generates a <see cref="RESTCommand{T}" /> for breaking a lease.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="breakPeriod">The amount of time to allow the lease to remain, rounded down to seconds.
/// If null, the break period is the remainder of the current lease, or zero for infinite leases.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> implementing the break lease operation.
/// </returns>
internal static RESTCommand <TimeSpan> BreakLeaseImpl(ICloudBlob blob, BlobAttributes attributes, TimeSpan?breakPeriod, AccessCondition accessCondition, BlobRequestOptions options)
{
int?breakSeconds = null;
if (breakPeriod.HasValue)
{
CommonUtils.AssertInBounds("breakPeriod", breakPeriod.Value, TimeSpan.FromSeconds(0), TimeSpan.MaxValue);
breakSeconds = (int)breakPeriod.Value.TotalSeconds;
}
RESTCommand <TimeSpan> putCmd = new RESTCommand <TimeSpan>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Lease(uri, serverTimeout, LeaseAction.Break, null /* proposedLeaseId */, null /* leaseDuration */, breakSeconds, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, TimeSpan.Zero, cmd, ex, ctx);
int?remainingLeaseTime = BlobHttpResponseParsers.GetRemainingLeaseTime(resp);
if (!remainingLeaseTime.HasValue)
{
// Unexpected result from service.
throw new StorageException(cmd.CurrentResult, SR.LeaseTimeNotReceived, null /* inner */);
}
return(TimeSpan.FromSeconds(remainingLeaseTime.Value));
};
return(putCmd);
}
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <RESULT_TYPE>(TableQuery query, TableContinuationToken token, CloudTableClient client, string tableName, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions)
{
Uri tempUri = NavigationHelper.AppendPathToUri(client.BaseUri, tableName);
UriQueryBuilder builder = query.GenerateQueryBuilder();
if (token != null)
{
token.ApplyToUriQueryBuilder(builder);
}
Uri reqUri = builder.AddToUri(tempUri);
RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, reqUri);
queryCmd.ApplyRequestOptions(requestOptions);
queryCmd.RetrieveResponseStream = true;
queryCmd.SignRequest = client.AuthenticationHandler.SignRequest;
queryCmd.BuildRequestDelegate = TableOperationHttpWebRequestFactory.BuildRequestForTableQuery;
queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp != null ? resp.StatusCode : HttpStatusCode.Unused, null /* retVal */, cmd, ex);
queryCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
ResultSegment <RESULT_TYPE> resSeg = TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE>(cmd.ResponseStream, resolver.Invoke, resp);
return(new TableQuerySegment <RESULT_TYPE>(resSeg));
};
return(queryCmd);
}
/// <summary>
/// Implements the DeleteBlob method.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="deleteSnapshotsOption">Whether to only delete the blob, to delete the blob and all snapshots, or to only delete the snapshots.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> that deletes the blob.
/// </returns>
internal static RESTCommand <NullType> DeleteBlobImpl(ICloudBlob blob, BlobAttributes attributes, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand <NullType> deleteCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.Uri);
deleteCmd.ApplyRequestOptions(options);
deleteCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Delete(uri, serverTimeout, attributes.SnapshotTime, deleteSnapshotsOption, accessCondition, ctx);
deleteCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
deleteCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, NullType.Value, cmd, ex, ctx);
return(deleteCmd);
}
/// <summary>
/// Create an ExecutionState object that can be used for pre-request operations
/// such as buffering user's data.
/// </summary>
/// <param name="options">Request options</param>
/// <returns>Temporary ExecutionState object</returns>
internal static ExecutionState <NullType> CreateTemporaryExecutionState(BlobRequestOptions options)
{
RESTCommand <NullType> cmdWithTimeout = new RESTCommand <NullType>(new StorageCredentials(), null /* Uri */);
if (options != null)
{
cmdWithTimeout.ApplyRequestOptions(options);
}
return(new ExecutionState <NullType>(cmdWithTimeout, options.RetryPolicy, new OperationContext()));
}
/// <summary>
/// Implementation of the AbortCopy method. No result is produced.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="copyId">The copy ID of the copy operation to abort.</param>
/// <param name="accessCondition">An object that represents the access conditions for the operation. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> that aborts the copy.
/// </returns>
internal static RESTCommand <NullType> AbortCopyImpl(ICloudBlob blob, BlobAttributes attributes, string copyId, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtils.AssertNotNull("copyId", copyId);
RESTCommand <NullType> putCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.AbortCopy(uri, serverTimeout, copyId, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(new HttpStatusCode[] { HttpStatusCode.OK, HttpStatusCode.NoContent }, resp, NullType.Value, cmd, ex, ctx);
return(putCmd);
}
private RESTCommand <ServiceProperties> GetServicePropertiesImpl(TableRequestOptions requestOptions)
{
RESTCommand <ServiceProperties> retCmd = new RESTCommand <ServiceProperties>(this.Credentials, this.BaseUri);
retCmd.BuildRequestDelegate = TableHttpWebRequestFactory.GetServiceProperties;
retCmd.SignRequest = this.AuthenticationHandler.SignRequest;
retCmd.RetrieveResponseStream = true;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(System.Net.HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
retCmd.PostProcessResponse = (cmd, resp, ex, ctx) => TableHttpWebResponseParsers.ReadServiceProperties(cmd.ResponseStream);
retCmd.ApplyRequestOptions(requestOptions);
return(retCmd);
}
/// <summary>
/// Implementation of the AbortCopy method. No result is produced.
/// </summary>
/// <param name="copyId">The copy ID of the copy operation to abort.</param>
/// <param name="accessCondition">An object that represents the access conditions for the operation. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="TaskSequence"/> that copies the blob.</returns>
internal static RESTCommand <NullType> AbortCopyImpl(ICloudBlob blob, BlobAttributes attributes, string copyId, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtils.AssertNotNull("copyId", copyId);
RESTCommand <NullType> putCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = blob.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.AbortCopy(cmd.Uri, cmd.ServerTimeoutInSeconds, copyId, accessCondition, cnt, ctx);
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, NullType.Value, cmd, ex, ctx);
return(putCmd);
}
/// <summary>
/// Implements the FetchAttributes method. The attributes are updated immediately.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> that fetches the attributes.
/// </returns>
internal static RESTCommand <NullType> FetchAttributesImpl(ICloudBlob blob, BlobAttributes attributes, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand <NullType> getCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.Uri);
getCmd.ApplyRequestOptions(options);
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.GetProperties(uri, serverTimeout, attributes.SnapshotTime, accessCondition, ctx);
getCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.UpdateAfterFetchAttributes(attributes, resp, false);
return(NullType.Value);
};
return(getCmd);
}
/// <summary>
/// Implementation for the SetProperties method.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> that sets the properties.
/// </returns>
internal static RESTCommand <NullType> SetPropertiesImpl(ICloudBlob blob, BlobAttributes attributes, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand <NullType> putCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.SetProperties(uri, serverTimeout, attributes.Properties, accessCondition, ctx);
putCmd.SetHeaders = (r, ctx) => BlobHttpWebRequestFactory.AddMetadata(r, attributes.Metadata);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(attributes, resp);
return(NullType.Value);
};
return(putCmd);
}
/// <summary>
/// Generates a <see cref="RESTCommand{T}" /> for releasing a lease.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> implementing the release lease operation.
/// </returns>
/// <exception cref="System.ArgumentException">accessCondition</exception>
internal static RESTCommand <NullType> ReleaseLeaseImpl(ICloudBlob blob, BlobAttributes attributes, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtils.AssertNotNull("accessCondition", accessCondition);
if (accessCondition.LeaseId == null)
{
throw new ArgumentException(SR.MissingLeaseIDReleasing, "accessCondition");
}
RESTCommand <NullType> putCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Lease(uri, serverTimeout, LeaseAction.Release, null /* proposedLeaseId */, null /* leaseDuration */, null /* leaseBreakPeriod */, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, NullType.Value, cmd, ex, ctx);
return(putCmd);
}
private static RESTCommand <TableResult> DeleteImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand <TableResult> deleteCmd = new RESTCommand <TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
deleteCmd.ApplyRequestOptions(requestOptions);
TableResult result = new TableResult()
{
Result = operation.Entity
};
deleteCmd.RetrieveResponseStream = false;
deleteCmd.SignRequest = client.AuthenticationHandler.SignRequest;
deleteCmd.BuildRequestDelegate = (uri, builder, timeout, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, ctx).Item1;
deleteCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd);
return(deleteCmd);
}
private static RESTCommand <IList <TableResult> > BatchImpl(TableBatchOperation batch, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand <IList <TableResult> > batchCmd = new RESTCommand <IList <TableResult> >(client.Credentials, client.BaseUri);
batchCmd.ApplyRequestOptions(requestOptions);
List <TableResult> results = new List <TableResult>();
batchCmd.RetrieveResponseStream = true;
batchCmd.Handler = client.AuthenticationHandler;
batchCmd.BuildClient = HttpClientFactory.BuildHttpClient;
batchCmd.BuildRequest = (cmd, cnt, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableBatchOperation(cmd, cmd.ServerTimeoutInSeconds, client.BaseUri, tableName, batch, client, ctx);
batchCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp.StatusCode, results, cmd, ex);
batchCmd.PostProcessResponse = (cmd, resp, ctx) => TableOperationHttpResponseParsers.TableBatchOperationPostProcess(results, batch, cmd, resp, ctx);
batchCmd.RecoveryAction = (cmd, ex, ctx) => results.Clear();
return(batchCmd);
}
private static RESTCommand <TableResult> ReplaceImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand <TableResult> replaceCmd = new RESTCommand <TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
replaceCmd.ApplyRequestOptions(requestOptions);
TableResult result = new TableResult()
{
Result = operation.Entity
};
replaceCmd.RetrieveResponseStream = false;
replaceCmd.Handler = client.AuthenticationHandler;
replaceCmd.BuildClient = HttpClientFactory.BuildHttpClient;
replaceCmd.BuildRequest = (cmd, cnt, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd, cmd.ServerTimeoutInSeconds, operation, client, ctx);
replaceCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
return(replaceCmd);
}
/// <summary>
/// Implements the FetchAttributes method. The attributes are updated immediately.
/// </summary>
/// <param name="blobUri">The URI of the blob.</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"/> that fetches the attributes.</returns>
private RESTCommand <ICloudBlob> GetBlobReferenceImpl(Uri blobUri, AccessCondition accessCondition, BlobRequestOptions options)
{
// If the blob Uri contains SAS credentials, we need to use those
// credentials instead of this service client's stored credentials.
StorageCredentials parsedCredentials;
DateTimeOffset? parsedSnapshot;
blobUri = NavigationHelper.ParseBlobQueryAndVerify(blobUri, out parsedCredentials, out parsedSnapshot);
CloudBlobClient client = parsedCredentials != null ? new CloudBlobClient(this.BaseUri, parsedCredentials) : this;
RESTCommand <ICloudBlob> getCmd = new RESTCommand <ICloudBlob>(client.Credentials, blobUri);
getCmd.ApplyRequestOptions(options);
getCmd.Handler = client.AuthenticationHandler;
getCmd.BuildClient = HttpClientFactory.BuildHttpClient;
getCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.GetProperties(cmd.Uri, cmd.ServerTimeoutInSeconds, parsedSnapshot, accessCondition, cnt, ctx);
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
BlobAttributes attributes = new BlobAttributes()
{
Uri = blobUri,
SnapshotTime = parsedSnapshot,
};
CloudBlobSharedImpl.UpdateAfterFetchAttributes(attributes, resp, false);
switch (attributes.Properties.BlobType)
{
case BlobType.BlockBlob:
return(new CloudBlockBlob(attributes, client));
case BlobType.PageBlob:
return(new CloudPageBlob(attributes, client));
default:
throw new InvalidOperationException();
}
};
return(getCmd);
}
/// <summary>
/// Core implementation for the ListQueues method.
/// </summary>
/// <param name="prefix">The queue prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="currentToken">The continuation token.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the
/// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param>
/// <returns>A <see cref="TaskSequence"/> that lists the queues.</returns>
private RESTCommand <ResultSegment <CloudQueue> > ListQueuesImpl(string prefix, int?maxResults, QueueListingDetails detailsIncluded, QueueRequestOptions options, QueueContinuationToken currentToken)
{
ListingContext listingContext = new ListingContext(prefix, maxResults)
{
Marker = currentToken != null ? currentToken.NextMarker : null
};
RESTCommand <ResultSegment <CloudQueue> > getCmd = new RESTCommand <ResultSegment <CloudQueue> >(this.Credentials, this.BaseUri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.Handler = this.AuthenticationHandler;
getCmd.BuildClient = HttpClientFactory.BuildHttpClient;
getCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.List(cmd.Uri, cmd.ServerTimeoutInSeconds, listingContext, detailsIncluded, cnt, ctx);
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
getCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
return(Task.Factory.StartNew(() =>
{
ListQueuesResponse listQueuesResponse = new ListQueuesResponse(cmd.ResponseStream);
List <CloudQueue> queuesList = new List <CloudQueue>(
listQueuesResponse.Queues.Select(item => new CloudQueue(item.Name, this)));
QueueContinuationToken continuationToken = null;
if (listQueuesResponse.NextMarker != null)
{
continuationToken = new QueueContinuationToken()
{
NextMarker = listQueuesResponse.NextMarker,
};
}
return new ResultSegment <CloudQueue>(queuesList)
{
ContinuationToken = continuationToken,
};
}));
};
return(getCmd);
}
private RESTCommand <ServiceProperties> GetServicePropertiesImpl(QueueRequestOptions requestOptions)
{
RESTCommand <ServiceProperties> retCmd = new RESTCommand <ServiceProperties>(this.Credentials, this.BaseUri);
retCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.GetServiceProperties(cmd.Uri, cmd.ServerTimeoutInSeconds, ctx);
retCmd.RetrieveResponseStream = true;
retCmd.Handler = this.AuthenticationHandler;
retCmd.BuildClient = HttpClientFactory.BuildHttpClient;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(System.Net.HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
retCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
return(Task.Factory.StartNew(() => QueueHttpResponseParsers.ReadServiceProperties(cmd.ResponseStream)));
};
retCmd.ApplyRequestOptions(requestOptions);
return(retCmd);
}
/// <summary>
/// Implementation for the SetPermissions method.
/// </summary>
/// <param name="acl">The permissions to set.</param>
/// <param name="requestOptions">A <see cref="TableRequestOptions"/> object that specifies execution options, such as retry policy and timeout settings, for the operation.</param>
/// <returns>A <see cref="RESTCommand"/> that sets the permissions.</returns>
private RESTCommand <NullType> SetPermissionsImpl(TablePermissions acl, TableRequestOptions requestOptions)
{
MultiBufferMemoryStream memoryStream = new MultiBufferMemoryStream(null /* bufferManager */, (int)(1 * Constants.KB));
TableRequest.WriteSharedAccessIdentifiers(acl.SharedAccessPolicies, memoryStream);
RESTCommand <NullType> putCmd = new RESTCommand <NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(requestOptions);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) => TableHttpRequestMessageFactory.SetAcl(cmd.Uri, cmd.ServerTimeoutInSeconds, cnt, ctx);
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null /* md5 */, cmd, ctx);
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.NoContent, resp, NullType.Value, cmd, ex);
return(NullType.Value);
};
return(putCmd);
}
/// <summary>
/// Implementation for the SetProperties method.
/// </summary>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that sets the metadata.</returns>
internal static RESTCommand <NullType> SetPropertiesImpl(ICloudBlob blob, BlobAttributes attributes, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand <NullType> putCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = blob.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) =>
{
HttpRequestMessage msg = BlobHttpRequestMessageFactory.SetProperties(cmd.Uri, cmd.ServerTimeoutInSeconds, attributes.Properties, accessCondition, cnt, ctx);
BlobHttpRequestMessageFactory.AddMetadata(msg, attributes.Metadata);
return(msg);
};
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(attributes, resp);
return(NullType.Value);
};
return(putCmd);
}
/// <summary>
/// Implementation for the GetPermissions method.
/// </summary>
/// <param name="requestOptions">An object that specifies additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that gets the permissions.</returns>
private RESTCommand <TablePermissions> GetPermissionsImpl(TableRequestOptions requestOptions)
{
RESTCommand <TablePermissions> getCmd = new RESTCommand <TablePermissions>(this.ServiceClient.Credentials, this.Uri);
getCmd.ApplyRequestOptions(requestOptions);
getCmd.Handler = this.ServiceClient.AuthenticationHandler;
getCmd.BuildClient = HttpClientFactory.BuildHttpClient;
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequest = (cmd, cnt, ctx) => TableHttpRequestMessageFactory.GetAcl(cmd.Uri, cmd.ServerTimeoutInSeconds, cnt, ctx);
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
getCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
return(Task <TablePermissions> .Factory.StartNew(() =>
{
TablePermissions TableAcl = new TablePermissions();
HttpResponseParsers.ReadSharedAccessIdentifiers(TableAcl.SharedAccessPolicies, new TableAccessPolicyResponse(cmd.ResponseStream));
return TableAcl;
}));
};
return(getCmd);
}
/// <summary>
/// Core implementation of the ListQueues method.
/// </summary>
/// <param name="prefix">The queue name prefix.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the
/// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param>
/// <param name="queueListingDetails">A <see cref="QueueListingDetails"/> enumeration describing which items to include in the listing.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
/// <param name="currentToken">The continuation token.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that lists the queues.</returns>
private RESTCommand <ResultSegment <CloudQueue> > ListQueuesImpl(string prefix, int?maxResults, QueueListingDetails queueListingDetails, QueueRequestOptions options, QueueContinuationToken currentToken)
{
QueueListingContext listingContext = new QueueListingContext(prefix, maxResults, queueListingDetails)
{
Marker = currentToken != null ? currentToken.NextMarker : null
};
RESTCommand <ResultSegment <CloudQueue> > getCmd = new RESTCommand <ResultSegment <CloudQueue> >(this.Credentials, this.BaseUri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.List(uri, serverTimeout, listingContext, queueListingDetails, ctx);
getCmd.SignRequest = this.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
getCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
ListQueuesResponse listQueuesResponse = new ListQueuesResponse(cmd.ResponseStream);
List <CloudQueue> queuesList = new List <CloudQueue>(
listQueuesResponse.Queues.Select(item => new CloudQueue(item.Name, this)));
QueueContinuationToken continuationToken = null;
if (listQueuesResponse.NextMarker != null)
{
continuationToken = new QueueContinuationToken()
{
NextMarker = listQueuesResponse.NextMarker,
};
}
return(new ResultSegment <CloudQueue>(queuesList)
{
ContinuationToken = continuationToken,
});
};
return(getCmd);
}
/// <summary>
/// Generates a <see cref="RESTCommand{T}" /> for acquiring a lease.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="leaseTime">A <see cref="TimeSpan" /> representing the span of time for which to acquire the lease,
/// which will be rounded down to seconds. If null, an infinite lease will be acquired. If not null, this must be
/// greater than zero.</param>
/// <param name="proposedLeaseId">A string representing the proposed lease ID for the new lease, or null if no lease ID is proposed.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> implementing the acquire lease operation.
/// </returns>
internal static RESTCommand <string> AcquireLeaseImpl(ICloudBlob blob, BlobAttributes attributes, TimeSpan?leaseTime, string proposedLeaseId, AccessCondition accessCondition, BlobRequestOptions options)
{
int leaseDuration = -1;
if (leaseTime.HasValue)
{
CommonUtils.AssertInBounds("leaseTime", leaseTime.Value, TimeSpan.FromSeconds(1), TimeSpan.MaxValue);
leaseDuration = (int)leaseTime.Value.TotalSeconds;
}
RESTCommand <string> putCmd = new RESTCommand <string>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Lease(uri, serverTimeout, LeaseAction.Acquire, proposedLeaseId, leaseDuration, null /* leaseBreakPeriod */, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, null, cmd, ex, ctx);
return(BlobHttpResponseParsers.GetLeaseId(resp));
};
return(putCmd);
}
private RESTCommand<NullType> SetServicePropertiesImpl(ServiceProperties properties, BlobRequestOptions requestOptions)
{
MemoryStream memoryStream = new MemoryStream();
try
{
properties.WriteServiceProperties(memoryStream);
}
catch (InvalidOperationException invalidOpException)
{
throw new ArgumentException(invalidOpException.Message, "properties");
}
RESTCommand<NullType> retCmd = new RESTCommand<NullType>(this.Credentials, this.BaseUri);
retCmd.ApplyRequestOptions(requestOptions);
retCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.SetServiceProperties(cmd.Uri, cmd.ServerTimeoutInSeconds, cnt, ctx);
retCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null /* md5 */, cmd, ctx);
retCmd.RetrieveResponseStream = true;
retCmd.Handler = this.AuthenticationHandler;
retCmd.BuildClient = HttpClientFactory.BuildHttpClient;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(System.Net.HttpStatusCode.Accepted, resp, null /* retVal */, cmd, ex, ctx);
retCmd.ApplyRequestOptions(requestOptions);
return retCmd;
}
private RESTCommand<ServiceProperties> GetServicePropertiesImpl(BlobRequestOptions requestOptions)
{
RESTCommand<ServiceProperties> retCmd = new RESTCommand<ServiceProperties>(this.Credentials, this.BaseUri);
retCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.GetServiceProperties(cmd.Uri, cmd.ServerTimeoutInSeconds, ctx);
retCmd.RetrieveResponseStream = true;
retCmd.Handler = this.AuthenticationHandler;
retCmd.BuildClient = HttpClientFactory.BuildHttpClient;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(System.Net.HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
retCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
return Task.Factory.StartNew(() => BlobHttpResponseParsers.ReadServiceProperties(cmd.ResponseStream));
};
retCmd.ApplyRequestOptions(requestOptions);
return retCmd;
}
/// <summary>
/// Core implementation for the ListContainers method.
/// </summary>
/// <param name="prefix">The container prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="currentToken">The continuation token.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned
/// in the result segment, up to the per-operation limit of 5000. If this value is null, the maximum possible number of results will be returned, up to 5000.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies any additional options for the request.</param>
/// <returns>A <see cref="ResultSegment{T}"/> that lists the containers.</returns>
private RESTCommand<ResultSegment<CloudBlobContainer>> ListContainersImpl(string prefix, ContainerListingDetails detailsIncluded, BlobContinuationToken currentToken, int? maxResults, BlobRequestOptions options)
{
ListingContext listingContext = new ListingContext(prefix, maxResults)
{
Marker = currentToken != null ? currentToken.NextMarker : null
};
RESTCommand<ResultSegment<CloudBlobContainer>> getCmd = new RESTCommand<ResultSegment<CloudBlobContainer>>(this.Credentials, this.BaseUri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => ContainerHttpWebRequestFactory.List(uri, serverTimeout, listingContext, detailsIncluded, ctx);
getCmd.SignRequest = this.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
getCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
ListContainersResponse listContainersResponse = new ListContainersResponse(cmd.ResponseStream);
List<CloudBlobContainer> containersList = new List<CloudBlobContainer>(
listContainersResponse.Containers.Select(item => new CloudBlobContainer(item.Properties, item.Metadata, item.Name, this)));
BlobContinuationToken continuationToken = null;
if (listContainersResponse.NextMarker != null)
{
continuationToken = new BlobContinuationToken()
{
NextMarker = listContainersResponse.NextMarker,
};
}
return new ResultSegment<CloudBlobContainer>(containersList)
{
ContinuationToken = continuationToken,
};
};
return getCmd;
}
/// <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;
}
/// <summary>
/// Gets the download block list.
/// </summary>
/// <param name="typesOfBlocks">The types of blocks.</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 gets the download block list.</returns>
internal RESTCommand<IEnumerable<ListBlockItem>> GetBlockListImpl(BlockListingFilter typesOfBlocks, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<IEnumerable<ListBlockItem>> getCmd = new RESTCommand<IEnumerable<ListBlockItem>>(this.ServiceClient.Credentials, this.Uri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.GetBlockList(uri, serverTimeout, this.SnapshotTime, typesOfBlocks, accessCondition, ctx);
getCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
getCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
CloudBlobSharedImpl.UpdateETagLMTAndSequenceNumber(this.attributes, resp);
GetBlockListResponse responseParser = new GetBlockListResponse(cmd.ResponseStream);
IEnumerable<ListBlockItem> blocks = new List<ListBlockItem>(responseParser.Blocks);
return blocks;
};
return getCmd;
}
/// <summary>
/// Uploads the block.
/// </summary>
/// <param name="source">The source stream.</param>
/// <param name="blockId">The block ID.</param>
/// <param name="contentMD5">The content MD5.</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 uploads the block.</returns>
internal RESTCommand<NullType> PutBlockImpl(Stream source, string blockId, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options)
{
long offset = source.Position;
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.SendStream = source;
putCmd.RecoveryAction = (cmd, ex, ctx) => RecoveryActions.SeekStream(cmd, offset);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.PutBlock(uri, serverTimeout, blockId, accessCondition, ctx);
putCmd.SetHeaders = (r, ctx) =>
{
if (!string.IsNullOrEmpty(contentMD5))
{
r.Headers[HttpRequestHeader.ContentMd5] = contentMD5;
}
};
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex);
return putCmd;
}
/// <summary>
/// Implements the Create method.
/// </summary>
/// <param name="sizeInBytes">The size in bytes.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the blob. If null, 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="TaskSequence"/> that creates the blob.</returns>
private RESTCommand<NullType> CreateImpl(long sizeInBytes, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) =>
{
HttpRequestMessage msg = BlobHttpRequestMessageFactory.Put(cmd.Uri, cmd.ServerTimeoutInSeconds, this.Properties, BlobType.PageBlob, sizeInBytes, accessCondition, cnt, ctx);
BlobHttpRequestMessageFactory.AddMetadata(msg, this.Metadata);
return msg;
};
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Core implementation of the ListQueues method.
/// </summary>
/// <param name="prefix">The queue name prefix.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the
/// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param>
/// <param name="queueListingDetails">A <see cref="QueueListingDetails"/> enumeration describing which items to include in the listing.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
/// <param name="currentToken">The continuation token.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that lists the queues.</returns>
private RESTCommand<ResultSegment<CloudQueue>> ListQueuesImpl(string prefix, int? maxResults, QueueListingDetails queueListingDetails, QueueRequestOptions options, QueueContinuationToken currentToken)
{
QueueListingContext listingContext = new QueueListingContext(prefix, maxResults, queueListingDetails)
{
Marker = currentToken != null ? currentToken.NextMarker : null
};
RESTCommand<ResultSegment<CloudQueue>> getCmd = new RESTCommand<ResultSegment<CloudQueue>>(this.Credentials, this.BaseUri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.List(uri, serverTimeout, listingContext, queueListingDetails, ctx);
getCmd.SignRequest = this.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
getCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
ListQueuesResponse listQueuesResponse = new ListQueuesResponse(cmd.ResponseStream);
List<CloudQueue> queuesList = new List<CloudQueue>(
listQueuesResponse.Queues.Select(item => new CloudQueue(item.Name, this)));
QueueContinuationToken continuationToken = null;
if (listQueuesResponse.NextMarker != null)
{
continuationToken = new QueueContinuationToken()
{
NextMarker = listQueuesResponse.NextMarker,
};
}
return new ResultSegment<CloudQueue>(queuesList)
{
ContinuationToken = continuationToken,
};
};
return getCmd;
}
/// <summary>
/// Implementation method for the WritePage methods.
/// </summary>
/// <param name="pageData">The page data.</param>
/// <param name="startOffset">The start offset.</param>
/// <param name="contentMD5">The content MD5.</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 writes the pages.</returns>
private RESTCommand<NullType> PutPageImpl(Stream pageData, long startOffset, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options)
{
if (startOffset % Constants.PageSize != 0)
{
CommonUtils.ArgumentOutOfRange("startOffset", startOffset);
}
long offset = pageData.Position;
long length = pageData.Length - offset;
PageRange pageRange = new PageRange(startOffset, startOffset + length - 1);
PageWrite pageWrite = PageWrite.Update;
if ((1 + pageRange.EndOffset - pageRange.StartOffset) % Constants.PageSize != 0 ||
(1 + pageRange.EndOffset - pageRange.StartOffset) == 0)
{
CommonUtils.ArgumentOutOfRange("pageData", pageData);
}
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.SendStream = pageData;
putCmd.RecoveryAction = (cmd, ex, ctx) => RecoveryActions.SeekStream(cmd, ex, ctx, offset);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.PutPage(uri, serverTimeout, pageRange, pageWrite, accessCondition, ctx);
putCmd.SetHeaders = (r, ctx) =>
{
if (!string.IsNullOrEmpty(contentMD5))
{
r.Headers.Set(HttpRequestHeader.ContentMd5, contentMD5);
}
};
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Implementation of the AbortCopy method. No result is produced.
/// </summary>
/// <param name="copyId">The copy ID of the copy operation to abort.</param>
/// <param name="accessCondition">An object that represents the access conditions for the operation. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that aborts the copy.</returns>
internal static RESTCommand<NullType> AbortCopyImpl(ICloudBlob blob, BlobAttributes attributes, string copyId, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtils.AssertNotNull("copyId", copyId);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.AbortCopy(uri, serverTimeout, copyId, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(new HttpStatusCode[] { HttpStatusCode.OK, HttpStatusCode.NoContent }, resp, NullType.Value, cmd, ex, ctx);
return putCmd;
}
/// <summary>
/// Implementation of the StartCopyFromBlob method. Result is a BlobAttributes object derived from the response headers.
/// </summary>
/// <param name="source">The URI of the source blob.</param>
/// <param name="sourceAccessCondition">An object that represents the access conditions for the source blob. If null, no condition is used.</param>
/// <param name="destAccessCondition">An object that represents the access conditions for the destination blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that starts to copy the blob.</returns>
internal static RESTCommand<string> StartCopyFromBlobImpl(ICloudBlob blob, BlobAttributes attributes, Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options)
{
if (sourceAccessCondition != null && !string.IsNullOrEmpty(sourceAccessCondition.LeaseId))
{
throw new ArgumentException(SR.LeaseConditionOnSource, "sourceAccessCondition");
}
RESTCommand<string> putCmd = new RESTCommand<string>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.CopyFrom(uri, serverTimeout, source, sourceAccessCondition, destAccessCondition, ctx);
putCmd.SetHeaders = (r, ctx) => BlobHttpWebRequestFactory.AddMetadata(r, attributes.Metadata);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, null /* retVal */, cmd, ex, ctx);
CopyState state = BlobHttpResponseParsers.GetCopyAttributes(resp);
attributes.Properties = BlobHttpResponseParsers.GetProperties(resp);
attributes.Metadata = BlobHttpResponseParsers.GetMetadata(resp);
attributes.CopyState = state;
return state.CopyId;
};
return putCmd;
}
/// <summary>
/// Implements getting the stream without specifying a range.
/// </summary>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that gets the stream.</returns>
internal static RESTCommand<NullType> GetBlobImpl(ICloudBlob blob, BlobAttributes attributes, Stream destStream, long? offset, long? length, AccessCondition accessCondition, BlobRequestOptions options)
{
string lockedETag = null;
AccessCondition lockedAccessCondition = null;
bool isRangeGet = offset.HasValue;
bool arePropertiesPopulated = false;
string storedMD5 = null;
long startingOffset = offset.HasValue ? offset.Value : 0;
long? startingLength = length;
RESTCommand<NullType> getCmd = new RESTCommand<NullType>(blob.ServiceClient.Credentials, attributes.Uri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.DestinationStream = destStream;
getCmd.CalculateMd5ForResponseStream = !options.DisableContentMD5Validation.Value;
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) =>
BlobHttpWebRequestFactory.Get(uri, serverTimeout, attributes.SnapshotTime, offset, length, options.UseTransactionalMD5.Value, accessCondition, ctx);
getCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
getCmd.RecoveryAction = (cmd, ex, ctx) =>
{
if ((lockedAccessCondition == null) && !string.IsNullOrEmpty(lockedETag))
{
lockedAccessCondition = AccessCondition.GenerateIfMatchCondition(lockedETag);
if (accessCondition != null)
{
lockedAccessCondition.LeaseId = accessCondition.LeaseId;
}
}
if (cmd.StreamCopyState != null)
{
offset = startingOffset + cmd.StreamCopyState.Length;
if (startingLength.HasValue)
{
length = startingLength.Value - cmd.StreamCopyState.Length;
}
}
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, context) =>
BlobHttpWebRequestFactory.Get(uri, serverTimeout, attributes.SnapshotTime, offset, length, options.UseTransactionalMD5.Value && !arePropertiesPopulated, lockedAccessCondition ?? accessCondition, context);
};
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(offset.HasValue ? HttpStatusCode.PartialContent : HttpStatusCode.OK, resp, NullType.Value, cmd, ex, ctx);
if (!arePropertiesPopulated)
{
CloudBlobSharedImpl.UpdateAfterFetchAttributes(attributes, resp, isRangeGet);
storedMD5 = resp.Headers[HttpResponseHeader.ContentMd5];
if (!options.DisableContentMD5Validation.Value &&
options.UseTransactionalMD5.Value &&
string.IsNullOrEmpty(storedMD5))
{
throw new StorageException(
cmd.CurrentResult,
SR.MD5NotPresentError,
null)
{
IsRetryable = false
};
}
lockedETag = attributes.Properties.ETag;
arePropertiesPopulated = true;
}
return NullType.Value;
};
getCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
long validateLength = startingLength.HasValue ? startingLength.Value : (attributes.Properties.Length - startingOffset);
HttpResponseParsers.ValidateResponseStreamMd5AndLength(validateLength, storedMD5, cmd, cmd.StreamCopyState);
return NullType.Value;
};
return getCmd;
}
/// <summary>
/// Gets the page ranges impl.
/// </summary>
/// <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="length">The length of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</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"/> for getting the page ranges.</returns>
private RESTCommand<IEnumerable<PageRange>> GetPageRangesImpl(long? offset, long? length, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<IEnumerable<PageRange>> getCmd = new RESTCommand<IEnumerable<PageRange>>(this.ServiceClient.Credentials, this.Uri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.Handler = this.ServiceClient.AuthenticationHandler;
getCmd.BuildClient = HttpClientFactory.BuildHttpClient;
getCmd.BuildRequest = (cmd, cnt, ctx) =>
{
HttpRequestMessage msg = BlobHttpRequestMessageFactory.GetPageRanges(cmd.Uri, cmd.ServerTimeoutInSeconds, this.SnapshotTime, offset, length, accessCondition, cnt, ctx);
BlobHttpRequestMessageFactory.AddMetadata(msg, this.Metadata);
return msg;
};
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
getCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
return Task.Factory.StartNew(() =>
{
GetPageRangesResponse getPageRangesResponse = new GetPageRangesResponse(cmd.ResponseStream);
IEnumerable<PageRange> pageRanges = new List<PageRange>(getPageRangesResponse.PageRanges);
return pageRanges;
});
};
return getCmd;
}
/// <summary>
/// Uploads the block list.
/// </summary>
/// <param name="blocks">The blocks to upload.</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"/> that uploads the block list.</returns>
internal RESTCommand<NullType> PutBlockListImpl(IEnumerable<PutBlockListItem> blocks, AccessCondition accessCondition, BlobRequestOptions options)
{
MemoryStream memoryStream = new MemoryStream();
BlobRequest.WriteBlockListBody(blocks, memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
string contentMD5;
using (MD5Wrapper md5 = new MD5Wrapper())
{
contentMD5 = md5.ComputeHash(memoryStream);
}
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, contentMD5, cmd, ctx);
putCmd.BuildRequest = (cmd, cnt, ctx) =>
{
HttpRequestMessage msg = BlobHttpRequestMessageFactory.PutBlockList(cmd.Uri, cmd.ServerTimeoutInSeconds, this.Properties, accessCondition, cnt, ctx);
BlobHttpRequestMessageFactory.AddMetadata(msg, this.Metadata);
return msg;
};
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
this.Properties.Length = 0;
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Implementation method for the WritePage methods.
/// </summary>
/// <param name="pageData">The page data.</param>
/// <param name="startOffset">The start offset.</param>
/// <param name="contentMD5">An optional hash value that will be used to set the <see cref="BlobProperties.ContentMD5"/> property
/// on the blob. May be <c>null</c> or an empty string.</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"/> that writes the pages.</returns>
private RESTCommand<NullType> PutPageImpl(Stream pageData, long startOffset, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options)
{
if (startOffset % Constants.PageSize != 0)
{
CommonUtils.ArgumentOutOfRange("startOffset", startOffset);
}
long offset = pageData.Position;
long length = pageData.Length - offset;
PageRange pageRange = new PageRange(startOffset, startOffset + length - 1);
PageWrite pageWrite = PageWrite.Update;
if ((1 + pageRange.EndOffset - pageRange.StartOffset) % Constants.PageSize != 0 ||
(1 + pageRange.EndOffset - pageRange.StartOffset) == 0)
{
CommonUtils.ArgumentOutOfRange("pageData", pageData);
}
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(pageData, offset, length, contentMD5, cmd, ctx);
putCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.PutPage(cmd.Uri, cmd.ServerTimeoutInSeconds, pageRange, pageWrite, accessCondition, cnt, ctx);
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Gets the download block list.
/// </summary>
/// <param name="typesOfBlocks">The types of blocks.</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="TaskSequence"/> that gets the download block list.</returns>
internal RESTCommand<IEnumerable<ListBlockItem>> GetBlockListImpl(BlockListingFilter typesOfBlocks, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<IEnumerable<ListBlockItem>> getCmd = new RESTCommand<IEnumerable<ListBlockItem>>(this.ServiceClient.Credentials, this.Uri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.Handler = this.ServiceClient.AuthenticationHandler;
getCmd.BuildClient = HttpClientFactory.BuildHttpClient;
getCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.GetBlockList(cmd.Uri, cmd.ServerTimeoutInSeconds, this.SnapshotTime, typesOfBlocks, accessCondition, cnt, ctx);
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
getCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
return Task.Factory.StartNew(() =>
{
GetBlockListResponse responseParser = new GetBlockListResponse(cmd.ResponseStream);
IEnumerable<ListBlockItem> blocks = new List<ListBlockItem>(responseParser.Blocks);
return blocks;
});
};
return getCmd;
}
/// <summary>
/// Uploads the full blob from a seekable stream.
/// </summary>
/// <param name="stream">The content stream. Must be seekable.</param>
/// <param name="length">Number of bytes to upload from the content stream starting at its current position.</param>
/// <param name="contentMD5">The content MD5.</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 gets the stream.</returns>
private RESTCommand<NullType> PutBlobImpl(Stream stream, long? length, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options)
{
long offset = stream.Position;
this.Properties.ContentMD5 = contentMD5;
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.SendStream = stream;
putCmd.SendStreamLength = length ?? stream.Length - offset;
putCmd.RecoveryAction = (cmd, ex, ctx) => RecoveryActions.SeekStream(cmd, offset);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Put(uri, serverTimeout, this.Properties, BlobType.BlockBlob, 0, accessCondition, ctx);
putCmd.SetHeaders = (r, ctx) => BlobHttpWebRequestFactory.AddMetadata(r, this.Metadata);
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex);
CloudBlobSharedImpl.UpdateETagLMTAndSequenceNumber(this.attributes, resp);
this.Properties.Length = putCmd.SendStreamLength.Value;
return NullType.Value;
};
return putCmd;
}
/// <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"/> 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>
internal RESTCommand<CloudBlockBlob> CreateSnapshotImpl(IDictionary<string, string> metadata, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<CloudBlockBlob> putCmd = new RESTCommand<CloudBlockBlob>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) =>
{
HttpRequestMessage msg = BlobHttpRequestMessageFactory.Snapshot(cmd.Uri, cmd.ServerTimeoutInSeconds, accessCondition, cnt, ctx);
if (metadata != null)
{
BlobHttpRequestMessageFactory.AddMetadata(msg, metadata);
}
return msg;
};
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, null /* retVal */, cmd, ex, ctx);
DateTimeOffset snapshotTime = NavigationHelper.ParseSnapshotTime(BlobHttpResponseParsers.GetSnapshotTime(resp));
CloudBlockBlob snapshot = new CloudBlockBlob(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;
}
/// <summary>
/// Uploads the block list.
/// </summary>
/// <param name="blocks">The blocks to upload.</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 uploads the block list.</returns>
internal RESTCommand<NullType> PutBlockListImpl(IEnumerable<PutBlockListItem> blocks, AccessCondition accessCondition, BlobRequestOptions options)
{
MultiBufferMemoryStream memoryStream = new MultiBufferMemoryStream(this.ServiceClient.BufferManager);
BlobRequest.WriteBlockListBody(blocks, memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
#if !WINDOWS_PHONE
string contentMD5 = memoryStream.ComputeMD5Hash();
memoryStream.Seek(0, SeekOrigin.Begin);
#endif
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.PutBlockList(uri, serverTimeout, this.Properties, accessCondition, ctx);
putCmd.SetHeaders = (r, ctx) =>
{
#if !WINDOWS_PHONE
r.Headers[HttpRequestHeader.ContentMd5] = contentMD5;
#endif
BlobHttpWebRequestFactory.AddMetadata(r, this.Metadata);
};
putCmd.SendStream = memoryStream;
putCmd.RecoveryAction = RecoveryActions.RewindStream;
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex);
CloudBlobSharedImpl.UpdateETagLMTAndSequenceNumber(this.attributes, resp);
this.Properties.Length = -1;
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Uploads the full blob.
/// </summary>
/// <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="SynchronousTask"/> that gets the stream.</returns>
private RESTCommand<NullType> PutBlobImpl(Stream stream, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options)
{
long offset = stream.Position;
long length = stream.Length - offset;
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(stream, offset, length, contentMD5, cmd, ctx);
putCmd.BuildRequest = (cmd, cnt, ctx) =>
{
HttpRequestMessage msg = BlobHttpRequestMessageFactory.Put(cmd.Uri, cmd.ServerTimeoutInSeconds, this.Properties, BlobType.BlockBlob, 0, accessCondition, cnt, ctx);
BlobHttpRequestMessageFactory.AddMetadata(msg, this.Metadata);
return msg;
};
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
this.Properties.Length = length;
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Implementation for the Resize method.
/// </summary>
/// <param name="sizeInBytes">The size in bytes.</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">An <see cref="BlobRequestOptions"/> object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that sets the metadata.</returns>
private RESTCommand<NullType> ResizeImpl(long sizeInBytes, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Resize(uri, serverTimeout, sizeInBytes, accessCondition, ctx);
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(attributes, resp);
this.Properties.Length = sizeInBytes;
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Uploads the block.
/// </summary>
/// <param name="source">The source stream.</param>
/// <param name="blockId">The block ID.</param>
/// <param name="contentMD5">The content MD5.</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"/> that uploads the block.</returns>
internal RESTCommand<NullType> PutBlockImpl(Stream source, string blockId, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options)
{
long offset = source.Position;
long length = source.Length - offset;
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(source, offset, length, contentMD5, cmd, ctx);
putCmd.BuildRequest = (cmd, cnt, ctx) => BlobHttpRequestMessageFactory.PutBlock(cmd.Uri, cmd.ServerTimeoutInSeconds, blockId, accessCondition, cnt, ctx);
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
return putCmd;
}
/// <summary>
/// Gets the page ranges impl.
/// </summary>
/// <param name="offset">The start offset. Must be multiples of 512.</param>
/// <param name="length">Length of the data range to be cleared. Must be multiples of 512.</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}"/> for getting the page ranges.</returns>
private RESTCommand<IEnumerable<PageRange>> GetPageRangesImpl(long? offset, long? length, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<IEnumerable<PageRange>> getCmd = new RESTCommand<IEnumerable<PageRange>>(this.ServiceClient.Credentials, this.Uri);
getCmd.ApplyRequestOptions(options);
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.GetPageRanges(uri, serverTimeout, this.SnapshotTime, offset, length, accessCondition, ctx);
getCmd.SetHeaders = (r, ctx) => BlobHttpWebRequestFactory.AddMetadata(r, this.Metadata);
getCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
getCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
GetPageRangesResponse getPageRangesResponse = new GetPageRangesResponse(cmd.ResponseStream);
IEnumerable<PageRange> pageRanges = new List<PageRange>(getPageRangesResponse.PageRanges);
return pageRanges;
};
return getCmd;
}
private RESTCommand<ServiceProperties> GetServicePropertiesImpl(BlobRequestOptions requestOptions)
{
RESTCommand<ServiceProperties> retCmd = new RESTCommand<ServiceProperties>(this.Credentials, this.BaseUri);
retCmd.BuildRequestDelegate = BlobHttpWebRequestFactory.GetServiceProperties;
retCmd.SignRequest = this.AuthenticationHandler.SignRequest;
retCmd.RetrieveResponseStream = true;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(
System.Net.HttpStatusCode.OK,
resp,
null /* retVal */,
cmd,
ex,
ctx);
retCmd.PostProcessResponse =
(cmd, resp, ex, ctx) => BlobHttpResponseParsers.ReadServiceProperties(cmd.ResponseStream);
retCmd.ApplyRequestOptions(requestOptions);
return retCmd;
}
/// <summary>
/// Implementation method for the ClearPage methods.
/// </summary>
/// <param name="startOffset">The start offset. Must be multiples of 512.</param>
/// <param name="length">Length of the data range to be cleared. Must be multiples of 512.</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 writes the pages.</returns>
private RESTCommand<NullType> ClearPageImpl(long startOffset, long length, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtils.AssertNotNull("options", options);
if (startOffset < 0 || startOffset % Constants.PageSize != 0)
{
CommonUtils.ArgumentOutOfRange("startOffset", startOffset);
}
if (length <= 0 || length % Constants.PageSize != 0)
{
CommonUtils.ArgumentOutOfRange("length", length);
}
PageRange pageRange = new PageRange(startOffset, startOffset + length - 1);
PageWrite pageWrite = PageWrite.Clear;
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.PutPage(uri, serverTimeout, pageRange, pageWrite, accessCondition, ctx);
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
CloudBlobSharedImpl.ParseSizeAndLastModified(this.attributes, resp);
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Generates a <see cref="RESTCommand{T}"/> for acquiring a lease.
/// </summary>
/// <param name="leaseTime">A <see cref="TimeSpan"/> representing the span of time for which to acquire the lease,
/// which will be rounded down to seconds. If null, an infinite lease will be acquired. If not null, this must be
/// greater than zero.</param>
/// <param name="proposedLeaseId">A string representing the proposed lease ID for the new lease, or null if no lease ID is proposed.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> implementing the acquire lease operation.</returns>
internal static RESTCommand<string> AcquireLeaseImpl(ICloudBlob blob, BlobAttributes attributes, TimeSpan? leaseTime, string proposedLeaseId, AccessCondition accessCondition, BlobRequestOptions options)
{
int leaseDuration = -1;
if (leaseTime.HasValue)
{
CommonUtils.AssertInBounds("leaseTime", leaseTime.Value, TimeSpan.FromSeconds(1), TimeSpan.MaxValue);
leaseDuration = (int)leaseTime.Value.TotalSeconds;
}
RESTCommand<string> putCmd = new RESTCommand<string>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Lease(uri, serverTimeout, LeaseAction.Acquire, proposedLeaseId, leaseDuration, null /* leaseBreakPeriod */, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, null, cmd, ex, ctx);
return BlobHttpResponseParsers.GetLeaseId(resp);
};
return putCmd;
}
/// <summary>
/// Implements the FetchAttributes method. The attributes are updated immediately.
/// </summary>
/// <param name="blobUri">The URI of the blob.</param>
/// <param name="accessCondition">An 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 fetches the attributes.</returns>
private RESTCommand<ICloudBlob> GetBlobReferenceImpl(Uri blobUri, AccessCondition accessCondition, BlobRequestOptions options)
{
// If the blob Uri contains SAS credentials, we need to use those
// credentials instead of this service client's stored credentials.
StorageCredentials parsedCredentials;
DateTimeOffset? parsedSnapshot;
blobUri = NavigationHelper.ParseBlobQueryAndVerify(blobUri, out parsedCredentials, out parsedSnapshot);
CloudBlobClient client = parsedCredentials != null ? new CloudBlobClient(this.BaseUri, parsedCredentials) : this;
RESTCommand<ICloudBlob> getCmd = new RESTCommand<ICloudBlob>(client.Credentials, blobUri);
getCmd.ApplyRequestOptions(options);
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.GetProperties(uri, serverTimeout, null /* snapshot */, accessCondition, ctx);
getCmd.SignRequest = client.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
BlobAttributes attributes = new BlobAttributes()
{
Uri = blobUri,
SnapshotTime = parsedSnapshot,
};
CloudBlobSharedImpl.UpdateAfterFetchAttributes(attributes, resp, false);
switch (attributes.Properties.BlobType)
{
case BlobType.BlockBlob:
return new CloudBlockBlob(attributes, client);
case BlobType.PageBlob:
return new CloudPageBlob(attributes, client);
default:
throw new InvalidOperationException();
}
};
return getCmd;
}
/// <summary>
/// Generates a <see cref="RESTCommand{T}"/> for releasing a lease.
/// </summary>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> implementing the release lease operation.</returns>
internal static RESTCommand<NullType> ReleaseLeaseImpl(ICloudBlob blob, BlobAttributes attributes, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtils.AssertNotNull("accessCondition", accessCondition);
if (accessCondition.LeaseId == null)
{
throw new ArgumentException(SR.MissingLeaseIDReleasing, "accessCondition");
}
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Lease(uri, serverTimeout, LeaseAction.Release, null /* proposedLeaseId */, null /* leaseDuration */, null /* leaseBreakPeriod */, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, NullType.Value, cmd, ex, ctx);
return putCmd;
}
private RESTCommand<NullType> SetServicePropertiesImpl(ServiceProperties properties, BlobRequestOptions requestOptions)
{
MemoryStream str = new MemoryStream();
try
{
properties.WriteServiceProperties(str);
}
catch (InvalidOperationException invalidOpException)
{
throw new ArgumentException(invalidOpException.Message, "properties");
}
str.Seek(0, SeekOrigin.Begin);
RESTCommand<NullType> retCmd = new RESTCommand<NullType>(this.Credentials, this.BaseUri);
retCmd.SendStream = str;
retCmd.BuildRequestDelegate = BlobHttpWebRequestFactory.SetServiceProperties;
retCmd.RecoveryAction = RecoveryActions.RewindStream;
retCmd.SignRequest = this.AuthenticationHandler.SignRequest;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(System.Net.HttpStatusCode.Accepted, resp, NullType.Value, cmd, ex, ctx);
retCmd.ApplyRequestOptions(requestOptions);
return retCmd;
}
/// <summary>
/// Generates a <see cref="RESTCommand{T}"/> for breaking a lease.
/// </summary>
/// <param name="breakPeriod">The amount of time to allow the lease to remain, rounded down to seconds.
/// If null, the break period is the remainder of the current lease, or zero for infinite leases.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> implementing the break lease operation.</returns>
internal static RESTCommand<TimeSpan> BreakLeaseImpl(ICloudBlob blob, BlobAttributes attributes, TimeSpan? breakPeriod, AccessCondition accessCondition, BlobRequestOptions options)
{
int? breakSeconds = null;
if (breakPeriod.HasValue)
{
CommonUtils.AssertInBounds("breakPeriod", breakPeriod.Value, TimeSpan.FromSeconds(0), TimeSpan.MaxValue);
breakSeconds = (int)breakPeriod.Value.TotalSeconds;
}
RESTCommand<TimeSpan> putCmd = new RESTCommand<TimeSpan>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Lease(uri, serverTimeout, LeaseAction.Break, null /* proposedLeaseId */, null /* leaseDuration */, breakSeconds, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, TimeSpan.Zero, cmd, ex, ctx);
int? remainingLeaseTime = BlobHttpResponseParsers.GetRemainingLeaseTime(resp);
if (!remainingLeaseTime.HasValue)
{
// Unexpected result from service.
throw new StorageException(cmd.CurrentResult, SR.LeaseTimeNotReceived, null /* inner */);
}
return TimeSpan.FromSeconds(remainingLeaseTime.Value);
};
return putCmd;
}