Esempio n. 1
0
 private void DBWork2(ISession session)
 {
     using (var tx = session.BeginTransaction())
     {
         RmqPublishMessage msg = session.Get <RmqPublishMessage>(Guid.Parse("c7cc9aae-0c81-433d-97cd-b827db8b49ca"));
         msg.Sender = "second-update";
         tx.Commit();
     }
 }
Esempio n. 2
0
        public void Handler(object sender, BasicNackEventArgs e, IPublishedMessageStore publishedMessageStore)
        {
            using (var tx = publishedMessageStore.BeginTransaction())
            {
                RmqPublishMessage targetMessage = publishedMessageStore.GetByDeliveryTag(e.DeliveryTag);

                targetMessage.Status = MessageStatusConstants.Failed;

                publishedMessageStore.Commit(tx);
            }
        }
Esempio n. 3
0
        public ActionResult <string> Update()
        {
            RmqPublishMessage found = _publishedMessageStore.GetByDeliveryTag(1);

            found.Status = MessageStatusConstants.Success;
            found.Sender = "updated sender";

            _publishedMessageStore.Update(found);

            RmqPublishMessage updated = _publishedMessageStore.GetByMessageId(found.MessageId);

            return(JsonConvert.SerializeObject(updated, Formatting.Indented));
        }
Esempio n. 4
0
        public void Send <D>(D message, string routingKey) where D : IDomainEvent
        {
            var camelCaseSerializer = new JsonSerializer()
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver()
            };

            // set property of message
            var properties = _channel.CreateBasicProperties();

            properties.Persistent = true;

            // map message to RmqPublishMessage object
            RmqPublishMessage rmqMessage = _mapper.Map <RmqPublishMessage>(message);

            // set delivery tag
            rmqMessage.DeliveryTag = _channel.NextPublishSeqNo;

            using (var tx = _publishedMessageStore.BeginTransaction())
            {
                _publishedMessageStore.Create(rmqMessage);

                _publishedMessageStore.Commit(tx);
            }

            // RmqPublishMessage => JObject (message)
            JObject rmqMessageJObject = JObject.FromObject(rmqMessage, camelCaseSerializer);

            // JObject (message) => json
            string jsonMessage = JsonConvert.SerializeObject(rmqMessageJObject, Formatting.None, new JsonSerializerSettings()
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver()
            });

            log.Debug("the message is about sent: ");
            log.Debug(jsonMessage);

            // json (message) => byte[];
            var body = Encoding.UTF8.GetBytes(jsonMessage);

            // send message
            _channel.BasicPublish(exchange: _publisher.ExchangeName,
                                  routingKey: routingKey,
                                  mandatory: true,
                                  basicProperties: properties,
                                  body: body);
        }
Esempio n. 5
0
        public void Handler(object sender, BasicReturnEventArgs e, IPublishedMessageStore publishedMessageStore)
        {
            using (var tx = publishedMessageStore.BeginTransaction())
            {
                string body = Encoding.UTF8.GetString(e.Body);

                RmqPublishMessage returnedMessage = JsonConvert.DeserializeObject <RmqPublishMessage>(body);

                RmqPublishMessage foundMessage = publishedMessageStore.GetByMessageId(returnedMessage.MessageId);

                foundMessage.Status       = MessageStatusConstants.Unroutable;
                foundMessage.StatusReason = e.ReplyText;

                publishedMessageStore.Update(foundMessage);

                publishedMessageStore.Commit(tx);
            }
        }
Esempio n. 6
0
        public ActionResult <string> Msg()
        {
            var    nhConfig       = new Configuration().Configure();
            var    sessionFactory = nhConfig.BuildSessionFactory();
            string result         = "";

            using (var session = sessionFactory.OpenSession())
                using (var tx = session.BeginTransaction())
                {
                    new SchemaExport(nhConfig).Execute(true, true, false, session.Connection, null);

                    IDomainEvent domainEvent = new CartCreatedDomainEvent()
                    {
                        DomainEventId   = Guid.NewGuid().ToString(),
                        DomainEventType = (int)DomainEventTypeConstants.CartCreatedDomainEvent,
                        DomainEventName = "CartCreated",
                        OccurredOn      = DateTime.Now,
                        CartId          = "test-cart-id"
                    };

                    RmqPublishMessage msg = new RmqPublishMessage()
                    {
                        MessageId       = Guid.NewGuid(),
                        DomainEventType = 0,
                        Sender          = "test",
                        OccurredOn      = DateTime.Now,
                        Content         = JObject.FromObject(domainEvent),
                        DeliveryTag     = 1,
                        Status          = MessageStatusConstants.Failed
                    };
                    session.Save(msg);

                    session.Flush();
                    session.Clear();

                    RmqPublishMessage found = session.Get <RmqPublishMessage>(msg.MessageId);
                    result = JsonConvert.SerializeObject(found, Formatting.Indented);

                    tx.Commit();
                }
            return(result);
        }
Esempio n. 7
0
        public ActionResult <string> MultiSessionTest()
        {
            var nhConfig       = new Configuration().Configure();
            var sessionFactory = nhConfig.BuildSessionFactory();

            using (var session = sessionFactory.OpenSession())
                using (var tx = session.BeginTransaction())
                {
                    RmqPublishMessage msg = session.Get <RmqPublishMessage>(Guid.Parse("c7cc9aae-0c81-433d-97cd-b827db8b49ca"));
                    msg.Sender = "update-1";
                    tx.Commit();
                }

            using (var session = sessionFactory.OpenSession())
                using (var tx = session.BeginTransaction())
                {
                    RmqPublishMessage msg = session.Get <RmqPublishMessage>(Guid.Parse("c7cc9aae-0c81-433d-97cd-b827db8b49ca"));
                    msg.Sender = "update-2";
                    tx.Commit();
                }

            return("multi session test");
        }
Esempio n. 8
0
        public ActionResult <string> GetById()
        {
            RmqPublishMessage msg2 = _publishedMessageStore.GetByMessageId(Guid.Parse("c742759a-dbe1-4f54-a97a-dd96feb5deb7"));

            return(JsonConvert.SerializeObject(msg2, Formatting.Indented));
        }
Esempio n. 9
0
        public ActionResult <string> Read()
        {
            RmqPublishMessage found = _publishedMessageStore.GetByDeliveryTag(1);

            return(JsonConvert.SerializeObject(found, Formatting.Indented));
        }
Esempio n. 10
0
 public void Update(RmqPublishMessage updatedMessage)
 {
     _session.Update(updatedMessage);
 }
Esempio n. 11
0
 public Guid Create(RmqPublishMessage message)
 {
     return((Guid)_session.Save(message));
 }