/// <summary>
/// Asynchronously sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
if (message.OriginatingSystem == null)
{
message.OriginatingSystem = "Kafka";
}
var kafkaMessage = new Message <string, byte[]> {
Value = message.BinaryPayload
};
if (message.Headers.TryGetValue(KafkaKeyHeader, out object objValue) &&
Serialize(objValue) is string kafkaKey)
{
kafkaMessage.Key = kafkaKey;
message.Headers.Remove(KafkaKeyHeader);
}
if (message.Headers.Count > 0)
{
kafkaMessage.Headers = kafkaMessage.Headers ?? new Headers();
foreach (var header in message.Headers)
{
if (Encode(Serialize(header.Value)) is byte[] headerValue)
{
kafkaMessage.Headers.Add(header.Key, headerValue);
}
}
}
return(_producer.Value.ProduceAsync(Topic, kafkaMessage));
}
private void StartupSequence()
{
var ingoingMessageInformation = _harakaDb.TryGetObjects <ExtendedPacketInformation>(Setup.IngoingMessagesCS);
if (ingoingMessageInformation.Any())
{
foreach (var extMsg in ingoingMessageInformation)
{
OnMessageReceived(extMsg);
}
}
var outMessageInformation = _harakaDb.TryGetObjects <ExtendedPacketInformation>(Setup.OutgoingMessagesCS);
if (!outMessageInformation.Any())
{
return;
}
{
foreach (var extendedMsg in outMessageInformation)
{
var sendMsg = new SenderMessage
{
Body = MessagePackSerializer.Serialize(extendedMsg.Packet),
Type = extendedMsg.UdpMessageType
};
_sender.SendMsg(sendMsg, extendedMsg.Ip, extendedMsg.Port);
}
}
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.OriginatingSystem is null)
{
message.OriginatingSystem = "NamedPipe";
}
var namedPipeMessage = new NamedPipeMessage
{
StringValue = message.StringPayload,
Headers = new Dictionary <string, string>()
};
foreach (var header in message.Headers)
{
namedPipeMessage.Headers.Add(header.Key, header.Value.ToString() !);
}
var messageString = NamedPipeMessageSerializer.SerializeToString(namedPipeMessage);
_workItems.Add(messageString, cancellationToken);
return(Task.CompletedTask);
}
public void Send(PeerHash peer, SenderMessage message)
{
NetworkConnection connection = context.Collection.Find(peer);
SenderDefinition definition = context.Configuration.Definition;
if (connection == null)
{
context.Hooks.CallMessageIgnored(peer, message.Type, message);
return;
}
string type = message.Type;
byte? identifier = definition?.GetIdentifier(type);
if (identifier != null)
{
connection.Send(message.Apply(identifier.Value));
context.Hooks.CallMessageSent(peer, type, message);
}
else
{
context.Hooks.CallMessageIgnored(peer, type, message);
message.Release();
}
}
/// <summary>
/// Asynchronously sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
if (message.OriginatingSystem == null)
message.OriginatingSystem = "SQS";
var sendMessageRequest = new SendMessageRequest(_queueUrl, message.StringPayload);
if (message.Headers.TryGetValue("SQS.MessageGroupId", out var value) && value != null)
{
sendMessageRequest.MessageGroupId = value.ToString();
message.Headers.Remove("SQS.MessageGroupId");
}
else if (_messageGroupId != null)
sendMessageRequest.MessageGroupId = _messageGroupId;
if (message.Headers.TryGetValue("SQS.MessageDeduplicationId", out value) && value != null)
{
sendMessageRequest.MessageDeduplicationId = value.ToString();
message.Headers.Remove("SQS.MessageDeduplicationId");
}
if (message.Headers.TryGetValue("SQS.DelaySeconds", out value) && value != null)
{
sendMessageRequest.DelaySeconds = (int)value;
message.Headers.Remove("SQS.DelaySeconds");
}
foreach (var header in message.Headers)
{
sendMessageRequest.MessageAttributes[header.Key] =
new MessageAttributeValue { StringValue = header.Value.ToString(), DataType = "String" };
}
return _sqs.SendMessageAsync(sendMessageRequest, cancellationToken);
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
if (message.OriginatingSystem == null)
{
message.OriginatingSystem = "NamedPipe";
}
var namedPipeMessage = new NamedPipeMessage
{
StringValue = message.StringPayload,
Headers = new Dictionary <string, string>()
};
foreach (var header in message.Headers)
{
namedPipeMessage.Headers.Add(header.Key, header.Value.ToString());
}
var messageString = _serializer.SerializeToString(namedPipeMessage);
var completion = new TaskCompletionSource <bool>();
_workItems.Add(new WorkItem {
Message = messageString, Completion = completion, CancellationToken = cancellationToken
});
return(completion.Task);
}
/// <summary>
/// Asynchronously sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">
/// The token to monitor for cancellation requests.
/// </param>
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.OriginatingSystem is null)
{
message.OriginatingSystem = "RabbitMQ";
}
var properties = Channel.CreateBasicProperties();
properties.Headers = message.Headers;
if (Persistent)
{
properties.Persistent = true;
}
// TODO: Should we set any properties (e.g. ContentType, ContentEncoding) on properties here?
// TODO: Should we support having a different routing key per message (possibly embedded in Headers)?
Channel.BasicPublish(Exchange, GetRoutingKey(message), properties, message.BinaryPayload);
return(Task.CompletedTask);
}
public void ImplicitConversionOperatorHappyPath2()
{
CloudEvent cloudEvent = null;
SenderMessage senderMessage = cloudEvent;
senderMessage.Should().BeNull();
}
public void SendMsg(SenderMessage msg, string ip, int port)
{
var broadcast = IPAddress.Parse(ip);
var sendbuf = MessagePackSerializer.Serialize(msg);
var ep = new IPEndPoint(broadcast, port);
_socket.SendTo(sendbuf, ep);
}
public void Bind(CloudEvent fromCloudEvent, SenderMessage toSenderMessage)
{
if (fromCloudEvent.GetPartitionKey() is string kafkaKey)
{
toSenderMessage.Headers.Remove(GetHeaderName(PartitionKeyAttribute));
toSenderMessage.Headers[KafkaKeyHeader] = kafkaKey;
}
}
public void SendUdpMessage(UdpMessage msg, UdpMessageType type, string ip, int port)
{
var sendMsg = new SenderMessage
{
Body = MessagePackSerializer.Serialize(msg),
Type = type
};
_sender.SendMsg(sendMsg, ip, port);
}
public void ReSend(Guid messageId)
{
var extendedPacketInformation = _harakaDb.TryGetObjects <ExtendedPacketInformation>(Setup.OutgoingMessagesCS).Find(x => x.Packet.Id == messageId);
var sendMsg = new SenderMessage
{
Body = MessagePackSerializer.Serialize(extendedPacketInformation.Packet),
Type = extendedPacketInformation.UdpMessageType
};
_sender.SendMsg(sendMsg, extendedPacketInformation.Ip, extendedPacketInformation.Port);
}
public void ReSend(string clientId, int seqNo)
{
var extendedPacketInformation = _harakaDb.TryGetObjects <ExtendedPacketInformation>(Setup.OutgoingMessagesCS).Find(x => x.SenderClient == clientId && x.Packet.SeqNo == seqNo);
var sendMsg = new SenderMessage
{
Body = MessagePackSerializer.Serialize(extendedPacketInformation.Packet),
Type = extendedPacketInformation.UdpMessageType
};
_sender.SendMsg(sendMsg, extendedPacketInformation.Ip, extendedPacketInformation.Port);
}
/// <summary>
/// Asynchronously sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public async Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.OriginatingSystem is null)
{
message.OriginatingSystem = "HTTP";
}
var headers = new Dictionary <string, object>(message.Headers);
var url = GetUrl(headers);
using var request = new HttpRequestMessage(Method, url)
{
Content = new ByteArrayContent(message.BinaryPayload)
};
foreach (var defaultContentHeader in _defaultContentHeaders)
{
if (!message.Headers.ContainsKey(defaultContentHeader.Key))
{
request.Content.Headers.Add(defaultContentHeader.Key, defaultContentHeader.Value);
}
}
foreach (var defaultRequestHeader in _defaultRequestHeaders)
{
if (!message.Headers.ContainsKey(defaultRequestHeader.Key))
{
request.Headers.Add(defaultRequestHeader.Key, defaultRequestHeader.Value);
}
}
foreach (var header in message.Headers)
{
if (IsContentHeader(header.Key))
{
AddHeader(request.Content.Headers, header.Key, header.Value?.ToString() !);
}
else
{
AddHeader(request.Headers, header.Key, header.Value?.ToString() !);
}
}
var response = await _client.SendAsync(request, cancellationToken).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
}
public void CompressedStringSenderMessageToStringReceiverMessageAsStringPayload()
{
var originalPayload = GetStringExample();
var senderMessage = new SenderMessage(originalPayload, compress: true);
var receiverMessage = new TestReceiverMessage(senderMessage.StringPayload, senderMessage.Headers);
receiverMessage.StringPayload.Should().Be(originalPayload);
var senderCopy = new SenderMessage(receiverMessage);
senderCopy.StringPayload.Should().Be(senderMessage.StringPayload);
senderCopy.BinaryPayload.Should().BeEquivalentTo(senderMessage.BinaryPayload);
}
public void SetText(SenderMessage msg)
{
if (tb_all.InvokeRequired)
{
TextReceiveCallback d = new TextReceiveCallback(SetText);
this.Invoke(d, new object[] { msg });
}
else
{
this.tb_all.Text += string.Format("{0} : {1} {2}", msg.name ,msg.text, Environment.NewLine);
}
}
public void UncompressedStringSenderMessageToBinaryReceiverMessageAsBinaryPayload()
{
var originalPayload = GetStringExample();
var senderMessage = new SenderMessage(originalPayload);
var receiverMessage = new TestReceiverMessage(senderMessage.BinaryPayload, senderMessage.Headers);
receiverMessage.BinaryPayload.Should().BeEquivalentTo(Encoding.UTF8.GetBytes(originalPayload));
var senderCopy = new SenderMessage(receiverMessage);
senderCopy.StringPayload.Should().Be(senderMessage.StringPayload);
senderCopy.BinaryPayload.Should().BeEquivalentTo(senderMessage.BinaryPayload);
}
public void UncompressedBinarySenderMessageToBinaryReceiverMessageAsStringPayload()
{
var originalPayload = GetBinaryExample();
var senderMessage = new SenderMessage(originalPayload);
var receiverMessage = new TestReceiverMessage(senderMessage.BinaryPayload, senderMessage.Headers);
receiverMessage.StringPayload.Should().Be(Convert.ToBase64String(originalPayload));
var senderCopy = new SenderMessage(receiverMessage);
senderCopy.StringPayload.Should().Be(senderMessage.StringPayload);
senderCopy.BinaryPayload.Should().BeEquivalentTo(senderMessage.BinaryPayload);
}
public void SetText(SenderMessage msg)
{
if (tb_all.InvokeRequired)
{
TextReceiveCallback d = new TextReceiveCallback(SetText);
this.Invoke(d, new object[] { msg });
}
else
{
this.tb_all.Text += string.Format("{0} : {1} {2}", msg.name, msg.text, Environment.NewLine);
}
}
public void ValidateMethodHappyPath2()
{
var senderMessage = new SenderMessage("Hello, world!");
senderMessage.Headers.Add(CloudEvent.SpecVersionAttribute, "1.0");
senderMessage.Headers.Add(CloudEvent.IdAttribute, "MyId");
senderMessage.Headers.Add(CloudEvent.SourceAttribute, "http://MySource");
senderMessage.Headers.Add(CloudEvent.TypeAttribute, "MyType");
senderMessage.Headers.Add(CloudEvent.TimeAttribute, DateTime.UtcNow.ToString("O"));
Action act = () => TestCloudEvent.Validate(senderMessage);
act.Should().NotThrow();
}
private byte[] BuildMessagePayload(SenderMessage message)
{
if (!ShouldIncludeSchemaId)
{
return(message.BinaryPayload);
}
using var memoryStream = new MemoryStream();
using var binaryWriter = new BinaryWriter(memoryStream);
memoryStream.WriteByte(SchemaIdLeadingByte);
binaryWriter.Write(IPAddress.HostToNetworkOrder(SchemaId));
binaryWriter.Write(message.BinaryPayload);
return(memoryStream.ToArray());
}
public void ValidateStaticMethodSadPath1()
{
// Missing Sequence
var senderMessage = new SenderMessage("Hello, world!");
senderMessage.Headers.Add(CloudEvent.IdAttribute, "MyId");
senderMessage.Headers.Add(CloudEvent.SourceAttribute, new Uri("http://MySource"));
senderMessage.Headers.Add(CloudEvent.TypeAttribute, "MyType");
senderMessage.Headers.Add(CloudEvent.TimeAttribute, DateTime.UtcNow);
Action act = () => SequentialEvent.Validate(senderMessage);
act.Should().ThrowExactly <CloudEventValidationException>();
}
public void ValidateMethodSadPath4()
{
// Missing Source
var senderMessage = new SenderMessage("Hello, world!");
senderMessage.Headers.Add(CloudEvent.SpecVersionAttribute, "1.0");
senderMessage.Headers.Add(CloudEvent.IdAttribute, "MyId");
senderMessage.Headers.Add(CloudEvent.TypeAttribute, "MyType");
senderMessage.Headers.Add(CloudEvent.TimeAttribute, DateTime.UtcNow);
Action act = () => TestCloudEvent.Validate(senderMessage);
act.Should().ThrowExactly <CloudEventValidationException>();
}
/// <summary>
/// Sets the Key of the Kafka message, as stored in the <see cref="KafkaKeyHeader"/> header
/// of the <see cref="SenderMessage"/>.
/// </summary>
/// <param name="senderMessage">The <see cref="SenderMessage"/>.</param>
/// <param name="kafkaKey">The Key of the Kafka message. If <see langword="null"/>, the
/// Kafka Key header of the message is removed.
/// event is removed.</param>
public static void SetKafkaKey(this SenderMessage senderMessage, string kafkaKey)
{
if (senderMessage is null)
{
throw new ArgumentNullException(nameof(senderMessage));
}
if (!string.IsNullOrEmpty(kafkaKey))
{
senderMessage.Headers[KafkaKeyHeader] = kafkaKey;
}
else
{
senderMessage.Headers.Remove(KafkaKeyHeader);
}
}
public void ValidateMethodSadPath2()
{
// Invalid SpecVersion
var senderMessage = new SenderMessage("Hello, world!");
senderMessage.Headers.Add(CloudEvent.SpecVersionAttribute, "0.0");
senderMessage.Headers.Add(CloudEvent.SourceAttribute, new Uri("http://MySource"));
senderMessage.Headers.Add(CloudEvent.IdAttribute, "MyId");
senderMessage.Headers.Add(CloudEvent.TypeAttribute, "MyType");
senderMessage.Headers.Add(CloudEvent.TimeAttribute, DateTime.UtcNow);
Action act = () => CloudEvent.Validate(senderMessage);
act.Should().ThrowExactly <CloudEventValidationException>();
}
public void ValidateStaticMethodHappyPath1()
{
var senderMessage = new SenderMessage("Hello, world!");
senderMessage.Headers.Add(SequentialEvent.SequenceAttribute, "1");
senderMessage.Headers.Add(CloudEvent.SpecVersionAttribute, "1.0");
senderMessage.Headers.Add(CloudEvent.IdAttribute, "MyId");
senderMessage.Headers.Add(CloudEvent.SourceAttribute, new Uri("http://MySource"));
senderMessage.Headers.Add(CloudEvent.TypeAttribute, "MyType");
senderMessage.Headers.Add(CloudEvent.TimeAttribute, DateTime.UtcNow);
Action act = () => SequentialEvent.Validate(senderMessage);
act.Should().NotThrow();
}
/// <summary>
/// Asynchronously sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
var producer = _producer.Value;
if (message.OriginatingSystem == null)
{
message.OriginatingSystem = "Kafka";
}
var kafkaMessage = new Message <Null, string> {
Value = message.StringPayload
};
if (message.Headers.Count > 0)
{
kafkaMessage.Headers = kafkaMessage.Headers ?? new Headers();
foreach (var header in message.Headers)
{
kafkaMessage.Headers.Add(header.Key, Encoding.UTF8.GetBytes(header.Value.ToString()));
}
}
var taskSource = new TaskCompletionSource <int>();
void OnDelivery(DeliveryReport <Null, string> deliveryReport)
{
if (deliveryReport?.Error.IsError == true)
{
taskSource.SetException(new KafkaException(deliveryReport.Error));
}
else
{
taskSource.SetResult(0);
}
}
try
{
producer.BeginProduce(Topic, kafkaMessage, OnDelivery);
}
catch (Exception ex)
{
taskSource.SetException(ex);
}
return(taskSource.Task);
}
public void Send(ExtendedPacketInformation msg)
{
var sendMsg = new SenderMessage
{
Body = MessagePackSerializer.Serialize(msg.Packet),
Type = msg.UdpMessageType
};
lock (_harakaDb.GetLock(Setup.OutgoingMessagesCS))
{
var messages = _harakaDb.GetObjects <ExtendedPacketInformation>(Setup.OutgoingMessagesCS);
messages.Add(msg);
_harakaDb.StoreObject(Setup.OutgoingMessagesCS, messages);
}
_sender.SendMsg(sendMsg, msg.Ip, msg.Port);
}
/// <summary>
/// Asynchronously sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.OriginatingSystem is null)
{
message.OriginatingSystem = "SQS";
}
var sendMessageRequest = new SendMessageRequest(QueueUrl.OriginalString, message.StringPayload);
if (message.Headers.TryGetValue("SQS.MessageGroupId", out var value) && value is not null)
{
sendMessageRequest.MessageGroupId = value.ToString();
message.Headers.Remove("SQS.MessageGroupId");
}
else if (MessageGroupId is not null)
{
sendMessageRequest.MessageGroupId = MessageGroupId;
}
if (message.Headers.TryGetValue("SQS.MessageDeduplicationId", out value) && value is not null)
{
sendMessageRequest.MessageDeduplicationId = value.ToString();
message.Headers.Remove("SQS.MessageDeduplicationId");
}
if (message.Headers.TryGetValue("SQS.DelaySeconds", out value) && value is not null)
{
sendMessageRequest.DelaySeconds = (int)value;
message.Headers.Remove("SQS.DelaySeconds");
}
foreach (var header in message.Headers)
{
sendMessageRequest.MessageAttributes[header.Key] =
new MessageAttributeValue {
StringValue = header.Value.ToString(), DataType = "String"
};
}
return(SQSClient.SendMessageAsync(sendMessageRequest, cancellationToken));
}
public void ValidateStaticMethodSadPath()
{
// Missing CorrelationId
var senderMessage = new SenderMessage("Hello, world!");
senderMessage.Headers.Add(CloudEvent.SpecVersionAttribute, "1.0");
senderMessage.Headers.Add(CloudEvent.IdAttribute, "MyId");
senderMessage.Headers.Add(CloudEvent.SourceAttribute, new Uri("http://MySource"));
senderMessage.Headers.Add(CloudEvent.TypeAttribute, "MyType");
senderMessage.Headers.Add(CloudEvent.TimeAttribute, DateTime.UtcNow);
CorrelatedEvent.Validate(senderMessage);
senderMessage.Headers.Should().ContainKey(CorrelatedEvent.CorrelationIdAttribute)
.WhoseValue.Should().NotBeNull();
}
public void BinaryConstructorCompressed()
{
var payload = GetCompressablePayload(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
var message = new SenderMessage(payload, compress: true);
message.StringPayload.Should().Be(Convert.ToBase64String(_gzip.Compress(payload)));
message.BinaryPayload.Should().BeEquivalentTo(_gzip.Compress(payload));
message.Headers.Should().ContainKey(HeaderNames.MessageId);
message.MessageId.Should().NotBeNull();
message.Headers[HeaderNames.IsBinaryPayload].Should().Be("true");
message.IsBinary.Should().BeTrue();
message.Headers[HeaderNames.IsCompressedPayload].Should().Be("true");
message.IsCompressed.Should().BeTrue();
}
