Initialize() public méthode

public Initialize ( ) : void
Résultat void
Exemple #1
0
 public void CanCreateNewQueueFactory()
 {
     using (var qf = new QueueStorage("test.esent"))
     {
         qf.Initialize();
     }
 }
        public void MovesMessageToOutgoingHistoryAfterMaxAttempts()
        {
            Directory.Delete("test.esent", true);
            using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration()))
            {
                qf.Initialize();
                qf.Global(actions =>
                {
                    actions.CreateQueueIfDoesNotExists("test");
                    actions.Commit();
                });

                var testMessage = new MessagePayload
                {
                    Data = new byte[0],
                    DeliverBy = null,
                    Headers = new NameValueCollection(),
                    MaxAttempts = 1
                };

                Guid messageId = Guid.Empty;
                qf.Global(actions =>
                {
                    Guid transactionId = Guid.NewGuid();
                    messageId = actions.RegisterToSend(new Endpoint("localhost", 0),
                        "test",
                        null,
                        testMessage,
                        transactionId);
                    actions.MarkAsReadyToSend(transactionId);
                    actions.Commit();
                });

                qf.Send(actions =>
                {
                    Endpoint endpoint;
                    var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
                    actions.MarkOutgoingMessageAsFailedTransmission(msgs.First().Bookmark, false);

                    msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
                    Assert.Empty(msgs);
                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    PersistentMessageToSend message = actions.GetSentMessages().FirstOrDefault(x => x.Id.MessageIdentifier == messageId);
                    Assert.NotNull(message);
                    Assert.Equal(OutgoingMessageStatus.Failed, message.OutgoingStatus);
                    actions.Commit();
                });
            }
        }
        public void MovesMessageToOutgoingFromHistory()
        {
            using (var qf = new QueueStorage("test.esent"))
            {
                qf.Initialize();
                qf.Global(actions =>
                {
                    actions.CreateQueueIfDoesNotExists("test");
                    actions.Commit();
                });

                var testMessage = new MessagePayload
                {
                    Data = new byte[0],
                    Headers = new NameValueCollection(),
                };

                qf.Global(actions =>
                {
                    Guid transactionId = Guid.NewGuid();
                    actions.RegisterToSend(new Endpoint("localhost", 0),
                        "test",
                        null,
                        testMessage,
                        transactionId);
                    actions.MarkAsReadyToSend(transactionId);
                    actions.Commit();
                });

                qf.Send(actions =>
                {
                    Endpoint endpoint;
                    var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
                    var bookmark = actions.MarkOutgoingMessageAsSuccessfullySent(msgs[0].Bookmark);
                    actions.RevertBackToSend(new[] { bookmark });

                    msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
                    Assert.NotEmpty(msgs);
                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    var messages = actions.GetSentMessages();
                    Assert.Empty(messages);
                    actions.Commit();
                });
            }
        }
        public QueueManager(IPEndPoint endpoint, string path, QueueManagerConfiguration configuration)
        {
            Configuration = configuration;

            this.endpoint = endpoint;
            this.path = path;
            queueStorage = new QueueStorage(path, configuration);
            queueStorage.Initialize();

            queueStorage.Global(actions =>
            {
                receivedMsgs.Add(actions.GetAlreadyReceivedMessageIds());

                actions.Commit();
            });

            HandleRecovery();
        }
Exemple #5
0
        public void CanDeleteOldEntries()
        {
            using (var qf = new QueueStorage("test.esent"))
            {
                qf.Initialize();

                var random = MessageId.GenerateRandom();
                qf.Global(actions =>
                {
                    for (int i = 0; i < 5; i++)
                    {
                        actions.MarkReceived(MessageId.GenerateRandom());
                    }
                    actions.MarkReceived(random);

                    for (int i = 0; i < 5; i++)
                    {
                        actions.MarkReceived(MessageId.GenerateRandom());
                    }

                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    actions.DeleteOldestReceivedMessages(6).ToArray();//consume & activate

                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    var array = actions.GetAlreadyReceivedMessageIds().ToArray();
                    Assert.Equal(6, array.Length);
                    Assert.Equal(random, array[0]);

                    actions.Commit();
                });
            }
        }
        public QueueManager(IPEndPoint endpoint, string path)
        {
            NumberOfMessagesToKeepInProcessedQueues = 100;
            NumberOfMessagesToKeepOutgoingQueues = 100;
            NumberOfReceivedMessagesToKeep = 100000;
            OldestMessageInProcessedQueues = TimeSpan.FromDays(3);
            OldestMessageInOutgoingQueues = TimeSpan.FromDays(3);

            this.endpoint = endpoint;
            this.path = path;
            queueStorage = new QueueStorage(path);
            queueStorage.Initialize();

            queueStorage.Global(actions =>
            {
                receivedMsgs.Add(actions.GetAlreadyReceivedMessageIds());

                actions.Commit();
            });

            HandleRecovery();
        }
Exemple #7
0
        public QueueManager(IPEndPoint endpoint, string path)
        {
            NumberOfMessagesToKeepInProcessedQueues = 100;
            NumberOfMessagesToKeepOutgoingQueues = 100;
            NumberOfReceivedMessagesToKeep = 100000;
            OldestMessageInProcessedQueues = TimeSpan.FromDays(3);
            OldestMessageInOutgoingQueues = TimeSpan.FromDays(3);

            this.endpoint = endpoint;
            this.path = path;
            queueStorage = new QueueStorage(path);
            queueStorage.Initialize();

            queueStorage.Global(actions =>
            {
                receivedMsgs.Add(actions.GetAlreadyReceivedMessageIds());

                actions.Commit();
            });

            receiver = new Receiver(endpoint, AcceptMessages);
            receiver.Start();

            HandleRecovery();

            queuedMessagesSender = new QueuedMessagesSender(queueStorage, this);
            sendingThread = new Thread(queuedMessagesSender.Send)
            {
                IsBackground = true,
                Name = "Rhino Queue Sender Thread for " + path
            };
            sendingThread.Start();
            purgeOldDataTimer = new Timer(PurgeOldData, null,
                TimeSpan.FromMinutes(3),
                TimeSpan.FromMinutes(3));
        }
Exemple #8
0
        public void WillNotGiveMessageToTwoClient()
        {
            using (var qf = new QueueStorage("test.esent"))
            {
                qf.Initialize();

                qf.Global(actions =>
                {
                    actions.CreateQueueIfDoesNotExists("h");
                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    var queue = actions.GetQueue("h");
                    var bookmark = queue.Enqueue(new Message
                    {
                        Queue = "h",
                        Id = MessageId.GenerateRandom(),
                        Data = new byte[] { 1 },
                    });
                    queue.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);

                    bookmark = queue.Enqueue(new Message
                    {
                        Queue = "h",
                        Id = MessageId.GenerateRandom(),
                        Data = new byte[] { 2 },
                    });
                    queue.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);

                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    var m1 = actions.GetQueue("h").Dequeue(null);

                    qf.Global(queuesActions =>
                    {
                        var m2 = queuesActions.GetQueue("h").Dequeue(null);

                        Assert.Equal(new byte[] { 2 }, m2.Data);

                        queuesActions.Commit();
                    });

                   Assert.Equal(new byte[] { 1 }, m1.Data);
                   actions.Commit();
                });
            }
        }
Exemple #9
0
        public void WillGiveNullWhenNoItemsAreInQueue()
        {
            using (var qf = new QueueStorage("test.esent"))
            {
                qf.Initialize();

                qf.Global(actions =>
                {
                    actions.CreateQueueIfDoesNotExists("h");
                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    var message = actions.GetQueue("h").Dequeue(null);
                    Assert.Null(message);
                    actions.Commit();
                });
            }
        }
Exemple #10
0
        public void CanRegisterReceivedMessageIds()
        {
            using (var qf = new QueueStorage("test.esent"))
            {
                qf.Initialize();

                    var random = MessageId.GenerateRandom();
                qf.Global(actions =>
                {
                    actions.MarkReceived(random);

                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    Assert.True(actions.GetAlreadyReceivedMessageIds().Contains(random));

                    actions.Commit();
                });
            }
        }
Exemple #11
0
        public void CanPutSingleMessageInQueue()
        {
            using (var qf = new QueueStorage("test.esent"))
            {
                qf.Initialize();

                qf.Global(actions =>
                {
                    actions.CreateQueueIfDoesNotExists("h");
                    actions.Commit();
                });

                MessageBookmark bookmark = null;
                var guid = Guid.NewGuid();
                var identifier = Guid.NewGuid();
                qf.Global(actions =>
                {
                    bookmark = actions.GetQueue("h").Enqueue(new Message
                    {
                        Queue = "h",
                        Data = new byte[] { 13, 12, 43, 5 },
                        SentAt = new DateTime(2004, 5, 5),
                        Id = new MessageId { SourceInstanceId = guid, MessageIdentifier = identifier }
                    });
                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    actions.GetQueue("h").SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);
                    actions.Commit();
                });

                qf.Global(actions =>
                {
                    var message = actions.GetQueue("h").Dequeue(null);

                    Assert.Equal(new byte[] { 13, 12, 43, 5 }, message.Data);
                    Assert.Equal(identifier, message.Id.MessageIdentifier);
                    Assert.Equal(guid, message.Id.SourceInstanceId);
                    Assert.Equal("h", message.Queue);
                    Assert.Equal(new DateTime(2004, 5, 5), message.SentAt);
                    actions.Commit();
                });
            }
        }