v1.0.0-rc.165 (#75)

* `rugnux --model` adopts the model's space group as a label where the data were merged in its enantiomorph, instead of reindexing the reflections - which swapped I(+) with I(-).
* `rugnux --model` warns, naming the atom, when the anomalous density at the model's atoms comes out inverted, which means the data and the model are in opposite hands.
* `rugnux --model` writes an anomalous difference map (`<prefix>_anom.ccp4`) when the merge kept the Bijvoet split, and names the ten model atoms it peaks highest on as `ANOMALOUS_SITE_01`..`_10`.
* `MEAN_ATOM_DENSITY_SIGMA` is read from the map by cubic rather than linear interpolation and comes out around a tenth higher; it is no longer comparable with the figure earlier versions printed.
* `rugnux --model` reads an mmCIF coordinate file as well as a PDB one, gzipped or not, taking the format from the file's content rather than its name.
* A model `rugnux --model` cannot use is reported as a `WARNING:` line in the results report instead of only in the log.
* The rugnux results report has a `10. MODEL VALIDATION` section when `--model` was given; `REPORT_VERSION` is 4, `WARNINGS` moves to section 11 and no existing key changed.
* The rugnux results report records how the run was invoked, what it cost and what it ran on: `COMMAND_LINE=`, `WALL_TIME=` and `GPU_COUNT=` / `GPU=`.
* rugnux says which GPUs it can see before it starts processing.
* `rugnux --export-unmerged` also writes `<prefix>_unmerged.mtz` on a `--no-merge` run, and is ignored on a run with no output prefix instead of writing a file called `_unmerged.mtz`.
* `/start` asks the writer whether the run can be written before the detector is armed, so a run whose master file already exists, or whose output directory cannot be created, is refused up front with the writer's own message. This needs the TCP image stream or the built-in HDF5 writer; the ZeroMQ stream is unchanged.
* A calibration that fails goes to `Error` carrying the reason instead of `Inactive`, so `/wait_till_done` and `/wait_until_running` report it; a cancelled calibration still goes to `Inactive`.
* `/wait_till_done` answers 500 with the message when a collection ended in an error. A cancelled collection and a collection that only triggered a warning still answer 200.
* A pending start failure is discarded by `/cancel` and `/deactivate`, as it already was by `/start` and `/initialize`.
* `/scan_result` no longer reports the previous run's images after a collection that failed to start, or after `/deactivate`.
* The TCP image stream protocol version is 4. `jfjoch_writer` and `jfjoch_broker` have to be of the same release, as before.

Reviewed-on: #75

tests/JFJochStateMachineTest.cpp

@@ -355,3 +355,198 @@ TEST_CASE("JFJochStateMachine_CalibrationFailure") {
     REQUIRE(calibrated.GetStatus().state == JFJochState::Idle);
     REQUIRE(calibrated.GetStatus().message_severity == BrokerStatus::MessageSeverity::Success);
 }
+
+namespace {
+    // Holds the run open until the test lets go, so a cancel lands while the collection is running
+    // instead of racing its end.
+    class GatedPusher : public ImagePusher {
+        std::atomic<bool> released{true};
+    public:
+        void Hold() { released = false; }
+        void Release() { released = true; }
+        void StartDataCollection(StartMessage &) override {}
+        bool EndDataCollection(const EndMessage &) override { return true; }
+        bool SendImage(const uint8_t *, size_t, int64_t) override {
+            while (!released)
+                std::this_thread::sleep_for(1ms);
+            return true;
+        }
+        bool SendCalibration(const CompressedImage &) override { return true; }
+        std::string PrintSetup() const override { return "GatedPusher"; }
+        ImagePusherType GetType() const override { return ImagePusherType::Test; }
+    };
+
+    // A writer that cannot finish the run - a rename that collides, a disk that filled up. It
+    // reaches the state machine from Stop(), not from Start(), which is the case that used to be
+    // reported as a run without problems.
+    class FinalizeFailingPusher : public ImagePusher {
+    public:
+        void StartDataCollection(StartMessage &) override {}
+        bool EndDataCollection(const EndMessage &) override { return true; }
+        bool SendImage(const uint8_t *, size_t, int64_t) override { return true; }
+        bool SendCalibration(const CompressedImage &) override { return true; }
+        std::string Finalize() override {
+            throw JFJochException(JFJochExceptionCategory::FileWriteError, "writer_finalize_failed_9876");
+        }
+        std::string PrintSetup() const override { return "FinalizeFailingPusher"; }
+        ImagePusherType GetType() const override { return ImagePusherType::Test; }
+    };
+}
+
+// /wait_till_done reads the severity of the end-of-run message to decide between 200 and 500, so
+// what the state machine puts there is what a script sees. A cancelled collection must not be an
+// error: it is incomplete by definition - the packets it never received would otherwise report
+// themselves - and calling every cancel a failure would make the endpoint useless.
+TEST_CASE("JFJochStateMachine_CancelledRunIsNotAnError") {
+    Logger logger("JFJochStateMachine_CancelledRunIsNotAnError");
+
+    DiffractionExperiment experiment(DetJF(2));
+    experiment.Conversion().PedestalG0Frames(0).NumTriggers(1).UseInternalPacketGenerator(true)
+            .ImagesPerTrigger(8).IncidentEnergy_keV(12.4);
+
+    AcquisitionDeviceGroup aq_devices;
+    for (int i = 0; i < experiment.GetDataStreamsNum(); i++)
+        aq_devices.Add(std::make_unique<HLSSimulatedDevice>(i, 64));
+
+    GatedPusher pusher;
+    JFJochReceiverService receiver_service(aq_devices, logger, pusher);
+
+    JFJochServices services(logger);
+    services.Receiver(&receiver_service);
+
+    JFJochStateMachine state_machine(experiment, services, logger);
+    state_machine.AddDetectorSetup(DetJF(2));
+    state_machine.DebugOnly_SetState(JFJochState::Idle);
+
+    DatasetSettings setup;
+    setup.ImagesPerTrigger(8).NumTriggers(1);
+
+    // A run that finished properly is a Success, so /wait_till_done answers 200.
+    REQUIRE_NOTHROW(state_machine.Start(setup));
+    REQUIRE_NOTHROW(state_machine.WaitTillMeasurementDone());
+    REQUIRE(state_machine.GetStatus().state == JFJochState::Idle);
+    REQUIRE(state_machine.GetStatus().message_severity == BrokerStatus::MessageSeverity::Success);
+
+    // The same run cancelled halfway. The gate keeps it running until the cancel is in.
+    pusher.Hold();
+    REQUIRE_NOTHROW(state_machine.Start(setup, true));
+
+    for (int i = 0; i < 400 && state_machine.GetStatus().state != JFJochState::Measuring; i++)
+        std::this_thread::sleep_for(25ms);
+    REQUIRE(state_machine.GetStatus().state == JFJochState::Measuring);
+
+    state_machine.Cancel();
+    pusher.Release();
+
+    REQUIRE_NOTHROW(state_machine.WaitTillMeasurementDone());
+    auto status = state_machine.GetStatus();
+    REQUIRE(status.state == JFJochState::Idle);
+    // Info, not Error and not Warning: the collection did what it was told to do.
+    REQUIRE(status.message_severity == BrokerStatus::MessageSeverity::Info);
+    REQUIRE_THAT(status.message.value_or(""), Catch::Matchers::ContainsSubstring("cancelled"));
+
+    // The run really was short - what makes this test worth having is that the incompleteness did
+    // not get reported ahead of the cancel.
+    REQUIRE(state_machine.GetMeasurementStatistics()->cancelled);
+}
+
+// A writer that failed while the run was being finalized arrives from Stop(), which leaves the
+// state Idle - the detector is still usable - and says so only in the severity. /wait_till_done
+// turns that into a 500 with the writer's message rather than reporting a good collection.
+TEST_CASE("JFJochStateMachine_WriterFailureAtEndIsAnError") {
+    Logger logger("JFJochStateMachine_WriterFailureAtEndIsAnError");
+
+    DiffractionExperiment experiment(DetJF(2));
+    experiment.Conversion().PedestalG0Frames(0).NumTriggers(1).UseInternalPacketGenerator(true)
+            .ImagesPerTrigger(4).IncidentEnergy_keV(12.4);
+
+    AcquisitionDeviceGroup aq_devices;
+    for (int i = 0; i < experiment.GetDataStreamsNum(); i++)
+        aq_devices.Add(std::make_unique<HLSSimulatedDevice>(i, 64));
+
+    FinalizeFailingPusher pusher;
+    JFJochReceiverService receiver_service(aq_devices, logger, pusher);
+
+    JFJochServices services(logger);
+    services.Receiver(&receiver_service);
+
+    JFJochStateMachine state_machine(experiment, services, logger);
+    state_machine.AddDetectorSetup(DetJF(2));
+    state_machine.DebugOnly_SetState(JFJochState::Idle);
+
+    DatasetSettings setup;
+    setup.ImagesPerTrigger(4).NumTriggers(1);
+
+    REQUIRE_NOTHROW(state_machine.Start(setup, true));
+    REQUIRE_NOTHROW(state_machine.WaitTillMeasurementDone());
+
+    auto status = state_machine.GetStatus();
+    REQUIRE(status.state == JFJochState::Idle);
+    REQUIRE(status.message_severity == BrokerStatus::MessageSeverity::Error);
+    REQUIRE_THAT(status.message.value_or(""),
+                 Catch::Matchers::ContainsSubstring("writer_finalize_failed_9876"));
+}
+
+namespace {
+    // Refuses the run before it starts, the way a writer refuses to overwrite a file that is
+    // already there. Records whether the collection was started anyway.
+    class PreflightRefusingPusher : public ImagePusher {
+    public:
+        std::atomic<bool> start_called{false};
+        void Preflight(StartMessage &) override {
+            throw JFJochException(JFJochExceptionCategory::FileWriteError, "preflight_refused_2468");
+        }
+        void StartDataCollection(StartMessage &) override { start_called = true; }
+        bool EndDataCollection(const EndMessage &) override { return true; }
+        bool SendImage(const uint8_t *, size_t, int64_t) override { return true; }
+        bool SendCalibration(const CompressedImage &) override { return true; }
+        std::string PrintSetup() const override { return "PreflightRefusingPusher"; }
+        ImagePusherType GetType() const override { return ImagePusherType::Test; }
+    };
+}
+
+// The pre-flight is the first thing a measurement does, so a run the writer will not accept is
+// refused before the receiver is built and before the detector is armed - which is what makes the
+// refusal free: there is no series left armed and waiting for a trigger to tear down.
+TEST_CASE("JFJochStateMachine_PreflightRefusesBeforeStarting") {
+    Logger logger("JFJochStateMachine_PreflightRefusesBeforeStarting");
+
+    DiffractionExperiment experiment(DetJF(2));
+    experiment.Conversion().PedestalG0Frames(0).NumTriggers(1).UseInternalPacketGenerator(true)
+            .ImagesPerTrigger(4).IncidentEnergy_keV(12.4).FilePrefix("preflight_refused");
+
+    AcquisitionDeviceGroup aq_devices;
+    for (int i = 0; i < experiment.GetDataStreamsNum(); i++)
+        aq_devices.Add(std::make_unique<HLSSimulatedDevice>(i, 64));
+
+    PreflightRefusingPusher pusher;
+    JFJochReceiverService receiver_service(aq_devices, logger, pusher);
+
+    JFJochServices services(logger);
+    services.Receiver(&receiver_service);
+
+    JFJochStateMachine state_machine(experiment, services, logger);
+    state_machine.AddDetectorSetup(DetJF(2));
+    state_machine.DebugOnly_SetState(JFJochState::Idle);
+
+    DatasetSettings setup;
+    setup.ImagesPerTrigger(4).NumTriggers(1).FilePrefix("preflight_refused");
+
+    // A synchronous start reports the writer's own message.
+    REQUIRE_THROWS_WITH(state_machine.Start(setup),
+                        Catch::Matchers::ContainsSubstring("preflight_refused_2468"));
+    REQUIRE_FALSE(pusher.start_called);
+
+    // An ordinary failure, so the detector stays usable and the run can be retried from Idle.
+    auto status = state_machine.GetStatus();
+    REQUIRE(status.state == JFJochState::Idle);
+    REQUIRE(status.message_severity == BrokerStatus::MessageSeverity::Error);
+
+    // The asynchronous start returns, and the wait functions report it.
+    REQUIRE_NOTHROW(state_machine.Start(setup, true));
+    REQUIRE_THROWS_WITH(state_machine.WaitTillNotBusy(10s),
+                        Catch::Matchers::ContainsSubstring("preflight_refused_2468"));
+    REQUIRE_THROWS_WITH(state_machine.WaitTillMeasurementDone(10s),
+                        Catch::Matchers::ContainsSubstring("preflight_refused_2468"));
+    REQUIRE_FALSE(pusher.start_called);
+}