public async Task <IBusMessage> ReciveAsync(IBusMessage request)
{
try
{
if (!_producer.Push(request))
{
throw new Exception("Error: message not sent!");
}
CancellationToken token = TokenHelper.GetToken(_config.ResponseTimeout);
var result = await _receiver.ReceiveAsync(request, token);
if (result == null)
{
result = request;
result.Body = null;
}
return(result);
}
catch (Exception e)
{
_logger?.LogError(e, $"{_connection.ServerInfo}.{typeof(BusQueue).FullName} : {e.Message}");
request.IsError = true;
request.ErrorDetails = e.Message;
return(request);
}
}
public bool ShouldAttemptDelivery(IBusMessage message)
{
if (message == null)
{
return(false);
}
//if (!(typeof(TMessage).IsAssignableFrom(message.GetType())))
if (!(message is TMessage))
{
return(false);
}
if (!_DeliveryAction.IsAlive)
{
return(false);
}
if (!_MessageFilter.IsAlive)
{
return(false);
}
return(((Func <TMessage, bool>)_MessageFilter.Target).Invoke(message as TMessage));
}
public void Deliver(IBusMessage message)
{
if (!(message is TMessage))
{
throw new ArgumentException("Message is not the correct type");
}
_DeliveryAction.Invoke(message as TMessage);
}
public async Task <IBusMessage> ReceiveAsync(IBusMessage request, CancellationToken stoppingToken)
{
if (!TryCreateChannel())
{
return(null);
}
using (BusListener listener = new BusListener(_consumer, _logger))
{
return(await listener.GetResponseAsync(request.Id, stoppingToken));
}
}
public static TResult GetResult <TResult>(this IBus <IBusMessage> bus, IBusMessage <TResult> message, TimeSpan?timeout = null)
{
var messageType = message.GetType();
var publishMethod =
bus.GetType()
.GetMethod("Publish", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance)
.MakeGenericMethod(messageType);
publishMethod.Invoke(bus, new object[] { message });
message.Wait(timeout);
return(message.Result);
}
public void Deliver(IBusMessage message)
{
if (!(message is TMessage))
{
throw new ArgumentException("Message is not the correct type");
}
if (!_DeliveryAction.IsAlive)
{
return;
}
((Action <TMessage>)_DeliveryAction.Target).Invoke(message as TMessage);
}
public bool ShouldAttemptDelivery(IBusMessage message)
{
if (message == null)
{
return(false);
}
//if (!(typeof(TMessage).IsAssignableFrom(message.GetType())))
if (!(message is TMessage))
{
return(false);
}
return(_MessageFilter.Invoke(message as TMessage));
}
private static IEnumerable <T> MatchPublish <T>(IBusMessage m)
{
switch (m)
{
case IPublishMessage pub:
switch (pub.Message)
{
case T match:
yield return(match);
break;
}
break;
}
}
public static IBusMessage TryExecuteOperationWrapper <T>(IBusMessage item, Func <T, object> operation, ILogger logger = null)
{
IBusMessage message = new ResponseMessage(item.Id, item.MessageType);
try
{
T value = item.GetBody <T>();
message.Body = operation(value);
}
catch (Exception ex)
{
message.IsError = true;
message.ErrorDetails = $"Error : {ex.Message}";
logger.LogError(ex, $"Error : {ex.Message}");
}
return(message);
}
private void MessageReceived(object sender, BasicDeliverEventArgs eventArgument)
{
try
{
byte[] body = eventArgument.Body.ToArray();
string bytesAsString = Encoding.UTF8.GetString(body);
IBusMessage item = JsonConvert.DeserializeObject <BusMessage>(bytesAsString);
if (item.Id.Equals(_messageId))
{
_queueMessages.Add(item);
}
}
catch (JsonException e)
{
_logger?.LogError(e, $"{_serverInfo}.{typeof(BusListener).FullName} : {e.Message}");
}
}
public static async Task <IBusMessage> TryExecuteOperationWrapperAsync <T>(IBusMessage item, Func <T, CancellationToken, Task <object> > operation, ILogger logger = null)
{
IBusMessage message = new ResponseMessage(item.Id, item.MessageType);
try
{
CancellationTokenSource cts = TokenHelper.GetTokenSource(item.CreateDate, item.TTL, DateTime.UtcNow);
T value = item.GetBody <T>();
message.Body = await operation(value, cts.Token);
}
catch (Exception ex)
{
message.IsError = true;
message.ErrorDetails = $"Error : {ex.Message}";
logger.LogError(ex, $"Error : {ex.Message}");
}
return(message);
}
public bool Push(IBusMessage request)
{
try
{
if (TryCreateChannel())
{
_channel.BasicPublish(exchange: _config.Exchange.Name,
routingKey: _config.Exchange.RoutingKey,
basicProperties: null,
body: request.GetMessage());
return(true);
}
return(false);
}
catch (Exception e)
{
_logger?.LogError(e, $"{_connection.ServerInfo}.{typeof(BusProducer).FullName} : {e.Message}");
return(false);
}
}
public bool Push(IBusMessage request)
{
return(_producer.Push(request));
}
public CacheMessage(IBusMessage contentMessage)
: base(contentMessage?.GetType().Name)
{
Content = contentMessage?.JsonSerialize();
ContentType = contentMessage?.GetType().Name;
}
private static void EnqueueInternal(string contextName, IBusMessage message)
{
var queues = GetQueue(contextName);
queues.Enqueue(message);
}
public InternalBusMessage(IPort source, IBusMessage message)
{
this.Source = source;
this.Message = message;
}
public void Deliver(IBusMessage message, IBusSubscription subscription)
{
subscription.Deliver(message);
}
public void Handle(IBusMessage message, Exception exception)
{
// 기본 동작은 아무것도 안하는 것이다.
}
public static void Enqueue(string contextName, IBusMessage message)
{
EnqueueInternal(contextName, message);
}
