public AckEventHandler(IEventBus eventBus,
ILogger <AckEventHandler> logger,
IEventStorage eventStorage) : base(eventBus, null)
{
this.logger = logger;
this.eventStorage = eventStorage;
}
public DefaultCommandContext(IServiceProvider Container)
{
this.Container = Container;
eventStorage = Container.GetService <IEventStorage>();
eventBus = Container.GetService <IEventBus>();
aggregates = new ConcurrentQueue <AggregateRoot>();
}
protected internal Repository(Builder builder)
{
storage_ = builder.EventStorage;
serialzer_ = builder.EventSerializer;
aggregate_factory_ = builder.AggregateFactory;
conflict_evaluator_ = builder.ConflictEvaluator;
}
public MeidoDbContext(
DbContextOptions <MeidoDbContext> options,
IEventStorage eventStorage)
: base(options)
{
_eventStorage = eventStorage;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Galaxy.Infrastructure.DomainRepository`2"/> class.
/// </summary>
/// <param name="eventStorage">Event storage.</param>
/// <param name="eventPublisher">Event publisher.</param>
public DomainRepository(IEventStorage <T> eventStorage,
IEventPublisher eventPublisher,
ILoggerFactory loggerFactory)
{
_eventStorage = eventStorage;
_eventPublisher = eventPublisher;
}
protected EventMessageHeader PopMessage(IEventStorage storage, string queueName, bool withBody = false, bool backup = false)
{
var msgKey = backup ? storage.RightPopLeftPush(queueName, queueName + this.BackupQueueSuffix) : storage.RightPop(queueName);
if (msgKey == null)
{
return(null);
}
var messageId = msgKey.ToGuidString();
EventMessageHeader header;
if (withBody)
{
var result = storage.MultiGet(this.MessageHeaderPrefix + messageId, this.MessagePrefix + messageId);
if (result == null || result.Length < 2)
{
return(null);
}
header = this.Serializer.Deserialize <EventMessageHeader>(result[0], null);
header.Message = this.Serializer.Deserialize <EventMessage>(result[1], null);
}
else
{
var result = storage.Get(this.MessageHeaderPrefix + messageId);
if (result == null || result.Length <= 0)
{
return(null);
}
header = this.Serializer.Deserialize <EventMessageHeader>(result, null);
}
return(header);
}
public void AddEventLog(IEventStorage eventStorage)
{
if (eventStorage == null)
{
throw new ArgumentNullException("eventStorage");
}
foreach (XmlNode testCaseNode in _testResultXml.GetElementsByTagName(TestCaseElementName))
{
var testCaseId = GetTestCaseId(testCaseNode);
if (!eventStorage.Exist(testCaseId))
{
continue;
}
XmlElement eventLogElement = _testResultXml.CreateElement("events");
using (var stringWriter = new StringWriter())
{
_jsonSerializer.Serialize(stringWriter, eventStorage.Get(testCaseId));
eventLogElement.AppendChild(
_testResultXml.CreateCDataSection(stringWriter.ToString())
);
}
testCaseNode.AppendChild(eventLogElement);
}
}
public Fetcher(IDocumentStore store, DaemonSettings settings, AsyncOptions options, IDaemonLogger logger, IDaemonErrorHandler errorHandler, IEnumerable <Type> eventTypes)
{
_settings = settings;
_options = options;
_logger = logger;
_errorHandler = errorHandler;
State = FetcherState.Waiting;
// TODO -- this will have to change
_tenant = store.Tenancy.Default;
_streamIdentity = store.Events.StreamIdentity;
_selector = _tenant.EventStorage();
EventTypeNames = eventTypes.Select(x => store.Events.EventMappingFor(x).Alias).ToArray();
var fields = _selector.SelectFields().Join(", ");
_sql =
$@"
select seq_id from {_selector.Events.DatabaseSchemaName}.mt_events where seq_id > :last and seq_id <= :limit and extract(epoch from age(transaction_timestamp(), {_selector.Events.DatabaseSchemaName}.mt_events.timestamp)) >= :buffer order by seq_id;
select {fields} from {_selector.Events.DatabaseSchemaName}.mt_events where seq_id > :last and seq_id <= :limit and type = ANY(:types) and extract(epoch from age(transaction_timestamp(), {_selector.Events.DatabaseSchemaName}.mt_events.timestamp)) >= :buffer order by seq_id;
select min(seq_id) from {_selector.Events.DatabaseSchemaName}.mt_events where seq_id > :limit and type = ANY(:types) and extract(epoch from age(transaction_timestamp(), {_selector.Events.DatabaseSchemaName}.mt_events.timestamp)) >= :buffer;
select max(seq_id) from {_selector.Events.DatabaseSchemaName}.mt_events where seq_id >= :limit and extract(epoch from age(transaction_timestamp(), {_selector.Events.DatabaseSchemaName}.mt_events.timestamp)) >= :buffer
".Replace(" as d", "");
}
protected EventMessage[] GetSubscribersInternal(IEventStorage storage)
{
var keys = storage.GetKeys(this.SubscriberKeyPrefix + "*");
if (keys == null || keys.Length <= 0)
{
return(null);
}
var result = storage.MultiGet(keys);
if (result == null || result.Length <= 0)
{
return(null);
}
var list = new List <EventMessage>(result.Length);
foreach (var bytes in result)
{
if (bytes != null && bytes.Length > 0)
{
var message = this.Serializer.Deserialize <EventMessage>(bytes, null);
if (message != null)
{
list.Add(message);
}
}
}
return(list.ToArray());
}
public EventStreamProcessor(IEventStorage storage) : base("EventStoreProcessor", ThreadScheduler.Factory)
{
_storage = storage;
OnStream().Of<UncommitedEventStream>().ReactWith(ProcessUncommited);
OnStream().Of<AggregateIdentity>().ReactWith(Load);
}
public Bus(IServiceProvider serviceProvider, IEventTypeFinder eventTypeFinder, ISerializer serializer, ISnowflakeIdGenerator snowflakeIdGenerator, IEventStorage eventStorage)
{
ServiceProvider = serviceProvider;
this.eventTypeFinder = eventTypeFinder;
this.serializer = serializer;
this.snowflakeIdGenerator = snowflakeIdGenerator;
this.eventStorage = eventStorage;
}
public EventBuffer(ILogger <EventBuffer> logger, IProducerInfoContainer producerContainer, IProducer producer, IEventStorage eventStorage, IOptions <PoleEventBusOption> options)
{
this.logger = logger;
this.producerContainer = producerContainer;
this.producer = producer;
this.eventStorage = eventStorage;
this.options = options.Value;
}
public EventSourcingRepository(IEventStorage <TAggregate> eventStorage, ISnapshotStorage <TAggregate> snapshotStorage, IEventDispatcher eventDispatcher, TypeKeyDirectory typeKeyDirectory, Factory <TAggregate> aggregateFactory)
{
this.eventStorage = eventStorage;
this.snapshotStorage = snapshotStorage;
this.eventDispatcher = eventDispatcher;
this.typeKeyDirectory = typeKeyDirectory;
this.aggregateFactory = aggregateFactory;
}
protected virtual IEventStorage <K> GetEventStorage()
{
if (_eventStorage == null)
{
_eventStorage = ServiceProvider.GetService <IStorageContainer>().GetEventStorage <K, S>(GetType(), this);
}
return(_eventStorage);
}
protected async ValueTask <IEventStorage <K> > GetEventStorage()
{
if (_eventStorage == null)
{
_eventStorage = await ServiceProvider.GetService <IStorageContainer>().GetEventStorage <K, S>(GetType(), this);
}
return(_eventStorage);
}
public CommandProcessor(IEventStorage aggreagateStorage)
{
if (aggreagateStorage == null)
{
throw new ArgumentException("Value cannot be null", nameof(aggreagateStorage));
}
this.AggregateStorage = aggreagateStorage;
}
public PrometheusFailedEventGaugeProcessor(
ILogger <PrometheusFailedEventGaugeProcessor> logger,
IEventStorage eventstorage,
IOptions <PoleEventBusOption> poleOptions)
{
this.logger = logger;
this.eventstorage = eventstorage;
this.poleOptions = poleOptions.Value;
}
internal Session(IEventStorage eventStorage)
{
_eventStorage = eventStorage;
if (_current != null)
{
throw new InvalidOperationException("Cannot nest unit of work");
}
_current = this;
}
//移除不活跃的订阅（默认24小时前）
protected void RemoveSubscriber(IEventStorage storage, EventMessage subscriber)
{
//判断队列是否有消息
var queueName = subscriber.ChannelID;
var qkey = this.SubscriberQueuePrefix + queueName;
var qlength = storage.GetLength(qkey);
if (qlength <= 0) //没有任何消息，忽略（实际上此队列在Redis中是不存在的）
{
return;
}
//24小时前
var now = DateTime.Now;
var minTicks = subscriber.Priority > 0 ? now.AddSeconds(-subscriber.Priority).Ticks : now.AddHours(-24).Ticks;
//获取最后一次活跃时间
var qfkey = this.SubscriberRefKeyPrefix + queueName;
var bytes = storage.Get(qfkey);
var remove = true;
if (bytes != null && bytes.Length > 0)
{
var ticks = BitConverter.ToInt64(bytes, 0);
if (ticks > minTicks) //还是活跃的
{
remove = false;
}
}
if (!remove) //此订阅还是活跃的，忽略
{
return;
}
//把订阅信息移除
var sk = this.SubscriberKeyPrefix + queueName;
storage.Delete(sk);
//把队列里的消息引用数-1
var mlist = new List <string>();
do
{
bytes = storage.RightPop(qkey);
if (bytes != null && bytes.Length > 0)
{
var messageId = bytes.ToGuidString();
mlist.Add(this.MessageRefPrefix + messageId);
}
} while(bytes != null);
//把订阅队列移除
storage.Pipeline(s => {
foreach (var msgid in mlist)
{
s.Decrement(msgid);
}
s.Delete(qkey);
});
}
public SchedulingService(
ILogger <SchedulingService> logger,
IGuildPropertyStorage guildPropertyStorage,
IEventStorage eventStorage,
MessagingService messagingService)
{
_logger = logger;
_guildPropertyStorage = guildPropertyStorage;
_eventStorage = eventStorage;
_messagingService = messagingService;
}
public PendingMessageRetryProcessor(IEventStorage eventStorage, IOptions <PoleEventBusOption> options, ILogger <PendingMessageRetryProcessor> logger,
IProducerInfoContainer producerContainer, ISerializer serializer, IProducer producer, IEventBuffer eventBuffer)
{
this.eventStorage = eventStorage;
this.options = options.Value ?? throw new Exception($"{nameof(PoleEventBusOption)} Must be injected");
this.logger = logger;
this.producerContainer = producerContainer;
this.serializer = serializer;
this.producer = producer;
this.eventBuffer = eventBuffer;
}
public SnapshotRepository(
IEventStorage eventStorage,
ISnapshotStorage snapshotStorage,
ISnapshotStrategy snapshotStrategy,
IDomainEventMediator domainEventMediator)
{
_snapshotStorage = snapshotStorage ?? throw new ArgumentNullException(nameof(snapshotStorage));
_snapshotStrategy = snapshotStrategy ?? throw new ArgumentNullException(nameof(snapshotStrategy));
_eventStorage = eventStorage ?? throw new ArgumentNullException(nameof(eventStorage));
_domainEventMediator = domainEventMediator ?? throw new ArgumentNullException(nameof(domainEventMediator));
}
public ExpiredEventsCollectorProcessor(
ILogger <ExpiredEventsCollectorProcessor> logger,
IEventStorageInitializer initializer,
IEventStorage eventstorage,
IOptions <PoleEventBusOption> poleOptions)
{
this.logger = logger;
this.initializer = initializer;
this.eventstorage = eventstorage;
this.poleOptions = poleOptions.Value;
}
public static async Task <List <IEvent> > DrainUntilHasEvents(this IEventStorage storage)
{
while (true)
{
var evt = await storage.DrainEvents().ConfigureAwait(false);
if (evt.Any())
{
return(evt);
}
await Task.Delay(100).ConfigureAwait(false);
}
}
public EventRecorder(
ILogger <EventRecorder> logger,
AppSettings appSettings,
ICheckpointStorage dateStorage,
IMailgunEventRetriever mailgunEventRetriever,
IEventStorage eventStorage)
{
this.logger = logger;
this.appSettings = appSettings;
this.dateStorage = dateStorage;
this.mailgunEventRetriever = mailgunEventRetriever;
this.eventStorage = eventStorage;
}
private void reset()
{
_session = (QuerySession)_store.QuerySession();
_storage = _session.EventStorage();
_statement = new EventStatement(_storage)
{
Filters = _filters
};
_handler = (IQueryHandler <IReadOnlyList <IEvent> >) new ListQueryHandler <IEvent>(_statement, _storage);
_cancellation = new CancellationTokenSource(5.Seconds());
_cancellation.Token.Register(teardown);
}
public RabbitMQEventBus(IConfiguration configuration, ILogger <RabbitMQEventBus> logger, IEventStorage eventStorage)
{
this.connection = new RabbitMQPersistentConnection(configuration, logger);
policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.Or <InvalidOperationException>()
.WaitAndRetry(retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
logger.LogWarning(ex.ToString());
});
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.consumerChannel = CreateConsumerChannel();
this.eventStorage = eventStorage;
}
public EventFetcher(IDocumentStore store, ISqlFragment[] filters)
{
_store = store;
_filters = filters;
using var session = (QuerySession)_store.QuerySession();
_storage = session.EventStorage();
_statement = new EventStatement(_storage)
{
Filters = _filters
};
_handler = new ListQueryHandler <IEvent>(_statement, _storage);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Order order = CreateOrder();
EventStorage.Event <Order> @event = new Event <Order>();
@event.AggregateType = "Order";
@event.AggregateValue = order;
@event.EventVersion = 1;
@event.EventPublishedName = "NewOrder";
IEventStorage <Order> storage = EventStorageFactory <Order> .GetDefaultEventStorage();
storage.CommitChangesAsync(@event);
}
/// <summary>
/// API Tracker constructor
/// </summary>
/// <param name="batchWorkersCount">
/// <see cref="int"/> task workers count
/// </param>
/// <param name="batchPoolSize">
/// <see cref="int"/> task pool size
/// </param>
public IronSourceAtomTracker(int batchWorkersCount = BATCH_WORKERS_COUNT_, int batchPoolSize = BATCH_POOL_SIZE_)
{
api_ = new IronSourceAtom();
eventPool_ = new BatchEventPool(batchWorkersCount, batchPoolSize);
eventStorage_ = new QueueEventStorage();
streamData_ = new ConcurrentDictionary <string, string>();
random_ = new Random();
ThreadStart threadMethodHolder = new ThreadStart(this.TrackerHandler);
trackerHandlerThread_ = new Thread(threadMethodHolder);
trackerHandlerThread_.Start();
}
protected EventMessageHeader[] PopMessagesFromSubscribeQueue(IEventStorage storage, string queueName, int count)
{
var list = new List <EventMessageHeader>();
while (--count >= 0)
{
var msg = this.PopMessage(storage, queueName, true);
if (msg == null)
{
break;
}
list.Add(msg);
}
storage.Pipeline(s => list.ForEach(m => s.Decrement(this.MessageRefPrefix + m.MessageGuid)));
return(list.ToArray());
}
public ProjectionsRebuilder(IEventStorage eventStore, HandlerInvoker handlerInvoker)
{
_eventStore = eventStore;
_handlerInvoker = handlerInvoker;
}
public StateHelper(IEventStorage eventStore, IEventBus eventBus)
{
_eventStore = eventStore;
_eventBus = eventBus;
}
public SessionFactory(IEventStorage eventStorage)
{
_eventStorage = eventStorage;
}
