private static void SendDurableMessageToDurableQueue(IModel model) { IBasicProperties basicProperties = model.CreateBasicProperties(); basicProperties.SetPersistent(true); byte[] payload = Encoding.UTF8.GetBytes("This is a persistent message from Visual Studio"); PublicationAddress address = new PublicationAddress(ExchangeType.Topic, "DurableExchange", "durable"); model.BasicPublish(address, basicProperties, payload); }
/// <summary> /// Initializes a new instance of the <see cref="RabbitConnection"/> class. /// </summary> /// <param name="queueName">Name of the queue.</param> /// <param name="connection">The connection.</param> /// <param name="channel">The channel.</param> /// <param name="publicationAddress">The publication address.</param> public RabbitConnection(string queueName, IConnection connection, IModel channel, PublicationAddress publicationAddress) { QueueName = queueName; Connection = connection; Channel = channel; PublicationAddress = publicationAddress; }
/// <summary> /// Creates an event publisher. /// </summary> /// <param name="uri">The URI.</param> /// <returns></returns> public IDataPublisher CreatePublisher(Uri uri) { if (uri.Scheme == "rabbitmq") { var pathParts = uri.Segments; var queuePath = pathParts[1].TrimEnd('/'); var model = _connection.CreateModel(); //_model.QueueDeclare( // exchangePath, // true, // false, // false, // null); // construct the publication address var publicationAddress = new PublicationAddress( ExchangeType.Direct, string.Empty, queuePath); // construct the publisher var eventPublisher = new RabbitMqDataPublisher(model, publicationAddress); // return the publisher return eventPublisher; } return null; }
/// <summary> /// Constructor for RabbitMqClient /// </summary> /// <param name="configuration">mandatory</param> public RabbitMQClient(RabbitMQConfiguration configuration) { // load configuration _config = configuration; _publicationAddress = new PublicationAddress(_config.ExchangeType, _config.Exchange, _config.RouteKey); // initialize InitializeEndpoint(); }
protected virtual void DeclareSystemExchange(IModel channel, PublicationAddress address) { if (this.DispatchOnly || address == null) return; channel.ExchangeDeclare(address.ExchangeName, address.ExchangeType, true, false, null); channel.QueueDeclare(address.ExchangeName, true, false, false, null); channel.QueueBind(address.ExchangeName, address.ExchangeName, address.RoutingKey, null); }
private static void ReceiveRetryMode <T>(Channel channel, Action <T, BasicDeliverEventArgs> received, MessageStructure messageStructure) { var currentChannel = channel.CurrentChannel; EventingBasicConsumer consumer = new EventingBasicConsumer(currentChannel); consumer.Received += (ch, ea) => { var body = Encoding.UTF8.GetString(ea.Body); try { channel.Logger.LogInformation($"{messageStructure.Queue.Name} Queue 消息体{{0}}", body); var message = JsonConvert.DeserializeObject <T>(body); try { received(message, ea); } catch (Exception e) { var properties = ea.BasicProperties; long retryCount = GetRetryCount(properties); if (retryCount > 3) { IDictionary <String, Object> headers = new Dictionary <String, Object>(); headers.Add("x-orig-routing-key", GetOrigRoutingKey(properties, ea.RoutingKey)); var address = new PublicationAddress(ExchangeType.Direct, messageStructure.Exchange.DeadLetterName, messageStructure.RoutingKey); channel.Publish(CreateOverrideProperties(properties, headers), ea.Body, address); } else { IDictionary <String, Object> headers = properties.Headers; if (headers == null) { headers = new Dictionary <String, Object>(); headers.Add("x-orig-routing-key", GetOrigRoutingKey(properties, ea.RoutingKey)); } else { headers["x-orig-routing-key"] = GetOrigRoutingKey(properties, ea.RoutingKey); } var address = new PublicationAddress(ExchangeType.Direct, messageStructure.Exchange.RetryName, messageStructure.RoutingKey); channel.Publish(CreateOverrideProperties(properties, headers), ea.Body, address); } } } catch (Exception) { channel.Logger.LogError($"Json解析{typeof(T).Name}失败:{{0}}", body); var properties = ea.BasicProperties; var address = new PublicationAddress(ExchangeType.Direct, messageStructure.Exchange.DeadLetterName, messageStructure.RoutingKey); channel.Publish(properties, ea.Body, address); } }; currentChannel.BasicConsume(messageStructure.Queue.Name, true, consumer); }
/// <summary> /// Initializes a new instance of the <see cref="RabbitMqEventPublisher"/> class. /// </summary> /// <param name="model">The model.</param> /// <param name="exchangeAddress">The exchange address.</param> /// <param name="address">The address.</param> public RabbitMqEventPublisher(IModel model, String exchangeAddress, PublicationAddress address) { var builder = new UriBuilder(); builder.Scheme = "rabbitmq"; builder.Host = exchangeAddress; builder.Path = string.Format("{0}/{1}", Uri.EscapeUriString(address.ExchangeName), Uri.EscapeUriString(address.RoutingKey)); URI = builder.Uri; _model = model; _address = address; }
//[SetUp] public void Setup() { _rabbitWrapper = new Mock<IRabbitWrapper>(); _basicConsumer = new Mock<IQueueBasicConsumer>(); _basicProperties = new Mock<IBasicProperties>(); _publicationAddress = new PublicationAddress("test", "test", "test"); _subject = new RabbitReceiverChannel(100, _rabbitWrapper.Object); _sharedQueue = new Mock<ISharedQueue>(); _model = new Mock<IModel>(); _basicConsumer.SetupGet(q => q.Queue).Returns(_sharedQueue.Object); //_rabbitWrapper.SetupGet(rw => rw.Channel).Returns(_model.Object); //_rabbitWrapper.SetupGet(rw => rw.BasicConsumer).Returns(_basicConsumer.Object); //_rabbitWrapper.SetupGet(rw => rw.PublicationAddress).Returns(_publicationAddress); }
/// <summary> /// Constructor for RabbitMqClient /// </summary> /// <param name="configuration">mandatory</param> public RabbitMQClient(RabbitMQConfiguration configuration) { // load configuration _config = configuration; _publicationAddress = new PublicationAddress(_config.ExchangeType, _config.Exchange, _config.RouteKey); // Lazy _modelWithPropertiesFactory = () => { var model = GetConnectionFactory() .CreateConnection() .CreateModel(); var basicProperties = model.CreateBasicProperties(); basicProperties.DeliveryMode = (byte)_config.DeliveryMode; //persistance return new ModelWithProperties(model, basicProperties); }; }
public static void Main(string[] args) { var connectionFactory = new ConnectionFactory {HostName = Settings.RabbitMqHost}; using (var connection = connectionFactory.CreateConnection()) { using (var model = connection.CreateModel()) { model.ExchangeDeclare(Settings.RabbitMqExchange, ExchangeType.Fanout); model.QueueDeclare(Settings.RabbitMqQueue, true, false, true, new Dictionary<string, object>()); model.QueueBind(Settings.RabbitMqQueue, Settings.RabbitMqExchange, string.Empty,new Dictionary<string, object>()); var publicationAddress = new PublicationAddress(ExchangeType.Fanout, Settings.RabbitMqExchange, string.Empty); var basicProperties = model.CreateBasicProperties(); var simpleMessage = new SimpleMessage {Content = "Simple Message"}; model.BasicPublish(Settings.RabbitMqExchange, "", false, false, basicProperties, simpleMessage.ToByteArray()); } } System.Console.ReadLine(); }
protected virtual void ForwardTo(BasicDeliverEventArgs message, PublicationAddress address) { Log.Debug("Forwarding message '{0}' to recipient '{1}'.", message.MessageId(), address); this.EnsureTransaction(); this.Send(message, address); this.CurrentTransaction.Commit(); }
public ICommand Publish(ICommand command, PublicationAddress receiver, TimeSpan? timeout = null) { if (!timeout.HasValue) timeout = TimeSpan.MaxValue; var props = this.Channel.CreateBasicProperties(); //props.AppId; //props.ClusterId; //props.CorrelationId; props.DeliveryMode = Constants.Persistent; //props.Expiration; //props.Headers; //props.MessageId; //props.Priority; //props.ProtocolClassId; //props.ProtocolClassName; //props.ReplyTo; props.ReplyToAddress = new PublicationAddress(this.CmdExchange.ExchangeType, this.CmdExchange.Name, this.PrivateQueue.Name); //props.Timestamp; //props.UserId; var reqBytes = CommandSerializer.Serialize(command); props.ContentEncoding = CommandSerializer.ContentEncoding; props.ContentType = CommandSerializer.ContentType; props.Type = command.GetType().FullName; // at this point, we're ready to send // set up to receive the response before the send occurs // so there's no chance it'll be missed ICommand reply = null; using (CancellationTokenSource cts = new CancellationTokenSource()) { var ct = cts.Token; Task replyTask = null; if (command.CorrelationId.HasValue) { props.CorrelationId = command.CorrelationId.ToString(); replyTask = Task.Run(() => { var autoAck = false; using (var subscription = new Subscription(this.Channel, this.PrivateQueue.Name, autoAck)) { var subscriptionTimeout = TimeSpan.FromMilliseconds(100d).Milliseconds; while (!ct.IsCancellationRequested) { BasicDeliverEventArgs eventArgs = null; subscription.Next(subscriptionTimeout, out eventArgs); if (eventArgs != null && !ct.IsCancellationRequested) { reply = CommandDeserializer.Deserialize(eventArgs.Body) as ICommand; if (reply != null && reply.CorrelationId == command.CorrelationId) { subscription.Ack(eventArgs); break; } else subscription.Model.BasicNack(eventArgs.DeliveryTag, false, true); } } } }); } // now the receiver is set up, publish the command this.Channel.BasicPublish(receiver, props, reqBytes); //Console.WriteLine("{0} Command sent ({1})", command.GetType().Name, command.CorrelationId); if (timeout < TimeSpan.MaxValue) cts.CancelAfter(timeout.Value); replyTask.Wait(); return reply; } }
/// <summary> /// (Extension method) Convenience overload of BasicPublish. /// </summary> /// <remarks> /// The publication occurs with mandatory=false and immediate=false. /// </remarks> public static void BasicPublish(this IModel model, PublicationAddress addr, IBasicProperties basicProperties, byte[] body) { model.BasicPublish(addr.ExchangeName, addr.RoutingKey, basicProperties: basicProperties, body: body); }
public Task Send(string exchangeName, byte[] body) { var address = new PublicationAddress("", exchangeName, ""); var sendingMessage = new SendingMessage(address, body); return Send(sendingMessage); }
/// <summary> /// 发布消息 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="channel"></param> /// <param name="properties"></param> /// <param name="body"></param> /// <param name="address"></param> public static void Publish <T>(this Channel channel, IBasicProperties properties, T body, PublicationAddress address) where T : class { var jsonb = JsonConvert.SerializeObject(body); var message = Encoding.UTF8.GetBytes(jsonb); channel.CurrentChannel.BasicPublish(address, properties, message); }
/// <summary> /// 发布消息 /// </summary> /// <param name="channel"></param> /// <param name="properties"></param> /// <param name="body"></param> /// <param name="address"></param> public static void Publish(this Channel channel, IBasicProperties properties, byte[] body, PublicationAddress address) { channel.CurrentChannel.BasicPublish(address, properties, body); }
/// <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 void BasicPublish(PublicationAddress addr, IBasicProperties basicProperties, byte[] body) { target.BasicPublish(addr, basicProperties, body); }
public void BasicPublish(PublicationAddress addr, IBasicProperties basicProperties, byte[] body) { InternalModel.BasicPublish(addr, basicProperties, body); }
public void BasicPublish(PublicationAddress addr, IBasicProperties basicProperties, byte[] body) { BasicPublish(addr.ExchangeName, addr.RoutingKey, basicProperties, body); }
///<summary>Process a single request received from our ///subscription.</summary> ///<remarks> ///<para> /// If the request's properties contain a non-null, non-empty /// CorrelationId string (see IBasicProperties), it is assumed /// to be a two-way call, requiring a response. The ReplyTo /// header property is used as the reply address (via /// PublicationAddress.Parse, unless that fails, in which case it /// is treated as a simple queue name), and the request is /// passed to HandleCall(). ///</para> ///<para> /// If the CorrelationId is absent or empty, the request is /// treated as one-way asynchronous event, and is passed to /// HandleCast(). ///</para> ///<para> /// Usually, overriding HandleCall(), HandleCast(), or one of /// their delegates is sufficient to implement a service, but /// in some cases overriding ProcessRequest() is /// required. Overriding ProcessRequest() gives the /// opportunity to implement schemes for detecting interaction /// patterns other than simple request/response or one-way /// communication. ///</para> ///</remarks> public virtual void ProcessRequest(BasicDeliverEventArgs evt) { IBasicProperties properties = evt.BasicProperties; if (properties.ReplyTo != null && properties.ReplyTo != "") { // It's a request. PublicationAddress replyAddress = PublicationAddress.Parse(properties.ReplyTo); if (replyAddress == null) { replyAddress = new PublicationAddress(ExchangeType.Direct, "", properties.ReplyTo); } IBasicProperties replyProperties; byte[] reply = HandleCall(evt.Redelivered, properties, evt.Body, out replyProperties); if (replyProperties == null) { replyProperties = m_subscription.Model.CreateBasicProperties(); } replyProperties.CorrelationId = properties.CorrelationId; m_subscription.Model.BasicPublish(replyAddress, replyProperties, reply); } else { // It's an asynchronous message. HandleCast(evt.Redelivered, properties, evt.Body); } }
public void BasicPublish(PublicationAddress addr, IBasicProperties basicProperties, byte[] body) { BasicPublish(exchange: addr.ExchangeName, routingKey: addr.RoutingKey, mandatory: true, immediate: true, basicProperties: basicProperties, body: body); }
/// <summary>The basic publish.</summary> /// <param name="addr">The addr.</param> /// <param name="basicProperties">The basic properties.</param> /// <param name="body">The body.</param> public void BasicPublish(PublicationAddress addr, IBasicProperties basicProperties, byte[] body) { this.channelDelegate.BasicPublish(addr, basicProperties, body); }
///<summary>Construct an instance that will deliver to the ///given address.</summary> public SimpleRpcClient(IModel model, PublicationAddress address) { m_model = model; m_address = address; m_subscription = null; m_timeout = Timeout.Infinite; }
public void BasicPublish(PublicationAddress addr, IBasicProperties basicProperties, byte[] body) { throw new NotImplementedException(); }
protected virtual void Send(BasicDeliverEventArgs message, PublicationAddress recipient) { if (recipient == null) return; if (recipient == this.configuration.DeadLetterExchange) this.adapter.AppendRetryAddress(message); this.EnsureTransaction().Register(() => this.Try(() => { Log.Info("Dispatching wire message '{0}' to messaging infrastructure for recipient '{1}'.", message.MessageId(), recipient); this.channel.BasicPublish(recipient, message.BasicProperties, message.Body); })); }
/// <summary> /// (Extension method) Convenience overload of BasicPublish. /// </summary> /// <remarks> /// The publication occurs with mandatory=false and immediate=false. /// </remarks> public static void BasicPublish(this IModel model, PublicationAddress addr, IBasicProperties basicProperties, ReadOnlyMemory <byte> body) { model.BasicPublish(addr.ExchangeName, addr.RoutingKey, basicProperties: basicProperties, body: body); }
/// <summary> /// Creates an event publisher. /// </summary> /// <returns></returns> public IEventPublisher CreatePublisher(EventPublisherArgs eventPublisherArgs) { // construct the exchange name var publisherTopic = CreatePublisherTopic(); // construct the publication address var publicationAddress = new PublicationAddress( ExchangeType.Topic, _exchangePath, publisherTopic); // construct the publisher var eventPublisher = new RabbitMqEventPublisher(_model, _exchangeAddr, publicationAddress); // connect the statement to the publisher eventPublisherArgs.Statement.Events += (sender, eventArgs) => eventPublisher.SendEvent(eventArgs); // return the publisher return eventPublisher; }