public void MessageDispatchException(RawBusMessage busMessage, Exception exception)
{
_busMessage = busMessage;
_exception = exception;
_ev.Set();
}
public RawBusMessage Dispatch(RawBusMessage message)
{
BusMessage <TData> busMessage = new BusMessage <TData>
{
BusId = message.BusId,
Sent = message.Sent,
Data = (TData)message.Data
};
foreach (var header in message.Headers)
{
busMessage.Headers.Add(header);
}
BusMessage <TReplyData> busReplyMessage = _action(busMessage);
RawBusMessage replyMessage = new RawBusMessage
{
Data = busReplyMessage.Data
};
foreach (var header in busReplyMessage.Headers)
{
replyMessage.Headers.Add(header);
}
return(replyMessage);
}
private void SetBusHeaders(RawBusMessage busMessage, Message message)
{
SetBusHeader(message, MessagingConstants.HeaderNames.Name, busMessage.Name);
SetBusHeader(message, MessagingConstants.HeaderNames.NameSpace, busMessage.Namespace);
SetBusHeader(message, MessagingConstants.HeaderNames.BusId, busMessage.BusId);
SetBusHeader(message, MessagingConstants.HeaderNames.SentTime, busMessage.Sent);
}
private void ConsumeWithDiscard(ITargetBlock <RawBusMessage> target, CancellationToken token, TimeSpan interval)
{
long lastTicks = 0;
while (!token.IsCancellationRequested)
{
_counter++;
var reading = _dataBus.Read();
if (ShowMessages.PrintReader)
{
Console.WriteLine($"Read message {_counter} on thread {Thread.CurrentThread.ManagedThreadId}");
}
var message = new RawBusMessage();
message.Data = reading.Data;
message.ReadingTime = new DateTime(reading.Ticks);
message.Counter = _counter;
if (lastTicks < reading.Ticks)
{
var posted = target.Post(message);
if (!posted && ShowMessages.PrintFullBuffers)
{
Console.WriteLine("Buffer full. Could not post");
}
}
lastTicks = reading.Ticks;
Thread.Sleep(interval);
}
}
public byte[] Serialize(RawBusMessage busMessage)
{
object data = busMessage.Data;
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(data.GetType());
//Create our own namespaces for the output
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
//Add an empty namespace and empty value
ns.Add("", "");
using (MemoryStream stream = new MemoryStream())
{
using (XmlWriter writer = XmlWriter.Create(stream, new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Indent = false,
NewLineHandling = NewLineHandling.None,
}))
{
serializer.Serialize(writer, busMessage.Data, ns);
writer.Flush();
return(stream.ToArray());
}
}
}
protected override RawBusMessage HandleMessage(ICallHandler handler, RawBusMessage message, bool redelivered, ulong deliveryTag)
{
try
{
RawBusMessage replyMessage = base.HandleMessage(handler, message, redelivered, deliveryTag);
Model.BasicAck(deliveryTag, false);
return(replyMessage);
}
catch (RejectMessageException)
{
// If reject message exception is thrown -> reject message without requeue it.
// Message will be lost or transfered to dead letter exchange by broker
Model.BasicNack(deliveryTag, false, false);
throw;
}
catch (Exception)
{
Model.BasicNack(deliveryTag, false, true);
throw;
}
}
public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
DataContractKey dataContractKey = properties.GetDataContractKey();
SerializedBusMessage message = _messageHelper.ConstructMessage(dataContractKey, properties, body);
try
{
_monitor(message);
}
catch (Exception ex)
{
RawBusMessage raw = new RawBusMessage
{
Data = message.Data,
Namespace = message.Namespace,
Name = message.Name,
BusId = message.BusId,
CorrelationId = message.CorrelationId,
Sent = message.Sent
};
foreach (var header in message.Headers)
{
raw.Headers.Add(header);
}
_errorSubscriber.MessageDispatchException(raw, ex);
}
}
private void ConsumeWithBackPressure(ITargetBlock <RawBusMessage> target, CancellationToken token, TimeSpan interval)
{
long lastTicks = 0;
while (!token.IsCancellationRequested)
{
_counter++;
var reading = _dataBus.Read();
if (ShowMessages.PrintReader)
{
Console.WriteLine($"Read message {_counter} on thread {Thread.CurrentThread.ManagedThreadId}");
}
var message = new RawBusMessage();
message.Data = reading.Data;
message.ReadingTime = new DateTime(reading.Ticks);
message.Counter = _counter;
if (lastTicks < reading.Ticks)
{
while (!target.Post(message))
{
Thread.Sleep((int)interval.TotalMilliseconds);
}
}
lastTicks = reading.Ticks;
Thread.Sleep(interval);
}
}
public IEnumerable <DecodedMessage> Decode(RawBusMessage reading)
{
foreach (var sensorConfig in _sensorConfigs)
{
yield return(Decode(reading, sensorConfig));
}
}
protected override async Task <RawBusMessage> HandleMessage(ICallHandler handler, RawBusMessage message, bool redelivered, ulong deliveryTag)
{
try
{
RawBusMessage replyMessage = await base.HandleMessage(handler, message, redelivered, deliveryTag);
Model.BasicAck(deliveryTag, false);
return(replyMessage);
}
catch (RejectMessageException)
{
// If reject message exception is thrown -> reject message without requeue it.
// Message will be lost or transfered to dead letter exchange by broker
Model.BasicNack(deliveryTag, false, false);
throw;
}
catch (Exception ex)
{
bool requeue = _exceptionFilter.Filter(ex, message, redelivered, deliveryTag);
Model.BasicNack(deliveryTag, false, requeue);
if (requeue)
{
return(null);
}
throw;
}
}
private void ModelOnBasicReturn(object sender, BasicReturnEventArgs args)
{
DataContractKey dataContractKey = args.BasicProperties.GetDataContractKey();
Type dataType = _sendHelper.GetDataType(dataContractKey);
if (dataType == null)
{
dataContractKey = DataContractKey.BinaryBlob;
}
object data;
if (dataContractKey.Equals(DataContractKey.BinaryBlob))
{
data = args.Body;
}
else
{
data = _configuration.Serializer.Deserialize(dataType, args.Body);
}
RawBusMessage message = _messageHelper.ConstructMessage(dataContractKey, args.BasicProperties, data);
OnMessageReturn(args.ReplyCode, args.ReplyText, message);
}
public void MessageDeserializeException(RawBusMessage busMessage, Exception exception)
{
_busMessage = busMessage;
_exception = exception;
_ev.Set();
}
public void Send(RawBusMessage message, ISerializer serializer, SendParams sendParams)
{
if (message.Data != null)
{
Type type = message.Data.GetType();
DataContractKey contractKey = _nameMappings.GetOrAdd(type, t => t.GetDataContractKey());
if (message.Name == null)
{
message.Name = contractKey.Name;
}
if (message.Namespace == null)
{
message.Namespace = contractKey.Ns;
}
}
var bytes = message.Data as byte[];
if (bytes == null)
{
bytes = message.Data != null?serializer.Serialize(message) : new byte[0];
}
Send(bytes, serializer.ContentType, message.Name, message.Namespace, message, sendParams);
}
public async Task WriteAsync(RawBusMessage message)
{
if (ShowMessages.PrintFileWriter)
{
Console.WriteLine($"Write to file message: {message.Counter} on thread {Thread.CurrentThread.ManagedThreadId}");
}
await Task.Yield();
}
public byte[] Serialize(RawBusMessage busMessage)
{
object data = busMessage.Data;
string body = JsonConvert.SerializeObject(data, _settings);
return(_encoding.GetBytes(body));
}
public RawBusMessage Dispatch(RawBusMessage message)
{
object result = _handler(message.Data);
return(new RawBusMessage {
Data = result
});
}
public Task <RawBusMessage> Dispatch(RawBusMessage message)
{
TOut result = _handler((TIn)message.Data);
return(Task.FromResult(new RawBusMessage {
Data = result
}));
}
public async Task <RawBusMessage> Dispatch(RawBusMessage message)
{
TOut result = await _handler((TIn)message.Data);
return(new RawBusMessage {
Data = result
});
}
public void DeliveryFailed(int errorCode, string text, RawBusMessage message)
{
_errorCode = errorCode;
_text = text;
_message = message;
_ev.Set();
}
public void Deserialize(RawBusMessage rawBusMessage, XmlDictionaryReader bodyContent)
{
XmlObjectSerializer serializer;
if (_map.TryGetValue(new DataContractKey(rawBusMessage.Name, rawBusMessage.Namespace), out serializer))
{
rawBusMessage.Data = serializer.ReadObject(bodyContent);
}
}
public void SetResponse(RawBusMessage message, Exception exception)
{
_message = message;
_exception = exception;
_callback(_message, _exception);
_ev.Set();
}
private static void SetUserHeaders(RawBusMessage busMessage, Message message)
{
foreach (BusHeaderBase busHeader in busMessage.Headers)
{
message.Headers.Add(MessageHeader.CreateHeader(busHeader.Name,
MessagingConstants.Namespace.MessageBus,
busHeader.GetValue(), false,
MessagingConstants.Actor.User));
}
}
public byte[] Serialize(RawBusMessage data)
{
IMessage message = (IMessage)data.Data;
using (MemoryStream stream = new MemoryStream())
{
message.WriteTo(stream);
return(stream.ToArray());
}
}
public IEnumerable <DecodedMessage> Decode(RawBusMessage reading)
{
int decodeCounter = 0;
foreach (var sensorConfig in _sensorConfigs)
{
yield return(Decode(reading, sensorConfig, decodeCounter));
decodeCounter++;
}
}
private bool IsMessageSurvivesFilter(MessageFilterInfo filterInfo, RawBusMessage busMessage)
{
// TODO: Add header filtering
if (filterInfo.ReceiveSelfPublish)
{
return(true);
}
bool selfPublished = Equals(busMessage.BusId, _busId);
return(!selfPublished);
}
public byte[] Serialize(RawBusMessage busMessage)
{
object data = busMessage.Data;
if (data.GetType() == typeof(byte[]))
{
return(data as byte[]);
}
string body = JsonConvert.SerializeObject(data, Formatting.None);
return(_encoding.GetBytes(body));
}
public void Send <TData>(BusMessage <TData> busMessage)
{
RawBusMessage rawBusMessage = new RawBusMessage
{
Data = busMessage.Data
};
foreach (BusHeader header in busMessage.Headers)
{
rawBusMessage.Headers.Add(header);
}
Send(rawBusMessage);
}
private RawBusMessage CreateRawMessage <TData>(BusMessage <TData> busMessage)
{
RawBusMessage rawBusMessage = new RawBusMessage
{
Data = busMessage.Data
};
foreach (var header in busMessage.Headers.Concat(_configuration.Headers))
{
rawBusMessage.Headers.Add(header);
}
return(rawBusMessage);
}
public void Send(RawBusMessage busMessage)
{
_sendHelper.Send(new SendParams
{
BusId = _busId,
Model = _model,
BusMessage = busMessage,
Serializer = _configuration.Serializer,
CorrelationId = "",
Exchange = _configuration.Exchange,
MandatoryDelivery = _configuration.MandatoryDelivery,
PersistentDelivery = _configuration.PersistentDelivery,
RoutingKey = _configuration.RoutingKey
});
}
public RawBusMessage ConstructMessage(DataContractKey dataContractKey, IBasicProperties properties, object data)
{
RawBusMessage message = new RawBusMessage
{
Data = data,
BusId = properties.AppId,
Sent = properties.Timestamp.GetDateTime(),
Name = dataContractKey.Name,
Namespace = dataContractKey.Ns
};
ConstructHeaders(message, properties);
return(message);
}
