public void testQueryEvents() {
EventRegistry registry = EventRegistryFactory.forObjectContainer(db());
EventRecorder recorder = new EventRecorder(fileSession().lock());
registry.queryStarted().addListener(recorder);
registry.queryFinished().addListener(recorder);
Assert.areEqual(0, recorder.size());
Query q = db().query();
q.execute();
Assert.areEqual(2, recorder.size());
EventRecord e1 = recorder.get(0);
Assert.areSame(registry.queryStarted(), e1.e);
Assert.areSame(q, ((QueryEventArgs) e1.args).query());
EventRecord e2 = recorder.get(1);
Assert.areSame(registry.queryFinished(), e2.e);
Assert.areSame(q, ((QueryEventArgs) e2.args).query());
recorder.clear();
registry.queryStarted().removeListener(recorder);
registry.queryFinished().removeListener(recorder);
db().query().execute();
Assert.areEqual(0, recorder.size());
}
public AssertFailureEvent getLastAssertFailureEvent() {
return (AssertFailureEvent) eventRecorder.getLast(AssertFailureEvent.class);
}
private void recordCommand(Command command, CommandState state) {
eventRecorder.record(command.getClass().getName(), state.ordinal());
}
private Strongback(Configurator config, Strongback previousInstance) {
boolean start = false;
if (previousInstance != null) {
start = previousInstance.started.get();
// Terminates all currently-scheduled commands and stops the executor's thread (if running)
// ...
previousInstance.doShutdown();
strictExecutables = previousInstance.strictExecutables;
executables = previousInstance.executables;
switchReactor = previousInstance.switchReactor;
executables.unregister(previousInstance.dataRecorderDriver);
executables.unregister(previousInstance.eventRecorder);
executables.unregister(previousInstance.scheduler);
dataRecorderChannels = previousInstance.dataRecorderChannels;
excessiveExecutionHandler = previousInstance.excessiveExecutionHandler;
} else {
executables = new Executables();
strictExecutables = new Executables();
switchReactor = new AsyncSwitchReactor();
executables.register(switchReactor);
dataRecorderChannels = new DataRecorderChannels();
excessiveExecutionHandler = config.excessiveExecutorDelayHandler;
}
loggers = config.loggersSupplier.get();
clock = config.timeSystemSupplier.get();
// Create a new executor ...
strictExecutor =
PeriodicExecutor.roboRIONotifierWithFallback(
"strictExecutor",
config.executionPeriodInMilliseconds,
TimeUnit.MILLISECONDS,
strictExecutables,
clock,
loggers.apply("strictExecutor"),
monitorDelay("strictExecutor", 100, TimeUnit.MILLISECONDS));
dsPacketExecutor =
PeriodicExecutor.waitForDSPacketWithFallback(
"dsPacketExecutor",
config.driverstationExecutorTimeoutInMilliseconds,
TimeUnit.MILLISECONDS,
executables,
clock,
loggers.apply("dsPacketExecutor"),
monitorDelay("dsPacketExecutor", 100, TimeUnit.MILLISECONDS));
// Create a new event recorder ...
if (config.eventWriterFactory != null) {
eventRecorder = new AsyncEventRecorder(config.eventWriterFactory.get(), clock);
executables.register(eventRecorder);
} else {
eventRecorder = EventRecorder.noOp();
}
// Create a new scheduler that optionally records command state
// transitions. Note that we ignore everything in
// the previous instance's scheduler, since all commands would have been
// terminated (as intended) ...
CommandListener commandListener =
config.recordCommandStateChanges ? this::recordCommand : this::recordNoCommands;
scheduler = new Scheduler(loggers.apply("scheduler"), commandListener);
executables.register(scheduler);
// Create a new data recorder driver ...
dataRecorderDriver = new DataRecorderDriver(dataRecorderChannels, config.dataWriterFactory);
executables.register(dataRecorderDriver);
// Start this if the previous was already started ...
if (previousInstance != null && start) {
doStart();
}
}
