/// <inheritdoc />
protected override void ClientMessageReceived(ClientSocketBase <HorseMessage> client, HorseMessage payload)
{
base.ClientMessageReceived(client, payload);
if (_observer != null)
{
_observer.Read((HorseClient)client, payload);
}
}
/// <inheritdoc />
protected override void ClientMessageReceived(ClientSocketBase <TmqMessage> client, TmqMessage payload)
{
base.ClientMessageReceived(client, payload);
if (_reader != null)
{
_reader.Read((TmqClient)client, payload);
}
}
/// <summary>
/// When a message received to Tmq Client, this method will be called
/// </summary>
private void ClientOnMessageReceived(ClientSocketBase <TmqMessage> client, TmqMessage message)
{
//only channel messages accepted
if (message.Type != MessageType.Channel || string.IsNullOrEmpty(message.Target))
{
return;
}
//find all subscriber actions
List <QueueSubscription> subs;
lock (_subscriptions)
{
subs = _subscriptions.Where(x => x.QueueId == message.ContentType &&
x.Channel.Equals(message.Target, StringComparison.InvariantCultureIgnoreCase))
.ToList();
}
if (subs.Count == 0)
{
return;
}
//convert model, only one time to first susbcriber's type
Type type = subs[0].MessageType;
object model = _func(message, type);
//call all subscriber methods if they have same type
foreach (QueueSubscription sub in subs)
{
if (sub.MessageType == type)
{
try
{
if (sub.TmqMessageParameter)
{
sub.Action.DynamicInvoke(model, message);
}
else
{
sub.Action.DynamicInvoke(model);
}
}
catch (Exception ex)
{
OnException?.Invoke(message, ex);
}
}
}
}
private void MessageReceived(ClientSocketBase <TmqMessage> client, TmqMessage message)
{
switch (message.Type)
{
case MessageType.Channel:
if (message.ContentType == ModelTypes.ProducerEvent)
{
ProducerEvent e = message.GetJsonContent <ProducerEvent>().Result;
Console.WriteLine(message.Target == "AckChannel"
? $"> AckChannel received: #{e.No}"
: $"> BasicChannel received: #{e.No}");
}
break;
}
}
private void MessageReceived(ClientSocketBase <TmqMessage> client, TmqMessage message)
{
if (message.Type == MessageType.Client && message.ContentType == ModelTypes.ConsumerRequest)
{
ConsumerRequest request = message.GetJsonContent <ConsumerRequest>().Result;
Console.WriteLine($"Consumer request received: {request.Guid}");
ProducerResponse model = new ProducerResponse();
model.RequestGuid = request.Guid;
model.ResponseGuid = Guid.NewGuid().ToString();
TmqMessage response = message.CreateResponse();
response.ContentType = ModelTypes.ProducerResponse;
response.SetJsonContent(model);
TmqClient tmq = (TmqClient)client;
tmq.Send(response);
}
}
/// <summary>
/// Raises client message received event
/// </summary>
protected virtual void ClientMessageReceived(ClientSocketBase <TMessage> client, TMessage payload)
{
MessageReceived?.Invoke((TClient)client, payload);
}
/// <summary>
/// When a message received to Horse Client, this method will be called
/// </summary>
private async void ClientOnMessageReceived(ClientSocketBase <HorseMessage> client, HorseMessage message)
{
try
{
ReadSource source;
if (message.Type == MessageType.QueueMessage)
{
if (string.IsNullOrEmpty(message.Target))
{
return;
}
source = ReadSource.Queue;
}
else if (message.Type == MessageType.DirectMessage)
{
source = message.WaitResponse ? ReadSource.Request : ReadSource.Direct;
}
else
{
return;
}
//find all subscriber actions
List <ReadSubscription> subs = null;
lock (_subscriptions)
{
switch (source)
{
case ReadSource.Queue:
subs = _subscriptions.Where(x => x.Source == ReadSource.Queue &&
x.Queue.Equals(message.Target, StringComparison.InvariantCultureIgnoreCase)).ToList();
break;
case ReadSource.Direct:
subs = _subscriptions.Where(x => x.Source == ReadSource.Direct && x.ContentType == message.ContentType).ToList();
break;
case ReadSource.Request:
subs = _subscriptions.Where(x => x.Source == ReadSource.Request && x.ContentType == message.ContentType).ToList();
//direct consumer waits for ack
if (subs.Count == 0)
{
subs = _subscriptions.Where(x => x.Source == ReadSource.Direct && x.ContentType == message.ContentType).ToList();
}
break;
}
}
if (subs == null || subs.Count == 0)
{
return;
}
//convert model, only one time to first susbcriber's type
Type type = subs[0].MessageType;
object model = type == typeof(string) ? message.GetStringContent() : _func(message, type);
//call all subscriber methods if they have same type
foreach (ReadSubscription sub in subs)
{
if (sub.MessageType == null || sub.MessageType == type)
{
try
{
if (sub.ConsumerExecuter != null)
{
await sub.ConsumerExecuter.Execute((HorseClient)client, message, model);
}
if (sub.Action != null)
{
if (sub.HmqMessageParameter)
{
if (sub.MessageType == null)
{
sub.Action.DynamicInvoke(message);
}
else
{
sub.Action.DynamicInvoke(model, message);
}
}
else
{
sub.Action.DynamicInvoke(model);
}
}
}
catch (Exception ex)
{
OnException?.Invoke(message, ex);
}
}
}
}
catch (Exception ex)
{
OnException?.Invoke(message, ex);
}
}
