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 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 Send(RawMessage message)
{
if (_closed)
{
return;
}
var length = message.Length;
if (length <= 0)
{
throw new ArgumentException("The message length must be greater than zero.");
}
if (length > _maxMessageSize)
{
throw new ArgumentException($"The message length is greater than {_maxMessageSize}");
}
_logger.Debug($"Multicast publisher reader enqueuing message {message.AsTextMessage()}");
_messageQueue.Enqueue(message);
}
public void TestCopyBytesTo()
{
var buffer = new MemoryStream(1000);
var text = "JOIN\nid=1 nm=node1 op=localhost:35745 app=localhost:35746";
var node1 = Node.With(Id.Of(1), Name.Of("node1"), Host.Of("localhost"), 35745, 35746);
var bytes = Converters.TextToBytes(text);
buffer.Write(bytes, 0, bytes.Length);
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(text, message.AsTextMessage());
buffer.Clear();
message.CopyBytesTo(buffer); // copyBytesTo
var convertedText = buffer.ToArray().BytesToText(RawMessageHeader.Bytes, (int)message.Length);
Assert.Equal(text, convertedText);
}
//=========================================
// 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 != null)
{
if (typedMessage.IsApp)
{
_attributesAgent.HandleInboundStreamMessage(addressType, message);
}
else
{
_localLiveNode.Handle(typedMessage);
}
}
else
{
Logger.Warn($"ClusterSnapshot received invalid raw message '{textMessage}'");
}
}
else if (addressType.IsApplication)
{
_clusterApplication.HandleApplicationMessage(message); // TODO
}
else
{
Logger.Warn($"ClusterSnapshot couldn't dispatch incoming message; unknown address type: {addressType} for message: {message.AsTextMessage()}");
}
}
public override void HandleApplicationMessage(RawMessage message, IApplicationOutboundStream?responder) =>
Logger.Debug($"APP: Received application message: {message.AsTextMessage()}");
private Dictionary <string, string> ParsePayload(RawMessage message)
{
var map = new Dictionary <string, string>();
var says = ApplicationSays.From(message.AsTextMessage());
map.Add(SourceNodeIdKey, says.Id.ValueString());
map.Add(SourceNodeNameKey, says.Name.Value);
var parsed = says.Payload.Split('\n');
map.Add(ClassOfMessageKey, parsed[0]);
switch (parsed[0])
{
case "ConfirmCreateAttributeSet":
map.Add(CorrelatingMessageIdKey, parsed[1]);
map.Add(TrackingIdKey, parsed[2]);
map.Add(MessageTypeKey, parsed[3]);
map.Add(AttributeSetNameKey, parsed[4]);
break;
case "ConfirmRemoveAttributeSet":
map.Add(CorrelatingMessageIdKey, parsed[1]);
map.Add(TrackingIdKey, parsed[2]);
map.Add(MessageTypeKey, parsed[3]);
map.Add(AttributeSetNameKey, parsed[4]);
break;
case "ConfirmAttribute":
map.Add(CorrelatingMessageIdKey, parsed[1]);
map.Add(TrackingIdKey, parsed[2]);
map.Add(MessageTypeKey, parsed[3]);
map.Add(AttributeSetNameKey, parsed[4]);
map.Add(AttributeNameKey, parsed[5]);
break;
case "CreateAttributeSet":
map.Add(TrackingIdKey, parsed[1]);
map.Add(MessageTypeKey, parsed[2]);
map.Add(AttributeSetNameKey, parsed[3]);
break;
case "RemoveAttributeSet":
map.Add(TrackingIdKey, parsed[1]);
map.Add(MessageTypeKey, parsed[2]);
map.Add(AttributeSetNameKey, parsed[3]);
break;
case "AddAttribute":
case "RemoveAttribute":
case "ReplaceAttribute":
map.Add(CorrelatingMessageIdKey, parsed[1]);
map.Add(TrackingIdKey, parsed[2]);
map.Add(MessageTypeKey, parsed[3]);
map.Add(AttributeSetNameKey, parsed[4]);
map.Add(AttributeNameKey, parsed[5]);
map.Add(AttributeTypeKey, parsed[6]);
map.Add(AttributeValueKey, parsed[7]);
break;
}
return(map);
}
public void Consume(RawMessage message)
{
_messages.Add(message.AsTextMessage());
_access.WriteUsing("count", 1);
}
public void Consume(RawMessage message)
{
_messages.Add(message.AsTextMessage());
UntilConsume.WriteUsing(_name, 1);
}
public override void HandleApplicationMessage(RawMessage message) =>
Logger.Debug($"APP: Received application message: {message.AsTextMessage()}");
private void RegisterService()
{
if (_directoryChannel != null && _registerService != null)
{
var expected = _registerService.TotalLength;
var actual = _directoryChannel.Write(_registerService, _buffer);
if (actual != expected)
{
Logger.Warn($"DIRECTORY CLIENT: Did not send full service registration message: {_registerService.AsTextMessage()}");
}
}
}
