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 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();
}
}
}
/// <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 void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32)
{
SlaveID = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Param = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct)
{
Error = new OperateError();
Error.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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 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 bool Refresh(int slaveid, bool operate)
{
try
{
if (!transport.IsOpen)
{
transport.Open();
}
OperateError error = client.DeviceRefresh(slaveid, operate);
return(error.Status);
}
catch (Exception ex)
{
LogHelper.Error("刷新设备列表失败", ex);
return(false);
}
}
public bool SetTemp(int slaveid, double temp)
{
try
{
if (!transport.IsOpen)
{
transport.Open();
}
OperateError error = client.SetTemp(slaveid, temp);
return(error.Status);
}
catch (Exception ex)
{
LogHelper.Error("设置温度失败", ex);
return(false);
}
}
public bool SetMode(int slaveid, int mode)
{
try
{
if (!transport.IsOpen)
{
transport.Open();
}
OperateError error = client.SetMode(slaveid, mode);
return(error.Status);
}
catch (Exception ex)
{
LogHelper.Error("设置模式失败", ex);
return(false);
}
}
public bool Operate(int slaveid, bool open)
{
try
{
if (!transport.IsOpen)
{
transport.Open();
}
OperateError error = client.OperateDevice(slaveid, open);
return(error.Status);
}
catch (Exception ex)
{
LogHelper.Error("启停设备失败", ex);
return(false);
}
}
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 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)));
}
}
