/// <inheritdoc cref="MessageSerializer"/>
public override Task <byte[]> ToBytesAsync(IOutboundMessage message, CancellationToken cancellationToken = default)
{
var mapper = _outboundMapperFactory.GetMapper(message);
var data = mapper.Convert(message).ToByteArray();
return(Task.FromResult(data));
}
public static BinaryMessageEnvelope From(IOutboundMessage context)
{
var envelope = new BinaryMessageEnvelope();
envelope.CopyFrom(context);
return(envelope);
}
/// <summary>
/// Convert an <see cref="IOutboundMessage"/> to proto buf contract
/// </summary>
/// <param name="obj">Message to map</param>
/// <returns>Converted message</returns>
/// <exception cref="InvalidOperationException"><paramref name="obj"/> is not of <typeparamref name="T"> type</typeparamref></exception>
public override IMessage Convert(IOutboundMessage obj)
{
if (obj is T outboundMessage)
{
return(Convert(outboundMessage));
}
throw new InvalidOperationException();
}
public async Task Enqueue(IOutboundMessage message)
{
await DbSet.AddAsync(new OutboundMessage
{
Message = DefaultSerializer.Serialize(message),
Endpoint = message.Endpoint.Name,
Created = DateTime.UtcNow
});
}
public Task Enqueue(IOutboundMessage message)
{
if (message.RawContent == null)
{
((OutboundMessage)message).RawContent = message.Endpoint.Serializer.Serialize(message.Content, message.Headers);
}
Add(new QueuedMessage(message.RawContent, message.Headers, message.Endpoint));
return(Task.CompletedTask);
}
/// <summary>
/// Send a <paramref name="message"/> to a channel
/// </summary>
/// <param name="message">Message to send</param>
/// <param name="cancellationToken">Cancellation token for the operation</param>
/// <exception cref="ArgumentNullException">message is <c>null</c></exception>
public async Task DispatchAsync(IOutboundMessage message, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var data = await _serializer.ToBytesAsync(message, cancellationToken).ConfigureAwait(false);
await _channel.WriteToAsync(data, cancellationToken).ConfigureAwait(false);
}
private void SetPartitioningKey(IOutboundMessage outboundMessage)
{
var key = KafkaKeyHelper.GetMessageKey(outboundMessage.Content);
if (key == null)
{
return;
}
outboundMessage.Headers.AddOrReplace(KafkaProducer.PartitioningKeyHeaderKey, key);
}
/// <summary>
/// Find a mapper for a type
/// </summary>
/// <param name="message">Message to locate mapper for</param>
/// <returns>Located mapper</returns>
/// <exception cref="ArgumentNullException"><paramref name="message"/> is <c>null</c></exception>
/// <exception cref="InvalidOperationException">no mapper found</exception>
public ProtobufOutboundMapper GetMapper(IOutboundMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var typeToLocate = _protobufMapperType.MakeGenericType(message.GetType());
var mapper = _serviceProvider.GetService(typeToLocate) as ProtobufOutboundMapper;
return(mapper ?? throw new InvalidOperationException("Mapper not found"));
}
public Task Enqueue(IOutboundMessage message)
{
DbSet.Add(new OutboundMessage
{
Content = message.RawContent ?? message.Endpoint.Serializer.Serialize(message.Content, message.Headers),
Headers = DefaultSerializer.Serialize((IEnumerable <MessageHeader>)message.Headers),
Endpoint = DefaultSerializer.Serialize(message.Endpoint),
EndpointName = message.Endpoint.Name,
Created = DateTime.UtcNow
});
return(Task.CompletedTask);
}
public void SendMessage(Client client, IOutboundMessage outboundMessage)
{
var generatedMessage = _messageProcessor.GenerateMessage(outboundMessage);
if (outboundMessage.Multiline)
{
// Don't send the message yet - store it in the message buffer
client.MessageBuffer += generatedMessage;
}
else
{
if (!string.IsNullOrEmpty(client.MessageBuffer))
{
generatedMessage = client.MessageBuffer + generatedMessage;
client.MessageBuffer = string.Empty;
}
_networkMessager.SendMessage(client.TcpClient, client.CancellationToken, generatedMessage);
}
}
/// <summary>
/// Sends the specified message to the specified destination.
/// </summary>
/// <param name="message">Message to send.</param>
/// <param name="destination">Destination to send message to.</param>
public void Send(IOutboundMessage message, IPAddress destination)
{
var endPoint = new IPEndPoint(destination, Port);
var payload = message.GetPayload();
try
{
var sent = _client.Send(payload, payload.Length, endPoint);
if (sent != payload.Length)
{
throw new MessageException($"Error sending message: expected bytes sent {payload.Length}, actual bytes sent {sent}.");
}
}
catch (SocketException e)
{
throw new MessageException("Error sending message.", e);
}
}
public void SendMessage(Client client, IOutboundMessage outboundMessage)
{
var generatedMessage = _messageProcessor.GenerateMessage(outboundMessage);
if (outboundMessage.Multiline)
{
// Don't send the message yet - store it in the message buffer
client.MessageBuffer += generatedMessage;
}
else
{
if (!string.IsNullOrEmpty(client.MessageBuffer))
{
generatedMessage = client.MessageBuffer + generatedMessage;
client.MessageBuffer = string.Empty;
}
_networkMessager.SendMessage(client.TcpClient, client.CancellationToken, generatedMessage);
}
}
public string GenerateMessage(IOutboundMessage message)
{
throw new NotImplementedException();
}
/// <summary> /// Map application message to protobuf /// </summary> /// <param name="obj">Object to map</param> /// <returns>Proto buf message</returns> public abstract IMessage Convert(IOutboundMessage obj);
public Task RelayMessage(IOutboundMessage message) => _broker.GetProducer(message.Endpoint).ProduceAsync(message.Message, message.Headers);
public Task Enqueue(IOutboundMessage message)
{
Add(new QueuedMessage(message));
return(Task.CompletedTask);
}
public DbQueuedMessage(int id, IOutboundMessage message) : base(message)
{
Id = id;
}
public QueuedMessage(IOutboundMessage message)
{
Message = message;
}
/// <summary>
/// Generate a text message from the provided IOutboundMessage implementation.
/// The generated text message can then be forwarded to the output stream.
/// </summary>
/// <param name="message">Message</param>
/// <returns></returns>
public string GenerateMessage(IOutboundMessage message)
{
return($"{message.ReplyCode}{(message.Multiline ? "-" : " ")}{message.GetMessage()}\r\n");
}
public async Task RelayMessage(IOutboundMessage message)
{
_messageLogger.LogTrace(_logger, "Queuing message for deferred publish.", message);
await _queueProducer.Enqueue(message);
}
protected virtual Task ProduceMessage(IOutboundMessage message) => _broker.GetProducer(message.Endpoint).ProduceAsync(message.Message, message.Headers);
/// <summary> /// Serialize a message /// </summary> /// <param name="message">Message to serialize</param> /// <param name="cancellationToken">Cancellation token for the request</param> /// <returns><see cref="byte"/> sequence for the message</returns> public abstract Task <byte[]> ToBytesAsync(IOutboundMessage message, CancellationToken cancellationToken = default);
public string GenerateMessage(IOutboundMessage message)
{
throw new NotImplementedException();
}
