/// <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(); }