public void Process(CronusMessage message)
{
var indexId = new EventStoreIndexEventTypeId(message.Payload.GetType().GetContractId());
var commit = new ProjectionCommit(indexId, Version, (IEvent)message.Payload, 1, message.GetEventOrigin(), DateTime.FromFileTimeUtc(message.GetRootEventTimestamp()));
store.Save(commit);
}
bool EnsureTenantIsSet(IServiceScope scope, CronusMessage message)
{
var cronusContextFactory = scope.ServiceProvider.GetRequiredService <CronusContextFactory>();
var context = cronusContextFactory.GetContext(message, scope.ServiceProvider);
return(context.IsInitialized);
}
public void Save(Type projectionType, CronusMessage cronusMessage)
{
var projection = FastActivator.CreateInstance(projectionType) as IProjectionDefinition;
if (projection != null)
{
var projectionIds = projection.GetProjectionIds(cronusMessage.Payload as IEvent);
string contractId = projectionType.GetContractId();
foreach (var projectionId in projectionIds)
{
foreach (var version in GetProjectionVersions(contractId))
{
ISnapshot snapshot = snapshotStore.Load(contractId, projectionId, version);
ProjectionStream projectionStream = LoadProjectionStream(projectionType, version, projectionId, snapshot);
int snapshotMarker = snapshotStrategy.GetSnapshotMarker(projectionStream.Commits, snapshot.Revision);
EventOrigin eventOrigin = cronusMessage.GetEventOrigin();
DateTime timestamp = DateTime.UtcNow;
IEvent @event = cronusMessage.Payload as IEvent;
var commit = new ProjectionCommit(projectionId, version, @event, snapshotMarker, eventOrigin, timestamp);
projectionStore.Save(commit);
}
}
}
}
public void Append(CronusMessage msg)
{
var date = DateTime.UtcNow;
var cutDownDate = Convert.ToDateTime(date.ToString("yyyyMMdd"));
var dateTimeStamp = cutDownDate.ToFileTimeUtc();
long resultTimestamp = DateTime.UtcNow.ToFileTimeUtc();
string publishTime;
if (msg.Headers.TryGetValue(MessageHeader.PublishTimestamp, out publishTime))
{
if (long.TryParse(publishTime, out resultTimestamp))
{
}
}
byte[] data = SerializeEvent(msg);
PreparedStatement insertPreparedStatement = session.Prepare(String.Format(INSERT_MESSAGE_QUERY_TEMPLATE, MESSAGE_STORE_TABLE_NAME));
session
.Execute(insertPreparedStatement
.Bind(dateTimeStamp, resultTimestamp, data));
}
public async Task IndexAsync(CronusMessage message)
{
IEnumerable <Type> projectionTypes = projectionsContainer.Items;
if (message.IsRepublished)
{
projectionTypes = message.RecipientHandlers.Intersect(projectionsContainer.Items.Select(t => t.GetContractId())).Select(dc => dc.GetTypeByContract());
}
List <Task> projectionSaveTasks = new List <Task>();
Type messagePayloadType = message.Payload.GetType();
foreach (var projectionType in projectionTypes)
{
bool isInterested = projectionType.GetInterfaces()
.Where(x => x.IsGenericType && x.GetGenericArguments().Length == 1 && (baseMessageType.IsAssignableFrom(x.GetGenericArguments()[0])))
.Where(@interface => @interface.GetGenericArguments()[0].IsAssignableFrom(messagePayloadType))
.Any();
if (isInterested)
{
projectionSaveTasks.Add(projection.SaveAsync(projectionType, message));
}
}
await Task.WhenAll(projectionSaveTasks).ConfigureAwait(false);
}
private byte[] SerializeEvent(CronusMessage msg)
{
using (var stream = new MemoryStream())
{
serializer.Serialize(stream, msg);
return(stream.ToArray());
}
}
public virtual void Process(CronusMessage message)
{
var context = new HandleContext(message, handlerType);
handlerMiddleware.Run(context);
log.Info(() => message.Payload.ToString());
log.Debug(() => "HANDLE => " + handlerType.Name + "( " + BuildDebugLog(message) + " )");
}
protected override bool PublishInternal(CronusMessage message)
{
try
{
if (ReferenceEquals(null, connection) || connection.IsOpen == false)
{
lock (connectionFactory)
{
if (ReferenceEquals(null, connection) || connection.IsOpen == false)
{
connection?.Abort();
connection = connectionFactory.CreateConnection();
connection.AutoClose = false;
}
}
}
if (publishModel == null || publishModel.IsClosed)
{
publishModel = connection.CreateModel();
}
IBasicProperties props = publishModel.CreateBasicProperties();
props.Headers = new Dictionary <string, object>()
{
{ message.Payload.GetType().GetContractId(), string.Empty }
};
props.Persistent = true;
props.Priority = 9;
byte[] body = this.serializer.SerializeToBytes(message);
var publishDelayInMiliseconds = message.GetPublishDelay();
if (publishDelayInMiliseconds < 1000)
{
var exchangeName = RabbitMqNamer.GetExchangeName(message.Payload.GetType());
publishModel.BasicPublish(exchangeName, string.Empty, false, props, body);
}
else
{
var exchangeName = RabbitMqNamer.GetExchangeName(message.Payload.GetType()) + ".Scheduler";
props.Headers.Add("x-delay", message.GetPublishDelay());
publishModel.BasicPublish(exchangeName, string.Empty, false, props, body);
}
return(true);
}
catch (Exception ex)
{
publishModel?.Abort();
connection?.Abort();
connection = null;
publishModel = null;
return(false);
}
}
public Task IndexAsync(CronusMessage message)
{
if (message.Payload is IEvent @event)
{
eventCounter.IncrementAsync(@event.Unwrap().GetType());
}
return(Task.CompletedTask);
}
private string GetScopeId(CronusMessage cronusMessage)
{
if (cronusMessage.Headers.TryGetValue(MessageHeader.CorelationId, out string scopeId) == false)
{
scopeId = Guid.NewGuid().ToString();
}
return(scopeId);
}
protected override bool PublishInternal(CronusMessage message)
{
NotifySubscribers(message, appServiceSubscribers);
NotifySubscribers(message, projectionSubscribers);
NotifySubscribers(message, portSubscribers);
NotifySubscribers(message, gatewaySubscribers);
NotifySubscribers(message, sagaSubscribers);
return(true);
}
protected override bool PublishInternal(T message, Dictionary <string, string> messageHeaders)
{
var cronusMessage = new CronusMessage(message, messageHeaders);
transport.PipelineFactory
.GetPipeline(message.GetType())
.Push(cronusMessage);
return(true);
}
public async Task IndexAsync(CronusMessage message)
{
var @event = message.Payload as IEvent;
string eventTypeId = @event.Unwrap().GetType().GetContractId();
var indexRecord = new List <IndexRecord>();
indexRecord.Add(new IndexRecord(eventTypeId, Encoding.UTF8.GetBytes(message.GetRootId())));
await indexStore.ApendAsync(indexRecord).ConfigureAwait(false);
}
protected override void Run(Execution <HandleContext> execution)
{
CronusMessage cronusMessage = execution.Context.Message;
if (cronusMessage.Payload is IEvent)
{
Type projectionType = execution.Context.HandlerType;
repository.Save(projectionType, cronusMessage);
}
}
void EnsureTenantIsSet(IServiceScope scope, CronusMessage message)
{
var cronusContext = scope.ServiceProvider.GetRequiredService <CronusContext>();
if (cronusContext.IsNotInitialized)
{
string tenant = tenantResolver.Resolve(message);
cronusContext.Initialize(tenant, scope.ServiceProvider);
}
}
public static long GetPublishDelay(this CronusMessage message)
{
string publishAt = "0";
if (message.Headers.TryGetValue(MessageHeader.PublishTimestamp, out publishAt))
{
return((long)(DateTime.FromFileTimeUtc(long.Parse(publishAt)) - DateTime.UtcNow).TotalMilliseconds);
}
return(0);
}
private string MessageAsString(ISerializer serializer, CronusMessage message)
{
using (var stream = new MemoryStream())
using (StreamReader reader = new StreamReader(stream))
{
serializer.Serialize(stream, message);
stream.Position = 0;
return(reader.ReadToEnd());
}
}
public void Index(CronusMessage message)
{
var @event = message.Payload as IEvent;
string eventTypeId = @event.Unwrap().GetType().GetContractId();
var indexRecord = new List <IndexRecord>();
indexRecord.Add(new IndexRecord(eventTypeId, Encoding.UTF8.GetBytes(message.GetRootId())));
indexStore.Apend(indexRecord);
}
protected override void Run(Execution <HandleContext> execution)
{
var projectionWriter = projectionWriterProvider(execution.Context);
CronusMessage cronusMessage = execution.Context.Message;
if (cronusMessage.Payload is IEvent)
{
Type projectionType = execution.Context.HandlerType;
projectionWriter.Save(projectionType, cronusMessage);
}
}
public string Resolve(CronusMessage cronusMessage)
{
var tenant = cronusMessage.GetTenant();
if (string.IsNullOrEmpty(tenant))
{
return(Resolve(cronusMessage.Payload));
}
return(tenant);
}
private bool EnsureTenantIsSet(IServiceScope scope, CronusMessage message)
{
var cronusContextFactory = scope.ServiceProvider.GetRequiredService <CronusContextFactory>();
var context = cronusContextFactory.GetContext(message, scope.ServiceProvider);
foreach (var header in message.Headers)
{
context.Trace.Add(header.Key, header.Value);
}
return(context.IsInitialized);
}
public void Start()
{
CronusMessage transportMessage = null;
try
{
isWorking = true;
while (isWorking)
{
for (int i = 0; i < messageThreshold.Size; i++)
{
transportMessage = endpoint.Dequeue(TimeSpan.FromMilliseconds(messageThreshold.Delay));
if (transportMessage == null)
{
break;
}
var subscribers = subscriptions.GetInterestedSubscribers(transportMessage);
foreach (var subscriber in subscribers)
{
subscriber.Process(transportMessage);
}
endpoint.Acknowledge(transportMessage);
}
}
}
catch (EndpointClosedException ex)
{
log.DebugException("Endpoint Closed", ex);
}
catch (Exception ex)
{
log.ErrorException("Unexpected Exception.", ex);
}
finally
{
try
{
if (transportMessage != null)
{
endpoint.Acknowledge(transportMessage);
}
}
catch (EndpointClosedException ex)
{
log.DebugException("Endpoint Closed", ex);
}
ScheduledStart = DateTime.UtcNow.AddMilliseconds(30);
}
}
public void Start()
{
try
{
isWorking = true;
endpoint.Open();
while (isWorking)
{
List <EndpointMessage> rawMessages = new List <EndpointMessage>();
for (int i = 0; i < messageThreshold.Size; i++)
{
EndpointMessage rawMessage = null;
if (!endpoint.BlockDequeue(messageThreshold.Delay, out rawMessage))
{
break;
}
CronusMessage transportMessage = (CronusMessage)serializer.DeserializeFromBytes(rawMessage.Body);
var subscribers = subscriptions.GetInterestedSubscribers(transportMessage);
foreach (var subscriber in subscribers)
{
subscriber.Process(transportMessage);
}
rawMessages.Add(rawMessage);
}
endpoint.AcknowledgeAll();
}
}
catch (EndpointClosedException ex)
{
log.DebugException("Endpoint Closed", ex);
}
catch (Exception ex)
{
log.ErrorException("Unexpected Exception.", ex);
}
finally
{
try
{
endpoint.AcknowledgeAll();
endpoint.Close();
}
catch (EndpointClosedException ex)
{
log.DebugException("Endpoint Closed", ex);
}
ScheduledStart = DateTime.UtcNow.AddMilliseconds(30);
}
}
public IMessageQueue <CronusMessage> GetQueue(CronusMessage message)
{
if (queues.TryGetValue(message.CorelationId, out MessageQueue <CronusMessage> existing))
{
existing.Enqueue(message);
return(new AllwaysEmptyQueue <CronusMessage>());
}
else
{
var queue = new MessageQueue <CronusMessage>(message.CorelationId, Deregister);
queues.TryAdd(message.CorelationId, queue);
return(queue);
}
}
void NotifySubscribers <TContract>(CronusMessage message, ISubscriberCollection <TContract> subscribers)
{
try
{
var interestedSubscribers = subscribers.GetInterestedSubscribers(message);
foreach (var subscriber in interestedSubscribers)
{
subscriber.Process(message);
}
}
catch (Exception ex)
{
log.Error("Unable to process message", ex);
}
}
public IEnumerable <ISubscriber> GetInterestedSubscribers(CronusMessage message)
{
IEnumerable <ISubscriber> result = Subscribers;
Type payloadType = message.Payload.GetType();
if (message.RecipientHandlers.Length > 0)
{
result = result.Where(subscriber => message.RecipientHandlers.Contains(subscriber.Id));
}
result = result.Where(subscriber => subscriber.GetInvolvedMessageTypes().Contains(payloadType));
return(result);
}
public async Task SaveAsync(Type projectionType, CronusMessage cronusMessage)
{
if (ReferenceEquals(null, projectionType))
{
throw new ArgumentNullException(nameof(projectionType));
}
if (ReferenceEquals(null, cronusMessage))
{
throw new ArgumentNullException(nameof(cronusMessage));
}
EventOrigin eventOrigin = cronusMessage.GetEventOrigin();
IEvent @event = cronusMessage.Payload as IEvent;
await SaveAsync(projectionType, @event, eventOrigin).ConfigureAwait(false);;
}
protected override bool PublishInternal(T message, Dictionary <string, string> messageHeaders)
{
var cronusMessage = new CronusMessage(message, messageHeaders);
byte[] body = serializer.SerializeToBytes(cronusMessage);
Dictionary <string, object> routingHeaders = new Dictionary <string, object>()
{
{ cronusMessage.Payload.GetType().GetContractId(), String.Empty }
};
EndpointMessage endpointMessage = new EndpointMessage(body, string.Empty, routingHeaders, cronusMessage.GetPublishDelay());
transport.PipelineFactory
.GetPipeline(message.GetType())
.Push(endpointMessage);
return(true);
}
public void Save(Type projectionType, CronusMessage cronusMessage)
{
if (ReferenceEquals(null, projectionType))
{
throw new ArgumentNullException(nameof(projectionType));
}
if (ReferenceEquals(null, cronusMessage))
{
throw new ArgumentNullException(nameof(cronusMessage));
}
EventOrigin eventOrigin = cronusMessage.GetEventOrigin();
IEvent @event = cronusMessage.Payload as IEvent;
Save(projectionType, @event, eventOrigin);
}
public void Start()
{
try
{
if (isRunning)
{
WorkStart();
}
else
{
WorkStop();
}
while (isRunning)
{
CronusMessage message = GetMessage();
if (ReferenceEquals(null, message))
{
break;
}
try
{
var subscribers = subscriptions.GetInterestedSubscribers(message);
foreach (var subscriber in subscribers)
{
subscriber.Process(message);
}
}
catch (Exception ex)
{
log.ErrorException("Unexpected Exception.", ex);
}
finally
{
MessageConsumed(message);
}
}
}
catch (Exception ex)
{
log.ErrorException("Unexpected Exception.", ex);
}
finally
{
ScheduledStart = DateTime.UtcNow.AddMilliseconds(50);
}
}
