/// <summary>
/// Creates the web request.
/// </summary>
/// <param name="uri">The request Uri.</param>
/// <param name="timeout">The timeout.</param>
/// <param name="builder">The builder.</param>
/// <returns>A web request for performing the operation.</returns>
internal static StorageRequestMessage CreateRequestMessage(HttpMethod method, Uri uri, int? timeout, UriQueryBuilder builder, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
if (builder == null)
{
builder = new UriQueryBuilder();
}
if (timeout.HasValue && timeout.Value > 0)
{
builder.Add("timeout", timeout.ToString());
}
#if WINDOWS_RT && !NETCORE
// Windows Phone does not allow the caller to disable caching, so a random GUID
// is added to every URI to make it look like a different request.
builder.Add("randomguid", Guid.NewGuid().ToString("N"));
#endif
Uri uriRequest = builder.AddToUri(uri);
StorageRequestMessage msg = new StorageRequestMessage(method, uriRequest, canonicalizer, credentials, credentials.AccountName);
msg.Content = content;
return msg;
}
private Task<HttpResponseMessage> GetSharedKeyAuthenticationTask(StorageRequestMessage request, CancellationToken cancellationToken)
{
StorageRequestMessage storageRequest = request as StorageRequestMessage;
ICanonicalizer canonicalizer = storageRequest.Canonicalizer;
StorageCredentials credentials = storageRequest.Credentials;
string accountName = storageRequest.AccountName;
if (!request.Headers.Contains(Constants.HeaderConstants.Date))
{
string dateString = HttpWebUtility.ConvertDateTimeToHttpString(DateTimeOffset.UtcNow);
request.Headers.Add(Constants.HeaderConstants.Date, dateString);
}
if (credentials.IsSharedKey)
{
StorageAccountKey accountKey = credentials.Key;
if (!string.IsNullOrEmpty(accountKey.KeyName))
{
request.Headers.Add(Constants.HeaderConstants.KeyNameHeader, accountKey.KeyName);
}
string message = canonicalizer.CanonicalizeHttpRequest(request, accountName);
string signature = CryptoUtility.ComputeHmac256(accountKey.KeyValue, message);
request.Headers.Authorization = new AuthenticationHeaderValue(
canonicalizer.AuthorizationScheme,
string.Format(CultureInfo.InvariantCulture, "{0}:{1}", credentials.AccountName, signature));
}
return base.SendAsync(request, cancellationToken);
}
private Func<StorageRequestMessage, CancellationToken, Task<HttpResponseMessage>> SelectAuthenticationTaskFactory(StorageRequestMessage request)
{
Func<StorageRequestMessage, CancellationToken, Task<HttpResponseMessage>> authenticationHandler;
if (request.Credentials.IsSharedKey)
{
authenticationHandler = this.GetSharedKeyAuthenticationTask;
}
else
{
authenticationHandler = this.GetNoOpAuthenticationTask;
}
return authenticationHandler;
}
private Func<StorageRequestMessage, CancellationToken, Task<HttpResponseMessage>> SelectAuthenticationTaskFactory(StorageRequestMessage request)
{
Func<StorageRequestMessage, CancellationToken, Task<HttpResponseMessage>> authenticationHandler;
if (request.Credentials.IsSharedKey)
{
#if PORTABLE
throw new NotSupportedException(SR.PortableDoesNotSupportSharedKey);
#else
authenticationHandler = this.GetSharedKeyAuthenticationTask;
#endif
}
else
{
authenticationHandler = this.GetNoOpAuthenticationTask;
}
return authenticationHandler;
}
/// <summary>
/// Adds the metadata.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="name">The metadata name.</param>
/// <param name="value">The metadata value.</param>
internal static void AddMetadata(StorageRequestMessage request, string name, string value)
{
CommonUtility.AssertNotNull("value", value);
if (string.IsNullOrWhiteSpace(value))
{
throw new ArgumentException(SR.ArgumentEmptyError, value);
}
request.Headers.Add("x-ms-meta-" + name, value);
}
/// <summary>
/// Adds the metadata.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="metadata">The metadata.</param>
internal static void AddMetadata(StorageRequestMessage request, IDictionary<string, string> metadata)
{
if (metadata != null)
{
foreach (KeyValuePair<string, string> entry in metadata)
{
AddMetadata(request, entry.Key, entry.Value);
}
}
}
/// <summary>
/// Adds user-defined metadata to the request as a single name-value pair.
/// </summary>
/// <param name="request">The web request.</param>
/// <param name="name">The metadata name.</param>
/// <param name="value">The metadata value.</param>
public static void AddMetadata(StorageRequestMessage request, string name, string value)
{
HttpRequestMessageFactory.AddMetadata(request, name, value);
}
/// <summary>
/// Adds user-defined metadata to the request as one or more name-value pairs.
/// </summary>
/// <param name="request">The web request.</param>
/// <param name="metadata">The user-defined metadata.</param>
public static void AddMetadata(StorageRequestMessage request, IDictionary<string, string> metadata)
{
HttpRequestMessageFactory.AddMetadata(request, metadata);
}
/// <summary>
/// Initializes a new instance of HttpRequestAdapterMessage.
/// </summary>
/// <param name="msg">The message to adapt.</param>
/// <param name="bufferManager">The <see cref="IBufferManager"/> to use to acquire and return buffers for the stream. May be <c>null</c>.</param>
/// <param name="bufferSize">The buffer size to use for each block. The default size is 64 KB. Note that this parameter is disregarded when an <see cref="IBufferManager"/> is specified.</param>
public HttpRequestAdapterMessage(StorageRequestMessage msg, IBufferManager bufferManager, int bufferSize)
{
this.msg = msg;
this.outStr = new MultiBufferMemoryStream(bufferManager, bufferSize);
this.content = new StreamContent(this.outStr);
}
public void Dispose()
{
this.msg = null;
this.outStr = null;
this.content = null;
}
/// <summary>
/// Adds the Range Header for File Service Operations.
/// </summary>
/// <param name="request">Request</param>
/// <param name="offset">Starting byte of the range</param>
/// <param name="count">Number of bytes in the range</param>
private static void AddRange(StorageRequestMessage request, long? offset, long? count)
{
if (count.HasValue)
{
CommonUtility.AssertNotNull("offset", offset);
CommonUtility.AssertInBounds("count", count.Value, 1, long.MaxValue);
}
if (offset.HasValue)
{
string rangeStart = offset.ToString();
string rangeEnd = string.Empty;
if (count.HasValue)
{
rangeEnd = (offset + count.Value - 1).ToString();
}
string rangeHeaderValue = string.Format(CultureInfo.InvariantCulture, Constants.HeaderConstants.RangeHeaderFormat, rangeStart, rangeEnd);
request.Headers.Add(Constants.HeaderConstants.RangeHeader, rangeHeaderValue);
}
}
private Task<HttpResponseMessage> GetNoOpAuthenticationTask(StorageRequestMessage request, CancellationToken cancellationToken)
{
return base.SendAsync(request, cancellationToken);
}
/// <summary>
/// Adds a lease action to a request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="leaseAction">The lease action.</param>
internal static void AddLeaseAction(StorageRequestMessage request, LeaseAction leaseAction)
{
request.Headers.Add(Constants.HeaderConstants.LeaseActionHeader, leaseAction.ToString().ToLower());
}
/// <summary>
/// Adds a lease break period to a request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="leaseBreakPeriod">The lease break period.</param>
internal static void AddLeaseBreakPeriod(StorageRequestMessage request, int? leaseBreakPeriod)
{
request.AddOptionalHeader(Constants.HeaderConstants.LeaseBreakPeriodHeader, leaseBreakPeriod);
}
/// <summary>
/// Adds a lease duration to a request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="leaseDuration">The lease duration.</param>
internal static void AddLeaseDuration(StorageRequestMessage request, int? leaseDuration)
{
request.AddOptionalHeader(Constants.HeaderConstants.LeaseDurationHeader, leaseDuration);
}
/// <summary>
/// Adds a proposed lease id to a request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="proposedLeaseId">The proposed lease id.</param>
internal static void AddProposedLeaseId(StorageRequestMessage request, string proposedLeaseId)
{
request.AddOptionalHeader(Constants.HeaderConstants.ProposedLeaseIdHeader, proposedLeaseId);
}