leonarski_fandClaude Opus 5.5
2981aedd3e
With a DECTRIS detector the broker starts the writers - and so learned the collection's start message - only when the detector's own start message arrived, after /start had returned. A reader started right after /start found no collection (404) and had to wait for, and race with, the detector. - /start registers the collection in LiveCollection (Expect) as it is accepted, so GET /live/events is accepted from then on. The image pusher fills in the start message when it starts the writers (Begin) - at once on the FPGA path, when the detector's start message arrives on the DECTRIS path. - The event stream's first event is now `start`, carrying that start message (CBOR, base64) with run number, file prefix, image count and images per file; it replaces `collection`. Until it is known the stream only keeps alive. file and end follow as before. - However the measurement thread ends, it ends a collection the pusher did not end (EndIfOpen), so a cancel or a failure before the detector streamed reaches the reader as `end` with an error. The wait is event-driven: it ends with the start message or with the measurement. - GET /live/start.cbor is removed: the stream carries the start message, one route less. - rugnux takes the start message from the stream (BrokerFeed::WaitForStart), so it can be started right after /start; files reported before it attached the reader are replayed to it. Tests: LiveCollection_ExpectedAtStart; BrokerFeed_StartFromEventStream (an event stream whose start message comes late, then a file and the end). Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SVmAWnzCmRKAXVUCdc4iNi
105 lines
3.0 KiB
C++
105 lines
3.0 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#include "LiveCollection.h"
|
|
|
|
#include "../writer/HDF5NXmx.h"
|
|
|
|
void LiveCollection::Expect() {
|
|
{
|
|
std::unique_lock ul(m);
|
|
const uint64_t generation = state.generation + 1;
|
|
state = Snapshot{};
|
|
state.generation = generation;
|
|
start_cbor.clear();
|
|
}
|
|
cv.notify_all();
|
|
}
|
|
|
|
void LiveCollection::Begin(const StartMessage &start, std::vector<uint8_t> cbor) {
|
|
{
|
|
std::unique_lock ul(m);
|
|
// The collection Expect announced, or - when nothing announced it - a new one.
|
|
if (state.generation == 0 || state.started || state.ended) {
|
|
const uint64_t generation = state.generation + 1;
|
|
state = Snapshot{};
|
|
state.generation = generation;
|
|
}
|
|
state.started = true;
|
|
state.run_number = start.run_number;
|
|
state.run_name = start.run_name;
|
|
state.file_prefix = start.file_prefix;
|
|
state.number_of_images = start.number_of_images;
|
|
state.images_per_file = start.images_per_file;
|
|
start_message = start;
|
|
start_cbor = std::move(cbor);
|
|
}
|
|
cv.notify_all();
|
|
}
|
|
|
|
void LiveCollection::FileClosed(uint64_t file_number, uint64_t image_count) {
|
|
{
|
|
std::unique_lock ul(m);
|
|
if (!state.started || state.ended)
|
|
return;
|
|
state.files.push_back(DataFile{
|
|
.file_number = file_number,
|
|
.file = HDF5Metadata::DataFileName(start_message, static_cast<int64_t>(file_number)),
|
|
.first_image = file_number * static_cast<uint64_t>(state.images_per_file),
|
|
.image_count = image_count
|
|
});
|
|
}
|
|
cv.notify_all();
|
|
}
|
|
|
|
void LiveCollection::End(uint64_t images, const std::string &error) {
|
|
{
|
|
std::unique_lock ul(m);
|
|
if (state.generation == 0 || state.ended)
|
|
return;
|
|
state.ended = true;
|
|
state.end_images = images;
|
|
state.end_error = error;
|
|
}
|
|
cv.notify_all();
|
|
}
|
|
|
|
void LiveCollection::EndIfOpen(const std::string &error) {
|
|
End(0, error);
|
|
}
|
|
|
|
std::optional<std::vector<uint8_t>> LiveCollection::StartCBOR() const {
|
|
std::unique_lock ul(m);
|
|
if (!state.started)
|
|
return {};
|
|
return start_cbor;
|
|
}
|
|
|
|
LiveCollection::Snapshot LiveCollection::Wait(uint64_t generation, bool started_seen, size_t files_seen,
|
|
std::chrono::milliseconds wait) {
|
|
std::unique_lock ul(m);
|
|
cv.wait_for(ul, wait, [&] {
|
|
return state.generation != generation || state.ended || state.files.size() > files_seen
|
|
|| (state.started && !started_seen);
|
|
});
|
|
return state;
|
|
}
|
|
|
|
LiveCollection::Snapshot LiveCollection::Get() const {
|
|
std::unique_lock ul(m);
|
|
return state;
|
|
}
|
|
|
|
bool LiveCollection::AcquireFollower() {
|
|
std::unique_lock ul(m);
|
|
if (follower)
|
|
return false;
|
|
follower = true;
|
|
return true;
|
|
}
|
|
|
|
void LiveCollection::ReleaseFollower() {
|
|
std::unique_lock ul(m);
|
|
follower = false;
|
|
}
|