public async Task PostConversationEdgeCaseFailedtoAddToBothPartitions()
{
Profile profile1 = CreateRandomProfile();
await _chatServiceClient.AddProfile(profile1);
Profile profile2 = CreateRandomProfile();
await _chatServiceClient.AddProfile(profile2);
var messageResponse = CreateRandomPostMessageResponse(profile1.Username);
string[] participants = { profile1.Username, profile2.Username };
string conversationId = ParticipantsToId(participants);
await _messageStore.AddMessage(messageResponse, conversationId);
var messageRequest = new PostMessageRequest
{
Id = messageResponse.Id,
Text = messageResponse.Text,
SenderUsername = profile1.Username
};
var conversationRequest = CreateRandomPostConversationRequest(messageRequest, participants);
var fetchedConversation = await _chatServiceClient.AddConversation(conversationRequest);
Assert.Equal(fetchedConversation.Id, conversationId);
}
public async Task <ApiResponse> Create(MessageDto messageDto)
{
_logger.LogDebug("Adding message: {@messageDto}", messageDto);
var message = await _messageStore.AddMessage(messageDto);
return(new ApiResponse(Status200OK, "Created Message", message));
}
public async Task <Message> AddMessage(string conversationId, AddMessageRequestBody addMessageRequestBody)
{
using (_logger.BeginScope("{ConversationId}", conversationId))
{
var message = new Message
{
Id = addMessageRequestBody.Id,
SenderUsername = addMessageRequestBody.SenderUsername,
Text = addMessageRequestBody.Text,
UnixTime = DateTimeOffset.Now.ToUnixTimeMilliseconds()
};
ThrowBadRequestIfMessageInvalid(message);
try
{
var stopWatch = Stopwatch.StartNew();
await _messageStore.AddMessage(conversationId, message);
_telemetryClient.TrackMetric("MessageStore.AddMessage.Time", stopWatch.ElapsedMilliseconds);
_telemetryClient.TrackEvent("MessageCreated");
}
catch (MessageAlreadyExistsException e)
{
message = await _messageStore.GetMessage(conversationId, message.Id);
return(message);
}
await _conversationStore.UpdateConversation(message.UnixTime, conversationId);
return(message);
}
}
public async Task <AddConversationResponse> AddConversation(AddConversationRequestBody addConversationRequestBody)
{
var id = "m_" + addConversationRequestBody.Participants[0] + "_" + addConversationRequestBody.Participants[1];
var conversation = new Conversation
{
Id = id,
Participants = addConversationRequestBody.Participants,
LastModifiedUnixTime = DateTimeOffset.Now.ToUnixTimeMilliseconds()
};
var addConversationResponse = new AddConversationResponse
{
Id = addConversationRequestBody.Participants[0] + "_" + addConversationRequestBody.Participants[1],
CreatedUnixTime = conversation.LastModifiedUnixTime
};
using (_logger.BeginScope("{ConversationId}", id))
{
var stopWatch = Stopwatch.StartNew();
await _conversationStore.AddConversation(conversation);
_telemetryClient.TrackMetric("ConversationStore.AddConversation.Time", stopWatch.ElapsedMilliseconds);
_telemetryClient.TrackEvent("ConversationCreated");
var message = new Message
{
Id = addConversationRequestBody.FirstMessage["Id"],
Text = addConversationRequestBody.FirstMessage["Text"],
SenderUsername = addConversationRequestBody.FirstMessage["SenderUsername"],
UnixTime = DateTimeOffset.Now.ToUnixTimeMilliseconds()
};
await _messageStore.AddMessage(id.Remove(0, 2), message);
return(addConversationResponse);
}
}
public async Task ReceiveLobbyMessage(Guid lobbyId, Message message)
{
// We are in the lobby
if (lobbyStore.SelectedLobby.Id == lobbyId)
{
await messageStore.AddMessage(message);
}
}
public async Task ReceiveMatchMessage(Guid matchId, Message message)
{
// We are in the match
if (matchStore.SelectedMatch.Id == matchId)
{
await messageStore.AddMessage(message);
}
}
private void OnMessageCreated(Guid sender, string message)
{
Console.WriteLine("{0} says {1}", sender, message);
lock (_syncRoot)
{
_clientPool.Broadcast(sender, message);
_store.AddMessage(sender, message);
}
}
public void Enqueue(T message)
{
_enqueueLocker.AtomWrite(() => {
_messageStore.AddMessage(Name, message);
_queue.Add(message);
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("{0} enqueued, id:{1}", message.ToString(), message.Id);
}
});
}
public async Task <PostMessageResponse> PostMessage(string conversationId, PostMessageRequest postMessageRequest)
{
using (_logger.BeginScope("{MessageId}", postMessageRequest.Id))
{
PostMessageResponse message = new PostMessageResponse
{
Id = postMessageRequest.Id,
Text = postMessageRequest.Text,
SenderUsername = postMessageRequest.SenderUsername,
UnixTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
};
var stopWatch = Stopwatch.StartNew();
var fetchedMessage = await _messageStore.AddMessage(message, conversationId);
await _conversationStore.UpdateConversation(conversationId, fetchedMessage.UnixTime);
_telemetryClient.TrackMetric("MessageStore.AddMessage.Time", stopWatch.ElapsedMilliseconds);
_telemetryClient.TrackEvent("MessageAdded");
return(fetchedMessage);
}
}
private async Task <UserMessage> CreateMessageInternalAsync(UserMessage newMessage, CancellationToken cancellationToken)
{
try
{
await messageStore.AddMessage(newMessage, cancellationToken);
await hubContext.Clients.All.ReceiveNewMessage(newMessage);
return(newMessage);
}
catch (Exception)
{
throw;
}
}
private void OnMessageReceived(ISmtp4devMessage message)
{
_messageStore.AddMessage(message);
}
public void Handle(CarRequest message)
{
Thread.Sleep(2000);
_logger.LogWarning("{Handler} : Brand = {CarBrand}, Model = {CarModel}, Color = {CarColor}", this.GetType().Name, message.Brand, message.Model, message.Color);
_messageStore.AddMessage(this.GetType().Name, message.ToString());
}
