protected override RawBusMessage HandleMessage(ICallHandler handler, RawBusMessage message, bool redelivered, ulong deliveryTag)
        {
            try
            {
                RawBusMessage replyMessage = base.HandleMessage(handler, message, redelivered, deliveryTag);

                Model.BasicAck(deliveryTag, false);

                return replyMessage;
            }
            catch (RejectMessageException)
            {
                // If reject message exception is thrown -> reject message without requeue it.
                // Message will be lost or transfered to dead letter exchange by broker
                Model.BasicNack(deliveryTag, false, false);

                throw;
            }
            catch (Exception)
            {
                Model.BasicNack(deliveryTag, false, true);

                throw;
            }
        }
        protected override async Task<RawBusMessage> HandleMessage(ICallHandler handler, RawBusMessage message, bool redelivered, ulong deliveryTag)
        {
            try
            {
                RawBusMessage replyMessage = await base.HandleMessage(handler, message, redelivered, deliveryTag);

                Model.BasicAck(deliveryTag, false);

                return replyMessage;
            }
            catch (RejectMessageException)
            {
                // If reject message exception is thrown -> reject message without requeue it. 
                // Message will be lost or transfered to dead letter exchange by broker
                Model.BasicNack(deliveryTag, false, false);

                throw;
            }
            catch (Exception ex)
            {
                bool requeue = _exceptionFilter.Filter(ex, message, redelivered, deliveryTag);

                Model.BasicNack(deliveryTag, false, requeue);

                if (requeue)
                {
                    return null;
                }

                throw;
            }
        }
 public void Deserialize(RawBusMessage rawBusMessage, XmlDictionaryReader bodyContent)
 {
     XmlObjectSerializer serializer;
     if (_map.TryGetValue(new DataContractKey(rawBusMessage.Name, rawBusMessage.Namespace), out serializer))
     {
         rawBusMessage.Data = serializer.ReadObject(bodyContent);
     }
 }
        public void DeliveryFailed(int errorCode, string text, RawBusMessage message)
        {
            _errorCode = errorCode;
            _text = text;
            _message = message;

            _ev.Set();
        }
Esempio n. 5
0
        public void SetResponse(RawBusMessage message, Exception exception)
        {
            _message = message;
            _exception = exception;

            _callback(_message, _exception);

            _ev.Set();
        }
Esempio n. 6
0
        private bool IsMessageSurvivesFilter(MessageFilterInfo filterInfo, RawBusMessage busMessage)
        {
            // TODO: Add header filtering

            if (filterInfo.ReceiveSelfPublish) return true;

            bool selfPublished = Equals(busMessage.BusId, _busId);

            return !selfPublished;
        }
Esempio n. 7
0
 private static void SetUserHeaders(RawBusMessage busMessage, Message message)
 {
     foreach (BusHeader busHeader in busMessage.Headers)
     {
         message.Headers.Add(MessageHeader.CreateHeader(busHeader.Name,
                                                        MessagingConstants.Namespace.MessageBus,
                                                        busHeader.Value, false,
                                                        MessagingConstants.Actor.User));
     }
 }
Esempio n. 8
0
        public byte[] Serialize(RawBusMessage busMessage)
        {
            object data = busMessage.Data;

            if (data.GetType() == typeof(byte[]))
            {
                return data as byte[];
            }

            string body = JsonConvert.SerializeObject(data, Formatting.None);

            return _encoding.GetBytes(body);
        }
Esempio n. 9
0
        public byte[] Serialize(RawBusMessage busMessage)
        {
            using (Message message = Message.CreateMessage(_encoderFactory.MessageVersion, MessagingConstants.MessageAction.Regular, busMessage.Data))
            {
                SetBusHeaders(busMessage, message);

                SetUserHeaders(busMessage, message);

                // Serialize the message to stream
                using (MemoryStream str = new MemoryStream())
                {
                    _encoderFactory.Encoder.WriteMessage(message, str);

                    return str.ToArray();
                }
            }
        }
Esempio n. 10
0
        public void Intercept(IInvocation invocation)
        {
            object data = _messageFactory.CreateMessage(invocation.Method, invocation.Arguments);

            RawBusMessage message = new RawBusMessage
            {
                Data = data,
            };

            IEnumerable<BusHeader> headers = _headersProvider.GetMessageHeaders();

            foreach (BusHeader header in headers)
            {
                message.Headers.Add(header);
            }

            _publisher.Send(message);
        }
Esempio n. 11
0
        public static RawBusMessage ToRawBusMessage <T>(this BusMessage <T> message)
        {
            if (message == null)
            {
                return(null);
            }

            RawBusMessage rawBusMessage = new RawBusMessage
            {
                Data = message.Data
            };

            foreach (var header in message.Headers)
            {
                rawBusMessage.Headers.Add(header);
            }

            return(rawBusMessage);
        }
Esempio n. 12
0
        public RawBusMessage ReadMessage(Message message, Action<RawBusMessage, XmlDictionaryReader> deserializer)
        {
            string busId = message.Headers.GetHeader<string>(MessagingConstants.HeaderNames.BusId,
                                                             MessagingConstants.Namespace.MessageBus,
                                                             MessagingConstants.Actor.Bus);

            DateTime sent = message.Headers.GetHeader<DateTime>(MessagingConstants.HeaderNames.SentTime,
                                                                MessagingConstants.Namespace.MessageBus,
                                                                MessagingConstants.Actor.Bus);

            RawBusMessage rawBusMessage = new RawBusMessage
                {
                    BusId = busId,
                    Sent = sent
                };

            foreach (MessageHeaderInfo headerInfo in message.Headers.Where(info => info.Actor == MessagingConstants.Actor.User &&
                                                                                   info.Namespace == MessagingConstants.Namespace.MessageBus))
            {
                string value = message.Headers.GetHeader<string>(headerInfo.Name, headerInfo.Namespace, headerInfo.Actor);

                rawBusMessage.Headers.Add(new BusHeader
                    {
                        Name = headerInfo.Name,
                        Value = value
                    });
            }

            using (XmlDictionaryReader bodyContents = message.GetReaderAtBodyContents())
            {
                rawBusMessage.Name = bodyContents.Name;
                rawBusMessage.Namespace = bodyContents.NamespaceURI;

                deserializer(rawBusMessage, bodyContents);
            }

            return rawBusMessage;
        }
Esempio n. 13
0
 public void SetUp()
 {
     _busMessage = null;
     _exception = null;
 }
Esempio n. 14
0
        public void MessageFilteredOut(RawBusMessage busMessage)
        {
            _busMessage = busMessage;

            _ev.Set();
        }
Esempio n. 15
0
        public void MessageDispatchException(RawBusMessage busMessage, Exception exception)
        {
            _busMessage = busMessage;
            _exception = exception;

            _ev.Set();
        }
Esempio n. 16
0
        public void MessageDeserializeException(RawBusMessage busMessage, Exception exception)
        {
            _busMessage = busMessage;
            _exception = exception;

            _ev.Set();
        }
Esempio n. 17
0
 protected abstract void OnMessageReturn(int replyCode, string replyText, RawBusMessage message);
Esempio n. 18
0
 protected virtual Task<RawBusMessage> HandleMessage(ICallHandler handler, RawBusMessage message, bool redelivered, ulong deliveryTag)
 {
     return handler.Dispatch(message);
 }
Esempio n. 19
0
 public void MessageArrived(string busId, RawBusMessage busMessage, string consumerTag)
 {
 }
Esempio n. 20
0
 public void Dispatch(RawBusMessage message)
 {
     _action(message);
 }
 public byte[] Serialize(RawBusMessage data)
 {
     return ((ScaleoutMessage)data.Data).ToBytes();
 }
Esempio n. 22
0
        public Task<RawBusMessage> Dispatch(RawBusMessage message)
        {
            _action(message);

            return Task.FromResult(new RawBusMessage());
        }
Esempio n. 23
0
        public async Task<RawBusMessage> Dispatch(RawBusMessage message)
        {
            await _action(message);

            return new RawBusMessage();
        }
 public void DeliveryFailed(int errorCode, string text, RawBusMessage message)
 {
 }
Esempio n. 25
0
        public void UnregisteredMessageArrived(RawBusMessage busMessage)
        {
            _busMessage = busMessage;

            _ev.Set();
        }
Esempio n. 26
0
 public void MessageSent(string busId, RawBusMessage busMessage)
 {
 }
Esempio n. 27
0
 private void SetBusHeaders(RawBusMessage busMessage, Message message)
 {
     SetBusHeader(message, MessagingConstants.HeaderNames.Name, busMessage.Name);
     SetBusHeader(message, MessagingConstants.HeaderNames.NameSpace, busMessage.Namespace);
     SetBusHeader(message, MessagingConstants.HeaderNames.BusId, busMessage.BusId);
     SetBusHeader(message, MessagingConstants.HeaderNames.SentTime, busMessage.Sent);
 }
Esempio n. 28
0
 public void Dispatch(RawBusMessage message)
 {
 }
 public bool Filter(Exception exception, RawBusMessage message, bool redelivered, ulong deliveryTag)
 {
     return !redelivered;
 }
Esempio n. 30
0
        protected virtual async Task<bool> ConsumeMessage(bool redelivered, ulong deliveryTag, IBasicProperties properties, byte[] body)
        {
            DataContractKey dataContractKey = properties.GetDataContractKey();

            var subscription =
                _subscriptions.Where(p => p.Value.FilterInfo.ContractKey.Equals(dataContractKey)).Select(
                    pair =>
                        new
                        {
                            DataType = pair.Key,
                            pair.Value.Handler
                        }).FirstOrDefault();

            if (subscription == null)
            {
                 RawBusMessage rawBusMessage = _messageHelper.ConstructMessage(dataContractKey, properties, (object)body);

                _errorSubscriber.UnregisteredMessageArrived(rawBusMessage);

                return false;
            }

            object data;

            if (!_serializers.ContainsKey(properties.ContentType))
            {
                RawBusMessage rawBusMessage = _messageHelper.ConstructMessage(dataContractKey, properties, (object)body);

                _errorSubscriber.MessageDeserializeException(rawBusMessage, new Exception("Unsupported content type"));

                return false;
            }

            ISerializer serializer;
            
            try
            {
                serializer = _serializers[properties.ContentType];
                
                data = serializer.Deserialize(dataContractKey, subscription.DataType, body);
            }
            catch (Exception ex)
            {
                RawBusMessage rawBusMessage = _messageHelper.ConstructMessage(dataContractKey, properties, (object)body);

                _errorSubscriber.MessageDeserializeException(rawBusMessage, ex);

                return false;
            }
            
            RawBusMessage message = _messageHelper.ConstructMessage(dataContractKey, properties, data);

            if (!_receiveSelfPublish && _busId.Equals(message.BusId))
            {
                _errorSubscriber.MessageFilteredOut(message);

                return false;
            }

            _trace.MessageArrived(_busId, message, ConsumerTag);

            RawBusMessage reply;

            try
            {
                reply = await HandleMessage(subscription.Handler, message, redelivered, deliveryTag);
            }
            catch (RejectMessageException ex)
            {
                reply = new RawBusMessage
                {
                    Data = ex.ReplyData
                };
                
                reply.Headers.Add(new RejectedHeader());
            }
            catch (Exception ex)
            {
                _errorSubscriber.MessageDispatchException(message, ex);

                reply = new RawBusMessage();

                reply.Headers.Add(new ExceptionHeader
                {
                    Message = ex.Message
                });
            }

            if (!_neverReply && reply != null && properties.IsReplyToPresent())
            {
                _sendHelper.Send(new SendParams
                {
                    BusId = _busId,
                    BusMessage = reply,
                    Model = Model,
                    CorrelationId = properties.IsCorrelationIdPresent() ? properties.CorrelationId : "",
                    Exchange = _replyExchange,
                    RoutingKey = properties.ReplyTo,
                    Serializer = serializer,
                    MandatoryDelivery = false,
                    PersistentDelivery = false
                });

                _trace.MessageSent(_busId, reply);
            }

            return true;
        }
Esempio n. 31
0
        public RawBusMessage Dispatch(RawBusMessage message)
        {
            _action(message);

            return new RawBusMessage();
        }