///<summary>Fires the Received event.</summary>
public override void HandleBasicDeliver(string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties properties,
byte[] body)
{
base.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
properties,
body);
if (Received != null) {
Received(this, new BasicDeliverEventArgs(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
properties,
body));
}
}
/// <summary>Converts from BasicProperties to MessageProperties.</summary>
/// <param name="source">The source.</param>
/// <param name="envelope">The envelope.</param>
/// <param name="charset">The charset.</param>
/// <returns>The message properties.</returns>
public MessageProperties ToMessageProperties(IBasicProperties source, BasicGetResult envelope, string charset)
{
var target = new MessageProperties();
var headers = source.Headers;
if (headers != null && headers.Count > 0)
{
foreach (DictionaryEntry entry in headers)
{
var value = entry.Value;
/*
if (value is LongString)
{
value = this.convertLongString((LongString) value, charset);
}
*/
target.Headers[(string)entry.Key] = value;
}
}
target.Timestamp = source.Timestamp.ToDateTime();
target.MessageId = source.MessageId;
target.UserId = source.UserId;
target.AppId = source.AppId;
target.ClusterId = source.ClusterId;
target.Type = source.Type;
target.DeliveryMode = (MessageDeliveryMode)source.DeliveryMode;
target.Expiration = source.Expiration;
target.Priority = source.Priority;
target.ContentType = source.ContentType;
target.ContentEncoding = source.ContentEncoding;
var correlationId = source.CorrelationId;
if (correlationId != null)
{
try
{
target.CorrelationId = source.CorrelationId.ToByteArrayWithEncoding(charset);
}
catch (Exception ex)
{
throw new AmqpUnsupportedEncodingException(ex);
}
}
var replyTo = source.ReplyTo;
if (replyTo != null)
{
target.ReplyTo = replyTo;
}
if (envelope != null)
{
target.ReceivedExchange = envelope.Exchange;
target.ReceivedRoutingKey = envelope.RoutingKey;
target.Redelivered = envelope.Redelivered;
target.DeliveryTag = (long)envelope.DeliveryTag;
}
return target;
}
public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
if (!Model.IsOpen) return;
var messageObject = Serializer.Deserialize(body, Subscription.MessageType);
var propertyHeaders = properties.Headers;
var headers = new Dictionary<string, string>();
if (propertyHeaders != null)
{
foreach (var propertyHeader in propertyHeaders)
{
headers.Add(propertyHeader.Key, Encoding.UTF8.GetString((byte[])propertyHeader.Value));
}
}
Log.Info("Executing handler for delivery tag '{0}' from queue '{1}'", deliveryTag, Subscription.QueueName);
Log.Debug("Message with delivery tag '{0}': '{1}'", deliveryTag, Encoding.UTF8.GetString(body));
try
{
ExecuteSubscriptionMessageHandler(properties, messageObject, headers);
Model.BasicAck(deliveryTag, false);
}
catch (Exception e)
{
Model.BasicNack(deliveryTag, false, true);
Log.Error(e, "Exception executing message handler for subscription '{0}'!", Subscription.SubscriptionId);
throw;
}
}
public void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
if (Deliver != null)
{
Deliver(this, new DeliverEventArgs(consumerTag, deliveryTag, redelivered, exchange, this.Queue, routingKey, properties, body));
}
}
public override void HandleBasicDeliver(
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties properties,
byte[] body )
{
Loop.Enqueue( () =>
{
var envelope = GetEnvelope( properties );
envelope.ByteStream = body;
envelope.Initialize(
consumerTag,
properties,
deliveryTag,
exchange,
Proxy,
redelivered,
routingKey
);
var translatedEnvelope = DeserializeMessage( envelope );
DispatchResult( translatedEnvelope );
} );
}
public void CopyFrom(IBasicProperties basicProperties)
{
Preconditions.CheckNotNull(basicProperties, "basicProperties");
if (basicProperties.IsContentTypePresent()) ContentType = basicProperties.ContentType;
if (basicProperties.IsContentEncodingPresent()) ContentEncoding = basicProperties.ContentEncoding;
if (basicProperties.IsDeliveryModePresent()) DeliveryMode = basicProperties.DeliveryMode;
if (basicProperties.IsPriorityPresent()) Priority = basicProperties.Priority;
if (basicProperties.IsCorrelationIdPresent()) CorrelationId = basicProperties.CorrelationId;
if (basicProperties.IsReplyToPresent()) ReplyTo = basicProperties.ReplyTo;
if (basicProperties.IsExpirationPresent()) Expiration = basicProperties.Expiration;
if (basicProperties.IsMessageIdPresent()) MessageId = basicProperties.MessageId;
if (basicProperties.IsTimestampPresent()) Timestamp = basicProperties.Timestamp.UnixTime;
if (basicProperties.IsTypePresent()) Type = basicProperties.Type;
if (basicProperties.IsUserIdPresent()) UserId = basicProperties.UserId;
if (basicProperties.IsAppIdPresent()) AppId = basicProperties.AppId;
if (basicProperties.IsClusterIdPresent()) ClusterId = basicProperties.ClusterId;
if (basicProperties.IsHeadersPresent())
{
foreach (var header in basicProperties.Headers)
{
Headers.Add(header.Key, header.Value);
}
}
}
public BasicPropertiesWrapper(IBasicProperties basicProperties)
{
ContentType = basicProperties.ContentType;
ContentEncoding = basicProperties.ContentEncoding;
DeliveryMode = basicProperties.DeliveryMode;
Priority = basicProperties.Priority;
CorrelationId = basicProperties.CorrelationId;
ReplyTo = basicProperties.ReplyTo;
Expiration = basicProperties.Expiration;
MessageId = basicProperties.MessageId;
Timestamp = basicProperties.Timestamp.UnixTime;
Type = basicProperties.Type;
UserId = basicProperties.UserId;
AppId = basicProperties.AppId;
ClusterId = basicProperties.ClusterId;
if (basicProperties.IsHeadersPresent())
{
Headers = new HybridDictionary();
foreach (DictionaryEntry header in basicProperties.Headers)
{
Headers.Add(header.Key, header.Value);
}
}
}
public static IBasicProperties FillRabbitMqProperties(TransportMessage message, IBasicProperties properties)
{
properties.MessageId = message.Id;
properties.CorrelationId = message.CorrelationId;
if (message.TimeToBeReceived < TimeSpan.MaxValue)
properties.Expiration = message.TimeToBeReceived.TotalMilliseconds.ToString();
properties.SetPersistent(message.Recoverable);
properties.Headers = message.Headers;
if (message.Headers.ContainsKey(Headers.EnclosedMessageTypes))
{
properties.Type = message.Headers[Headers.EnclosedMessageTypes].Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
}
if (message.Headers.ContainsKey(Headers.ContentType))
properties.ContentType = message.Headers[Headers.ContentType];
else
{
properties.ContentType = "application/octet-stream";
}
if (message.ReplyToAddress != null && message.ReplyToAddress != Address.Undefined)
properties.ReplyTo = message.ReplyToAddress.Queue;
return properties;
}
public void HandleBasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
byte[] body)
{
UnlessShuttingDown(() =>
{
try
{
consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
body);
}
catch (Exception e)
{
var details = new Dictionary<string, object>()
{
{"consumer", consumer},
{"context", "HandleBasicDeliver"}
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
});
}
public void HandleBasicDeliver(ulong deliveryTag, IBasicProperties properties, object body)
{
if (!Model.IsOpen) return;
Model.BasicAck(deliveryTag, false); // TODO: Review - Check case of failure on Message Handler
Task.Run(() =>
{
var messageObject = body;
var propertyHeaders = properties.Headers;
var headers = new Dictionary<string, string>();
if (propertyHeaders != null)
{
foreach (var propertyHeader in propertyHeaders)
{
headers.Add(propertyHeader.Key, (string)propertyHeader.Value);
}
}
Log.Info("Executing handler for delivery tag '{0}' from queue '{1}'", deliveryTag, Subscription.QueueName);
try
{
ExecuteSubscriptionMessageHandler(properties, messageObject, headers);
}
catch (Exception e)
{
Log.Error(e, "Exception executing message handler for subscription '{0}'!", Subscription.SubscriptionId);
throw;
}
});
}
public override void HandleBasicDeliver(String consumerTag,
UInt64 deliveryTag,
Boolean redelivered,
String exchange,
String routingKey,
IBasicProperties properties,
Byte[] body)
{
base.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
properties,
body);
var args = new BasicDeliverEventArgs
{
ConsumerTag = consumerTag,
DeliveryTag = deliveryTag,
Redelivered = redelivered,
Exchange = exchange,
RoutingKey = routingKey,
BasicProperties = properties,
Body = body
};
ConsumeInternalAsync(args);
}
/// <summary>
/// 入队操作
/// </summary>
/// <param name="bytes"></param>
/// <param name="property"></param>
/// <param name="persistent"></param>
public static void Enqueue(byte[] bytes, IBasicProperties property, bool persistent = false)
{
IModel channel = channels[new Random().Next(0, channels_num)]; //随机选取channel发送数据
if (property == null) property = channel.CreateBasicProperties(); //额外的属性,添加消息头的
property.SetPersistent(persistent); //消息持久化
channel.BasicPublish(exchange_name, route_key, property, bytes);
}
private void InitializeConnection()
{
try
{
Channel = RabbitChannelProvider.OpenChannelToHost(HostConfig);
CreateExchange(_exchangeConfig);
_sentMessageProperties = Channel.CreateBasicProperties();
_sentMessageProperties.ContentType = "text/plain";
if (_messagesMustBeRouted)
{
CreateQueue(_deadLetterQueueConfig);
_sentMessageProperties.DeliveryMode = 2; // 1 = Delivery is optional, 2 = Delivery is mandatory
Channel.BasicReturn += (sender, eventArgs) =>
{
Log.ErrorFormat(CultureInfo.InvariantCulture,
"Message sent by publisher could not be routed. Message: \"{0}\"",
Encoding.UTF8.GetString(eventArgs.Body));
};
}
}
catch (BrokerUnreachableException ex)
{
throw new ConnectionException("Publisher was unable to connect to broker. Check that the broker is online and the publisher is configured correctly.", ex);
}
}
internal void HydrateProperties(IBasicProperties properties)
{
properties.Persistent = false;
foreach (var pair in _dictionary)
if (!_reserverKeys.Contains(pair.Key))
properties.Headers.Add(pair.Key, pair.Value);
}
protected override void ExecuteSubscriptionMessageHandler(IBasicProperties properties, object message, Dictionary<string, string> headers)
{
var messageType = message.GetType();
InSingleProcessMemoryAuthorizer.Verify(Operation, messageType, message, headers);
base.ExecuteSubscriptionMessageHandler(properties, message, headers);
}
public InSingleProcessMemoryMessage(ulong deliveryTag, string routingKey, IBasicProperties properties,
object body)
{
DeliveryTag = deliveryTag;
RoutingKey = routingKey;
BasicProperties = properties;
Body = body;
}
public RabbitEnvelope GetEnvelope( IBasicProperties basicProperties )
{
var messageTypeBuffer = (byte[]) basicProperties.Headers["MessageType"];
var messageTypeName = Encoding.UTF8.GetString( messageTypeBuffer );
var messageType = Type.GetType( messageTypeName );
var envelopeType = typeof( RabbitEnvelope<> ).MakeGenericType( messageType );
return Activator.CreateInstance( envelopeType ) as RabbitEnvelope;
}
//public static void Main(string[] args)
//{
// var factory = new ConnectionFactory() { HostName = "localhost" };
// using (var connection = factory.CreateConnection())
// using (var channel = connection.CreateModel())
// {
// channel.QueueDeclare(queue: "task_queue",
// durable: true,
// exclusive: false,
// autoDelete: false,
// arguments: null);
// var properties = channel.CreateBasicProperties();
// properties.SetPersistent(true);
// for (var i = 0; i < 10; i++)
// {
// var text = String.Format("Message Numero {0}", i);
// var message = GetMessage(args, text);
// var body = Encoding.UTF8.GetBytes(message);
// GenerateQueueItems(args, channel, properties, body, message);
// }
// }
// Console.WriteLine(" Press [enter] to exit.");
// Console.ReadLine();
//}
private static void GenerateQueueItems(string[] args, IModel channel, IBasicProperties properties, byte[] body, string message)
{
channel.BasicPublish(exchange: "",
routingKey: "task_queue",
basicProperties: properties,
body: body);
Console.WriteLine(" [x] Sent {0}", message);
}
///<summary>Construct an instance ready for writing.</summary>
public BasicMessageBuilder(IModel model, int initialAccumulatorSize) {
m_properties = model.CreateBasicProperties();
m_accumulator = new MemoryStream(initialAccumulatorSize);
string contentType = GetDefaultContentType();
if (contentType != null) {
Properties.ContentType = contentType;
}
}
public RabbitMq(bool durable)
{
_connection = _factory.CreateConnection();
_session = durable ? _connection.CreateDurableSession() : _connection.CreateNonDurableSession();
_props = _session.Model.CreateBasicProperties();
_props.SetPersistent(true);
_consumeThread = new Thread(ReadMessages);
}
public byte[] Serialize(object instance, IBasicProperties prop)
{
var buffer = new byte[16];
_number.GetNonZeroBytes(buffer);
_byte2instance[buffer] = instance;
return buffer;
}
public override void HandleBasicDeliver(string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties properties,
byte[] body)
{
throw new SystemException("I am a bad consumer");
}
public override void Publish(string message, string exchangeName, string routingKey,
IBasicProperties messageProperties = null) {
if (!IsConnected) Connect();
using (var channel = _connection.CreateModel()) {
var payload = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchangeName, routingKey,
messageProperties ?? RabbitMQProperties.CreateDefaultProperties(channel), payload);
}
}
public MessageContext(IBasicProperties basicProperties)
{
MessageId = basicProperties.MessageId;
CorrelationId = basicProperties.CorrelationId;
ReplyTo = basicProperties.ReplyTo;
Type = basicProperties.Type;
ContentType = basicProperties.ContentType;
ContentEncoding = basicProperties.ContentEncoding;
Headers = basicProperties.Headers;
}
public static void FlagHeaders(IBasicProperties properties)
{
var headers = properties.Headers;
if (headers == null)
{
headers = new Dictionary<string, object>();
properties.Headers = headers;
}
headers[Header] = FlagVal;
}
public DequeueResult(ulong deliveryTag, bool redelivered, string exchange, string routingKey, uint messageCount, IBasicProperties basicProperties, Stream body)
{
DeliveryTag = deliveryTag;
Redelivered = redelivered;
Exchange = exchange;
RoutingKey = routingKey;
MessageCount = messageCount;
BasicProperties = basicProperties;
Body = body;
}
public RabbitMessageQueueDataManager(string queueName, string rabbitServerConnString)
{
if (string.IsNullOrEmpty(rabbitServerConnString))
throw new ArgumentNullException(nameof(rabbitServerConnString));
if (string.IsNullOrEmpty(queueName))
throw new ArgumentNullException(nameof(queueName));
this.QueueName = queueName;
this._channel = RabbitMessageQueueUtils.GetQueueChanel(rabbitServerConnString);
this._commonMessageHeader = this.GetCommonMessageHeader();
}
public override void Publish(string message, string queueName, bool createQueue = true,
IBasicProperties messageProperties = null, IDictionary<string, object> queueArgs = null) {
if (!IsConnected) Connect();
using (var channel = _connection.CreateModel()) {
if (createQueue) channel.QueueDeclare(queueName, true, false, false, queueArgs);
var payload = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(string.Empty, queueName,
messageProperties ?? RabbitMQProperties.CreateDefaultProperties(channel), payload);
}
}
public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
Func<Task<bool>> func = () => ConsumeMessage(redelivered, deliveryTag, properties, body).ContinueWith(t =>
{
_errorSubscriber.UnhandledException(t.Exception);
return false;
}, TaskContinuationOptions.OnlyOnFaulted);
_taskFactory.StartNew(func).Unwrap();
}
public override void HandleBasicDeliver(
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties properties,
byte[] body)
{
callback(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
}
public void Publish(IModel channel, Type type, TransportMessage message, IBasicProperties properties)
{
throw new NotImplementedException();
}
public ServerRabbit()
{
logger.Info("Server started");
ConnectionFactory factory = new ConnectionFactory()
{
UserName = "******", Password = "******", HostName = "localhost"
};
connection = factory.CreateConnection();
channel = connection.CreateModel();
channel.QueueDeclare(queue: "rpc_queue", durable: false, exclusive: false, autoDelete: false, arguments: null);
//channel.BasicQos(0, 1, false);
var consumer = new EventingBasicConsumer(channel);
channel.BasicConsume(queue: "rpc_queue", autoAck: true, consumer: consumer);
consumer.Received += (model, ea) =>
{
IBasicProperties props = ea.BasicProperties;
if (!ClientsList.Exists((c) => c.QeueuName == props.ReplyTo))
{
ClientsList.Add(new ClientPeer()
{
QeueuName = props.ReplyTo, LastUpTime = DateTime.UtcNow
});
logger.Info($"Was added a client: {props.ReplyTo}");
}
Object obtained = ea.Body.Deserializer();
switch (obtained)
{
//case ObjectCategory.Message:
// Message mess = ea.Body.Deserializer<Message>();
// IBasicProperties replyPropMessage = channel.CreateBasicProperties();
// replyPropMessage.CorrelationId = props.CorrelationId;
// foreach (ClientPeer p in ClientsList)
// {
// if (props.ReplyTo != p.qName)
// channel.BasicPublish(exchange: "", routingKey: p.qName, basicProperties: replyPropMessage, body: mess.Serializer());
// }
// break;
case PingPeer p:
//ClientsList.ForEach((c) =>
//{
// if (c.QeueuName == ea.BasicProperties.ReplyTo)
// {
// logger.Info($"client's queue: {c.QeueuName} refreshed");
// c.LastUpTime = DateTime.UtcNow;
// }
//});
ClientPeer peer = ClientsList.FirstOrDefault((pr) => pr.QeueuName == ea.BasicProperties.ReplyTo);
if (peer != null)
{
peer.LastUpTime = DateTime.UtcNow;
}
break;
//case ObjectCategory.GameData:
// GameData game = ea.Body.Deserializer<GameData>();
// IBasicProperties replyPropGame = channel.CreateBasicProperties();
// replyPropGame.CorrelationId = props.CorrelationId;
// foreach (ClientPeer p in ClientsList)
// {
// if (props.ReplyTo != p.qName)
// channel.BasicPublish(exchange: "", routingKey: p.qName, basicProperties: replyPropGame, body: game.Serializer());
// }
// break;
default:
logger.Error("Type is different!");
break;
}//switch
};
tokenSource = new CancellationTokenSource();
PingToAll();
}//ctor
/// <summary>
/// (Extension method) Convenience overload of BasicPublish.
/// </summary>
/// <remarks>
/// The publication occurs with mandatory=false
/// </remarks>
public static Task BasicPublish(this IModel model, string exchange, string routingKey, IBasicProperties basicProperties, byte[] body)
{
return(model.BasicPublish(exchange, routingKey, false, basicProperties, body));
}
public RabbitMQRequestClient(ILoggerFactory logger, RabbitMQConfiguration hostConfig)
{
_logger = logger?
.AddConsole()
.AddDebug()
.CreateLogger <RabbitMQRequestClient <TRequest, TResponse> >()
?? throw new ArgumentNullException("Logger reference is required");
try
{
_hostConfig = hostConfig;
exchange = _hostConfig.exchange;
route = _hostConfig.routes.FirstOrDefault() ?? throw new ArgumentNullException("route queue is missing.");
var host = Helper.ExtractHostStructure(_hostConfig.hostName);
connectionFactory = new ConnectionFactory()
{
HostName = host.hostName,
Port = host.port ?? defaultMiddlewarePort,
UserName = _hostConfig.userName,
Password = _hostConfig.password,
ContinuationTimeout = TimeSpan.FromSeconds(DomainModels.System.Identifiers.TimeoutInSec)
};
new Function(_logger, DomainModels.System.Identifiers.RetryCount).Decorate(() =>
{
connection = connectionFactory.CreateConnection();
channel = connection.CreateModel();
return(true);
}, (ex) =>
{
switch (ex)
{
case BrokerUnreachableException brokerEx:
return(true);
case ConnectFailureException connEx:
return(true);
case SocketException socketEx:
return(true);
default:
return(false);
}
}).Wait();
replyQueueName = channel.QueueDeclare().QueueName;
consumer = new EventingBasicConsumer(channel);
props = channel.CreateBasicProperties();
props.Persistent = true;
var correlationId = Guid.NewGuid().ToString();
props.CorrelationId = correlationId;
props.ReplyTo = replyQueueName;
consumer.Received += (model, ea) =>
{
try
{
if (ea.Body == null)
{
return;
}
var response = Utilities.JsonBinaryDeserialize <TResponse>(ea.Body);
if (response == null)
{
response = default(TResponse);
}
if (ea.BasicProperties.CorrelationId == correlationId)
{
respQueue.Add(response);
}
}
catch (Exception ex)
{
_logger.LogError("Error while processing message by query client", ex);
throw ex;
}
};
}
catch (Exception ex)
{
_logger.LogError("Failed to initialize RabbitMQQueryClient", ex);
throw ex;
}
}
private void PublishSingleMessage(string message, ConnectionFactory _factory, string exchange, IBasicProperties properties)
{
using (var connection = _factory.CreateConnection())
using (var channel = connection.CreateModel())
{
var props = properties ?? channel.CreateBasicProperties();
var queueName = channel.QueueDeclare().QueueName;
channel.ConfirmSelect();
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: exchange, routingKey: "configuration.train", basicProperties: props, body: body);
channel.WaitForConfirmsOrDie(new TimeSpan(0, 0, 5));
}
}
private static MessageEnvelope Deserialize(byte[] bytes, string exchange, ulong deliveryTag, bool redelivered, string routingKey, IBasicProperties basicProperties, MessageClientBase messageClient)
{
var envelope = MessageEnvelope.Deserialize(bytes, messageClient);
envelope.Exchange = exchange;
envelope.DeliveryTag = deliveryTag;
envelope.Redelivered = redelivered;
envelope.RoutingKey = routingKey;
envelope.BasicProperties = basicProperties;
if (basicProperties != null && basicProperties.Headers != null)
{
List <MessageTag> tags = new List <MessageTag>();
foreach (var key in basicProperties.Headers.Keys)
{
tags.Add(MessageTag.DemangleTag(key));
}
envelope.Tags = tags.ToArray();
}
return(envelope);
}
public void CopyFrom(IBasicProperties basicProperties)
{
Preconditions.CheckNotNull(basicProperties, "basicProperties");
if (basicProperties.IsContentTypePresent())
{
ContentType = basicProperties.ContentType;
}
if (basicProperties.IsContentEncodingPresent())
{
ContentEncoding = basicProperties.ContentEncoding;
}
if (basicProperties.IsDeliveryModePresent())
{
DeliveryMode = basicProperties.DeliveryMode;
}
if (basicProperties.IsPriorityPresent())
{
Priority = basicProperties.Priority;
}
if (basicProperties.IsCorrelationIdPresent())
{
CorrelationId = basicProperties.CorrelationId;
}
if (basicProperties.IsReplyToPresent())
{
ReplyTo = basicProperties.ReplyTo;
}
if (basicProperties.IsExpirationPresent())
{
Expiration = basicProperties.Expiration;
}
if (basicProperties.IsMessageIdPresent())
{
MessageId = basicProperties.MessageId;
}
if (basicProperties.IsTimestampPresent())
{
Timestamp = basicProperties.Timestamp.UnixTime;
}
if (basicProperties.IsTypePresent())
{
Type = basicProperties.Type;
}
if (basicProperties.IsUserIdPresent())
{
UserId = basicProperties.UserId;
}
if (basicProperties.IsAppIdPresent())
{
AppId = basicProperties.AppId;
}
if (basicProperties.IsClusterIdPresent())
{
ClusterId = basicProperties.ClusterId;
}
if (basicProperties.IsHeadersPresent())
{
foreach (var header in basicProperties.Headers)
{
Headers.Add(header.Key, header.Value);
}
}
}
public void Send(IModel channel, Address address, TransportMessage message, IBasicProperties properties)
{
var subscriberName = address.Queue;
channel.BasicPublish(subscriberName, String.Empty, true, properties, message.Body);
}
public MessageProperties(IBasicProperties basicProperties)
: this()
{
CopyFrom(basicProperties);
}
public void Publish(IModel channel, Type type, TransportMessage message, IBasicProperties properties)
{
SetupTypeSubscriptions(channel, type);
channel.BasicPublish(ExchangeName(type), String.Empty, true, properties, message.Body);
}
private static void Listen()
{
IConnectionFactory connectionFactory = new ConnectionFactory
{
HostName = "localhost"
};
using (IConnection connection = connectionFactory.CreateConnection())
{
using (IModel channel = connection.CreateModel())
{
channel.QueueDeclare(
queue: "reversestring_queue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null
);
channel.BasicQos(
prefetchSize: 0,
prefetchCount: 1,
global: false
);
Console.WriteLine("[*] Waiting for request...");
EventingBasicConsumer consumer = new EventingBasicConsumer(channel);
consumer.Received += (sender, payload) =>
{
string result = "";
string input = Encoding.UTF8.GetString(payload.Body);
IBasicProperties requestProps = payload.BasicProperties;
IBasicProperties responseProps = channel.CreateBasicProperties();
responseProps.CorrelationId = requestProps.CorrelationId;
try
{
result = ReverseString(input);
Console.WriteLine("[#] Incoming request.");
Console.WriteLine($"[*] `{input}` -> `{result}`");
}
catch (Exception ex)
{
result = "";
Console.WriteLine(ex);
}
finally
{
byte[] resultBytes = Encoding.UTF8.GetBytes(result);
channel.BasicPublish(
exchange: "",
routingKey: requestProps.ReplyTo,
basicProperties: responseProps,
body: resultBytes
);
channel.BasicAck(deliveryTag: payload.DeliveryTag, multiple: false);
}
};
channel.BasicConsume(
queue: "reversestring_queue",
autoAck: false,
consumer: consumer
);
Console.WriteLine("[!] Press [ENTER] to quit");
Console.ReadLine();
}
}
}
public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
RabbitDataHandler rabbitDataHandler = new RabbitDataHandler();
CarService carService = new CarService();
string result = "";
string documentID = "";
try
{
if (exchange.Equals("request.cars"))
{
connClass = new ConnectionClass();
ConnectionFactory connectionFactory = connClass.getConnectionFactored();
var model = connClass.getModel();
connClass.getProperties().Persistent = false;
switch (routingKey)
{
// update is Available
case "request.reservecar":
documentID = JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(body));
result = carService.markCarAsReserved(documentID);
break;
// get available Cars Count By Category & Location
case "request.get.car.counter":
var getcarcounter_locationAndCat = JsonConvert.DeserializeObject <Object>(Encoding.UTF8.GetString(body));
var getcarcounter_Location = ((Newtonsoft.Json.Linq.JContainer)getcarcounter_locationAndCat).First;
var getcarcounter_LocationID = ((Newtonsoft.Json.Linq.JProperty)getcarcounter_Location).Value;
var getcarcounter_category = ((Newtonsoft.Json.Linq.JContainer)getcarcounter_locationAndCat).Last;
var getcarcounter_categoryID = ((Newtonsoft.Json.Linq.JProperty)getcarcounter_Location).Value;
result = carService.get_CarCount_CategoryCount_PerLocation((int)getcarcounter_LocationID, (int)getcarcounter_categoryID);
break;
// Get random car
case "request.get.random.car":
var locationAndCat = JsonConvert.DeserializeObject <Object>(Encoding.UTF8.GetString(body));
var Location = ((Newtonsoft.Json.Linq.JContainer)locationAndCat).First;
var LocationID = ((Newtonsoft.Json.Linq.JProperty)Location).Value;
var category = ((Newtonsoft.Json.Linq.JContainer)locationAndCat).Last;
var categoryID = ((Newtonsoft.Json.Linq.JProperty)Location).Value;
result = carService.get_RandomCarBy_Category_And_Location((int)LocationID, (int)categoryID);
break;
case "request.car.delete":
documentID = JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(body));
result = carService.DeleteCarByDocumentID(documentID);
break;
case "request.get.categories.by.locationid":
int LocID = JsonConvert.DeserializeObject <int>(Encoding.UTF8.GetString(body));
result = carService.getCategoriesListPerLocation(LocID);
break;
case "request.get.locationlist":
result = carService.getLocationList();
break;
}
byte[] messagebuffer = Encoding.Default.GetBytes(result);
model.BasicPublish(exchange, routingKey, connClass.getProperties(), messagebuffer);
//model.BasicConsume("cars.queue", true);
// rpc test
//var replyQueueName = _channel.QueueDeclare("rpc_reply", true, false, false, null);
//_consumer = new QueueingBasicConsumer(_channel);
//_channel.BasicConsume(replyQueueName, true, _consumer);
//var props = _channel.CreateBasicProperties();
//props.ReplyTo = replyQueueName;
//props.CorrelationId = Guid.NewGuid().ToString();
//model.BasicPublish("", "rpc_reply", props, messagebuffer);
//var ea = _consumer.Queue.Dequeue();
//var props = ea.BasicProperties;
//var replyProps = _channel.CreateBasicProperties();
//replyProps.CorrelationId = props.CorrelationId;
//long deliveryTag = envelope.getDeliveryTag();
_channel.BasicAck(deliveryTag, true);
}
}
catch (Exception ex)
{
_channel.BasicNack(deliveryTag, true, true);
}
}
public void Send(IModel channel, Address address, TransportMessage message, IBasicProperties properties)
{
throw new NotImplementedException();
}
public void CopyTo(IBasicProperties basicProperties)
{
Preconditions.CheckNotNull(basicProperties, "basicProperties");
if (contentTypePresent)
{
basicProperties.ContentType = ContentType;
}
if (contentEncodingPresent)
{
basicProperties.ContentEncoding = ContentEncoding;
}
if (deliveryModePresent)
{
basicProperties.DeliveryMode = DeliveryMode;
}
if (priorityPresent)
{
basicProperties.Priority = Priority;
}
if (correlationIdPresent)
{
basicProperties.CorrelationId = CorrelationId;
}
if (replyToPresent)
{
basicProperties.ReplyTo = ReplyTo;
}
if (expirationPresent)
{
basicProperties.Expiration = Expiration;
}
if (messageIdPresent)
{
basicProperties.MessageId = MessageId;
}
if (timestampPresent)
{
basicProperties.Timestamp = new AmqpTimestamp(Timestamp);
}
if (typePresent)
{
basicProperties.Type = Type;
}
if (userIdPresent)
{
basicProperties.UserId = UserId;
}
if (appIdPresent)
{
basicProperties.AppId = AppId;
}
if (clusterIdPresent)
{
basicProperties.ClusterId = ClusterId;
}
if (headersPresent)
{
basicProperties.Headers = new Dictionary <string, object>(Headers);
}
}
public void Publish(string message, ConnectionFactory _factory, string exchange = "configuration", IBasicProperties properties = null)
{
PublishSingleMessage(message, _factory, exchange, properties);
}
static void Main(string[] args)
{
var exchangeName = "chapter2-example";
var queueName = "example";
var routingKey = "routing_key";
var alternateExchangeName = "alternate-example";
var alternateQueueName = "alternate-example";
ConnectionFactory factory = new ConnectionFactory();
factory.Uri = new Uri("amqp://*****:*****@localhost:5672/");
using (IConnection conn = factory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//channel.ExchangeDeclare(alternateExchangeName, ExchangeType.Fanout);
//channel.QueueDeclare(alternateQueueName, false, false, false);
//var args = new Dictionary<string, object> {{"alternate-exchange", alternateExchangeName}};
channel.ExchangeDeclare(exchangeName, ExchangeType.Direct);
channel.QueueDelete(queueName);
//var args2 = new Dictionary<string, object> {{"x-max-length", 1}};
channel.QueueDeclare(queueName, true, false, false);
channel.QueueBind(queueName, exchangeName, routingKey, null);
channel.QueueDeclare(queueName + "2", true, false, false);
channel.QueueBind(queueName + "2", exchangeName, routingKey, null);
channel.QueuePurge(queueName);
//channel.QueueUnbind(queueName, exchangeName, routingKey);
//channel.QueueBind(alternateQueueName, alternateExchangeName, routingKey, null);
//channel.QueuePurge(alternateQueueName);
channel.BasicReturn += (sender, eventArgs) =>
{
Console.WriteLine($"Basic.Return {eventArgs.ReplyText}");
};
byte[] messageBodyBytes = System.Text.Encoding.UTF8.GetBytes("Hello, world!");
byte[] messageBodyBytes2 = System.Text.Encoding.UTF8.GetBytes("Hello, world 2!");
IBasicProperties props = channel.CreateBasicProperties();
//props.Persistent = true;
props.ContentType = "text/plain/xxx";
props.DeliveryMode = 2;
props.Headers = new Dictionary <string, object>();
props.Headers.Add("latitude", 51.5252949);
props.Headers.Add("longitude", -0.0905493);
//var consumer = new EventingBasicConsumer(channel);
//consumer.Received += (ch, ea) =>
//{
// using (IModel channel = conn.CreateModel())
// {
// var body = ea.Body;
// Console.WriteLine(System.Text.Encoding.UTF8.GetString(body));
// channel.BasicAck(ea.DeliveryTag, false);
// }
//};
channel.BasicQos(0, 1, false);
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine($"Publish Acknowledgement : {eventArgs.DeliveryTag}");
};
channel.BasicNacks += (sender, eventArgs) =>
{
Console.WriteLine($"Publish Negative Acknowledgement : {eventArgs.DeliveryTag}");
};
channel.ConfirmSelect();
channel.BasicPublish(exchangeName, routingKey, true, props, messageBodyBytes);
channel.BasicPublish(exchangeName, routingKey, true, props, messageBodyBytes);
Console.WriteLine("Before");
channel.WaitForConfirmsOrDie(TimeSpan.FromSeconds(5));
Console.WriteLine("After");
//var consumer = new Consumer(conn);
//String consumerTag = consumer.Model.BasicConsume(queueName, false, consumer);
//consumer.Model.BasicCancel(consumerTag);
//channel.BasicQos(0, 2, true);
//channel.ConfirmSelect();
//channel.TxSelect();
//channel.BasicPublish(exchangeName, routingKey, true, props, messageBodyBytes2);
//channel.BasicPublish(exchangeName, routingKey, true, props, messageBodyBytes2);
//channel.BasicPublish(exchangeName, routingKey, true, props, messageBodyBytes2);
//channel.BasicPublish(exchangeName, routingKey, true, props, messageBodyBytes2);
//channel.TxCommit();
//channel.TxSelect();
//BasicGetResult result = null;
//for (int i = 0; i < 4; i++)
//{
// result = channel.BasicGet(queueName, false);
// if (result == null)
// {
// Console.WriteLine("No messages");
// }
// else
// {
// byte[] body = result.Body;
// Console.WriteLine($"Message {System.Text.Encoding.UTF8.GetString(body)}");
// }
//}
//Console.ReadLine();
//channel.BasicAck(2, true);
Console.ReadLine();
}
}
Console.WriteLine("Hello World!");
}
private ErrorMessage(byte[] data, IBasicProperties basicProperties) : base(data, 0, 0)
{
_basicProperties = basicProperties;
}
public void BasicPublish(string exchange, string routingKey, bool mandatory, IBasicProperties basicProperties, byte[] body)
{
BasicPublish(exchange: exchange, routingKey: routingKey, mandatory: mandatory, immediate: true, basicProperties: basicProperties, body: body);
}
internal static ErrorMessage Create(byte[] data, IBasicProperties basicProperties)
{
return(new ErrorMessage(data, basicProperties));
}
/// <summary>
/// (Spec method) Convenience overload of BasicPublish.
/// </summary>
public static Task BasicPublish(this IModel model, string exchange, string routingKey, bool mandatory = false, IBasicProperties basicProperties = null, byte[] body = null)
{
return(model.BasicPublish(exchange, routingKey, mandatory, basicProperties, body));
}
public void BasicPublish(string exchange, string routingKey, bool mandatory, bool immediate, IBasicProperties basicProperties, byte[] body)
{
var parameters = new RabbitMessage
{
Exchange = exchange,
RoutingKey = routingKey,
Mandatory = mandatory,
Immediate = immediate,
BasicProperties = basicProperties,
Body = body
};
Func <string, Exchange> addExchange = s =>
{
var newExchange = new Exchange
{
Name = exchange,
Arguments = null,
IsAutoDelete = false,
IsDurable = false,
Type = "direct"
};
newExchange.PublishMessage(parameters);
return(newExchange);
};
Func <string, Exchange, Exchange> updateExchange = (s, existingExchange) =>
{
existingExchange.PublishMessage(parameters);
return(existingExchange);
};
_server.Exchanges.AddOrUpdate(exchange, addExchange, updateExchange);
NextPublishSeqNo++;
}
/// <summary>
/// Called each time a message arrives for this consumer.
/// Queues received messages in the internal queue.
/// </summary>
public void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
if (_isClosed)
{
return;
}
var eventArgs = new BasicDeliverEventArgs
{
ConsumerTag = consumerTag,
DeliveryTag = deliveryTag,
Redelivered = redelivered,
Exchange = exchange,
RoutingKey = routingKey,
BasicProperties = properties,
Body = body
};
_queue.Enqueue(eventArgs);
if (_itemQueuedEvent != null)
{
_itemQueuedEvent.Set();
}
}
public void BasicPublish(PublicationAddress addr, IBasicProperties basicProperties, byte[] body)
{
BasicPublish(exchange: addr.ExchangeName, routingKey: addr.RoutingKey, mandatory: true, immediate: true, basicProperties: basicProperties, body: body);
}
async Task ISendTransport.Send <T>(T message, IPipe <SendContext <T> > pipe, CancellationToken cancelSend)
{
IPipe <ModelContext> modelPipe = Pipe.New <ModelContext>(p =>
{
p.UseFilter(_filter);
p.UseExecuteAsync(async modelContext =>
{
IBasicProperties properties = modelContext.Model.CreateBasicProperties();
var context = new RabbitMqSendContextImpl <T>(properties, message, _sendSettings, cancelSend);
try
{
await pipe.Send(context).ConfigureAwait(false);
properties.ContentType = context.ContentType.MediaType;
properties.Headers = (properties.Headers ?? Enumerable.Empty <KeyValuePair <string, object> >())
.Concat(context.Headers.GetAll())
.Where(x => x.Value != null && (x.Value is string || x.Value.GetType().IsValueType))
.Distinct()
.ToDictionary(entry => entry.Key, entry => entry.Value);
properties.Headers["Content-Type"] = context.ContentType.MediaType;
properties.Persistent = context.Durable;
if (context.MessageId.HasValue)
{
properties.MessageId = context.MessageId.ToString();
}
if (context.CorrelationId.HasValue)
{
properties.CorrelationId = context.CorrelationId.ToString();
}
if (context.TimeToLive.HasValue)
{
properties.Expiration = context.TimeToLive.Value.TotalMilliseconds.ToString("F0", CultureInfo.InvariantCulture);
}
await _observers.PreSend(context).ConfigureAwait(false);
await modelContext.BasicPublishAsync(context.Exchange, context.RoutingKey, context.Mandatory,
context.Immediate, context.BasicProperties, context.Body).ConfigureAwait(false);
context.DestinationAddress.LogSent(context.MessageId?.ToString("N") ?? "", TypeMetadataCache <T> .ShortName);
await _observers.PostSend(context).ConfigureAwait(false);
}
catch (Exception ex)
{
await _observers.SendFault(context, ex).ConfigureAwait(false);
if (_log.IsErrorEnabled)
{
_log.Error("Send Fault: " + context.DestinationAddress, ex);
}
throw;
}
});
});
await _modelCache.Send(modelPipe, cancelSend).ConfigureAwait(false);
}
/// <summary>
/// Construct an instance for reading. See <see cref="BasicMessageReader"/>.
/// </summary>
public MapMessageReader(IBasicProperties properties, byte[] payload)
: base(properties, payload)
{
}
public void BasicPublish(string exchange, string routingKey, IBasicProperties basicProperties, byte[] body)
{
Model.BasicPublish(exchange, routingKey, basicProperties, body);
}
///<summary>Construct an instance ready for reading.</summary>
public BasicMessageReader(IBasicProperties properties, byte[] body)
{
m_properties = properties;
m_body = body;
}
/// <summary>
/// 发送消息 多线程安全
/// </summary>
/// <param name="routingKey">routingkey</param>
/// <param name="messageBytes">消息内容最大2g</param>
/// <param name="exceptionHandler">异常处理，一般是消息丢失</param>
/// <returns></returns>
public bool SendMessage(string routingKey, byte[] messageBytes, Action <Exception> exceptionHandler = null)
{
//获取当前mq的配置
try
{
if (messageBytes == null || messageBytes.Length == 0)
{
throw new Exception("消息内容为空");
}
#region 判断是否需要创建exchange
//mq配置
string mqConfigStr = "";
//判断是否需要创建exchange
bool needCreateExchange = this._needToCreateExchange;
if (needCreateExchange)
{
//获取当前mq的配置
var mqConfig = GetCurrentUsedRmq();
mqConfigStr = mqConfig.ToString();
bool alreadyCreated = false;
if (_exchangeCreatedDict.TryGetValue(mqConfigStr, out alreadyCreated) && alreadyCreated)
{
needCreateExchange = false;
}
}
#endregion
IConnection conn = null;
lock (_locker)
{
conn = _curUsedConnection;
}
if (conn == null)
{
throw new Exception("当前连接为null");
}
using (var channel = conn.CreateModel())
{
if (needCreateExchange)
{
channel.ExchangeDeclare(exchange: this._exchangeName, type: this._exchangeType, durable: true, autoDelete: false, arguments: null);
_exchangeCreatedDict.AddOrUpdate(mqConfigStr, true, (key, oldV) => true);
}
IBasicProperties properties = channel.CreateBasicProperties();
//定义消息的持久性
properties.Persistent = true;
//设置单个消息的过期时间单位毫秒
properties.Expiration = MessageExpirationInMilliseconds.ToString();//两个小时
//Direct Exchange将会把消息发送到和routingkey一样的队列中
//使用指定的routing key发送到指定的exchange
channel.BasicPublish(exchange: this._exchangeName, routingKey: routingKey, basicProperties: properties, body: messageBytes);
}
return(true);
}
catch (Exception e)
{
exceptionHandler?.Invoke(e);
return(false);
}
}
/// <summary>
/// (Extension method) Convenience overload of BasicPublish.
/// </summary>
/// <remarks>
/// The publication occurs with mandatory=false and immediate=false.
/// </remarks>
public static Task BasicPublish(this IModel model, PublicationAddress addr, IBasicProperties basicProperties, byte[] body)
{
return(model.BasicPublish(addr.ExchangeName, addr.RoutingKey, basicProperties: basicProperties, body: body));
}
public static void GetMessage()
{
var factory = new ConnectionFactory();
//サーバー名
factory.HostName = "godpubtest";
//RabbitServerのユーザー名
factory.UserName = "******";
//RabbitServerのパスワード
factory.Password = "******";
var queueName = "hello";
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
////Useage:① Simple Interaction
//channel.QueueDeclare(
// queue: queueName,
// durable: false,
// exclusive: false,
// autoDelete: false,
// arguments: null);
//----------------------------------------
//Useage:② Message durability（消息持久机制），关键参数 durable
queueName = "task_queue";
channel.QueueDeclare(queue: queueName,
durable: true /* 如果 生产者 设置为 true，相应的 消费者 也需要设置为 true 才会生效 */,
exclusive: false,
autoDelete: false,
arguments: null);
// Fair dispatch（公平触发机制）
channel.BasicQos(
prefetchSize: 0,
prefetchCount: 1,
global: false);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (ch, ea) =>
{
//var body = ea.Body;
//var message = Encoding.UTF8.GetString(body);
//Console.WriteLine(" [x] Received {0}", message);
var body = SerializeTool.GetBody(ea.Body);
IBasicProperties basicProperties = ea.BasicProperties;
Console.WriteLine("Message received by the event based consumer. Check the debug window for details.");
Debug.WriteLine("------------------------------------------------------------------");
Debug.WriteLine(string.Concat("Message received from the exchange ", ea.Exchange));
Debug.WriteLine(string.Concat("Content type: ", basicProperties.ContentType));
Debug.WriteLine(string.Concat("Consumer tag: ", ea.ConsumerTag));
Debug.WriteLine(string.Concat("Delivery tag: ", ea.DeliveryTag));
Debug.WriteLine(string.Concat("Message id: ", body.MsgID));
Debug.WriteLine(string.Concat("Message: ", body.MsgContent));
// 如果 channel.BasicConsume 中参数 noAck 设置为 false，必须加上消息确认语句
// Message acknowledgment（消息确认机制作用）
channel.BasicAck(ea.DeliveryTag, false);
};
try
{
string consumeID = channel.BasicConsume(queue: queueName,
autoAck: false,/* Message acknowledgment（消息确认机制） */
consumer: consumer);
Console.WriteLine(" Consume ID={0}", consumeID);
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
//channel.BasicConsume(queueName, false, eventingBasicConsumer);
}
}
}
