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;
}