public CachingNode(ICalculationNode decoratedNode, ICycleGuard cycleGuard, IEventBuffer eventBuffer)
{
_decoratedNode = decoratedNode;
_cycleGuard = cycleGuard;
_eventBuffer = eventBuffer;
_decoratedNode.ValueChanged += DecoratedNodeOnValueChanged;
}
public UnitOfWork(IProducerInfoContainer producerContainer, IEventTypeFinder eventTypeFinder,
ISerializer serializer, IEventBuffer eventBuffer, IServiceProvider serviceProvider)
{
this.producerContainer = producerContainer;
this.eventTypeFinder = eventTypeFinder;
this.serializer = serializer;
this.eventBuffer = eventBuffer;
this.ServiceProvider = serviceProvider;
}
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 BacketController(IClusterClient clusterClient, ILogger <BacketController> logger, IProducerInfoContainer producerContainer,
IEventTypeFinder eventTypeFinder, ISerializer serializer, ISnowflakeIdGenerator snowflakeIdGenerator, IEventBuffer eventBuffer, IServiceProvider serviceProvider)
{
this.clusterClient = clusterClient;
this.logger = logger;
this.producerContainer = producerContainer;
this.eventTypeFinder = eventTypeFinder;
this.serializer = serializer;
this.snowflakeIdGenerator = snowflakeIdGenerator;
this.eventBuffer = eventBuffer;
this.serviceProvider = serviceProvider;
}
public ITask Execute(IFileSystem fileSystem, IEventBuffer buffer, FeedBuilder feedBuilder, Action<FeedMappingsChangedEventArgs> notifyMappingsChanged)
{
IEnumerable<Event> events = buffer.Take(QueryingEvents.BatchSize);
Log.DebugFormat("Requerying events. Number of events found: [{0}].", events.Count());
if (events.Count().Equals(0))
{
return new SavingRecentEventsFeed(recentEventsFeed);
}
return new UpdatingRecentEventsFeed(recentEventsFeed, events);
}
private static (ICalculationGraph, ICalculationGraphPruner) CreateCalculationGraph(
TransformableNodeFactory nodeFactory, StatRegistry statRegistry, ValueTransformer valueTransformer,
IEventBuffer eventBuffer)
{
var coreGraph = new CoreCalculationGraph(
s => CreateStatGraph(nodeFactory, valueTransformer, eventBuffer, s), nodeFactory);
var eventGraph = new CalculationGraphWithEvents(coreGraph);
var defaultPruningRuleSet = new DefaultPruningRuleSet(statRegistry);
var defaultPruner = new CalculationGraphPruner(eventGraph, defaultPruningRuleSet);
var userSpecifiedValuePruningRuleSet =
new UserSpecifiedValuePruningRuleSet(defaultPruningRuleSet, statRegistry);
var userSpecifiedValuePruner =
new CalculationGraphPruner(eventGraph, userSpecifiedValuePruningRuleSet);
var pruner = new CompositeCalculationGraphPruner(defaultPruner, userSpecifiedValuePruner);
eventGraph.StatAdded += StatAdded;
eventGraph.StatRemoved += StatRemoved;
eventGraph.ModifierAdded += ModifierAdded;
eventGraph.ModifierRemoved += ModifierRemoved;
return(eventGraph, pruner);
void StatAdded(IStat stat)
{
statRegistry.Add(stat);
valueTransformer.AddBehaviors(stat.Behaviors);
defaultPruner.StatAdded(stat);
userSpecifiedValuePruner.StatAdded(stat);
}
void StatRemoved(IStat stat)
{
statRegistry.Remove(stat);
valueTransformer.RemoveBehaviors(stat.Behaviors);
defaultPruner.StatRemoved(stat);
userSpecifiedValuePruner.StatRemoved(stat);
}
void ModifierAdded(Modifier modifier)
{
defaultPruner.ModifierAdded(modifier);
userSpecifiedValuePruner.ModifierAdded(modifier);
}
void ModifierRemoved(Modifier modifier)
{
defaultPruner.ModifierRemoved(modifier);
userSpecifiedValuePruner.ModifierRemoved(modifier);
}
}
private static IStatGraph CreateStatGraph(
TransformableNodeFactory nodeFactory, ValueTransformer valueTransformer, IEventBuffer eventBuffer,
IStat stat)
{
var paths = new PathDefinitionCollection(BufferingEventViewProvider.Create(
new ObservableCollection <PathDefinition>(),
new EventBufferingObservableCollection <PathDefinition>(eventBuffer)));
var coreGraph = new CoreStatGraph(new StatNodeFactory(eventBuffer, nodeFactory, stat), paths);
return(new StatGraphWithEvents(coreGraph, NodeAdded, NodeRemoved));
void NodeAdded(NodeSelector selector)
{
var node = coreGraph.Nodes[selector];
var transformable = nodeFactory.TransformableDictionary[node];
valueTransformer.AddTransformable(stat, selector, transformable);
}
void NodeRemoved(NodeSelector selector) => valueTransformer.RemoveTransformable(stat, selector);
}
internal EventManager(ISequenceResolver sequenceResolver, IEventResolver eventResolver, int timeout, IEventBuffer eventBuffer, bool disposeBuffer)
{
Trace.WriteLine("EventManager.ctor(ISequenceResolver sequenceResolver, IEventResolver eventResolver, IEventBuffer eventBuffer, int timeout, bool disposeBuffer)");
Guard.Against.Null(() => sequenceResolver);
Guard.Against.Null(() => eventResolver);
Guard.Against.Null(() => eventBuffer);
Guard.Against.NegativeTimeout(() => timeout);
this.sequenceResolver = sequenceResolver;
this.eventResolver = eventResolver;
this.eventBuffer = eventBuffer;
this.timeout = timeout;
this.disposeBuffer = disposeBuffer;
Trace.WriteLine("EventManager.ctor: Timer.ctor(Timeout.Infinite, Timeout.Infinite)");
this.timer = new Timer(state => this.ResolveMissingEvents(this.cancellationTokenSource.Token), null, Timeout.Infinite, Timeout.Infinite);
// NOTE (Cameron): This will immediately resolve all missing events from the specified sequence number (eg. event re-playing).
this.IsEventReplaying = true;
new Task(() => this.ResolveMissingEvents(this.cancellationTokenSource.Token)).Start();
}
private static CachingNode CreateSut(
ICalculationNode decoratedNode, ICycleGuard cycleGuard = null, IEventBuffer eventBuffer = null)
=> new CachingNode(decoratedNode, cycleGuard ?? Mock.Of <ICycleGuard>(), eventBuffer ?? new EventBuffer());
private static EventBufferingObservableCollection <int> CreateSut(IEventBuffer eventBuffer = null) => new EventBufferingObservableCollection <int>(eventBuffer ?? new EventBuffer());
private static NodeCollection <IStat> CreateNodeCollection(IEventBuffer eventBuffer = null) => new NodeCollection <IStat>(eventBuffer ?? new EventBuffer());
public StatNodeFactory(IEventBuffer eventBuffer, INodeFactory nodeFactory, IStat stat)
{
_eventBuffer = eventBuffer;
_nodeFactory = nodeFactory;
_stat = stat;
}
public ITask Execute(IFileSystem fileSystem, IEventBuffer buffer, FeedBuilder feedBuilder, Action<FeedMappingsChangedEventArgs> notifyMappingsChanged)
{
RecentEventsFeed feed = feedBuilder.CreateRecentEventsFeed(new FeedMapping(Id.InitialValue), PrevArchiveLinkGenerator.Null);
return new UpdatingRecentEventsFeed(feed, events);
}
public EventBufferingObservableCollection(IEventBuffer eventBuffer) => _eventBuffer = eventBuffer;
public EventManager(ISequenceResolver sequenceResolver, IEventBuffer eventBuffer)
: this(sequenceResolver, new NullEventResolver(), Timeout.Infinite, eventBuffer, false)
{
}
public ITask Execute(IFileSystem fileSystem, IEventBuffer buffer, FeedBuilder feedBuilder, Action<FeedMappingsChangedEventArgs> notifyMappingsChanged)
{
notifyMappingsChanged.Invoke(recentEventsFeed.CreateFeedMappingsChangedEventArgs());
return new Terminate();
}
public EventManager(ISequenceResolver sequenceResolver, IEventResolver eventResolver, int timeout, IEventBuffer eventBuffer)
: this(sequenceResolver, eventResolver, timeout, eventBuffer, false)
{
}
public NodeFactory(IEventBuffer eventBuffer) => _eventBuffer = eventBuffer;
public ITask Execute(IFileSystem fileSystem, IEventBuffer buffer, FeedBuilder feedBuilder, Action<FeedMappingsChangedEventArgs> notifyMappingsChanged)
{
throw new InvalidOperationException();
}
