/// <summary>
/// Returns a shared access signature for the queue.
/// </summary>
/// <param name="policy">A <see cref="SharedAccessQueuePolicy"/> object specifying the access policy for the shared access signature.</param>
/// <param name="accessPolicyIdentifier">A string identifying a stored access policy.</param>
/// <param name="protocols">The allowed protocols (https only, or http and https). Null if you don't want to restrict protocol.</param>
/// <param name="ipAddressOrRange">The allowed IP address or IP address range. Null if you don't want to restrict based on IP address.</param>
/// <returns>A shared access signature, as a URI query string.</returns>
/// <remarks>The query string returned includes the leading question mark.</remarks>
public string GetSharedAccessSignature(SharedAccessQueuePolicy policy, string accessPolicyIdentifier, SharedAccessProtocol?protocols, IPAddressOrRange ipAddressOrRange)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceName = this.GetCanonicalName();
StorageAccountKey accountKey = this.ServiceClient.Credentials.Key;
string signature = QueueSharedAccessSignatureHelper.GetHash(
policy,
accessPolicyIdentifier,
resourceName,
Constants.HeaderConstants.TargetStorageVersion,
protocols,
ipAddressOrRange,
accountKey.KeyValue);
string accountKeyName = accountKey.KeyName;
UriQueryBuilder builder = QueueSharedAccessSignatureHelper.GetSignature(
policy,
accessPolicyIdentifier,
signature,
accountKeyName,
Constants.HeaderConstants.TargetStorageVersion,
protocols,
ipAddressOrRange);
return(builder.ToString());
}
public string GetSharedAccessSignature(SharedAccessQueuePolicy policy, string accessPolicyIdentifier, string sasVersion)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string validatedSASVersion = SharedAccessSignatureHelper.ValidateSASVersionString(sasVersion);
string resourceName = this.GetCanonicalName(validatedSASVersion);
StorageAccountKey accountKey = this.ServiceClient.Credentials.Key;
string signature = SharedAccessSignatureHelper.GetHash(
policy,
accessPolicyIdentifier,
resourceName,
validatedSASVersion,
accountKey.KeyValue);
string accountKeyName = accountKey.KeyName;
UriQueryBuilder builder = SharedAccessSignatureHelper.GetSignature(
policy,
accessPolicyIdentifier,
signature,
accountKeyName,
validatedSASVersion);
return(builder.ToString());
}
public XDocument BrowseCategory(ECategoryName categoryName, EExtendedInfoType extInfoType = EExtendedInfoType.None)
{
var url = new UriQueryBuilder(string.Format("http://api.xrel.to/api/release/browse_category.{0}", ResultFormatValue));
var client = new WebClient();
url.QueryString.Add("category_name", categoryName.GetAttribute <ValueAttribute>().Value);
if (extInfoType != EExtendedInfoType.None)
{
url.QueryString.Add("ext_info_type", extInfoType.GetAttribute <ValueAttribute>().Value);
}
var resultString = client.DownloadString(url.ToString());
if (string.IsNullOrEmpty(resultString))
{
return(null);
}
using (var memStream = new MemoryStream()) {
var buf = Encoding.UTF8.GetBytes(resultString);
memStream.Write(buf, 0, buf.Length);
memStream.Position = 0;
return(XDocument.Load(memStream));
}
}
public static string GetSharedAccessSignature(
CloudBlob blob,
SharedAccessBlobPolicy policy,
SharedAccessBlobHeaders headers,
string groupPolicyIdentifier,
SharedAccessProtocol?protocols,
IPAddressOrRange ipAddressOrRange,
string targetStorageVersion)
{
if (!blob.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, "CannotCreateSASWithoutAccountKey");
throw new InvalidOperationException(errorMessage);
}
string resourceName = GetCanonicalName(blob, targetStorageVersion);
string signature = GetHash(policy,
headers,
groupPolicyIdentifier,
resourceName,
targetStorageVersion,
protocols,
ipAddressOrRange,
blob.ServiceClient.Credentials.ExportKey());
// Future resource type changes from "c" => "container"
UriQueryBuilder builder = GetSignature(policy, headers, groupPolicyIdentifier, "b", signature, null, targetStorageVersion, protocols, ipAddressOrRange);
return(builder.ToString());
}
/// <summary>
/// Returns a shared access signature for the blob.
/// </summary>
/// <param name="policy">A <see cref="SharedAccessBlobPolicy"/> object specifying the access policy for the shared access signature.</param>
/// <param name="headers">A <see cref="SharedAccessBlobHeaders"/> object specifying optional header values to set for a blob accessed with this SAS.</param>
/// <param name="groupPolicyIdentifier">A string identifying a stored access policy.</param>
/// <param name="protocols">The allowed protocols (https only, or http and https). Null if you don't want to restrict protocol.</param>
/// <param name="ipAddressOrRange">The allowed IP address or IP address range. Null if you don't want to restrict based on IP address.</param>
/// <returns>A shared access signature, as a URI query string.</returns>
public string GetSharedAccessSignature(SharedAccessBlobPolicy policy, SharedAccessBlobHeaders headers, string groupPolicyIdentifier, SharedAccessProtocol?protocols, IPAddressOrRange ipAddressOrRange)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.InvariantCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceName = this.GetCanonicalName(true /* ignoreSnapshotTime */);
StorageAccountKey accountKey = this.ServiceClient.Credentials.Key;
#if ALL_SERVICES
string signature = SharedAccessSignatureHelper.GetHash(policy, headers, groupPolicyIdentifier, resourceName, OperationContext.StorageVersion ?? Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange, accountKey.KeyValue);
#else
string signature = BlobSharedAccessSignatureHelper.GetHash(policy, headers, groupPolicyIdentifier, resourceName, Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange, accountKey.KeyValue);
#endif
// Future resource type changes from "c" => "container"
#if ALL_SERVICES
UriQueryBuilder builder = SharedAccessSignatureHelper.GetSignature(policy, headers, groupPolicyIdentifier, "b", signature, accountKey.KeyName, OperationContext.StorageVersion ?? Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange);
#else
UriQueryBuilder builder = BlobSharedAccessSignatureHelper.GetSignature(policy, headers, groupPolicyIdentifier, "b", signature, accountKey.KeyName, Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange);
#endif
return(builder.ToString());
}
/// <summary>
/// Returns a shared access signature for the share.
/// </summary>
/// <param name="policy">A <see cref="SharedAccessFilePolicy"/> object specifying the access policy for the shared access signature.</param>
/// <param name="groupPolicyIdentifier">A share-level access policy.</param>
/// <param name="protocols">The allowed protocols (https only, or http and https). Null if you don't want to restrict protocol.</param>
/// <param name="ipAddressOrRange">The allowed IP address or IP address range. Null if you don't want to restrict based on IP address.</param>
/// <returns>A shared access signature, as a URI query string.</returns>
/// <remarks>The query string returned includes the leading question mark.</remarks>
public string GetSharedAccessSignature(SharedAccessFilePolicy policy, string groupPolicyIdentifier, SharedAccessProtocol?protocols, IPAddressOrRange ipAddressOrRange)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceName = this.GetSharedAccessCanonicalName();
StorageAccountKey accountKey = this.ServiceClient.Credentials.Key;
#if ALL_SERVICES
string signature = SharedAccessSignatureHelper.GetHash(policy, null /* headers */, groupPolicyIdentifier, resourceName, OperationContext.StorageVersion ?? Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange, accountKey.KeyValue);
#else
string signature = FileSharedAccessSignatureHelper.GetHash(policy, null /* headers */, groupPolicyIdentifier, resourceName, Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange, accountKey.KeyValue);
#endif
string accountKeyName = accountKey.KeyName;
#if ALL_SERVICES
UriQueryBuilder builder = SharedAccessSignatureHelper.GetSignature(policy, null /* headers */, groupPolicyIdentifier, "s", signature, accountKeyName, OperationContext.StorageVersion ?? Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange);
#else
UriQueryBuilder builder = FileSharedAccessSignatureHelper.GetSignature(policy, null /* headers */, groupPolicyIdentifier, "s", signature, accountKeyName, Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange);
#endif
return(builder.ToString());
}
public void UriQueryBuilder_A1()
{
var uqb = new UriQueryBuilder();
Assert.AreEqual("", uqb.ToString());
Assert.AreEqual(0, uqb.Length);
}
/// <summary>
/// Returns a shared access signature for the queue.
/// </summary>
/// <param name="policy">The access policy for the shared access signature.</param>
/// <param name="accessPolicyIdentifier">A queue-level access policy.</param>
/// <returns>A shared access signature.</returns>
public string GetSharedAccessSignature(SharedAccessQueuePolicy policy, string accessPolicyIdentifier)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceName = this.GetCanonicalName();
string signature = SharedAccessSignatureHelper.GetSharedAccessSignatureHashImpl(
policy,
accessPolicyIdentifier,
resourceName,
this.ServiceClient.Credentials);
string accountKeyName = this.ServiceClient.Credentials.IsSharedKey ? this.ServiceClient.Credentials.KeyName : null;
UriQueryBuilder builder = SharedAccessSignatureHelper.GetSharedAccessSignatureImpl(
policy,
accessPolicyIdentifier,
signature,
accountKeyName);
return(builder.ToString());
}
public void Test_10()
{
var sut = new UriQueryBuilder("http://yahoo.com") { { "eq", "32 * sin(x) ^ 2 / cos(y)-2 ^ e" } };
Aver.AreEqual("http://yahoo.com?eq=32%20%2A%20sin%28x%29%20%5E%202%20%20%20%2F%20%20%20cos%28y%29-2%20%5E%20e", sut.ToString());
var uri = new Uri(sut.ToString());
Aver.AreEqual("?eq=32 * sin(x) ^ 2 / cos(y)-2 ^ e", Uri.UnescapeDataString(uri.Query));
}
public void Test_9()
{
var sut = new UriQueryBuilder("http://yahoo.com") { { "topic", "РБМК Реактор" }};
Aver.AreEqual("http://yahoo.com?topic=%D0%A0%D0%91%D0%9C%D0%9A%20%D0%A0%D0%B5%D0%B0%D0%BA%D1%82%D0%BE%D1%80", sut.ToString());
var uri = new Uri(sut.ToString());
Aver.AreEqual("?topic=РБМК Реактор", Uri.UnescapeDataString(uri.Query));
}
public void UriQueryBuilder_A7()
{
var uqb = new UriQueryBuilder("?a=1");
uqb.AppendParameter("b", "2");
Assert.AreEqual("a=1&b=2", uqb.ToString());
}
public void UriQueryBuilder_A2()
{
var uqb = new UriQueryBuilder();
uqb.AppendParameter("a", "1");
Assert.AreEqual("a=1", uqb.ToString());
Assert.AreEqual(3, uqb.Length);
}
public void UriQueryBuilder_A3()
{
var uqb = new UriQueryBuilder();
uqb
.AppendParameter("a", "1")
.AppendParameter("b", "2");
Assert.AreEqual("a=1&b=2", uqb.ToString());
Assert.AreEqual(7, uqb.Length);
}
public void UriQueryBuilder_A8()
{
var ub = new UriBuilder("https://example.com/?key=abc");
var uqb = new UriQueryBuilder(ub.Query)
.AppendParameter("mode", "1")
.AppendParameter("complexity", "easy");
ub.Query = uqb.ToString();
Assert.AreEqual("https://example.com/?key=abc&mode=1&complexity=easy", ub.Uri.ToString());
}
/// <summary>
/// Returns an user-delegation-based shared access signature for the container, with credentials solely based on the <see cref="UserDelegationKey"/> provided.
/// </summary>
/// <param name="delegationKey"><see cref="UserDelegationKey"/> for signing this SAS token.</param>
/// <param name="policy">A <see cref="SharedAccessBlobPolicy"/> object specifying the access policy for the shared access signature.</param>
/// <param name="headers">A <see cref="SharedAccessBlobHeaders"/> object specifying optional header values to set for a blob container accessed with this SAS.</param>
/// <param name="protocols">The allowed protocols (https only, or http and https). Null if you don't want to restrict protocol.</param>
/// <param name="ipAddressOrRange">The allowed IP address or IP address range. Null if you don't want to restrict based on IP address.</param>
/// <returns></returns>
public string GetUserDelegationSharedAccessSignature(
UserDelegationKey delegationKey,
SharedAccessBlobPolicy policy,
SharedAccessBlobHeaders headers = default(SharedAccessBlobHeaders),
SharedAccessProtocol?protocols = default(SharedAccessProtocol?),
IPAddressOrRange ipAddressOrRange = default(IPAddressOrRange))
{
string resourceName = this.GetSharedAccessCanonicalName();
string signature = BlobSharedAccessSignatureHelper.GetHash(policy, headers, resourceName, Constants.HeaderConstants.TargetStorageVersion, Constants.QueryConstants.ContainerResourceType, null /* snapshotTime */, protocols, ipAddressOrRange, delegationKey);
UriQueryBuilder builder = BlobSharedAccessSignatureHelper.GetSignature(policy, headers, null, Constants.QueryConstants.ContainerResourceType, signature, null, Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange, delegationKey);
return(builder.ToString());
}
public async Task EchoVariousParams_GET()
{
var uri = new UriQueryBuilder("echovariousparams")
.Add("gd", new GDID(1, 3, 1234))
.Add("gu", new Guid("4937EE58-A81F-402A-B019-3D5EA6BC12D6"))
.Add("a", Atom.Encode("abc123"))
.Add("e", EntityId.Parse("type.sch@sys::address").AsString)
.Add("dt", new DateTime(1980, 08, 15, 12, 00, 00, DateTimeKind.Utc).ToString("o"))
.Add("m", -123.4567m)
.Add("d", -5e3)
.Add("b", true)
.Add("li", -8_000_000_000L)
.Add("s", "my string!");
uri.ToString().See();
var response = await Client.GetAsync(uri.ToString());
Aver.IsTrue(HttpStatusCode.OK == response.StatusCode);
var got = (await response.Content.ReadAsStringAsync()).JsonToDataObject() as JsonDataMap;
invariant(got);
}
/// <summary>
/// Returns a shared access signature for the file.
/// </summary>
/// <param name="policy">A <see cref="SharedAccessFilePolicy"/> object specifying the access policy for the shared access signature.</param>
/// <param name="headers">A <see cref="SharedAccessFileHeaders"/> object specifying optional header values to set for a file accessed with this SAS.</param>
/// <param name="groupPolicyIdentifier">A string identifying a stored access policy.</param>
/// <returns>A shared access signature, as a URI query string.</returns>
public string GetSharedAccessSignature(SharedAccessFilePolicy policy, SharedAccessFileHeaders headers, string groupPolicyIdentifier)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.InvariantCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceName = this.GetCanonicalName();
StorageAccountKey accountKey = this.ServiceClient.Credentials.Key;
string signature = SharedAccessSignatureHelper.GetHash(policy, headers, groupPolicyIdentifier, resourceName, Constants.HeaderConstants.TargetStorageVersion, accountKey.KeyValue);
UriQueryBuilder builder = SharedAccessSignatureHelper.GetSignature(policy, headers, groupPolicyIdentifier, "f", signature, accountKey.KeyName, Constants.HeaderConstants.TargetStorageVersion);
return(builder.ToString());
}
/// <summary>
/// Returns a shared access signature for the container.
/// </summary>
/// <param name="policy">The access policy for the shared access signature.</param>
/// <param name="groupPolicyIdentifier">A container-level access policy.</param>
/// <returns>A shared access signature.</returns>
public string GetSharedAccessSignature(SharedAccessBlobPolicy policy, string groupPolicyIdentifier)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceName = this.GetSharedAccessCanonicalName();
string signature = SharedAccessSignatureHelper.GetSharedAccessSignatureHashImpl(policy, groupPolicyIdentifier, resourceName, this.ServiceClient.Credentials);
string accountKeyName = this.ServiceClient.Credentials.KeyName;
// Future resource type changes from "c" => "container"
UriQueryBuilder builder = SharedAccessSignatureHelper.GetSharedAccessSignatureImpl(policy, groupPolicyIdentifier, "c", signature, accountKeyName);
return(builder.ToString());
}
/// <summary>
/// Returns a shared access signature for the blob.
/// </summary>
/// <param name="policy">A <see cref="SharedAccessBlobPolicy"/> object specifying the access policy for the shared access signature.</param>
/// <param name="headers">A <see cref="SharedAccessBlobHeaders"/> object specifying optional header values to set for a blob accessed with this SAS.</param>
/// <param name="groupPolicyIdentifier">A string identifying a stored access policy.</param>
/// <param name="protocols">The allowed protocols (https only, or http and https). Null if you don't want to restrict protocol.</param>
/// <param name="ipAddressOrRange">The allowed IP address or IP address range. Null if you don't want to restrict based on IP address.</param>
/// <returns>A shared access signature, as a URI query string.</returns>
public string GetSharedAccessSignature(SharedAccessBlobPolicy policy, SharedAccessBlobHeaders headers, string groupPolicyIdentifier, SharedAccessProtocol?protocols, IPAddressOrRange ipAddressOrRange)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.InvariantCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceType = this.IsSnapshot ? Constants.QueryConstants.BlobSnapshotResourceType : Constants.QueryConstants.BlobResourceType;
string resourceName = this.GetCanonicalName(true /* ignoreSnapshotTime */);
StorageAccountKey accountKey = this.ServiceClient.Credentials.Key;
string signature = BlobSharedAccessSignatureHelper.GetHash(policy, headers, groupPolicyIdentifier, resourceName, Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange, accountKey.KeyValue, resourceType, this.SnapshotTime);
UriQueryBuilder builder = BlobSharedAccessSignatureHelper.GetSignature(policy, headers, groupPolicyIdentifier, resourceType, signature, accountKey.KeyName, Constants.HeaderConstants.TargetStorageVersion, protocols, ipAddressOrRange);
return(builder.ToString());
}
/// <summary>
/// Returns a shared access signature for the blob.
/// </summary>
/// <param name="policy">A <see cref="SharedAccessBlobPolicy"/> object specifying the access policy for the shared access signature.</param>
/// <param name="headers">A <see cref="SharedAccessBlobHeaders"/> object specifying optional header values to set for a blob accessed with this SAS.</param>
/// <param name="groupPolicyIdentifier">A string identifying a stored access policy.</param>
/// <param name="sasVersion">A string indicating the desired SAS version to use, in storage service version format. Value must be <c>2012-02-12</c> or later.</param>
/// <returns>A shared access signature, as a URI query string.</returns>
public string GetSharedAccessSignature(SharedAccessBlobPolicy policy, SharedAccessBlobHeaders headers, string groupPolicyIdentifier, string sasVersion)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.InvariantCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceName = this.GetCanonicalName(true);
StorageAccountKey accountKey = this.ServiceClient.Credentials.Key;
string validatedSASVersion = SharedAccessSignatureHelper.ValidateSASVersionString(sasVersion);
string signature = SharedAccessSignatureHelper.GetHash(policy, headers, groupPolicyIdentifier, resourceName, validatedSASVersion, accountKey.KeyValue);
// Future resource type changes from "c" => "container"
UriQueryBuilder builder = SharedAccessSignatureHelper.GetSignature(policy, headers, groupPolicyIdentifier, "b", signature, accountKey.KeyName, validatedSASVersion);
return(builder.ToString());
}
/// <summary>
/// Parses the query.
/// </summary>
/// <param name="queryParameters">The query parameters.</param>
internal static StorageCredentials ParseQuery(IDictionary <string, string> queryParameters)
{
bool sasParameterFound = false;
List <string> removeList = new List <string>();
foreach (KeyValuePair <string, string> parameter in queryParameters)
{
switch (parameter.Key.ToLower())
{
case Constants.QueryConstants.Signature:
sasParameterFound = true;
break;
case Constants.QueryConstants.ResourceType:
case Constants.QueryConstants.Component:
case Constants.QueryConstants.Snapshot:
case Constants.QueryConstants.ApiVersion:
case Constants.QueryConstants.ShareSnapshot:
removeList.Add(parameter.Key);
break;
default:
break;
}
}
foreach (string removeParam in removeList)
{
queryParameters.Remove(removeParam);
}
if (sasParameterFound)
{
UriQueryBuilder builder = new UriQueryBuilder();
foreach (KeyValuePair <string, string> parameter in queryParameters)
{
AddEscapedIfNotNull(builder, parameter.Key.ToLower(), parameter.Value);
}
return(new StorageCredentials(builder.ToString()));
}
return(null);
}
public XDocument BrowseCategory(ECategoryName categoryName, EExtendedInfoType extInfoType = EExtendedInfoType.None) {
var url = new UriQueryBuilder(string.Format("http://api.xrel.to/api/release/browse_category.{0}", ResultFormatValue));
var client = new WebClient();
url.QueryString.Add("category_name", categoryName.GetAttribute<ValueAttribute>().Value);
if (extInfoType != EExtendedInfoType.None) {
url.QueryString.Add("ext_info_type", extInfoType.GetAttribute<ValueAttribute>().Value);
}
var resultString = client.DownloadString(url.ToString());
if (string.IsNullOrEmpty(resultString)) {
return null;
}
using (var memStream = new MemoryStream()) {
var buf = Encoding.UTF8.GetBytes(resultString);
memStream.Write(buf, 0, buf.Length);
memStream.Position = 0;
return XDocument.Load(memStream);
}
}
public static string GetSharedAccessSignature(
CloudFile file,
SharedAccessFilePolicy policy,
SharedAccessFileHeaders headers,
string groupPolicyIdentifier,
SharedAccessProtocol?protocols,
IPAddressOrRange ipAddressOrRange,
string targetStorageVersion)
{
if (!file.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.InvariantCulture, "CannotCreateSASWithoutAccountKey");
throw new InvalidOperationException(errorMessage);
}
string resourceName = GetCanonicalName(file);
string signature = GetHash(
policy,
headers,
groupPolicyIdentifier,
resourceName,
targetStorageVersion,
protocols,
ipAddressOrRange,
file.ServiceClient.Credentials.ExportKey());
UriQueryBuilder builder =
GetSignature(
policy,
headers,
groupPolicyIdentifier,
"f",
signature,
null,
targetStorageVersion,
protocols,
ipAddressOrRange);
return(builder.ToString());
}
/// <summary>
/// Returns a shared access signature for the table.
/// </summary>
/// <param name="policy">The access policy for the shared access signature.</param>
/// <param name="accessPolicyIdentifier">An access policy identifier.</param>
/// <param name="startPartitionKey">The start partition key, or null.</param>
/// <param name="startRowKey">The start row key, or null.</param>
/// <param name="endPartitionKey">The end partition key, or null.</param>
/// <param name="endRowKey">The end row key, or null.</param>
/// <returns>A shared access signature, as a URI query string.</returns>
/// <remarks>The query string returned includes the leading question mark.</remarks>
/// <exception cref="InvalidOperationException">Thrown if the current credentials don't support creating a shared access signature.</exception>
public string GetSharedAccessSignature(
SharedAccessTablePolicy policy,
string accessPolicyIdentifier,
string startPartitionKey,
string startRowKey,
string endPartitionKey,
string endRowKey)
{
if (!this.ServiceClient.Credentials.IsSharedKey)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
throw new InvalidOperationException(errorMessage);
}
string resourceName = this.GetCanonicalName();
StorageAccountKey accountKey = this.ServiceClient.Credentials.Key;
string signature = SharedAccessSignatureHelper.GetSharedAccessSignatureHashImpl(
policy,
accessPolicyIdentifier,
startPartitionKey,
startRowKey,
endPartitionKey,
endRowKey,
resourceName,
accountKey.KeyValue);
UriQueryBuilder builder = SharedAccessSignatureHelper.GetSharedAccessSignatureImpl(
policy,
this.Name,
accessPolicyIdentifier,
startPartitionKey,
startRowKey,
endPartitionKey,
endRowKey,
signature,
accountKey.KeyName);
return(builder.ToString());
}
/// <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;
}
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);
}
public void Test_7()
{
var sut = new UriQueryBuilder("yahoo.com") { { "a", 1 }, { "b", null }, { "c", "yes" } };
Aver.AreEqual("yahoo.com?a=1&b&c=yes", sut.ToString());
}
public TResponse Get <TResponse>(UriQueryBuilder requestUri, bool throwOnHttpErrorCode = true)
{
return(Get <TResponse>(requestUri.ToString(), throwOnHttpErrorCode));
}
public void Test_8()
{
var sut = new UriQueryBuilder("yahoo.com") { { "a b", 1 }, { "c d", "Lenin is alive!" }};
Aver.AreEqual("yahoo.com?a%20b=1&c%20d=Lenin%20is%20alive%21", sut.ToString());
}
/// <summary>
/// Parses the query.
/// </summary>
/// <param name="queryParameters">The query parameters.</param>
internal static StorageCredentials ParseQuery(IDictionary<string, string> queryParameters)
{
bool sasParameterFound = false;
List<string> removeList = new List<string>();
foreach (KeyValuePair<string, string> parameter in queryParameters)
{
switch (parameter.Key.ToLower())
{
case Constants.QueryConstants.Signature:
sasParameterFound = true;
break;
case Constants.QueryConstants.ResourceType:
case Constants.QueryConstants.Component:
case Constants.QueryConstants.Snapshot:
case Constants.QueryConstants.ApiVersion:
removeList.Add(parameter.Key);
break;
default:
break;
}
}
foreach (string removeParam in removeList)
{
queryParameters.Remove(removeParam);
}
if (sasParameterFound)
{
UriQueryBuilder builder = new UriQueryBuilder();
foreach (KeyValuePair<string, string> parameter in queryParameters)
{
AddEscapedIfNotNull(builder, parameter.Key.ToLower(), parameter.Value);
}
return new StorageCredentials(builder.ToString());
}
return null;
}
/// <summary>
/// Parses the query.
/// </summary>
/// <param name="queryParameters">The query parameters.</param>
/// <param name="credentials">The credentials.</param>
internal static void ParseQuery(NameValueCollection queryParameters, out StorageCredentialsSharedAccessSignature credentials)
{
string signature = null;
string signedStart = null;
string signedExpiry = null;
string signedResource = null;
string sigendPermissions = null;
string signedIdentifier = null;
string signedVersion = null;
bool sasParameterFound = false;
credentials = null;
foreach (var key in queryParameters.AllKeys)
{
switch (key.ToLower())
{
case Constants.QueryConstants.SignedStart:
signedStart = queryParameters[key];
sasParameterFound = true;
break;
case Constants.QueryConstants.SignedExpiry:
signedExpiry = queryParameters[key];
sasParameterFound = true;
break;
case Constants.QueryConstants.SignedPermissions:
sigendPermissions = queryParameters[key];
sasParameterFound = true;
break;
case Constants.QueryConstants.SignedResource:
signedResource = queryParameters[key];
sasParameterFound = true;
break;
case Constants.QueryConstants.SignedIdentifier:
signedIdentifier = queryParameters[key];
sasParameterFound = true;
break;
case Constants.QueryConstants.Signature:
signature = queryParameters[key];
sasParameterFound = true;
break;
case Constants.QueryConstants.SignedVersion:
signedVersion = queryParameters[key];
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);
string token = builder.ToString();
credentials = new StorageCredentialsSharedAccessSignature(token);
}
}
/// <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);
}
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;
}
private async Task <bool> Send(bool post, string url, TimeSpan timeout, CancellationToken ct)
{
var urlBuilder = new UriBuilder(url);
var urlQueryBuilder = new UriQueryBuilder();
var queryPart1 = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(urlBuilder.Query);
foreach (var pair in queryPart1)
{
urlQueryBuilder.Add(pair.Key, pair.Value.FirstOrDefault());
}
var queryPart2 = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(_query);
foreach (var pair in queryPart2)
{
urlQueryBuilder.Add(pair.Key, pair.Value.FirstOrDefault());
}
urlBuilder.Query = urlQueryBuilder.ToString();
url = urlBuilder.ToString();
using (var client = new HttpClient()) {
client.Timeout = timeout;
if (_auth != null)
{
client.DefaultRequestHeaders.Authorization = _auth;
}
foreach (var ah in _hdrAccept)
{
client.DefaultRequestHeaders.Accept.Add(ah);
}
try {
_logger?.Trace($"Sending request to `{url}`");
if (post)
{
using (var res = new Result(await client.PostAsync(url, _body, ct))) {
if (_callbackFnc != null)
{
await _callbackFnc(res);
}
_callbackAct?.Invoke(res);
}
}
else
{
using (var res = new Result(await client.GetAsync(url, ct))) {
if (_callbackFnc != null)
{
await _callbackFnc(res);
}
_callbackAct?.Invoke(res);
}
}
} catch (Exception e) {
_logger?.Error(e, "Failed to send request to " + url);
}
}
return(false);
}
