public void Send(string name, string message)
{
Message mess = new Message(name, message);
messList.Add(mess);
string jsonString = JsonConvert.SerializeObject(messList, Formatting.Indented);
System.Diagnostics.Debug.WriteLine(jsonString);
// Call the broadcastMessage method to update clients.
Clients.All.broadcastMessage(jsonString);
}
protected override Task Send(Message[] messages)
{
return Task.Factory.StartNew(msgs =>
{
var messagesToSend = msgs as Message[];
messagesToSend.GroupBy(m => m.Source).ToList().ForEach(group =>
{
var message = new RabbitMqMessageWrapper(group.Key, group.ToArray());
_rabbitConnection.Send(message);
});
},
messages);
}
public async Task SendMessage(MessageViewModel messageViewModel)
{
var userIdentity = this.Context.User.Identity as CustomIdentity;
int receiverKey = 0;
if (userIdentity != null && int.TryParse(messageViewModel.Author, out receiverKey))
{
User sender = this._membershipService.GetUserByKey(userIdentity.Id);
User receiver = this._membershipService.GetUserByKey(receiverKey);
var message = new Message(
messageViewModel.Text,
sender.UserProfile,
receiver.UserProfile);
message.SendDate = messageViewModel.Date ?? DateTime.Now;
messageViewModel.Sender = string.Format(
"{0} {1}",
sender.UserProfile.FirstName,
sender.UserProfile.LastName);
await this._messageService.SendMessageAsync(message);
await this.Clients.User(messageViewModel.Author).ShowMessage(messageViewModel);
}
}
/// <summary>
/// Invoked when a payload is received from the backplane. There should only be one active call at any time.
/// </summary>
/// <param name="streamId">id of the stream</param>
/// <param name="id">id of the payload within that stream</param>
/// <param name="messages">List of messages associated</param>
/// <returns></returns>
protected Task OnReceived(string streamId, ulong id, Message[] messages)
{
// Create a local dictionary for this payload
var dictionary = new ConcurrentDictionary<string, LocalEventKeyInfo>();
foreach (var m in messages)
{
// Get the payload info
var info = dictionary.GetOrAdd(m.Key, _ => new LocalEventKeyInfo());
// Save the min and max for this payload for later
ulong localId = Save(m);
// Set the topic pointer for this event key so we don't need to look it up later
info.Store = _topics[m.Key].Store;
info.MinLocal = Math.Min(localId, info.MinLocal);
info.Count++;
}
// Create the mapping for this payload
var mapping = new ScaleoutMapping(dictionary);
// Get the stream for this payload
var stream = _streams.GetOrAdd(streamId, _ => new Linktionary<ulong, ScaleoutMapping>());
// Publish only after we've setup the mapping fully
stream.Add(id, mapping);
// Schedule after we're done
foreach (var eventKey in dictionary.Keys)
{
ScheduleEvent(eventKey);
}
return TaskAsyncHelper.Empty;
}
protected ulong Save(Message message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
Topic topic = GetTopic(message.Key);
ulong id = topic.Store.Add(message);
Counters.MessageBusMessagesPublishedTotal.Increment();
Counters.MessageBusMessagesPublishedPerSec.Increment();
return id;
}
/// <summary>
/// Publishes a new message to the specified event on the bus.
/// </summary>
/// <param name="message">The message to publish.</param>
public virtual Task Publish(Message message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
Topic topic = GetTopic(message.Key);
topic.Store.Add(message);
Counters.MessageBusMessagesPublishedTotal.Increment();
Counters.MessageBusMessagesPublishedPerSec.Increment();
ScheduleTopic(topic);
return TaskAsyncHelper.Empty;
}
private bool ExcludeMessage(Message message)
{
if (String.IsNullOrEmpty(message.Filter))
{
return false;
}
string[] exclude = message.Filter.Split('|');
return exclude.Any(signal => Identity.Equals(signal, StringComparison.OrdinalIgnoreCase) ||
_signals.Contains(signal) ||
_groups.Contains(signal));
}
private Message CreateMessage(string key, object value)
{
var command = value as Command;
var message = new Message(_connectionId, key, _serializer.Stringify(value));
if (command != null)
{
// Set the command id
message.CommandId = command.Id;
message.WaitForAck = command.WaitForAck;
}
return message;
}
public void Signal(Message data)
{
// Call the addNewMessageToPage method to update clients.
Clients.Others.signal(data);
}
public async Task SendMessage(string to, string text)
{
var userName = HttpContext.User.Identity.Name;
var message = new Message() { ConversationId = to, Text = text, Date = DateTime.Now };
var conv = await _chatManager.AddMessageAsync(userName, to, message);
if (conv == null)
return;
foreach(var attendee in conv.Attendees)
{
var user = await _userManager.FindByIdAsync(attendee.UserId);
if (user != null && user.UserName != userName)
_hub.Clients.Group(user.UserName).messageReceived(new MessageViewModel() { ConversationId = to, Date = message.Date, From = HttpContext.User.Identity.Name, Text = text });
}
}
public RabbitMqMessageWrapper(string key, Message[] message)
{
Id = GetNext();
Key = key;
Messages = message;
}
/// <summary>
/// Publishes a new message to the specified event on the bus.
/// </summary>
/// <param name="source">A value representing the source of the data sent.</param>
public virtual Task Publish(Message message)
{
Topic topic = GetTopic(message.Key);
topic.Store.Add(message);
_counters.MessageBusMessagesPublishedTotal.Increment();
_counters.MessageBusMessagesPublishedPerSec.Increment();
ScheduleTopic(topic);
return TaskAsyncHelper.Empty;
}
protected ulong Save(Message message)
{
Topic topic = GetTopic(message.Key);
ulong id = topic.Store.Add(message);
_counters.MessageBusMessagesPublishedTotal.Increment();
_counters.MessageBusMessagesPublishedPerSec.Increment();
return id;
}
/// <summary> /// Sends messages to the backplane /// </summary> /// <param name="messages"></param> /// <returns></returns> protected abstract Task Send(Message[] messages);
public override Task Publish(Message message)
{
// TODO: Buffer messages here and make it configurable
return Send(new[] { message });
}
