public void PutMessage(string content, int priority, int characterSet, string correlationId, string groupId, int?lsn)
        {
            var ep  = BuildExtendedProperties(correlationId, groupId, lsn);
            var msg = QueueSource.NewMessage(content, priority, characterSet, ep);

            QueueSource.PutMessages(new[] { msg }, CancellationToken.None);
        }
        public void A_QueueSource_should_fail_when_an_error_occurs()
        {
            Queue.DeleteIfExists();

            var probe = QueueSource.Create(Queue, pollInterval: TimeSpan.FromSeconds(1))
                        .Take(3)
                        .Select(x => x.AsString)
                        .RunWith(this.SinkProbe <string>(), Materializer);

            probe.Request(1).ExpectError();
        }
Beispiel #3
0
        public async Task A_QueueSource_should_fail_when_an_error_occurs()
        {
            await Queue.DeleteIfExistsAsync();

            var probe = QueueSource.Create(Queue, pollInterval: TimeSpan.FromSeconds(1))
                        .Take(3)
                        .Select(x => x.MessageText)
                        .RunWith(this.SinkProbe <string>(), Materializer);

            Output.WriteLine(probe.Request(1).ExpectError().Message);
        }
        public void PutMessages(IEnumerable <string> contents, int priority, int characterSet, string correlationId, string groupId, int?lsn, CancellationToken ct, IProgress <int> progress)
        {
            var msgs = contents.Select(s =>
            {
                var ep = BuildExtendedProperties(correlationId, groupId, lsn);
                if (lsn.HasValue)
                {
                    lsn++;
                }
                return(QueueSource.NewMessage(s, priority, characterSet, ep));
            }).ToList();

            QueueSource.PutMessages(msgs, ct, progress);
        }
        public void A_QueueSource_should_push_available_messages()
        {
            Queue.AddMessage(new CloudQueueMessage("Test1"));
            Queue.AddMessage(new CloudQueueMessage("Test2"));
            Queue.AddMessage(new CloudQueueMessage("Test3"));

            QueueSource.Create(Queue)
            .Take(3)
            .Select(x => x.AsString)
            .RunWith(this.SinkProbe <string>(), Materializer)
            .Request(3)
            .ExpectNext("Test1", "Test2", "Test3")
            .ExpectComplete();
        }
        public IEnumerable <MessageInfo> Browse(int numberOfMessages, BrowseFilter filter, CancellationToken ct, IProgress <int> progress, MessageInfo lastMessage, IByteCharConverter converter)
        {
            int indexOffset = 0;

            if (lastMessage != null && lastMessage.Index.HasValue)
            {
                indexOffset = lastMessage.Index.Value;
            }

            foreach (var msg in QueueSource.BrowseMessages(numberOfMessages, ct, lastMessage?.MessageId, filter, progress))
            {
                var mi = new MessageInfo(msg, converter, indexOffset);
                yield return(mi);
            }
        }
Beispiel #7
0
        public async Task A_QueueSource_should_push_available_messages()
        {
            await Queue.SendMessageAsync("Test1");

            await Queue.SendMessageAsync("Test2");

            await Queue.SendMessageAsync("Test3");

            var probe = QueueSource.Create(Queue)
                        .Take(3)
                        .Select(x => x.MessageText)
                        .RunWith(this.SinkProbe <string>(), Materializer);

            probe.Request(3)
            .ExpectNext("Test1", "Test2", "Test3")
            .ExpectComplete();
        }
        public void A_QueueSource_should_poll_for_messages_if_the_queue_is_empty()
        {
            Queue.AddMessage(new CloudQueueMessage("Test1"));

            var probe = QueueSource.Create(Queue, pollInterval: TimeSpan.FromSeconds(1))
                        .Take(3)
                        .Select(x => x.AsString)
                        .RunWith(this.SinkProbe <string>(), Materializer);

            probe.Request(2)
            .ExpectNext("Test1")
            .ExpectNoMsg(TimeSpan.FromSeconds(3));

            Queue.AddMessage(new CloudQueueMessage("Test2"));
            Queue.AddMessage(new CloudQueueMessage("Test3"));

            probe.ExpectNext("Test2", TimeSpan.FromSeconds(2));
            probe.Request(1).ExpectNext("Test3").ExpectComplete();
        }
Beispiel #9
0
        public async Task A_QueueSource_should_poll_for_messages_if_the_queue_is_empty()
        {
            await Queue.SendMessageAsync("Test1");

            var probe = QueueSource.Create(Queue, pollInterval: TimeSpan.FromSeconds(1))
                        .Take(3)
                        .Select(x => x.MessageText)
                        .RunWith(this.SinkProbe <string>(), Materializer);

            probe.Request(2)
            .ExpectNext("Test1")
            .ExpectNoMsg(TimeSpan.FromSeconds(3));

            await Queue.SendMessageAsync("Test2");

            await Queue.SendMessageAsync("Test3");

            probe.ExpectNext("Test2", TimeSpan.FromSeconds(2));
            probe.Request(1).ExpectNext("Test3").ExpectComplete();
        }
        public void A_QueueSource_should_not_fail_if_the_supervision_strategy_is_not_stop_when_an_error_occurs()
        {
            Queue.DeleteIfExists();

            var probe = QueueSource.Create(Queue, pollInterval: TimeSpan.FromSeconds(1))
                        .Take(3)
                        .Select(x => x.AsString)
                        .WithAttributes(ActorAttributes.CreateSupervisionStrategy(Deciders.ResumingDecider))
                        .RunWith(this.SinkProbe <string>(), Materializer);

            probe.Request(3).ExpectNoMsg();

            Queue.CreateIfNotExists();
            Queue.AddMessage(new CloudQueueMessage("Test1"));
            Queue.AddMessage(new CloudQueueMessage("Test2"));
            Queue.AddMessage(new CloudQueueMessage("Test3"));

            probe.ExpectNext("Test1", "Test2", "Test3")
            .ExpectComplete();
        }
        public void A_QueueSource_should_only_poll_if_demand_is_available()
        {
            Queue.AddMessage(new CloudQueueMessage("Test1"));

            var probe = QueueSource.Create(Queue, pollInterval: TimeSpan.FromSeconds(1))
                        .Select(x =>
            {
                Queue.DeleteMessage(x);
                return(x.AsString);
            })
                        .RunWith(this.SinkProbe <string>(), Materializer);

            probe.Request(1).ExpectNext("Test1");

            Queue.AddMessage(new CloudQueueMessage("Test2"));

            probe.ExpectNoMsg(TimeSpan.FromSeconds(3));
            //Message wouldn't be visible if the source has called GetMessages even if the message wasn't pushed to the stream
            Queue.PeekMessage().AsString.Should().Be("Test2");

            probe.Request(1).ExpectNext("Test2");
        }
Beispiel #12
0
        public async Task A_QueueSource_should_only_poll_if_demand_is_available()
        {
            await Queue.SendMessageAsync("Test1");

            var probe = QueueSource.Create(Queue, pollInterval: TimeSpan.FromSeconds(1))
                        .Select(x =>
            {
                Queue.DeleteMessage(x.MessageId, x.PopReceipt);
                return(x.MessageText);
            })
                        .RunWith(this.SinkProbe <string>(), Materializer);

            probe.Request(1).ExpectNext("Test1");

            await Queue.SendMessageAsync("Test2");

            probe.ExpectNoMsg(TimeSpan.FromSeconds(3));
            //Message wouldn't be visible if the source has called GetMessages even if the message wasn't pushed to the stream
            (await Queue.PeekMessagesAsync(1)).Value[0].MessageText.Should().Be("Test2");

            probe.Request(1).ExpectNext("Test2");
        }
Beispiel #13
0
        public async Task A_QueueSource_should_not_fail_if_the_supervision_strategy_is_not_stop_when_an_error_occurs()
        {
            await Queue.DeleteIfExistsAsync();

            var probe = QueueSource.Create(Queue, pollInterval: TimeSpan.FromSeconds(1))
                        .Take(3)
                        .Select(x => x.MessageText)
                        .WithAttributes(ActorAttributes.CreateSupervisionStrategy(Deciders.ResumingDecider))
                        .RunWith(this.SinkProbe <string>(), Materializer);

            probe.Request(3).ExpectNoMsg();

            await Queue.CreateIfNotExistsAsync();

            await Queue.SendMessageAsync("Test1", TimeSpan.Zero);

            await Queue.SendMessageAsync("Test2", TimeSpan.Zero);

            await Queue.SendMessageAsync("Test3", TimeSpan.Zero);

            probe.ExpectNext("Test1", "Test2", "Test3")
            .ExpectComplete();
        }
Beispiel #14
0
        public void StartSyncronizing()
        {
            enable = true;
            Task.Factory.StartNew(() =>
            {
                IDbManager dbManager = ObjectPool.Instance.Resolve <IDbManager>();
                IDataCommand db      = dbManager.GetDatabase(DatabaseNames.SMSGW);

                List <Inbox> newInbox;
                List <Outbox> newOutbox;
                List <Trash> newTrash;
                List <Spam> newSpam;

                while (enable)
                {
                    newInbox  = db.Query <Inbox>("GetInbox");
                    newOutbox = db.Query <Outbox>("GetOutbox");
                    newTrash  = db.Query <Trash>("GetTrash");
                    newSpam   = db.Query <Spam>("GetSpam");

                    // save current view source
                    InboxMaster.Source  = newInbox.Convert <Inbox>();
                    OutboxMaster.Source = newOutbox.Convert <Outbox>();
                    SpamMaster.Source   = newSpam.Convert <Spam>();
                    TrashMaster.Source  = newTrash.Convert <Trash>();

                    DraftSource.Refresh();
                    QueueSource.Refresh();

                    // refresh all view source when search text box is empty
                    if (string.IsNullOrEmpty(searchText))
                    {
                        IEnumerable <Inbox> inboxAdded;
                        MutableObservableCollection <Inbox> inboxRemoved;

                        IEnumerable <Outbox> outboxAdded;
                        IEnumerable <Outbox> outboxRemoved;

                        IEnumerable <Spam> spamAdded;
                        IEnumerable <Spam> spamRemoved;

                        IEnumerable <Trash> trashAdded;
                        IEnumerable <Trash> trashRemoved;

                        if (firstLoaded)
                        {
                            firstLoaded         = false;
                            InboxSource.Source  = newInbox.Convert <Inbox>();
                            OutboxSource.Source = newOutbox.Convert <Outbox>();
                            SpamSource.Source   = newSpam.Convert <Spam>();
                            TrashSource.Source  = newTrash.Convert <Trash>();
                        }
                        else
                        {
                            if (newInbox.Count > InboxSource.Source.Count)
                            {
                                inboxAdded = newInbox.Except(InboxSource.Source, new InboxComparer());
                                if (inboxAdded.Any())
                                {
                                    foreach (Inbox message in inboxAdded)
                                    {
                                        InboxSource.Source.Insert(0, message);
                                    }
                                    InboxSource.Unread = inboxAdded.Count();
                                    InboxHeader        = "inbox";

                                    ApplicationSettings settings = ObjectPool.Instance.Resolve <ApplicationSettings>();
                                    if (settings.General.Sounds)
                                    {
                                        IAudioService audio = ObjectPool.Instance.Resolve <IAudioService>();
                                        audio.PlayAsync(AudioEnum.ReceiveMessage);
                                    }
                                }
                            }
                            else if (newInbox.Count < InboxSource.Source.Count)
                            {
                                inboxRemoved = InboxSource.Source.Except(newInbox, new InboxComparer()).Convert <Inbox>();
                                foreach (Inbox removed in inboxRemoved.ToList())
                                {
                                    InboxSource.Source.Remove(removed);
                                }
                            }

                            if (newOutbox.Count > OutboxSource.Source.Count)
                            {
                                outboxAdded = newOutbox.Except(OutboxSource.Source, new OutboxComparer());
                                if (outboxAdded.Any())
                                {
                                    foreach (Outbox message in outboxAdded)
                                    {
                                        OutboxSource.Source.Insert(0, message);
                                    }
                                }
                                OutboxSource.Unread = outboxAdded.Count();
                            }
                            else if (newOutbox.Count < OutboxSource.Source.Count)
                            {
                                outboxRemoved = OutboxSource.Source.Except(newOutbox, new OutboxComparer());
                                foreach (Outbox removed in outboxRemoved.ToList())
                                {
                                    OutboxSource.Source.Remove(removed);
                                }
                            }

                            if (newTrash.Count > TrashSource.Source.Count)
                            {
                                trashAdded = newTrash.Except(TrashSource.Source, new TrashComparer());
                                if (trashAdded.Any())
                                {
                                    foreach (Trash message in trashAdded)
                                    {
                                        TrashSource.Source.Insert(0, message);
                                    }
                                }
                                TrashSource.Unread = trashAdded.Count();
                            }
                            else if (newTrash.Count < TrashSource.Source.Count)
                            {
                                trashRemoved = TrashSource.Source.Except(newTrash, new TrashComparer());
                                foreach (Trash removed in trashRemoved.ToList())
                                {
                                    TrashSource.Source.Remove(removed);
                                }
                            }

                            if (newSpam.Count > SpamSource.Source.Count)
                            {
                                spamAdded = newSpam.Except(SpamSource.Source, new SpamComparer());
                                if (spamAdded.Any())
                                {
                                    foreach (Spam message in spamAdded)
                                    {
                                        SpamSource.Source.Insert(0, message);
                                    }
                                }
                                SpamSource.Unread = spamAdded.Count();
                            }
                            else if (newSpam.Count < SpamSource.Source.Count)
                            {
                                spamRemoved = SpamSource.Source.Except(newSpam, new SpamComparer());
                                foreach (Spam removed in spamRemoved.ToList())
                                {
                                    SpamSource.Source.Remove(removed);
                                }
                            }
                        }
                    }

                    wait.WaitOne(3000);
                }
                db.Close();
            });
        }
 public void RefreshInfo()
 {
     QueueSource.RefreshInfo();
 }
 internal void Empty(bool withTruncate)
 {
     QueueSource.ClearQueue(withTruncate);
 }
 public void ForwardMessages(IEnumerable <MessageInfo> list, IQueue destinationQ, CancellationToken ct, IProgress <int> progress)
 {
     QueueSource.ForwardMessages(list.Select(m => m.MessageSource).ToList(), destinationQ, ct, progress);
 }
 public void DeleteMessages(IEnumerable <MessageInfo> list, CancellationToken ct, IProgress <int> progress)
 {
     QueueSource.DeleteMessages(list.Select(m => m.MessageSource).ToList(), ct, progress);
 }
 protected override void Queue()
 {
     QueueSource.AddAllTracks(Music);
 }
 public void SetPutStatus(GetPutStatus newStatus)
 {
     QueueSource.SetPutStatus(newStatus);
 }
Beispiel #21
0
        public void Setup()
        {
            _firstPage = new ListMetricsResponse
            {
                NextToken = "token-1",
                Metrics   = new List <Metric>
                {
                    new Metric
                    {
                        MetricName = "ApproximateAgeOfOldestMessage",
                        Dimensions = new List <Dimension>
                        {
                            new Dimension
                            {
                                Name  = "QueueName",
                                Value = "Queue-1"
                            }
                        }
                    }
                }
            };
            _secondPage = new ListMetricsResponse
            {
                NextToken = "token-2",
                Metrics   = new List <Metric>
                {
                    new Metric
                    {
                        MetricName = "ApproximateAgeOfOldestMessage",
                        Dimensions = new List <Dimension>
                        {
                            new Dimension
                            {
                                Name  = "QueueName",
                                Value = "Queue-2"
                            }
                        }
                    }
                }
            };
            _thirdPage = new ListMetricsResponse
            {
                NextToken = "token-3",
                Metrics   = new List <Metric>
                {
                    new Metric
                    {
                        MetricName = "ApproximateAgeOfOldestMessage",
                        Dimensions = new List <Dimension>
                        {
                            new Dimension
                            {
                                Name  = "QueueName",
                                Value = "Queue-3"
                            }
                        }
                    }
                }
            };

            _attributes = new Dictionary <string, string>
            {
                { "AttrName", "AttrValue" }
            };

            var cloudWatchMock = new Mock <IAmazonCloudWatch>();

            cloudWatchMock.Setup(s => s.ListMetricsAsync(
                                     It.Is <ListMetricsRequest>(r => r.MetricName == "ApproximateAgeOfOldestMessage" && r.NextToken == null),
                                     It.IsAny <CancellationToken>()))
            .ReturnsAsync(_firstPage);

            cloudWatchMock.Setup(s => s.ListMetricsAsync(
                                     It.Is <ListMetricsRequest>(r => r.MetricName == "ApproximateAgeOfOldestMessage" && r.NextToken == "token-1"),
                                     It.IsAny <CancellationToken>()))
            .ReturnsAsync(_secondPage);

            cloudWatchMock.Setup(s => s.ListMetricsAsync(
                                     It.Is <ListMetricsRequest>(r => r.MetricName == "ApproximateAgeOfOldestMessage" && r.NextToken == "token-2"),
                                     It.IsAny <CancellationToken>()))
            .ReturnsAsync(_thirdPage);


            _queueSource = new QueueSource(cloudWatchMock.Object);
        }
 public void EmptyQueue(bool truncate)
 {
     QueueSource.ClearQueue(truncate);
 }