public AggregateRoot(AggregateRootDependencies <TState> dependencies, string context, string aggregateRootName)
{
_logger = dependencies.Logger;
_stateRepo = dependencies.StateRepo;
_streamIdBuilder = dependencies.StreamIdBuilder;
_streamClientFactory = dependencies.StreamClientFactory;
_resolver = dependencies.EventResolver;
_context = context;
_aggregateRootName = aggregateRootName;
}
public ProjectorDependencies(IStandardLogger logger, ISubscriberFactory subscriberFactory, SubscriberFactoryOptions subscriberFactoryOptions, IStreamClientFactory streamClientFactory, IStreamStateRepo streamStateRepo, IBusinessEventResolver eventResolver, IList <SubscriptionStreamId> subscriptionStreamIds)
{
Logger = logger;
SubscriberFactory = subscriberFactory;
StreamClientFactory = streamClientFactory;
StreamStateRepo = streamStateRepo;
EventResolver = eventResolver;
SubscriberFactoryOptions = subscriberFactoryOptions;
SubscriptionStreamIds = subscriptionStreamIds;
}
public AggregateRootDependencies(
IStandardLogger logger,
IAggregateRootStateRepo <TState> stateRepo, IStreamIdBuilder streamIdBuilder,
IStreamClientFactory streamClientFactory, IBusinessEventResolver eventResolver)
{
Logger = logger;
StateRepo = stateRepo;
StreamIdBuilder = streamIdBuilder;
StreamClientFactory = streamClientFactory;
EventResolver = eventResolver;
}
public FlatFileAggregateRootStateRepo(IStreamClientFactory streamClientFactory, Func <string, TState> stateConstructor, string basePath)
{
_streamClientFactory = streamClientFactory;
_stateConstructor = stateConstructor;
_basePath = Path.GetFullPath(basePath);
// Initialize state storage directory.
if (!Directory.Exists(_basePath))
{
Directory.CreateDirectory(_basePath);
}
}
public Subscriber(
IStandardLogger logger, IStreamClientFactory streamClientFactory, ISubscriptionListener subscriptionListener,
IResolutionManager resolutionManager, ISortingManager sortingManager, IHandlingManager handlingManager,
IStreamStateRepo streamStateRepo,
SubscriberOptions options)
{
_logger = logger;
_streamClientFactory = streamClientFactory;
_subscriptionListener = subscriptionListener;
_resolutionManager = resolutionManager;
_sortingManager = sortingManager;
_handlingManager = handlingManager;
_streamStateRepo = streamStateRepo;
_options = options;
}
public ISubscriber Create(IStandardLogger logger, IStreamClientFactory streamClientFactory, IStreamStateRepo streamStateRepo, IBusinessEventResolver resolver, ISubscriberEventSorter sorter, ISubscriberEventHandler handler, SubscriberFactoryOptions factoryOptions, IList <SubscriptionStreamId> subscriptionStreamIds)
{
var handlingManagerAwaiter = new HandlingManagerAwaiter(factoryOptions.MaxParallelHandlerExecutions);
var handlingQueue = new HandlingQueue(new QueueAwaiter(), factoryOptions.MaxHandlingQueuesSharedSize);
var handlerRunner = new HandlingManagerHandlerRunner(logger, handlingManagerAwaiter, streamStateRepo, handler);
var handlerTasks = new HandlingManagerTaskCollection();
var handlingManager = new HandlingManager(logger, handlingManagerAwaiter, streamStateRepo, handlingQueue, handlerRunner, handlerTasks);
var sortingQueue = new SortingQueue(new QueueAwaiter(), factoryOptions.MaxSortingQueueSize);
var sortingManager = new SortingManager(logger, sortingQueue, sorter, handlingManager);
var resolutionQueue = new ResolutionQueue(new QueueAwaiter(), factoryOptions.MaxResolutionQueueSize);
var resolutionManager = new ResolutionManager(logger, resolver, streamStateRepo, resolutionQueue, sortingManager);
var listener = new SubscriptionListener(logger, streamClientFactory, resolutionManager);
var subscriberOptions = new SubscriberOptions(subscriptionStreamIds);
return(new Subscriber(logger, streamClientFactory, listener, resolutionManager, sortingManager, handlingManager, streamStateRepo, subscriberOptions));
}
public DatabaseAggregateRootStateRepo(IStreamClientFactory streamClientFactory, Func <string, TState> stateConstructor, int saveBatchSize)
{
_streamClientFactory = streamClientFactory;
_stateConstructor = stateConstructor;
_saveBatchSize = saveBatchSize;
}
public SubscriptionListener(IStandardLogger logger, IStreamClientFactory streamClientFactory, IResolutionManager resolutionManager)
{
_logger = logger;
_streamClientFactory = streamClientFactory;
_resolutionManager = resolutionManager;
}
private const int SAVE_BATCH_SIZE = 30; // How many events to apply before saving to database.
// private static Func<string, EmailBuilderState> = (regionId) => new Email
public EmailBuilderStateRepo(IStreamClientFactory streamClientFactory, EmailBuilderStateFactory stateFactory)
: base(streamClientFactory, (regionId) => stateFactory.Create(regionId), SAVE_BATCH_SIZE)
{
}
