public StorageRequestMessage(HttpMethod method, Uri requestUri, ICanonicalizer canonicalizer, StorageCredentials credentials, string accountName) : base(method, requestUri) { this.Canonicalizer = canonicalizer; this.Credentials = credentials; this.AccountName = accountName; }
/// <summary> /// Generates a web request to return the user-defined metadata for this container. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder(); StorageRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, containerBuilder, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); return request; }
/// <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; }
/// <summary> /// Constructs a web request to create a new block blob or page blob, or to update the content /// of an existing block blob. /// </summary> /// <param name="uri">The absolute URI to the blob.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="properties">The properties to set for the blob.</param> /// <param name="blobType">The type of the blob.</param> /// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored /// for block blobs.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Put(Uri uri, int? timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { if (blobType == BlobType.Unspecified) { throw new InvalidOperationException(SR.UndefinedBlobType); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext, canonicalizer, credentials); if (properties.CacheControl != null) { request.Headers.CacheControl = CacheControlHeaderValue.Parse(properties.CacheControl); } if (content != null) { if (properties.ContentType != null) { content.Headers.ContentType = MediaTypeHeaderValue.Parse(properties.ContentType); } if (properties.ContentMD5 != null) { content.Headers.ContentMD5 = Convert.FromBase64String(properties.ContentMD5); } if (properties.ContentLanguage != null) { content.Headers.ContentLanguage.Add(properties.ContentLanguage); } if (properties.ContentEncoding != null) { content.Headers.ContentEncoding.Add(properties.ContentEncoding); } if (properties.ContentDisposition != null) { content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(properties.ContentDisposition); } } if (blobType == BlobType.PageBlob) { request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.PageBlob); request.Headers.Add(Constants.HeaderConstants.BlobContentLengthHeader, pageBlobSize.ToString(NumberFormatInfo.InvariantInfo)); properties.Length = pageBlobSize; } else if (blobType == BlobType.BlockBlob) { request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.BlockBlob); } else { request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.AppendBlob); } request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to delete the share and all of the files within it. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Delete(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); StorageRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, shareBuilder, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to commit a block to an append blob. /// </summary> /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param> /// <param name="timeout">An integer specifying the server timeout interval.</param> /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param> /// <param name="content"> The HTTP entity body and content headers.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns> public static StorageRequestMessage AppendBlock(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "appendblock"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); request.ApplyAppendCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to create a new share. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="properties">Properties to set on the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Create(Uri uri, FileShareProperties properties, int? timeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); StorageRequestMessage request = HttpRequestMessageFactory.Create(uri, timeout, shareBuilder, content, operationContext, canonicalizer, credentials); if (properties != null && properties.Quota.HasValue) { request.AddOptionalHeader(Constants.HeaderConstants.ShareQuota, properties.Quota.Value); } return request; }
/// <summary> /// Constructs a web request to create a new container. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="accessType">An <see cref="BlobContainerPublicAccessType"/> object that specifies whether data in the container may be accessed publicly and what level of access is to be allowed.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Create(Uri uri, int? timeout, HttpContent content, OperationContext operationContext, BlobContainerPublicAccessType accessType, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder(); StorageRequestMessage request = HttpRequestMessageFactory.Create(uri, timeout, containerBuilder, content, operationContext, canonicalizer, credentials); if (accessType != BlobContainerPublicAccessType.Off) { request.Headers.Add(Constants.HeaderConstants.ContainerPublicAccessType, accessType.ToString().ToLower()); } return request; }
/// <summary> /// Constructs a web request to return the ACL for a cloud resource. /// </summary> /// <param name="uri">The absolute URI to the resource.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="builder">An optional query builder to use.</param> /// <returns><returns>A web request to use to perform the operation.</returns></returns> internal static StorageRequestMessage GetAcl(Uri uri, int? timeout, UriQueryBuilder builder, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { if (builder == null) { builder = new UriQueryBuilder(); } builder.Add(Constants.QueryConstants.Component, "acl"); StorageRequestMessage request = CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); #if WINDOWS_PHONE // Windows phone adds */* as the Accept type when we don't set one explicitly. request.Headers.Add(Constants.HeaderConstants.PayloadAcceptHeader, Constants.XMLAcceptHeaderValue); #endif return request; }
/// <summary> /// Constructs a web request to create a new file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="properties">The properties to set for the file.</param> /// <param name="fileSize">For a file, the size of the file. This parameter is ignored /// for block files.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Create(Uri uri, int? timeout, FileProperties properties, long fileSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext, canonicalizer, credentials); if (properties.CacheControl != null) { request.Headers.CacheControl = CacheControlHeaderValue.Parse(properties.CacheControl); } if (content != null) { if (properties.ContentType != null) { content.Headers.ContentType = MediaTypeHeaderValue.Parse(properties.ContentType); } if (properties.ContentMD5 != null) { content.Headers.ContentMD5 = Convert.FromBase64String(properties.ContentMD5); } if (properties.ContentLanguage != null) { content.Headers.ContentLanguage.Add(properties.ContentLanguage); } if (properties.ContentEncoding != null) { content.Headers.ContentEncoding.Add(properties.ContentEncoding); } if (properties.ContentDisposition != null) { content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(properties.ContentDisposition); } } request.Headers.Add(Constants.HeaderConstants.FileType, Constants.HeaderConstants.File); request.Headers.Add(Constants.HeaderConstants.FileContentLengthHeader, fileSize.ToString(NumberFormatInfo.InvariantInfo)); properties.Length = fileSize; request.ApplyAccessCondition(accessCondition); return request; }
/// Constructs a web request to set system properties for a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="newFileSize">The new file size. Set this parameter to <c>null</c> to keep the existing file size.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Resize(Uri uri, int? timeout, long newFileSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "properties"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.Headers.Add(Constants.HeaderConstants.FileContentLengthHeader, newFileSize.ToString(NumberFormatInfo.InvariantInfo)); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to set system properties for a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="properties">The file's properties.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage SetProperties(Uri uri, int? timeout, FileProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "properties"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); if (properties != null) { request.AddOptionalHeader(Constants.HeaderConstants.FileCacheControlHeader, properties.CacheControl); request.AddOptionalHeader(Constants.HeaderConstants.FileContentDispositionRequestHeader, properties.ContentDisposition); request.AddOptionalHeader(Constants.HeaderConstants.FileContentEncodingHeader, properties.ContentEncoding); request.AddOptionalHeader(Constants.HeaderConstants.FileContentLanguageHeader, properties.ContentLanguage); request.AddOptionalHeader(Constants.HeaderConstants.FileContentMD5Header, properties.ContentMD5); request.AddOptionalHeader(Constants.HeaderConstants.FileContentTypeHeader, properties.ContentType); } request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to return a listing of all queues in this storage account. /// </summary> /// <param name="uri">The absolute URI for the account.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="listingContext">A set of parameters for the listing operation.</param> /// <param name="detailsIncluded">Additional details to return with the listing.</param> /// <returns>A web request for the specified operation.</returns> public static StorageRequestMessage List(Uri uri, int?timeout, ListingContext listingContext, QueueListingDetails detailsIncluded, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "list"); if (listingContext != null) { if (listingContext.Prefix != null) { builder.Add("prefix", listingContext.Prefix); } if (listingContext.Marker != null) { builder.Add("marker", listingContext.Marker); } if (listingContext.MaxResults.HasValue) { builder.Add("maxresults", listingContext.MaxResults.ToString()); } } if ((detailsIncluded & QueueListingDetails.Metadata) != 0) { builder.Add("include", "metadata"); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Creates a web request to get the stats of the service. /// </summary> /// <param name="uri">The absolute URI to the service.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to get the service stats.</returns> internal static StorageRequestMessage GetServiceStats(Uri uri, int? timeout, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = GetServiceUriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "stats"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, null /* content */, operationContext, canonicalizer, credentials); return request; }
/// <summary> /// Constructs a web request to set the ACL for a table. /// </summary> /// <param name="uri">The absolute URI to the table.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns><returns>A web request to use to perform the operation.</returns></returns> public static StorageRequestMessage SetAcl(Uri uri, int? timeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.SetAcl(uri, timeout, null /* builder */, content, operationContext, canonicalizer, credentials); return request; }
/// <summary> /// Constructs a web request to create a snapshot of a share. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Snapshot(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.ResourceType, "share"); builder.Add(Constants.QueryConstants.Component, Constants.QueryConstants.Snapshot); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to return a listing of all containers in this storage account. /// </summary> /// <param name="uri">The absolute URI for the account.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="listingContext">A set of parameters for the listing operation.</param> /// <param name="detailsIncluded">Additional details to return with the listing.</param> /// <returns>A web request for the specified operation.</returns> public static StorageRequestMessage List(Uri uri, int? timeout, ListingContext listingContext, ContainerListingDetails detailsIncluded, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "list"); if (listingContext != null) { if (listingContext.Prefix != null) { builder.Add("prefix", listingContext.Prefix); } if (listingContext.Marker != null) { builder.Add("marker", listingContext.Marker); } if (listingContext.MaxResults.HasValue) { builder.Add("maxresults", listingContext.MaxResults.ToString()); } } if ((detailsIncluded & ContainerListingDetails.Metadata) != 0) { builder.Add("include", "metadata"); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return request; }
/// <summary> /// Constructs a web request to get the stats of the service. /// </summary> /// <param name="uri">The absolute URI to the service.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A StorageRequestMessage to get the service stats.</returns> public static StorageRequestMessage GetServiceStats(Uri uri, int?timeout, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { return(HttpRequestMessageFactory.GetServiceStats(uri, timeout, operationContext, canonicalizer, credentials)); }
/// <summary> /// Constructs a web request to peek messages for a queue. /// </summary> /// <param name="uri">The absolute URI to the queue.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage PeekMessages(Uri uri, int?timeout, int numberOfMessages, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.HeaderConstants.PeekOnly, Constants.HeaderConstants.TrueHeader); builder.Add(Constants.QueryConstants.NumOfMessages, numberOfMessages.ToString()); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Constructs a web request to get messages for a queue. /// </summary> /// <param name="uri">The absolute URI to the queue.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage GetMessages(Uri uri, int?timeout, int numberOfMessages, TimeSpan?visibilityTimeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.NumOfMessages, numberOfMessages.ToString()); if (visibilityTimeout != null) { builder.Add(Constants.QueryConstants.VisibilityTimeout, visibilityTimeout.Value.RoundUpToSeconds().ToString()); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Constructs a web request to delete a message for a queue. /// </summary> /// <param name="uri">The absolute URI to the queue.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage DeleteMessage(Uri uri, int?timeout, string popReceipt, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.PopReceipt, popReceipt); StorageRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, builder, content, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Constructs a web request to update a message for a queue. /// </summary> /// <param name="uri">The absolute URI to the queue.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage UpdateMessage(Uri uri, int?timeout, string popReceipt, TimeSpan?visibilityTimeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.PopReceipt, popReceipt); if (visibilityTimeout != null) { builder.Add(Constants.QueryConstants.VisibilityTimeout, visibilityTimeout.Value.TotalSeconds.ToString()); } else { builder.Add(Constants.QueryConstants.VisibilityTimeout, "0"); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Constructs a web request to add a message for a queue. /// </summary> /// <param name="uri">The absolute URI to the queue.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="timeToLiveInSeconds">The message time-to-live, in seconds.</param> /// <param name="visibilityTimeoutInSeconds">The length of time during which the message will be invisible, in seconds.</param> /// <param name="content">The contents of the HTTP request message.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage AddMessage(Uri uri, int?timeout, long?timeToLiveInSeconds, int?visibilityTimeoutInSeconds, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); if (timeToLiveInSeconds != null) { builder.Add(Constants.QueryConstants.MessageTimeToLive, timeToLiveInSeconds.Value.ToString()); } if (visibilityTimeoutInSeconds != null) { builder.Add(Constants.QueryConstants.VisibilityTimeout, visibilityTimeoutInSeconds.Value.ToString()); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Post, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Generates a web request to copy. /// </summary> /// <param name="uri">The absolute URI to the destination file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="source">The absolute URI to the source object, including any necessary authentication parameters.</param> /// <param name="sourceAccessCondition">The access condition to apply to the source object.</param> /// <param name="destAccessCondition">The access condition to apply to the destination file.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage CopyFrom(Uri uri, int? timeout, Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext, canonicalizer, credentials); request.Headers.Add(Constants.HeaderConstants.CopySourceHeader, source.AbsoluteUri); request.ApplyAccessCondition(destAccessCondition); request.ApplyAccessConditionToSource(sourceAccessCondition); return request; }
/// <summary> /// Constructs a web request to create a new queue. /// </summary> /// <param name="uri">The absolute URI to the queue.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Create(Uri uri, int?timeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { return(HttpRequestMessageFactory.Create(uri, timeout, null, content, operationContext, canonicalizer, credentials)); }
/// <summary> /// Generates a web request to set user-defined metadata for the queue. /// </summary> /// <param name="uri">The absolute URI to the queue.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage SetMetadata(Uri uri, int?timeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.SetMetadata(uri, timeout, null, content, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Generates a web request to return a listing of all blobs in the container. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="listingContext">A set of parameters for the listing operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage ListBlobs(Uri uri, int? timeout, BlobListingContext listingContext, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = ContainerHttpRequestMessageFactory.GetContainerUriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "list"); if (listingContext != null) { if (listingContext.Prefix != null) { builder.Add("prefix", listingContext.Prefix); } if (listingContext.Delimiter != null) { builder.Add("delimiter", listingContext.Delimiter); } if (listingContext.Marker != null) { builder.Add("marker", listingContext.Marker); } if (listingContext.MaxResults.HasValue) { builder.Add("maxresults", listingContext.MaxResults.ToString()); } if (listingContext.Details != BlobListingDetails.None) { StringBuilder sb = new StringBuilder(); bool started = false; if ((listingContext.Details & BlobListingDetails.Snapshots) == BlobListingDetails.Snapshots) { if (!started) { started = true; } else { sb.Append(","); } sb.Append("snapshots"); } if ((listingContext.Details & BlobListingDetails.UncommittedBlobs) == BlobListingDetails.UncommittedBlobs) { if (!started) { started = true; } else { sb.Append(","); } sb.Append("uncommittedblobs"); } if ((listingContext.Details & BlobListingDetails.Metadata) == BlobListingDetails.Metadata) { if (!started) { started = true; } else { sb.Append(","); } sb.Append("metadata"); } if ((listingContext.Details & BlobListingDetails.Copy) == BlobListingDetails.Copy) { if (!started) { started = true; } else { sb.Append(","); } sb.Append("copy"); } builder.Add("include", sb.ToString()); } } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return request; }
/// <summary> /// Constructs a web request to return the list of valid ranges for a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="offset">The starting offset of the data range over which to list file ranges, in bytes.</param> /// <param name="count">The length of the data range over which to list file ranges, in bytes.</param> /// <param name="shareSnapshot">A <see cref="DateTimeOffset"/> specifying the share snapshot timestamp, if the share is a snapshot.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage ListRanges(Uri uri, int?timeout, long?offset, long?count, DateTimeOffset?shareSnapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { if (offset.HasValue) { CommonUtility.AssertNotNull("count", count); } UriQueryBuilder builder = new UriQueryBuilder(); FileHttpRequestMessageFactory.AddShareSnapshot(builder, shareSnapshot); builder.Add(Constants.QueryConstants.Component, "rangelist"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); AddRange(request, offset, count); request.ApplyAccessCondition(accessCondition); return(request); }
public SharedKeyLiteAuthenticationHandler(ICanonicalizer canonicalizer, StorageCredentials credentials, string resourceAccountName) { this.canonicalizer = canonicalizer; this.credentials = credentials; this.resourceAccountName = resourceAccountName; }
/// <summary> /// Constructs a web request to set system properties for a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="properties">The file's properties.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage SetProperties(Uri uri, int?timeout, FileProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { CommonUtility.AssertNotNull("properties", properties); UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "properties"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); if (properties != null) { request.AddOptionalHeader(Constants.HeaderConstants.FileCacheControlHeader, properties.CacheControl); request.AddOptionalHeader(Constants.HeaderConstants.FileContentDispositionRequestHeader, properties.ContentDisposition); request.AddOptionalHeader(Constants.HeaderConstants.FileContentEncodingHeader, properties.ContentEncoding); request.AddOptionalHeader(Constants.HeaderConstants.FileContentLanguageHeader, properties.ContentLanguage); request.AddOptionalHeader(Constants.HeaderConstants.FileContentMD5Header, properties.ContentMD5); request.AddOptionalHeader(Constants.HeaderConstants.FileContentTypeHeader, properties.ContentType); } request.ApplyAccessCondition(accessCondition); return(request); }
public SharedKeyAuthenticationHttpHandler(ICanonicalizer canonicalizer, StorageCredentials credentials, string accountName) { this.canonicalizer = canonicalizer; this.credentials = credentials; this.accountName = accountName; }
/// <summary> /// Constructs a web request to return a specified range of the file's content, together with its properties and metadata. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval, in seconds.</param> /// <param name="offset">The byte offset at which to begin returning content.</param> /// <param name="count">The number of bytes to return, or null to return all bytes through the end of the file.</param> /// <param name="shareSnapshot">A <see cref="DateTimeOffset"/> specifying the share snapshot timestamp, if the share is a snapshot.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Get(Uri uri, int?timeout, long?offset, long?count, bool rangeContentMD5, DateTimeOffset?shareSnapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { if (offset.HasValue && offset.Value < 0) { CommonUtility.ArgumentOutOfRange("offset", offset); } if (offset.HasValue && rangeContentMD5) { CommonUtility.AssertNotNull("count", count); CommonUtility.AssertInBounds("count", count.Value, 1, Constants.MaxRangeGetContentMD5Size); } StorageRequestMessage request = Get(uri, timeout, shareSnapshot, accessCondition, content, operationContext, canonicalizer, credentials); AddRange(request, offset, count); if (offset.HasValue && rangeContentMD5) { request.Headers.Add(Constants.HeaderConstants.RangeContentMD5Header, Constants.HeaderConstants.TrueHeader); } return(request); }
/// <summary> /// Creates the specified Uri. /// </summary> /// <param name="uri">The Uri to create.</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 Create(Uri uri, int? timeout, UriQueryBuilder builder, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return request; }
/// <summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="newFileSize">The new file size. Set this parameter to <c>null</c> to keep the existing file size.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> /// </summary> public static StorageRequestMessage Resize(Uri uri, int?timeout, long newFileSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "properties"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.Headers.Add(Constants.HeaderConstants.FileContentLengthHeader, newFileSize.ToString(NumberFormatInfo.InvariantInfo)); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to return the list of valid ranges for a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="offset">The starting offset of the data range over which to list file ranges, in bytes.</param> /// <param name="count">The length of the data range over which to list file ranges, in bytes.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage ListRanges(Uri uri, int? timeout, long? offset, long? count, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { if (offset.HasValue) { CommonUtility.AssertNotNull("count", count); } UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "rangelist"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); AddRange(request, offset, count); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to write or clear a range of pages in a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="fileRange">The beginning and ending offsets.</param> /// <param name="fileRangeWrite">Action describing whether we are writing to a file or clearing a set of ranges.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="content">The corresponding Http content.</param> /// <param name="operationContext">An object that represents the context for the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage PutRange(Uri uri, int?timeout, FileRange fileRange, FileRangeWrite fileRangeWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "range"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, fileRange.ToString()); request.Headers.Add(Constants.HeaderConstants.FileRangeWrite, fileRangeWrite.ToString()); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to return a specified range of the file's content, together with its properties and metadata. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval, in seconds.</param> /// <param name="offset">The byte offset at which to begin returning content.</param> /// <param name="count">The number of bytes to return, or null to return all bytes through the end of the file.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Get(Uri uri, int? timeout, long? offset, long? count, bool rangeContentMD5, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { if (offset.HasValue && offset.Value < 0) { CommonUtility.ArgumentOutOfRange("offset", offset); } if (offset.HasValue && rangeContentMD5) { CommonUtility.AssertNotNull("count", count); CommonUtility.AssertInBounds("count", count.Value, 1, Constants.MaxBlockSize); } StorageRequestMessage request = Get(uri, timeout, accessCondition, content, operationContext, canonicalizer, credentials); AddRange(request, offset, count); if (offset.HasValue && rangeContentMD5) { request.Headers.Add(Constants.HeaderConstants.RangeContentMD5Header, Constants.HeaderConstants.TrueHeader); } return request; }
/// <summary> /// Generates a web request to copy. /// </summary> /// <param name="uri">The absolute URI to the destination file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="source">The absolute URI to the source object, including any necessary authentication parameters.</param> /// <param name="sourceAccessCondition">The access condition to apply to the source object.</param> /// <param name="destAccessCondition">The access condition to apply to the destination file.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage CopyFrom(Uri uri, int?timeout, Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext, canonicalizer, credentials); request.Headers.Add(Constants.HeaderConstants.CopySourceHeader, source.AbsoluteUri); request.ApplyAccessCondition(destAccessCondition); request.ApplyAccessConditionToSource(sourceAccessCondition); return(request); }
/// <summary> /// Constructs a web request to write or clear a range of pages in a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="fileRange">The beginning and ending offsets.</param> /// <param name="fileRangeWrite">Action describing whether we are writing to a file or clearing a set of ranges.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="content">The corresponding Http content.</param> /// <param name="operationContext">An object that represents the context for the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage PutRange(Uri uri, int? timeout, FileRange fileRange, FileRangeWrite fileRangeWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "range"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, fileRange.ToString()); request.Headers.Add(Constants.HeaderConstants.FileRangeWrite, fileRangeWrite.ToString()); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Creates a web request to set the properties of the service. /// </summary> /// <param name="uri">The absolute URI to the service.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to set the service properties.</returns> internal static StorageRequestMessage SetServiceProperties(Uri uri, int?timeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { return(HttpRequestMessageFactory.SetServiceProperties(uri, timeout, content, operationContext, canonicalizer, credentials)); }
/// <summary> /// Generates a web request to abort a copy operation. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="copyId">The ID string of the copy operation to be aborted.</param> /// <param name="accessCondition">The access condition to apply to the request. /// Only lease conditions are supported for this operation.</param> /// <returns>A web request for performing the operation.</returns> public static StorageRequestMessage AbortCopy(Uri uri, int? timeout, string copyId, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "copy"); builder.Add(Constants.QueryConstants.CopyId, copyId); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.Headers.Add(Constants.HeaderConstants.CopyActionHeader, Constants.HeaderConstants.CopyActionAbort); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to create a new file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="properties">The properties to set for the file.</param> /// <param name="fileSize">For a file, the size of the file. This parameter is ignored /// for block files.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Create(Uri uri, int?timeout, FileProperties properties, long fileSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { CommonUtility.AssertNotNull("properties", properties); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext, canonicalizer, credentials); if (properties.CacheControl != null) { request.Headers.CacheControl = CacheControlHeaderValue.Parse(properties.CacheControl); } if (content != null) { if (properties.ContentType != null) { content.Headers.ContentType = MediaTypeHeaderValue.Parse(properties.ContentType); } if (properties.ContentMD5 != null) { content.Headers.ContentMD5 = Convert.FromBase64String(properties.ContentMD5); } if (properties.ContentLanguage != null) { content.Headers.ContentLanguage.Add(properties.ContentLanguage); } if (properties.ContentEncoding != null) { content.Headers.ContentEncoding.Add(properties.ContentEncoding); } if (properties.ContentDisposition != null) { content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(properties.ContentDisposition); } } request.Headers.Add(Constants.HeaderConstants.FileType, Constants.HeaderConstants.File); request.Headers.Add(Constants.HeaderConstants.FileContentLengthHeader, fileSize.ToString(NumberFormatInfo.InvariantInfo)); properties.Length = fileSize; request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Generates a web request to use to acquire, renew, change, release or break the lease for the container. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval, in seconds.</param> /// <param name="action">The lease action to perform.</param> /// <param name="proposedLeaseId">A lease ID to propose for the result of an acquire or change operation, /// or null if no ID is proposed for an acquire operation. This should be null for renew, release, and break operations.</param> /// <param name="leaseDuration">The lease duration, in seconds, for acquire operations. /// If this is -1 then an infinite duration is specified. This should be null for renew, change, release, and break operations.</param> /// <param name="leaseBreakPeriod">The amount of time to wait, in seconds, after a break operation before the lease is broken. /// If this is null then the default time is used. This should be null for acquire, renew, change, and release operations.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Lease(Uri uri, int? timeout, LeaseAction action, string proposedLeaseId, int? leaseDuration, int? leaseBreakPeriod, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = GetContainerUriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "lease"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); // Add Headers BlobHttpRequestMessageFactory.AddLeaseAction(request, action); BlobHttpRequestMessageFactory.AddLeaseDuration(request, leaseDuration); BlobHttpRequestMessageFactory.AddProposedLeaseId(request, proposedLeaseId); BlobHttpRequestMessageFactory.AddLeaseBreakPeriod(request, leaseBreakPeriod); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Generates a web request to abort a copy operation. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="copyId">The ID string of the copy operation to be aborted.</param> /// <param name="accessCondition">The access condition to apply to the request. /// Only lease conditions are supported for this operation.</param> /// <returns>A web request for performing the operation.</returns> public static StorageRequestMessage AbortCopy(Uri uri, int?timeout, string copyId, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "copy"); builder.Add(Constants.QueryConstants.CopyId, copyId); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.Headers.Add(Constants.HeaderConstants.CopyActionHeader, Constants.HeaderConstants.CopyActionAbort); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to set the ACL for a container. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="publicAccess">The type of public access to allow for the container.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns><returns>A web request to use to perform the operation.</returns></returns> public static StorageRequestMessage SetAcl(Uri uri, int? timeout, BlobContainerPublicAccessType publicAccess, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.SetAcl(uri, timeout, GetContainerUriQueryBuilder(), content, operationContext, canonicalizer, credentials); if (publicAccess != BlobContainerPublicAccessType.Off) { request.Headers.Add(Constants.HeaderConstants.ContainerPublicAccessType, publicAccess.ToString().ToLower()); } request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to return the user-defined metadata for the file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="shareSnapshot">A <see cref="DateTimeOffset"/> specifying the share snapshot timestamp, if the share is a snapshot.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request for performing the operation.</returns> public static StorageRequestMessage GetMetadata(Uri uri, int?timeout, DateTimeOffset?shareSnapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); FileHttpRequestMessageFactory.AddShareSnapshot(builder, shareSnapshot); StorageRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to create a new container. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Create(Uri uri, int? timeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { return ContainerHttpRequestMessageFactory.Create(uri, timeout, content, operationContext, BlobContainerPublicAccessType.Off, canonicalizer, credentials); }
/// <summary> /// Constructs a web request to set user-defined metadata for the file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request for performing the operation.</returns> public static StorageRequestMessage SetMetadata(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.SetMetadata(uri, timeout, null /* builder */, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to get the stats of the service. /// </summary> /// <param name="uri">The absolute URI to the service.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A StorageRequestMessage to get the service stats.</returns> public static StorageRequestMessage GetStats(Uri uri, int?timeout, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); shareBuilder.Add(Constants.QueryConstants.Component, "stats"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, shareBuilder, null /* content */, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Constructs a web request to return a listing of all shares in this storage account. /// </summary> /// <param name="uri">The absolute URI for the account.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="listingContext">A set of parameters for the listing operation.</param> /// <param name="detailsIncluded">Additional details to return with the listing.</param> /// <returns>A web request for the specified operation.</returns> public static StorageRequestMessage List(Uri uri, int?timeout, ListingContext listingContext, ShareListingDetails detailsIncluded, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "list"); if (listingContext != null) { if (listingContext.Prefix != null) { builder.Add("prefix", listingContext.Prefix); } if (listingContext.Marker != null) { builder.Add("marker", listingContext.Marker); } if (listingContext.MaxResults.HasValue) { builder.Add("maxresults", listingContext.MaxResults.ToString()); } } if (detailsIncluded != ShareListingDetails.None) { StringBuilder sb = new StringBuilder(); bool started = false; if ((detailsIncluded & ShareListingDetails.Snapshots) == ShareListingDetails.Snapshots) { if (!started) { started = true; } else { sb.Append(","); } sb.Append("snapshots"); } if ((detailsIncluded & ShareListingDetails.Metadata) == ShareListingDetails.Metadata) { if (!started) { started = true; } else { sb.Append(","); } sb.Append("metadata"); } builder.Add("include", sb.ToString()); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return(request); }
/// <summary> /// Constructs a web request to get the stats of the service. /// </summary> /// <param name="uri">The absolute URI to the service.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A StorageRequestMessage to get the service stats.</returns> public static StorageRequestMessage GetServiceStats(Uri uri, int? timeout, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { return HttpRequestMessageFactory.GetServiceStats(uri, timeout, operationContext, canonicalizer, credentials); }
/// <summary> /// Constructs a web request to close one or more open handles for a file or directory. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="handleId">ID of the handle to be closed, "*" if all should be closed.</param> /// <param name="recursive">Whether to recurse through this directory's subfiles and folders.</param> /// <param name="token">Continuation token for closing many handles.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param> /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns> public static StorageRequestMessage CloseHandle(Uri uri, int?timeout, string handleId, bool?recursive, FileContinuationToken token, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "forceclosehandles"); if (token != null && token.NextMarker != null) { builder.Add(Constants.HeaderConstants.Marker, token.NextMarker); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); if (handleId != null) { request.AddOptionalHeader(Constants.HeaderConstants.HandleId, handleId); } if (recursive.HasValue) { request.AddOptionalHeader(Constants.HeaderConstants.Recursive, recursive.Value.ToString()); } request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Creates a web request to set the properties of the service. /// </summary> /// <param name="uri">The absolute URI to the service.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to set the service properties.</returns> internal static StorageRequestMessage SetServiceProperties(Uri uri, int? timeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.SetServiceProperties(uri, timeout, content, operationContext, canonicalizer, credentials); return request; }
/// <summary> /// Constructs a web request to return the list of open handles for a file or directory. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="maxResults">The maximum number of results to be returned by the server.</param> /// <param name="recursive">Whether to recurse through a directory's files and subfolders.</param> /// <param name="nextMarker">Marker returned by a previous call to continue fetching results.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param> /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns> public static StorageRequestMessage ListHandles(Uri uri, int?timeout, int?maxResults, bool?recursive, FileContinuationToken nextMarker, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "listhandles"); if (maxResults.HasValue) { builder.Add(Constants.MaxResults, maxResults.Value.ToString()); } if (nextMarker != null) { builder.Add(Constants.HeaderConstants.Marker, nextMarker.NextMarker); } StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); if (recursive.HasValue) { request.AddOptionalHeader(Constants.HeaderConstants.Recursive, recursive.Value.ToString()); } return(request); }
/// <summary> /// Sets the metadata. /// </summary> /// <param name="uri">The blob 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 SetMetadata(Uri uri, int? timeout, UriQueryBuilder builder, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { if (builder == null) { builder = new UriQueryBuilder(); } builder.Add(Constants.QueryConstants.Component, "metadata"); StorageRequestMessage request = CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); return request; }
/// <summary> /// Constructs a web request to delete the share and all of the files within it. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the share is a snapshot.</param> /// <param name="deleteSnapshotsOption">A <see cref="DeleteShareSnapshotsOption"/> object indicating whether to only delete the share or delete the share and all snapshots.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Delete(Uri uri, int?timeout, DateTimeOffset?snapshot, DeleteShareSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); ShareHttpRequestMessageFactory.AddShareSnapshot(shareBuilder, snapshot); StorageRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, shareBuilder, content, operationContext, canonicalizer, credentials); switch (deleteSnapshotsOption) { case DeleteShareSnapshotsOption.None: break; // nop case DeleteShareSnapshotsOption.IncludeSnapshots: request.Headers.Add( Constants.HeaderConstants.DeleteSnapshotHeader, Constants.HeaderConstants.IncludeSnapshotsValue); break; } request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to set the ACL for a share. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="publicAccess">The type of public access to allow for the share.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns><returns>A web request to use to perform the operation.</returns></returns> public static StorageRequestMessage SetAcl(Uri uri, int?timeout, FileSharePublicAccessType publicAccess, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { StorageRequestMessage request = HttpRequestMessageFactory.SetAcl(uri, timeout, GetShareUriQueryBuilder(), content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to create a new share. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="properties">Properties to set on the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage Create(Uri uri, FileShareProperties properties, int?timeout, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); StorageRequestMessage request = HttpRequestMessageFactory.Create(uri, timeout, shareBuilder, content, operationContext, canonicalizer, credentials); if (properties != null && properties.Quota.HasValue) { request.AddOptionalHeader(Constants.HeaderConstants.ShareQuota, properties.Quota.Value); } return(request); }
/// <summary> /// Constructs a web request to set system properties for a share. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="properties">The share's properties.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage SetProperties(Uri uri, int?timeout, FileShareProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { CommonUtility.AssertNotNull("properties", properties); UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); shareBuilder.Add(Constants.QueryConstants.Component, "properties"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, shareBuilder, content, operationContext, canonicalizer, credentials); if (properties.Quota.HasValue) { request.AddOptionalHeader(Constants.HeaderConstants.ShareQuota, properties.Quota.Value); } request.ApplyAccessCondition(accessCondition); return(request); }
public SharedKeyLiteAuthenticationHandler(ICanonicalizer canonicalizer, StorageCredentials credentials, string resourceAccountName) { this.canonicalizer = canonicalizer; this.credentials = credentials; this.resourceAccountName = resourceAccountName; }