///<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); } } }