public void BackplaneMessage_DeserializeInvalidBytes_WrongAction()
{
// arrange
var data = new byte[] { 0, 118, 50, 0, 4, 0, 0, 0, 1, 2, 3, 4, 255 };
Action act = () => BackplaneMessage.Deserialize(data).First();
act.Should().Throw <ArgumentException>().WithMessage("*invalid message type*");
}
public void BackplaneMessage_DeserializeInvalidBytes_NoAction()
{
// arrange
var data = new byte[] { 0, 118, 50, 0, 4, 0, 0, 0, 1, 2, 3, 4 };
Action act = () => BackplaneMessage.Deserialize(data).First();
act.Should().Throw <IndexOutOfRangeException>().WithMessage("*Cannot read byte,*");
}
public void BackplaneMessage_DeserializeInvalidBytes_InvalidString()
{
// arrange clear region with wrong region string
var data = new byte[] { 0, 118, 50, 0, 4, 0, 0, 0, 1, 2, 3, 4, 3, 10, 0, 0, 0, 42 };
Action act = () => BackplaneMessage.Deserialize(data).First();
act.ShouldThrow <IndexOutOfRangeException>().WithMessage("*Cannot read string,*");
}
public void BackplaneMessage_EqualsOtherClear()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var msg = BackplaneMessage.ForClear(owner);
var msg2 = BackplaneMessage.ForClear(owner);
// act
msg.Equals(msg2).Should().BeTrue();
}
public void BackplaneMessage_HashClear()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var msg = BackplaneMessage.ForClear(owner);
var msg2 = BackplaneMessage.ForClear(owner);
// act
msg.GetHashCode().Should().Be(msg2.GetHashCode());
}
public void BackplaneMessage_RefEquals()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var region = Guid.NewGuid().ToString();
var msg = BackplaneMessage.ForClearRegion(owner, region);
// act
msg.Equals(msg).Should().BeTrue();
}
public void BackplaneMessage_NotEqualOther()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var region = Guid.NewGuid().ToString();
var msg = BackplaneMessage.ForClearRegion(owner, region);
// act
msg.Equals("hello").Should().BeFalse();
}
public void BackplaneMessage_EqualsOtherChangedKey()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var key = Guid.NewGuid().ToString();
var msg = BackplaneMessage.ForChanged(owner, key, CacheItemChangedEventAction.Update);
var msg2 = BackplaneMessage.ForChanged(owner, key, CacheItemChangedEventAction.Update);
// act
msg.Equals(msg2).Should().BeTrue();
}
public void BackplaneMessage_EqualsOtherRemovedKey()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var key = Guid.NewGuid().ToString();
var msg = BackplaneMessage.ForRemoved(owner, key);
var msg2 = BackplaneMessage.ForRemoved(owner, key);
// act
msg.Equals(msg2).Should().BeTrue();
}
public void BackplaneMessage_HashClearRegion()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var region = Guid.NewGuid().ToString();
var msg = BackplaneMessage.ForClearRegion(owner, region);
var msg2 = BackplaneMessage.ForClearRegion(owner, region);
// act
msg.GetHashCode().Should().Be(msg2.GetHashCode());
}
public void BackplaneMessage_HashRemovedKey()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var key = Guid.NewGuid().ToString();
var msg = BackplaneMessage.ForRemoved(owner, key);
var msg2 = BackplaneMessage.ForRemoved(owner, key);
// act
msg.GetHashCode().Should().Be(msg2.GetHashCode());
}
public void BackplaneMessage_HashChangedKey()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var key = Guid.NewGuid().ToString();
var msg = BackplaneMessage.ForChanged(owner, key, CacheItemChangedEventAction.Update);
var msg2 = BackplaneMessage.ForChanged(owner, key, CacheItemChangedEventAction.Update);
// act
msg.GetHashCode().Should().Be(msg2.GetHashCode());
}
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);
}
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);
}
public static int GetEstimatedSize(BackplaneMessage msg, bool skipOwner)
{
// this is only a rough size multiplied by two for getting a roughly sized buffer
int size = 2; // two enums
if (!skipOwner)
{
size += msg.OwnerIdentity.Length * 4;
}
size += msg.Key?.Length * 4 ?? 0;
return(size * 2);
}
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);
}
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);
}
public void BackplaneMessage_Hashset_DifferentMessage()
{
// arrange
var owner = new byte[] { 1, 2, 3, 4 };
var key = Guid.NewGuid().ToString();
var region = Guid.NewGuid().ToString();
var msg = BackplaneMessage.ForChanged(owner, key, region, CacheItemChangedEventAction.Update);
var msg2 = BackplaneMessage.ForRemoved(owner, key, region);
var hashset = new HashSet <BackplaneMessage>();
// act
hashset.Add(msg);
hashset.Add(msg);
hashset.Count.Should().Be(1);
hashset.Add(msg2);
hashset.Add(msg2);
hashset.Count.Should().Be(2);
}
private void PublishMessage(BackplaneMessage message)
{
lock (_messageLock)
{
if (message.Action == BackplaneAction.Clear)
{
Interlocked.Exchange(ref _skippedMessages, _messages.Count);
_messages.Clear();
}
if (!_messages.Add(message))
{
Interlocked.Increment(ref _skippedMessages);
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("Skipped duplicate message: {0}.", message);
}
}
SendMessages(null);
}
}
static BackplaneMessageBenchmarkMultiple()
{
var messages = new List <BackplaneMessage>();
for (var i = 0; i < 10; i++)
{
messages.Add(BackplaneMessage.ForChanged(_ownderBytes, "somerandomkey" + i, CacheItemChangedEventAction.Update));
messages.Add(BackplaneMessage.ForChanged(_ownderBytes, "somerandomkey" + i, "withregion", CacheItemChangedEventAction.Add));
}
for (var i = 0; i < 10; i++)
{
messages.Add(BackplaneMessage.ForClear(_ownderBytes));
}
for (var i = 0; i < 10; i++)
{
messages.Add(BackplaneMessage.ForClearRegion(_ownderBytes, "somerandomregion" + i));
}
for (var i = 0; i < 10; i++)
{
messages.Add(BackplaneMessage.ForRemoved(_ownderBytes, "somerandomkey" + i, "withregion"));
}
_multiple = messages.ToArray();
}
private async Task PublishMessageAsync(BackplaneMessage message)
{
await _messageAsyncLock.WaitAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
try
{
if (message.Action == BackplaneAction.Clear)
{
Interlocked.Exchange(ref _skippedMessages, _messages.Count);
_messages.Clear();
}
if (_messages.Count > HardLimit)
{
if (!loggedLimitWarningOnce)
{
_logger.LogError("Exceeded hard limit of number of messages pooled to send through the backplane. Skipping new messages...");
loggedLimitWarningOnce = true;
}
}
else if (!_messages.Add(message))
{
Interlocked.Increment(ref _skippedMessages);
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("Skipped duplicate message: {0}.", message);
}
}
await SendMessagesAsync(null).ConfigureAwait(false);
}
finally
{
_messageAsyncLock.Release();
}
}
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();
}
}
/// <summary>
/// Notifies other cache clients about a removed cache key.
/// </summary>
/// <param name="key">The key.</param>
public override void NotifyRemove(string key)
{
this.PublishMessage(BackplaneMessage.ForRemoved(this.identifier, key));
}
/// <summary>
/// Notifies other cache clients about a cache clear region call.
/// </summary>
/// <param name="region">The region.</param>
public override void NotifyClearRegion(string region)
{
this.PublishMessage(BackplaneMessage.ForClearRegion(this.identifier, region));
}
/// <summary>
/// Notifies other cache clients about a cache clear.
/// </summary>
public override void NotifyClear()
{
this.PublishMessage(BackplaneMessage.ForClear(this.identifier));
}
/// <summary>
/// Notifies other cache clients about a changed cache key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="region">The region.</param>
public override void NotifyChange(string key, string region)
{
this.PublishMessage(BackplaneMessage.ForChanged(this.identifier, key, region));
}
/// <summary>
/// Notifies other cache clients about a changed cache key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="region">The region.</param>
/// <param name="action">The cache action.</param>
public override void NotifyChange(string key, string region, CacheItemChangedEventAction action)
{
PublishMessage(BackplaneMessage.ForChanged(_identifier, key, region, action));
}
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
},
/// <summary>
/// Notifies other cache clients about a removed cache key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="region">The region.</param>
public override void NotifyRemove(string key, string region)
{
PublishMessage(BackplaneMessage.ForRemoved(_identifier, key, region));
}
/// <summary>
/// Notifies other cache clients about a changed cache key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="action">The cache action.</param>
public override void NotifyChange(string key, CacheItemChangedEventAction action)
{
this.PublishMessage(BackplaneMessage.ForChanged(this.identifier, key, action));
}
