public async Task <TDomainEntity> GetById(string id)
{
// TODO: Passing id as pk is not the correct approach!
CosmosDbResponse <TDomainEntity> response = await Container.Get <TDomainEntity>(id, id);
return(response.Result);
}
public async Task <PagedMessages <ArchivedMessage> > Handle(GetMessages request, CancellationToken cancellationToken)
{
ICosmosDbContainer messagesContainer = await _cosmosDbClient.GetContainer("messages");
IQueryable <ArchivedMessage> query = messagesContainer.GetByLinq <ArchivedMessage>();
query = ApplyFilters(query, request);
query = query.OrderByDescending(m => m.MessageDate);
int count = await messagesContainer.ResolveCount(query);
query = ApplyPaging(query, request);
CosmosDbResponse <IEnumerable <ArchivedMessage> > messages = await messagesContainer.ResolveWithStreamIterator(query);
if (!messages.IsSuccessful)
{
throw new ApplicationException($"Error fetching messages: {messages.ErrorMessage}");
}
return(new PagedMessages <ArchivedMessage>()
{
Messages = messages.Result,
PageIndex = request.MessageFilters.PageIndex,
PageSize = request.MessageFilters.PageSize,
TotalRecords = count
});
}
private async Task TrackResponse(CosmosDbResponse resp)
{
if (ChargeTracker != null)
{
await ChargeTracker?.Track(resp.ToChargedResponse(_innerContainer.Definition.ContainerId, Feature, Tags));
}
}
public async Task <CosmosDbResponse <IEnumerable <T> > > ResolveWithStreamIterator <T>(IQueryable <T> query)
{
CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.ResolveWithStreamIterator(query);
await TrackResponse(resp);
return(resp);
}
public async Task <CosmosDbResponse <IEnumerable <T> > > GetAll <T>()
{
CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.GetAll <T>();
await TrackResponse(resp);
return(resp);
}
public async Task <CosmosDbResponse <IEnumerable <T> > > GetByQuery <T>(string partitionKey, string query, IReadOnlyDictionary <string, object> parameters)
{
CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.GetByQuery <T>(partitionKey, query, parameters);
await TrackResponse(resp);
return(resp);
}
public async Task <CosmosDbResponse <IEnumerable <T> > > Get <T>(string partitionKey, Expression <Func <T, bool> > predicate)
{
CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.Get(partitionKey, predicate);
await TrackResponse(resp);
return(resp);
}
public async Task <CosmosDbResponse <T> > Get <T>(string id)
{
CosmosDbResponse <T> resp = await _innerContainer.Get <T>(id);
await TrackResponse(resp);
return(resp);
}
public async Task <CosmosDbResponse <IEnumerable <T> > > GetByQuery <T>(string partitionKey, string query)
{
CosmosDbResponse <IEnumerable <T> > resp = await _innerContainer.GetByQuery <T>(partitionKey, query);
await TrackResponse(resp);
return(resp);
}
public async Task <int> Count <TResult>(Expression <Func <IQueryable <TDomainEntity>, IQueryable <TResult> > > queryExpression)
{
IQueryable <TDomainEntity> query = Container.GetByLinq <TDomainEntity>();
IQueryable <TResult> q = queryExpression.Compile().Invoke(query);
CosmosDbResponse <int> response = await Container.ResolveCount(q);
return(response.Result);
}
public async Task <CosmosDbResponse <T> > Delete <T>(string partitionKey, string id)
{
CosmosDbResponse <T> resp = await _innerContainer.Delete <T>(partitionKey, id);
await TrackResponse(resp);
return(resp);
}
public async Task <CosmosDbResponse <T> > Update <T>(string partitionKey, T entity)
{
CosmosDbResponse <T> resp = await _innerContainer.Update(partitionKey, entity);
await TrackResponse(resp);
return(resp);
}
public async Task <TDomainEntity> Delete(TDomainEntity entity)
{
CosmosDbResponse <TDomainEntity> deletedEntity = await Container.Delete <TDomainEntity>(ResolvePartitionKeyValue(entity), entity.Id);
if (!deletedEntity.IsSuccessful)
{
throw new CosmosDbException($"DELETE Error: {deletedEntity.ErrorMessage}", typeof(TDomainEntity), entity.Id);
}
return(deletedEntity.Result);
}
public async Task <TDomainEntity> GetById(string id)
{
CosmosDbResponse <TDomainEntity> response = await Container.Get <TDomainEntity>(id);
if (!response.IsSuccessful)
{
throw new CosmosDbException($"GetById Error: {response.ErrorMessage}", typeof(TDomainEntity), id);
}
return(response.Result);
}
public async Task <IEnumerable <TDomainEntity> > Get(Expression <Func <TDomainEntity, bool> > predicate)
{
IQueryable <TDomainEntity> query = Container.GetByLinq <TDomainEntity>()
// add the predicate
.Where(predicate);
CosmosDbResponse <IEnumerable <TDomainEntity> > response = await Container.Resolve(query);
return(response.Result);
}
public async Task <TDomainEntity> Update(TDomainEntity entity)
{
CosmosDbResponse <TDomainEntity> updatedEntity = await Container.Update(ResolvePartitionKeyValue(entity), entity);
if (!updatedEntity.IsSuccessful)
{
throw new CosmosDbException($"UPDATE Error: {updatedEntity.ErrorMessage}", typeof(TDomainEntity), entity.Id);
}
return(updatedEntity.Result);
}
public async Task <IEnumerable <TDomainEntity> > Get(Expression <Func <TDomainEntity, bool> > predicate)
{
IQueryable <TDomainEntity> query = Container.GetByLinq <TDomainEntity>()
// add the predicate
.Where(predicate);
CosmosDbResponse <IEnumerable <TDomainEntity> > response = await Container.Resolve(query);
if (!response.IsSuccessful)
{
throw new CosmosDbException($"GET Error: {response.ErrorMessage}", typeof(TDomainEntity));
}
return(response.Result);
}
public async Task <TDomainEntity> Add(TDomainEntity entity)
{
// TODO: Move the ID Value Generator and Discriminator Setter to the lower level container
// always set new ID
entity.Id = _idValueGenerator.Generate(entity);
// always set the entity type / Discriminator
entity.Discriminator = _entityType;
CosmosDbResponse <TDomainEntity> response = await Container.Add(ResolvePartitionKeyValue(entity), entity);
return(response.Result);
}
public static CosmosDbChargedResponse ToChargedResponse(this CosmosDbResponse response,
string containerId,
string feature,
IEnumerable <string> context)
{
return(new CosmosDbChargedResponse()
{
ContainerId = containerId,
Feature = feature,
Context = context,
StatusCode = response.StatusCode,
ExecutionTime = response.ExecutionTime,
RequestCharge = response.RequestCharge
});
}
public async Task <IEnumerable <HealthCheckInfo> > Handle(GetHealthCheckInfo request, CancellationToken cancellationToken)
{
IList <HealthCheckInfo> healthCheckInfoList = new List <HealthCheckInfo>();
//Get the latest HealthCheck Requests from Cosmos DB
ICosmosDbContainer messagesContainer = await _cosmosDbClient.GetContainer("messages");
IQueryable <ArchivedMessage> query = messagesContainer.GetByLinq <ArchivedMessage>();
query = query.Where(m => m.Message.MessageType == typeof(HealthCheckRequest).AssemblyQualifiedName)
.OrderByDescending(m => m.MessageDate)
.Take(12); // last hour
CosmosDbResponse <IEnumerable <ArchivedMessage> > messages = await messagesContainer.ResolveWithStreamIterator(query);
if (!messages.IsSuccessful)
{
throw new ApplicationException($"Error fetching messages: {messages.ErrorMessage}");
}
foreach (var message in messages.Result)
{
var heathCheckRequest = message.Message as HealthCheckRequest;
var healthCheckInfo = new HealthCheckInfo
{
HealthCheckRequest = heathCheckRequest
};
//Search the HealthCheck Responses using the correlationId
IEnumerable <ArchivedMessage> healthCheckResponses = await GetHealthCheckResponsesByCorrelationId(message.Message.CorrelationId);
foreach (var response in healthCheckResponses)
{
HealthCheckResponse healthCheckResponse = (HealthCheckResponse)response.Message;
healthCheckResponse.ResponseStatus = healthCheckResponse.AggregateTestResults();
MarkDelayedHealthyResponseAsWarning(healthCheckResponse, heathCheckRequest.MessageDate);
healthCheckInfo.HealthCheckResponses.Add(healthCheckResponse);
}
AddErrorsForMissingServices(healthCheckInfo);
AggregateResult(healthCheckInfo);
healthCheckInfoList.Add(healthCheckInfo);
}
return(healthCheckInfoList);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger Test Storing a message!");
var message = new ArchivedMessage(new TestMessage()
{
Description = "This is a test message with a random value of " + new Random().Next(0, int.MaxValue)
});
ICosmosDbContainer cosmosContainer = await _cosmosClient.GetContainer <ArchivedMessage>();
CosmosDbResponse <ArchivedMessage> cosmosResponse = await cosmosContainer.Add(message.Id, message);
return(new OkObjectResult($"Cosmos Response: {cosmosResponse.IsSuccessful}"));
}
public async Task <TDomainEntity> Add(TDomainEntity entity)
{
// TODO: Move the ID Value Generator and Discriminator Setter to the lower level container
// always set new ID
entity.Id = _idValueGenerator.Generate(entity);
// always set the entity type / Discriminator
entity.Discriminator = _entityType;
CosmosDbResponse <TDomainEntity> response = await Container.Add(ResolvePartitionKeyValue(entity), entity);
if (!response.IsSuccessful)
{
throw new CosmosDbException($"Add Error: {response.ErrorMessage}", typeof(TDomainEntity), entity.Id);
}
return(response.Result);
}
private async Task <IEnumerable <ArchivedMessage> > GetHealthCheckResponsesByCorrelationId(string correlationId)
{
ICosmosDbContainer messagesContainer = await _cosmosDbClient.GetContainer("messages");
IQueryable <ArchivedMessage> queryHealthCheckResponse = messagesContainer.GetByLinq <ArchivedMessage>();
queryHealthCheckResponse = queryHealthCheckResponse.Where(m =>
m.Message.MessageType == typeof(HealthCheckResponse).AssemblyQualifiedName &&
m.Message.CorrelationId == correlationId);
CosmosDbResponse <IEnumerable <ArchivedMessage> > messages = await messagesContainer.ResolveWithStreamIterator(queryHealthCheckResponse);
if (!messages.IsSuccessful)
{
throw new ApplicationException($"Error fetching messages: {messages.ErrorMessage}");
}
return(messages.Result);
}
public async Task Run([ServiceBusTrigger("%ServiceBusTopic%", "%ServiceBusSubscription%", Connection = "ServiceBusConnectionString")] string messageString, ILogger log)
{
MessageBase originalMessage = null;
try
{
originalMessage = _messageReader.ReadMessage(messageString);
var archivedMessage = new ArchivedMessage(originalMessage);
if (archivedMessage.MessageTypeName.Equals(nameof(HealthCheckRequest)))
{
await HandleHealthCheckRequest(_messageReader.ReadMessage <HealthCheckRequest>(messageString));
}
ICosmosDbContainer cosmosContainer = await _cosmosClient.GetContainer <ArchivedMessage>();
CosmosDbResponse <ArchivedMessage> cosmosResponse =
await cosmosContainer.Add(archivedMessage.Id, archivedMessage);
if (!cosmosResponse.IsSuccessful)
{
throw new ApplicationException(
$"MessageStorage failed to write message {archivedMessage.Message.MessageId} of type {archivedMessage.Message.MessageType}. {cosmosResponse.ErrorMessage}");
}
}
catch (Exception storeException)
{
try
{
log.LogError(storeException, "exception saving to MessageStorage. OriginalMessage: " + messageString);
await _messageSender.SendException(storeException, originalMessage);
}
catch (Exception sendException)
{
log.LogCritical(sendException, "Exception attempting to save an error message to the bus! This is very bad!");
}
throw;
}
}
private async Task <IEnumerable <TDomainEntity> > Resolve(IQueryable <TDomainEntity> query)
{
CosmosDbResponse <IEnumerable <TDomainEntity> > resolvedQuery = await Container.Resolve(query);
return(resolvedQuery.Result);
}
public async Task <TDomainEntity> Update(TDomainEntity entity)
{
CosmosDbResponse <TDomainEntity> updatedEntity = await Container.Update(ResolvePartitionKeyValue(entity), entity);
return(updatedEntity.Result);
}
public async Task <TDomainEntity> Delete(TDomainEntity entity)
{
CosmosDbResponse <TDomainEntity> deletedEntity = await Container.Delete <TDomainEntity>(ResolvePartitionKeyValue(entity), entity.Id);
return(deletedEntity.Result);
}
public async Task <TDomainEntity> GetById(string id)
{
CosmosDbResponse <TDomainEntity> response = await Container.Get <TDomainEntity>(id);
return(response.Result);
}
public async Task <IEnumerable <TDomainEntity> > GetAll()
{
CosmosDbResponse <IEnumerable <TDomainEntity> > response = await Container.GetAll <TDomainEntity>();
return(response.Result);
}
