private NameValueCollection Get(INameValueCollection coll)
{
var nv = new NameValueCollection(StringComparer.OrdinalIgnoreCase);
foreach (var key in coll.AllKeys)
{
nv[key] = coll[key];
}
return nv;
//return coll.ToNameValueCollection();
}
public TestAuthorizationRequest(AuthorizationContext authorizationContext, WebServerRequestType requestType, string url, INameValueCollection queryString, string resource = null)
{
UserIsInRole = false;
AuthorizationContext = authorizationContext;
Resource = resource;
RequestType = requestType;
Url = new Uri(url);
QueryString = queryString;
var principal = new Mock<IPrincipal>();
principal.Setup(p => p.Identity.Name).Returns("User");
principal.Setup(p => p.IsInRole(It.Is<string>(role => UserRoles.Contains(role)))).Returns(true);
principal.Setup(p => p.IsInRole(It.Is<string>(role => !UserRoles.Contains(role)))).Returns(false);
User = principal.Object;
}
public static string GenerateKeyAuthorizationSignature(string verb,
string resourceId,
string resourceType,
INameValueCollection headers,
IComputeHash stringHMACSHA256Helper,
out MemoryStream payload)
{
string authorizationToken = AuthorizationHelper.GenerateAuthorizationTokenWithHashCore(
verb,
resourceId,
resourceType,
headers,
stringHMACSHA256Helper,
out payload);
return(HttpUtility.UrlEncode(string.Format(CultureInfo.InvariantCulture, Constants.Properties.AuthorizationFormat,
Constants.Properties.MasterToken,
Constants.Properties.TokenVersion,
authorizationToken)));
}
internal DocumentFeedResponse(
IEnumerable <T> result,
int count,
INameValueCollection responseHeaders,
bool useETagAsContinuation = false,
IReadOnlyDictionary <string, QueryMetrics> queryMetrics = null,
IClientSideRequestStatistics requestStats = null,
string disallowContinuationTokenMessage = null,
long responseLengthBytes = 0)
: this(result)
{
this.Count = count;
this.responseHeaders = (INameValueCollection)responseHeaders.Clone();
this.usageHeaders = new Dictionary <string, long>();
this.quotaHeaders = new Dictionary <string, long>();
this.useETagAsContinuation = useETagAsContinuation;
this.queryMetrics = queryMetrics;
this.disallowContinuationTokenMessage = disallowContinuationTokenMessage;
this.ResponseLengthBytes = responseLengthBytes;
}
public static void SerializeMessagePayload(
MemoryStream stream,
string verb,
string resourceId,
string resourceType,
INameValueCollection headers,
bool bUseUtcNowForMissingXDate = false)
{
string xDate = AuthorizationHelper.GetHeaderValue(headers, HttpConstants.HttpHeaders.XDate);
string date = AuthorizationHelper.GetHeaderValue(headers, HttpConstants.HttpHeaders.HttpDate);
// At-least one of date header should present
// https://docs.microsoft.com/en-us/rest/api/documentdb/access-control-on-documentdb-resources
if (string.IsNullOrEmpty(xDate) && string.IsNullOrWhiteSpace(date))
{
if (!bUseUtcNowForMissingXDate)
{
throw new UnauthorizedException(RMResources.InvalidDateHeader);
}
headers[HttpConstants.HttpHeaders.XDate] = DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture);
xDate = AuthorizationHelper.GetHeaderValue(headers, HttpConstants.HttpHeaders.XDate);
}
// for name based, it is case sensitive, we won't use the lower case
if (!PathsHelper.IsNameBased(resourceId))
{
resourceId = resourceId.ToLowerInvariant();
}
stream.Write(verb.ToLowerInvariant());
stream.Write("\n");
stream.Write(resourceType.ToLowerInvariant());
stream.Write("\n");
stream.Write(resourceId);
stream.Write("\n");
stream.Write(xDate.ToLowerInvariant());
stream.Write("\n");
stream.Write(xDate.Equals(string.Empty, StringComparison.OrdinalIgnoreCase) ? date.ToLowerInvariant() : string.Empty);
stream.Write("\n");
}
// This API is a helper method to create auth header based on client request.
// Uri is split into resourceType/resourceId -
// For feed/post/put requests, resourceId = parentId,
// For point get requests, resourceId = last segment in URI
public static string GenerateKeyAuthorizationSignature(string verb,
Uri uri,
INameValueCollection headers,
IComputeHash stringHMACSHA256Helper,
string clientVersion = "")
{
if (string.IsNullOrEmpty(verb))
{
throw new ArgumentException(RMResources.StringArgumentNullOrEmpty, "verb");
}
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (stringHMACSHA256Helper == null)
{
throw new ArgumentNullException("stringHMACSHA256Helper");
}
if (headers == null)
{
throw new ArgumentNullException("headers");
}
string resourceType = string.Empty;
string resourceIdValue = string.Empty;
bool isNameBased = false;
AuthorizationHelper.GetResourceTypeAndIdOrFullName(uri, out isNameBased, out resourceType, out resourceIdValue, clientVersion);
string payload;
return(AuthorizationHelper.GenerateKeyAuthorizationSignature(verb,
resourceIdValue,
resourceType,
headers,
stringHMACSHA256Helper,
out payload));
}
public static bool CheckPayloadUsingKey(string inputToken,
string verb,
string resourceId,
string resourceType,
INameValueCollection headers,
string key)
{
string payload;
string requestBasedToken = AuthorizationHelper.GenerateKeyAuthorizationSignature(
verb,
resourceId,
resourceType,
headers,
key,
out payload);
requestBasedToken = HttpUtility.UrlDecode(requestBasedToken);
requestBasedToken = requestBasedToken.Substring(requestBasedToken.IndexOf("sig=", StringComparison.OrdinalIgnoreCase) + 4);
return(inputToken.Equals(requestBasedToken, StringComparison.OrdinalIgnoreCase));
}
public static string GenerateKeyAuthorizationSignature(string verb,
string resourceId,
string resourceType,
INameValueCollection headers,
IComputeHash stringHMACSHA256Helper,
out string payload)
{
string authorizationToken = AuthorizationHelper.GenerateUrlEncodedAuthorizationTokenWithHashCore(
verb,
resourceId,
resourceType,
headers,
stringHMACSHA256Helper,
out ArrayOwner payloadStream);
using (payloadStream)
{
payload = AuthorizationHelper.AuthorizationEncoding.GetString(payloadStream.Buffer.Array, payloadStream.Buffer.Offset, (int)payloadStream.Buffer.Count);
return(AuthorizationHelper.AuthorizationFormatPrefixUrlEncoded + authorizationToken);
}
}
public static string GenerateKeyAuthorizationSignature(string verb,
string resourceId,
string resourceType,
INameValueCollection headers,
string key,
bool bUseUtcNowForMissingXDate = false)
{
string authorizationToken = AuthorizationHelper.GenerateKeyAuthorizationCore(
verb,
resourceId,
resourceType,
headers,
key,
out _,
bUseUtcNowForMissingXDate);
return(HttpUtility.UrlEncode(string.Format(CultureInfo.InvariantCulture, Constants.Properties.AuthorizationFormat,
Constants.Properties.MasterToken,
Constants.Properties.TokenVersion,
authorizationToken)));
}
// This API is a helper method to create auth header based on client request.
// Uri is split into resourceType/resourceId -
// For feed/post/put requests, resourceId = parentId,
// For point get requests, resourceId = last segment in URI
public static string GenerateKeyAuthorizationSignature(string verb,
Uri uri,
INameValueCollection headers,
IComputeHash stringHMACSHA256Helper,
string clientVersion = "")
{
if (string.IsNullOrEmpty(verb))
{
throw new ArgumentException(RMResources.StringArgumentNullOrEmpty, nameof(verb));
}
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
if (stringHMACSHA256Helper == null)
{
throw new ArgumentNullException(nameof(stringHMACSHA256Helper));
}
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
AuthorizationHelper.GetResourceTypeAndIdOrFullName(uri, out _, out string resourceType, out string resourceIdValue, clientVersion);
string authorizationToken = AuthorizationHelper.GenerateKeyAuthorizationSignature(verb,
resourceIdValue,
resourceType,
headers,
stringHMACSHA256Helper,
out ArrayOwner arrayOwner);
using (arrayOwner)
{
return(authorizationToken);
}
}
public override Task <HttpResponseMessage> GetAsync(
Uri uri,
INameValueCollection additionalHeaders,
ResourceType resourceType,
HttpTimeoutPolicy timeoutPolicy,
CosmosDiagnosticsContext diagnosticsContext,
CancellationToken cancellationToken)
{
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
// GetAsync doesn't let clients to pass in additional headers. So, we are
// internally using SendAsync and add the additional headers to requestMessage.
ValueTask <HttpRequestMessage> CreateRequestMessage()
{
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, uri);
if (additionalHeaders != null)
{
foreach (string header in additionalHeaders)
{
if (GatewayStoreClient.IsAllowedRequestHeader(header))
{
requestMessage.Headers.TryAddWithoutValidation(header, additionalHeaders[header]);
}
}
}
return(new ValueTask <HttpRequestMessage>(requestMessage));
}
return(this.SendHttpAsync(
CreateRequestMessage,
resourceType,
timeoutPolicy,
diagnosticsContext,
cancellationToken));
}
private void CaptureSessionToken(DocumentServiceRequest request, INameValueCollection responseHeaders)
{
if (request.ResourceType == ResourceType.Collection && request.OperationType == OperationType.Delete)
{
string resourceId;
if (request.IsNameBased)
{
resourceId = responseHeaders[HttpConstants.HttpHeaders.OwnerId];
}
else
{
resourceId = request.ResourceId;
}
this.sessionContainer.ClearTokenByResourceId(resourceId);
}
else
{
this.sessionContainer.SetSessionToken(request, responseHeaders);
}
}
private DocumentServiceRequest CreateReadFeedDocumentServiceRequest(INameValueCollection requestHeaders)
{
if (this.resourceTypeEnum == Microsoft.Azure.Cosmos.Internal.ResourceType.Database ||
this.resourceTypeEnum == Microsoft.Azure.Cosmos.Internal.ResourceType.Offer)
{
return(DocumentServiceRequest.Create(
OperationType.ReadFeed,
null,
this.resourceTypeEnum,
AuthorizationTokenType.PrimaryMasterKey,
requestHeaders));
}
else
{
return(DocumentServiceRequest.Create(
OperationType.ReadFeed,
this.resourceTypeEnum,
this.resourceLink,
AuthorizationTokenType.PrimaryMasterKey,
requestHeaders));
}
}
// This API is a helper method to create auth header based on client request.
// Uri is split into resourceType/resourceId -
// For feed/post/put requests, resourceId = parentId,
// For point get requests, resourceId = last segment in URI
public static string GenerateGatewayAuthSignatureWithAddressResolution(string verb,
Uri uri,
INameValueCollection headers,
IComputeHash stringHMACSHA256Helper,
string clientVersion = "")
{
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
// Address request has the URI fragment (dbs/dbid/colls/colId...) as part of
// either $resolveFor 'or' $generate queries of the context.RequestUri.
// Extracting out the URI in the form https://localhost/dbs/dbid/colls/colId/docs to generate the signature.
// Authorizer uses the same URI to verify signature.
if (uri.AbsolutePath.Equals(Paths.Address_Root, StringComparison.OrdinalIgnoreCase))
{
uri = AuthorizationHelper.GenerateUriFromAddressRequestUri(uri);
}
return(GenerateKeyAuthorizationSignature(verb, uri, headers, stringHMACSHA256Helper, clientVersion));
}
protected ServiceClientBase()
{
this.HttpMethod = DefaultHttpMethod;
this.Headers = PclExportClient.Instance.NewNameValueCollection();
asyncClient = new AsyncServiceClient
{
ContentType = ContentType,
StreamSerializer = AsyncSerializeToStream,
StreamDeserializer = AsyncDeserializeFromStream,
UserName = this.UserName,
Password = this.Password,
RequestFilter = this.RequestFilter,
ResponseFilter = this.ResponseFilter,
Headers = this.Headers,
};
this.CookieContainer = new CookieContainer();
this.StoreCookies = true; //leave
this.UserAgent = DefaultUserAgent;
asyncClient.HandleCallbackOnUiThread = this.HandleCallbackOnUiThread = true;
asyncClient.ShareCookiesWithBrowser = this.ShareCookiesWithBrowser = true;
}
public void TestSetAndGetKnownProperties(HeaderType headerType)
{
string value1 = Guid.NewGuid().ToString();
string value2 = Guid.NewGuid().ToString();
string value3 = Guid.NewGuid().ToString();
INameValueCollection headers = this.CreateHeaders(headerType);
headers.Add(HttpConstants.HttpHeaders.Continuation, value1);
headers.Add(HttpConstants.HttpHeaders.PartitionKey, value2);
headers.Add(WFConstants.BackendHeaders.PartitionKeyRangeId, value3);
Assert.AreEqual(value1, headers[HttpConstants.HttpHeaders.Continuation]);
Assert.AreEqual(value2, headers[HttpConstants.HttpHeaders.PartitionKey]);
Assert.AreEqual(value3, headers[WFConstants.BackendHeaders.PartitionKeyRangeId]);
value1 = Guid.NewGuid().ToString();
value2 = Guid.NewGuid().ToString();
value3 = Guid.NewGuid().ToString();
headers[HttpConstants.HttpHeaders.Continuation] = value1;
headers[HttpConstants.HttpHeaders.PartitionKey] = value2;
headers[WFConstants.BackendHeaders.PartitionKeyRangeId] = value3;
Assert.AreEqual(value1, headers[HttpConstants.HttpHeaders.Continuation]);
Assert.AreEqual(value2, headers[HttpConstants.HttpHeaders.PartitionKey]);
Assert.AreEqual(value3, headers[WFConstants.BackendHeaders.PartitionKeyRangeId]);
}
public override ValueTask <string> GetUserAuthorizationTokenAsync(
string resourceAddress,
string resourceType,
string requestVerb,
INameValueCollection headers,
AuthorizationTokenType tokenType,
ITrace trace)
{
// this is masterkey authZ
headers[HttpConstants.HttpHeaders.XDate] = DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture);
string authorizationToken = AuthorizationHelper.GenerateKeyAuthorizationSignature(
requestVerb,
resourceAddress,
resourceType,
headers,
this.authKeyHashFunction,
out AuthorizationHelper.ArrayOwner arrayOwner);
using (arrayOwner)
{
return(new ValueTask <string>(authorizationToken));
}
}
internal static async Task <DocumentServiceResponse> ParseResponseAsync(HttpResponseMessage responseMessage, JsonSerializerSettings serializerSettings = null, DocumentServiceRequest request = null)
{
using (responseMessage)
{
IClientSideRequestStatistics requestStatistics = request?.RequestContext?.ClientRequestStatistics;
if ((int)responseMessage.StatusCode < 400)
{
INameValueCollection headers = GatewayStoreClient.ExtractResponseHeaders(responseMessage);
Stream contentStream = await GatewayStoreClient.BufferContentIfAvailableAsync(responseMessage);
return(new DocumentServiceResponse(
body: contentStream,
headers: headers,
statusCode: responseMessage.StatusCode,
clientSideRequestStatistics: requestStatistics,
serializerSettings: serializerSettings));
}
else if (request != null &&
request.IsValidStatusCodeForExceptionlessRetry((int)responseMessage.StatusCode))
{
INameValueCollection headers = GatewayStoreClient.ExtractResponseHeaders(responseMessage);
Stream contentStream = await GatewayStoreClient.BufferContentIfAvailableAsync(responseMessage);
return(new DocumentServiceResponse(
body: contentStream,
headers: headers,
statusCode: responseMessage.StatusCode,
clientSideRequestStatistics: requestStatistics,
serializerSettings: serializerSettings));
}
else
{
throw await GatewayStoreClient.CreateDocumentClientExceptionAsync(responseMessage, requestStatistics);
}
}
}
ValueTask <string> ICosmosAuthorizationTokenProvider.GetUserAuthorizationTokenAsync(
string resourceAddress,
string resourceType,
string requestVerb,
INameValueCollection headers,
AuthorizationTokenType tokenType,
CosmosDiagnosticsContext diagnosticsContext) // unused, use token based upon what is passed in constructor
{
// this is masterkey authZ
headers[HttpConstants.HttpHeaders.XDate] = DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture);
string authorization = AuthorizationHelper.GenerateKeyAuthorizationSignature(
verb: requestVerb,
resourceId: resourceAddress,
resourceType: resourceType,
headers: headers,
stringHMACSHA256Helper: this.authKeyHashFunction,
payload: out AuthorizationHelper.ArrayOwner payload);
using (payload)
{
return(new ValueTask <string>(authorization));
}
}
public static string GenerateKeyAuthorizationSignature(string verb,
string resourceId,
string resourceType,
INameValueCollection headers,
IComputeHash stringHMACSHA256Helper,
out string payload)
{
string authorizationToken = AuthorizationHelper.GenerateAuthorizationTokenWithHashCore(
verb,
resourceId,
resourceType,
headers,
stringHMACSHA256Helper,
out ArrayOwner payloadStream);
using (payloadStream)
{
payload = AuthorizationHelper.AuthorizationEncoding.GetString(payloadStream.Buffer.Array, payloadStream.Buffer.Offset, (int)payloadStream.Buffer.Count);
return(HttpUtility.UrlEncode(string.Format(CultureInfo.InvariantCulture, Constants.Properties.AuthorizationFormat,
Constants.Properties.MasterToken,
Constants.Properties.TokenVersion,
authorizationToken)));
}
}
private static string ToQueryString(INameValueCollection queryStringCollection)
{
return(ToQueryString((NameValueCollection)queryStringCollection.Original));
}
public JsonHttpClient()
{
this.Headers = PclExportClient.Instance.NewNameValueCollection();
this.CookieContainer = new CookieContainer();
}
private async Task <DocumentServiceResponse> ExecutePartitionKeyRangeReadChangeFeedAsync(string collectionRid,
INameValueCollection headers,
ITrace trace,
IClientSideRequestStatistics clientSideRequestStatistics)
{
using (ITrace childTrace = trace.StartChild("Read PartitionKeyRange Change Feed", TraceComponent.Transport, Tracing.TraceLevel.Info))
{
using (DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.ReadFeed,
collectionRid,
ResourceType.PartitionKeyRange,
AuthorizationTokenType.PrimaryMasterKey,
headers))
{
string authorizationToken = null;
try
{
authorizationToken = await this.authorizationTokenProvider.GetUserAuthorizationTokenAsync(
request.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
HttpConstants.HttpMethods.Get,
request.Headers,
AuthorizationTokenType.PrimaryMasterKey,
childTrace);
}
catch (UnauthorizedException)
{
}
if (authorizationToken == null)
{
// User doesn't have rid based resource token. Maybe he has name based.
throw new NotSupportedException("Resource tokens are not supported");
////CosmosContainerSettings collection = await this.collectionCache.ResolveCollectionAsync(request, CancellationToken.None);
////authorizationToken =
//// this.authorizationTokenProvider.GetUserAuthorizationTokenAsync(
//// collection.AltLink,
//// PathsHelper.GetResourcePath(request.ResourceType),
//// HttpConstants.HttpMethods.Get,
//// request.Headers,
//// AuthorizationTokenType.PrimaryMasterKey);
}
request.Headers[HttpConstants.HttpHeaders.Authorization] = authorizationToken;
request.RequestContext.ClientRequestStatistics = clientSideRequestStatistics ?? new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow);
if (clientSideRequestStatistics == null)
{
childTrace.AddDatum("Client Side Request Stats", request.RequestContext.ClientRequestStatistics);
}
using (new ActivityScope(Guid.NewGuid()))
{
try
{
return(await this.storeModel.ProcessMessageAsync(request));
}
catch (DocumentClientException ex)
{
childTrace.AddDatum("Exception Message", ex.Message);
throw;
}
}
}
}
}
public static NameValueCollection ToNameValueCollection(this INameValueCollection nvc)
{
return((NameValueCollection)nvc.Original);
}
private DocumentServiceResponse ReadDocumentRequest(DocumentClient client, Document doc, INameValueCollection headers)
{
DocumentServiceRequest request = DocumentServiceRequest.Create(OperationType.Read, ResourceType.Document, doc.SelfLink, AuthorizationTokenType.PrimaryMasterKey, headers);
request.Headers.Set(HttpConstants.HttpHeaders.PartitionKey, (new PartitionKey(doc.Id)).InternalKey.ToJsonString());
var retrievedDocResponse = client.ReadAsync(request, null).Result;
return(retrievedDocResponse);
}
private StoredProcedureResponse <string> CreateDocumentScript(DocumentClient client, INameValueCollection headers)
{
var headersIterator = headers.AllKeys().SelectMany(headers.GetValues, (k, v) => new { key = k, value = v });
var scriptOptions = "{";
var headerIndex = 0;
foreach (var header in headersIterator)
{
if (headerIndex != 0)
{
scriptOptions += ", ";
}
headerIndex++;
scriptOptions += header.key + ":" + header.value;
}
scriptOptions += "}";
var guid = Guid.NewGuid().ToString();
var script = @" function() {
var client = getContext().getCollection();
client.createDocument(client.getSelfLink(), { id: ""TestDoc"" }," + scriptOptions + @", function(err, docCreated, options) {
if(err) throw new Error('Error while creating document: ' + err.message);
else {
getContext().getResponse().setBody(JSON.stringify(docCreated));
}
});}";
Database database = client.CreateDatabaseAsync(new Database {
Id = Guid.NewGuid().ToString()
}).Result;
PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition {
Paths = new System.Collections.ObjectModel.Collection <string>(new[] { "/id" }), Kind = PartitionKind.Hash
};
DocumentCollection collection = client.CreateDocumentCollectionAsync(database.SelfLink,
new DocumentCollection
{
Id = Guid.NewGuid().ToString(),
PartitionKey = partitionKeyDefinition
}).Result;
var sproc = new StoredProcedure()
{
Id = Guid.NewGuid().ToString(), Body = script
};
var createdSproc = client.CreateStoredProcedureAsync(collection, sproc).Result.Resource;
RequestOptions requestOptions = new RequestOptions();
requestOptions.PartitionKey = new PartitionKey("TestDoc");
var result = client.ExecuteStoredProcedureAsync <string>(createdSproc, requestOptions).Result;
return(result);
}
public static Dictionary<string, string> ToDictionary(INameValueCollection nvc)
{
var map = new Dictionary<string, string>();
for (var i = 0; i < nvc.Count; i++)
{
map[nvc.GetKey(i)] = nvc.Get(i);
}
return map;
}
private DocumentServiceResponse ReadDatabaseFeedRequest(DocumentClient client, INameValueCollection headers)
{
DocumentServiceRequest request = DocumentServiceRequest.Create(OperationType.ReadFeed, null, ResourceType.Database, AuthorizationTokenType.PrimaryMasterKey, headers);
var response = client.ReadFeedAsync(request, null).Result;
return(response);
}
private DocumentServiceResponse ReadDocumentFeedRequest(DocumentClient client, string collectionId, INameValueCollection headers)
{
DocumentServiceRequest request = DocumentServiceRequest.Create(OperationType.ReadFeed, collectionId, ResourceType.Document, AuthorizationTokenType.PrimaryMasterKey, headers);
Range <string> fullRange = new Range <string>(
PartitionKeyInternal.MinimumInclusiveEffectivePartitionKey,
PartitionKeyInternal.MaximumExclusiveEffectivePartitionKey,
true,
false);
IRoutingMapProvider routingMapProvider = client.GetPartitionKeyRangeCacheAsync().Result;
IReadOnlyList <PartitionKeyRange> ranges = routingMapProvider.TryGetOverlappingRangesAsync(collectionId, fullRange).Result;
request.RouteTo(new PartitionKeyRangeIdentity(collectionId, ranges.First().Id));
var response = client.ReadFeedAsync(request, null).Result;
return(response);
}
public static string ToString(INameValueCollection nvc)
{
var map = ToDictionary(nvc);
return(TypeSerializer.SerializeToString(map));
}
public static Dictionary <string, string> ToDictionary(this INameValueCollection nameValues)
{
return(ToDictionary((NameValueCollection)nameValues.Original));
}
private static string GenerateKeyAuthorizationCore(
string verb,
string resourceId,
string resourceType,
INameValueCollection headers,
string key,
out ArraySegment <byte> payload,
bool bUseUtcNowForMissingXDate = false)
{
string authorizationToken;
// resourceId can be null for feed-read of /dbs
if (string.IsNullOrEmpty(verb))
{
throw new ArgumentException(RMResources.StringArgumentNullOrEmpty, nameof(verb));
}
if (resourceType == null)
{
throw new ArgumentNullException(nameof(resourceType)); // can be empty
}
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException(RMResources.StringArgumentNullOrEmpty, nameof(key));
}
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
byte[] keyBytes = Convert.FromBase64String(key);
using (HMACSHA256 hmacSha256 = new HMACSHA256(keyBytes))
{
// Order of the values included in the message payload is a protocol that clients/BE need to follow exactly.
// More headers can be added in the future.
// If any of the value is optional, it should still have the placeholder value of ""
// OperationType -> ResourceType -> ResourceId/OwnerId -> XDate -> Date
string verbInput = verb ?? string.Empty;
string resourceIdInput = resourceId ?? string.Empty;
string resourceTypeInput = resourceType ?? string.Empty;
string authResourceId = AuthorizationHelper.GetAuthorizationResourceIdOrFullName(resourceTypeInput, resourceIdInput);
int memoryStreamCapacity = AuthorizationHelper.ComputeMemoryCapacity(verbInput, authResourceId, resourceTypeInput);
byte[] buffer = ArrayPool <byte> .Shared.Rent(memoryStreamCapacity);
using ArrayOwner owner = new ArrayOwner(ArrayPool <byte> .Shared, new ArraySegment <byte>(buffer, 0, buffer.Length));
Span <byte> payloadBytes = buffer;
int length = AuthorizationHelper.SerializeMessagePayload(
payloadBytes,
verbInput,
authResourceId,
resourceTypeInput,
headers);
byte[] hashPayLoad = hmacSha256.ComputeHash(buffer, 0, length);
authorizationToken = Convert.ToBase64String(hashPayLoad);
}
return(authorizationToken);
}
public object CreateFromMap(INameValueCollection nameValues)
{
return PopulateFromMap(null, nameValues, null);
}
public object PopulateFromMap(object instance, INameValueCollection nameValues, List<string> ignoredWarningsOnPropertyNames = null)
{
var errors = new List<RequestBindingError>();
PropertySerializerEntry propertySerializerEntry = null;
if (instance == null)
instance = type.CreateInstance();
foreach (var key in nameValues.AllKeys)
{
string value = nameValues[key];
if (!string.IsNullOrEmpty(value))
{
instance = PopulateFromKeyValue(instance, key, value,
out propertySerializerEntry, errors, ignoredWarningsOnPropertyNames);
}
}
if (errors.Count > 0)
{
var serializationException = new SerializationException($"Unable to bind to request '{type.Name}'");
serializationException.Data.Add("errors", errors);
throw serializationException;
}
return instance;
}
private StoredProcedureResponse <string> ReadFeedScript(DocumentClient client, INameValueCollection headers)
{
var headersIterator = headers.AllKeys().SelectMany(headers.GetValues, (k, v) => new { key = k, value = v });
var scriptOptions = "{";
var headerIndex = 0;
foreach (var header in headersIterator)
{
if (headerIndex != 0)
{
scriptOptions += ", ";
}
headerIndex++;
scriptOptions += header.key + ":" + header.value;
}
scriptOptions += "}";
var script = @"function() {
var client = getContext().getCollection();
function callback(err, docFeed, responseOptions) {
if(err) throw 'Error while reading documents';
docFeed.forEach(function(doc, i, arr) { getContext().getResponse().appendBody(JSON.stringify(doc)); });
};
client.readDocuments(client.getSelfLink()," + scriptOptions + @", callback);}";
Database database = client.CreateDatabaseAsync(new Database {
Id = Guid.NewGuid().ToString()
}).Result;
PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition {
Paths = new System.Collections.ObjectModel.Collection <string>(new[] { "/id" }), Kind = PartitionKind.Hash
};
DocumentCollection collection = client.CreateDocumentCollectionAsync(database.SelfLink,
new DocumentCollection
{
Id = Guid.NewGuid().ToString(),
PartitionKey = partitionKeyDefinition
}).Result;
var sproc = new StoredProcedure()
{
Id = Guid.NewGuid().ToString(), Body = script
};
var createdSproc = client.CreateStoredProcedureAsync(collection, sproc).Result.Resource;
RequestOptions requestOptions = new RequestOptions();
requestOptions.PartitionKey = new PartitionKey("test");
var result = client.ExecuteStoredProcedureAsync <string>(createdSproc, requestOptions).Result;
return(result);
}
private static string ToQueryString(INameValueCollection queryStringCollection)
{
return ToQueryString((NameValueCollection)queryStringCollection.Original);
}
public static string ToString(INameValueCollection nvc)
{
var map = ToDictionary(nvc);
return TypeSerializer.SerializeToString(map);
}
