public RedisQueueRawServerListener(MQConnection connection, IMQueueRawServer server, bool responseServer) : base(connection, server, responseServer)
{
_name = server.Name;
_messageHandlerDelegate = new Action <RedisChannel, RedisValue>(MessageHandler);
_processDelegate = new Func <RedisValue, Task>(ProcessingTaskAsync);
_monitorDelegate = new Func <Task>(MonitorProcess);
}
protected MQueueRawServerListenerBase(MQConnection connection, IMQueueRawServer server, bool responseServer)
{
Connection = connection;
Config = server.Config;
Counters = new MQRawServerCounters(server.Name + "\\Listener (" + connection?.Route + ")", server.Config.IgnoreServerCounters);
ReceiverSerializer = server.ReceiverSerializer;
ResponseServer = responseServer;
Core.Status.Attach(collection =>
{
collection.Add("Connection Route:", Connection?.Route);
collection.Add("Connection Name:", Connection?.Name);
collection.Add(nameof(ResponseServer), ResponseServer);
Core.Status.AttachChild(Counters, this);
});
}
/// <inheritdoc />
/// <summary>
/// On Service Start method
/// </summary>
/// <param name="args">Start arguments</param>
public void OnStart(string[] args)
{
try
{
Core.Log.InfoBasic("Starting messaging service");
_cTokenSource = new CancellationTokenSource();
OnInit(args);
QueueServer = GetQueueServer();
if (QueueServer is null)
{
throw new Exception("The queue server is null, please check the configuration file and ensure the Types assemblies are on the assembly folder.");
}
Processor = GetMessageProcessorAsync(QueueServer);
if (Processor is null)
{
throw new Exception("The message processor is null, please check your GetMessageProcessor method implementation.");
}
if (QueueServer.ResponseServer)
{
QueueServer.ResponseReceived += async(s, e) =>
{
if (MessageReceived != null)
{
await MessageReceived.InvokeAsync(this, new RawMessageEventArgs(e.Message, e.CorrelationId)).ConfigureAwait(false);
}
await Processor.ProcessAsync(e, _cTokenSource.Token).ConfigureAwait(false);
};
}
else
{
QueueServer.RequestReceived += async(s, e) =>
{
if (MessageReceived != null)
{
await MessageReceived.InvokeAsync(this, new RawMessageEventArgs(e.Request, e.CorrelationId)).ConfigureAwait(false);
}
var result = await Processor.ProcessAsync(e, _cTokenSource.Token).ConfigureAwait(false);
if (result != ResponseMessage.NoResponse && result != null)
{
if (result is byte[] rBytes)
{
e.Response = rBytes;
}
else if (result is MultiArray <byte> mBytes)
{
e.Response = mBytes;
}
else
{
e.Response = QueueServer.SenderSerializer.Serialize(result);
}
}
};
QueueServer.BeforeSendResponse += async(s, e) =>
{
if (BeforeSendMessage != null)
{
await BeforeSendMessage.InvokeAsync(this, new RawMessageEventArgs(e.Message, e.CorrelationId)).ConfigureAwait(false);
}
};
QueueServer.ResponseSent += async(s, e) =>
{
if (MessageSent != null)
{
await MessageSent.InvokeAsync(this, new RawMessageEventArgs(e.Message, e.CorrelationId)).ConfigureAwait(false);
}
};
}
Processor.Init();
QueueServer.StartListeners();
Core.Log.InfoBasic("Messaging service started.");
Core.Status.Attach(collection =>
{
Core.Status.AttachChild(Processor, this);
Core.Status.AttachChild(QueueServer, this);
});
}
catch (Exception ex)
{
Core.Log.Write(ex);
throw;
}
}
/// <summary> /// Gets the message processor /// </summary> /// <param name="server">Queue server object instance</param> /// <returns>Message processor instance</returns> protected abstract IMessageProcessorAsync GetMessageProcessorAsync(IMQueueRawServer server);
public NATSQueueRawServerListener(MQConnection connection, IMQueueRawServer server, bool responseServer) : base(connection, server, responseServer)
{
_factory = new ConnectionFactory();
_name = server.Name;
}
public RabbitMQueueRawServerListener(MQConnection connection, IMQueueRawServer server, bool responseServer) : base(connection, server, responseServer)
{
_name = server.Name;
}
public RabbitMQueueRawServerListener(MQConnection connection, IMQueueRawServer server, bool responseServer) : base(connection, server, responseServer)
{
_name = server.Name;
_processingTaskAsyncDelegate = ProcessingTaskAsync;
}
