private void Application_Startup(object sender, StartupEventArgs e)
{
string parentDataSavePath = Path.Combine(Environment.CurrentDirectory, "Sourced Data");
Directory.CreateDirectory(parentDataSavePath);
// TODO: create DI bindings container
// TODO: create IFactory
IEventReader <EventArgs> keyboardSourcer = new KeyboardEventSourcer(new Keyboard());
IEventReader <EventArgs> mouseSourcer = new MouseEventSourcer(new Mouse());
var readers = new IEventReader <EventArgs>[] { keyboardSourcer, mouseSourcer };
foreach (var reader in readers)
{
Directory.CreateDirectory(Path.Combine(parentDataSavePath, reader.Name));
}
EventSourcerEngine engine = new EventSourcerEngine(
"Keyboard and Mouse data sourcing engine",
new ThreadedTimer(TimeSpan.FromMinutes(1).TotalMilliseconds),
readers);
ContextMenu menu = App.Current.TryFindResource(App.TrayContextMenuControlName) as ContextMenu;
SystemTrayControl tray = new SystemTrayControl(menu, UiResources.App, App.Name);
this.mainWindow = new MainWindow(engine, tray, parentDataSavePath);
this.mainWindow.Hide();
}
public FlightEventProcessor(ILogger logger, IEventReader eventReader, IErrorsProcessingHandler errorsProcessingHandler, IEventProcessingHandler eventProcessingHandler)
{
_logger = logger;
_eventReader = eventReader;
_errorsProcessingHandler = errorsProcessingHandler;
_eventProcessingHandler = eventProcessingHandler;
}
public void Stop()
{
EnsureStarted();
_headEventReader.Pause();
_headEventReader = null;
_started = false;
}
public FileSystemLoader(RepositoryHierarchy repositoryHierarchy, IEventReader eventReader)
{
if (repositoryHierarchy == null) throw new ArgumentNullException("repositoryHierarchy");
if (eventReader == null) throw new ArgumentNullException("eventReader");
_repositoryHierarchy = repositoryHierarchy;
_eventReader = eventReader;
}
internal EventReaderLink(IEventReader reader, IEventLog log, string name)
{
this.reader = reader;
this.log = log;
this.name = name;
reader.EventData += Log;
}
public RiakLoader(IRiakClient riakClient, IEventReader eventReader)
{
if (riakClient == null) throw new ArgumentNullException("riakClient");
if (eventReader == null) throw new ArgumentNullException("eventReader");
_riakClient = riakClient;
_eventReader = eventReader;
}
public static IDisposable ListenWhile <T>(this IEventReader <T> reader, ICell <bool> listenCondition, Action <T> act)
{
var disp = new DoubleDisposable();
disp.first = listenCondition.Bind(val =>
{
if (val)
{
if (disp.disposed)
{
return;
}
if (disp.second != null)
{
throw new ZergRushException();
}
disp.second = reader.Subscribe(act);
}
else if (disp.second != null)
{
disp.second.Dispose();
disp.second = null;
}
});
return(disp);
}
public Task <BucketContainer> ProcessEventsAsync(IEventReader reader, bool enablePayloads)
{
var progressManager = new MultiOperationsProgressManager(_progressHandler);
IProgress <int> operationProgress = progressManager.AddOperation();
var readingTask = reader.StartReadingEvents(
enablePayloads,
operationProgress
);
operationProgress = progressManager.AddOperation();
var processTask = StartProcessingEventsWithPipeline(
reader,
operationProgress
);
return(Task.WhenAll(readingTask, processTask)
.ContinueWith(
task => {
if (task.IsFaulted)
{
var tcs = new TaskCompletionSource <BucketContainer>();
tcs.SetException(task.Exception);
return tcs.Task;
}
return processTask;
}
).Unwrap());
}
public StateRehydrator(IEventReader eventReader,
IEventHandler <T> eventHandler)
{
_snapshotReader = DefaultSnapshotReader.Instance;
_eventReader = eventReader;
_eventHandler = eventHandler;
}
internal RadonExecutor(IEmailConfiguration emailConfig, IFilterConfiguration filterConfig, IEventIdentificationStore eventIdentificationStore, IEventReader eventReader)
{
EmailConfig = emailConfig;
_filterConfig = filterConfig;
_eventIdentificationStore = eventIdentificationStore;
_eventReader = eventReader;
}
/// <summary>
/// Connect to Log
/// </summary>
/// <param name="reader">The reader</param>
/// <param name="log">Log</param>
/// <param name="name">Name of the reader</param>
public static void ConnectLog(this IEventReader reader, IEventLog log, string name)
{
if (reader is INativeReader)
{
readers.Add(new EventReaderLink(reader, log, name));
}
}
void IEventLog.Write(IEventReader reader, string name, object[] output, DateTime time)
{
Tuple <string, object[], DateTime> t = new Tuple <string, object[], DateTime>(name, output, time);
t.TransformSave();
Save(t, time);
// formatter.Serialize(stream, t);
}
public MessagingExtensionService(
IMapper mapper,
IEventReader eventReader
)
{
this.mapper = mapper;
this.eventReader = eventReader;
}
public StateRehydrator(ISnapshotReader <T> snapshotReader,
IEventReader eventReader,
IEventHandler <T> eventHandler)
{
_snapshotReader = snapshotReader;
_eventReader = eventReader;
_eventHandler = eventHandler;
}
/// <summary>
/// Disposes itself
/// </summary>
public void Dispose()
{
if (reader != null)
{
reader.EventData -= Log;
}
reader = null;
}
public SimpleStateRehydrator(Func <Guid, T> seedFactory,
IEventReader eventReader,
IEventHandler <T> eventHandler)
{
_seedFactory = seedFactory;
_eventReader = eventReader;
_eventHandler = eventHandler;
}
public void TestFixtureSetUp()
{
_mockReportSender = MockRepository.GenerateMock <IReportSender>();
_mockEmailConfiguration = MockRepository.GenerateMock <IEmailConfiguration>();
_mockFilterConfiguration = MockRepository.GenerateMock <IFilterConfiguration>();
_mockEventIdentificationStore = MockRepository.GenerateMock <IEventIdentificationStore>();
_mockEventReader = MockRepository.GenerateMock <IEventReader>();
_radonExecutor = new RadonExecutor(_mockEmailConfiguration, _mockFilterConfiguration, _mockEventIdentificationStore, _mockEventReader);
}
public static Task <IEnumerable <object> > QueryEvents(
this IEventReader eventReader, Guid streamId)
{
if (eventReader is null)
{
throw new ArgumentNullException(nameof(eventReader));
}
return(eventReader.QueryEvents(streamId, fromVersion: 1));
}
// On each event it makes |\____|\_______|\_____....
public static ICell <float> SignalTrigger(this IEventReader e, float decayTime, Action <IDisposable> connectionSink)
{
TriggerCell cell = new TriggerCell {
decay = decayTime
};
connectionSink(UnityExecutor.instance.AddUpdatable(cell));
connectionSink(e.Subscribe(cell.Reset));
return(cell);
}
public static CellOfSin SignalSin(this IEventReader e, float scale, float speed, float resetVal, Action <IDisposable> connectionSink)
{
CellOfSin cell = new CellOfSin {
scale = scale, speed = speed
};
connectionSink(UnityExecutor.instance.AddUpdatable(cell));
connectionSink(e.Subscribe(() => cell.Reset(resetVal)));
return(cell);
}
public EventStreamReader(Stream innerStream, IEventReader eventReader, Action<EventStreamReaderState> beforeStateChange, Action<EventStreamReaderState> afterStateChange)
{
if (innerStream == null) throw new ArgumentNullException("innerStream");
if (eventReader == null) throw new ArgumentNullException("eventReader");
_innerStream = innerStream;
_eventReader = eventReader;
_beforeStateChange = beforeStateChange;
_afterStateChange = afterStateChange;
}
public BotService(
IQueryCommands queryCommands,
ITemplateService templateService,
IEventReader eventReader
)
{
this.queryCommands = queryCommands;
this.templateService = templateService;
this.eventReader = eventReader;
}
public SnapshottedStateRehydrator(Func <Guid, T> seedFactory,
ISnapshotReader <T> snapshotReader,
IEventReader eventReader,
IEventHandler <T> eventHandler)
{
_seedFactory = seedFactory;
_snapshotReader = snapshotReader;
_eventReader = eventReader;
_eventHandler = eventHandler;
}
public static async Task SingleMessageAsync(this IEventReader reader)
{
bool finished = false;
var waiting = reader.Subscribe(() => { finished = true; });
while (!finished)
{
await frame;
}
}
public async Task QueryEvents_relays_correctly(
IEventReader reader, Guid streamId, IEnumerable <object> events)
{
long fromVersion = 1;
Mock.Get(reader).Setup(x => x.QueryEvents(streamId, fromVersion)).ReturnsAsync(events);
IEnumerable <object> actual = await reader.QueryEvents(streamId);
actual.Should().BeSameAs(events);
}
public ReplicatorService(
IEventReader reader,
SinkPipeOptions sinkOptions,
PreparePipelineOptions prepareOptions,
ICheckpointStore checkpointStore
)
{
_reader = reader;
_sinkOptions = sinkOptions;
_prepareOptions = prepareOptions;
_checkpointStore = checkpointStore;
}
public AggregateStore(
IEventStore eventStore,
TReader archiveReader,
Func <StreamEvent, StreamEvent>?amendEvent = null,
AggregateFactoryRegistry?factoryRegistry = null
)
{
_amendEvent = amendEvent ?? (x => x);
_factoryRegistry = factoryRegistry ?? AggregateFactoryRegistry.Instance;
_eventStore = Ensure.NotNull(eventStore);
_archiveReader = Ensure.NotNull(archiveReader);
}
public static async Task <T> SingleMessageAsync <T>(this IEventReader <T> reader)
{
T result = default(T);
bool finished = false;
var waiting = reader.Subscribe(res => { result = res; finished = true; });
while (!finished)
{
await frame;
}
return(result);
}
/// <summary>
/// Creates a new instance of the default aggregate store
/// </summary>
/// <param name="reader"></param>
/// <param name="writer"></param>
/// <param name="amendEvent"></param>
/// <param name="factoryRegistry"></param>
public AggregateStore(
IEventReader reader,
IEventWriter writer,
Func <StreamEvent, StreamEvent>?amendEvent = null,
AggregateFactoryRegistry?factoryRegistry = null
)
{
_amendEvent = amendEvent ?? (x => x);
_factoryRegistry = factoryRegistry ?? AggregateFactoryRegistry.Instance;
_eventReader = Ensure.NotNull(reader);
_eventWriter = Ensure.NotNull(writer);
}
public EventStreamVerifier(Stream innerStream, IEventReader eventReader)
{
if (innerStream == null) throw new ArgumentNullException("innerStream");
if (eventReader == null) throw new ArgumentNullException("eventReader");
_innerStream = innerStream;
_eventReader = eventReader;
Debug.Assert(innerStream.CanRead);
Debug.Assert(innerStream.CanWrite);
Debug.Assert(innerStream.CanSeek);
}
public void Setup()
{
_mockEventSource = MockRepository.GenerateMock <IEventReader>();
_mockEventIdentificationStore = MockRepository.GenerateMock <IEventIdentificationStore>();
_events = Enumerable.Range(0, 10).Select(i => new LogEvent {
Message = i.ToString(), TimeGenerated = DateTime.Now.AddHours(-i)
}).ToList();
_mockEventSource.Expect(e => e.ReadEvents()).Return(_events);
_target = new AlreadyReportedFilter(_mockEventSource, _mockEventIdentificationStore);
}
public void Start(Guid eventReaderId, IEventReader eventReader)
{
if (_started)
{
throw new InvalidOperationException("Already started");
}
_eventReaderId = eventReaderId;
_headEventReader = eventReader;
//Guid.Empty means head distribution point
_started = true; // started before resume due to old style test with immediate callback
_headEventReader.Resume();
}
private void CreateActual()
{
IEventReader a;
if (eventName.Length == 0)
{
if (eventReader.EventNames != null)
{
if (eventReader.EventNames.Length == 1)
{
eventName = eventReader.EventNames[0];
}
}
}
if (eventName.Length != 0)
{
a = eventReader[eventName];
}
else
{
a = eventReader;
}
if (actual == a)
{
return;
}
if (actual != null)
{
actual.EventData -= PostEvent;
}
actual = a;
List <Tuple <string, object> > at = actual.Types;
if (actual is IAssociatedObject & children[0] != actual)
{
children = new IAssociatedObject[] { actual as IAssociatedObject };
}
types = at;
actual.EventData += PostEvent;
if (actual is IMeasurements)
{
child = actual as IMeasurements;
update = () =>
{
if (shouldUpdate)
{
child.IsUpdated = false;
child.UpdateMeasurements();
}
};
}
}
// On each event it makes /--\____/--\________....
public static ICell <float> SignalSpike(this IEventReader e, float attack, float plato, float decay, Action <IDisposable> connectionSink)
{
SpikeCell cell = new SpikeCell
{
attackPoint = attack,
platoPoint = attack + plato,
decayPoint = attack + plato + decay
};
connectionSink(UnityExecutor.instance.AddUpdatable(cell));
connectionSink(e.Subscribe(cell.Reset));
return(cell);
}
public EventReaderWriterPair(IEventReader reader, IEventWriter writer)
: this()
{
Reader = reader;
Writer = writer;
}
public RiakLoader(IEventReader eventReader)
{
if (eventReader == null) throw new ArgumentNullException("eventReader");
_eventReader = eventReader;
}
public void Stop()
{
EnsureStarted();
_headEventReader.Pause();
_headEventReader = null;
_started = false;
}
public void Start(Guid eventReaderId, IEventReader eventReader)
{
if (_started)
throw new InvalidOperationException("Already started");
_eventReaderId = eventReaderId;
_headEventReader = eventReader;
//Guid.Empty means head distribution point
_started = true; // started before resume due to old style test with immediate callback
_headEventReader.Resume();
}
public void Body(IEventReader eventReader)
{
Before(EventStreamReaderState.Body);
{
_innerReader.Body(eventReader);
}
After(EventStreamReaderState.Body);
}
public EventStreamReader(Stream innerStream, IEventReader eventReader)
: this(innerStream, eventReader, null, null)
{
}
