rpcsetup

package
v0.0.0-...-ff61ee7 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 5, 2020 License: GPL-3.0 Imports: 26 Imported by: 0

Documentation

Overview

This package contains functions for running nodes over a network, who communicate using RPC for test setup. It also provided client interfaces to RPC functions. See the cmd package for the running the actual binaries.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AllFinished

func AllFinished(scs *SingleConsState)

AllFinished is called after RunSingleConsType has completed running on all nodes to shutdown the node.

func GetDecisions

func GetDecisions(scs *SingleConsState) ([][]byte, error)

GetDecisions returns the decided values at the node. It should be called after RunSingleConsType has finished, and before AllFinished has been called.

func Reset

func Reset(scs *SingleConsState)

Reset is called after AllFinished to do remaining cleanup

func RunCons

func RunCons(setup *SingleConsSetup) (err error)

RunCons sets up a consensus experiment for a single node given the input setup. Once setup is complete RunSingleConsType is called to run the experiment.

func RunSingleConsType

func RunSingleConsType(setup *SingleConsSetup)

RunSingleConsType is called after the setup of RunBinCons1 or RunMvCons1 has completed on all nodes.

Types

type CausalDecisions

type CausalDecisions struct {
	Root             *utils.StringNode
	OrderedDecisions [][]byte
}

CausalDecisions represents the decided values of a causally ordered test.

type NewRunningArgs

type NewRunningArgs struct {
	I             int               // The index of the node in the test (note this is not used in consensus, consensus uses the index of the sorted pub key list)
	To            types.TestOptions // The options of the test
	ParRegAddress string            // The address of the participant register
}

NewRunningArgs is used as the argument to create a new consensus participant for an experiment.

type None

type None int

None is used as input to an RPC call that takes no arguments. It is used so the functions follow the needed go RPC interface.

type ParRegClient

type ParRegClient struct {
	// contains filtered or unexported fields
}

ParRegClient acts as an interface to a ParticipantRegister through rpc.

func NewParRegClient

func NewParRegClient(address string) (pc *ParRegClient, err error)

NewParRegClient creates a new client connection to the ParticipantRegister at address.

func (*ParRegClient) Close

func (pc *ParRegClient) Close() (err error)

Close closes the connection.

func (*ParRegClient) GenBlsShared

func (pc *ParRegClient) GenBlsShared(id, idx, numThresh int) error

GenBlsShared calls ParticipantRegister.GenBlsShared on the server

func (*ParRegClient) GenDSSShared

func (pc *ParRegClient) GenDSSShared(id, numNonMembers, numThresh int) error

GenDSSShared calls ParticipantRegister.GenDSSShared on the server

func (*ParRegClient) GetAllParticipants

func (pc *ParRegClient) GetAllParticipants(id int) (pi []*network.ParticipantInfo, err error)

GetAllParticipants call ParRegClient.GetAllParticipants on the server

func (*ParRegClient) GetBlsShared

func (pc *ParRegClient) GetBlsShared(id, idx int) (*network.BlsSharedMarshalIndex, error)

GetBlsShared calls ParticipantRegister.GetBlsShared on the server

func (*ParRegClient) GetDSSShared

func (pc *ParRegClient) GetDSSShared(id int) (*ed.CoinSharedMarshaled, error)

GetDSSShared calls ParticipantRegister.GetDSSShared on the server

func (*ParRegClient) GetParticipants

func (pc *ParRegClient) GetParticipants(id int, pub sig.PubKeyStr) (pi [][]*network.ParticipantInfo, err error)

GetParticipants call ParticipantRegister.GetParticipants on the server

func (*ParRegClient) NewParReg

func (pc *ParRegClient) NewParReg(ps PregSetup) error

NewParReg calls NewParReg on the server.

func (*ParRegClient) RegisterParticipant

func (pc *ParRegClient) RegisterParticipant(id int, parInfo *network.ParticipantInfo) error

RegisterParticipant calls ParticipantRegister.RegisterParticipant on the server

type PregClientWrapper

type PregClientWrapper struct {
	network.ParRegClientInterface
	// contains filtered or unexported fields
}

PregClientWrapper wraps the ParRegClient object with the nework.PregInterface interface.

func NewPregClientWrapper

func NewPregClientWrapper(cli network.ParRegClientInterface, id int) *PregClientWrapper

func (*PregClientWrapper) GenBlsShared

func (pr *PregClientWrapper) GenBlsShared(idx, numThresh int) error

func (*PregClientWrapper) GenDSSShared

func (pr *PregClientWrapper) GenDSSShared(numNonNumbers, numThresh int) error

func (*PregClientWrapper) GetAllParticipants

func (pr *PregClientWrapper) GetAllParticipants() ([]*network.ParticipantInfo, error)

func (*PregClientWrapper) GetBlsShared

func (pr *PregClientWrapper) GetBlsShared(idx int) (index int, blsShared *bls.BlsSharedMarshal)

func (*PregClientWrapper) GetDSSShared

func (pr *PregClientWrapper) GetDSSShared() ed.CoinSharedMarshaled

func (*PregClientWrapper) GetParticipants

func (pr *PregClientWrapper) GetParticipants(pub sig.PubKeyStr) ([][]*network.ParticipantInfo, error)

func (*PregClientWrapper) RegisterParticipant

func (pr *PregClientWrapper) RegisterParticipant(parInfo *network.ParticipantInfo) error

type PregSetup

type PregSetup struct {
	ID        int                             // identifier of the par reg
	ConnType  network.NetworkPropagationSetup // The network propagation type
	NodeCount int                             // The number of participants in the consensus
}

PregSetup is used as the agrument to create a new ParticipantRegister through rpc

type RPCNodeClient

type RPCNodeClient struct {
	// contains filtered or unexported fields
}

RPCNodeClient creates a connection to a node running a RunningCons rpc server, (see cmd.RunninCons)

func NewRPCNodeClient

func NewRPCNodeClient(address string) (rnc *RPCNodeClient, err error)

NewRPCNodeClient creates a client connection to the node at address running a RunningCons rpc server.

func (*RPCNodeClient) AllFinished

func (rnc *RPCNodeClient) AllFinished() (err error)

AllFinished calls RunningCons.AllFinished at the remote node.

func (*RPCNodeClient) AllStart

func (rnc *RPCNodeClient) AllStart() (err error)

AllStart calls RunningCons.AllStart at the remote node.

func (*RPCNodeClient) Close

func (rnc *RPCNodeClient) Close() (err error)

Close closes the connection.

func (*RPCNodeClient) Exit

func (rnc *RPCNodeClient) Exit() (err error)

Exit calls RunningCons.Exit at the remote node.

func (*RPCNodeClient) GetCausalDecisions

func (rnc *RPCNodeClient) GetCausalDecisions(i int) (dec CausalDecisions, err error)

GetDecisions calls RunningCons.GetDecisions for index i at the remote node.

func (*RPCNodeClient) GetDecisions

func (rnc *RPCNodeClient) GetDecisions(i int) (dec [][]byte, err error)

GetDecisions calls RunningCons.GetDecisions for index i at the remote node.

func (*RPCNodeClient) GetResults

func (rnc *RPCNodeClient) GetResults(i int, proposerStatsObj consinterface.SMStats) (res RpcResults, err error)

GetResults calls RunningCons.GetResults for index i at the remote node.

func (*RPCNodeClient) NewConsRunning

func (rnc *RPCNodeClient) NewConsRunning(nra NewRunningArgs) (err error)

NewMvCons1Running calls RunningCons.NewMvConsRunning at the remote node.

func (*RPCNodeClient) Reset

func (rnc *RPCNodeClient) Reset() (err error)

Reset calls RunningCons.Reset at the remote node.

type RpcResults

type RpcResults struct {
	Stats *stats.MergedStats // Binary consensus statistics
	// NwStats  *stats.BasicNwStats  // Network statistics
	SMStats consinterface.SMStats
}

RpcResults is used to transport the results of an experiment in a struct as the result of a rpc call. TODO this is hardcoded to binary/simple nw stats, should make more general.

type SingleConsSetup

type SingleConsSetup struct {
	I      int                           // The index of the node in the test (note this is not used in consensus, consensus uses the index of the sorted pub key list)
	MyIP   string                        // The ip address and port of the node
	To     types.TestOptions             // The test setup
	ParReg network.ParRegClientInterface // RPC connection to the participant register
	SCS    *SingleConsState              // Pointer to the actual state
	Mutex  *sync.RWMutex

	SetInitialConfig *bool
	SetInitialHash   *bool
	Shared           *consinterface.Shared
}

SingleConsSetup contains all the details for a single node to start running a test.

type SingleConsState

type SingleConsState struct {
	I                  int                            // The index of the node in the test (note this is not used in consensus, consensus uses the index of the sorted pub key list)
	MyIP               string                         // The ip address and port of the node
	PrivKey            sig.Priv                       // The private key
	RandKey            [32]byte                       // Key for random number generation
	To                 types.TestOptions              // The test setup
	TestProc           channelinterface.MainChannel   // The main channel
	NetNodeInfo        []channelinterface.NetNodeInfo // The local connection information
	StorageFileName    string                         // name of the storage file
	RetExtraParRegInfo [][]byte                       // Per process extra info (usually generated by the state machine, ex an init block)
	NumCons            []int                          // Number of connections to make

	FinishedChan     chan channelinterface.ChannelCloseType // Where we wait for cons to finish
	FailFinishedChan chan channelinterface.ChannelCloseType // Where we wait for failure cons to finish

	ConsState          cons.ConsStateInterface
	MemberCheckerState consinterface.ConsStateInterface
	BcastFunc          consinterface.ByzBroadcastFunc // Function to check if should act byzantine

	Sc    consinterface.ConsItem // The init consensus object
	Ds    storage.StoreInterface // The interface to the disk storage
	Stats stats.StatsInterface   // The statsistics tracking
	// NwStats              stats.NwStatsInterface                // Network statistics tracking
	ParReg     network.ParRegClientInterface // RPC connection to the participant register
	ParRegsInt []network.PregInterface       // Interface to ParReg for using functions from cons package
	Gc         *generalconfig.GeneralConfig  // the general config

	*consinterface.Shared
}

SingleConsState tracks the state of a single node when running an experiment over a network.

type TPanic

type TPanic struct{}

func (TPanic) Errorf

func (tp TPanic) Errorf(format string, args ...interface{})

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL