github.com/hyperledger/burrow@v0.34.5-0.20220512172541-77f09336001d/execution/state/registry.go (about)

     1  package state
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/hyperledger/burrow/crypto"
     7  	"github.com/hyperledger/burrow/encoding"
     8  	"github.com/hyperledger/burrow/execution/registry"
     9  	"github.com/hyperledger/burrow/storage"
    10  )
    11  
    12  var _ registry.IterableReader = &State{}
    13  
    14  func getNode(forest storage.ForestReader, id crypto.Address) (*registry.NodeIdentity, error) {
    15  	tree, err := forest.Reader(keys.Registry.Prefix())
    16  	if err != nil {
    17  		return nil, err
    18  	}
    19  	nodeBytes, err := tree.Get(keys.Registry.KeyNoPrefix(id))
    20  	if err != nil {
    21  		return nil, err
    22  	} else if nodeBytes == nil {
    23  		return nil, nil
    24  	}
    25  
    26  	regNode := new(registry.NodeIdentity)
    27  	return regNode, encoding.Decode(nodeBytes, regNode)
    28  
    29  }
    30  
    31  func (s *ImmutableState) GetNodeByID(id crypto.Address) (*registry.NodeIdentity, error) {
    32  	return getNode(s.Forest, id)
    33  }
    34  
    35  func (s *State) GetNodeIDsByAddress(net string) ([]crypto.Address, error) {
    36  	return s.writeState.nodeStats.GetAddresses(net), nil
    37  }
    38  
    39  func (ws *writeState) UpdateNode(id crypto.Address, node *registry.NodeIdentity) error {
    40  	if node == nil {
    41  		return fmt.Errorf("RegisterNode passed nil node in State")
    42  	}
    43  
    44  	bs, err := encoding.Encode(node)
    45  	if err != nil {
    46  		return fmt.Errorf("RegisterNode could not encode node: %v", err)
    47  	}
    48  	return ws.forest.Write(keys.Registry.Prefix(), func(tree *storage.RWTree) error {
    49  		prev, err := getNode(ws.forest, id)
    50  		if err != nil {
    51  			return err
    52  		}
    53  
    54  		ws.nodeStats.Remove(prev)
    55  		ws.nodeStats.Insert(node.GetNetworkAddress(), id)
    56  		tree.Set(keys.Registry.KeyNoPrefix(id), bs)
    57  		return nil
    58  	})
    59  }
    60  
    61  func (ws *writeState) RemoveNode(id crypto.Address) error {
    62  	return ws.forest.Write(keys.Registry.Prefix(), func(tree *storage.RWTree) error {
    63  		prev, err := getNode(ws.forest, id)
    64  		if err != nil {
    65  			return err
    66  		}
    67  
    68  		ws.nodeStats.Remove(prev)
    69  		tree.Delete(keys.Registry.KeyNoPrefix(id))
    70  		return nil
    71  	})
    72  }
    73  
    74  func (s *ImmutableState) IterateNodes(consumer func(crypto.Address, *registry.NodeIdentity) error) error {
    75  	tree, err := s.Forest.Reader(keys.Registry.Prefix())
    76  	if err != nil {
    77  		return err
    78  	}
    79  	return tree.Iterate(nil, nil, true, func(key []byte, value []byte) error {
    80  		rn := new(registry.NodeIdentity)
    81  		err := encoding.Decode(value, rn)
    82  		if err != nil {
    83  			return fmt.Errorf("State.IterateNodes() could not iterate over nodes: %v", err)
    84  		}
    85  		address, err := crypto.AddressFromBytes(key)
    86  		if err != nil {
    87  			return fmt.Errorf("could not decode key: %v", err)
    88  		}
    89  		return consumer(address, rn)
    90  	})
    91  }
    92  
    93  func (s *State) GetNumPeers() int {
    94  	return len(s.writeState.nodeStats.Addresses)
    95  }