Struct fbas_analyzer::Fbas

pub struct Fbas { /* private fields */ }

Representation of an FBAS.

Example

use fbas_analyzer::{Fbas, QuorumSet};

let fbas = Fbas::from_json_str(
    r#"[
    {
        "publicKey": "n0",
        "quorumSet": { "threshold": 1, "validators": ["n1"] }
    },
    {
        "publicKey": "n1",
        "quorumSet": { "threshold": 2, "validators": ["n1", "n2"] }
    },
    {
        "publicKey": "n2",
        "quorumSet": { "threshold": 2, "validators": ["n1", "n2"] }
    }
]"#,
);
assert_eq!(3, fbas.number_of_nodes());
assert_eq!(Some(0), fbas.get_node_id("n0"));
assert_eq!(
    QuorumSet {
        validators: vec![1],
        inner_quorum_sets: vec![],
        threshold: 1
    },
    fbas.get_quorum_set(0).unwrap()
);

let quorum_set = QuorumSet {
    validators: vec![1, 2],
    inner_quorum_sets: vec![],
    threshold: 2,
};
let mut fbas = fbas;
fbas.swap_quorum_set(0, quorum_set.clone());
assert_eq!(Some(quorum_set), fbas.get_quorum_set(0));

Implementations

impl Fbas

pub fn assume_crash_faulty(&mut self, nodes: &NodeIdSet)

Assume in the following that nodes can exhibit crash failures with the “goal” of blocking individual nodes or the whole FBAS. For keeping node IDs unchanged, this method doesn’t delete the node entirely but only makes it unsatisfiable.

pub fn assume_split_faulty(&mut self, nodes: &NodeIdSet)

Assume in the following that nodes can exhibit Byzantine failures with the “goal” of provoking splits. This corresponds to the delete operation from Mazières’s original FBAS/SCP paper. For keeping node IDs unchanged, this method doesn’t delete the node entirely but only makes it unsatisfiable and redacts it from all quorum sets.

impl Fbas

pub fn satisfiable_nodes(&self) -> NodeIdSet

pub fn unsatisfiable_nodes(&self) -> NodeIdSet

pub fn strongly_connected_components(&self) -> Vec<NodeIdSet>

pub fn rank_nodes(&self) -> Vec<RankScore>

Rank all nodes in the FBAS using an algorithm vaguely resembling PageRank.

pub fn core_nodes(&self) -> NodeIdSet

Returns all nodes part of a quorum-containing strongly connected component.

pub fn one_node_quorums(&self) -> Vec<NodeId>

Returns all nodes v for which {v} is a quorum slice (and hence a quorum). These are often nodes that are somehow broken.

pub fn to_core(&self) -> Self

Removes all nodes that are not part of a quorum-containing strongly connected component (the FBAS “core”). Changes node IDs and causes splitting sets analyses to return only such splitting sets that can cause core nodes to diverge from each other!

pub fn to_standard_form(&self) -> Self

Removes all unsatisfiable nodes and reorders node IDs so that nodes are sorted by public key.

pub fn without_nodes_pretty(&self, nodes: &[String]) -> Self

Remove nodes (referred to by their public keys) from the FBAS and all quorum sets, basically assuming they have irrevocably crashed. Changes the node IDs of remaining nodes! For a similar method hat keeps node IDs unchanged see Fbas::assume_crash_faulty.

pub fn without_nodes(&self, nodes: &[NodeId]) -> Self

Remove nodes (referred to by their node IDs) from the FBAS and all quorum sets, basically assuming they have irrevocably crashed. Changes the node IDs of remaining nodes! For a similar method hat keeps node IDs unchanged see Fbas::assume_crash_faulty.

impl Fbas

pub fn new() -> Self

FBAS of 0 nodes.

pub fn new_generic_unconfigured(n: usize) -> Self

FBAS of n nodes with empty quorum sets

pub fn add_node(&mut self, node: Node) -> NodeId

pub fn add_generic_node(&mut self, quorum_set: QuorumSet) -> NodeId

Add a node with generic public_key

pub fn get_node_id(&self, public_key: &str) -> Option<NodeId>

pub fn get_quorum_set(&self, node_id: NodeId) -> Option<QuorumSet>

pub fn swap_quorum_set( &mut self, node_id: NodeId, quorum_set: QuorumSet ) -> QuorumSet

pub fn number_of_nodes(&self) -> usize

pub fn all_nodes(&self) -> NodeIdSet

pub fn is_quorum(&self, node_set: &NodeIdSet) -> bool

impl Fbas

pub fn shrunken(&self, ids_to_keep: NodeIdSet) -> (Self, ShrinkManager)

impl Fbas

pub fn from_json_str(json: &str) -> Self

pub fn from_json_file(path: &Path) -> Self

pub fn from_json_stdin() -> Self

pub fn to_json_string(&self) -> String

pub fn to_json_string_pretty(&self) -> String

Trait Implementations

impl Clone for Fbas

fn clone(&self) -> Fbas

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Fbas

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Fbas

fn default() -> Fbas

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Fbas

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Fbas

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Fbas

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Fbas

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Fbas

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Fbas

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Fbas

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Fbas