seqeron 0.18.0
Loading...
Searching...
No Matches
org::limitless::seqeron::protocol Namespace Reference

Classes

struct  FrameView
 One frame off the queue, unwrapped: everything a consumer dispatches on, with the envelope stripped. More...
 
struct  LifecycleEvent
 A connection at a producer opening (ConnectionOpened) or closing (ConnectionClosed). More...
 
struct  SequencedEvent
 Carries one message from the cluster stream. More...
 
struct  SnapshotGatewayRow
 
struct  SnapshotGatewayState
 
struct  SnapshotGroup
 
struct  SnapshotHeader
 The header a façade writes ahead of the application's body: what it derives from frames before the round's cut. More...
 

Enumerations

enum class  Publish { Published , Refused , Declined }
 

Functions

std::int64_t addAppCounter (const std::shared_ptr< aeron::Aeron > &aeron, const std::int32_t typeId, const std::string &label, const std::int32_t memberId, const std::int32_t clientId)
 Allocates an app counter keyed on {memberId, clientId}.
 
constexpr std::int32_t queueStreamId (const std::int32_t groupId)
 Names the stream of a group's queue.
 
constexpr std::int32_t ingressBlockLength (const std::uint16_t systemEventType)
 Looks up the compiled block length of a submittable system event: §9.2 conditions 8 and 9 in one lookup.
 
void readSystemHeader (FrameView &view, sbe::frame::SequencedSystemHeader &header)
 Copies the identity every system message carries; the two composites are the same 44 bytes.
 
FrameView unwrapFrame (const char *const frame, const std::uint64_t length)
 Reads one fragment into a FrameView, stripping the envelope.
 
template<typename Decoder >
Decoder decodeSequenced (const char *payload, const std::uint64_t payloadLength, const std::uint16_t blockLength, const std::uint16_t version)
 Wraps an application payload held as loose bytes in its decoder, past its own messageHeader.
 
template<typename Decoder >
Decoder decodeSystem (const char *message, const std::uint64_t messageLength)
 Wraps a system frame's message in its decoder.
 
template<typename Decoder >
Decoder decodeSystem (const SequencedEvent &event)
 Wraps a system event's message in its decoder; see decodeSystem(const char*, std::uint64_t).
 
template<typename Decoder >
Decoder decodeSequenced (const SequencedEvent &event)
 Wraps an application event's payload in its decoder.
 
std::int64_t frameStartPosition (const aeron::Header &header)
 Computes the stream position of a frame's first byte; what SequencedEvent::position carries.
 
template<typename Decoder >
Decoder decodeSystem (const LifecycleEvent &event)
 Wraps a lifecycle event's message in its decoder: ConnectionOpened or ConnectionClosed.
 
SequencedEvent sequencedEventOf (const FrameView &view, const std::int64_t receiveTimeNs, const std::int64_t position)
 Fills a SequencedEvent from an unwrapped frame, plus the two stamps that belong to the delivery rather than to the frame.
 
LifecycleEvent lifecycleEventOf (const FrameView &view, const std::int64_t receiveTimeNs)
 Fills a LifecycleEvent from an unwrapped ConnectionOpened/ConnectionClosed.
 
std::int64_t nowNs ()
 
std::uint32_t crc32c (const std::uint8_t *data, const std::size_t length, const std::uint32_t crc=0)
 Computes the CRC-32C of a span of bytes, as SnapshotEnd::crc32c carries it, or continues one: with the CPU's CRC-32C instruction where it has one, through a table where it does not.
 

Variables

constexpr const char * PROXY_DEFAULT_HOST_NAME = "hosted"
 
constexpr std::uint16_t PROXY_PROTOCOL_VERSION = 2
 
constexpr std::uint16_t PROXY_SCHEMA_ID = 218
 
constexpr std::int32_t PROXY_ATTACH_REQUEST_STREAM = 301
 
constexpr std::int32_t PROXY_ATTACH_REPLY_STREAM = 302
 
constexpr std::int32_t PROXY_EVENTS_STREAM = 303
 
constexpr std::int32_t PROXY_COMMANDS_STREAM = 304
 
constexpr std::int32_t SEQUENCER_TYPE_ID_MIN = 5000
 
constexpr std::int32_t SEQUENCER_TYPE_ID_MAX = 5099
 
constexpr std::int32_t SEQUENCER_CLUSTER_SEQ_NO_TYPE_ID = 5000
 
constexpr std::int32_t SEQUENCER_QUEUE_BACKPRESSURE_ALERTS_TYPE_ID = 5001
 
constexpr std::int32_t SEQUENCER_REJECTED_INGRESS_COUNT_TYPE_ID = 5002
 
constexpr std::int32_t SEQUENCER_LEADERSHIP_CHANGE_COUNT_TYPE_ID = 5003
 
constexpr std::int32_t SEQUENCER_CURRENT_LEADER_MEMBER_ID_TYPE_ID = 5004
 
constexpr std::int32_t SEQUENCER_LAST_CLUSTER_HEARTBEAT_TIMESTAMP_TYPE_ID = 5005
 
constexpr std::int32_t SEQUENCER_GATEWAY_PROMOTION_COUNT_TYPE_ID = 5006
 
constexpr std::int32_t SEQUENCER_BOOTSTRAP_ACTIVATED_TYPE_ID = 5007
 
constexpr std::int32_t SEQUENCER_QUEUE_STALLED_TYPE_ID = 5008
 
constexpr std::int32_t SEQUENCER_INGRESS_MESSAGES_TYPE_ID = 5010
 
constexpr std::int32_t SEQUENCER_GATEWAY_PROMOTION_FAILED_COUNT_TYPE_ID = 5011
 
constexpr std::int32_t REPLAYER_TYPE_ID_MIN = 5100
 
constexpr std::int32_t REPLAYER_TYPE_ID_MAX = 5199
 
constexpr std::int32_t REPLAYER_READY_TYPE_ID = 5101
 
constexpr std::int32_t REPLAYER_ACTIVE_SLOTS_TYPE_ID = 5102
 
constexpr std::int32_t REPLAYER_PENDING_REQUESTS_TYPE_ID = 5103
 
constexpr std::int32_t REPLAYER_REPLAYS_SERVED_COUNT_TYPE_ID = 5104
 
constexpr std::int32_t REPLAYER_CONTROL_REPLIES_DROPPED_COUNT_TYPE_ID = 5107
 
constexpr std::int32_t REPLAYER_THROTTLED_REQUESTS_COUNT_TYPE_ID = 5110
 
constexpr std::int32_t REPLAYER_ARCHIVE_ERRORS_COUNT_TYPE_ID = 5111
 
constexpr std::int32_t APP_TYPE_ID_MIN = 5200
 
constexpr std::int32_t APP_TYPE_ID_MAX = 5299
 
constexpr std::int32_t APP_RECOVERY_STALLED_TYPE_ID = 5200
 
constexpr std::int32_t HOSTED_LAG_TYPE_ID = 5297
 
constexpr std::int32_t APP_SNAPSHOT_ROUND_TYPE_ID = 5298
 
constexpr std::int32_t GATEWAY_CONNECTIONS_TYPE_ID = 5299
 
constexpr std::int32_t PROXY_TYPE_ID_MIN = 5300
 
constexpr std::int32_t PROXY_TYPE_ID_MAX = 5399
 
constexpr std::int32_t PROXY_CLIENT_HEARTBEAT_TYPE_ID = 5300
 
constexpr std::int32_t PROXY_CLIENT_APPLIED_TYPE_ID = 5301
 
constexpr std::int32_t PROXY_HEARTBEAT_TYPE_ID = 5302
 
constexpr std::int32_t PROXY_RETIRED_TYPE_ID = 5303
 
constexpr std::int32_t MIN_TYPE_ID = SEQUENCER_TYPE_ID_MIN
 
constexpr std::int32_t MAX_TYPE_ID = PROXY_TYPE_ID_MAX
 
constexpr std::size_t KEY_MEMBER_ID_OFFSET = 0
 
constexpr std::size_t KEY_CLIENT_ID_OFFSET = 4
 
constexpr std::size_t KEY_LENGTH = 4
 
constexpr std::size_t APP_KEY_LENGTH = 8
 
constexpr const char * QUEUE_CHANNEL = "aeron:ipc?alias=seqeron-queue"
 
constexpr std::int32_t MAX_GROUPS = 16
 
constexpr std::int32_t QUEUE_STREAM_ID_BASE = 2000
 
constexpr std::int64_t CLUSTER_HEARTBEAT_INTERVAL_MS = 1000
 
constexpr std::int64_t CLUSTER_HEARTBEAT_INTERVAL_NS = CLUSTER_HEARTBEAT_INTERVAL_MS * 1'000'000
 
constexpr std::uint16_t MAX_PAYLOAD_LENGTH = 8874
 
constexpr std::uint16_t MIN_INGRESS_LENGTH
 
constexpr std::uint16_t MAX_INGRESS_LENGTH = MIN_INGRESS_LENGTH + MAX_PAYLOAD_LENGTH
 
constexpr std::uint16_t CONNECTION_OPENED = sbe::frame::ConnectionOpened::sbeTemplateId()
 
constexpr std::uint16_t CONNECTION_CLOSED = sbe::frame::ConnectionClosed::sbeTemplateId()
 
constexpr std::uint16_t LEADERSHIP_CHANGED = 5
 
constexpr std::uint16_t CLUSTER_STARTED = sbe::frame::ClusterStarted::sbeTemplateId()
 
constexpr std::uint16_t CLUSTER_STOPPED = sbe::frame::ClusterStopped::sbeTemplateId()
 
constexpr std::uint16_t CLUSTER_HEARTBEAT = 16
 
constexpr std::uint16_t GATEWAY_REGISTERED = sbe::frame::GatewayRegistered::sbeTemplateId()
 
constexpr std::uint16_t GATEWAY_ACTIVE = 18
 
constexpr std::uint16_t GATEWAY_STARTED = sbe::frame::GatewayStarted::sbeTemplateId()
 
constexpr std::uint16_t PAYLOAD_ID_REGISTERED = sbe::frame::PayloadIdRegistered::sbeTemplateId()
 
constexpr std::uint16_t GATEWAY_ACTIVATION_REQUESTED = sbe::frame::GatewayActivationRequested::sbeTemplateId()
 
constexpr std::uint16_t APPLICATION_REGISTERED = sbe::frame::ApplicationRegistered::sbeTemplateId()
 
constexpr std::uint16_t SNAPSHOT_REQUESTED = sbe::frame::SnapshotRequested::sbeTemplateId()
 
constexpr std::uint16_t SNAPSHOT_END = sbe::frame::SnapshotEnd::sbeTemplateId()
 
constexpr std::uint16_t SNAPSHOT_POLICY_REGISTERED = sbe::frame::SnapshotPolicyRegistered::sbeTemplateId()
 
constexpr std::uint16_t SNAPSHOT_STARTED = 30
 
constexpr std::uint16_t SESSION_CLOSED = 31
 
constexpr std::uint16_t GROUPS_REGISTERED = sbe::frame::GroupsRegistered::sbeTemplateId()
 
constexpr std::int32_t NOT_INGRESS_LEGAL = -1
 
constexpr std::uint16_t MAX_SNAPSHOT_RECORD_LENGTH = 65535
 

Enumeration Type Documentation

◆ Publish

Enumerator
Published 
Refused 
Declined 

Function Documentation

◆ addAppCounter()

std::int64_t org::limitless::seqeron::protocol::addAppCounter ( const std::shared_ptr< aeron::Aeron > &  aeron,
const std::int32_t  typeId,
const std::string &  label,
const std::int32_t  memberId,
const std::int32_t  clientId 
)
inline

Allocates an app counter keyed on {memberId, clientId}.

Parameters
aeronthe client to allocate it on
typeIdthe counter's type id (doc/ops.md, "Counter type ids")
labelthe counter's label
memberIdthe node the app runs on, the key's first half
clientIdthe app's client id, the key's second half
Returns
the registration id for Aeron::findCounter: the add is async, so callers resolve it on a later duty cycle

◆ crc32c()

std::uint32_t org::limitless::seqeron::protocol::crc32c ( const std::uint8_t *  data,
const std::size_t  length,
const std::uint32_t  crc = 0 
)
inline

Computes the CRC-32C of a span of bytes, as SnapshotEnd::crc32c carries it, or continues one: with the CPU's CRC-32C instruction where it has one, through a table where it does not.

Parameters
datathe bytes
lengthhow many
crcthe CRC of the bytes before these, or 0 to start
Returns
the CRC of everything so far

◆ decodeSequenced() [1/2]

template<typename Decoder >
Decoder org::limitless::seqeron::protocol::decodeSequenced ( const char *  payload,
const std::uint64_t  payloadLength,
const std::uint16_t  blockLength,
const std::uint16_t  version 
)

Wraps an application payload held as loose bytes in its decoder, past its own messageHeader.

Template Parameters
Decoderthe payload's decoder, matched on (payloadId, templateId)
Parameters
payloadthe payload's first byte, its messageHeader included
payloadLengththe payload's length
blockLengththe block length the payload's messageHeader declares
versionthe schema version the payload's messageHeader declares

◆ decodeSequenced() [2/2]

template<typename Decoder >
Decoder org::limitless::seqeron::protocol::decodeSequenced ( const SequencedEvent &  event)

Wraps an application event's payload in its decoder.

The decoder is valid only for the callback, like SequencedEvent::payload.

Template Parameters
Decoderthe decoder the caller matched the event's (payloadId, templateId) against
Parameters
eventthe event, valid only during its callback

◆ decodeSystem() [1/3]

template<typename Decoder >
Decoder org::limitless::seqeron::protocol::decodeSystem ( const char *  message,
const std::uint64_t  messageLength 
)

Wraps a system frame's message in its decoder.

The message carries no framing, so block length and version come from this build's decoder (§7, V-3). Serves both a submitted payload and a synthesized template's inline block.

Template Parameters
Decoderthe decoder systemEventType names
Parameters
messagethe message's first byte
messageLengththe message's length

◆ decodeSystem() [2/3]

template<typename Decoder >
Decoder org::limitless::seqeron::protocol::decodeSystem ( const LifecycleEvent &  event)

Wraps a lifecycle event's message in its decoder: ConnectionOpened or ConnectionClosed.

See decodeSystem(const char*, std::uint64_t).

Template Parameters
Decoderthe decoder the event's callback names
Parameters
eventthe event, valid only during its callback

◆ decodeSystem() [3/3]

template<typename Decoder >
Decoder org::limitless::seqeron::protocol::decodeSystem ( const SequencedEvent &  event)

Wraps a system event's message in its decoder; see decodeSystem(const char*, std::uint64_t).

Template Parameters
Decoderthe decoder the event's systemEventType names
Parameters
eventthe event, valid only during its callback

◆ frameStartPosition()

std::int64_t org::limitless::seqeron::protocol::frameStartPosition ( const aeron::Header &  header)
inline

Computes the stream position of a frame's first byte; what SequencedEvent::position carries.

Parameters
headerthe Aeron header of the frame's fragment

◆ ingressBlockLength()

constexpr std::int32_t org::limitless::seqeron::protocol::ingressBlockLength ( const std::uint16_t  systemEventType)
constexpr

Looks up the compiled block length of a submittable system event: §9.2 conditions 8 and 9 in one lookup.

The Java twin is SystemFrame.ingressBlockLength.

Parameters
systemEventTypethe event to look up
Returns
its block length, or NOT_INGRESS_LEGAL if a producer may not submit it

◆ lifecycleEventOf()

LifecycleEvent org::limitless::seqeron::protocol::lifecycleEventOf ( const FrameView &  view,
const std::int64_t  receiveTimeNs 
)
inline

Fills a LifecycleEvent from an unwrapped ConnectionOpened/ConnectionClosed.

Parameters
viewthe unwrapped frame
receiveTimeNswhen this process read it

◆ nowNs()

std::int64_t org::limitless::seqeron::protocol::nowNs ( )
inline

◆ queueStreamId()

constexpr std::int32_t org::limitless::seqeron::protocol::queueStreamId ( const std::int32_t  groupId)
constexpr

Names the stream of a group's queue.

Parameters
groupId1 to MAX_GROUPS
Returns
the stream id of that group's queue

◆ readSystemHeader()

void org::limitless::seqeron::protocol::readSystemHeader ( FrameView &  view,
sbe::frame::SequencedSystemHeader &  header 
)
inline

Copies the identity every system message carries; the two composites are the same 44 bytes.

Parameters
[out]viewthe view to fill, marked as a system frame
headerthe frame's system header, already wrapped

◆ sequencedEventOf()

SequencedEvent org::limitless::seqeron::protocol::sequencedEventOf ( const FrameView &  view,
const std::int64_t  receiveTimeNs,
const std::int64_t  position 
)
inline

Fills a SequencedEvent from an unwrapped frame, plus the two stamps that belong to the delivery rather than to the frame.

Both stream clients deliver the same event built from the same view, so the mapping is here rather than once per client.

Parameters
viewthe unwrapped frame
receiveTimeNswhen this process read it
positionthe stream position of its first byte

◆ unwrapFrame()

FrameView org::limitless::seqeron::protocol::unwrapFrame ( const char *const  frame,
const std::uint64_t  length 
)
inline

Reads one fragment into a FrameView, stripping the envelope.

Bounds are checked because a short fragment would otherwise be read past its end. It should not happen — the sequencer validates every frame on ingress and the recording is what it wrote — so valid == false here means the recording itself is damaged, and the caller logs and drops.

Parameters
framethe fragment's first byte
lengththe fragment's length
Returns
the frame's view; valid is false if the fragment is short or not a sequenced frame

Variable Documentation

◆ APP_KEY_LENGTH

constexpr std::size_t org::limitless::seqeron::protocol::APP_KEY_LENGTH = 8
inlineconstexpr

◆ APP_RECOVERY_STALLED_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::APP_RECOVERY_STALLED_TYPE_ID = 5200
inlineconstexpr

◆ APP_SNAPSHOT_ROUND_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::APP_SNAPSHOT_ROUND_TYPE_ID = 5298
inlineconstexpr

◆ APP_TYPE_ID_MAX

constexpr std::int32_t org::limitless::seqeron::protocol::APP_TYPE_ID_MAX = 5299
inlineconstexpr

◆ APP_TYPE_ID_MIN

constexpr std::int32_t org::limitless::seqeron::protocol::APP_TYPE_ID_MIN = 5200
inlineconstexpr

◆ APPLICATION_REGISTERED

constexpr std::uint16_t org::limitless::seqeron::protocol::APPLICATION_REGISTERED = sbe::frame::ApplicationRegistered::sbeTemplateId()
inlineconstexpr

◆ CLUSTER_HEARTBEAT

constexpr std::uint16_t org::limitless::seqeron::protocol::CLUSTER_HEARTBEAT = 16
inlineconstexpr

◆ CLUSTER_HEARTBEAT_INTERVAL_MS

constexpr std::int64_t org::limitless::seqeron::protocol::CLUSTER_HEARTBEAT_INTERVAL_MS = 1000
inlineconstexpr

◆ CLUSTER_HEARTBEAT_INTERVAL_NS

constexpr std::int64_t org::limitless::seqeron::protocol::CLUSTER_HEARTBEAT_INTERVAL_NS = CLUSTER_HEARTBEAT_INTERVAL_MS * 1'000'000
inlineconstexpr

◆ CLUSTER_STARTED

constexpr std::uint16_t org::limitless::seqeron::protocol::CLUSTER_STARTED = sbe::frame::ClusterStarted::sbeTemplateId()
inlineconstexpr

◆ CLUSTER_STOPPED

constexpr std::uint16_t org::limitless::seqeron::protocol::CLUSTER_STOPPED = sbe::frame::ClusterStopped::sbeTemplateId()
inlineconstexpr

◆ CONNECTION_CLOSED

constexpr std::uint16_t org::limitless::seqeron::protocol::CONNECTION_CLOSED = sbe::frame::ConnectionClosed::sbeTemplateId()
inlineconstexpr

◆ CONNECTION_OPENED

constexpr std::uint16_t org::limitless::seqeron::protocol::CONNECTION_OPENED = sbe::frame::ConnectionOpened::sbeTemplateId()
inlineconstexpr

◆ GATEWAY_ACTIVATION_REQUESTED

constexpr std::uint16_t org::limitless::seqeron::protocol::GATEWAY_ACTIVATION_REQUESTED = sbe::frame::GatewayActivationRequested::sbeTemplateId()
inlineconstexpr

◆ GATEWAY_ACTIVE

constexpr std::uint16_t org::limitless::seqeron::protocol::GATEWAY_ACTIVE = 18
inlineconstexpr

◆ GATEWAY_CONNECTIONS_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::GATEWAY_CONNECTIONS_TYPE_ID = 5299
inlineconstexpr

◆ GATEWAY_REGISTERED

constexpr std::uint16_t org::limitless::seqeron::protocol::GATEWAY_REGISTERED = sbe::frame::GatewayRegistered::sbeTemplateId()
inlineconstexpr

◆ GATEWAY_STARTED

constexpr std::uint16_t org::limitless::seqeron::protocol::GATEWAY_STARTED = sbe::frame::GatewayStarted::sbeTemplateId()
inlineconstexpr

◆ GROUPS_REGISTERED

constexpr std::uint16_t org::limitless::seqeron::protocol::GROUPS_REGISTERED = sbe::frame::GroupsRegistered::sbeTemplateId()
inlineconstexpr

◆ HOSTED_LAG_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::HOSTED_LAG_TYPE_ID = 5297
inlineconstexpr

◆ KEY_CLIENT_ID_OFFSET

constexpr std::size_t org::limitless::seqeron::protocol::KEY_CLIENT_ID_OFFSET = 4
inlineconstexpr

◆ KEY_LENGTH

constexpr std::size_t org::limitless::seqeron::protocol::KEY_LENGTH = 4
inlineconstexpr

◆ KEY_MEMBER_ID_OFFSET

constexpr std::size_t org::limitless::seqeron::protocol::KEY_MEMBER_ID_OFFSET = 0
inlineconstexpr

◆ LEADERSHIP_CHANGED

constexpr std::uint16_t org::limitless::seqeron::protocol::LEADERSHIP_CHANGED = 5
inlineconstexpr

◆ MAX_GROUPS

constexpr std::int32_t org::limitless::seqeron::protocol::MAX_GROUPS = 16
inlineconstexpr

◆ MAX_INGRESS_LENGTH

constexpr std::uint16_t org::limitless::seqeron::protocol::MAX_INGRESS_LENGTH = MIN_INGRESS_LENGTH + MAX_PAYLOAD_LENGTH
inlineconstexpr

◆ MAX_PAYLOAD_LENGTH

constexpr std::uint16_t org::limitless::seqeron::protocol::MAX_PAYLOAD_LENGTH = 8874
inlineconstexpr

◆ MAX_SNAPSHOT_RECORD_LENGTH

constexpr std::uint16_t org::limitless::seqeron::protocol::MAX_SNAPSHOT_RECORD_LENGTH = 65535
inlineconstexpr

◆ MAX_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::MAX_TYPE_ID = PROXY_TYPE_ID_MAX
inlineconstexpr

◆ MIN_INGRESS_LENGTH

constexpr std::uint16_t org::limitless::seqeron::protocol::MIN_INGRESS_LENGTH
inlineconstexpr
Initial value:
= static_cast<std::uint16_t>(
sbe::frame::MessageHeader::encodedLength() + sbe::frame::UnsequencedHeader::encodedLength() +
sbe::frame::Unsequenced::payloadHeaderLength())

◆ MIN_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::MIN_TYPE_ID = SEQUENCER_TYPE_ID_MIN
inlineconstexpr

◆ NOT_INGRESS_LEGAL

constexpr std::int32_t org::limitless::seqeron::protocol::NOT_INGRESS_LEGAL = -1
inlineconstexpr

◆ PAYLOAD_ID_REGISTERED

constexpr std::uint16_t org::limitless::seqeron::protocol::PAYLOAD_ID_REGISTERED = sbe::frame::PayloadIdRegistered::sbeTemplateId()
inlineconstexpr

◆ PROXY_ATTACH_REPLY_STREAM

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_ATTACH_REPLY_STREAM = 302
inlineconstexpr

◆ PROXY_ATTACH_REQUEST_STREAM

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_ATTACH_REQUEST_STREAM = 301
inlineconstexpr

◆ PROXY_CLIENT_APPLIED_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_CLIENT_APPLIED_TYPE_ID = 5301
inlineconstexpr

◆ PROXY_CLIENT_HEARTBEAT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_CLIENT_HEARTBEAT_TYPE_ID = 5300
inlineconstexpr

◆ PROXY_COMMANDS_STREAM

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_COMMANDS_STREAM = 304
inlineconstexpr

◆ PROXY_DEFAULT_HOST_NAME

constexpr const char* org::limitless::seqeron::protocol::PROXY_DEFAULT_HOST_NAME = "hosted"
inlineconstexpr

◆ PROXY_EVENTS_STREAM

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_EVENTS_STREAM = 303
inlineconstexpr

◆ PROXY_HEARTBEAT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_HEARTBEAT_TYPE_ID = 5302
inlineconstexpr

◆ PROXY_PROTOCOL_VERSION

constexpr std::uint16_t org::limitless::seqeron::protocol::PROXY_PROTOCOL_VERSION = 2
inlineconstexpr

◆ PROXY_RETIRED_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_RETIRED_TYPE_ID = 5303
inlineconstexpr

◆ PROXY_SCHEMA_ID

constexpr std::uint16_t org::limitless::seqeron::protocol::PROXY_SCHEMA_ID = 218
inlineconstexpr

◆ PROXY_TYPE_ID_MAX

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_TYPE_ID_MAX = 5399
inlineconstexpr

◆ PROXY_TYPE_ID_MIN

constexpr std::int32_t org::limitless::seqeron::protocol::PROXY_TYPE_ID_MIN = 5300
inlineconstexpr

◆ QUEUE_CHANNEL

constexpr const char* org::limitless::seqeron::protocol::QUEUE_CHANNEL = "aeron:ipc?alias=seqeron-queue"
inlineconstexpr

◆ QUEUE_STREAM_ID_BASE

constexpr std::int32_t org::limitless::seqeron::protocol::QUEUE_STREAM_ID_BASE = 2000
inlineconstexpr

◆ REPLAYER_ACTIVE_SLOTS_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_ACTIVE_SLOTS_TYPE_ID = 5102
inlineconstexpr

◆ REPLAYER_ARCHIVE_ERRORS_COUNT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_ARCHIVE_ERRORS_COUNT_TYPE_ID = 5111
inlineconstexpr

◆ REPLAYER_CONTROL_REPLIES_DROPPED_COUNT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_CONTROL_REPLIES_DROPPED_COUNT_TYPE_ID = 5107
inlineconstexpr

◆ REPLAYER_PENDING_REQUESTS_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_PENDING_REQUESTS_TYPE_ID = 5103
inlineconstexpr

◆ REPLAYER_READY_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_READY_TYPE_ID = 5101
inlineconstexpr

◆ REPLAYER_REPLAYS_SERVED_COUNT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_REPLAYS_SERVED_COUNT_TYPE_ID = 5104
inlineconstexpr

◆ REPLAYER_THROTTLED_REQUESTS_COUNT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_THROTTLED_REQUESTS_COUNT_TYPE_ID = 5110
inlineconstexpr

◆ REPLAYER_TYPE_ID_MAX

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_TYPE_ID_MAX = 5199
inlineconstexpr

◆ REPLAYER_TYPE_ID_MIN

constexpr std::int32_t org::limitless::seqeron::protocol::REPLAYER_TYPE_ID_MIN = 5100
inlineconstexpr

◆ SEQUENCER_BOOTSTRAP_ACTIVATED_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_BOOTSTRAP_ACTIVATED_TYPE_ID = 5007
inlineconstexpr

◆ SEQUENCER_CLUSTER_SEQ_NO_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_CLUSTER_SEQ_NO_TYPE_ID = 5000
inlineconstexpr

◆ SEQUENCER_CURRENT_LEADER_MEMBER_ID_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_CURRENT_LEADER_MEMBER_ID_TYPE_ID = 5004
inlineconstexpr

◆ SEQUENCER_GATEWAY_PROMOTION_COUNT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_GATEWAY_PROMOTION_COUNT_TYPE_ID = 5006
inlineconstexpr

◆ SEQUENCER_GATEWAY_PROMOTION_FAILED_COUNT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_GATEWAY_PROMOTION_FAILED_COUNT_TYPE_ID = 5011
inlineconstexpr

◆ SEQUENCER_INGRESS_MESSAGES_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_INGRESS_MESSAGES_TYPE_ID = 5010
inlineconstexpr

◆ SEQUENCER_LAST_CLUSTER_HEARTBEAT_TIMESTAMP_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_LAST_CLUSTER_HEARTBEAT_TIMESTAMP_TYPE_ID = 5005
inlineconstexpr

◆ SEQUENCER_LEADERSHIP_CHANGE_COUNT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_LEADERSHIP_CHANGE_COUNT_TYPE_ID = 5003
inlineconstexpr

◆ SEQUENCER_QUEUE_BACKPRESSURE_ALERTS_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_QUEUE_BACKPRESSURE_ALERTS_TYPE_ID = 5001
inlineconstexpr

◆ SEQUENCER_QUEUE_STALLED_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_QUEUE_STALLED_TYPE_ID = 5008
inlineconstexpr

◆ SEQUENCER_REJECTED_INGRESS_COUNT_TYPE_ID

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_REJECTED_INGRESS_COUNT_TYPE_ID = 5002
inlineconstexpr

◆ SEQUENCER_TYPE_ID_MAX

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_TYPE_ID_MAX = 5099
inlineconstexpr

◆ SEQUENCER_TYPE_ID_MIN

constexpr std::int32_t org::limitless::seqeron::protocol::SEQUENCER_TYPE_ID_MIN = 5000
inlineconstexpr

◆ SESSION_CLOSED

constexpr std::uint16_t org::limitless::seqeron::protocol::SESSION_CLOSED = 31
inlineconstexpr

◆ SNAPSHOT_END

constexpr std::uint16_t org::limitless::seqeron::protocol::SNAPSHOT_END = sbe::frame::SnapshotEnd::sbeTemplateId()
inlineconstexpr

◆ SNAPSHOT_POLICY_REGISTERED

constexpr std::uint16_t org::limitless::seqeron::protocol::SNAPSHOT_POLICY_REGISTERED = sbe::frame::SnapshotPolicyRegistered::sbeTemplateId()
inlineconstexpr

◆ SNAPSHOT_REQUESTED

constexpr std::uint16_t org::limitless::seqeron::protocol::SNAPSHOT_REQUESTED = sbe::frame::SnapshotRequested::sbeTemplateId()
inlineconstexpr

◆ SNAPSHOT_STARTED

constexpr std::uint16_t org::limitless::seqeron::protocol::SNAPSHOT_STARTED = 30
inlineconstexpr