private async Task <CosmosDatabase> CreateDatabaseStreamHelper(
string databaseId = null,
int?throughput = null,
bool databaseExists = false)
{
if (string.IsNullOrEmpty(databaseId))
{
databaseId = Guid.NewGuid().ToString();
}
CosmosDatabaseSettings databaseSettings = new CosmosDatabaseSettings()
{
Id = databaseId
};
using (Stream streamPayload = CosmosResource.ToStream(databaseSettings))
{
CosmosResponseMessage response = await this.cosmosClient.Databases.CreateDatabaseStreamAsync(
streamPayload,
throughput : 400);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Headers.RequestCharge);
Assert.IsNotNull(response.Headers.ActivityId);
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK || (response.StatusCode == HttpStatusCode.Created && !databaseExists));
return(this.cosmosClient.Databases[databaseId]);
}
}
private async Task <CosmosDatabase> CreateDatabaseStreamHelper(
string databaseId = null,
int?throughput = null,
bool databaseExists = false)
{
if (string.IsNullOrEmpty(databaseId))
{
databaseId = Guid.NewGuid().ToString();
}
CosmosDatabaseProperties databaseSettings = new CosmosDatabaseProperties()
{
Id = databaseId
};
CosmosResponseMessage response = await this.cosmosClient.CreateDatabaseStreamAsync(
databaseSettings,
requestUnitsPerSecond : 400);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Headers.RequestCharge);
Assert.IsNotNull(response.Headers.ActivityId);
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK || (response.StatusCode == HttpStatusCode.Created && !databaseExists));
return(this.cosmosClient.GetDatabase(databaseId));
}
public async Task VerifyCosmosDefaultResultSetStreamIteratorOperationType()
{
CosmosClient mockClient = MockDocumentClient.CreateMockCosmosClient();
CosmosDatabase database = new CosmosDatabase(mockClient, "database");
CosmosContainer container = new CosmosContainer(database, "container");
CosmosItems item = new CosmosItems(container);
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r");
CosmosResultSetIterator setIterator = item
.CreateItemQueryAsStream(sql, "pk", requestOptions: new CosmosQueryRequestOptions());
TestHandler testHandler = new TestHandler((request, cancellationToken) => {
Assert.AreEqual(
15, //OperationType.SqlQuery
(int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null)
);
return(TestHandler.ReturnSuccess());
});
mockClient.RequestHandler.InnerHandler = testHandler;
mockClient.CosmosConfiguration.UseConnectionModeDirect();
CosmosResponseMessage response = await setIterator.FetchNextSetAsync();
testHandler = new TestHandler((request, cancellationToken) => {
Assert.AreEqual(
14, //OperationType.Query
(int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null)
);
return(TestHandler.ReturnSuccess());
});
mockClient.RequestHandler.InnerHandler = testHandler;
mockClient.CosmosConfiguration.UseConnectionModeGateway();
response = await setIterator.FetchNextSetAsync();
}
public async Task StreamCreateConflictTestAsync()
{
CosmosDatabaseSettings databaseSettings = new CosmosDatabaseSettings()
{
Id = Guid.NewGuid().ToString()
};
using (CosmosResponseMessage response = await this.cosmosClient.Databases.CreateDatabaseStreamAsync(CosmosResource.ToStream(databaseSettings)))
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.IsNotNull(response.Headers);
Assert.IsTrue(response.Headers.RequestCharge > 0);
}
// Stream operations do not throw exceptions.
using (CosmosResponseMessage response = await this.cosmosClient.Databases.CreateDatabaseStreamAsync(CosmosResource.ToStream(databaseSettings)))
{
Assert.AreEqual(HttpStatusCode.Conflict, response.StatusCode);
Assert.IsNotNull(response.Headers);
Assert.IsTrue(response.Headers.RequestCharge > 0);
}
using (CosmosResponseMessage response = await this.cosmosClient.Databases[databaseSettings.Id].DeleteStreamAsync())
{
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
Assert.IsNotNull(response.Headers);
Assert.IsTrue(response.Headers.RequestCharge > 0);
}
}
public async Task ItemIterator()
{
IList <ToDoActivity> deleteList = null;
HashSet <string> itemIds = null;
try
{
deleteList = await CreateRandomItems(3, randomPartitionKey : true);
itemIds = deleteList.Select(x => x.id).ToHashSet <string>();
CosmosResultSetIterator <ToDoActivity> setIterator =
this.Container.Items.GetItemIterator <ToDoActivity>();
while (setIterator.HasMoreResults)
{
foreach (ToDoActivity toDoActivity in await setIterator.FetchNextSetAsync(this.cancellationToken))
{
if (itemIds.Contains(toDoActivity.id))
{
itemIds.Remove(toDoActivity.id);
}
}
}
}
finally
{
foreach (ToDoActivity delete in deleteList)
{
CosmosResponseMessage deleteResponse = await this.Container.Items.DeleteItemStreamAsync(delete.status, delete.id);
deleteResponse.Dispose();
}
}
Assert.AreEqual(itemIds.Count, 0);
}
public override async Task <CosmosResponseMessage> SendAsync(
CosmosRequestMessage request,
CancellationToken cancellationToken)
{
try
{
using (new ActivityScope(Guid.NewGuid()))
{
DocumentServiceResponse response = await this.ProcessMessageAsync(request, cancellationToken);
return(response.ToCosmosResponseMessage(request));
}
}
//catch DocumentClientException and exceptions that inherit it. Other exception types happen before a backend request
catch (DocumentClientException ex)
{
return(ex.ToCosmosResponseMessage(request));
}
catch (AggregateException ex)
{
// TODO: because the SDK underneath this path uses ContinueWith or task.Result we need to catch AggregateExceptions here
// in order to ensure that underlying DocumentClientExceptions get propagated up correctly. Once all ContinueWith and .Result
// is removed this catch can be safely removed.
CosmosResponseMessage errorMessage = AggregateExceptionConverter(ex, request);
if (errorMessage != null)
{
return(errorMessage);
}
throw;
}
}
public async Task ExecutionLogsAsStreamTests()
{
const string testLogsText = "this is a test";
const string testPartitionId = "1";
string sprocId = Guid.NewGuid().ToString();
string sprocBody = @"function(name) { var context = getContext(); console.log('" + testLogsText + "'); var response = context.getResponse(); response.setBody('hello there ' + name); }";
StoredProcedureResponse storedProcedureResponse =
await this.scripts.CreateStoredProcedureAsync(new CosmosStoredProcedureProperties(sprocId, sprocBody));
double requestCharge = storedProcedureResponse.RequestCharge;
Assert.IsTrue(requestCharge > 0);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
CosmosStoredProcedureProperties storedProcedure = storedProcedureResponse;
CosmosResponseMessage sprocResponse = await this.scripts.ExecuteStoredProcedureStreamAsync(
new Cosmos.PartitionKey(testPartitionId),
sprocId,
cosmosJsonSerializer.ToStream(new string[] { Guid.NewGuid().ToString() }),
new StoredProcedureRequestOptions()
{
EnableScriptLogging = true
});
Assert.AreEqual(HttpStatusCode.OK, sprocResponse.StatusCode);
Assert.AreEqual(testLogsText, Uri.UnescapeDataString(sprocResponse.Headers["x-ms-documentdb-script-log-results"]));
}
public async Task UpsertItemStreamTest()
{
ToDoActivity testItem = this.CreateRandomToDoActivity();
using (Stream stream = this.jsonSerializer.ToStream <ToDoActivity>(testItem))
{
//Create the object
using (CosmosResponseMessage response = await this.Container.Items.UpsertItemStreamAsync(partitionKey: testItem.status, streamPayload: stream))
{
Assert.IsNotNull(response);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
using (StreamReader str = new StreamReader(response.Content))
{
string responseContentAsString = await str.ReadToEndAsync();
}
}
}
//Updated the taskNum field
testItem.taskNum = 9001;
using (Stream stream = this.jsonSerializer.ToStream <ToDoActivity>(testItem))
{
using (CosmosResponseMessage response = await this.Container.Items.UpsertItemStreamAsync(partitionKey: testItem.status, streamPayload: stream))
{
Assert.IsNotNull(response);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
}
using (CosmosResponseMessage deleteResponse = await this.Container.Items.DeleteItemStreamAsync(partitionKey: testItem.status, id: testItem.id))
{
Assert.IsNotNull(deleteResponse);
Assert.AreEqual(deleteResponse.StatusCode, HttpStatusCode.NoContent);
}
}
public async Task VerifySendUsesOringianlContinuationOnNonSuccessfulResponse()
{
Mock <PartitionRoutingHelper> partitionRoutingHelperMock = this.GetPartitionRoutingHelperMock();
PartitionKeyRangeHandler partitionKeyRangeHandler = new PartitionKeyRangeHandler(MockCosmosUtil.CreateMockCosmosClient(), partitionRoutingHelperMock.Object);
TestHandler testHandler = new TestHandler(async(request, cancellationToken) => {
CosmosResponseMessage errorResponse = await TestHandler.ReturnStatusCode(HttpStatusCode.Gone);
errorResponse.Headers.Remove(HttpConstants.HttpHeaders.Continuation); //Clobber original continuation
return(errorResponse);
});
partitionKeyRangeHandler.InnerHandler = testHandler;
//Pass valid collections path because it is required by DocumentServiceRequest's constructor. This can't be mocked because ToDocumentServiceRequest() is an extension method
CosmosRequestMessage initialRequest = new CosmosRequestMessage(HttpMethod.Get, new Uri($"{Paths.DatabasesPathSegment}/test/{Paths.CollectionsPathSegment}/test", UriKind.Relative));
initialRequest.OperationType = OperationType.ReadFeed;
initialRequest.Headers.Add(HttpConstants.HttpHeaders.Continuation, Continuation);
CosmosResponseMessage response = await partitionKeyRangeHandler.SendAsync(initialRequest, CancellationToken.None);
Assert.IsFalse(response.IsSuccessStatusCode);
Assert.AreEqual(System.Net.HttpStatusCode.Gone, response.StatusCode);
//Check if original continuation was restored
Assert.AreEqual(Continuation, response.Headers.GetValues(HttpConstants.HttpHeaders.Continuation).First());
Assert.AreEqual(Continuation, initialRequest.Headers.GetValues(HttpConstants.HttpHeaders.Continuation).First());
}
public Task <ShouldRetryResult> ShouldRetryAsync(
CosmosResponseMessage cosmosResponseMessage,
CancellationToken cancellationToken)
{
// Its used by query/feed and are not yet needed.
throw new NotImplementedException();
}
private static CosmosResponseMessage GetResponse(HttpStatusCode statusCode, bool includeItem, int subStatusCode = 0)
{
CosmosResponseMessage message = new CosmosResponseMessage(statusCode);
message.Headers.Continuation = "someContinuation";
if (subStatusCode > 0)
{
message.Headers.SubStatusCode = (Documents.SubStatusCodes)subStatusCode;
}
if (includeItem)
{
MyDocument document = new MyDocument();
document.id = "test";
CosmosFeedResponseUtil <MyDocument> cosmosFeedResponse = new CosmosFeedResponseUtil <MyDocument>();
cosmosFeedResponse.Data = new System.Collections.ObjectModel.Collection <MyDocument>()
{
document
};
message.Content = (new CosmosJsonSerializerCore()).ToStream(cosmosFeedResponse);
}
return(message);
}
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));
}
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");
}
private static async Task ItemStreamFeed(CosmosContainer container)
{
int totalCount = 0;
// SQL
FeedIterator setIterator = container.GetItemsStreamIterator();
while (setIterator.HasMoreResults)
{
int count = 0;
using (CosmosResponseMessage response = await setIterator.FetchNextSetAsync())
{
response.EnsureSuccessStatusCode();
count++;
using (StreamReader sr = new StreamReader(response.Content))
using (JsonTextReader jtr = new JsonTextReader(sr))
{
JsonSerializer jsonSerializer = new JsonSerializer();
dynamic array = jsonSerializer.Deserialize <dynamic>(jtr);
totalCount += array.Documents.Count;
}
}
}
Assert("Expected two families", totalCount == 2);
}
private static async Task QueryItemsInPartitionAsStreams(CosmosContainer container)
{
// SQL
FeedIterator setIterator = container.CreateItemQueryStream(
"SELECT F.id, F.LastName, F.IsRegistered FROM Families F",
partitionKey: new PartitionKey("Anderson"),
maxConcurrency: 1,
maxItemCount: 1);
int count = 0;
while (setIterator.HasMoreResults)
{
using (CosmosResponseMessage response = await setIterator.FetchNextSetAsync())
{
Assert("Response failed", response.IsSuccessStatusCode);
count++;
using (StreamReader sr = new StreamReader(response.Content))
using (JsonTextReader jtr = new JsonTextReader(sr))
{
JsonSerializer jsonSerializer = new JsonSerializer();
dynamic items = jsonSerializer.Deserialize <dynamic>(jtr).Documents;
Assert("Expected one family", items.Count == 1);
dynamic item = items[0];
Assert($"Expected LastName: Anderson Actual: {item.LastName}", string.Equals("Anderson", item.LastName.ToString(), StringComparison.InvariantCulture));
}
}
}
Assert("Expected 1 family", count == 1);
}
public async Task TestIteratorContract()
{
this.ContinuationToken = null;
this.Options = new QueryRequestOptions();
this.CancellationToken = new CancellationTokenSource().Token;
this.ContinueNextExecution = true;
FeedIterator resultSetIterator = new FeedIteratorCore(
this.MaxItemCount,
this.ContinuationToken,
this.Options,
this.NextResultSetDelegate);
Assert.IsTrue(resultSetIterator.HasMoreResults);
CosmosResponseMessage response = await resultSetIterator.FetchNextSetAsync(this.CancellationToken);
this.ContinuationToken = response.Headers.Continuation;
Assert.IsTrue(resultSetIterator.HasMoreResults);
this.ContinueNextExecution = false;
response = await resultSetIterator.FetchNextSetAsync(this.CancellationToken);
this.ContinuationToken = response.Headers.Continuation;
Assert.IsFalse(resultSetIterator.HasMoreResults);
Assert.IsNull(response.Headers.Continuation);
}
public async Task TestCustomPropertyWithHandler()
{
CustomHandler testHandler = new CustomHandler();
// Add the random guid to the property
Guid randomGuid = Guid.NewGuid();
string propertyKey = "Test";
testHandler.UpdateRequestMessage = x => x.Properties[propertyKey] = randomGuid;
CosmosClient customClient = TestCommon.CreateCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler));
ToDoActivity testItem = CreateRandomToDoActivity();
using (CosmosResponseMessage response = await customClient.GetContainer(this.database.Id, this.Container.Id).CreateItemStreamAsync(
partitionKey: new Cosmos.PartitionKey(testItem.status),
streamPayload: this.jsonSerializer.ToStream(testItem)))
{
Assert.IsNotNull(response);
Assert.IsNotNull(response.RequestMessage);
Assert.IsNotNull(response.RequestMessage.Properties);
Assert.AreEqual(randomGuid, response.RequestMessage.Properties[propertyKey]);
}
}
private static async Task ReadItemAsync()
{
Console.WriteLine("\n1.2 - Reading Item by Id");
// Note that Reads require a partition key to be specified.
CosmosItemResponse <SalesOrder> response = await container.Items.ReadItemAsync <SalesOrder>(
partitionKey : "Account1",
id : "SalesOrder1");
// You can measure the throughput consumed by any operation by inspecting the RequestCharge property
Console.WriteLine("Item read by Id {0}", response.Resource);
Console.WriteLine("Request Units Charge for reading a Item by Id {0}", response.RequestCharge);
SalesOrder readOrder = (SalesOrder)response;
// Read the same item but as a stream.
using (CosmosResponseMessage responseMessage = await container.Items.ReadItemStreamAsync(
partitionKey: "Account1",
id: "SalesOrder1"))
{
// Item stream operations do not throw exceptions for better performance
if (responseMessage.IsSuccessStatusCode)
{
SalesOrder streamResponse = FromStream <SalesOrder>(responseMessage.Content);
Console.WriteLine($"\n1.2.2 - Item created {streamResponse.Id}");
}
else
{
Console.WriteLine($"Read item from stream failed. Status code: {responseMessage.StatusCode} Message: {responseMessage.ErrorMessage}");
}
}
}
private void SetOriginalContinuationToken(CosmosRequestMessage request, CosmosResponseMessage response, string originalContinuation)
{
request.Headers.Continuation = originalContinuation;
if (response != null)
{
response.Headers.Continuation = originalContinuation;
}
}
private static Collection <JObject> GetItemsFromResponse(CosmosResponseMessage response)
{
if (response.Content == null)
{
return(new Collection <JObject>());
}
return(RemainingWorkEstimatorCore.DefaultSerializer.FromStream <CosmosFeedResponseUtil <JObject> >(response.Content).Data);
}
private CosmosResponseMessage CreateResponse()
{
CosmosResponseMessage cosmosResponse = new CosmosResponseMessage(statusCode: HttpStatusCode.OK)
{
Content = new MemoryStream()
};
return(cosmosResponse);
}
public async Task ItemMultiplePartitionOrderByQueryStream()
{
IList <ToDoActivity> deleteList = new List <ToDoActivity>();
try
{
deleteList = await CreateRandomItems(300, randomPartitionKey : true);
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("SELECT * FROM toDoActivity t ORDER BY t.taskNum ");
CosmosQueryRequestOptions requestOptions = new CosmosQueryRequestOptions()
{
MaxBufferedItemCount = 10,
ResponseContinuationTokenLimitInKb = 500
};
List <ToDoActivity> resultList = new List <ToDoActivity>();
double totalRequstCharge = 0;
CosmosResultSetIterator setIterator =
this.Container.Items.CreateItemQueryAsStream(sql, maxConcurrency: 5, maxItemCount: 1, requestOptions: requestOptions);
while (setIterator.HasMoreResults)
{
using (CosmosQueryResponse iter = await setIterator.FetchNextSetAsync())
{
Assert.IsTrue(iter.IsSuccess);
Assert.IsNull(iter.ErrorMessage);
Assert.IsTrue(iter.Count <= 5);
totalRequstCharge += iter.RequestCharge;
ToDoActivity response = this.jsonSerializer.FromStream <ToDoActivity[]>(iter.Content).First();
resultList.Add(response);
}
}
Assert.AreEqual(deleteList.Count, resultList.Count);
Assert.IsTrue(totalRequstCharge > 0);
List <ToDoActivity> verifiedOrderBy = deleteList.OrderBy(x => x.taskNum).ToList();
for (int i = 0; i < verifiedOrderBy.Count(); i++)
{
Assert.AreEqual(verifiedOrderBy[i].taskNum, resultList[i].taskNum);
Assert.AreEqual(verifiedOrderBy[i].id, resultList[i].id);
}
}
finally
{
foreach (ToDoActivity delete in deleteList)
{
CosmosResponseMessage deleteResponse = await this.Container.Items.DeleteItemStreamAsync(delete.status, delete.id);
deleteResponse.Dispose();
}
}
}
private CosmosResponseMessage GetHttpResponse()
{
CosmosResponseMessage response = new CosmosResponseMessage();
if (this.ContinueNextExecution)
{
response.Headers.Add("x-ms-continuation", ResultSetIteratorTests.RandomString(10));
}
return(response);
}
public override Task <CosmosResponseMessage> SendAsync(CosmosRequestMessage request, CancellationToken cancellationToken)
{
CosmosResponseMessage httpResponse = null;
if (request.Properties.TryGetValue(PreProcessingTestHandler.StatusCodeName, out object statusCodeOut))
{
httpResponse = new CosmosResponseMessage((HttpStatusCode)statusCodeOut);
}
return(Task.FromResult(httpResponse));
}
public async Task StandByFeedIterator_VerifyRefreshIsCalledOnSplit()
{
CosmosChangeFeedResultSetIteratorCoreMock iterator = new CosmosChangeFeedResultSetIteratorCoreMock(this.Container, "", 100, new ChangeFeedRequestOptions());
using (CosmosResponseMessage responseMessage =
await iterator.FetchNextSetAsync(this.cancellationToken))
{
Assert.IsTrue(iterator.HasCalledForceRefresh);
Assert.IsTrue(iterator.Iteration > 1);
Assert.AreEqual(responseMessage.StatusCode, System.Net.HttpStatusCode.NotModified);
}
}
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 Task <ShouldRetryResult> ShouldRetryAsync(
CosmosResponseMessage httpResponseMessage,
CancellationToken cancellationToken)
{
Debug.Assert(this.nextPolicy == null);
return(this.ShouldRetryAsyncInternal(
httpResponseMessage.StatusCode,
httpResponseMessage.Headers.SubStatusCode,
httpResponseMessage.GetResourceAddress(),
// In the new OM, retries are chained by handlers, not by chaining retry policies. Consequently, the next policy should be null here.
continueIfNotHandled: null));
}
public override async Task <CosmosResponseMessage> SendAsync(
CosmosRequestMessage request,
CancellationToken cancellationToken)
{
CosmosResponseMessage response = await base.SendAsync(request, cancellationToken);
if (response.StatusCode == System.Net.HttpStatusCode.PreconditionFailed)
{
response.Headers.Set("x-ms-substatus", "999");
}
return(response);
}
public override async Task RunAsync(CancellationToken cancellationToken)
{
string lastContinuation = this.settings.StartContinuation;
while (!cancellationToken.IsCancellationRequested)
{
TimeSpan delay = this.settings.FeedPollDelay;
try
{
do
{
CosmosResponseMessage response = await this.resultSetIterator.FetchNextSetAsync(cancellationToken).ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.NotModified && !response.IsSuccessStatusCode)
{
DefaultTrace.TraceWarning("unsuccessful feed read: lease token '{0}' status code {1}. substatuscode {2}", this.settings.LeaseToken, response.StatusCode, response.Headers.SubStatusCode);
this.HandleFailedRequest(response.StatusCode, (int)response.Headers.SubStatusCode, lastContinuation);
if (response.Headers.RetryAfter.HasValue)
{
delay = response.Headers.RetryAfter.Value;
}
// Out of the loop for a retry
break;
}
lastContinuation = response.Headers.Continuation;
if (this.resultSetIterator.HasMoreResults)
{
await this.DispatchChangesAsync(response, cancellationToken).ConfigureAwait(false);
}
}while (this.resultSetIterator.HasMoreResults && !cancellationToken.IsCancellationRequested);
}
catch (TaskCanceledException canceledException)
{
if (cancellationToken.IsCancellationRequested)
{
throw;
}
DefaultTrace.TraceException(canceledException);
DefaultTrace.TraceWarning("exception: lease token '{0}'", this.settings.LeaseToken);
// ignore as it is caused by Cosmos DB client when StopAsync is called
}
await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
}
}
private static async Task UpsertItemAsync()
{
Console.WriteLine("\n1.6 - Upserting a item");
SalesOrder upsertOrder = GetSalesOrderSample("SalesOrder3");
CosmosItemResponse <SalesOrder> response = await container.Items.UpsertItemAsync(
partitionKey : upsertOrder.AccountNumber,
item : upsertOrder);
SalesOrder upserted = response.Resource;
Console.WriteLine($"Request charge of upsert operation: {response.RequestCharge}");
Console.WriteLine($"StatusCode of this operation: { response.StatusCode}");
Console.WriteLine($"Id of upserted item: {upserted.Id}");
Console.WriteLine($"AccountNumber of upserted item: {upserted.AccountNumber}");
upserted.AccountNumber = "updated account number";
response = await container.Items.UpsertItemAsync(partitionKey : upserted.AccountNumber, item : upserted);
upserted = response.Resource;
Console.WriteLine($"Request charge of upsert operation: {response.RequestCharge}");
Console.WriteLine($"StatusCode of this operation: { response.StatusCode}");
Console.WriteLine($"Id of upserted item: {upserted.Id}");
Console.WriteLine($"AccountNumber of upserted item: {upserted.AccountNumber}");
// For better performance upsert a SalesOrder object from a stream.
SalesOrder salesOrderV4 = GetSalesOrderSample("SalesOrder4");
using (Stream stream = Program.ToStream <SalesOrder>(salesOrderV4))
{
using (CosmosResponseMessage responseMessage = await container.Items.UpsertItemStreamAsync(
partitionKey: salesOrderV4.AccountNumber,
streamPayload: stream))
{
// Item stream operations do not throw exceptions for better performance
if (responseMessage.IsSuccessStatusCode)
{
SalesOrder streamResponse = FromStream <SalesOrder>(responseMessage.Content);
Console.WriteLine($"\n1.6.2 - Item upserted via stream {streamResponse.Id}");
}
else
{
Console.WriteLine($"Upsert item from stream failed. Status code: {responseMessage.StatusCode} Message: {responseMessage.ErrorMessage}");
}
}
}
}
