Documentation ¶
Index ¶
- type IdentifierSet
- type NodeBlocklistWrapper
- func (w *NodeBlocklistWrapper) ByNodeID(identifier flow.Identifier) (*flow.Identity, bool)
- func (w *NodeBlocklistWrapper) ByPeerID(p peer.ID) (*flow.Identity, bool)
- func (w *NodeBlocklistWrapper) ClearBlocklist() error
- func (w *NodeBlocklistWrapper) GetBlocklist() flow.IdentifierList
- func (w *NodeBlocklistWrapper) Identities(filter flow.IdentityFilter) flow.IdentityList
- func (w *NodeBlocklistWrapper) Update(blocklist flow.IdentifierList) error
- type ProtocolStateIDCache
- func (p *ProtocolStateIDCache) ByNodeID(flowID flow.Identifier) (*flow.Identity, bool)
- func (p *ProtocolStateIDCache) ByPeerID(peerID peer.ID) (*flow.Identity, bool)
- func (p *ProtocolStateIDCache) EpochCommittedPhaseStarted(currentEpochCounter uint64, header *flow.Header)
- func (p *ProtocolStateIDCache) EpochSetupPhaseStarted(currentEpochCounter uint64, header *flow.Header)
- func (p *ProtocolStateIDCache) EpochTransition(newEpochCounter uint64, header *flow.Header)
- func (p *ProtocolStateIDCache) GetFlowID(peerID peer.ID) (flow.Identifier, error)
- func (p *ProtocolStateIDCache) GetPeerID(flowID flow.Identifier) (peer.ID, error)
- func (p *ProtocolStateIDCache) Identities(filter flow.IdentityFilter) flow.IdentityList
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type IdentifierSet ¶
type IdentifierSet map[flow.Identifier]struct{}
IdentifierSet represents a set of node IDs (operator-defined) whose communication should be blocked.
func (IdentifierSet) Contains ¶
func (s IdentifierSet) Contains(id flow.Identifier) bool
Contains returns true iff id ∈ s
type NodeBlocklistWrapper ¶
type NodeBlocklistWrapper struct {
// contains filtered or unexported fields
}
NodeBlocklistWrapper is a wrapper for an `module.IdentityProvider` instance, where the wrapper overrides the `Ejected` flag to true for all NodeIDs in a `blocklist`. To avoid modifying the source of the identities, the wrapper creates shallow copies of the identities (whenever necessary) and modifies the `Ejected` flag only in the copy. The `NodeBlocklistWrapper` internally represents the `blocklist` as a map, to enable performant lookup. However, the exported API works with `flow.IdentifierList` for blocklist, as this is a broadly supported data structure which lends itself better to config or command-line inputs.
func NewNodeBlocklistWrapper ¶
func NewNodeBlocklistWrapper(identityProvider module.IdentityProvider, db *badger.DB) (*NodeBlocklistWrapper, error)
NewNodeBlocklistWrapper wraps the given `IdentityProvider`. The blocklist is loaded from the database (or assumed to be empty if no database entry is present).
func (*NodeBlocklistWrapper) ByNodeID ¶
func (w *NodeBlocklistWrapper) ByNodeID(identifier flow.Identifier) (*flow.Identity, bool)
ByNodeID returns the full identity for the node with the given Identifier, where Identifier is the way the protocol refers to the node. The function has the same semantics as a map lookup, where the boolean return value is true if and only if Identity has been found, i.e. `Identity` is not nil. Caution: function returns include ejected nodes. Please check the `Ejected` flag in the identity.
func (*NodeBlocklistWrapper) ByPeerID ¶
ByPeerID returns the full identity for the node with the given peer ID, peer.ID is the libp2p-level identifier of a Flow node. The function has the same semantics as a map lookup, where the boolean return value is true if and only if Identity has been found, i.e. `Identity` is not nil. Caution: function returns include ejected nodes. Please check the `Ejected` flag in the identity.
func (*NodeBlocklistWrapper) ClearBlocklist ¶
func (w *NodeBlocklistWrapper) ClearBlocklist() error
ClearBlocklist purges the set of blocked node IDs. Convenience function equivalent to w.Update(nil). No errors are expected during normal operations.
func (*NodeBlocklistWrapper) GetBlocklist ¶
func (w *NodeBlocklistWrapper) GetBlocklist() flow.IdentifierList
GetBlocklist returns the set of blocked node IDs.
func (*NodeBlocklistWrapper) Identities ¶
func (w *NodeBlocklistWrapper) Identities(filter flow.IdentityFilter) flow.IdentityList
Identities returns the full identities of _all_ nodes currently known to the protocol that pass the provided filter. Caution, this includes ejected nodes. Please check the `Ejected` flag in the returned identities (or provide a filter for removing ejected nodes).
func (*NodeBlocklistWrapper) Update ¶
func (w *NodeBlocklistWrapper) Update(blocklist flow.IdentifierList) error
Update sets the wrapper's internal set of blocked nodes to `blocklist`. Empty list and `nil` (equivalent to empty list) are accepted inputs. To avoid legacy entries in the data base, this function purges the entire data base entry if `blocklist` is empty. This implementation is _eventually consistent_, where changes are written to the data base first and then (non-atomically!) the in-memory set of blocked nodes is updated. This strongly benefits performance and modularity. No errors are expected during normal operations.
type ProtocolStateIDCache ¶
ProtocolStateIDCache implements an `id.IdentityProvider` and `p2p.IDTranslator` for the set of authorized Flow network participants as according to the given `protocol.State`. the implementation assumes that the node information changes rarely, while queries are frequent. Hence, we follow an event-driven design, where the ProtocolStateIDCache subscribes to relevant protocol notifications (mainly Epoch notifications) and updates its internally cached list of authorized node identities. Note: this implementation is _eventually consistent_, where changes in the protocol state will quickly, but not atomically, propagate to the ProtocolStateIDCache. This strongly benefits performance and modularity, as we can cache identities locally here, while the marginal delay of updates is of no concern to the protocol.
func NewProtocolStateIDCache ¶
func NewProtocolStateIDCache( logger zerolog.Logger, state protocol.State, eventDistributor *events.Distributor, ) (*ProtocolStateIDCache, error)
func (*ProtocolStateIDCache) ByNodeID ¶
func (p *ProtocolStateIDCache) ByNodeID(flowID flow.Identifier) (*flow.Identity, bool)
ByNodeID returns the full identity for the node with the given Identifier, where Identifier is the way the protocol refers to the node. The function has the same semantics as a map lookup, where the boolean return value is true if and only if Identity has been found, i.e. `Identity` is not nil. Caution: function returns include ejected nodes. Please check the `Ejected` flag in the identity.
func (*ProtocolStateIDCache) ByPeerID ¶
ByPeerID returns the full identity for the node with the given peer ID, where ID is the way the libP2P refers to the node. The function has the same semantics as a map lookup, where the boolean return value is true if and only if Identity has been found, i.e. `Identity` is not nil. Caution: function returns include ejected nodes. Please check the `Ejected` flag in the identity.
func (*ProtocolStateIDCache) EpochCommittedPhaseStarted ¶
func (p *ProtocolStateIDCache) EpochCommittedPhaseStarted(currentEpochCounter uint64, header *flow.Header)
EpochCommittedPhaseStarted is a callback function for notifying the `ProtocolStateIDCache` that the EpochCommitted Phase has just stared. Upon such notification, the internally-cached Identity table of authorized network participants is updated.
TODO: per API contract, implementations of `EpochCommittedPhaseStarted` should be non-blocking and virtually latency free. However, we run data base queries and acquire locks here, which is undesired.
func (*ProtocolStateIDCache) EpochSetupPhaseStarted ¶
func (p *ProtocolStateIDCache) EpochSetupPhaseStarted(currentEpochCounter uint64, header *flow.Header)
EpochSetupPhaseStarted is a callback function for notifying the `ProtocolStateIDCache` that the EpochSetup Phase has just stared. Upon such notification, the internally-cached Identity table of authorized network participants is updated.
TODO: per API contract, implementations of `EpochSetupPhaseStarted` should be non-blocking and virtually latency free. However, we run data base queries and acquire locks here, which is undesired.
func (*ProtocolStateIDCache) EpochTransition ¶
func (p *ProtocolStateIDCache) EpochTransition(newEpochCounter uint64, header *flow.Header)
EpochTransition is a callback function for notifying the `ProtocolStateIDCache` of an Epoch transition that just occurred. Upon such notification, the internally-cached Identity table of authorized network participants is updated.
TODO: per API contract, implementations of `EpochTransition` should be non-blocking and virtually latency free. However, we run data base queries and acquire locks here, which is undesired.
func (*ProtocolStateIDCache) GetFlowID ¶
func (p *ProtocolStateIDCache) GetFlowID(peerID peer.ID) (flow.Identifier, error)
GetFlowID returns the Flow ID for the given peer ID. During normal operations, the following error returns are expected
- ErrUnknownId if the given Identifier is unknown
func (*ProtocolStateIDCache) GetPeerID ¶
func (p *ProtocolStateIDCache) GetPeerID(flowID flow.Identifier) (peer.ID, error)
GetPeerID returns the peer ID for the given Flow ID. During normal operations, the following error returns are expected
- ErrUnknownId if the given Identifier is unknown
func (*ProtocolStateIDCache) Identities ¶
func (p *ProtocolStateIDCache) Identities(filter flow.IdentityFilter) flow.IdentityList
Identities returns the full identities of _all_ nodes currently known to the protocol that pass the provided filter. Caution, this includes ejected nodes. Please check the `Ejected` flag in the identities (or provide a filter for removing ejected nodes).