コード例 #1
0
        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message">消息</param>
        public void SendMessage <T>(Envelope <T> message) where T : class
        {
            if (message == null || message.Body == null)
            {
                throw new ArgumentNullException("message");
            }
            var body            = Serializer.Serialize(message.Body);
            var messageTypeName = MessageTypeAttribute.GetTypeName(message.Body.GetType());
            var routingKey      = string.Empty;

            if (_publishToExchange)
            {
                uint routingKeyHashCode = 0;
                if (!uint.TryParse(message.RoutingKey, out routingKeyHashCode))
                {
                    routingKeyHashCode = (uint)message.RoutingKey.GetHashCode();
                }
                routingKey = (routingKeyHashCode % _publishToExchangeQueueCount).ToString();
            }
            else
            {
                routingKey = message.RoutingKey == null ? string.Empty : message.RoutingKey;
            }
            var envelopedMessage = new EnvelopedMessage(message.MessageId,
                                                        messageTypeName,
                                                        message.Timestamp,
                                                        Serializer.GetString(body),
                                                        routingKey,
                                                        string.Empty,
                                                        string.Empty);

            var context = new MessageSendingTransportationContext(ExchangeName, new Dictionary <string, object> {
                { MessagePropertyConstants.MESSAGE_ID, string.IsNullOrEmpty(message.MessageId) ? Guid.NewGuid().ToString() : message.MessageId },
                { MessagePropertyConstants.MESSAGE_TYPE, messageTypeName },
                { MessagePropertyConstants.TIMESTAMP, message.Timestamp },
                { MessagePropertyConstants.CONTENT_TYPE, Serializer.ContentType },
                { MessagePropertyConstants.PAYLOAD, Serializer.GetString(body) },
                { MessagePropertyConstants.ROUTING_KEY, routingKey }
            });

            try
            {
                TriggerOnMessageSent(new MessageSentEventArgs(this.GetSenderType(), context));
                if (!IsRunning())
                {
                    throw new ObjectDisposedException(nameof(PubsubSender));
                }
                IncreaseRetryingMessageCount();

                RetryPolicy.Retry(() =>
                {
                    using (var channel = _conn.CreateChannel())
                    {
                        var properties          = channel.CreateBasicProperties();
                        properties.Persistent   = true;
                        properties.DeliveryMode = 2;
                        properties.ContentType  = Serializer.ContentType;
                        properties.MessageId    = message.MessageId;
                        properties.Type         = messageTypeName;
                        properties.Timestamp    = new AmqpTimestamp(DateTime2UnixTime.ToUnixTime(message.Timestamp));
                        if (_confirmEnabled)
                        {
                            channel.ConfirmSelect();
                        }
                        channel.BasicPublish(exchange: ExchangeName,
                                             routingKey: routingKey,
                                             mandatory: _atLeastMatchOneQueue,
                                             basicProperties: properties,
                                             body: body);
                        if (_confirmEnabled && !channel.WaitForConfirms())
                        {
                            throw new Exception("Wait for confirm after sending message failed");
                        }
                    }
                },
                                  cancelOnFailed: (retryCount, retryException) =>
                {
                    return(false);
                },
                                  retryCondition: ex => IOHelper.IsIOError(ex) || RabbitMQExceptionHelper.IsChannelError(ex),
                                  retryTimeInterval: 1000,
                                  maxRetryCount: _maxRetryCount);
                TriggerOnMessageSendingSucceeded(new MessageSendingSucceededEventArgs(this.GetSenderType(), context));
            }
            catch (Exception ex)
            {
                var realEx = ex is TargetInvocationException ? ex.InnerException : ex;
                context.LastException = realEx;
                TriggerOnMessageSendingFailed(new MessageSendingFailedEventArgs(this.GetSenderType(), context));
                throw new MessageSendFailedException(envelopedMessage, ExchangeName, realEx);
            }
            finally
            {
                DecreaseRetryingMessageCount();
            }
        }
コード例 #2
0
        /// <summary>
        /// 重发到队列
        /// </summary>
        /// <param name="queueName">队列名</param>
        /// <param name="messageId">消息ID</param>
        /// <param name="messageTypeName">消息类型名</param>
        /// <param name="messageTimestamp">消息时间戳</param>
        /// <param name="messageBody">消息体</param>
        /// <param name="correlationId">关联ID</param>
        /// <param name="replyTo">响应队列名</param>
        public void RedeliverToQueue(string queueName, string messageId, string messageTypeName, DateTime messageTimestamp, string messageBody, string correlationId = "", string replyTo = "")
        {
            if (string.IsNullOrEmpty(queueName))
            {
                throw new ArgumentNullException("queueName", "must not empty");
            }
            if (string.IsNullOrEmpty(messageId))
            {
                throw new ArgumentNullException("messageId", "must not empty");
            }
            if (string.IsNullOrEmpty(messageTypeName))
            {
                throw new ArgumentNullException("messageTypeName", "must not empty");
            }
            if (messageTimestamp == DateTime.MinValue)
            {
                throw new ArgumentNullException("messageTimestamp", "must not empty");
            }
            if (string.IsNullOrEmpty(messageBody))
            {
                throw new ArgumentNullException("messageBody", "must not empty");
            }

            var body             = Serializer.GetBytes(messageBody);
            var routingKey       = queueName;
            var envelopedMessage = new EnvelopedMessage(messageId,
                                                        messageTypeName,
                                                        messageTimestamp,
                                                        messageBody,
                                                        routingKey,
                                                        correlationId,
                                                        replyTo);

            try
            {
                var context = new MessageSendingTransportationContext(string.Empty, new Dictionary <string, object> {
                    { MessagePropertyConstants.MESSAGE_ID, string.IsNullOrEmpty(messageId) ? Guid.NewGuid().ToString() : messageId },
                    { MessagePropertyConstants.MESSAGE_TYPE, messageTypeName },
                    { MessagePropertyConstants.TIMESTAMP, messageTimestamp },
                    { MessagePropertyConstants.CONTENT_TYPE, Serializer.ContentType },
                    { MessagePropertyConstants.PAYLOAD, Serializer.GetString(body) },
                    { MessagePropertyConstants.ROUTING_KEY, routingKey },
                    { MessagePropertyConstants.REPLY_TO, replyTo },
                    { MessagePropertyConstants.CORRELATION_ID, correlationId }
                });

                RetryPolicy.Retry(() =>
                {
                    using (var channel = _conn.CreateChannel())
                    {
                        var properties          = channel.CreateBasicProperties();
                        properties.Persistent   = true;
                        properties.DeliveryMode = 2;
                        properties.ContentType  = Serializer.ContentType;
                        properties.MessageId    = messageId;
                        properties.Type         = messageTypeName;
                        properties.Timestamp    = new AmqpTimestamp(DateTime2UnixTime.ToUnixTime(messageTimestamp));
                        if (!string.IsNullOrEmpty(correlationId) && !string.IsNullOrEmpty(replyTo))
                        {
                            properties.CorrelationId = correlationId;
                            properties.ReplyTo       = replyTo;
                        }

                        channel.BasicPublish(exchange: string.Empty,
                                             routingKey: routingKey,
                                             mandatory: true,
                                             basicProperties: properties,
                                             body: body);
                        channel.Close();
                    }
                },
                                  cancelOnFailed: (retryCount, retryException) =>
                {
                    if (retryCount == 0)
                    {
                        _logger.Error($"Message [{messageTypeName}] \"{Serializer.GetString(body)}\" send to queue \"{queueName}\" failed.", retryException);
                    }
                    return(false);
                },
                                  retryCondition: ex => IOHelper.IsIOError(ex) || RabbitMQExceptionHelper.IsChannelError(ex),
                                  maxRetryCount: 1,
                                  retryTimeInterval: 1000);
                if (_debugEnabled)
                {
                    _logger.Info($"Message [{messageTypeName}] \"{Serializer.GetString(body)}\" send to queue \"{queueName}\" successful.");
                }
            }
            catch (Exception ex)
            {
                var realEx = ex is TargetInvocationException ? ex.InnerException : ex;
                _logger.Error($"Message [{ messageTypeName}] \"{Serializer.GetString(body)}\" send to queue \"{queueName}\" failed.", realEx);
                throw new MessageSendFailedException(envelopedMessage, string.Empty, realEx);
            }
        }
コード例 #3
0
        /// <summary>
        /// 发送请求
        /// </summary>
        /// <param name="message">消息</param>
        /// <param name="methodName">方法名</param>
        /// <param name="correlationId">关联ID</param>
        public void SendRequest <T>(Envelope <T> message, string methodName, string correlationId) where T : class
        {
            if (message == null || message.Body == null)
            {
                throw new ArgumentNullException("message");
            }
            var queueName         = _disableQueuePrefix ? methodName : $"rpc.{methodName}";
            var callbackQueueName = $"{queueName}.callback";
            var body             = Serializer.Serialize(message.Body);
            var messageTypeName  = MessageTypeAttribute.GetTypeName(message.Body.GetType());
            var routingKey       = string.IsNullOrEmpty(ExchangeName) ? queueName : methodName;
            var envelopedMessage = new EnvelopedMessage(message.MessageId,
                                                        messageTypeName,
                                                        message.Timestamp,
                                                        Serializer.GetString(body),
                                                        routingKey,
                                                        correlationId,
                                                        callbackQueueName);

            var context = new MessageSendingTransportationContext(ExchangeName, new Dictionary <string, object> {
                { MessagePropertyConstants.MESSAGE_ID, string.IsNullOrEmpty(message.MessageId) ? Guid.NewGuid().ToString() : message.MessageId },
                { MessagePropertyConstants.MESSAGE_TYPE, messageTypeName },
                { MessagePropertyConstants.TIMESTAMP, message.Timestamp },
                { MessagePropertyConstants.CONTENT_TYPE, Serializer.ContentType },
                { MessagePropertyConstants.PAYLOAD, Serializer.GetString(body) },
                { MessagePropertyConstants.ROUTING_KEY, routingKey },
                { MessagePropertyConstants.REPLY_TO, callbackQueueName },
                { MessagePropertyConstants.CORRELATION_ID, correlationId }
            });

            TriggerOnMessageSent(new MessageSentEventArgs(this.GetSenderType(), context));
            try
            {
                if (!IsRunning())
                {
                    throw new ObjectDisposedException(nameof(RpcClient));
                }
                IncreaseRetryingMessageCount();

                RetryPolicy.Retry(() =>
                {
                    using (var channel = _conn.CreateChannel())
                    {
                        var properties           = channel.CreateBasicProperties();
                        properties.Persistent    = true;
                        properties.DeliveryMode  = 2;
                        properties.ContentType   = Serializer.ContentType;
                        properties.MessageId     = message.MessageId;
                        properties.Type          = messageTypeName;
                        properties.Timestamp     = new AmqpTimestamp(DateTime2UnixTime.ToUnixTime(message.Timestamp));
                        properties.ReplyTo       = callbackQueueName;
                        properties.CorrelationId = correlationId;
                        if (_confirmEnabled)
                        {
                            channel.ConfirmSelect();
                        }
                        channel.BasicPublish(exchange: ExchangeName,
                                             routingKey: routingKey,
                                             mandatory: true,
                                             basicProperties: properties,
                                             body: body);
                        if (_confirmEnabled && !channel.WaitForConfirms())
                        {
                            throw new Exception("Wait for confirm after sending message failed");
                        }
                    }
                },
                                  cancelOnFailed: (retryCount, retryException) =>
                {
                    return(false);
                },
                                  retryCondition: ex => IOHelper.IsIOError(ex) || RabbitMQExceptionHelper.IsChannelError(ex),
                                  retryTimeInterval: 1000,
                                  maxRetryCount: _maxRetryCount);
                TriggerOnMessageSendingSucceeded(new MessageSendingSucceededEventArgs(this.GetSenderType(), context));
            }
            catch (Exception ex)
            {
                var realEx = ex is TargetInvocationException ? ex.InnerException : ex;
                context.LastException = realEx;
                TriggerOnMessageSendingFailed(new MessageSendingFailedEventArgs(this.GetSenderType(), context));
                throw new MessageSendFailedException(envelopedMessage, ExchangeName, realEx);
            }
            finally
            {
                DecreaseRetryingMessageCount();
            }
        }