leonarski_fandClaude Opus 5
41983ca589
A writer refusing to overwrite an existing file was reported badly, and the
earlier fix only covered half of it. The commit message of a6a715703 states the
assumption that broke: "SendStartMessage precedes every std::async in the
receiver constructor". That is true of JFJochReceiverFPGA, where the start
message goes out from the constructor body, and false of JFJochReceiverLite,
where it goes out from MeasurementThread - launched by std::async from the
constructor, which waits only on data_analysis_started. On the DECTRIS path the
writer's refusal therefore cannot reach services.Start(); it arrives from
services.Stop(), i.e. the second try-block of the state machine's
MeasurementThread, which never touched start_exception. /wait_till_done answered
200 for a run that never wrote anything.
Two changes, in front of the problem and behind it.
In front: a PREFLIGHT frame (TCP protocol version 3 -> 4), sent to every writer
before the receiver is built and before the detector is armed. It carries the
same CBOR start message a START does and asks one question: could this run be
written? The writer runs FileWriter::Preflight - the first three statements of
the FileWriter constructor, stopping short of the only one that creates
anything - and answers with an ACK. Shared code, so a pre-flight that passes
cannot be contradicted by the start behind it. A refusal is not fatal: nothing
was started, the connection stays usable, and above all no series is left armed
waiting for a trigger that will not come. Both ends already reject a frame of
another protocol version, so the bump costs no compatibility.
The check now covers the data files, not only the master. A stale
_data_000001.h5 used to sail through and fail when the file was renamed into
place at the end of the run, after the whole dataset had been collected. The
writer holding the master file checks for all of them - they share a directory
by construction, the master linking them by relative name - so the siblings do
not race each other statting files the others are creating.
Behind: /wait_till_done maps an Idle state to 200 or 500 by the severity of the
end-of-run message, so a collection that lost packets, or whose writer could not
write, is no longer indistinguishable from a good one to a script. A cancelled
collection is not affected - MeasurementThread checks the cancel before it looks
at the completeness of the data, and reports it with Info severity - and a
warning is still a 200. start_exception is untouched.
The PREFLIGHT payload is built from FillMessage alone, which is what keeps it
small: the per-pixel arrays are added by SendStartMessage and are not in it.
Measured on a JUNGFRAU 9M, 1.4 kB against 543 kB for the start message. It is
deliberately the whole of FillMessage rather than the fields the check reads
today - a hand-picked subset would answer for a different set of file names the
day the check learns to read one more field, and would do it silently.
Three defects found on the way:
TCPImagePuller republished a PREFLIGHT as a real start message, announcing to
downstream consumers a run that was not going to happen.
TCPStreamPusher::run_number was a plain uint64_t written by the control thread
and read by every ACK thread; Preflight adds a second writer to it.
StreamWriter::CollectImages reprocessed the last frame whenever WaitForImage
returned false - run is only tested at the top of the loop - so an abort wrote
the last image a second time. Pre-existing; the new branch made it visible.
Verified against a running broker on the local configuration: a colliding master
file and a colliding data file are both refused by /start, /wait_until_running
and /wait_till_done with the writer's own message, and the log shows the receiver
was never started for either; a cancelled collection still answers 200.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016WmryXe8ASbNi632sUMfsa
68 lines
2.3 KiB
C++
68 lines
2.3 KiB
C++
// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
|
|
constexpr uint32_t JFJOCH_TCP_MAGIC = 0x4A464A54; // JFJT
|
|
constexpr uint32_t JFJOCH_TCP_VERSION = 4;
|
|
|
|
// Upper bound on a single frame's payload. A receiver rejects any header claiming more
|
|
// before allocating for it: an uncapped payload_size would otherwise drive a huge
|
|
// resize() and take down the receiving thread. 1 GiB is far above any real image frame.
|
|
constexpr uint64_t JFJOCH_TCP_MAX_PAYLOAD_SIZE = static_cast<uint64_t>(1) << 30;
|
|
|
|
enum class TCPFrameType : uint16_t {
|
|
START = 1,
|
|
DATA = 2,
|
|
CALIBRATION = 3,
|
|
END = 4,
|
|
ACK = 5,
|
|
CANCEL = 6,
|
|
KEEPALIVE = 7,
|
|
// Writer -> pusher liveness/backpressure heartbeat. Tells the pusher the writer
|
|
// is alive but busy (e.g. stalled on a slow filesystem) and that it should keep
|
|
// waiting for a proper ACK rather than declaring the connection dead. Carries the
|
|
// writer's current FIFO occupancy in the ack_fifo_* fields.
|
|
BUSY = 8,
|
|
// Pusher -> writer dry run, sent before the detector is armed. Carries the same CBOR
|
|
// StartMessage a START would, but the writer only checks that it could write the output
|
|
// (path, directory, no file in the way) and answers with an ACK; it opens nothing and
|
|
// leaves its state untouched. A rejected PREFLIGHT is not fatal - the run was never
|
|
// started, so the connection stays usable for the next attempt.
|
|
PREFLIGHT = 9,
|
|
};
|
|
|
|
enum class TCPAckCode : uint16_t {
|
|
None = 0,
|
|
StartFailed = 1,
|
|
DataWriteFailed = 2,
|
|
EndFailed = 3,
|
|
DiskQuotaExceeded = 4,
|
|
NoSpaceLeft = 5,
|
|
PermissionDenied = 6,
|
|
IoError = 7,
|
|
ProtocolError = 8
|
|
};
|
|
|
|
constexpr uint32_t TCP_ACK_FLAG_OK = 1u << 0;
|
|
constexpr uint32_t TCP_ACK_FLAG_FATAL = 1u << 1;
|
|
constexpr uint32_t TCP_ACK_FLAG_HAS_ERROR_TEXT = 1u << 2;
|
|
|
|
struct alignas(64) TcpFrameHeader {
|
|
uint32_t magic = JFJOCH_TCP_MAGIC;
|
|
uint16_t version = JFJOCH_TCP_VERSION ;
|
|
uint16_t type = 0;
|
|
uint64_t image_number = 0;
|
|
uint64_t payload_size = 0;
|
|
uint32_t socket_number = 0;
|
|
uint32_t flags = 0;
|
|
uint64_t run_number = 0;
|
|
|
|
uint32_t ack_processed_images = 0;
|
|
uint16_t ack_code = 0;
|
|
uint16_t ack_for = 0;
|
|
uint64_t ack_fifo_occupancy = 0;
|
|
uint64_t ack_fifo_max_occupancy = 0;
|
|
}; |