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; }