public virtual async Task <T> SendAsync <T>( Uri resourceUri, ResourceType resourceType, OperationType operationType, RequestOptions requestOptions, CosmosContainerCore cosmosContainerCore, Cosmos.PartitionKey partitionKey, Stream streamPayload, Action <CosmosRequestMessage> requestEnricher, Func <CosmosResponseMessage, T> responseCreator, CancellationToken cancellationToken = default(CancellationToken)) { if (responseCreator == null) { throw new ArgumentNullException(nameof(responseCreator)); } CosmosResponseMessage responseMessage = await this.SendAsync( resourceUri : resourceUri, resourceType : resourceType, operationType : operationType, requestOptions : requestOptions, cosmosContainerCore : cosmosContainerCore, partitionKey : partitionKey, streamPayload : streamPayload, requestEnricher : requestEnricher, cancellationToken : cancellationToken); return(responseCreator(responseMessage)); }
internal CosmosChangeFeedResultSetIteratorCoreMock( CosmosContainerCore cosmosContainer, string continuationToken, int?maxItemCount, CosmosChangeFeedRequestOptions options) : base(cosmosContainer, continuationToken, maxItemCount, options) { List <CompositeContinuationToken> compositeContinuationTokens = new List <CompositeContinuationToken>() { new CompositeContinuationToken() { Token = null, Range = new Documents.Routing.Range <string>("A", "B", true, false) } }; string serialized = JsonConvert.SerializeObject(compositeContinuationTokens); this.compositeContinuationToken = StandByFeedContinuationToken.CreateAsync("containerRid", serialized, (string containerRid, Documents.Routing.Range <string> ranges, bool forceRefresh) => { IReadOnlyList <Documents.PartitionKeyRange> filteredRanges = new List <Documents.PartitionKeyRange>() { new Documents.PartitionKeyRange() { MinInclusive = "A", MaxExclusive = "B", Id = "0" } }; if (forceRefresh) { this.HasCalledForceRefresh = true; } return(Task.FromResult(filteredRanges)); }).Result; }
public static ChangeFeedPartitionKeyResultSetIteratorCore BuildResultSetIterator( string partitionKeyRangeId, string continuationToken, int?maxItemCount, CosmosContainerCore cosmosContainer, DateTime?startTime, bool startFromBeginning) { ChangeFeedRequestOptions requestOptions = new ChangeFeedRequestOptions(); if (startTime.HasValue) { requestOptions.StartTime = startTime.Value; } else if (startFromBeginning) { requestOptions.StartTime = DateTime.MinValue; } return(new ChangeFeedPartitionKeyResultSetIteratorCore( partitionKeyRangeId: partitionKeyRangeId, continuationToken: continuationToken, maxItemCount: maxItemCount, clientContext: cosmosContainer.ClientContext, cosmosContainer: cosmosContainer, options: requestOptions)); }
public async Task StandByFeedIterator_WithMaxItemCount() { await this.CreateRandomItems(2, randomPartitionKey : true); CosmosContainerCore itemsCore = (CosmosContainerCore)this.Container; FeedIterator feedIterator = itemsCore.GetStandByFeedIterator(maxItemCount: 1, requestOptions: new ChangeFeedRequestOptions() { StartTime = DateTime.MinValue }); while (feedIterator.HasMoreResults) { using (CosmosResponseMessage responseMessage = await feedIterator.FetchNextSetAsync(this.cancellationToken)) { if (responseMessage.IsSuccessStatusCode) { Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data; if (response.Count > 0) { Assert.AreEqual(1, response.Count); return; } } } } Assert.Fail("Found no batch with size 1"); }
public void ApplyBuildConfiguration( DocumentServiceLeaseStoreManager customDocumentServiceLeaseStoreManager, CosmosContainerCore leaseContainer, string monitoredContainerRid, string instanceName, ChangeFeedLeaseOptions changeFeedLeaseOptions, ChangeFeedProcessorOptions changeFeedProcessorOptions, CosmosContainerCore monitoredContainer) { if (monitoredContainer == null) { throw new ArgumentNullException(nameof(monitoredContainer)); } if (customDocumentServiceLeaseStoreManager == null && leaseContainer == null) { throw new ArgumentNullException(nameof(leaseContainer)); } if (instanceName == null) { throw new ArgumentNullException("InstanceName is required for the processor to initialize."); } this.documentServiceLeaseStoreManager = customDocumentServiceLeaseStoreManager; this.leaseContainer = leaseContainer; this.monitoredContainerRid = monitoredContainerRid; this.instanceName = instanceName; this.changeFeedProcessorOptions = changeFeedProcessorOptions; this.changeFeedLeaseOptions = changeFeedLeaseOptions; this.monitoredContainer = monitoredContainer; }
public async Task ContainerContractTest() { ContainerResponse response = await this.cosmosDatabase.CreateContainerAsync(new Guid().ToString(), "/id"); Assert.IsNotNull(response); Assert.IsTrue(response.RequestCharge > 0); Assert.IsNotNull(response.Headers); Assert.IsNotNull(response.Headers.ActivityId); CosmosContainerSettings containerSettings = response.Resource; Assert.IsNotNull(containerSettings.Id); Assert.IsNotNull(containerSettings.ResourceId); Assert.IsNotNull(containerSettings.ETag); Assert.IsTrue(containerSettings.LastModified.HasValue); Assert.IsNotNull(containerSettings.PartitionKeyPath); Assert.IsNotNull(containerSettings.PartitionKeyPathTokens); Assert.AreEqual(1, containerSettings.PartitionKeyPathTokens.Length); Assert.AreEqual("id", containerSettings.PartitionKeyPathTokens[0]); CosmosContainerCore containerCore = response.Container as CosmosContainerCore; Assert.IsNotNull(containerCore); Assert.IsNotNull(containerCore.LinkUri); Assert.IsFalse(containerCore.LinkUri.ToString().StartsWith("/")); Assert.IsTrue(containerSettings.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), containerSettings.LastModified.Value.ToString()); }
public override Task <CosmosResponseMessage> ExecuteStoredProcedureStreamAsync( Cosmos.PartitionKey partitionKey, string storedProcedureId, Stream streamPayload, StoredProcedureRequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken)) { if (string.IsNullOrEmpty(storedProcedureId)) { throw new ArgumentNullException(nameof(storedProcedureId)); } CosmosContainerCore.ValidatePartitionKey(partitionKey, requestOptions); Uri linkUri = this.clientContext.CreateLink( parentLink: this.container.LinkUri.OriginalString, uriPathSegment: Paths.StoredProceduresPathSegment, id: storedProcedureId); return(this.ProcessStreamOperationAsync( resourceUri: linkUri, resourceType: ResourceType.StoredProcedure, operationType: OperationType.ExecuteJavaScript, partitionKey: partitionKey, streamPayload: streamPayload, requestOptions: requestOptions, cancellationToken: cancellationToken)); }
public FeedProcessorFactoryCore( CosmosContainerCore container, ChangeFeedProcessorOptions changeFeedProcessorOptions, DocumentServiceLeaseCheckpointer leaseCheckpointer, CosmosJsonSerializer cosmosJsonSerializer) { if (container == null) { throw new ArgumentNullException(nameof(container)); } if (changeFeedProcessorOptions == null) { throw new ArgumentNullException(nameof(changeFeedProcessorOptions)); } if (leaseCheckpointer == null) { throw new ArgumentNullException(nameof(leaseCheckpointer)); } if (cosmosJsonSerializer == null) { throw new ArgumentNullException(nameof(cosmosJsonSerializer)); } this.container = container; this.changeFeedProcessorOptions = changeFeedProcessorOptions; this.leaseCheckpointer = leaseCheckpointer; this.cosmosJsonSerializer = cosmosJsonSerializer; }
internal CosmosScriptsCore( CosmosContainerCore container, CosmosClientContext clientContext) { this.container = container; this.clientContext = clientContext; }
public virtual async Task <CosmosResponseMessage> SendAsync( Uri resourceUri, ResourceType resourceType, OperationType operationType, RequestOptions requestOptions, CosmosContainerCore cosmosContainerCore, object partitionKey, Stream streamPayload, Action <CosmosRequestMessage> requestEnricher, CancellationToken cancellationToken = default(CancellationToken)) { if (resourceUri == null) { throw new ArgumentNullException(nameof(resourceUri)); } HttpMethod method = RequestInvokerHandler.GetHttpMethod(operationType); CosmosRequestMessage request = new CosmosRequestMessage(method, resourceUri) { OperationType = operationType, ResourceType = resourceType, RequestOptions = requestOptions, Content = streamPayload }; if (partitionKey != null) { if (cosmosContainerCore == null && Object.ReferenceEquals(partitionKey, CosmosContainerSettings.NonePartitionKeyValue)) { throw new ArgumentException($"{nameof(cosmosContainerCore)} can not be null with partition key as PartitionKey.None"); } else if (Object.ReferenceEquals(partitionKey, CosmosContainerSettings.NonePartitionKeyValue)) { try { PartitionKeyInternal partitionKeyInternal = await cosmosContainerCore.GetNonePartitionKeyValueAsync(cancellationToken); request.Headers.PartitionKey = partitionKeyInternal.ToJsonString(); } catch (DocumentClientException dce) { return(dce.ToCosmosResponseMessage(request)); } } else { PartitionKey pk = new PartitionKey(partitionKey); request.Headers.PartitionKey = pk.InternalKey.ToJsonString(); } } if (operationType == OperationType.Upsert) { request.Headers.IsUpsert = bool.TrueString; } requestEnricher?.Invoke(request); return(await this.SendAsync(request, cancellationToken)); }
public void ValidateUriGenerationForResources() { string databaseId = "db1234"; string crId = "cr42"; string spId = "sp9001"; string trId = "tr9002"; string udfId = "udf9003"; CosmosClient mockClient = MockDocumentClient.CreateMockCosmosClient(); CosmosDatabaseCore db = new CosmosDatabaseCore(mockClient, databaseId); Assert.AreEqual(db.LinkUri.OriginalString, "/dbs/" + databaseId); CosmosContainerCore container = new CosmosContainerCore(db, crId); Assert.AreEqual(container.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId); CosmosStoredProcedureCore sp = new CosmosStoredProcedureCore(container, spId); Assert.AreEqual(sp.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId + "/sprocs/" + spId); CosmosTrigger tr = new CosmosTrigger(container, trId); Assert.AreEqual(tr.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId + "/triggers/" + trId); CosmosUserDefinedFunction udf = new CosmosUserDefinedFunction(container, udfId); Assert.AreEqual(udf.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId + "/udfs/" + udfId); }
public CosmosLinqQueryProvider( CosmosContainerCore container, CosmosJsonSerializer cosmosJsonSerializer, CosmosQueryClient queryClient, QueryRequestOptions cosmosQueryRequestOptions, bool allowSynchronousQueryExecution) { this.container = container; this.cosmosJsonSerializer = cosmosJsonSerializer; this.queryClient = queryClient; this.cosmosQueryRequestOptions = cosmosQueryRequestOptions; this.allowSynchronousQueryExecution = allowSynchronousQueryExecution; }
public PartitionSynchronizerCore( CosmosContainerCore container, DocumentServiceLeaseContainer leaseContainer, DocumentServiceLeaseManager leaseManager, int degreeOfParallelism, int maxBatchSize) { this.container = container; this.leaseContainer = leaseContainer; this.leaseManager = leaseManager; this.degreeOfParallelism = degreeOfParallelism; this.maxBatchSize = maxBatchSize; }
public async Task ConflictsFeedSetsPartitionKeyRangeIdentity() { CosmosContainerCore container = CosmosConflictTests.GetMockedContainer((request, cancellationToken) => { Assert.IsNotNull(request.DocumentServiceRequest.PartitionKeyRangeIdentity); return(TestHandler.ReturnSuccess()); }); FeedIterator iterator = container.GetConflicts().GetConflictsStreamIterator(); while (iterator.HasMoreResults) { CosmosResponseMessage responseMessage = await iterator.FetchNextSetAsync(); } }
public async Task TestInitialize() { await base.TestInit(); string PartitionKey = "/status"; CosmosContainerResponse response = await this.database.Containers.CreateContainerAsync( new CosmosContainerSettings(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey), cancellationToken : this.cancellationToken); Assert.IsNotNull(response); Assert.IsNotNull(response.Container); Assert.IsNotNull(response.Resource); this.container = (CosmosContainerCore)response; }
public CosmosLinqQuery( CosmosContainerCore container, CosmosJsonSerializer cosmosJsonSerializer, CosmosQueryClient queryClient, QueryRequestOptions cosmosQueryRequestOptions, bool allowSynchronousQueryExecution) : this( container, cosmosJsonSerializer, queryClient, cosmosQueryRequestOptions, null, allowSynchronousQueryExecution) { }
public async Task StandByFeedIterator_NoFetchNext() { var pkRanges = await this.Container.ClientContext.DocumentClient.ReadPartitionKeyRangeFeedAsync(this.Container.LinkUri); int expected = 25; int iterations = 0; await this.CreateRandomItems(expected, randomPartitionKey : true); CosmosContainerCore itemsCore = (CosmosContainerCore)this.Container; string continuationToken = null; int count = 0; while (true) { ChangeFeedRequestOptions requestOptions = new ChangeFeedRequestOptions() { StartTime = DateTime.MinValue }; FeedIterator feedIterator = itemsCore.GetStandByFeedIterator(continuationToken, requestOptions: requestOptions); using (CosmosResponseMessage responseMessage = await feedIterator.FetchNextSetAsync(this.cancellationToken)) { continuationToken = responseMessage.Headers.Continuation; if (responseMessage.IsSuccessStatusCode) { Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data; count += response.Count; } } if (count > expected) { Assert.Fail($"{count} does not equal {expected}"); } if (count.Equals(expected)) { break; } if (iterations++ > pkRanges.Count) { Assert.Fail("Feed does not contain all elements even after looping through PK ranges. Either the continuation is not moving forward or there is some state problem."); } } }
public FeedProcessorCore(ChangeFeedObserver <T> observer, CosmosContainerCore container, ProcessorSettings settings, PartitionCheckpointer checkpointer) { this.observer = observer; this.settings = settings; this.checkpointer = checkpointer; this.options = new ChangeFeedOptions { MaxItemCount = settings.MaxItemCount, PartitionKeyRangeId = settings.LeaseToken, SessionToken = settings.SessionToken, StartFromBeginning = settings.StartFromBeginning, RequestContinuation = settings.StartContinuation, StartTime = settings.StartTime, }; this.query = container.ClientContext.DocumentClient.CreateDocumentChangeFeedQuery(container.LinkUri.ToString(), this.options); }
public void ReadConflictContentDeserializesContent() { CosmosContainerCore container = CosmosConflictTests.GetMockedContainer((request, cancellationToken) => { return(TestHandler.ReturnSuccess()); }); JObject someJsonObject = new JObject(); someJsonObject["id"] = Guid.NewGuid().ToString(); someJsonObject["someInt"] = 2; CosmosConflictSettings conflictSettings = new CosmosConflictSettings(); conflictSettings.Content = someJsonObject.ToString(); Assert.AreEqual(someJsonObject.ToString(), container.GetConflicts().ReadConflictContent <JObject>(conflictSettings).ToString()); }
public async Task TestInitialize() { await base.TestInit(); ContainerResponse response = await this.database.CreateContainerAsync( new CosmosContainerSettings(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey), requestUnits : 50000, cancellationToken : this.cancellationToken); Assert.IsNotNull(response); Assert.IsNotNull(response.Container); Assert.IsNotNull(response.Resource); this.Container = (CosmosContainerCore)response; DocumentFeedResponse <PartitionKeyRange> pkRangesFeed = await this.cosmosClient.DocumentClient.ReadPartitionKeyRangeFeedAsync(this.Container.LinkUri); Assert.IsTrue(pkRangesFeed.Count > 1, "Refresh container throughput to have at-least > 1 pk-range"); }
public async Task DeleteSendsCorrectPayload() { const string expectedId = "something"; const string partitionKey = "pk"; Uri expectedRequestUri = new Uri($"/dbs/conflictsDb/colls/conflictsColl/conflicts/{expectedId}", UriKind.Relative); CosmosContainerCore container = CosmosConflictTests.GetMockedContainer((request, cancellationToken) => { Assert.AreEqual(OperationType.Delete, request.OperationType); Assert.AreEqual(ResourceType.Conflict, request.ResourceType); Assert.AreEqual(expectedRequestUri, request.RequestUri); return(TestHandler.ReturnSuccess()); }); CosmosConflictSettings conflictSettings = new CosmosConflictSettings(); conflictSettings.Id = expectedId; await container.Conflicts.DeleteConflictAsync(partitionKey, conflictSettings); }
public override Task <StoredProcedureExecuteResponse <TOutput> > ExecuteStoredProcedureAsync <TInput, TOutput>( Cosmos.PartitionKey partitionKey, string id, TInput input, StoredProcedureRequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken)) { if (string.IsNullOrEmpty(id)) { throw new ArgumentNullException(nameof(id)); } CosmosContainerCore.ValidatePartitionKey(partitionKey, requestOptions); Stream parametersStream; if (input != null && !input.GetType().IsArray) { parametersStream = this.clientContext.CosmosSerializer.ToStream <TInput[]>(new TInput[1] { input }); } else { parametersStream = this.clientContext.CosmosSerializer.ToStream <TInput>(input); } Uri linkUri = this.clientContext.CreateLink( parentLink: this.container.LinkUri.OriginalString, uriPathSegment: Paths.StoredProceduresPathSegment, id: id); Task <CosmosResponseMessage> response = this.ProcessStreamOperationAsync( resourceUri: linkUri, resourceType: ResourceType.StoredProcedure, operationType: OperationType.ExecuteJavaScript, partitionKey: partitionKey, streamPayload: parametersStream, requestOptions: requestOptions, cancellationToken: cancellationToken); return(this.clientContext.ResponseFactory.CreateStoredProcedureExecuteResponseAsync <TOutput>(response)); }
public async Task ReadCurrentGetsCorrectRID() { const string expectedRID = "something"; const string partitionKey = "pk"; // Using "test" as container name because the Mocked DocumentClient has it hardcoded Uri expectedRequestUri = new Uri($"/dbs/conflictsDb/colls/test/docs/{expectedRID}", UriKind.Relative); CosmosContainerCore container = CosmosConflictTests.GetMockedContainer((request, cancellationToken) => { Assert.AreEqual(OperationType.Read, request.OperationType); Assert.AreEqual(ResourceType.Document, request.ResourceType); Assert.AreEqual(expectedRequestUri, request.RequestUri); return(TestHandler.ReturnSuccess()); }); CosmosConflictSettings conflictSettings = new CosmosConflictSettings(); conflictSettings.SourceResourceId = expectedRID; await container.Conflicts.ReadCurrentAsync <JObject>(partitionKey, conflictSettings); }
public RemainingWorkEstimatorCore( DocumentServiceLeaseContainer leaseContainer, CosmosContainerCore container, int degreeOfParallelism) { if (leaseContainer == null) { throw new ArgumentNullException(nameof(leaseContainer)); } if (container == null) { throw new ArgumentNullException(nameof(container)); } if (degreeOfParallelism < 1) { throw new ArgumentException("Degree of parallelism is out of range", nameof(degreeOfParallelism)); } this.leaseContainer = leaseContainer; this.container = container; this.degreeOfParallelism = degreeOfParallelism; }
public async Task TestInitialize() { this.cancellationTokenSource = new CancellationTokenSource(); this.cancellationToken = this.cancellationTokenSource.Token; this.cosmosClient = TestCommon.CreateCosmosClient(); this.database = await this.cosmosClient.Databases.CreateDatabaseAsync(Guid.NewGuid().ToString(), cancellationToken : this.cancellationToken); this.documentClient = TestCommon.CreateClient(true, defaultConsistencyLevel: Documents.ConsistencyLevel.Session); string PartitionKey = "/partitionKey"; ContainerResponse response = await this.database.Containers.CreateContainerAsync( new CosmosContainerSettings(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey), cancellationToken : this.cancellationToken); Assert.IsNotNull(response); Assert.IsNotNull(response.Container); Assert.IsNotNull(response.Resource); this.Container = (CosmosContainerCore)response; this.jsonSerializer = new CosmosJsonSerializerCore(); }
public CosmosLinqQuery( CosmosContainerCore container, CosmosJsonSerializer cosmosJsonSerializer, CosmosQueryClient queryClient, QueryRequestOptions cosmosQueryRequestOptions, Expression expression, bool allowSynchronousQueryExecution) { this.container = container ?? throw new ArgumentNullException(nameof(container)); this.cosmosJsonSerializer = cosmosJsonSerializer; this.queryClient = queryClient; this.cosmosQueryRequestOptions = cosmosQueryRequestOptions; this.expression = expression ?? Expression.Constant(this); this.allowSynchronousQueryExecution = allowSynchronousQueryExecution; this.queryProvider = new CosmosLinqQueryProvider( container, cosmosJsonSerializer, queryClient, cosmosQueryRequestOptions, this.allowSynchronousQueryExecution); this.correlatedActivityId = Guid.NewGuid(); }
public void ValidateUriGenerationForResources() { string databaseId = "db1234"; string crId = "cr42"; CosmosClientContext context = new CosmosClientContextCore( client: null, clientOptions: null, userJsonSerializer: null, defaultJsonSerializer: null, cosmosResponseFactory: null, requestHandler: null, documentClient: null, documentQueryClient: new Mock <IDocumentQueryClient>().Object); CosmosDatabaseCore db = new CosmosDatabaseCore(context, databaseId); Assert.AreEqual(db.LinkUri.OriginalString, "/dbs/" + databaseId); CosmosContainerCore container = new CosmosContainerCore(context, db, crId); Assert.AreEqual(container.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId); }
public async Task StandByFeedIterator_WithInexistentRange() { // Add some random range, this will force the failure List <CompositeContinuationToken> corruptedTokens = new List <CompositeContinuationToken> { new CompositeContinuationToken() { Range = new Documents.Routing.Range <string>("whatever", "random", true, false), Token = "oops" } }; string corruptedTokenSerialized = JsonConvert.SerializeObject(corruptedTokens); CosmosContainerCore itemsCore = (CosmosContainerCore)this.Container; FeedIterator setIteratorNew = itemsCore.GetStandByFeedIterator(corruptedTokenSerialized); CosmosResponseMessage responseMessage = await setIteratorNew.FetchNextSetAsync(this.cancellationToken); Assert.Fail("Should have thrown."); }
public void ValidateUriGenerationForResources() { string databaseId = "db1234"; string crId = "cr42"; string spId = "sp9001"; string trId = "tr9002"; string udfId = "udf9003"; CosmosClientContext context = new CosmosClientContextCore( client: null, clientConfiguration: null, cosmosJsonSerializer: null, cosmosResponseFactory: null, requestHandler: null, documentClient: null, documentQueryClient: new Mock <IDocumentQueryClient>().Object); CosmosDatabaseCore db = new CosmosDatabaseCore(context, databaseId); Assert.AreEqual(db.LinkUri.OriginalString, "/dbs/" + databaseId); CosmosContainerCore container = new CosmosContainerCore(context, db, crId); Assert.AreEqual(container.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId); CosmosStoredProcedureCore sp = new CosmosStoredProcedureCore(context, container, spId); Assert.AreEqual(sp.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId + "/sprocs/" + spId); CosmosTrigger tr = new CosmosTrigger(context, container, trId); Assert.AreEqual(tr.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId + "/triggers/" + trId); CosmosUserDefinedFunction udf = new CosmosUserDefinedFunction(context, container, udfId); Assert.AreEqual(udf.LinkUri.OriginalString, "/dbs/" + databaseId + "/colls/" + crId + "/udfs/" + udfId); }
internal static async Task <DocumentServiceLeaseStoreManager> InitializeLeaseStoreManagerAsync( DocumentServiceLeaseStoreManager documentServiceLeaseStoreManager, CosmosContainerCore leaseContainer, string leaseContainerPrefix, string instanceName) { if (documentServiceLeaseStoreManager == null) { ContainerResponse cosmosContainerResponse = await leaseContainer.ReadAsync().ConfigureAwait(false); CosmosContainerProperties containerSettings = cosmosContainerResponse.Resource; bool isPartitioned = containerSettings.PartitionKey != null && containerSettings.PartitionKey.Paths != null && containerSettings.PartitionKey.Paths.Count > 0; if (isPartitioned && (containerSettings.PartitionKey.Paths.Count != 1 || containerSettings.PartitionKey.Paths[0] != "/id")) { throw new ArgumentException("The lease collection, if partitioned, must have partition key equal to id."); } RequestOptionsFactory requestOptionsFactory = isPartitioned ? (RequestOptionsFactory) new PartitionedByIdCollectionRequestOptionsFactory() : (RequestOptionsFactory) new SinglePartitionRequestOptionsFactory(); DocumentServiceLeaseStoreManagerBuilder leaseStoreManagerBuilder = new DocumentServiceLeaseStoreManagerBuilder() .WithLeasePrefix(leaseContainerPrefix) .WithLeaseContainer(leaseContainer) .WithRequestOptionsFactory(requestOptionsFactory) .WithHostName(instanceName); documentServiceLeaseStoreManager = await leaseStoreManagerBuilder.BuildAsync().ConfigureAwait(false); } return(documentServiceLeaseStoreManager); }