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