Esempio n. 1
0
            public void Publish(int streamIndex, ulong id, IList <Message> messages, DateTime creationTime)
            {
                var message = new ScaleoutMessage
                {
                    Messages           = messages,
                    ServerCreationTime = creationTime,
                };

                OnReceived(streamIndex, id, message);
            }
Esempio n. 2
0
        public void SingleMessageOnlyVerifyIds()
        {
            var store   = new ScaleoutStore(10);
            var message = new ScaleoutMessage();

            store.Add(new ScaleoutMapping(10ul, message));

            Assert.Equal(10ul, store.MinMappingId);
            Assert.Equal(10ul, store.MaxMapping.Id);
        }
Esempio n. 3
0
            protected override Task Send(int streamIndex, IList <Message> messages)
            {
                var message = new ScaleoutMessage(messages);

                OnReceived(streamIndex, _id, message);

                _id++;

                return(TaskAsyncHelper.Empty);
            }
Esempio n. 4
0
        public static NetMQMessage FromBytes(byte[] bytes)
        {
            using (var r = new BinaryReader(new MemoryStream(bytes)))
            {
                long            messageId       = r.ReadInt64();
                byte[]          messageBytes    = r.ReadBytes(bytes.Length - 8);
                ScaleoutMessage scaleoutMessage = ScaleoutMessage.FromBytes(messageBytes);

                return(new NetMQMessage(messageId, scaleoutMessage));
            }
        }
        public static Stream ToStream(IList <Message> messages)
        {
            if (messages == null)
            {
                throw new ArgumentNullException("messages");
            }

            var scaleoutMessage = new ScaleoutMessage(messages);

            return(new MemoryStream(scaleoutMessage.ToBytes()));
        }
Esempio n. 6
0
        protected override Task Send(int streamIndex, IList <Message> messages)
        {
            var scaleoutMessage = new ScaleoutMessage(messages);
            var bytes           = scaleoutMessage.ToBytes();

            //var stream = ServiceBusMessage.ToStream(messages);

            TraceMessages(messages, "Sending");

            return(_connectionContext.Publish(streamIndex, bytes));
        }
Esempio n. 7
0
        public static byte[] ToBytes(IList <Message> messages)
        {
            if (messages == null)
            {
                throw new ArgumentNullException("messages");
            }

            var message = new ScaleoutMessage(messages);

            return(message.ToBytes());
        }
        // Send messages from the server to the backplane
        protected override Task Send(int streamIndex,
                                     IList <Message> messages)
        {
            return(Task.Factory.StartNew(() =>
            {
                var bytes = new ScaleoutMessage(messages).ToBytes();
                var filePath = BasePath + "\\" +
                               DateTime.Now.Ticks + ".txt";

                File.WriteAllBytes(filePath, bytes);
            }));
        }
Esempio n. 9
0
        public void AccurateMappingIds()
        {
            var store    = new ScaleoutStore(10);
            var message1 = new ScaleoutMessage();

            store.Add(new ScaleoutMapping(10ul, message1));
            var message2 = new ScaleoutMessage();

            store.Add(new ScaleoutMapping(15ul, message2));

            Assert.Equal(10ul, store.MinMappingId);
            Assert.Equal(15ul, store.MaxMapping.Id);
        }
Esempio n. 10
0
        public void GettingMessagesWithCursorInbetweenOnElementRangeGetsAll()
        {
            var store = new ScaleoutStore(10);

            var message = new ScaleoutMessage();

            store.Add(new ScaleoutMapping((ulong)1, message));

            var result = store.GetMessagesByMappingId(2);

            Assert.Equal(0ul, result.FirstMessageId);
            Assert.Equal(0, result.Messages.Count);
        }
Esempio n. 11
0
        public void GettingMessagesWithSentinelCursorReturnsEverything()
        {
            var store = new ScaleoutStore(10);

            var message = new ScaleoutMessage();

            store.Add(new ScaleoutMapping((ulong)0, message));

            var result = store.GetMessagesByMappingId(UInt64.MaxValue);

            Assert.Equal(0ul, result.FirstMessageId);
            Assert.Equal(1, result.Messages.Count);
        }
Esempio n. 12
0
        public void GettingMessagesWithCursorBiggerThanMaxReturnsNothingIfNewer()
        {
            var store = new ScaleoutStore(10);

            for (int i = 0; i < 5; i++)
            {
                var message = new ScaleoutMessage();
                store.Add(new ScaleoutMapping((ulong)i, message));
            }

            var result = store.GetMessagesByMappingId(6);

            Assert.Equal(0, result.Messages.Count);
        }
Esempio n. 13
0
        public static byte[] ToBytes(IList <Message> messages)
        {
            using (var ms = new MemoryStream())
            {
                var binaryWriter = new BinaryWriter(ms);

                var scaleoutMessage = new ScaleoutMessage(messages);
                var buffer          = scaleoutMessage.ToBytes();

                binaryWriter.Write(buffer.Length);
                binaryWriter.Write(buffer);

                return(ms.ToArray());
            }
        }
        public Task Send(IList <Message> messages)
        {
            if (messages == null || messages.Count == 0)
            {
                var tcs = new TaskCompletionSource <object>();
                tcs.SetResult(null);
                return(tcs.Task);
            }

            _trace.TraceVerbose("{0}Sending payload with {1} messages(s)", _tracePrefix, messages.Count, _streamIndex);

            ScaleoutMessage message = new ScaleoutMessage(messages);

            return(_hubProxy.Invoke(BackplaneConstants.BroadcastNotification, message.ToBytes()));
        }
        public static CouchbaseMessage FromMessages(int streamIndex, IList <Message> messages)
        {
            if (messages == null)
            {
                throw new NullReferenceException("messages");
            }

            var scaleoutMessage = new ScaleoutMessage(messages);

            return(new CouchbaseMessage
            {
                Id = DateTime.UtcNow.ToString(),
                StreamIndex = streamIndex,
                Data = scaleoutMessage.ToBytes()
            });
        }
Esempio n. 16
0
        public void GettingMessagesWithCursorLowerThanMinReturnsAll()
        {
            var store = new ScaleoutStore(10);

            for (int i = 5; i < 10; i++)
            {
                var message = new ScaleoutMessage();
                store.Add(new ScaleoutMapping((ulong)i, message));
            }

            var result = store.GetMessagesByMappingId(4);

            Assert.Equal(0ul, result.FirstMessageId);
            Assert.Equal(5ul, store.MinMappingId);
            Assert.Equal(5, result.Messages.Count);
        }
Esempio n. 17
0
            protected override void OnReceived(int streamIndex, ulong id, ScaleoutMessage message)
            {
                string value = message.Messages[0].GetString();

                if (!value.Contains("ServerCommandType"))
                {
                    if (_delay != TimeSpan.Zero)
                    {
                        Thread.Sleep(_delay);
                    }

                    Console.WriteLine("{0}: OnReceived({1}, {2}, {3})", _serverName, streamIndex, id, value);
                }

                base.OnReceived(streamIndex, id, message);
            }
        public void StartReceiving()
        {
            _hubProxy.On <byte[]>(BackplaneConstants.ReceiveNotification, m =>
            {
                ulong id = BitConverter.ToUInt64(m.Take(8).ToArray(), 0);
                ScaleoutMessage message = ScaleoutMessage.FromBytes(m.Skip(8).ToArray());

                foreach (Message msg in message.Messages)
                {
                    msg.MappingId = id;
                }

                _trace.TraceVerbose("Payload {0} containing {1} message(s) received", id, message.Messages.Count);
                Received(id, message);
            });
        }
Esempio n. 19
0
        public void AssertMessagesWithCursorForRange(int[] values, ulong targetId, ulong firstId, int count)
        {
            var store = new ScaleoutStore(10);

            var message = new ScaleoutMessage();

            foreach (var v in values)
            {
                store.Add(new ScaleoutMapping((ulong)v, message));
            }

            var result = store.GetMessagesByMappingId(targetId);

            Assert.Equal(firstId, result.FirstMessageId);
            Assert.Equal(count, result.Messages.Count);
        }
Esempio n. 20
0
        public void GettingMessagesWithCursorLowerThanMinReturnsAllEvenAfterMultipleOverwrites()
        {
            var store = new ScaleoutStore(10);

            for (int i = 0; i < 100; i++)
            {
                var message = new ScaleoutMessage();
                store.Add(new ScaleoutMapping(((ulong)i + MappingIdBase), message));
            }

            var result = store.GetMessagesByMappingId(MappingIdBase + 62);

            Assert.Equal(64ul, result.FirstMessageId);
            Assert.Equal(63ul + MappingIdBase, store.MinMappingId);
            Assert.Equal(8, result.Messages.Count);
            Assert.True(result.HasMoreData);
        }
Esempio n. 21
0
            public void Publish(int streamIndex, ScaleoutMessage message)
            {
                if (Received != null)
                {
                    lock (this)
                    {
                        Received(this, new EventMessage
                        {
                            Id          = (ulong)id,
                            Message     = message,
                            StreamIndex = streamIndex
                        });

                        id++;
                    }
                }
            }
        private void ProcOldMessages(CallContext cntx, SignalRMessageServiceProxy msgsvc)
        {
            var hsvc = new SignalRHostStateServiceProxy();
            var host = hsvc.LoadEntityByNature(cntx, config.HostName, config.App.ID).SingleOrDefault();

            if (host == null)
            {
                host = new SignalRHostState
                {
                    HostName      = config.HostName,
                    ApplicationID = config.App.ID,
                    LastMsgId     = 0
                };
                var x = hsvc.AddOrUpdateEntities(cntx, new SignalRHostStateSet(), new SignalRHostState[] { host });
                host = x.ChangedEntities[0].UpdatedItem;
            }
            DateTime       dt    = DateTime.UtcNow.AddHours(-config.TimeWindowInHours);
            QueryExpresion qexpr = new QueryExpresion();

            qexpr.OrderTks = new List <QToken>(new QToken[] {
                new QToken {
                    TkName = "ID"
                },
                new QToken {
                    TkName = "desc"
                }
            });
            qexpr.FilterTks = new List <QToken>(new QToken[] {
                new QToken {
                    TkName = "ApplicationID == \"" + config.App.ID + "\" && ID > " + host.LastMsgId + " && TimeStamp > " + dt.Ticks
                }
            });
            var msgs = msgsvc.QueryDatabaseLimited(cntx, new SignalRMessageSet(), qexpr, config.MaxBacklogMessages).ToArray();

            if (msgs.Length > 0)
            {
                host.LastMsgId         = msgs[0].ID;
                LastMessageId          = (ulong)host.LastMsgId;
                IsLastMessageIdChanged = true;
                foreach (var e in from d in msgs orderby d.ID ascending select d)
                {
                    OnReceived(0, (ulong)e.ID, ScaleoutMessage.FromBytes(e.MesssageData));
                }
            }
        }
        void FromBytesToBytesProducesCorrectValues()
        {
            var message         = new Message("source", "key", "value");
            var message2        = new Message("string", "more", "str");
            var message3        = new Message("s", "l", "n");
            var scaleoutMessage = new ScaleoutMessage(new List <Message>()
            {
                message, message2, message3
            });

            var bytes = scaleoutMessage.ToBytes();
            var msg   = ScaleoutMessage.FromBytes(bytes);

            Assert.True(scaleoutMessage.Messages.Count == 3);
            Assert.True(scaleoutMessage.Messages[0].Source == msg.Messages[0].Source, "Source is not the same");
            Assert.True(scaleoutMessage.Messages[0].Key == msg.Messages[0].Key, "Key is not the same");
            Assert.True(scaleoutMessage.Messages[0].GetString() == msg.Messages[0].GetString(), "Value is not the same");
        }
        protected override Task Send(int streamIndex, IList <Message> messages)
        {
            return(Task.Run(() =>
            {
                var scaleoutMsg = new ScaleoutMessage(messages);

                var msg = new RmqMessage
                {
                    StreamIndex = streamIndex,
                    Id = 0,
                    Body = scaleoutMsg.ToBytes()
                };

                var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(msg));

                model.BasicPublish(this.configuration.ExchangeName, "", true, new BasicProperties(), body);
            }));
        }
        public static ScaleoutMessage FromBrokeredMessage(BrokeredMessage brokeredMessage)
        {
            if (brokeredMessage == null)
            {
                throw new ArgumentNullException("brokeredMessage");
            }

            var stream = brokeredMessage.GetBody <Stream>();

            using (var ms = new MemoryStream())
            {
                stream.CopyTo(ms);

                var message = ScaleoutMessage.FromBytes(ms.ToArray());

                return(message);
            }
        }
Esempio n. 26
0
        private void OnMessage(int topicIndex, IEnumerable <BrokeredMessage> messages)
        {
            if (!messages.Any())
            {
                // Force the topic to re-open if it was ever closed even if we didn't get any messages
                Open(topicIndex);
            }

            foreach (var message in messages)
            {
                using (message)
                {
                    ScaleoutMessage scaleoutMessage = ServiceBusMessage.FromBrokeredMessage(message);

                    OnReceived(topicIndex, (ulong)message.EnqueuedSequenceNumber, scaleoutMessage);
                }
            }
        }
Esempio n. 27
0
        public void MinMappingIdMovesWhenOverflow()
        {
            var store = new ScaleoutStore(5);

            int id = 0;

            for (int i = 0; i < store.FragmentSize + 1; i++)
            {
                for (int j = 0; j < store.FragmentCount; j++)
                {
                    var message = new ScaleoutMessage();
                    store.Add(new ScaleoutMapping((ulong)id, message));
                    id++;
                }
            }

            Assert.Equal((ulong)store.FragmentSize - 1, store.MinMappingId);
        }
Esempio n. 28
0
        private void OnReceived_P(byte[] data)
        {
            BinaryFormatter ser    = new BinaryFormatter();
            Packet          packet = null;

            using (MemoryStream ms = new MemoryStream())
            {
                ms.Write(data, 0, data.Length);
                ms.Seek(0, SeekOrigin.Begin);
                packet = ser.Deserialize(ms) as Packet;
            }


            var message = ScaleoutMessage.FromBytes(packet.Data);
            var args    = new OnReceivedArgs();

            args.Id      = packet.Id;
            args.Message = message;
            OnReceived(this, args);
        }
Esempio n. 29
0
        public static byte[] ToBytes(IList <Message> messages)
        {
            if (messages == null)
            {
                throw new ArgumentNullException("messages");
            }

            using (var ms = new MemoryStream())
            {
                var binaryWriter = new BinaryWriter(ms);

                var scaleoutMessage = new ScaleoutMessage(messages);
                var buffer          = scaleoutMessage.ToBytes();

                binaryWriter.Write(buffer.Length);
                binaryWriter.Write(buffer);

                return(ms.ToArray());
            }
        }
 private ScaleoutMessage GetJsonMessage(dynamic msg, out ulong msgId)
 {
     msgId = 0;
     if ((string)msg["status"] == "added")
     {
         DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(SignalRMessage));
         byte[]       bf   = Encoding.UTF8.GetBytes((string)msg["data"]);
         MemoryStream strm = new MemoryStream(bf);
         strm.Position = 0;
         var e = ser.ReadObject(strm) as SignalRMessage;
         if (e.ApplicationID == config.App.ID)
         {
             msgId = (ulong)e.ID;
             return(ScaleoutMessage.FromBytes(e.MesssageData));
         }
         else
         {
             return(null);
         }
     }
     return(null);
 }