ceremonyclient/consensus/models/timeout_state.go
Cassandra Heart c797d482f9
v2.1.0.5 (#457)
* wip: conversion of hotstuff from flow into Q-oriented model

* bulk of tests

* remaining non-integration tests

* add integration test, adjust log interface, small tweaks

* further adjustments, restore full pacemaker shape

* add component lifecycle management+supervisor

* further refinements

* resolve timeout hanging

* mostly finalized state for consensus

* bulk of engine swap out

* lifecycle-ify most types

* wiring nearly complete, missing needed hooks for proposals

* plugged in, vetting message validation paths

* global consensus, plugged in and verified

* app shard now wired in too

* do not decode empty keys.yml (#456)

* remove obsolete engine.maxFrames config parameter (#454)

* default to Info log level unless debug is enabled (#453)

* respect config's  "logging" section params, remove obsolete single-file logging (#452)

* Trivial code cleanup aiming to reduce Go compiler warnings (#451)

* simplify range traversal

* simplify channel read for single select case

* delete rand.Seed() deprecated in Go 1.20 and no-op as of Go 1.24

* simplify range traversal

* simplify channel read for single select case

* remove redundant type from array

* simplify range traversal

* simplify channel read for single select case

* RC slate

* finalize 2.1.0.5

* Update comments in StrictMonotonicCounter

Fix comment formatting and clarify description.

---------

Co-authored-by: Black Swan <3999712+blacks1ne@users.noreply.github.com>
2025-11-11 05:00:17 -06:00

66 lines
2.3 KiB
Go

package models
import (
"bytes"
)
// TimeoutState represents the stored state change step relevant to the point of
// rank of a given instance of the consensus state machine.
type TimeoutState[VoteT Unique] struct {
// The rank of the timeout data.
Rank uint64
// The latest quorum certificate seen by the pacemaker.
LatestQuorumCertificate QuorumCertificate
// The previous rank's timeout certificate, if applicable.
PriorRankTimeoutCertificate TimeoutCertificate
// The signed payload which will become part of the new timeout certificate.
Vote *VoteT
// TimeoutTick is the number of times the `timeout.Controller` has
// (re-)emitted the timeout for this rank. When the timer for the rank's
// original duration expires, a `TimeoutState` with `TimeoutTick = 0` is
// broadcast. Subsequently, `timeout.Controller` re-broadcasts the
// `TimeoutState` periodically based on some internal heuristic. Each time
// we attempt a re-broadcast, the `TimeoutTick` is incremented. Incrementing
// the field prevents de-duplicated within the network layer, which in turn
// guarantees quick delivery of the `TimeoutState` after GST and facilitates
// recovery.
TimeoutTick uint64
}
func (t *TimeoutState[VoteT]) Equals(other *TimeoutState[VoteT]) bool {
// Shortcut if `t` and `other` point to the same object; covers case where
// both are nil.
if t == other {
return true
}
if t == nil || other == nil {
// only one is nil, the other not (otherwise we would have returned above)
return false
}
if t.Vote != other.Vote && (other.Vote == nil || t.Vote == nil) {
return false
}
if (t.PriorRankTimeoutCertificate != nil &&
other.PriorRankTimeoutCertificate == nil) ||
(t.PriorRankTimeoutCertificate == nil &&
other.PriorRankTimeoutCertificate != nil) {
return false
}
// both are not nil, so we can compare the fields
return t.Rank == other.Rank &&
((t.LatestQuorumCertificate == nil &&
other.LatestQuorumCertificate == nil) ||
t.LatestQuorumCertificate.Equals(other.LatestQuorumCertificate)) &&
((t.PriorRankTimeoutCertificate == nil &&
other.PriorRankTimeoutCertificate == nil) ||
t.PriorRankTimeoutCertificate.Equals(
other.PriorRankTimeoutCertificate,
)) &&
((t.Vote == other.Vote) ||
((*t.Vote).Source() == (*other.Vote).Source()) &&
bytes.Equal((*t.Vote).GetSignature(), (*other.Vote).GetSignature()))
}