//=========================================
// InboundStreamInterest (operations and application)
//=========================================
public void HandleInboundStreamMessage(AddressType addressType, RawMessage message)
{
if (IsStopped)
{
return;
}
if (addressType.IsOperational)
{
var textMessage = message.AsTextMessage();
var typedMessage = OperationalMessage.MessageFrom(textMessage);
if (typedMessage.IsApp)
{
_attributesAgent.HandleInboundStreamMessage(addressType, message);
}
else
{
_localLiveNode.Handle(typedMessage);
}
}
else if (addressType.IsApplication)
{
_clusterApplication.HandleApplicationMessage(message, _communicationsHub.ApplicationOutboundStream); // TODO
}
else
{
Logger.Warn($"ClusterSnapshot couldn't dispatch incoming message; unknown address type: {addressType} for message: {message.AsTextMessage()}");
}
}
public void TestCachedMessages()
{
var node1 = Node.With(Id.Of(2), Name.Of("node2"), Host.Of("localhost"), 37373, 37374);
var cache = new OperationalMessageCache(node1);
var elect = cache.CachedRawMessage(OperationalMessage.ELECT);
Assert.True(OperationalMessage.MessageFrom(elect.AsTextMessage()).IsElect);
var join = cache.CachedRawMessage(OperationalMessage.JOIN);
Assert.True(OperationalMessage.MessageFrom(join.AsTextMessage()).IsJoin);
var leader = cache.CachedRawMessage(OperationalMessage.LEADER);
Assert.True(OperationalMessage.MessageFrom(leader.AsTextMessage()).IsLeader);
var leave = cache.CachedRawMessage(OperationalMessage.LEAVE);
Assert.True(OperationalMessage.MessageFrom(leave.AsTextMessage()).IsLeave);
var ping = cache.CachedRawMessage(OperationalMessage.PING);
Assert.True(OperationalMessage.MessageFrom(ping.AsTextMessage()).IsPing);
var pulse = cache.CachedRawMessage(OperationalMessage.PULSE);
Assert.True(OperationalMessage.MessageFrom(pulse.AsTextMessage()).IsPulse);
var vote = cache.CachedRawMessage(OperationalMessage.VOTE);
Assert.True(OperationalMessage.MessageFrom(vote.AsTextMessage()).IsVote);
}
private void SingleChannelMessageAssertions()
{
var channel1 = _channelProvider.ChannelFor(_localNodeId);
var message1 = OperationalMessage.MessageFrom(Mock(channel1).Writes[0]);
Assert.Single(Mock(channel1).Writes);
Assert.Equal(_localNodeId, message1.Id);
}
public void TestLeave()
{
_outboundStream.Actor.Leave();
foreach (var channel in AllTargetChannels())
{
var message = OperationalMessage.MessageFrom(Mock(channel).Writes[0]);
Assert.True(message.IsLeave);
Assert.Equal(_localNodeId, message.Id);
}
}
public void TestElect()
{
_outboundStream.Actor.Elect(Config.AllGreaterNodes(_localNodeId));
foreach (var channel in AllTargetChannels())
{
var message = OperationalMessage.MessageFrom(Mock(channel).Writes[0]);
Assert.True(message.IsElect);
Assert.Equal(_localNodeId, message.Id);
}
}
public void TestDirectory()
{
_outboundStream.Actor.Directory(new HashSet <Node>(Config.AllNodes));
foreach (var channel in AllTargetChannels())
{
var message = OperationalMessage.MessageFrom(Mock(channel).Writes[0]);
Assert.True(message.IsDirectory);
Assert.Equal(_localNodeId, message.Id);
}
}
public void TestLeaderOfId()
{
var targetId = Id.Of(3);
_outboundStream.Actor.Leader(targetId);
var channel = _channelProvider.ChannelFor(targetId);
var message = OperationalMessage.MessageFrom(Mock(channel).Writes[0]);
Assert.True(message.IsLeader);
Assert.Equal(_localNodeId, message.Id);
}
public void TestOneInboundMessage()
{
Join();
_builder.PrepareContent().Sync();
Assert.True(_builder.IsCurrentMessageComplete());
var message = _builder.CurrentRawMessage();
var text = message.AsTextMessage();
var typed = OperationalMessage.MessageFrom(text);
Assert.Equal(_join, typed);
}
public void TestSplit()
{
var targetNodeId = Id.Of(2);
var currentLeaderId = Id.Of(3);
_outboundStream.Actor.Split(targetNodeId, currentLeaderId);
var channel = _channelProvider.ChannelFor(targetNodeId);
var message = OperationalMessage.MessageFrom(Mock(channel).Writes[0]);
Assert.True(message.IsSplit);
Assert.Equal(currentLeaderId, message.Id);
}
public void TestParseJoin()
{
var join = OperationalMessage.MessageFrom(MessageFixtures.JoinAsText());
Assert.True(join.IsJoin);
var expectedNode =
new Node(
Id.Of(1),
new Name("node1"),
Address.From("localhost:37371", AddressType.Op),
Address.From("localhost:37372", AddressType.App));
var expectedJoin = new Join(expectedNode);
Assert.Equal(expectedNode, ((Join)join).Node);
Assert.Equal(expectedJoin, join);
}
private void MultiChannelMessageAssertions(int messageCount)
{
var allOtherNodes = Config.AllOtherNodes(_localNodeId).ToList();
var channel2 = _channelProvider.ChannelFor(allOtherNodes[0].Id);
var channel3 = _channelProvider.ChannelFor(allOtherNodes[1].Id);
Assert.Equal(messageCount, Mock(channel2).Writes.Count);
Assert.Equal(messageCount, Mock(channel3).Writes.Count);
var message2 = OperationalMessage.MessageFrom(Mock(channel2).Writes[0]);
var message3 = OperationalMessage.MessageFrom(Mock(channel3).Writes[0]);
Assert.True(message2.IsApp);
Assert.True(message3.IsApp);
Assert.Equal(_localNodeId, message2.Id);
Assert.Equal(_localNodeId, message3.Id);
Assert.Equal(message2, message3);
}
public void TestParseElect()
{
var elect1 = OperationalMessage.MessageFrom(OperationalMessage.ELECT + "\n" + "id=1");
Assert.True(elect1.IsElect);
Assert.Equal(Id.Of(1), elect1.Id);
var expectedElec1 = new Elect(Id.Of(1));
Assert.Equal(expectedElec1, elect1);
var elect100 = OperationalMessage.MessageFrom(OperationalMessage.ELECT + "\n" + "id=100");
Assert.True(elect100.IsElect);
Assert.Equal(Id.Of(100), elect100.Id);
var expectedElec100 = new Elect(Id.Of(100));
Assert.Equal(expectedElec100, elect100);
}
public void TestParseVote()
{
var vote1 = OperationalMessage.MessageFrom(OperationalMessage.VOTE + "\n" + "id=1");
Assert.True(vote1.IsVote);
Assert.Equal(Id.Of(1), vote1.Id);
var expectedVote1 = new Vote(Id.Of(1));
Assert.Equal(expectedVote1, vote1);
var vote100 = OperationalMessage.MessageFrom(OperationalMessage.VOTE + "\n" + "id=100");
Assert.True(vote100.IsVote);
Assert.Equal(Id.Of(100), vote100.Id);
var expectedVote100 = new Vote(Id.Of(100));
Assert.Equal(expectedVote100, vote100);
}
public void TestParsePing()
{
var ping1 = OperationalMessage.MessageFrom(OperationalMessage.PING + "\n" + "id=1");
Assert.True(ping1.IsPing);
Assert.Equal(Id.Of(1), ping1.Id);
var expectedPing1 = new Ping(Id.Of(1));
Assert.Equal(expectedPing1, ping1);
var ping100 = OperationalMessage.MessageFrom(OperationalMessage.PING + "\n" + "id=100");
Assert.True(ping100.IsPing);
Assert.Equal(Id.Of(100), ping100.Id);
var expectedPing100 = new Ping(Id.Of(100));
Assert.Equal(expectedPing100, ping100);
}
public void TestParseLeave()
{
var leave1 = OperationalMessage.MessageFrom(MessageFixtures.LeaveAsText());
Assert.True(leave1.IsLeave);
Assert.Equal(Id.Of(1), leave1.Id);
var expectedLeave1 = new Leave(Id.Of(1));
Assert.Equal(expectedLeave1, leave1);
var leave100 = OperationalMessage.MessageFrom(OperationalMessage.LEAVE + "\n" + "id=100");
Assert.True(leave100.IsLeave);
Assert.Equal(Id.Of(100), leave100.Id);
var expectedLeave100 = new Leave(Id.Of(100));
Assert.Equal(expectedLeave100, leave100);
}
public void TestParsePulse()
{
var pulse1 = OperationalMessage.MessageFrom(OperationalMessage.PULSE + "\n" + "id=1");
Assert.True(pulse1.IsPulse);
Assert.Equal(Id.Of(1), pulse1.Id);
var expectedPulse1 = new Pulse(Id.Of(1));
Assert.Equal(expectedPulse1, pulse1);
var pulse100 = OperationalMessage.MessageFrom(OperationalMessage.PULSE + "\n" + "id=100");
Assert.True(pulse100.IsPulse);
Assert.Equal(Id.Of(100), pulse100.Id);
var expectedPulse100 = new Pulse(Id.Of(100));
Assert.Equal(expectedPulse100, pulse100);
}
public void TestKnownSizeWithAppend()
{
var buffer = new MemoryStream(1000);
var node1 = NextNodeWith(1);
var join = new Join(node1);
MessageConverters.MessageToBytes(join, buffer);
buffer.Flip();
var messageSize = buffer.Length;
var message = new RawMessage(messageSize); // known size
message.Header(RawMessageHeader.From(node1.Id.Value, 0, messageSize));
message.Append(buffer.ToArray(), 0, messageSize);
Assert.Equal(node1.Id.Value, message.Header().NodeId);
Assert.Equal(messageSize, message.Header().Length);
Assert.Equal(join, OperationalMessage.MessageFrom(message.AsTextMessage()));
}
public void TestParseDirectory()
{
var dir = OperationalMessage.MessageFrom(MessageFixtures.DirectoryAsText(1, 2, 3));
Assert.True(dir.IsDirectory);
Assert.Equal(Id.Of(MessageFixtures.DefaultNodeId), dir.Id);
Assert.Equal(new Name(MessageFixtures.DefaultNodeName), ((Directory)dir).Name);
int index = 1;
foreach (var node in ((Directory)dir).Nodes)
{
Assert.Equal(Id.Of(index), node.Id);
Assert.Equal(new Name("node" + index), node.Name);
Assert.Equal(Address.From(MessageFixtures.OpAddresses[index], AddressType.Op), node.OperationalAddress);
Assert.Equal(Address.From(MessageFixtures.AppAddresses[index], AddressType.App), node.ApplicationAddress);
++index;
}
var nodeEntries = new HashSet <Node>();
nodeEntries.Add(new Node(
Id.Of(1),
new Name("node1"),
Address.From(MessageFixtures.OpAddresses[1], AddressType.Op),
Address.From(MessageFixtures.AppAddresses[1], AddressType.App)));
nodeEntries.Add(new Node(
Id.Of(2),
new Name("node2"),
Address.From(MessageFixtures.OpAddresses[2], AddressType.Op),
Address.From(MessageFixtures.AppAddresses[2], AddressType.App)));
nodeEntries.Add(new Node(
Id.Of(3),
new Name("node3"),
Address.From(MessageFixtures.OpAddresses[3], AddressType.Op),
Address.From(MessageFixtures.AppAddresses[3], AddressType.App)));
var expectedDir = new Directory(Id.Of(MessageFixtures.DefaultNodeId), new Name(MessageFixtures.DefaultNodeName), nodeEntries);
Assert.Equal(expectedDir, dir);
}
public void TestFromBytesWithLengthAndRequiredMessageLength()
{
var buffer = new MemoryStream(1000);
var node1 = NextNodeWith(1);
var join = new Join(node1);
MessageConverters.MessageToBytes(join, buffer);
buffer.Flip();
var messageSize = buffer.Length;
var messageBytes = new byte[messageSize];
Array.Copy(buffer.ToArray(), 0, messageBytes, 0, messageSize);
var message = new RawMessage(messageBytes);
message.Header(RawMessageHeader.From(node1.Id.Value, 0, message.Length));
Assert.Equal(node1.Id.Value, message.Header().NodeId);
Assert.Equal(message.Length, message.Header().Length);
Assert.Equal(message.Length, message.RequiredMessageLength);
Assert.Equal(join, OperationalMessage.MessageFrom(message.AsTextMessage()));
}
public void TestCopyBytesTo()
{
var buffer = new MemoryStream(1000);
var node1 = NextNodeWith(1);
var join = new Join(node1);
MessageConverters.MessageToBytes(join, buffer);
buffer.Flip();
var messageSize = buffer.Length;
var messageBytes = new byte[messageSize];
Array.Copy(buffer.ToArray(), 0, messageBytes, 0, messageSize);
var message = new RawMessage(messageBytes);
message.Header(RawMessageHeader.From(node1.Id.Value, 0, message.Length));
buffer.Clear();
message.CopyBytesTo(buffer); // copyBytesTo
var text = buffer.ToArray().BytesToText(RawMessageHeader.Bytes, (int)message.Length);
Assert.True(OperationalMessage.MessageFrom(text).IsJoin);
}
public void TestTwoInboundMessages()
{
Join();
Leader();
_builder.PrepareContent().Sync();
Assert.True(_builder.IsCurrentMessageComplete());
Assert.True(_builder.HasContent);
var inboundJoin = _builder.CurrentRawMessage();
var joinText = inboundJoin.AsTextMessage();
var joinFromText = OperationalMessage.MessageFrom(joinText);
Assert.Equal(_join, joinFromText);
_builder.PrepareForNextMessage();
Assert.True(_builder.HasContent);
_builder.Sync();
var inboundLeader = _builder.CurrentRawMessage();
var leaderText = inboundLeader.AsTextMessage();
var leaderFromText = OperationalMessage.MessageFrom(leaderText);
Assert.Equal(_leader, leaderFromText);
}