public async Task <IEnumerable <Item> > GetByClassName(string classname) { using (var scope = CreateScope()) { var paramUri = new UriQueryBuilder(); paramUri.Add("classname", classname); HttpResponseMessage response = await scope.Instance.GetAsync(CreatePathBuilder().AddQuery(paramUri).Build()); response.EnsureSuccessStatusCode(); return(await response.Content.ReadAsAsync <IEnumerable <Item> >()); } }
/// <summary> /// Converts the source blob of a copy operation to an appropriate access URI, taking Shared Access Signature credentials into account. /// </summary> /// <param name="source">The source blob.</param> /// <returns>A URI addressing the source blob, using SAS if appropriate.</returns> internal static Uri SourceBlobToUri(ICloudBlob source) { Uri sourceUri = source.ServiceClient.Credentials.TransformUri(source.Uri); if (source.SnapshotTime.HasValue) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add("snapshot", BlobRequest.ConvertDateTimeToSnapshotString(source.SnapshotTime.Value)); sourceUri = builder.AddToUri(sourceUri); } return(sourceUri); }
/// 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 HttpRequestMessage Resize(Uri uri, int?timeout, long newFileSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "properties"); HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext); request.Headers.Add(Constants.HeaderConstants.FileContentLengthHeader, newFileSize.ToString(NumberFormatInfo.InvariantInfo)); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to resize a page blob. /// </summary> /// <param name="uri">The absolute URI to the blob.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="newBlobSize">The new blob size, if the blob is a page blob. Set this parameter to <c>null</c> to keep the existing blob size.</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 web request to use to perform the operation.</returns> public static HttpWebRequest Resize(Uri uri, int?timeout, long newBlobSize, AccessCondition accessCondition, OperationContext operationContext) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "properties"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, operationContext); request.Headers.Add(Constants.HeaderConstants.BlobContentLengthHeader, newBlobSize.ToString(NumberFormatInfo.InvariantInfo)); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Generates a web request to return a listing of all files and subdirectories in the directory. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="listingContext">A set of parameters for the listing operation.</param> /// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</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 HttpWebRequest List(Uri uri, int?timeout, FileListingContext listingContext, bool useVersionHeader, OperationContext operationContext) { UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder(); directoryBuilder.Add(Constants.QueryConstants.Component, "list"); if (listingContext != null) { if (listingContext.Marker != null) { directoryBuilder.Add("marker", listingContext.Marker); } if (listingContext.MaxResults.HasValue) { directoryBuilder.Add("maxresults", listingContext.MaxResults.ToString()); } } HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Get, uri, timeout, directoryBuilder, useVersionHeader, operationContext); return(request); }
/// <summary> /// Constructs a web request to get the blob's content, properties, and metadata. /// </summary> /// <param name="uri">The absolute URI to the blob.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="snapshot">The snapshot version, if the blob is a snapshot.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request for performing the operation.</returns> public static HttpRequestMessage Get(Uri uri, int?timeout, DateTimeOffset?snapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { UriQueryBuilder builder = new UriQueryBuilder(); if (snapshot.HasValue) { builder.Add("snapshot", Request.ConvertDateTimeToSnapshotString(snapshot.Value)); } HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext); 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); }
public async Task SetDefaultMachine(int id) { using (HttpClient client = CreateHttpClient()) { var paramUri = new UriQueryBuilder(); paramUri.Add("id", id); HttpResponseMessage response = await client.PutAsJsonAsync(CreatePathBuilder().AddPath("defaultmachine").AddQuery(paramUri).Build(), "dummy"); if (response.IsSuccessStatusCode) { return; } } }
/// <summary> /// Constructs a web request to write or clear a range of pages in a page blob. /// </summary> /// <param name="uri">The absolute URI to the blob.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="properties">The blob'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 HttpRequestMessage PutPage(Uri uri, int?timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "page"); HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext); request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, pageRange.ToString()); request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString()); request.ApplyAccessCondition(accessCondition); return(request); }
public void TestToString() { var builder = new UriQueryBuilder("http://mytest.com/announce.aspx?key=1"); builder.Add("key", 2); builder.Add("foo", 2); builder.Add("foo", "bar"); Assert.AreEqual(new Uri("http://mytest.com/announce.aspx?key=2&foo=bar"), builder.ToUri(), "#1"); builder = new UriQueryBuilder("http://mytest.com/announce.aspx?passkey=1"); builder.Add("key", 2); Assert.AreEqual(new Uri("http://mytest.com/announce.aspx?passkey=1&key=2"), builder.ToUri(), "#2"); builder = new UriQueryBuilder("http://mytest.com/announce.aspx"); Assert.AreEqual(new Uri("http://mytest.com/announce.aspx"), builder.ToUri(), "#3"); builder = new UriQueryBuilder("http://mytest.com/announce.aspx"); var infoHash = new byte[] { 0x01, 0x47, 0xff, 0xaa, 0xbb, 0xcc }; builder.Add("key", UriHelper.UrlEncode(infoHash)); Assert.AreEqual(new Uri("http://mytest.com/announce.aspx?key=%01G%ff%aa%bb%cc"), builder.ToUri(), "#4"); }
/// <summary> /// Constructs a web request to get the blob's content, properties, and metadata. /// </summary> /// <param name="uri">The absolute URI to the blob.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="snapshot">The snapshot version, if the blob is a snapshot.</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 web request for performing the operation.</returns> public static HttpWebRequest Get(Uri uri, int?timeout, DateTimeOffset?snapshot, AccessCondition accessCondition, OperationContext operationContext) { UriQueryBuilder builder = new UriQueryBuilder(); if (snapshot.HasValue) { builder.Add("snapshot", BlobRequest.ConvertDateTimeToSnapshotString(snapshot.Value)); } HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Get, uri, timeout, builder, operationContext); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Generates a web request to return a listing of all files and subdirectories in the directory. /// </summary> /// <param name="uri">The absolute URI to the share.</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 HttpRequestMessage List(Uri uri, int?timeout, FileListingContext listingContext, HttpContent content, OperationContext operationContext) { UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder(); directoryBuilder.Add(Constants.QueryConstants.Component, "list"); if (listingContext != null) { if (listingContext.Marker != null) { directoryBuilder.Add("marker", listingContext.Marker); } if (listingContext.MaxResults.HasValue) { directoryBuilder.Add("maxresults", listingContext.MaxResults.ToString()); } } HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, directoryBuilder, content, operationContext); 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> /// 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="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</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 HttpWebRequest PutRange(Uri uri, int?timeout, FileRange fileRange, FileRangeWrite fileRangeWrite, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { CommonUtility.AssertNotNull("fileRange", fileRange); UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "range"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext); request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, fileRange.ToString()); request.Headers.Add(Constants.HeaderConstants.FileRangeWrite, fileRangeWrite.ToString()); request.ApplyAccessCondition(accessCondition); return(request); }
Uri CreateAnnounceString(AnnounceParameters parameters) { var b = new UriQueryBuilder(Uri); b.Add("info_hash", parameters.InfoHash.UrlEncode()) .Add("peer_id", parameters.PeerId.UrlEncode()) .Add("port", parameters.Port) .Add("uploaded", parameters.BytesUploaded) .Add("downloaded", parameters.BytesDownloaded) .Add("left", parameters.BytesLeft) .Add("compact", 1) .Add("numwant", 100); if (parameters.SupportsEncryption) { b.Add("supportcrypto", 1); } if (parameters.RequireEncryption) { b.Add("requirecrypto", 1); } if (!b.Contains("key") && Key != null) { b.Add("key", Key.UrlEncode()); } if (!string.IsNullOrEmpty(parameters.IPAddress)) { b.Add("ip", parameters.IPAddress); } // If we have not successfully sent the started event to this tier, override the passed in started event // Otherwise append the event if it is not "none" //if (!parameters.Id.Tracker.Tier.SentStartedEvent) //{ // sb.Append("&event=started"); // parameters.Id.Tracker.Tier.SendingStartedEvent = true; //} if (parameters.ClientEvent != TorrentEvent.None) { b.Add("event", parameters.ClientEvent.ToString().ToLower()); } if (!BEncodedString.IsNullOrEmpty(TrackerId)) { b.Add("trackerid", TrackerId.UrlEncode()); } return(b.ToUri()); }
/// <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> /// <param name="useVersionHeader">A flag indicating whether to set the x-ms-version HTTP header.</param> /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static HttpWebRequest ListRanges(Uri uri, int?timeout, long?offset, long?count, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { if (offset.HasValue) { CommonUtility.AssertNotNull("count", count); } UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "rangelist"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Get, uri, timeout, builder, useVersionHeader, operationContext); AddRange(request, offset, count); 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> /// Generates a web request to use to acquire, renew, change, release or break the lease for the container. /// </summary> /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the container.</param> /// <param name="timeout">An integer specifying the server timeout interval.</param> /// <param name="action">A <see cref="LeaseAction"/> enumeration value indicating the lease action to perform.</param> /// <param name="proposedLeaseId">A string specifying the lease ID to propose for the result of an acquire or change operation, /// or <c>null</c> if no ID is proposed for an acquire operation. This parameter should be <c>null</c> 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 <c>null</c> 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 <c>null</c> then the default time is used. This should be <c>null</c> for acquire, renew, change, and release operations.</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="useVersionHeader">A flag indicating whether to set the x-ms-version HTTP header.</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 HttpWebRequest Lease(Uri uri, int?timeout, LeaseAction action, string proposedLeaseId, int?leaseDuration, int?leaseBreakPeriod, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { UriQueryBuilder builder = GetContainerUriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "lease"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext); // Add Headers BlobHttpWebRequestFactory.AddLeaseAction(request, action); BlobHttpWebRequestFactory.AddLeaseDuration(request, leaseDuration); BlobHttpWebRequestFactory.AddProposedLeaseId(request, proposedLeaseId); BlobHttpWebRequestFactory.AddLeaseBreakPeriod(request, leaseBreakPeriod); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to write or clear a range of pages in a page blob. /// </summary> /// <param name="uri">The absolute URI to the blob.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="pageRange">The page range, defined by an object of type <see cref="PageRange"/>.</param> /// <param name="pageWrite">A value of type <see cref="PageWrite"/>, indicating the operation to perform on the page blob.</param> /// <param name="accessCondition">The <see cref="AccessCondition"/> to apply to the request.</param> /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param> /// <returns> /// A web request to use to perform the operation. /// </returns> public static HttpWebRequest PutPage(Uri uri, int?timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, OperationContext operationContext) { CommonUtility.AssertNotNull("pageRange", pageRange); UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "page"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, operationContext); request.Headers.Add(Constants.HeaderConstants.RangeHeader, pageRange.ToString()); request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString()); request.ApplyAccessCondition(accessCondition); request.ApplySequenceNumberCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to create or update a blob by committing a block list. /// </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="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request for performing the operation.</returns> public static HttpRequestMessage PutBlockList(Uri uri, int?timeout, BlobProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "blocklist"); HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext); request.AddOptionalHeader(Constants.HeaderConstants.CacheControlHeader, properties.CacheControl); request.AddOptionalHeader(Constants.HeaderConstants.ContentTypeHeader, properties.ContentType); request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5); request.AddOptionalHeader(Constants.HeaderConstants.ContentLanguageHeader, properties.ContentLanguage); request.AddOptionalHeader(Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Generates a web request to use to acquire, renew, change, release or break the lease for the blob. /// </summary> /// <param name="uri">The absolute URI to the blob.</param> /// <param name="timeout">The server timeout interval, in seconds.</param> /// <param name="action">The lease action to perform.</param> /// <param name="proposedLeaseId">A lease ID to propose for the result of an acquire or change operation, /// or null if no ID is proposed for an acquire operation. This should be null for renew, release, and break operations.</param> /// <param name="leaseDuration">The lease duration, in seconds, for acquire operations. /// If this is -1 then an infinite duration is specified. This should be null for renew, change, release, and break operations.</param> /// <param name="leaseBreakPeriod">The amount of time to wait, in seconds, after a break operation before the lease is broken. /// If this is null then the default time is used. This should be null for acquire, renew, change, and release operations.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static HttpRequestMessage Lease(Uri uri, int?timeout, LeaseAction action, string proposedLeaseId, int?leaseDuration, int?leaseBreakPeriod, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "lease"); HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext); request.ApplyAccessCondition(accessCondition); // Add lease headers BlobHttpRequestMessageFactory.AddLeaseAction(request, action); BlobHttpRequestMessageFactory.AddLeaseDuration(request, leaseDuration); BlobHttpRequestMessageFactory.AddProposedLeaseId(request, proposedLeaseId); BlobHttpRequestMessageFactory.AddLeaseBreakPeriod(request, leaseBreakPeriod); return(request); }
/// <summary> /// Constructs a web request to return the list of valid page ranges for a page blob. /// </summary> /// <param name="uri">The absolute URI to the blob.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param> /// <param name="offset">The starting offset of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param> /// <param name="count">The length of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <returns>A web request to use to perform the operation.</returns> public static HttpRequestMessage GetPageRanges(Uri uri, int?timeout, DateTimeOffset?snapshot, long?offset, long?count, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { if (offset.HasValue) { CommonUtility.AssertNotNull("count", count); } UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "pagelist"); BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot); HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext); AddRange(request, offset, count); request.ApplyAccessCondition(accessCondition); return(request); }
/// <summary> /// Constructs a web request to 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); }
/// <summary> /// Constructs a web request to set system properties for a share. /// </summary> /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the share.</param> /// <param name="timeout">An integer specifying the server timeout interval.</param> /// <param name="properties">The share's properties.</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="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</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 HttpWebRequest SetProperties(Uri uri, int?timeout, FileShareProperties properties, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { CommonUtility.AssertNotNull("properties", properties); UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); shareBuilder.Add(Constants.QueryConstants.Component, "properties"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, shareBuilder, useVersionHeader, operationContext); if (properties.Quota.HasValue) { request.AddOptionalHeader(Constants.HeaderConstants.ShareQuota, properties.Quota.Value); } request.ApplyAccessCondition(accessCondition); return(request); }
internal static HttpRequestMessage BuildRequestCore(Uri uri, HttpMethod method, int?timeout, OperationContext ctx) { Uri uriRequest = uri; if (timeout != null && timeout != 0) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add("timeout", timeout.ToString()); uriRequest = builder.AddToUri(uri); } HttpRequestMessage msg = new HttpRequestMessage(method, uriRequest); msg.Headers.Add("Accept", "application/atom+xml,application/xml"); msg.Headers.Add("Accept-Charset", "UTF-8"); msg.Headers.Add("MaxDataServiceVersion", "2.0;NetFx"); return(msg); }
/// <summary> /// Constructs a web request to create or update a blob by committing a block list. /// </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="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 web request for performing the operation.</returns> public static HttpWebRequest PutBlockList(Uri uri, int?timeout, BlobProperties properties, AccessCondition accessCondition, OperationContext operationContext) { CommonUtility.AssertNotNull("properties", properties); UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "blocklist"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, operationContext); request.AddOptionalHeader(Constants.HeaderConstants.CacheControlHeader, properties.CacheControl); request.AddOptionalHeader(Constants.HeaderConstants.ContentTypeHeader, properties.ContentType); request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5); request.AddOptionalHeader(Constants.HeaderConstants.BlobContentLanguageHeader, properties.ContentLanguage); request.AddOptionalHeader(Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding); request.ApplyAccessCondition(accessCondition); return(request); }
public async Task <IEnumerable <Item> > GetByClassName(string classname) { using (HttpClient client = CreateHttpClient()) { var paramUri = new UriQueryBuilder(); paramUri.Add("classname", classname); HttpResponseMessage response = await client.GetAsync(CreatePathBuilder().AddQuery(paramUri).Build()); if (response.IsSuccessStatusCode) { IEnumerable <Item> items = await response.Content.ReadAsAsync <IEnumerable <Item> >(); return(items); } return(null); } }
public async Task <EepromConfiguration> CalculateConfig(EepromConfigurationInput param) { using (var scope = CreateScope()) { var paramUri = new UriQueryBuilder(); paramUri.Add("teeth", param.Teeth) .Add("toothSizeInMm", param.ToothSizeInMm) .Add("microSteps", param.MicroSteps) .Add("stepsPerRotation", param.StepsPerRotation) .Add("estimatedRotationSpeed", param.EstimatedRotationSpeed) .Add("timeToAcc", param.TimeToAcc) .Add("timeToDec", param.TimeToDec); var response = await scope.Instance.GetAsync(CreatePathBuilder().AddQuery(paramUri).Build()); response.EnsureSuccessStatusCode(); return(await response.Content.ReadAsAsync <EepromConfiguration>()); } }
/// <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 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> /// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</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 HttpWebRequest SetProperties(Uri uri, int?timeout, FileProperties properties, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { CommonUtility.AssertNotNull("properties", properties); UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "properties"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext); if (properties != null) { request.AddOptionalHeader(Constants.HeaderConstants.FileCacheControlHeader, properties.CacheControl); request.AddOptionalHeader(Constants.HeaderConstants.FileContentEncodingHeader, properties.ContentEncoding); request.AddOptionalHeader(Constants.HeaderConstants.FileContentDispositionRequestHeader, properties.ContentDisposition); 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> /// Parses the query. /// </summary> /// <param name="queryParameters">The query parameters.</param> internal static StorageCredentials ParseQuery(IDictionary<string, string> queryParameters) { string signature = null; string signedStart = null; string signedExpiry = null; string signedResource = null; string sigendPermissions = null; string signedIdentifier = null; string signedVersion = null; bool sasParameterFound = false; foreach (KeyValuePair<string, string> parameter in queryParameters) { switch (parameter.Key.ToLower()) { case Constants.QueryConstants.SignedStart: signedStart = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedExpiry: signedExpiry = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedPermissions: sigendPermissions = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedResource: signedResource = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedIdentifier: signedIdentifier = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.Signature: signature = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedVersion: signedVersion = parameter.Value; sasParameterFound = true; break; default: break; //// string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.InvalidQueryParametersInsideBlobAddress, key.ToLower()); //// throw new ArgumentException(errorMessage); } } if (sasParameterFound) { if (signature == null || signedResource == null) { string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.MissingMandatoryParamtersForSAS); throw new ArgumentException(errorMessage); } UriQueryBuilder builder = new UriQueryBuilder(); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedStart, signedStart); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedExpiry, signedExpiry); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedPermissions, sigendPermissions); builder.Add(Constants.QueryConstants.SignedResource, signedResource); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedIdentifier, signedIdentifier); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedVersion, signedVersion); AddEscapedIfNotNull(builder, Constants.QueryConstants.Signature, signature); return new StorageCredentials(builder.ToString()); } return null; }
/// <summary> /// Escapes and adds the specified name/value pair to the query builder if it is not null. /// </summary> /// <param name="builder">The builder to add the value to.</param> /// <param name="name">The name of the pair.</param> /// <param name="value">The value to be escaped.</param> internal static void AddEscapedIfNotNull(UriQueryBuilder builder, string name, string value) { if (value != null) { builder.Add(name, value); } }
internal static StorageCredentials ParseQuery(IDictionary<string, string> queryParameters, bool mandatorySignedResource) { string signature = null; string signedStart = null; string signedExpiry = null; string signedResource = null; string sigendPermissions = null; string signedIdentifier = null; string signedVersion = null; string cacheControl = null; string contentType = null; string contentEncoding = null; string contentLanguage = null; string contentDisposition = null; string tableName = null; bool sasParameterFound = false; foreach (KeyValuePair<string, string> parameter in queryParameters) { switch (parameter.Key.ToLower()) { case Constants.QueryConstants.SignedStart: signedStart = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedExpiry: signedExpiry = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedPermissions: sigendPermissions = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedResource: signedResource = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedIdentifier: signedIdentifier = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.Signature: signature = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SignedVersion: signedVersion = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.CacheControl: cacheControl = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.ContentType: contentType = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.ContentEncoding: contentEncoding = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.ContentLanguage: contentLanguage = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.ContentDisposition: contentDisposition = parameter.Value; sasParameterFound = true; break; case Constants.QueryConstants.SasTableName: tableName = parameter.Value; sasParameterFound = true; break; default: break; } } if (sasParameterFound) { if (signature == null || (mandatorySignedResource && signedResource == null)) { string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.MissingMandatoryParametersForSAS); throw new ArgumentException(errorMessage); } UriQueryBuilder builder = new UriQueryBuilder(); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedStart, signedStart); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedExpiry, signedExpiry); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedPermissions, sigendPermissions); if (signedResource != null) { builder.Add(Constants.QueryConstants.SignedResource, signedResource); } AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedIdentifier, signedIdentifier); AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedVersion, signedVersion); AddEscapedIfNotNull(builder, Constants.QueryConstants.Signature, signature); AddEscapedIfNotNull(builder, Constants.QueryConstants.CacheControl, cacheControl); AddEscapedIfNotNull(builder, Constants.QueryConstants.ContentType, contentType); AddEscapedIfNotNull(builder, Constants.QueryConstants.ContentEncoding, contentEncoding); AddEscapedIfNotNull(builder, Constants.QueryConstants.ContentLanguage, contentLanguage); AddEscapedIfNotNull(builder, Constants.QueryConstants.ContentDisposition, contentDisposition); AddEscapedIfNotNull(builder, Constants.QueryConstants.SasTableName, tableName); return new StorageCredentials(builder.ToString()); } return null; }