/// <summary>
/// Publish message to a topic
/// </summary>
/// <param name="keyName">Topic name</param>
/// <param name="content">Message content</param>
/// <returns>Publish result</returns>
public override Task <OperateResult> PublishAsync(string keyName, string content)
{
var session = _connectionPool.Rent();
try
{
var destination = session.GetTopic(keyName);
using (IMessageProducer producer = session.CreateProducer(destination))
{
var message = session.CreateTextMessage(content);
producer.Send(message);
}
var returned = _connectionPool.Return(session);
if (!returned)
{
session.Dispose();
}
_logger.LogDebug($"ActiveMQ topic message [{keyName}] has been published. Body: {content}");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
session.Dispose();
var wapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wapperEx, errors)));
}
}
public override async Task <OperateResult> PublishAsync(string keyName, string content)
{
try
{
var contentBytes = Encoding.UTF8.GetBytes(content);
var message = new Message
{
MessageId = Guid.NewGuid().ToString(),
Body = contentBytes,
Label = keyName,
};
await _topicClient.SendAsync(message);
_logger.LogDebug($"Azure Service Bus message [{keyName}] 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 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 override Task <OperateResult> PublishAsync(string keyName, string content)
{
var channel = _connectionChannelPool.Rent();
try
{
var body = Encoding.UTF8.GetBytes(content);
channel.ExchangeDeclare(_exchange, RabbitMQOptions.ExchangeType, true);
channel.BasicPublish(_exchange, keyName, null, body);
_logger.LogDebug($"RabbitMQ topic message [{keyName}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wapperEx, errors)));
}
finally
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
public override async Task <OperateResult> PublishAsync(string keyName, string content)
{
var producer = _connectionPool.Rent();
try
{
var contentBytes = Encoding.UTF8.GetBytes(content);
var message = await producer.ProduceAsync(keyName, null, contentBytes);
if (message.Error.HasError)
{
throw new PublisherSentFailedException(message.Error.ToString());
}
_logger.LogDebug($"kafka topic message [{keyName}] has been published.");
return(OperateResult.Success);
}
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)
{
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 override Task <OperateResult> PublishAsync(string keyName, string content)
{
var producer = _connectionProducerPool.Rent();
try
{
var body = Encoding.UTF8.GetBytes(content);
var bytesMessage = producer.CreateBytesMessage(body);
producer.Send(new ActiveMQTopic($"VirtualTopic.{keyName}"), bytesMessage);
_logger.LogDebug($"ActiveMQ topic message [{keyName}] has been published. Body: {content}");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wapperEx, errors)));
}
finally
{
var returned = _connectionProducerPool.Return(producer);
if (!returned)
{
producer.Close();
producer.Dispose();
}
}
}
public override async Task <OperateResult> PublishAsync(string keyName, string content)
{
var producer = _connectionPool.RentProducer();
try
{
var result = await producer.ProduceAsync(keyName, new Message <Null, string>()
{
Value = content
});
if (result.Status == PersistenceStatus.Persisted || result.Status == PersistenceStatus.PossiblyPersisted)
{
_logger.LogDebug($"kafka topic message [{keyName}] has been published.");
return(OperateResult.Success);
}
throw new PublisherSentFailedException("kafka message persisted failed!");
}
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 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 override Task <OperateResult> PublishAsync(string keyName, string content)
{
#region 个人添加的
var items = keyName.Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
if (items.Length != 2)
{
throw new Exception("传入的keyName必须包含routingKey和queueName，并且以短杠隔开！");
}
var routingKey = items[0];
var queueName = items[1];
#endregion
var channel = _connectionChannelPool.Rent();
try
{
var body = Encoding.UTF8.GetBytes(content);
channel.ExchangeDeclare(_exchange, RabbitMQOptions.ExchangeType, true);
#region 个人添加的
var arguments = new Dictionary <string, object>
{
{ "x-message-ttl", _rabbitMQOptions.QueueMessageExpires }
};
channel.QueueDeclare(queueName, true, false, false, arguments);
channel.QueueBind(queueName, _exchange, routingKey);
#endregion
channel.BasicPublish(_exchange, routingKey, null, body);
_logger.LogDebug($"RabbitMQ topic message [{routingKey}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wapperEx, errors)));
}
finally
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
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 Task <OperateResult> SendAsync(TransportMessage message)
{
try
{
_queue.Send(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 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));
}
}
private void TracingError(Guid operationId, CapPublishedMessage message, OperateResult result, DateTimeOffset startTime, TimeSpan du)
{
var ex = new PublisherSentFailedException(result.ToString(), result.Exception);
_logger.MessagePublishException(message.Id, result.ToString(), ex);
var eventData = new BrokerPublishErrorEventData(
operationId,
"",
ServersAddress,
message.Name,
message.Content,
ex,
startTime,
du);
s_diagnosticListener.WritePublishError(eventData);
}
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 override Task <OperateResult> PublishAsync(string keyName, string content)
{
var account = new CmqAccount("", "", "");
try
{
account.createTopic(keyName, 1);
_logger.LogDebug($"CMQ topic message [{keyName}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wapperEx, errors)));
}
}
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();
}
}
}
