コード例 #1
0
        private void SendMessages()
        {
            if (_sending || _messages == null || _messages.Count == 0)
            {
                return;
            }

            Task.Factory.StartNew(
                async(obj) =>
            {
                if (_sending || _messages == null || _messages.Count == 0)
                {
                    return;
                }

                _sending = true;
#if !NET40
                await Task.Delay(10).ConfigureAwait(false);
#endif
                byte[] msgs = null;
                lock (_messageLock)
                {
                    if (_messages != null && _messages.Count > 0)
                    {
                        msgs = BackplaneMessage.Serialize(_messages.ToArray());

                        if (_logger.IsEnabled(LogLevel.Debug))
                        {
                            _logger.LogDebug("Backplane is sending {0} messages ({1} skipped).", _messages.Count, _skippedMessages);
                        }

                        Interlocked.Add(ref MessagesSent, _messages.Count);
                        _skippedMessages = 0;
                        _messages.Clear();
                    }

                    try
                    {
                        if (msgs != null)
                        {
                            Publish(msgs);
                            Interlocked.Increment(ref SentChunks);
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Error occurred sending backplane messages.");
                    }

                    _sending = false;
                }
#if NET40
            },
                this,
                _source.Token,
                TaskCreationOptions.None,
                TaskScheduler.Default)
            .ConfigureAwait(false);
#else
            },
コード例 #2
0
        public void BackplaneMessage_Mulitple_IgnoreOwner()
        {
            // arrange
            var owner = new byte[] { 1, 2, 3, 4 };

            var messages = CreateMany(owner);

            var serialized   = BackplaneMessage.Serialize(messages.ToArray());
            var deserialized = BackplaneMessage.Deserialize(serialized, skipOwner: owner).ToArray();

            messages.Count.Should().Be(41);
            deserialized.Length.Should().Be(0);
        }
コード例 #3
0
        public void BackplaneMessage_Mulitple()
        {
            // arrange
            var owner = new byte[] { 1, 2, 3, 4 };

            var messages = CreateMany(owner);

            var serialized   = BackplaneMessage.Serialize(messages.ToArray());
            var deserialized = BackplaneMessage.Deserialize(serialized).ToArray();

            messages.Count.Should().Be(41);
            deserialized.ShouldAllBeEquivalentTo(messages);
        }
コード例 #4
0
        public void BackplaneMessage_Clear()
        {
            // arrange
            var owner = new byte[] { 1, 2, 3, 4 };
            var msg   = BackplaneMessage.ForClear(owner);

            // act
            var serialized   = BackplaneMessage.Serialize(msg);
            var deserialized = BackplaneMessage.Deserialize(serialized).First();

            // assert
            deserialized.Key.Should().Be(null);
            deserialized.Region.Should().Be(null);
            deserialized.ChangeAction.Should().Be(CacheItemChangedEventAction.Invalid);
            deserialized.Action.Should().Be(BackplaneAction.Clear);
            deserialized.OwnerIdentity.ShouldBeEquivalentTo(owner);
            deserialized.ShouldBeEquivalentTo(msg);
        }
コード例 #5
0
        public void BackplaneMessage_ChangePutKey()
        {
            // arrange
            var owner = new byte[] { 1, 2, 3, 4 };
            var key   = Guid.NewGuid().ToString();
            var msg   = BackplaneMessage.ForChanged(owner, key, CacheItemChangedEventAction.Put);

            // act
            var serialized   = BackplaneMessage.Serialize(msg);
            var deserialized = BackplaneMessage.Deserialize(serialized).First();

            // assert
            deserialized.Key.Should().Be(key);
            deserialized.Region.Should().Be(null);
            deserialized.ChangeAction.Should().Be(CacheItemChangedEventAction.Put);
            deserialized.Action.Should().Be(BackplaneAction.Changed);
            deserialized.OwnerIdentity.ShouldBeEquivalentTo(owner);
            deserialized.ShouldBeEquivalentTo(msg);
        }
コード例 #6
0
        private void PublishMessage(BackplaneMessage message)
        {
            var msg = message.Serialize();

            lock (this.messageLock)
            {
                if (message.Action == BackplaneAction.Clear)
                {
                    Interlocked.Exchange(ref this.skippedMessages, this.messages.Count);
                    this.messages.Clear();
                }

                if (!this.messages.Add(msg))
                {
                    Interlocked.Increment(ref this.skippedMessages);
                    if (this.logger.IsEnabled(LogLevel.Trace))
                    {
                        this.logger.LogTrace("Skipped duplicate message: {0}.", msg);
                    }
                }

                this.SendMessages();
            }
        }
コード例 #7
0
        private void SendMessages(object state)
        {
            if (_sending || _messages == null || _messages.Count == 0)
            {
                return;
            }

            Task.Factory.StartNew(
                async(obj) =>
            {
                if (_sending || _messages == null || _messages.Count == 0)
                {
                    return;
                }

                _sending = true;
                if (state != null && state is bool boolState && boolState == true)
                {
                    _logger.LogInfo($"Backplane is sending {_messages.Count} messages triggered by timer.");
                }
#if !NET40
                await Task.Delay(10).ConfigureAwait(false);
#endif
                byte[] msgs = null;
                lock (_messageSendLock)
                {
                    if (_messages != null && _messages.Count > 0)
                    {
                        msgs = BackplaneMessage.Serialize(_messages.ToArray());

                        if (_logger.IsEnabled(LogLevel.Debug))
                        {
                            _logger.LogDebug("Backplane is sending {0} messages ({1} skipped).", _messages.Count, _skippedMessages);
                        }

                        try
                        {
                            if (msgs != null)
                            {
                                Publish(msgs);
                                Interlocked.Increment(ref SentChunks);
                                Interlocked.Add(ref MessagesSent, _messages.Count);
                                _skippedMessages = 0;

                                // clearing up only after successfully sending. Basically retrying...
                                _messages.Clear();

                                // reset log limmiter because we just send stuff
                                loggedLimitWarningOnce = false;
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.LogError(ex, "Error occurred sending backplane messages.");
                        }
                    }

                    _sending = false;
                }
#if NET40
            },
                this,
                _source.Token,
                TaskCreationOptions.None,
                TaskScheduler.Default)
            ;
#else
            },
コード例 #8
0
 public void SerializeClear()
 {
     var fullMessage = BackplaneMessage.Serialize(_dataSingleClear);
 }
コード例 #9
0
 public void SerializeChangeRegion()
 {
     var fullMessage = BackplaneMessage.Serialize(_dataSingleChangeRegion);
 }
コード例 #10
0
 public void SerializeMany()
 {
     var bytes = BackplaneMessage.Serialize(_multiple);
 }
コード例 #11
0
 public void SerializeRemove()
 {
     var fullMessage = BackplaneMessage.Serialize(_dataSingleRemove);
 }
コード例 #12
0
        private async Task SendMessagesAsync(object state)
        {
            if (_sending || _messages == null || _messages.Count == 0)
            {
                return;
            }

            if (_sending || _messages == null || _messages.Count == 0)
            {
                return;
            }

            _sending = true;
            if (state != null && state is bool boolState && boolState == true)
            {
                _logger.LogInfo($"Backplane is sending {_messages.Count} messages triggered by timer.");
            }
#if !NET40
            await Task.Delay(10).ConfigureAwait(false);
#endif
            byte[] msgs = null;
            await _messageSendAsyncLock.WaitAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false);

            try
            {
                if (_messages != null && _messages.Count > 0)
                {
                    msgs = BackplaneMessage.Serialize(_messages.ToArray());

                    if (_logger.IsEnabled(LogLevel.Debug))
                    {
                        _logger.LogDebug("Backplane is sending {0} messages ({1} skipped).", _messages.Count, _skippedMessages);
                    }

                    try
                    {
                        if (msgs != null)
                        {
                            await PublishAsync(msgs).ConfigureAwait(false);

                            Interlocked.Increment(ref SentChunks);
                            Interlocked.Add(ref MessagesSent, _messages.Count);
                            _skippedMessages = 0;

                            // clearing up only after successfully sending. Basically retrying...
                            _messages.Clear();

                            // reset log limmiter because we just send stuff
                            loggedLimitWarningOnce = false;
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Error occurred sending backplane messages.");
                    }
                }

                _sending = false;
            }
            finally
            {
                _messageSendAsyncLock.Release();
            }
        }
コード例 #13
0
 private void PublishMessage(BackplaneMessage message)
 {
     byte[] serializedMessage = BackplaneMessage.Serialize(message);
     _publishSubscribe.Publish(_channelName, serializedMessage);
 }