public bool Publish(TMessage message, Dictionary <string, string> messageHeaders)
{
try
{
messageHeaders = messageHeaders ?? new Dictionary <string, string>();
string messageId = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
messageHeaders.Add(MessageHeader.MessageId, messageId);
if (messageHeaders.ContainsKey(MessageHeader.CorelationId) == false)
{
messageHeaders.Add(MessageHeader.CorelationId, messageId);
}
if (messageHeaders.ContainsKey(MessageHeader.PublishTimestamp) == false)
{
messageHeaders.Add(MessageHeader.PublishTimestamp, DateTime.UtcNow.ToFileTimeUtc().ToString());
}
var cronusMessage = new CronusMessage(message, messageHeaders);
PublishInternal(cronusMessage);
log.Info(() => message.ToString());
log.Debug(() => "PUBLISH => " + BuildDebugLog(message, messageHeaders));
return(true);
}
catch (Exception ex)
{
log.ErrorException(ex.Message, ex);
return(false);
}
}
public static string GetTenant(this CronusMessage message)
{
string tenant = null;
message.Headers.TryGetValue(MessageHeader.Tenant, out tenant);
return(tenant);
}
public static string GetRootId(this CronusMessage message)
{
var aggregateRootId = string.Empty;
if (message.Headers.TryGetValue(MessageHeader.AggregateRootId, out aggregateRootId))
{
return(aggregateRootId);
}
throw new ArgumentException("Cronus message does not contain a valid AggregateRootId");
}
public static long GetRootEventTimestamp(this CronusMessage message)
{
long timestamp = 0;
var value = string.Empty;
if (message.Headers.TryGetValue(MessageHeader.PublishTimestamp, out value) && long.TryParse(value, out timestamp))
{
return(timestamp);
}
return(0);
}
public static int GetRootEventPosition(this CronusMessage message)
{
var revision = 0;
var value = string.Empty;
if (message.Headers.TryGetValue(MessageHeader.AggregateRootEventPosition, out value) && int.TryParse(value, out revision))
{
return(revision);
}
return(0);
}
public override bool Publish(TMessage message, Dictionary <string, string> messageHeaders)
{
try
{
messageHeaders = BuildHeaders(message, messageHeaders);
var cronusMessage = new CronusMessage(message, messageHeaders);
using (logger.BeginScope(cronusMessage.CorelationId))
{
bool isPublished = RetryableOperation.TryExecute(() => PublishInternal(cronusMessage), retryPolicy, () => BuildTraceData());
if (isPublished)
{
logger.Info(() => "Publish {cronus_MessageType} {cronus_MessageName} - OK", typeof(TMessage).Name, message.GetType().Name, messageHeaders);
}
else
{
logger.Error(() => "Publish {cronus_MessageType} {cronus_MessageName} - Fail", typeof(TMessage).Name, message.GetType().Name, messageHeaders);
}
return(isPublished);
}
}
catch (Exception ex) when(logger.ErrorException(ex, () => BuildTraceData()))
{
return(false);
}
string BuildTraceData()
{
StringBuilder errorMessage = new StringBuilder();
errorMessage.AppendLine("Failed to publish message!");
errorMessage.AppendLine("Headers:");
foreach (var header in messageHeaders)
{
errorMessage.AppendLine($"{header.Key}:{header.Value}");
}
string messageString = JsonSerializer.Serialize <object>(message);
errorMessage.AppendLine(messageString);
return(errorMessage.ToString());
}
}
public virtual bool Publish(TMessage message, Dictionary <string, string> messageHeaders)
{
try
{
messageHeaders = BuildHeaders(message, messageHeaders);
var cronusMessage = new CronusMessage(message, messageHeaders);
using (logger.BeginScope(cronusMessage.CorelationId))
{
bool isPublished = PublishInternal(cronusMessage);
return(isPublished);
}
}
catch (Exception ex) when(logger.ErrorException(ex, () => BuildTraceData()))
{
return(false);
}
string BuildTraceData()
{
StringBuilder errorMessage = new StringBuilder();
errorMessage.AppendLine("Failed to publish message!");
errorMessage.AppendLine("Headers:");
foreach (var header in messageHeaders)
{
errorMessage.AppendLine($"{header.Key}:{header.Value}");
}
string messageString = JsonSerializer.Serialize <object>(message);
errorMessage.AppendLine(messageString);
return(errorMessage.ToString());
}
}
protected abstract bool PublishInternal(CronusMessage message);
public static EventOrigin GetEventOrigin(this CronusMessage message)
{
return(new EventOrigin(GetRootId(message), GetRevision(message), GetRootEventPosition(message), GetRootEventTimestamp(message)));
}
public bool Publish(TMessage message, Dictionary <string, string> messageHeaders)
{
try
{
messageHeaders = messageHeaders ?? new Dictionary <string, string>();
string messageId = string.Empty;
if (messageHeaders.ContainsKey(MessageHeader.MessageId) == false)
{
messageHeaders.Add(MessageHeader.MessageId, messageId);
}
else
{
messageId = messageHeaders[MessageHeader.MessageId];
}
if (messageHeaders.ContainsKey(MessageHeader.CorelationId) == false)
{
messageHeaders.Add(MessageHeader.CorelationId, messageId);
}
if (messageHeaders.ContainsKey(MessageHeader.PublishTimestamp) == false)
{
messageHeaders.Add(MessageHeader.PublishTimestamp, DateTime.UtcNow.ToFileTimeUtc().ToString());
}
if (messageHeaders.ContainsKey(MessageHeader.Tenant) == false)
{
messageHeaders.Add(MessageHeader.Tenant, tenantResolver.Resolve(message));
}
if (messageHeaders.ContainsKey(MessageHeader.BoundedContext))
{
if (messageHeaders[MessageHeader.BoundedContext] == "implicit")
{
messageHeaders[MessageHeader.BoundedContext] = boundedContext.Name;
}
}
else
{
var bc = message.GetType().GetBoundedContext(boundedContext.Name);
messageHeaders.Add(MessageHeader.BoundedContext, bc);
}
var cronusMessage = new CronusMessage(message, messageHeaders);
var published = PublishInternal(cronusMessage);
if (published == false)
{
logger.Error(() => "Failed to publish => " + BuildDebugLog(message, messageHeaders));
return(false);
}
logger.Info(() => message.ToString());
logger.Debug(() => "PUBLISH => " + BuildDebugLog(message, messageHeaders));
return(true);
}
catch (Exception ex)
{
logger.ErrorException(ex, () => ex.Message);
return(false);
}
}
