public async Task <OperateResult> SendAsync(TransportMessage message)
{
var producer = _connectionPool.RentProducer();
try
{
var headers = new Confluent.Kafka.Headers();
foreach (var header in message.Headers)
{
headers.Add(header.Value != null
? new Header(header.Key, Encoding.UTF8.GetBytes(header.Value))
: new Header(header.Key, null));
}
var result = await producer.ProduceAsync(message.GetName(), new Message <string, byte[]>
{
Headers = headers,
Key = message.Headers.TryGetValue(KafkaHeaders.KafkaKey, out string kafkaMessageKey) && !string.IsNullOrEmpty(kafkaMessageKey) ? kafkaMessageKey : message.GetId(),
Value = message.Body
});
if (result.Status == PersistenceStatus.Persisted || result.Status == PersistenceStatus.PossiblyPersisted)
{
_logger.LogDebug($"kafka topic message [{message.GetName()}] has been published.");
return(OperateResult.Success);
}
throw new PublisherSentFailedException("kafka message persisted failed!");
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
var connection = _connectionPool.RentConnection();
try
{
var msg = new Msg(message.GetName(), message.Body);
foreach (var header in message.Headers)
{
msg.Header[header.Key] = header.Value;
}
var reply = connection.Request(msg);
if (reply.Data != null && reply.Data[0] == 1)
{
_logger.LogDebug($"NATS subject message [{message.GetName()}] has been consumed.");
return(Task.FromResult(OperateResult.Success));
}
throw new PublisherSentFailedException("NATS message send failed, no consumer reply!");
}
catch (Exception ex)
{
var warpEx = new PublisherSentFailedException(ex.Message, ex);
return(Task.FromResult(OperateResult.Failed(warpEx)));
}
finally
{
_connectionPool.Return(connection);
}
}
public async Task <OperateResult> SendAsync(TransportMessage transportMessage)
{
try
{
Connect();
var message = new Microsoft.Azure.ServiceBus.Message
{
MessageId = transportMessage.GetId(),
Body = transportMessage.Body,
Label = transportMessage.GetName(),
CorrelationId = transportMessage.GetCorrelationId()
};
foreach (var header in transportMessage.Headers)
{
message.UserProperties.Add(header.Key, header.Value);
}
await _topicClient.SendAsync(message);
_logger.LogDebug($"Azure Service Bus message [{transportMessage.GetName()}] has been published.");
return(OperateResult.Success);
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
return(OperateResult.Failed(wrapperEx));
}
}
public async Task <OperateResult> SendAsync(TransportMessage message)
{
try
{
await TryAddTopicArns();
if (_topicArnMaps.TryGetValue(message.GetName().NormalizeForAws(), out var arn))
{
string bodyJson = null;
if (message.Body != null)
{
bodyJson = Encoding.UTF8.GetString(message.Body);
}
var attributes = message.Headers.Where(x => x.Value != null).ToDictionary(x => x.Key,
x => new MessageAttributeValue
{
StringValue = x.Value,
DataType = "String"
});
var request = new PublishRequest(arn, bodyJson)
{
MessageAttributes = attributes
};
await _snsClient.PublishAsync(request);
_logger.LogDebug($"SNS topic message [{message.GetName().NormalizeForAws()}] has been published.");
return(OperateResult.Success);
}
var errorMessage = $"Can't be found SNS topics for [{message.GetName().NormalizeForAws()}]";
_logger.LogWarning(errorMessage);
return(OperateResult.Failed(
new PublisherSentFailedException(errorMessage),
new OperateError
{
Code = "SNS",
Description = $"Can't be found SNS topics for [{message.GetName().NormalizeForAws()}]"
}));
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(OperateResult.Failed(wrapperEx, errors));
}
}
public async Task <OperateResult> SendAsync(TransportMessage message)
{
var producer = _connectionPool.RentProducer();
try
{
var headers = new Confluent.Kafka.Headers();
foreach (var header in message.Headers)
{
headers.Add(header.Value != null
? new Header(header.Key, Encoding.UTF8.GetBytes(header.Value))
: new Header(header.Key, null));
}
var result = await producer.ProduceAsync(message.GetName(), new Message <string, byte[]>
{
Headers = headers,
Key = message.GetId(),
Value = message.Body
});
if (result.Status == PersistenceStatus.Persisted || result.Status == PersistenceStatus.PossiblyPersisted)
{
_logger.LogDebug($"kafka topic message [{message.GetName()}] has been published.");
return(OperateResult.Success);
}
var ex = new PublisherSentFailedException("kafka message persisted failed!");
return(OperateResult.Failed(ex));
}
catch (Exception ex)
{
var wapperEx = new PublisherSentFailedException(ex.Message, ex);
return(OperateResult.Failed(wapperEx));
}
finally
{
var returned = _connectionPool.Return(producer);
if (!returned)
{
producer.Dispose();
}
}
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
IModel channel = null;
try
{
channel = _connectionChannelPool.Rent();
channel.ConfirmSelect();
var props = channel.CreateBasicProperties();
props.DeliveryMode = 2;
props.Headers = message.Headers.ToDictionary(x => x.Key, x => (object)x.Value);
channel.ExchangeDeclare(_exchange, RabbitMQOptions.ExchangeType, true);
channel.BasicPublish(_exchange, message.GetName(), props, message.Body);
channel.WaitForConfirmsOrDie(TimeSpan.FromSeconds(5));
_logger.LogDebug($"RabbitMQ topic message [{message.GetName()}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wrapperEx, errors)));
}
finally
{
if (channel != null)
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
}
public async Task <OperateResult> SendAsync(TransportMessage message)
{
try
{
await redis.PublishAsync(message.GetName(), message.AsStreamEntries());
logger.LogDebug($"Redis message [{message.GetName()}] has been published.");
return(OperateResult.Success);
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
return(OperateResult.Failed(wrapperEx));
}
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
try
{
_queue.Send(message.GetName(), message);
_logger.LogDebug($"Event message [{message.GetName()}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
return(Task.FromResult(OperateResult.Failed(wrapperEx)));
}
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
FullRedis channel = null;
try
{
channel = _connectionChannelPool.Rent();
var queue = channel.GetQueue <string>(message.GetName());
queue.Add(JsonConvert.SerializeObject(message));
_logger.LogDebug($"RedisMQ topic message [{message.GetName()}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wrapperEx, errors)));
}
// finally
// {
// if (channel != null)
// {
// //var returned = _connectionChannelPool.Return(channel);
// if (!returned)
// {
// channel.Dispose();
// }
// }
// }
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
NetMQSocket channel = null;
try
{
channel = _connectionChannelPool.Rent();
NetMQMessage msg = new NetMQMessage();
msg.Append(message.GetName());
msg.Append(System.Text.Json.JsonSerializer.Serialize(message.Headers.ToDictionary(x => x.Key, x => (object)x.Value)));
msg.Append(message.Body);
channel.SendMultipartMessage(msg);
_logger.LogDebug($"ZeroMQ topic message [{message.GetName()}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wrapperEx, errors)));
}
finally
{
if (channel != null)
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
}
public async Task <OperateResult> SendAsync(TransportMessage message)
{
var connection = _connectionPool.RentConnection();
try
{
var msg = new Msg(message.GetName(), message.Body);
foreach (var header in message.Headers)
{
msg.Header[header.Key] = header.Value;
}
var js = connection.CreateJetStreamContext(_jetStreamOptions);
var builder = PublishOptions.Builder().WithMessageId(message.GetId());
var resp = await js.PublishAsync(msg, builder.Build());
if (resp.Seq > 0)
{
_logger.LogDebug($"NATS stream message [{message.GetName()}] has been published.");
return(OperateResult.Success);
}
throw new PublisherSentFailedException("NATS message send failed, no consumer reply!");
}
catch (Exception ex)
{
var warpEx = new PublisherSentFailedException(ex.Message, ex);
return(OperateResult.Failed(warpEx));
}
finally
{
_connectionPool.Return(connection);
}
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
var connection = _connectionPool.RentConnection();
try
{
var binFormatter = new BinaryFormatter();
using var mStream = new MemoryStream();
binFormatter.Serialize(mStream, message);
//connection.Publish(message.GetName(), mStream.ToArray());
//return Task.FromResult(OperateResult.Success);
var reply = connection.Request(message.GetName(), mStream.ToArray(), 2000);
if (reply.Data != null && reply.Data[0] == 1)
{
_logger.LogDebug($"NATS subject message [{message.GetName()}] has been consumed.");
return(Task.FromResult(OperateResult.Success));
}
throw new PublisherSentFailedException("NATS message send failed, no consumer reply!");
}
catch (Exception ex)
{
var warpEx = new PublisherSentFailedException(ex.Message, ex);
return(Task.FromResult(OperateResult.Failed(warpEx)));
}
finally
{
var returned = _connectionPool.Return(connection);
if (!returned)
{
connection.Dispose();
}
}
}
private void TracingAfter(long?tracingTimestamp, TransportMessage message, BrokerAddress broker)
{
if (tracingTimestamp.HasValue && s_diagnosticListener.IsEnabled("DotNetCore.CAP.WriteConsumeAfter"))
{
long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
CapEventDataSubStore eventData = new CapEventDataSubStore
{
OperationTimestamp = now,
Operation = message.GetName(),
BrokerAddress = broker,
TransportMessage = message,
ElapsedTimeMs = now - tracingTimestamp.Value
};
s_diagnosticListener.Write("DotNetCore.CAP.WriteConsumeAfter", eventData);
}
}
private long?TracingBefore(TransportMessage message, BrokerAddress broker)
{
if (s_diagnosticListener.IsEnabled("DotNetCore.CAP.WriteConsumeBefore"))
{
CapEventDataSubStore eventData = new CapEventDataSubStore
{
OperationTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
Operation = message.GetName(),
BrokerAddress = broker,
TransportMessage = message
};
s_diagnosticListener.Write("DotNetCore.CAP.WriteConsumeBefore", eventData);
return(eventData.OperationTimestamp);
}
return(null);
}
private void TracingAfter(long?tracingTimestamp, TransportMessage message, BrokerAddress broker)
{
if (tracingTimestamp != null && s_diagnosticListener.IsEnabled(CapDiagnosticListenerNames.AfterConsume))
{
var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
var eventData = new CapEventDataSubStore()
{
OperationTimestamp = now,
Operation = message.GetName(),
BrokerAddress = broker,
TransportMessage = message,
ElapsedTimeMs = now - tracingTimestamp.Value
};
s_diagnosticListener.Write(CapDiagnosticListenerNames.AfterConsume, eventData);
}
}
private long? TracingBefore(TransportMessage message, BrokerAddress broker)
{
if (s_diagnosticListener.IsEnabled(CapDiagnosticListenerNames.BeforeConsume))
{
var eventData = new CapEventDataSubStore()
{
OperationTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
Operation = message.GetName(),
BrokerAddress = broker,
TransportMessage = message
};
s_diagnosticListener.Write(CapDiagnosticListenerNames.BeforeConsume, eventData);
return eventData.OperationTimestamp;
}
return null;
}
private void TracingError(long?tracingTimestamp, TransportMessage message, BrokerAddress broker, OperateResult result)
{
if (tracingTimestamp != null && s_diagnosticListener.IsEnabled(CapDiagnosticListenerNames.ErrorPublish))
{
var ex = new PublisherSentFailedException(result.ToString(), result.Exception);
var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
var eventData = new CapEventDataPubSend()
{
OperationTimestamp = now,
Operation = message.GetName(),
BrokerAddress = broker,
TransportMessage = message,
ElapsedTimeMs = now - tracingTimestamp.Value,
Exception = ex
};
s_diagnosticListener.Write(CapDiagnosticListenerNames.ErrorPublish, eventData);
}
}
