state

package
v6.4.2-rc2+incompatible Latest Latest
Warning

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

 Go to latest Published: Sep 18, 2019 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause, + 4 more Imports: 54 Imported by: 80

Documentation

Overview

Defines the state for factoid. By using the proper interfaces, the functionality of factoid can be imported into any framework.

Index

Constants

View Source 
const BATCH_SIZE uint32 = 250

BATCH_SIZE is the amount of blocks per torrent

View Source 
const Range = 60 // Double this for the period we protect, i.e. 120 means +/- 120 minutes

Variables

View Source 
var (
	// Time window for identity to require registration: 24hours = 144 blocks
	TIME_WINDOW uint32 = 144

	// Where all Identities register
	MAIN_FACTOM_IDENTITY_LIST = "888888001750ede0eff4b05f0c3f557890b256450cabbb84cada937f9c258327"
)
View Source 
var (

	// Entry Syncing Controller
	ESMissingQueue = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_missing_entry_queue",
		Help: "Number of known missing entries in our queue to find.",
	})
	ESMissing = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_missing_entries",
		Help: "Number of known missing entries",
	})
	ESFound = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_found_entries",
		Help: "Number of known missing entries found.",
	})
	ESAsking = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_asking_missing_entries",
		Help: "Number we are asking for of the known missing entries.",
	})
	ESHighestAsking = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_highest_asking_entries",
		Help: "Highest entry DBHeight which has has a request made.",
	})
	ESHighestMissing = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_highest_missing_entries",
		Help: "Highest DBHeight of the entries we know are missing.",
	})
	ESFirstMissing = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_first_missing_entries",
		Help: "First DBHeight with a missing entry",
	})
	ESDBHTComplete = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_entry_dbheight_complete",
		Help: "First DBHeight with a missing entry",
	})
	ESAvgRequests = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_es_average_requests",
		Help: "Average number of times we have had to request a missing entry",
	})
	HighestAck = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_highest_ack",
		Help: "Acknowledgement with the highest directory block height",
	})
	HighestKnown = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_highest_known",
		Help: "Highest known block (which can be different than the highest ack)",
	})
	HighestSaved = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_highest_saved",
		Help: "Highest saved block to the database",
	})
	HighestCompleted = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_highest_completed",
		Help: "Highest completed block, which may or may not be saved to the database",
	})

	// TPS
	TotalTransactionPerSecond = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_txrate_total_tps",
		Help: "Total transactions over life of node",
	})

	InstantTransactionPerSecond = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_txrate_instant_tps",
		Help: "Total transactions over life of node weighted for last 3 seconds",
	})

	// Queues
	CurrentMessageQueueInMsgGeneralVec = prometheus.NewGaugeVec(prometheus.GaugeOpts{
		Name: "factomd_state_queue_current_general_inmsg_vec",
		Help: "Instrumenting the current  inmsg queue ",
	}, []string{"message"})

	TotalMessageQueueInMsgGeneralVec = prometheus.NewGaugeVec(prometheus.GaugeOpts{
		Name: "factomd_state_queue_total_general_inmsg_vec",
		Help: "Instrumenting the inmsg queue ",
	}, []string{"message"})

	CurrentMessageQueueApiGeneralVec = prometheus.NewGaugeVec(prometheus.GaugeOpts{
		Name: "factomd_state_queue_current_general_api_vec",
		Help: "Instrumenting the current API queue ",
	}, []string{"message"})

	TotalMessageQueueApiGeneralVec = prometheus.NewGaugeVec(prometheus.GaugeOpts{
		Name: "factomd_state_queue_total_general_api_vec",
		Help: "Instrumenting the API queue ",
	}, []string{"message"})

	TotalMessageQueueNetOutMsgGeneralVec = prometheus.NewGaugeVec(prometheus.GaugeOpts{
		Name: "factomd_state_queue_total_general_netoutmsg_vec",
		Help: "Instrumenting the netoutmsg queue ",
	}, []string{"message"})

	// MsgQueue chan
	TotalMsgQueueInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_msgqueue_total_inputs",
		Help: "Tally of total messages gone into MsgQueue (useful for rating)",
	})
	TotalMsgQueueOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_msgqueue_total_outputs",
		Help: "Tally of total messages drained out of MsgQueue (useful for rating)",
	})

	// Holding Queue
	TotalHoldingQueueInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_total_inputs",
		Help: "Tally of total messages gone into Holding (useful for rating)",
	})
	TotalHoldingQueueOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_total_outputs",
		Help: "Tally of total messages drained out of Holding (useful for rating)",
	})
	TotalHoldingQueueRecycles = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_total_recycles",
		Help: "Tally of total messages recycled thru Holding (useful for rating)",
	})
	HoldingQueueDBSigInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_dbsig_inputs",
		Help: "Tally of DBSig messages gone into Holding (useful for rating)",
	})
	HoldingQueueDBSigOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_dbsig_outputs",
		Help: "Tally of DBSig messages drained out of Holding",
	})
	HoldingQueueCommitEntryInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_commitentry_inputs",
		Help: "Tally of CommitEntry messages gone into Holding (useful for rating)",
	})
	HoldingQueueCommitEntryOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_commitentry_outputs",
		Help: "Tally of CommitEntry messages drained out of Holding",
	})
	HoldingQueueCommitChainInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_commitchain_inputs",
		Help: "Tally of CommitChain messages gone into Holding (useful for rating)",
	})
	HoldingQueueCommitChainOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_commitchain_outputs",
		Help: "Tally of CommitChain messages drained out of Holding",
	})
	HoldingQueueRevealEntryInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_revealentry_inputs",
		Help: "Tally of RevealEntry messages gone into Holding (useful for rating)",
	})
	HoldingQueueRevealEntryOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_holding_queue_revealentry_outputs",
		Help: "Tally of RevealEntry messages drained out of Holding",
	})

	// Acks Queue
	TotalAcksInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_acks_total_inputs",
		Help: "Tally of total messages gone into Acks (useful for rating)",
	})
	TotalAcksOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_acks_total_outputs",
		Help: "Tally of total messages drained out of Acks (useful for rating)",
	})

	// Commits map
	TotalCommitsInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_commits_total_inputs",
		Help: "Tally of total messages gone into Commits (useful for rating)",
	})
	TotalCommitsOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_commits_total_outputs",
		Help: "Tally of total messages drained out of Commits (useful for rating)",
	})

	// XReview Queue
	TotalXReviewQueueInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_xreview_queue_total_inputs",
		Help: "Tally of total messages gone into XReview (useful for rating)",
	})
	TotalXReviewQueueOutputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_xreview_queue_total_outputs",
		Help: "Tally of total messages drained out of XReview (useful for rating)",
	})

	// Executions
	LeaderExecutions = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_leader_executions",
		Help: "Tally of total messages executed via LeaderExecute",
	})
	FollowerExecutions = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_follower_executions",
		Help: "Tally of total messages executed via FollowerExecute",
	})
	LeaderEOMExecutions = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_leader_eom_executions",
		Help: "Tally of total messages executed via LeaderExecuteEOM",
	})
	FollowerEOMExecutions = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_follower_eom_executions",
		Help: "Tally of total messages executed via FollowerExecuteEOM",
	})
	FollowerMissingMsgExecutions = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_follower_mm_executions",
		Help: "Tally of total messages executed via FollowerExecuteMissingMsg",
	})

	// ProcessList
	TotalProcessListInputs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_process_list_inputs",
		Help: "Tally of total messages gone into ProcessLists (useful for rating)",
	})
	TotalProcessListProcesses = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_process_list_processes",
		Help: "Tally of total messages processed from ProcessLists (useful for rating)",
	})
	TotalProcessEOMs = prometheus.NewCounter(prometheus.CounterOpts{
		Name: "factomd_state_process_eom_processes",
		Help: "Tally of EOM messages processed from ProcessLists (useful for rating)",
	})

	// Durations
	TotalReviewHoldingTime = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_review_holding_time",
		Help: "Time spent in ReviewHolding()",
	})
	TotalProcessXReviewTime = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_process_xreview_time",
		Help: "Time spent Processing XReview",
	})
	TotalProcessProcChanTime = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_process_proc_chan_time",
		Help: "Time spent Processing Process Chan",
	})
	TotalEmptyLoopTime = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_empty_loop_time",
		Help: "Time spent in empty loop",
	})
	TotalAckLoopTime = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_ack_loop_time",
		Help: "Time spent in ack loop",
	})
	TotalExecuteMsgTime = prometheus.NewGauge(prometheus.GaugeOpts{
		Name: "factomd_state_execute_msg_time",
		Help: "Time spent in executeMsg",
	})
)
View Source 
var ControlPanelAllowedSize int = 2
View Source 
var FACTOID_CHAINID_HASH = primitives.NewHash(constants.FACTOID_CHAINID)
View Source 
var FilterTimeLimit = int64(Range * 60 * 2 * 1000000000) // Filter hold two hours of messages, one in the past one in the future
View Source 
var MMR_enable bool = true

Used by debug code only

View Source 
var ValidationDebug bool = false

Functions

func AppendExtIDs 

func AppendExtIDs(extIDs [][]byte, start int, end int) ([]byte, error)

func BytesToUint32 

func BytesToUint32(data []byte) (ret uint32, err error)

func CheckDBKeyMR 

func CheckDBKeyMR(s *State, ht uint32, hash string) error

*************************************************************** Checkpoint DBKeyMR ***************************************************************

func CheckGrants 

func CheckGrants()

func CheckLength 

func CheckLength(length int, item []byte) bool

func CheckSig 

func CheckSig(idKey interfaces.IHash, pub []byte, msg []byte, sig []byte) bool

Sig is signed message, msg is raw message

func DeleteFile 

func DeleteFile(filename string) error

func FaultCheck 

func FaultCheck(pl *ProcessList)

func FedServerVM 

func FedServerVM(serverMap [10][64]int, numberOfFedServers int, minute int, fedIndex int) int

func GenerateGenesisBlocks 

func GenerateGenesisBlocks(networkID uint32, bootstrapIdentity interfaces.IHash) (interfaces.IDirectoryBlock, interfaces.IAdminBlock, interfaces.IFBlock, interfaces.IEntryCreditBlock)

func GetGrantPayoutsFor 

func GetGrantPayoutsFor(currentDBHeight uint32) []interfaces.ITransAddress

return a (possibly empty) of coinbase payouts to be scheduled at this height

func GetMapHash 

func GetMapHash(bmap map[[32]byte]int64) interfaces.IHash

func HeightToHash 

func HeightToHash(height uint32, minute int) [32]byte

put a height in the first 5 bytes of a hash so we can use it to look up dependent message in holding

func LoadDatabase 

func LoadDatabase(s *State)

func LoadFromFile 

func LoadFromFile(s *State, filename string) ([]byte, error)

func MakeMap 

func MakeMap(numberFedServers int, dbheight uint32) (serverMap [10][64]int)

This function will be replaced by a calculation from the Matryoshka hashes from the servers but for now, we are just going to make it a function of the dbheight. serverMap[minute][vmIndex] => Index of the Federated Server responsible for that minute

func Minutes 

func Minutes(unix int64) int

Remember that Unix time is in seconds since 1970. This code wants to be handed time in seconds.

func NetworkIDToFilename 

func NetworkIDToFilename(networkName string, fileLocation string) string

func NonBlockingChannelAdd 

func NonBlockingChannelAdd(channel chan interfaces.IMsg, msg interfaces.IMsg) bool

NonBlockingChannelAdd will only add to the channel if the action is non-blocking

func PopBalanceMap 

func PopBalanceMap(buf *primitives.Buffer) (map[[32]byte]int64, error)

func PopBucketMap 

func PopBucketMap(buf *primitives.Buffer) (map[[32]byte]int, error)

func PrintState 

func PrintState(state *State)

func ProcessIdentityToAdminBlock 

func ProcessIdentityToAdminBlock(st *State, chainID interfaces.IHash, servertype int) bool

Called by AddServer Message

func PushBalanceMap 

func PushBalanceMap(b *primitives.Buffer, m map[[32]byte]int64) error

func PushBucketMap 

func PushBucketMap(b *primitives.Buffer, m map[[32]byte]int) error

func RandomServer 

func RandomServer() interfaces.IServer

func RegisterPrometheus 

func RegisterPrometheus()

RegisterPrometheus registers the variables to be exposed. This can only be run once, hence the boolean flag to prevent panics if launched more than once. This is called in NetStart

func SaveToFile 

func SaveToFile(s *State, dbht uint32, b []byte, filename string) error

func SortServers 

func SortServers(servers []interfaces.IServer) []interfaces.IServer

func Uint32ToBytes 

func Uint32ToBytes(val uint32) ([]byte, error)

Types

type ACKMap 

type ACKMap struct {
	Acks     map[MsgHeight]interfaces.IMsg
	MsgOrder [1000]MsgHeight
	N        int
}

map of the last N Acks indexed by height

func (*ACKMap) Add 

func (a *ACKMap) Add(msg interfaces.IMsg)

Adds Acks to a map of the last 1000 acks The map of acks will be used in tandem with the message map when we get an MMR to ensure we don't ask for a message we already have.

func (*ACKMap) Get 

func (a *ACKMap) Get(DBHeight int, vmIndex int, height int) interfaces.IMsg

type APIMSGQueue 

type APIMSGQueue chan interfaces.IMsg

APIMSGQueue counts incoming and outgoing messages for API queue

func NewAPIQueue 

func NewAPIQueue(capacity int) APIMSGQueue

func (APIMSGQueue) BlockingDequeue 

func (q APIMSGQueue) BlockingDequeue() interfaces.IMsg

BlockingDequeue will block until it retrieves from queue

func (APIMSGQueue) Cap 

func (q APIMSGQueue) Cap() int

Cap of underlying channel

func (APIMSGQueue) Dequeue 

func (q APIMSGQueue) Dequeue() interfaces.IMsg

Dequeue removes an item from channel and instruments based on type. Returns nil if nothing in queue

func (APIMSGQueue) Enqueue 

func (q APIMSGQueue) Enqueue(m interfaces.IMsg)

Enqueue adds item to channel and instruments based on type

func (APIMSGQueue) Length 

func (q APIMSGQueue) Length() int

Length of underlying channel

type AckMsgPairCache 

type AckMsgPairCache struct {
	CurrentWorkingHeight int
	// MsgPairMap will contain ack/msg pairs
	MsgPairMap map[int]map[plRef]*MsgPair
}

func NewAckMsgCache 

func NewAckMsgCache() *AckMsgPairCache

func (*AckMsgPairCache) AddMsgPair 

func (a *AckMsgPairCache) AddMsgPair(pair *MsgPair)

AddMsgPair will add an ack to the cache if it is not too old, and it is an ack+msg pair 

We assume that all msgs being added have been added to our processlist, and therefore
the current working height and they are valid.

func (*AckMsgPairCache) Expire 

func (a *AckMsgPairCache) Expire(newHeight int)

Expire for the AckMsgPairCache will expire all acks older than 2 blocks. 

TODO: Is iterating over a map extra cost? Should we have a sorted list?
		Technically we can just call delete NewHeight-2 as long as we always
		Update every height

func (*AckMsgPairCache) Get 

func (a *AckMsgPairCache) Get(dbHeight, vmIndex, plHeight int) *MsgPair

func (*AckMsgPairCache) HeightTooOld 

func (a *AckMsgPairCache) HeightTooOld(height int) bool

HeightTooOld determines if the ack height is too old for the ackcache

func (*AckMsgPairCache) UpdateWorkingHeight 

func (a *AckMsgPairCache) UpdateWorkingHeight(newHeight int)

UpdateWorkingHeight will only update the height if it is new

type ByKey 

type ByKey [][32]byte

func (ByKey) Len 

func (f ByKey) Len() int

func (ByKey) Less 

func (f ByKey) Less(i, j int) bool

func (ByKey) Swap 

func (f ByKey) Swap(i, j int)

type CrossReplayFilter 

type CrossReplayFilter struct {
	Currentheight int
	LowestHeight  int
	// contains filtered or unexported fields
}

CrossReplayFilter checks for old messages across reboots based on the salts inside the ack messages. It saves all salts of leaders it sees while running. On reboot, it will ignore all messages that have an old salt (for a set duration). After the duration, no new salts are saved (extra overhead we don't need) and will stop ignoring messages based on salts (so a single leader reboot will rejoin the network).

func NewCrossReplayFilter 

func NewCrossReplayFilter(path string) *CrossReplayFilter

func (*CrossReplayFilter) AddSalt 

func (c *CrossReplayFilter) AddSalt(height uint32, salt [8]byte) error

AddSalt will add the salt to the replay filter that is used on reboot

func (*CrossReplayFilter) Close 

func (c *CrossReplayFilter) Close()

func (*CrossReplayFilter) ExistOldSalt 

func (c *CrossReplayFilter) ExistOldSalt(salt [8]byte) bool

ExistOldSalt checks to see if the salt existed on the previous boot

func (*CrossReplayFilter) ExistSalt 

func (c *CrossReplayFilter) ExistSalt(salt [8]byte) (bool, error)

Exists check if the hash is in the replay filter, and if it encounters a db error, it will report false

func (*CrossReplayFilter) Run 

func (c *CrossReplayFilter) Run()

Run is a simple loop that ensures we discard old data we do not need.

type DBSig 

type DBSig struct {
	ChainID   interfaces.IHash
	Signature interfaces.IFullSignature
	VMIndex   int
}

Data needed to add to admin block

type DBState 

type DBState struct {
	IsNew bool

	SaveStruct *SaveState

	DBHash interfaces.IHash
	ABHash interfaces.IHash
	FBHash interfaces.IHash
	ECHash interfaces.IHash

	DirectoryBlock   interfaces.IDirectoryBlock
	AdminBlock       interfaces.IAdminBlock
	FactoidBlock     interfaces.IFBlock
	EntryCreditBlock interfaces.IEntryCreditBlock

	EntryBlocks []interfaces.IEntryBlock
	Entries     []interfaces.IEBEntry

	Repeat      bool
	ReadyToSave bool
	Locked      bool
	Signed      bool
	Saved       bool

	Added interfaces.Timestamp

	FinalExchangeRate uint64
	NextTimestamp     interfaces.Timestamp
}

func (*DBState) Init 

func (dbs *DBState) Init()

func (*DBState) IsSameAs 

func (a *DBState) IsSameAs(b *DBState) bool

func (*DBState) MarshalBinary 

func (dbs *DBState) MarshalBinary() (rval []byte, err error)

func (*DBState) String 

func (ds *DBState) String() string

func (*DBState) UnmarshalBinary 

func (dbs *DBState) UnmarshalBinary(p []byte) error

func (*DBState) UnmarshalBinaryData 

func (dbs *DBState) UnmarshalBinaryData(p []byte) (newData []byte, err error)

func (*DBState) ValidNext 

func (d *DBState) ValidNext(state *State, next *messages.DBStateMsg) int

Validate this directory block given the next Directory Block. Need to check the signatures as being from the authority set, and valid. Also check that this DBState holds a previous KeyMR that matches the previous DBState KeyMR.

Return a -1 on failure.

type DBStateList 

type DBStateList struct {
	LastEnd       int
	LastBegin     int
	TimeToAsk     interfaces.Timestamp
	ProcessHeight uint32
	SavedHeight   uint32
	State         *State
	Base          uint32
	Complete      uint32
	DBStates      []*DBState
}

func (*DBStateList) Catchup 

func (list *DBStateList) Catchup()

TODO: Redesign Catchup. Some assumptions were made that made this more TODO: complex than it needed to be. 

func (list *DBStateList) FixupLinks(p *DBState, d *DBState) (progress bool)

p is previous, d is current

func (*DBStateList) Get 

func (list *DBStateList) Get(height int) *DBState

func (*DBStateList) GetHighestCompletedBlk 

func (list *DBStateList) GetHighestCompletedBlk() uint32

func (*DBStateList) GetHighestLockedSignedAndSavesBlk 

func (list *DBStateList) GetHighestLockedSignedAndSavesBlk() uint32

func (*DBStateList) GetHighestSavedBlk 

func (list *DBStateList) GetHighestSavedBlk() uint32

func (*DBStateList) GetHighestSignedBlk 

func (list *DBStateList) GetHighestSignedBlk() uint32

func (*DBStateList) Highest 

func (list *DBStateList) Highest() uint32

func (*DBStateList) Init 

func (dbsl *DBStateList) Init()

func (*DBStateList) IsSameAs 

func (a *DBStateList) IsSameAs(b *DBStateList) bool

func (*DBStateList) Last 

func (list *DBStateList) Last() *DBState

func (*DBStateList) MarshalBinary 

func (dbsl *DBStateList) MarshalBinary() (rval []byte, err error)

func (*DBStateList) NewDBState 

func (list *DBStateList) NewDBState(isNew bool,
	directoryBlock interfaces.IDirectoryBlock,
	adminBlock interfaces.IAdminBlock,
	factoidBlock interfaces.IFBlock,
	entryCreditBlock interfaces.IEntryCreditBlock,
	eBlocks []interfaces.IEntryBlock,
	entries []interfaces.IEBEntry) *DBState

func (*DBStateList) ProcessBlocks 

func (list *DBStateList) ProcessBlocks(d *DBState) (progress bool)

func (*DBStateList) Put 

func (list *DBStateList) Put(dbState *DBState) bool

Return true if we actually added the dbstate to the list

func (*DBStateList) SaveDBStateToDB 

func (list *DBStateList) SaveDBStateToDB(d *DBState) (progress bool)

func (*DBStateList) SignDB 

func (list *DBStateList) SignDB(d *DBState) (process bool)

We don't really do the signing here, but just check that we have all the signatures. If we do, we count that as progress.

func (*DBStateList) String 

func (list *DBStateList) String() string

func (*DBStateList) UnmarshalBinary 

func (dbsl *DBStateList) UnmarshalBinary(p []byte) error

func (*DBStateList) UnmarshalBinaryData 

func (dbsl *DBStateList) UnmarshalBinaryData(p []byte) (newData []byte, err error)

func (*DBStateList) UpdateState 

func (list *DBStateList) UpdateState() (progress bool)

func (*DBStateList) WriteDBStateToDebugFile 

func (list *DBStateList) WriteDBStateToDebugFile(d *DBState)

WriteDBStateToDebugFile will write the marshaled dbstate to a file alongside the database. This can be written on the processblocks, so in the event the block does not get written to disk in the event of a stall, the dbstate can be analyzed. The written dbstate does NOT include entries.

type DisplayState 

type DisplayState struct {
	NodeName string

	ControlPanelPort    int
	ControlPanelSetting int

	// DB Info
	CurrentNodeHeight   uint32
	CurrentLeaderHeight uint32
	CurrentEBDBHeight   uint32
	LeaderHeight        uint32
	LastDirectoryBlock  interfaces.IDirectoryBlock

	// Identity Info
	IdentityChainID interfaces.IHash
	Identities      []*Identity
	Authorities     []*Authority
	PublicKey       *primitives.PublicKey

	// Process List
	PLFactoid []FactoidTransaction
	PLEntry   []EntryTransaction

	// DataDump
	RawSummary          string
	PrintMap            string
	ProcessList0        string
	ProcessList         string
	ProcessList2        string
	Election            string
	SimElection         string
	SyncingState        [256]string
	SyncingStateCurrent int
	IgnoreDone          bool
}

This struct will contain all information wanted by the control panel from the state.

func DeepStateDisplayCopy 

func DeepStateDisplayCopy(s *State) (*DisplayState, error)

func DeepStateDisplayCopyDifference 

func DeepStateDisplayCopyDifference(s *State, prev *DisplayState) (*DisplayState, error)

func NewDisplayState 

func NewDisplayState() *DisplayState

func (*DisplayState) Clone 

func (d *DisplayState) Clone() *DisplayState

Used for display dump. Allows a clone of the display state to be made

func (*DisplayState) CopyDirectoryBlock 

func (ds *DisplayState) CopyDirectoryBlock(s *State, prev *DisplayState, height uint32)

type ElectionQueue 

type ElectionQueue chan interfaces.IMsg

ElectionQueue counts incoming and outgoing messages for inmsg queue

func NewElectionQueue 

func NewElectionQueue(capacity int) ElectionQueue

func (ElectionQueue) BlockingDequeue 

func (q ElectionQueue) BlockingDequeue() interfaces.IMsg

BlockingDequeue will block until it retrieves from queue

func (ElectionQueue) Cap 

func (q ElectionQueue) Cap() int

Cap of underlying channel

func (ElectionQueue) Dequeue 

func (q ElectionQueue) Dequeue() interfaces.IMsg

Dequeue removes an item from channel and instruments based on type. Returns nil if nothing in queue

func (ElectionQueue) Enqueue 

func (q ElectionQueue) Enqueue(m interfaces.IMsg)

Enqueue adds item to channel and instruments based on type

func (ElectionQueue) Length 

func (q ElectionQueue) Length() int

Length of underlying channel

type EntrySync 

type EntrySync struct {
	MissingDBlockEntries chan []*ReCheck    // We don't have these entries.  Each list is from a directory block.
	DBHeightBase         int                // This is the highest block with entries not yet checked or are missing
	TotalEntries         int                // Total Entries in the database
	SyncingBlocks        map[int][]*ReCheck // Map of Directory blocks by height

	SendRequest              chan *messages.MissingData // Channel for messages being requested
	Processing               int                        // Directory block we are processing
	EntriesProcessing        int                        // Total of Entries being processed
	EntryRequests            int                        // Requests made
	EntriesFound             int                        // Entries found
	DirectoryBlocksInProcess int                        // Number of Directory blocks we are processing
	// contains filtered or unexported fields
}

func (*EntrySync) Init 

func (es *EntrySync) Init()

Maintain queues of what we want to test, and what we are currently testing.

type EntryTransaction 

type EntryTransaction struct {
	ChainID   string
	EntryHash string
}

type EntryUpdate 

type EntryUpdate struct {
	Hash      interfaces.IHash
	Timestamp interfaces.Timestamp
}

type FactoidState 

type FactoidState struct {
	DBHeight     uint32
	State        *State
	CurrentBlock interfaces.IFBlock
	Wallet       interfaces.ISCWallet
}

func (*FactoidState) AddECBlock 

func (fs *FactoidState) AddECBlock(blk interfaces.IEntryCreditBlock) error

func (*FactoidState) AddTransaction 

func (fs *FactoidState) AddTransaction(index int, trans interfaces.ITransaction) error

Only add valid transactions to the current

func (*FactoidState) AddTransactionBlock 

func (fs *FactoidState) AddTransactionBlock(blk interfaces.IFBlock) error

When we are playing catchup, adding the transaction block is a pretty useful feature.

func (*FactoidState) EndOfPeriod 

func (fs *FactoidState) EndOfPeriod(period int)

func (*FactoidState) GetBalanceHash 

func (fs *FactoidState) GetBalanceHash(TempBalanceHash bool) (rval interfaces.IHash)

GetBalanceHash() Compute either a Hash of the temporary balance hash map, or the Permanent Balance hash map

func (*FactoidState) GetCoinbaseTransaction 

func (fs *FactoidState) GetCoinbaseTransaction(dbheight uint32, ftime interfaces.Timestamp) interfaces.ITransaction

func (*FactoidState) GetCurrentBlock 

func (fs *FactoidState) GetCurrentBlock() interfaces.IFBlock

func (*FactoidState) GetECBalance 

func (fs *FactoidState) GetECBalance(address [32]byte) int64

func (*FactoidState) GetFactoidBalance 

func (fs *FactoidState) GetFactoidBalance(address [32]byte) int64

func (*FactoidState) GetMultipleECBalances 

func (fs *FactoidState) GetMultipleECBalances(singleAdd [32]byte) (uint32, uint32, int64, int64, string)

func (*FactoidState) GetMultipleFactoidBalances 

func (fs *FactoidState) GetMultipleFactoidBalances(singleAdd [32]byte) (uint32, uint32, int64, int64, string)

func (*FactoidState) ProcessEndOfBlock 

func (fs *FactoidState) ProcessEndOfBlock(state interfaces.IState)

End of Block means packing the current block away, and setting up the next

func (*FactoidState) UpdateECTransaction 

func (fs *FactoidState) UpdateECTransaction(rt bool, trans interfaces.IECBlockEntry) error

func (*FactoidState) UpdateTransaction 

func (fs *FactoidState) UpdateTransaction(rt bool, trans interfaces.ITransaction) error

Assumes validation has already been done.

func (*FactoidState) Validate 

func (fs *FactoidState) Validate(index int, trans interfaces.ITransaction) (err error, holdAddr [32]byte)

Returns an error message about what is wrong with the transaction if it is invalid, otherwise you are good to go.

func (*FactoidState) ValidateTransactionAge 

func (fs *FactoidState) ValidateTransactionAge(trans interfaces.ITransaction) error

Checks the transaction timestamp for validity in being included in the current No node has any responsibility to forward on transactions that do not fall within the timeframe around a block defined by TRANSACTION_PRIOR_LIMIT and TRANSACTION_POST_LIMIT

type FactoidTransaction 

type FactoidTransaction struct {
	TxID         string
	Hash         string
	TotalInput   string
	Status       string
	TotalInputs  int
	TotalOutputs int
}

type FaultCore 

type FaultCore struct {
	// The following 5 fields represent the "Core" of the message
	// This should match the Core of FullServerFault messages
	ServerID      interfaces.IHash
	AuditServerID interfaces.IHash
	VMIndex       byte
	DBHeight      uint32
	Height        uint32
	SystemHeight  uint32
	Timestamp     interfaces.Timestamp
}

func (*FaultCore) GetHash 

func (fc *FaultCore) GetHash() (rval interfaces.IHash)

func (*FaultCore) MarshalCore 

func (fc *FaultCore) MarshalCore() (data []byte, err error)

type GeneralMSGQueue 

type GeneralMSGQueue chan interfaces.IMsg

Returning this is non-instrumented way

func (GeneralMSGQueue) BlockingDequeue 

func (q GeneralMSGQueue) BlockingDequeue() interfaces.IMsg

func (GeneralMSGQueue) Cap 

func (q GeneralMSGQueue) Cap() int

Cap of underlying channel

func (GeneralMSGQueue) Dequeue 

func (q GeneralMSGQueue) Dequeue() interfaces.IMsg

Dequeue returns the channel dequeue

func (GeneralMSGQueue) Enqueue 

func (q GeneralMSGQueue) Enqueue(t interfaces.IMsg)

Enqueue adds item to channel

func (GeneralMSGQueue) Length 

func (q GeneralMSGQueue) Length() int

Length of underlying channel

type GenericListItem 

type GenericListItem interface {
	Height() uint32
}

type HardGrant 

type HardGrant struct {
	DBh     uint32
	Amount  uint64
	Address interfaces.IAddress
}

func GetHardCodedGrants 

func GetHardCodedGrants() []HardGrant

Return the Hard Coded Grants. Buried in an func so other code cannot easily Address the array and change it

type HoldingList 

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

This hold a slice of messages dependent on a hash

func (*HoldingList) Add 

func (l *HoldingList) Add(h [32]byte, msg interfaces.IMsg) bool

Add a message to a dependent holding list

func (*HoldingList) ExecuteForNewHeight 

func (l *HoldingList) ExecuteForNewHeight(ht uint32, minute int)

func (*HoldingList) Get 

func (l *HoldingList) Get(h [32]byte) []interfaces.IMsg

get and remove the list of dependent message for a hash

func (*HoldingList) GetDependentMsg 

func (l *HoldingList) GetDependentMsg(h [32]byte) interfaces.IMsg

Get a single msg from dependent holding

func (*HoldingList) GetSize 

func (l *HoldingList) GetSize() int

func (*HoldingList) Init 

func (l *HoldingList) Init(s *State)

func (*HoldingList) Messages 

func (l *HoldingList) Messages() map[[32]byte][]interfaces.IMsg

func (*HoldingList) RemoveDependentMsg 

func (l *HoldingList) RemoveDependentMsg(h [32]byte, reason string)

remove a single msg from dependent holding (done when we add it to the process list).

func (*HoldingList) Review 

func (l *HoldingList) Review()

clean stale messages from holding

type IPrometheusRateMethods 

type IPrometheusRateMethods interface {
	// Arrival
	SetArrivalInstantAvg(v float64)
	SetArrivalTotalAvg(v float64)
	SetArrivalBackup(v float64)
	SetMovingArrival(v float64)

	// Complete
	SetCompleteInstantAvg(v float64)
	SetCompleteTotalAvg(v float64)
	SetMovingComplete(v float64)
}

IPrometheusRateMethods indicated which prometheus counters/gauges to set

type IdentityEntry 

type IdentityEntry struct {
	Entry       interfaces.IEBEntry
	Timestamp   interfaces.Timestamp
	Blockheight uint32
}

type InMsgMSGQueue 

type InMsgMSGQueue chan interfaces.IMsg

InMsgMSGQueue counts incoming and outgoing messages for inmsg queue

func NewInMsgQueue 

func NewInMsgQueue(capacity int) InMsgMSGQueue

func (InMsgMSGQueue) BlockingDequeue 

func (q InMsgMSGQueue) BlockingDequeue() interfaces.IMsg

BlockingDequeue will block until it retrieves from queue

func (InMsgMSGQueue) Cap 

func (q InMsgMSGQueue) Cap() int

Cap of underlying channel

func (InMsgMSGQueue) Dequeue 

func (q InMsgMSGQueue) Dequeue() interfaces.IMsg

Dequeue removes an item from channel and instruments based on type. Returns nil if nothing in queue

func (InMsgMSGQueue) Enqueue 

func (q InMsgMSGQueue) Enqueue(m interfaces.IMsg)

Enqueue adds item to channel and instruments based on type

func (InMsgMSGQueue) Length 

func (q InMsgMSGQueue) Length() int

Length of underlying channel

type Last100 

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

func (*Last100) Add 

func (list *Last100) Add(msg interfaces.IMsg)

func (*Last100) Get 

func (list *Last100) Get(h [32]byte) interfaces.IMsg

type MMRInfo 

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

type MSGMap 

type MSGMap struct {
	Msgs     map[[32]byte]interfaces.IMsg
	MsgOrder [1000][32]byte
	N        int
}

map of the last N messages indexed by hash

type MSgPair 

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

type MarshalableUint32 

type MarshalableUint32 uint32

func (*MarshalableUint32) MarshalBinary 

func (m *MarshalableUint32) MarshalBinary() (rval []byte, err error)

func (*MarshalableUint32) UnmarshalBinary 

func (m *MarshalableUint32) UnmarshalBinary(data []byte) error

func (*MarshalableUint32) UnmarshalBinaryData 

func (m *MarshalableUint32) UnmarshalBinaryData(data []byte) ([]byte, error)

type MissingEntry 

type MissingEntry struct {
	Cnt       int
	LastTime  time.Time
	EBHash    interfaces.IHash
	EntryHash interfaces.IHash
	DBHeight  uint32
}

func RandomMissingEntry 

func RandomMissingEntry() *MissingEntry

func (*MissingEntry) IsSameAs 

func (s *MissingEntry) IsSameAs(b *MissingEntry) bool

func (*MissingEntry) MarshalBinary 

func (s *MissingEntry) MarshalBinary() (rval []byte, err error)

func (*MissingEntry) UnmarshalBinary 

func (s *MissingEntry) UnmarshalBinary(p []byte) error

func (*MissingEntry) UnmarshalBinaryData 

func (s *MissingEntry) UnmarshalBinaryData(p []byte) (newData []byte, err error)

type MissingEntryBlock 

type MissingEntryBlock struct {
	EBHash   interfaces.IHash
	DBHeight uint32
}

func RandomMissingEntryBlock 

func RandomMissingEntryBlock() *MissingEntryBlock

func (*MissingEntryBlock) IsSameAs 

func (s *MissingEntryBlock) IsSameAs(b *MissingEntryBlock) bool

func (*MissingEntryBlock) MarshalBinary 

func (s *MissingEntryBlock) MarshalBinary() (rval []byte, err error)

func (*MissingEntryBlock) UnmarshalBinary 

func (s *MissingEntryBlock) UnmarshalBinary(p []byte) error

func (*MissingEntryBlock) UnmarshalBinaryData 

func (s *MissingEntryBlock) UnmarshalBinaryData(p []byte) (newData []byte, err error)

type MissingMessageResponseCache 

type MissingMessageResponseCache struct {
	// MissingMsgRequests is the channel on which we receive acked messages to cache
	MissingMsgRequests chan interfaces.IMsg
	// ProcessedPairs is all the ack+msg pairs that we processed
	ProcessedPairs chan *MsgPair

	// AckMessageCache is the cached acks from the last 2 blocks
	AckMessageCache *AckMsgPairCache
	// contains filtered or unexported fields
}

MissingMessageResponseCache will cache all processlist items from the last 2 blocks. It can create MissingMessageResponses to peer requests, and prevent us from asking the network if we already have something locally.

func NewMissingMessageReponseCache 

func NewMissingMessageReponseCache(s *State) *MissingMessageResponseCache

func (*MissingMessageResponseCache) Close 

func (mmrc *MissingMessageResponseCache) Close()

func (*MissingMessageResponseCache) NotifyNewMsgPair 

func (mmrc *MissingMessageResponseCache) NotifyNewMsgPair(ack interfaces.IMsg, msg interfaces.IMsg)

NotifyNewMsgPair is the threadsafe way to include a new msg pair to respond to missing message requests from peers

func (*MissingMessageResponseCache) NotifyPeerMissingMsg 

func (mmrc *MissingMessageResponseCache) NotifyPeerMissingMsg(missingMsg interfaces.IMsg)

NotifyPeerMissingMsg is the threadsafe way to notify that a peer sent us a missing message

func (*MissingMessageResponseCache) Run 

func (mmrc *MissingMessageResponseCache) Run()

Run will start the loop to read messages from the channel and build the cache to respond to missing message requests

type MissingState 

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

MissingState is information about a DBState that is known to exist but is not available on the current node.

func NewMissingState 

func NewMissingState(height uint32) *MissingState

NewMissingState creates a new MissingState for the DBState at a specific height.

func (*MissingState) Height 

func (s *MissingState) Height() uint32

type MovingAverage 

type MovingAverage struct {
	Window int
	// contains filtered or unexported fields
}

func NewMovingAverage 

func NewMovingAverage(window int) *MovingAverage

func (*MovingAverage) Add 

func (ma *MovingAverage) Add(val float64)

func (*MovingAverage) Avg 

func (ma *MovingAverage) Avg() float64

type MsgHeight 

type MsgHeight struct {
	DBHeight int
	VM       int
	Height   int
}

type MsgPair 

type MsgPair struct {
	Ack interfaces.IMsg
	Msg interfaces.IMsg
}

The pair of messages for a missing message response

type NetOutMsgQueue 

type NetOutMsgQueue chan interfaces.IMsg

NetOutMsgQueue counts incoming and outgoing messages for netout queue

func NewNetOutMsgQueue 

func NewNetOutMsgQueue(capacity int) NetOutMsgQueue

func (NetOutMsgQueue) BlockingDequeue 

func (q NetOutMsgQueue) BlockingDequeue() interfaces.IMsg

BlockingDequeue will block until it retrieves from queue

func (NetOutMsgQueue) Cap 

func (q NetOutMsgQueue) Cap() int

Cap of underlying channel

func (NetOutMsgQueue) Dequeue 

func (q NetOutMsgQueue) Dequeue() interfaces.IMsg

Dequeue removes an item from channel and instruments based on type. Returns nil if nothing in queue

func (NetOutMsgQueue) Enqueue 

func (q NetOutMsgQueue) Enqueue(m interfaces.IMsg)

Enqueue adds item to channel and instruments based on type

func (NetOutMsgQueue) Length 

func (q NetOutMsgQueue) Length() int

Length of underlying channel

type ProcessList 

type ProcessList struct {
	DBHeight uint32 // The directory block height for these lists

	// Temporary balances from updating transactions in real time.
	FactoidBalancesT      map[[32]byte]int64
	FactoidBalancesTMutex sync.Mutex
	ECBalancesT           map[[32]byte]int64
	ECBalancesTMutex      sync.Mutex

	State     *State
	VMs       []*VM       // Process list for each server (up to 32)
	ServerMap [10][64]int // Map of FedServers to all Servers for each minute
	System    VM          // System Faults and other system wide messages

	// messages processed in this list
	OldMsgs map[[32]byte]interfaces.IMsg

	// Chains that are executed, but not processed. There is a small window of a pending chain that the ack
	// will pass and the chainhead will fail. This covers that window. This is only used by WSAPI,
	// do not use it anywhere internally.
	PendingChainHeads *SafeMsgMap

	OldAcks map[[32]byte]interfaces.IMsg

	// Entry Blocks added within 10 minutes (follower and leader)
	NewEBlocks map[[32]byte]interfaces.IEntryBlock

	NewEntriesMutex sync.RWMutex
	NewEntries      map[[32]byte]interfaces.IEntry

	// State information about the directory block while it is under construction.  We may
	// have to start building the next block while still building the previous block.
	AdminBlock       interfaces.IAdminBlock
	EntryCreditBlock interfaces.IEntryCreditBlock
	DirectoryBlock   interfaces.IDirectoryBlock

	// Number of Servers acknowledged by Factom
	Matryoshka   []interfaces.IHash   // Reverse Hash
	AuditServers []interfaces.IServer // List of Audit Servers
	FedServers   []interfaces.IServer // List of Federated Servers

	// The Fedlist and Audlist at the START of the block. Server faults
	// can change the list, and we can calculate the deltas at the end
	StartingAuditServers []interfaces.IServer // List of Audit Servers
	StartingFedServers   []interfaces.IServer // List of Federated Servers

	// DB Sigs
	DBSignatures     []DBSig
	DBSigAlreadySent bool

	NextHeightToProcess [64]int
	// contains filtered or unexported fields
}

func NewProcessList 

func NewProcessList(state interfaces.IState, previous *ProcessList, dbheight uint32) *ProcessList

func (*ProcessList) AddAuditServer 

func (p *ProcessList) AddAuditServer(identityChainID interfaces.IHash) int

Add the given serverChain to this processlist as an Audit Server, and return the server index number of the added server

func (*ProcessList) AddDBSig 

func (p *ProcessList) AddDBSig(serverID interfaces.IHash, sig interfaces.IFullSignature)

func (*ProcessList) AddFedServer 

func (p *ProcessList) AddFedServer(identityChainID interfaces.IHash) int

Add the given serverChain to this processlist as a Federated Server, and return the server index number of the added server

func (*ProcessList) AddNewEBlocks 

func (p *ProcessList) AddNewEBlocks(key interfaces.IHash, value interfaces.IEntryBlock)

func (*ProcessList) AddNewEntry 

func (p *ProcessList) AddNewEntry(key interfaces.IHash, value interfaces.IEntry)

func (*ProcessList) AddOldMsgs 

func (p *ProcessList) AddOldMsgs(m interfaces.IMsg)

func (*ProcessList) AddToProcessList 

func (p *ProcessList) AddToProcessList(s *State, ack *messages.Ack, m interfaces.IMsg)

func (*ProcessList) CheckDiffSigTally 

func (p *ProcessList) CheckDiffSigTally() bool

func (*ProcessList) Complete 

func (p *ProcessList) Complete() bool

func (*ProcessList) ContainsDBSig 

func (p *ProcessList) ContainsDBSig(serverID interfaces.IHash) bool

func (*ProcessList) FedServerFor 

func (p *ProcessList) FedServerFor(minute int, hash []byte) interfaces.IServer

Returns the Federated Server responsible for this hash in this minute

func (*ProcessList) GetAckAt 

func (p *ProcessList) GetAckAt(vmIndex int, height int) *messages.Ack

Given a server index, return the last Ack

func (*ProcessList) GetAuditServerIndexHash 

func (p *ProcessList) GetAuditServerIndexHash(identityChainID interfaces.IHash) (bool, int)

Returns true and the index of this server, or false and the insertion point for this server

func (*ProcessList) GetDBHeight 

func (p *ProcessList) GetDBHeight() uint32

func (*ProcessList) GetFedServerIndexHash 

func (p *ProcessList) GetFedServerIndexHash(identityChainID interfaces.IHash) (bool, int)

Returns true and the index of this server, or false and the insertion point for this server

func (*ProcessList) GetKeysNewEntries 

func (p *ProcessList) GetKeysNewEntries() (keys [][32]byte)

func (*ProcessList) GetNewEBlocks 

func (p *ProcessList) GetNewEBlocks(key interfaces.IHash) interfaces.IEntryBlock

func (*ProcessList) GetNewEntry 

func (p *ProcessList) GetNewEntry(key [32]byte) interfaces.IEntry

func (*ProcessList) GetOldAck 

func (p *ProcessList) GetOldAck(key interfaces.IHash) interfaces.IMsg

func (*ProcessList) GetVMStatsForFedServer 

func (p *ProcessList) GetVMStatsForFedServer(index int) (vmIndex int, listHeight int, listLength int, nextNil int)

func (*ProcessList) GetVirtualServers 

func (p *ProcessList) GetVirtualServers(minute int, identityChainID interfaces.IHash) (found bool, index int)

func (*ProcessList) IncrementDiffSigTally 

func (p *ProcessList) IncrementDiffSigTally()

func (*ProcessList) IsPendingChainHead 

func (p *ProcessList) IsPendingChainHead(chainid interfaces.IHash) bool

IsPendingChainHead returns if a chainhead is about to be updated (In PL)

func (*ProcessList) LenNewEntries 

func (p *ProcessList) LenNewEntries() int

func (*ProcessList) LogPrintLeaders 

func (p *ProcessList) LogPrintLeaders(log string)

func (*ProcessList) MakeMap 

func (p *ProcessList) MakeMap()

func (*ProcessList) PrintMap 

func (p *ProcessList) PrintMap() string

This function will be replaced by a calculation from the Matryoshka hashes from the servers but for now, we are just going to make it a function of the dbheight.

func (*ProcessList) Process 

func (p *ProcessList) Process(s *State) (progress bool)

Process messages and update our state.

func (*ProcessList) RemoveAuditServerHash 

func (p *ProcessList) RemoveAuditServerHash(identityChainID interfaces.IHash)

Remove the given serverChain from this processlist's Audit Servers

func (*ProcessList) RemoveFedServerHash 

func (p *ProcessList) RemoveFedServerHash(identityChainID interfaces.IHash)

Remove the given serverChain from this processlist's Federated Servers

func (*ProcessList) RemoveFromPL 

func (p *ProcessList) RemoveFromPL(vm *VM, j int, reason string)

func (*ProcessList) Reset 

func (p *ProcessList) Reset() bool

Intended to let a demoted leader come back before the next DB state but interfered with boot under load so disable for now that means demoted leaders are not sane till the next DBState (up to 10 minutes). Maybe revisit after the missing message storms are fixed.

func (*ProcessList) ResetDiffSigTally 

func (p *ProcessList) ResetDiffSigTally()

func (*ProcessList) SetStartingAuthoritySet 

func (p *ProcessList) SetStartingAuthoritySet()

Will set the starting fed/aud list for delta comparison at the end of the block

func (*ProcessList) Sort 

func (p *ProcessList) Sort(serv []interfaces.IServer) bool

duplicate function in election but cannot import because of a dependency loop

func (*ProcessList) SortAuditServers 

func (p *ProcessList) SortAuditServers()

func (*ProcessList) SortDBSigs 

func (p *ProcessList) SortDBSigs()

func (*ProcessList) SortFedServers 

func (p *ProcessList) SortFedServers()

func (*ProcessList) String 

func (p *ProcessList) String() string

func (*ProcessList) TrimVMList 

func (p *ProcessList) TrimVMList(h uint32, vmIndex int)

func (*ProcessList) UpdateStatus 

func (p *ProcessList) UpdateStatus(s *State)

func (*ProcessList) VMIndexFor 

func (p *ProcessList) VMIndexFor(hash []byte) int

Returns the Virtual Server index for this hash for the given minute

type ProcessLists 

type ProcessLists struct {
	State        *State         // Pointer to the state object
	DBHeightBase uint32         // Height of the first Process List in this structure.
	Lists        []*ProcessList // Pointer to the ProcessList structure for each DBHeight under construction
	SetString    bool
	Str          string
}

func NewProcessLists 

func NewProcessLists(state interfaces.IState) *ProcessLists

func (*ProcessLists) Get 

func (lists *ProcessLists) Get(dbheight uint32) *ProcessList

func (*ProcessLists) GetSafe 

func (lists *ProcessLists) GetSafe(dbheight uint32) (pl *ProcessList)

Only gets an existing process list

func (*ProcessLists) LastList 

func (lists *ProcessLists) LastList() *ProcessList

func (*ProcessLists) String 

func (lists *ProcessLists) String() string

func (*ProcessLists) UpdateState 

func (lists *ProcessLists) UpdateState(dbheight uint32) (progress bool)

UpdateState is executed from a Follower's perspective. So the block we are building is always the block above the HighestRecordedBlock, but we only care about messages that are at the highest known block, as long as that is above the highest recorded block.

type RateCalculator 

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

RateCalculator will maintain the rate of msgs arriving and rate of msgs leaving a queue. The instant rate is a 2s avg

func NewRateCalculator 

func NewRateCalculator(p IPrometheusRateMethods) *RateCalculator

func NewRateCalculatorTime 

func NewRateCalculatorTime(p IPrometheusRateMethods, td time.Duration) *RateCalculator

NewRateCalculatorTime is good for unit tests, or if you want to change the measureing time

func (*RateCalculator) Arrival 

func (r *RateCalculator) Arrival()

Arrival indicates a new item added to the queue

func (*RateCalculator) Complete 

func (r *RateCalculator) Complete()

Complete indicates something left the queue

func (*RateCalculator) Start 

func (r *RateCalculator) Start()

Start begins instrumentation

func (*RateCalculator) StartTime 

func (r *RateCalculator) StartTime(start time.Time)

StartTime is good for unit tests

type ReCheck 

type ReCheck struct {
	TimeToCheck int64            //Time in seconds to recheck
	EntryHash   interfaces.IHash //Entry Hash to check
	DBHeight    int
	NumEntries  int
	Tries       int
}

type ReceivedState 

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

ReceivedState represents a DBStateMsg received from the network

func NewReceivedState 

func NewReceivedState(msg *messages.DBStateMsg) *ReceivedState

NewReceivedState creates a new member for the StatesReceived list

func (*ReceivedState) Height 

func (s *ReceivedState) Height() uint32

Height returns the block height of the received state

func (*ReceivedState) Message 

func (s *ReceivedState) Message() *messages.DBStateMsg

Message returns the DBStateMsg received from the network.

type RecentMessage 

type RecentMessage struct {
	AcksMap ACKMap
	MsgsMap MSGMap
	NewMsgs chan interfaces.IMsg
}

Keep the history last N acks and Ackable messages

func (*RecentMessage) Add 

func (m *RecentMessage) Add(msg interfaces.IMsg)

Adds messages to a map The map of messages will be used in tandem with the ack map when we get an MMR to ensure we don't ask for a message we already have.

func (*RecentMessage) GetAckAndMsg 

func (am *RecentMessage) GetAckAndMsg(DBHeight int, vmIndex int, height int, s interfaces.IState) (ack interfaces.IMsg, msg interfaces.IMsg)

Called when we receive an ask for an MMR, we check to see if we have an ack and message in out Ask amd Message maps

func (*RecentMessage) HandleRejection 

func (m *RecentMessage) HandleRejection(msg interfaces.IMsg, iAck interfaces.IMsg)

If a message is rejected we need to delete it from the recent message history so we will ask a neighbor

type Replay 

type Replay struct {
	Mutex    sync.Mutex
	Buckets  [numBuckets]map[[32]byte]int
	Basetime int // hours since 1970
	Center   int // Hour of the current time.
	// contains filtered or unexported fields
}

func RandomReplay 

func RandomReplay() *Replay

func (*Replay) Clear 

func (r *Replay) Clear(mask int, hash [32]byte)

func (*Replay) Init 

func (r *Replay) Init()

func (*Replay) IsHashUnique 

func (r *Replay) IsHashUnique(mask int, hash [32]byte) bool

Returns True if there is no record of this hash in the Replay structures. Returns false if we have seen this hash before.

func (*Replay) IsHashUnique_internal 

func (r *Replay) IsHashUnique_internal(mask int, hash [32]byte) bool

Returns True if there is no record of this hash in the Replay structures. Returns false if we have seen this hash before. Assume locking is done by caller

func (*Replay) IsSameAs 

func (a *Replay) IsSameAs(b *Replay) bool

func (*Replay) IsTSValid 

func (r *Replay) IsTSValid(mask int, hash interfaces.IHash, timestamp interfaces.Timestamp) bool

Checks if the timestamp is valid. If the timestamp is too old or too far into the future, then we don't consider it valid. Or if we have seen this hash before, then it is not valid. To that end, this code remembers hashes tested in the past, and rejects the second submission of the same hash.

func (*Replay) IsTSValidAndUpdateState 

func (r *Replay) IsTSValidAndUpdateState(mask int, hash [32]byte, timestamp interfaces.Timestamp, systemtime interfaces.Timestamp) (rval bool)

To make the function testable, the logic accepts the current time as a parameter. This way, the test code can manipulate the clock at will.

func (*Replay) MarshalBinary 

func (r *Replay) MarshalBinary() (rval []byte, err error)

func (*Replay) Recenter 

func (r *Replay) Recenter(systemtime interfaces.Timestamp)

This move the center time of the replay filter to the current systemtime. Really it should track the time for the current block.

func (*Replay) Save 

func (r *Replay) Save() *Replay

func (*Replay) SetHashNow 

func (r *Replay) SetHashNow(mask int, hash [32]byte, now interfaces.Timestamp) bool

Fixed conflicting lock path Add a hash/mask at a specific time if it did not exist prior.

func (*Replay) UnmarshalBinary 

func (r *Replay) UnmarshalBinary(p []byte) error

func (*Replay) UnmarshalBinaryData 

func (r *Replay) UnmarshalBinaryData(p []byte) ([]byte, error)

func (*Replay) Valid 

func (r *Replay) Valid(mask int, hash [32]byte, timestamp interfaces.Timestamp, systemtime interfaces.Timestamp) (index int, valid bool)

Returns false if the hash is too old, or is already a member of the set. Timestamp is in seconds. Does not add the hash to the buckets!

type SafeMsgMap 

type SafeMsgMap struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

SafeMsgMap is a threadsafe map[[32]byte]interfaces.IMsg

func NewSafeMsgMap 

func NewSafeMsgMap(name string, s *State) *SafeMsgMap

func (*SafeMsgMap) Cleanup 

func (m *SafeMsgMap) Cleanup(s *State)

Cleanup will clean old elements out from the commit map.

func (*SafeMsgMap) Copy 

func (m *SafeMsgMap) Copy() *SafeMsgMap

func (*SafeMsgMap) Delete 

func (m *SafeMsgMap) Delete(key [32]byte) (msg interfaces.IMsg, found bool)

func (*SafeMsgMap) Get 

func (m *SafeMsgMap) Get(key [32]byte) (msg interfaces.IMsg)

func (*SafeMsgMap) GetRaw 

func (m *SafeMsgMap) GetRaw() map[[32]byte]interfaces.IMsg

GetRaw is used in testing and simcontrol. Do no use this in production

func (*SafeMsgMap) Len 

func (m *SafeMsgMap) Len() int

func (*SafeMsgMap) Put 

func (m *SafeMsgMap) Put(key [32]byte, msg interfaces.IMsg)

func (*SafeMsgMap) RemoveExpired 

func (m *SafeMsgMap) RemoveExpired(s *State)

RemoveExpired is used when treating this as a commit map. Do not

func (*SafeMsgMap) Reset 

func (m *SafeMsgMap) Reset()

Reset will delete all elements

type SaveState 

type SaveState struct {
	DBHeight uint32

	FedServers   []interfaces.IServer
	AuditServers []interfaces.IServer

	// The old balances must be restored
	FactoidBalancesP map[[32]byte]int64
	ECBalancesP      map[[32]byte]int64

	IdentityControl *IdentityManager // Identities

	AuthorityServerCount int // number of federated or audit servers allowed

	// Server State
	LLeaderHeight uint32
	Leader        bool
	LeaderVMIndex int
	LeaderPL      *ProcessList
	CurrentMinute int

	EOMsyncing bool

	EOM          bool // Set to true when the first EOM is encountered
	EOMLimit     int
	EOMProcessed int
	EOMDone      bool
	EOMMinute    int
	EOMSys       bool // At least one EOM has covered the System List

	DBSig          bool
	DBSigLimit     int
	DBSigProcessed int // Number of DBSignatures received and processed.
	DBSigDone      bool
	DBSigSys       bool // At least one DBSig has covered the System List

	Newblk  bool // True if we are starting a new block, and a dbsig is needed.
	Saving  bool // True if we are in the process of saving to the database
	Syncing bool // Looking for messages from leaders to sync

	LeaderTimestamp interfaces.Timestamp

	Holding map[[32]byte]interfaces.IMsg // Hold Messages
	XReview []interfaces.IMsg            // After the EOM, we must review the messages in Holding
	Acks    map[[32]byte]interfaces.IMsg // Hold Acknowledgements
	Commits *SafeMsgMap                  // map[[32]byte]interfaces.IMsg // Commit Messages

	InvalidMessages map[[32]byte]interfaces.IMsg

	// DBlock Height at which node has a complete set of eblocks+entries
	EntryBlockDBHeightComplete uint32
	// DBlock Height at which we have started asking for entry blocks
	EntryBlockDBHeightProcessing uint32
	// Entry Blocks we don't have that we are asking our neighbors for
	MissingEntryBlocks []MissingEntryBlock

	// DBlock Height at which node has a complete set of eblocks+entries
	EntryDBHeightComplete uint32
	// Height in the DBlock where we have all the entries
	EntryHeightComplete int
	// DBlock Height at which we have started asking for or have all entries
	EntryDBHeightProcessing uint32
	// Height in the Directory Block where we have
	// Entries we don't have that we are asking our neighbors for
	MissingEntries []MissingEntry

	// FER section
	FactoshisPerEC                 uint64
	FERChainId                     string
	ExchangeRateAuthorityPublicKey string

	FERChangeHeight      uint32
	FERChangePrice       uint64
	FERPriority          uint32
	FERPrioritySetHeight uint32
}

Because we have to go back to a previous state should the network be partitioned and we are on a separate branch, we need to log our state periodically so we can reset to a state prior to the network partition. The need to go back to a SaveState should be rare. And even more rare would be the need to go back two levels. However, it is possible that a minority partition is able to see a level of consensus and save a state to disk that the majority of the nodes did not see. However it is not possible for this to occur more than once. This is because any consensus a node can see requires that all the nodes saw the previous consensus.

func SaveFactomdState 

func SaveFactomdState(state *State, d *DBState) (ss *SaveState)

func (*SaveState) Init 

func (ss *SaveState) Init()

func (*SaveState) IsSameAs 

func (a *SaveState) IsSameAs(b *SaveState) bool

func (*SaveState) JSONByte 

func (e *SaveState) JSONByte() ([]byte, error)

func (*SaveState) JSONString 

func (e *SaveState) JSONString() (string, error)

func (*SaveState) MarshalBinary 

func (ss *SaveState) MarshalBinary() (rval []byte, err error)

func (*SaveState) RestoreFactomdState 

func (ss *SaveState) RestoreFactomdState(s *State)

func (*SaveState) String 

func (e *SaveState) String() string

func (*SaveState) TrimBack 

func (ss *SaveState) TrimBack(s *State, d *DBState)

func (*SaveState) UnmarshalBinary 

func (ss *SaveState) UnmarshalBinary(p []byte) error

func (*SaveState) UnmarshalBinaryData 

func (ss *SaveState) UnmarshalBinaryData(p []byte) (newData []byte, err error)

type Server 

type Server struct {
	ChainID interfaces.IHash
	Name    string
	Online  bool
	Replace interfaces.IHash
}

func (*Server) GetChainID 

func (s *Server) GetChainID() (rval interfaces.IHash)

func (*Server) GetName 

func (s *Server) GetName() string

func (*Server) Init 

func (s *Server) Init()

func (*Server) IsOnline 

func (s *Server) IsOnline() bool

func (*Server) IsSameAs 

func (s *Server) IsSameAs(b interfaces.IServer) bool

func (*Server) JSONByte 

func (e *Server) JSONByte() ([]byte, error)

func (*Server) JSONString 

func (e *Server) JSONString() (string, error)

func (*Server) LeaderToReplace 

func (s *Server) LeaderToReplace() (rval interfaces.IHash)

func (*Server) MarshalBinary 

func (s *Server) MarshalBinary() (rval []byte, err error)

func (*Server) SetOnline 

func (s *Server) SetOnline(o bool)

func (*Server) SetReplace 

func (s *Server) SetReplace(h interfaces.IHash)

func (*Server) String 

func (s *Server) String() string

func (*Server) UnmarshalBinary 

func (s *Server) UnmarshalBinary(p []byte) error

func (*Server) UnmarshalBinaryData 

func (s *Server) UnmarshalBinaryData(p []byte) (newData []byte, err error)

type State 

type State struct {
	Logger            *log.Entry
	RunState          runstate.RunState
	NetworkController *p2p.Controller
	Salt              interfaces.IHash
	Cfg               interfaces.IFactomConfig
	ConfigFilePath    string // $HOME/.factom/m2/factomd.conf by default

	Prefix          string
	FactomNodeName  string
	FactomdVersion  string
	LogPath         string
	LdbPath         string
	BoltDBPath      string
	LogLevel        string
	ConsoleLogLevel string
	NodeMode        string
	DBType          string
	CheckChainHeads struct {
		CheckChainHeads bool
		Fix             bool
	}
	CloneDBType       string
	ExportData        bool
	ExportDataSubpath string

	LogBits int64 // Bit zero is for logging the Directory Block on DBSig [5]

	DBStatesSent            []*interfaces.DBStateSent
	DBStatesReceivedBase    int
	DBStatesReceived        []*messages.DBStateMsg
	LocalServerPrivKey      string
	DirectoryBlockInSeconds int
	PortNumber              int
	Replay                  *Replay
	FReplay                 *Replay
	CrossReplay             *CrossReplayFilter
	DropRate                int
	Delay                   int64 // Simulation delays sending messages this many milliseconds

	ControlPanelPort    int
	ControlPanelSetting int
	// Keeping the last display state lets us know when to send over the new blocks
	LastDisplayState        *DisplayState
	ControlPanelChannel     chan DisplayState
	ControlPanelDataRequest bool // If true, update Display state

	// Network Configuration
	Network                 string
	MainNetworkPort         string
	PeersFile               string
	MainSeedURL             string
	MainSpecialPeers        string
	TestNetworkPort         string
	TestSeedURL             string
	TestSpecialPeers        string
	LocalNetworkPort        string
	LocalSeedURL            string
	LocalSpecialPeers       string
	CustomNetworkPort       string
	CustomSeedURL           string
	CustomSpecialPeers      string
	CustomNetworkID         []byte
	CustomBootstrapIdentity string
	CustomBootstrapKey      string

	IdentityChainID interfaces.IHash // If this node has an identity, this is it
	//Identities      []*Identity      // Identities of all servers in management chain
	// Authorities          []*Authority     // Identities of all servers in management chain
	AuthorityServerCount int // number of federated or audit servers allowed
	IdentityControl      *IdentityManager

	// Just to print (so debugging doesn't drive functionality)
	Status int // Return a status (0 do nothing, 1 provide queues, 2 provide consensus data)

	StatusMutex sync.Mutex
	StatusStrs  []string
	Starttime   time.Time

	ResetTryCnt int
	ResetCnt    int

	//  pending entry/transaction api calls for the holding queue do not have proper scope
	//  This is used to create a temporary, correctly scoped holding queue snapshot for the calls on demand
	HoldingMutex sync.RWMutex
	HoldingLast  int64
	HoldingMap   map[[32]byte]interfaces.IMsg

	// Elections are managed through the Elections Structure
	EFactory  interfaces.IElectionsFactory
	Elections interfaces.IElections
	Election0 string // Title
	Election1 string // Election state for display
	Election2 string // Election state for display
	Election3 string // Election leader list

	//  pending entry/transaction api calls for the ack queue do not have proper scope
	//  This is used to create a temporary, correctly scoped ackqueue snapshot for the calls on demand
	AcksMutex sync.RWMutex
	AcksLast  int64
	AcksMap   map[[32]byte]interfaces.IMsg

	DBStateAskCnt     int
	DBStateReplyCnt   int
	DBStateIgnoreCnt  int
	DBStateAppliedCnt int

	MissingRequestAskCnt      int
	MissingRequestReplyCnt    int
	MissingRequestIgnoreCnt   int
	MissingResponseAppliedCnt int

	ResendCnt int
	ExpireCnt int

	TimeOffset    interfaces.Timestamp
	MaxTimeOffset interfaces.Timestamp

	ShutdownChan chan int // For gracefully halting Factom
	JournalFile  string
	Journaling   bool

	ServerPrivKey *primitives.PrivateKey
	ServerPubKey  *primitives.PublicKey

	// RPC connection config
	RpcUser     string
	RpcPass     string
	RpcAuthHash []byte

	FactomdTLSEnable   bool
	FactomdTLSKeyFile  string
	FactomdTLSCertFile string
	FactomdLocations   string

	CorsDomains []string
	// Server State
	StartDelay      int64 // Time in Milliseconds since the last DBState was applied
	StartDelayLimit int64
	DBFinished      bool
	RunLeader       bool
	BootTime        int64 // Time in seconds that we last booted

	// Ignore missing messages for a period to allow rebooting a network where your
	// own messages from the previously executing network can confuse you.
	IgnoreDone    bool
	IgnoreMissing bool

	// Timout and Limit for outstanding missing DBState requests
	RequestTimeout time.Duration
	RequestLimit   int

	LLeaderHeight   uint32
	Leader          bool
	LeaderVMIndex   int
	LeaderPL        *ProcessList
	PLProcessHeight uint32
	// Height cutoff where no missing messages below this height
	DBHeightAtBoot  uint32
	TimestampAtBoot interfaces.Timestamp
	OneLeader       bool
	OutputAllowed   bool
	CurrentMinute   int

	// These are the start times for blocks and minutes
	PreviousMinuteStartTime int64
	CurrentMinuteStartTime  int64
	CurrentBlockStartTime   int64

	EOMsyncing   bool
	EOMSyncTime  int64
	EOM          bool // Set to true when the first EOM is encountered
	EOMLimit     int
	EOMProcessed int
	EOMDone      bool
	EOMMinute    int
	EOMSys       bool // At least one EOM has covered the System List

	DBSig          bool
	DBSigLimit     int
	DBSigProcessed int // Number of DBSignatures received and processed.
	DBSigDone      bool
	DBSigSys       bool // At least one DBSig has covered the System List

	CreatedLastBlockFromDBState bool

	// By default, this is false, which means DBstates are discarded
	// when a majority of leaders disagree with the hash we have via DBSigs
	KeepMismatch bool

	DBSigFails int // Keep track of how many blockhash mismatches we've had to correct

	Saving  bool // True if we are in the process of saving to the database
	Syncing bool // Looking for messages from leaders to sync

	NetStateOff     bool // Disable if true, Enable if false
	DebugConsensus  bool // If true, dump consensus trace
	FactoidTrans    int
	ECCommits       int
	ECommits        int
	FCTSubmits      int
	NewEntryChains  int
	NewEntries      int
	LeaderTimestamp interfaces.Timestamp

	// Maps
	// ====
	// For Follower
	ResendHolding interfaces.Timestamp         // Timestamp to gate resending holding to neighbors
	HoldingList   chan [32]byte                // Queue to process Holding in order
	HoldingVM     int                          // VM used to build current holding list
	Holding       map[[32]byte]interfaces.IMsg // Hold Messages
	XReview       []interfaces.IMsg            // After the EOM, we must review the messages in Holding
	Acks          map[[32]byte]interfaces.IMsg // Hold Acknowledgements
	Commits       *SafeMsgMap                  //  map[[32]byte]interfaces.IMsg // Commit Messages

	InvalidMessages      map[[32]byte]interfaces.IMsg
	InvalidMessagesMutex sync.RWMutex

	AuditHeartBeats []interfaces.IMsg // The checklist of HeartBeats for this period

	FaultTimeout  int
	FaultWait     int
	EOMfaultIndex int
	LastTiebreak  int64

	AuthoritySetString string
	// Network MAIN = 0, TEST = 1, LOCAL = 2, CUSTOM = 3
	NetworkNumber int // Encoded into Directory Blocks(s.Cfg.(*util.FactomdConfig)).String()

	// Database
	DB     interfaces.DBOverlaySimple
	Anchor interfaces.IAnchor

	// Directory Block State
	DBStates       *DBStateList // Holds all DBStates not yet processed.
	StatesMissing  *StatesMissing
	StatesWaiting  *StatesWaiting
	StatesReceived *StatesReceived

	ResetRequest bool // Set to true to trigger a reset
	ProcessLists *ProcessLists

	AuthorityDeltas string

	// Factom State
	FactoidState    interfaces.IFactoidState
	NumTransactions int

	// Permanent balances from processing blocks.
	RestoreFCT            map[[32]byte]int64
	RestoreEC             map[[32]byte]int64
	FactoidBalancesPapi   map[[32]byte]int64
	FactoidBalancesP      map[[32]byte]int64
	FactoidBalancesPMutex sync.Mutex
	ECBalancesPapi        map[[32]byte]int64
	ECBalancesP           map[[32]byte]int64
	ECBalancesPMutex      sync.Mutex
	TempBalanceHash       interfaces.IHash
	Balancehash           interfaces.IHash

	// Web Services
	Port int

	// For Replay / journal
	IsReplaying     bool
	ReplayTimestamp interfaces.Timestamp

	// State for the Entry Syncing process
	EntrySyncState *EntrySync

	MissingEntryBlockRepeat interfaces.Timestamp
	// DBlock Height at which node has a complete set of eblocks+entries
	EntryBlockDBHeightComplete uint32
	// DBlock Height at which we have started asking for entry blocks
	EntryBlockDBHeightProcessing uint32
	// Entry Blocks we don't have that we are asking our neighbors for
	MissingEntryBlocks []MissingEntryBlock

	MissingEntryRepeat interfaces.Timestamp
	// DBlock Height at which node has a complete set of eblocks+entries
	EntryDBHeightComplete uint32
	// DBlock Height at which we have started asking for or have all entries
	EntryDBHeightProcessing uint32
	// Height in the Directory Block where we have
	// Entries we don't have that we are asking our neighbors for
	MissingEntries chan *MissingEntry

	// Holds leaders and followers up until all missing entries are processed, if true
	WaitForEntries  bool
	UpdateEntryHash chan *EntryUpdate // Channel for updating entry Hashes tracking (repeats and such)
	WriteEntry      chan interfaces.IEBEntry
	// MessageTally causes the node to keep track of (and display) running totals of each
	// type of message received during the tally interval
	MessageTally           bool
	MessageTalliesReceived [constants.NUM_MESSAGES]int
	MessageTalliesSent     [constants.NUM_MESSAGES]int

	LastPrint    string
	LastPrintCnt int

	// FER section
	FactoshisPerEC                 uint64
	FERChainId                     string
	ExchangeRateAuthorityPublicKey string

	FERChangeHeight      uint32
	FERChangePrice       uint64
	FERPriority          uint32
	FERPrioritySetHeight uint32

	AckChange uint32

	StateSaverStruct StateSaverStruct

	// Logstash
	UseLogstash bool
	LogstashURL string

	Uploader                *UploadController // Controls the uploads of torrents. Prevents backups
	DBStateManager          interfaces.IManagerController
	HighestCompletedTorrent uint32
	FastBoot                bool
	FastBootLocation        string
	FastSaveRate            int

	// These stats are collected when we write the dbstate to the database.
	NumNewChains   int // Number of new Chains in this block
	NumNewEntries  int // Number of new Entries, not counting the first entry in a chain
	NumEntries     int // Number of entries in this block (including the entries that create chains)
	NumEntryBlocks int // Number of Entry Blocks
	NumFCTTrans    int // Number of Factoid Transactions in this block

	SyncingState        [256]string
	SyncingStateCurrent int

	ProcessListProcessCnt int64 // count of attempts to process .. so we can see if the thread is running
	StateProcessCnt       int64
	StateUpdateState      int64
	ValidatorLoopSleepCnt int64

	MMRInfo // fields for MMR processing

	OutputRegEx       *regexp.Regexp
	OutputRegExString string
	InputRegEx        *regexp.Regexp
	InputRegExString  string

	Hold HoldingList

	// MissingMessageResponse is a cache of the last 1000 msgs we receive such that when
	// we send out a missing message, we can find that message locally before we ask the net
	RecentMessage

	// MissingMessageResponseHandler is a cache of the last 2 blocks of processed acks.
	// It can handle and respond to missing message requests on it's own thread.
	MissingMessageResponseHandler *MissingMessageResponseCache
	ChainCommits                  Last100
	Reveals                       Last100
	// contains filtered or unexported fields
}

func (*State) APIQueue 

func (s *State) APIQueue() interfaces.IQueue

func (*State) AckQueue 

func (s *State) AckQueue() chan interfaces.IMsg

func (*State) Add 

func (s *State) Add(h [32]byte, msg interfaces.IMsg) int

Add a message to a dependent holding list

func (*State) AddAuditServer 

func (s *State) AddAuditServer(dbheight uint32, hash interfaces.IHash) int

func (*State) AddAuthorityDelta 

func (s *State) AddAuthorityDelta(authSet string)

func (*State) AddDBSig 

func (s *State) AddDBSig(dbheight uint32, chainID interfaces.IHash, sig interfaces.IFullSignature)

func (*State) AddDBState 

func (s *State) AddDBState(isNew bool,
	directoryBlock interfaces.IDirectoryBlock,
	adminBlock interfaces.IAdminBlock,
	factoidBlock interfaces.IFBlock,
	entryCreditBlock interfaces.IEntryCreditBlock,
	eBlocks []interfaces.IEntryBlock,
	entries []interfaces.IEBEntry) *DBState

Adds blocks that are either pulled locally from a database, or acquired from peers.

func (*State) AddFedServer 

func (s *State) AddFedServer(dbheight uint32, hash interfaces.IHash) int

func (*State) AddIdentityEblocks 

func (st *State) AddIdentityEblocks(cid interfaces.IHash, rootChain bool) error

AddIdentityEblocks will find all eblocks for a root/management chain and add them to the sync list

func (*State) AddIdentityFromChainID 

func (st *State) AddIdentityFromChainID(cid interfaces.IHash) error

AddIdentityFromChainID will add an identity to our list to watch and sync it.

func (*State) AddNewIdentityEblocks 

func (st *State) AddNewIdentityEblocks(eblocks []interfaces.IEntryBlock, dblockTimestamp interfaces.Timestamp)

AddNewIdentityEblocks will scan the new eblock list and identify any eblocks of interest. If an eblock belongs to a current identity, we add it to the eblock lists of the identity to be synced.

func (*State) AddPrefix 

func (s *State) AddPrefix(prefix string)

func (*State) AddStatus 

func (s *State) AddStatus(status string)

func (*State) AddToHolding 

func (s *State) AddToHolding(hash [32]byte, msg interfaces.IMsg)

func (*State) AddToReplayFilter 

func (s *State) AddToReplayFilter(mask int, hash [32]byte, timestamp interfaces.Timestamp, systemtime interfaces.Timestamp) (rval bool)

Check and Add a hash to the network replay filter

func (*State) Ask 

func (s *State) Ask(DBHeight int, vmIndex int, height int, when int64) bool

Ask is called from ReportMissing which comes from validation thread to notify MMR that we are missing a message return false if we are unable to ask

func (*State) CalculateTransactionRate 

func (s *State) CalculateTransactionRate() (totalTPS float64, instantTPS float64)

CalculateTransactionRate calculates how many transactions this node is processing 

totalTPS	: Transaction rate over life of node (totaltime / totaltrans)
instantTPS	: Transaction rate weighted over last 3 seconds

func (*State) CheckFileName 

func (s *State) CheckFileName(name string) bool

func (*State) CheckForIDChange 

func (s *State) CheckForIDChange()

func (*State) Clone 

func (s *State) Clone(cloneNumber int) interfaces.IState

func (*State) ComputeVMIndex 

func (s *State) ComputeVMIndex(hash []byte) int

Returns the Virtual Server Index for this hash if this server is the leader; returns -1 if we are not the leader for this hash

func (*State) ConstructAuthoritySetString 

func (s *State) ConstructAuthoritySetString() (authSets []string)

func (*State) CopyStateToControlPanel 

func (s *State) CopyStateToControlPanel() error

Sends the copy of State over channel to control panel

func (*State) CreateDBSig 

func (s *State) CreateDBSig(dbheight uint32, vmIndex int) (interfaces.IMsg, interfaces.IMsg)

func (*State) CreateEOM 

func (s *State) CreateEOM(force bool, m interfaces.IMsg, vmIdx int) (eom *messages.EOM, ack interfaces.IMsg)

func (*State) CrossReplayAddSalt 

func (s *State) CrossReplayAddSalt(height uint32, salt [8]byte) error

CrossReplayAddSalt adds the salt to the DB

func (*State) DatabaseContains 

func (s *State) DatabaseContains(hash interfaces.IHash) bool

func (*State) DebugExec 

func (s *State) DebugExec() (ret bool)

func (*State) DeleteFromHolding 

func (s *State) DeleteFromHolding(hash [32]byte, msg interfaces.IMsg, reason string)

func (*State) DidCreateLastBlockFromDBState 

func (s *State) DidCreateLastBlockFromDBState() bool

func (*State) DoProcessing 

func (s *State) DoProcessing()

This is the tread with access to state. It does process and update state

func (*State) DoReset 

func (s *State) DoReset()

Set to reprocess all messages and states

func (*State) ElectionsQueue 

func (s *State) ElectionsQueue() interfaces.IQueue

func (*State) ExchangeRateAuthorityIsValid 

func (this *State) ExchangeRateAuthorityIsValid(e interfaces.IEBEntry) bool

func (*State) ExecuteFromHolding 

func (s *State) ExecuteFromHolding(h [32]byte)

Execute a list of messages from holding that are dependent on a hash the hash may be a EC address or a ChainID or a height (ok heights are not really hashes but we cheat on that)

func (*State) ExpireHolding 

func (s *State) ExpireHolding()

func (*State) FactomSecond 

func (s *State) FactomSecond() time.Duration

FactomSecond finds the time duration of 1 second relative to 10min blocks. 

Blktime			EOMs		Second
600s			60s			1s
300s			30s			0.5s
120s			12s			0.2s
 60s			 6s			0.1s
 30s			 3s			0.05s

func (*State) FastVerifyAuthoritySignature 

func (st *State) FastVerifyAuthoritySignature(msg []byte, sig interfaces.IFullSignature, dbheight uint32) (int, error)

Checks the signature of a message. Returns an int based on who signed it: 

1  -> Federated Signature
0  -> Audit Signature
-1 -> Neither Fed or Audit Signature

func (*State) FerEntryIsValid 

func (this *State) FerEntryIsValid(passedFEREntry interfaces.IFEREntry) bool

func (*State) FetchECTransactionByHash 

func (s *State) FetchECTransactionByHash(hash interfaces.IHash) (interfaces.IECBlockEntry, error)

func (*State) FetchEntryByHash 

func (s *State) FetchEntryByHash(hash interfaces.IHash) (interfaces.IEBEntry, error)

func (*State) FetchEntryHashFromProcessListsByTxID 

func (s *State) FetchEntryHashFromProcessListsByTxID(txID string) (interfaces.IHash, error)

might want to make this search the database at some point to be more generic

func (*State) FetchEntryRevealAndCommitFromHolding 

func (s *State) FetchEntryRevealAndCommitFromHolding(hash interfaces.IHash) (reveal interfaces.IMsg, commit interfaces.IMsg)

FetchEntryRevealAndCommitFromHolding will look for the commit and reveal for a given hash. It will check the hash as an entryhash and a txid, and return any reveals that match the entryhash and any commits that match the entryhash or txid 

Returns
	reveal = The reveal message if found
	commit = The commit message if found

func (*State) FetchFactoidTransactionByHash 

func (s *State) FetchFactoidTransactionByHash(hash interfaces.IHash) (interfaces.ITransaction, error)

func (*State) FetchHoldingMessageByHash 

func (s *State) FetchHoldingMessageByHash(hash interfaces.IHash) (int, byte, interfaces.IMsg, error)

func (*State) FetchIdentityChainEntriesInCreateOrder 

func (s *State) FetchIdentityChainEntriesInCreateOrder(chainid interfaces.IHash) ([]IdentityEntry, error)

FetchIdentityChainEntriesInCreateOrder will grab all entries in a chain for an identity in the order they were created.

func (*State) FetchPaidFor 

func (s *State) FetchPaidFor(hash interfaces.IHash) (interfaces.IHash, error)

func (*State) FixMissingKeys 

func (s *State) FixMissingKeys(id *Identity) error

func (*State) FollowerExecuteAck 

func (s *State) FollowerExecuteAck(msg interfaces.IMsg)

Ack messages always match some message in the Process List. That is done here, though the only msg that should call this routine is the Ack message.

func (*State) FollowerExecuteCommitChain 

func (s *State) FollowerExecuteCommitChain(m interfaces.IMsg)

func (*State) FollowerExecuteCommitEntry 

func (s *State) FollowerExecuteCommitEntry(m interfaces.IMsg)

func (*State) FollowerExecuteDBState 

func (s *State) FollowerExecuteDBState(msg interfaces.IMsg)

func (*State) FollowerExecuteDataResponse 

func (s *State) FollowerExecuteDataResponse(m interfaces.IMsg)

func (*State) FollowerExecuteEOM 

func (s *State) FollowerExecuteEOM(m interfaces.IMsg)

Messages that will go into the Process List must match an Acknowledgement. The code for this is the same for all such messages, so we put it here.

Returns true if it finds a match, puts the message in holding, or invalidates the message

func (*State) FollowerExecuteFullFault 

func (s *State) FollowerExecuteFullFault(m interfaces.IMsg)

When we execute a FullFault message, it could be complete (includes all necessary signatures + pledge) or incomplete, in which case it is just a negotiation ping

func (*State) FollowerExecuteMMR 

func (s *State) FollowerExecuteMMR(m interfaces.IMsg)

func (*State) FollowerExecuteMissingMsg 

func (s *State) FollowerExecuteMissingMsg(msg interfaces.IMsg)

func (*State) FollowerExecuteMsg 

func (s *State) FollowerExecuteMsg(m interfaces.IMsg)

Messages that will go into the Process List must match an Acknowledgement. The code for this is the same for all such messages, so we put it here.

Returns true if it finds a match, puts the message in holding, or invalidates the message

func (*State) FollowerExecuteRevealEntry 

func (s *State) FollowerExecuteRevealEntry(m interfaces.IMsg)

func (*State) FollowerExecuteSFault 

func (s *State) FollowerExecuteSFault(m interfaces.IMsg)

func (*State) GetACKStatus 

func (s *State) GetACKStatus(hash interfaces.IHash) (int, interfaces.IHash, interfaces.Timestamp, interfaces.Timestamp, error)

GetACKStatus also checks the oldmsgs map

func (*State) GetAckChange 

func (s *State) GetAckChange() (bool, error)

func (*State) GetAnchor 

func (s *State) GetAnchor() interfaces.IAnchor

func (*State) GetAuditHeartBeats 

func (s *State) GetAuditHeartBeats() []interfaces.IMsg

func (*State) GetAuditServers 

func (s *State) GetAuditServers(dbheight uint32) []interfaces.IServer

func (*State) GetAuthorities 

func (s *State) GetAuthorities() []interfaces.IAuthority

GetAuthorities will return a list of the network authorities

func (*State) GetAuthority 

func (st *State) GetAuthority(serverID interfaces.IHash) (*Authority, int)

Gets the authority matching the identity ChainID. Returns the authority and the int of its type: 

1  ->  Federated
0  ->  Audit
-1 ->  Not fed or audit
-2 -> Not found

func (*State) GetAuthorityDeltas 

func (s *State) GetAuthorityDeltas() string

func (*State) GetAuthorityInterface 

func (s *State) GetAuthorityInterface(chainid interfaces.IHash) interfaces.IAuthority

GetAuthorityInterface will the authority as an interface. Because of import issues we cannot access IdentityControl Directly

func (*State) GetAuthorityServerType 

func (st *State) GetAuthorityServerType(chainID interfaces.IHash) int

func (*State) GetAuthoritySetString 

func (s *State) GetAuthoritySetString() string

func (*State) GetBootTime 

func (s *State) GetBootTime() int64

func (*State) GetCfg 

func (s *State) GetCfg() interfaces.IFactomConfig

Getting the cfg state for Factom doesn't force a read of the config file unless it hasn't been read yet.

func (*State) GetConfigPath 

func (s *State) GetConfigPath() string

func (*State) GetCorsDomains 

func (s *State) GetCorsDomains() []string

func (*State) GetCurrentBlockStartTime 

func (s *State) GetCurrentBlockStartTime() int64

func (*State) GetCurrentMinute 

func (s *State) GetCurrentMinute() int

func (*State) GetCurrentMinuteStartTime 

func (s *State) GetCurrentMinuteStartTime() int64

func (*State) GetCurrentTime 

func (s *State) GetCurrentTime() int64

func (*State) GetDB 

func (s *State) GetDB() interfaces.DBOverlaySimple

func (*State) GetDBFinished 

func (s *State) GetDBFinished() bool

func (*State) GetDBHeightAtBoot 

func (s *State) GetDBHeightAtBoot() uint32

func (*State) GetDBHeightComplete 

func (s *State) GetDBHeightComplete() uint32

func (*State) GetDBState 

func (s *State) GetDBState(height uint32) *DBState

func (*State) GetDBStatesSent 

func (s *State) GetDBStatesSent() []*interfaces.DBStateSent

func (*State) GetDelay 

func (s *State) GetDelay() int64

func (*State) GetDirectoryBlock 

func (s *State) GetDirectoryBlock() interfaces.IDirectoryBlock

func (*State) GetDirectoryBlockByHeight 

func (s *State) GetDirectoryBlockByHeight(height uint32) interfaces.IDirectoryBlock

Return the Directory block if it is in memory, or hit the database if it must be loaded.

func (*State) GetDirectoryBlockInSeconds 

func (s *State) GetDirectoryBlockInSeconds() int

func (*State) GetDropRate 

func (s *State) GetDropRate() int

func (*State) GetE 

func (s *State) GetE(rt bool, adr [32]byte) (v int64)

func (*State) GetEBlockKeyMRFromEntryHash 

func (s *State) GetEBlockKeyMRFromEntryHash(entryHash interfaces.IHash) (rval interfaces.IHash)

func (*State) GetElections 

func (s *State) GetElections() interfaces.IElections

func (*State) GetEntryBlockDBHeightComplete 

func (s *State) GetEntryBlockDBHeightComplete() uint32

func (*State) GetEntryBlockDBHeightProcessing 

func (s *State) GetEntryBlockDBHeightProcessing() uint32

func (*State) GetEntryCommitAckByEntryHash 

func (s *State) GetEntryCommitAckByEntryHash(hash interfaces.IHash) (status int, commit interfaces.IMsg)

GetEntryCommitAck will fetch the status of a entrycommit by ENTRYHASH. The places it checks are: 

	CommitMap 	--> This indicates if the entry made it into the processlist within the last 4 hrs
	Last PL		--> Check if still in a processList
	Holding 	--> See if it is in holding

Returns:
	status 		= Status of reveal from possible ack responses
	commit 		= The commit message

func (*State) GetEntryCommitAckByTXID 

func (s *State) GetEntryCommitAckByTXID(hash interfaces.IHash) (status int, blktime interfaces.Timestamp, commit interfaces.IMsg, entryhash interfaces.IHash)

GetEntryCommitAckByTXID will fetch the status of a commit by TxID 

Searches this order:
	Database	--> Check if it made it to blockchain
	PL			-->	See if it is still in the processlist
	PL - 1		-->	Only if min 0, because then it's not in DB yet, but still in this PL
	Holding 	--> See if it is in holding

func (*State) GetEntryDBHeightComplete 

func (s *State) GetEntryDBHeightComplete() uint32

func (*State) GetEntryRevealAckByEntryHash 

func (s *State) GetEntryRevealAckByEntryHash(hash interfaces.IHash) (status int, blktime interfaces.Timestamp, commit interfaces.IMsg)

GetEntryRevealAck will fetch the status of a entryreveal. The places it checks are: 

	ReplayMap	--> This indicates if the entry made it into the processlist within the last 4 hrs
	Database	-->	Check if it made it to blockchain
	Holding		-->	See if it is in holding. Will also look for commit if it finds that

Returns:
	status 		= Status of reveal from possible ack responses
	blktime		= The time of the block if found in the database, nil if not found in blockchain
	commit		 = Only returned if found from holding. This will be empty if found in dbase or in processlist

func (*State) GetF 

func (s *State) GetF(rt bool, adr [32]byte) (v int64)

GetF() If rt == true, read the Temp balances. Otherwise read the Permanent balances. concurrency safe to call

func (*State) GetFactoidState 

func (s *State) GetFactoidState() interfaces.IFactoidState

func (*State) GetFactomNodeName 

func (s *State) GetFactomNodeName() string

func (*State) GetFactomdLocations 

func (s *State) GetFactomdLocations() string

func (*State) GetFactomdVersion 

func (s *State) GetFactomdVersion() string

func (*State) GetFactoshisPerEC 

func (s *State) GetFactoshisPerEC() uint64

func (*State) GetFaultTimeout 

func (s *State) GetFaultTimeout() int

func (*State) GetFaultWait 

func (s *State) GetFaultWait() int

func (*State) GetFedServers 

func (s *State) GetFedServers(dbheight uint32) []interfaces.IServer

func (*State) GetFilterTimeNano 

func (s *State) GetFilterTimeNano() int64

func (*State) GetHighestAck 

func (s *State) GetHighestAck() uint32

func (*State) GetHighestCompletedBlk 

func (s *State) GetHighestCompletedBlk() uint32

This is the highest block signed off, but not necessarily validated.

func (*State) GetHighestKnownBlock 

func (s *State) GetHighestKnownBlock() uint32

The highest block for which we have received a message. Sometimes the same as BuildingBlock(), but can be different depending or the order messages are received.

func (*State) GetHighestLockedSignedAndSavesBlk 

func (s *State) GetHighestLockedSignedAndSavesBlk() uint32

func (*State) GetHighestSavedBlk 

func (s *State) GetHighestSavedBlk() uint32

This is the highest block signed off and recorded in the Database.

func (*State) GetIdentityChainID 

func (s *State) GetIdentityChainID() (rval interfaces.IHash)

func (*State) GetIgnoreDone 

func (s *State) GetIgnoreDone() bool

func (*State) GetInputRegEx 

func (s *State) GetInputRegEx() (*regexp.Regexp, string)

func (*State) GetInvalidMsg 

func (s *State) GetInvalidMsg(hash interfaces.IHash) interfaces.IMsg

func (*State) GetJournalMessages 

func (s *State) GetJournalMessages() [][]byte

GetJournalMessages gets all messages from the message journal

func (*State) GetLLeaderHeight 

func (s *State) GetLLeaderHeight() uint32

func (*State) GetLastStatus 

func (s *State) GetLastStatus() string

func (*State) GetLeaderHeight 

func (s *State) GetLeaderHeight() uint32

This is lowest block currently under construction under the "leader".

func (*State) GetLeaderPL 

func (s *State) GetLeaderPL() interfaces.IProcessList

GetLeaderPL returns the leader process list from the state. this method is for debugging and should not be called in normal production code.

func (*State) GetLeaderTimestamp 

func (s *State) GetLeaderTimestamp() interfaces.Timestamp

func (*State) GetLeaderVM 

func (s *State) GetLeaderVM() int

func (*State) GetMatryoshka 

func (s *State) GetMatryoshka(dbheight uint32) (rval interfaces.IHash)

func (*State) GetMessageFilterTimestamp 

func (s *State) GetMessageFilterTimestamp() interfaces.Timestamp

func (*State) GetMessageTalliesReceived 

func (s *State) GetMessageTalliesReceived(i int) int

func (*State) GetMessageTalliesSent 

func (s *State) GetMessageTalliesSent(i int) int

func (*State) GetMinuteDuration 

func (s *State) GetMinuteDuration() time.Duration

func (*State) GetMissingDBState 

func (s *State) GetMissingDBState(height uint32) error

func (*State) GetMissingEntryCount 

func (s *State) GetMissingEntryCount() uint32

func (*State) GetMsg 

func (s *State) GetMsg(vmIndex int, dbheight int, height int) (interfaces.IMsg, error)

func (*State) GetNetStateOff 

func (s *State) GetNetStateOff() bool

func (*State) GetNetworkBootStrapIdentity 

func (s *State) GetNetworkBootStrapIdentity() (rval interfaces.IHash)

The initial identity that can sign the first block

func (*State) GetNetworkBootStrapKey 

func (s *State) GetNetworkBootStrapKey() (rval interfaces.IHash)

The initial public key that can sign the first block

func (*State) GetNetworkID 

func (s *State) GetNetworkID() uint32

func (*State) GetNetworkIdentityRegistrationChain 

func (s *State) GetNetworkIdentityRegistrationChain() (rval interfaces.IHash)

func (*State) GetNetworkName 

func (s *State) GetNetworkName() string

func (*State) GetNetworkNumber 

func (s *State) GetNetworkNumber() int

func (*State) GetNetworkSkeletonIdentity 

func (s *State) GetNetworkSkeletonIdentity() (rval interfaces.IHash)

The identity for validating messages

func (*State) GetNetworkSkeletonKey 

func (st *State) GetNetworkSkeletonKey() (rval interfaces.IHash)

func (*State) GetNewEBlocks 

func (s *State) GetNewEBlocks(dbheight uint32, hash interfaces.IHash) interfaces.IEntryBlock

func (*State) GetNewHash 

func (s *State) GetNewHash() (rval interfaces.IHash)

func (*State) GetOnlineAuditServers 

func (s *State) GetOnlineAuditServers(dbheight uint32) []interfaces.IServer

func (*State) GetOut 

func (s *State) GetOut() bool

func (*State) GetOutputRegEx 

func (s *State) GetOutputRegEx() (*regexp.Regexp, string)

func (*State) GetPendingEntries 

func (s *State) GetPendingEntries(params interface{}) []interfaces.IPendingEntry

func (*State) GetPendingTransactions 

func (s *State) GetPendingTransactions(params interface{}) []interfaces.IPendingTransaction

func (*State) GetPort 

func (s *State) GetPort() int

func (*State) GetPredictiveFER 

func (this *State) GetPredictiveFER() uint64

Returns the higher of the current factoid exchange rate and what it knows will change in the future

func (*State) GetPreviousMinuteStartTime 

func (s *State) GetPreviousMinuteStartTime() int64

func (*State) GetRpcAuthHash 

func (s *State) GetRpcAuthHash() []byte

func (*State) GetRpcPass 

func (s *State) GetRpcPass() string

func (*State) GetRpcUser 

func (s *State) GetRpcUser() string

func (*State) GetRunLeader 

func (s *State) GetRunLeader() bool

func (*State) GetRunState 

func (s *State) GetRunState() runstate.RunState

func (*State) GetSalt 

func (s *State) GetSalt(ts interfaces.Timestamp) uint32

func (*State) GetServerPrivateKey 

func (s *State) GetServerPrivateKey() *primitives.PrivateKey

func (*State) GetServerPublicKey 

func (s *State) GetServerPublicKey() *primitives.PublicKey

func (*State) GetServerPublicKeyString 

func (s *State) GetServerPublicKeyString() string

func (*State) GetSigningKey 

func (st *State) GetSigningKey(id interfaces.IHash) (interfaces.IHash, int)

GetSigningKey will return the signing key of the identity, and it's type 

Returns:
	-1	--> Follower
	0 	--> Audit Server
	1	--> Federated

func (*State) GetSpecificACKStatus 

func (s *State) GetSpecificACKStatus(hash interfaces.IHash) (int, interfaces.IHash, interfaces.Timestamp, interfaces.Timestamp, error)

GetSpecificACKStatus does NOT check the oldmsgs map. This is because the processlists map for entries and entry blocks is updated after the oldmsgs. This means an EntryACK will returns TransactionACK, but GetChain will return not found To fix this, for some calls (entries) we don't want to check the oldmsgs.

func (*State) GetStatus 

func (s *State) GetStatus() []string

func (*State) GetSystemHeight 

func (s *State) GetSystemHeight(dbheight uint32) int

func (*State) GetSystemMsg 

func (s *State) GetSystemMsg(dbheight uint32, height uint32) interfaces.IMsg

Gets the system message at the given dbheight, and given height in the System list

func (*State) GetTimeOffset 

func (s *State) GetTimeOffset() interfaces.Timestamp

func (*State) GetTimestamp 

func (s *State) GetTimestamp() interfaces.Timestamp

Returns a millisecond timestamp

func (*State) GetTlsInfo 

func (s *State) GetTlsInfo() (bool, string, string)

func (*State) GetTrueLeaderHeight 

func (s *State) GetTrueLeaderHeight() uint32

returns what finished block height this node thinks the leader is at, assuming that the local node has the process list the leader is working on plus an extra empty one on top of it.

func (*State) GetUnsyncedServers 

func (s *State) GetUnsyncedServers() (ids []interfaces.IHash, vms []int)

GetUnsyncedServers returns an array of the IDs for all unsynced VMs when you are not in a sync phase, no VM is considered sync'd

func (*State) GetUnsyncedServersString 

func (s *State) GetUnsyncedServersString() string

GetUnsyncedServersString returns a string with the short IDs for all unsynced VMs

func (*State) GetVirtualServers 

func (s *State) GetVirtualServers(dbheight uint32, minute int, identityChainID interfaces.IHash) (bool, int)

func (*State) GoSyncEntries 

func (s *State) GoSyncEntries()

GoSyncEntries() Start up all of our supporting go routines, and run through the directory blocks and make sure we have all the entries they reference.

func (*State) GotHeartbeat 

func (s *State) GotHeartbeat(heartbeatTS interfaces.Timestamp, dbheight uint32)

func (*State) HoldForHeight 

func (s *State) HoldForHeight(ht uint32, minute int, msg interfaces.IMsg) int

func (*State) HookLogstash 

func (s *State) HookLogstash() error

func (*State) InMsgQueue 

func (s *State) InMsgQueue() interfaces.IQueue

func (*State) InMsgQueue2 

func (s *State) InMsgQueue2() interfaces.IQueue

func (*State) IncDBStateAnswerCnt 

func (s *State) IncDBStateAnswerCnt()

func (*State) IncECCommits 

func (s *State) IncECCommits()

func (*State) IncECommits 

func (s *State) IncECommits()

func (*State) IncEntries 

func (s *State) IncEntries()

func (*State) IncEntryChains 

func (s *State) IncEntryChains()

func (*State) IncFCTSubmits 

func (s *State) IncFCTSubmits()

func (*State) IncFactoidTrans 

func (s *State) IncFactoidTrans()

func (*State) Init 

func (s *State) Init()

func (*State) InitBoltDB 

func (s *State) InitBoltDB() error

func (*State) InitLevelDB 

func (s *State) InitLevelDB() error

func (*State) InitMapDB 

func (s *State) InitMapDB() error

func (*State) InitiateNetworkIdentityRegistration 

func (st *State) InitiateNetworkIdentityRegistration() error

func (*State) IntiateNetworkSkeletonIdentity 

func (st *State) IntiateNetworkSkeletonIdentity() error

Add the skeleton identity and try to build it

func (*State) IsActive 

func (s *State) IsActive(id activations.ActivationType) bool

Return if a feature is active for the current height

func (*State) IsHighestCommit 

func (s *State) IsHighestCommit(hash interfaces.IHash, msg interfaces.IMsg) bool

IsHighestCommit will determine if the commit given has more entry credits than the current commit in the commit hashmap. If there is no prior commit, this will also return true.

func (*State) IsLeader 

func (s *State) IsLeader() bool

func (*State) IsNewOrPendingEBlocks 

func (s *State) IsNewOrPendingEBlocks(dbheight uint32, hash interfaces.IHash) bool

func (*State) IsStalled 

func (s *State) IsStalled() bool

func (*State) IsStateFullySynced 

func (s *State) IsStateFullySynced() bool

func (*State) IsSyncing 

func (s *State) IsSyncing() bool

func (*State) IsSyncingDBSigs 

func (s *State) IsSyncingDBSigs() bool

func (*State) IsSyncingEOMs 

func (s *State) IsSyncingEOMs() bool

func (*State) JournalMessage 

func (s *State) JournalMessage(msg interfaces.IMsg)

JournalMessage writes the message to the message journal for debugging

func (*State) LeaderExecute 

func (s *State) LeaderExecute(m interfaces.IMsg)

func (*State) LeaderExecuteCommitChain 

func (s *State) LeaderExecuteCommitChain(m interfaces.IMsg)

func (*State) LeaderExecuteCommitEntry 

func (s *State) LeaderExecuteCommitEntry(m interfaces.IMsg)

func (*State) LeaderExecuteDBSig 

func (s *State) LeaderExecuteDBSig(m interfaces.IMsg)

func (*State) LeaderExecuteEOM 

func (s *State) LeaderExecuteEOM(m interfaces.IMsg)

func (*State) LeaderExecuteRevealEntry 

func (s *State) LeaderExecuteRevealEntry(m interfaces.IMsg)

func (*State) LoadAcksMap 

func (s *State) LoadAcksMap() map[[32]byte]interfaces.IMsg

this is called from the APIs that do not have access directly to the Acks. State makes a copy and puts it in AcksMap

func (*State) LoadConfig 

func (s *State) LoadConfig(filename string, networkFlag string)

func (*State) LoadDBState 

func (s *State) LoadDBState(dbheight uint32) (interfaces.IMsg, error)

func (*State) LoadDataByHash 

func (s *State) LoadDataByHash(requestedHash interfaces.IHash) (interfaces.BinaryMarshallable, int, error)

func (*State) LoadHoldingMap 

func (s *State) LoadHoldingMap() map[[32]byte]interfaces.IMsg

func (*State) LoadIdentityByEntry 

func (st *State) LoadIdentityByEntry(ent interfaces.IEBEntry, height uint32, dblockTimestamp interfaces.Timestamp, d *DBState)

LoadIdentityByEntry is only useful when initial is set to false. If initial is false, it will track changes in an identity that corresponds to an authority. If initial is true, then calling ProcessIdentityEntry directly will have the same result.

func (*State) LoadSpecificMsg 

func (s *State) LoadSpecificMsg(dbheight uint32, vm int, plistheight uint32) (interfaces.IMsg, error)

func (*State) LoadSpecificMsgAndAck 

func (s *State) LoadSpecificMsgAndAck(dbheight uint32, vmIndex int, plistheight uint32) (interfaces.IMsg, interfaces.IMsg, error)

func (*State) Log 

func (s *State) Log(level string, message string)

func (*State) LogMessage 

func (s *State) LogMessage(logName string, comment string, msg interfaces.IMsg)

func (*State) LogPrintf 

func (s *State) LogPrintf(logName string, format string, more ...interface{})

func (*State) Logf 

func (s *State) Logf(level string, format string, args ...interface{})

func (*State) LookupIdentityInBlockchainByChainID 

func (st *State) LookupIdentityInBlockchainByChainID(cid interfaces.IHash) error

func (*State) MMRDummy 

func (s *State) MMRDummy()

MMRDummy is for unit tests that populate the various mmr queues. We need to drain the queues to ensure we don't block. 

ONLY FOR UNIT TESTS

func (*State) MoveStateToHeight 

func (s *State) MoveStateToHeight(dbheight uint32, newMinute int)

func (*State) MsgQueue 

func (s *State) MsgQueue() chan interfaces.IMsg

func (*State) Needed 

func (s *State) Needed(eb interfaces.IEntryBlock) bool

Checks ChainIDs to determine if we need their entries to process entries and transactions.

func (*State) NetworkInvalidMsgQueue 

func (s *State) NetworkInvalidMsgQueue() chan interfaces.IMsg

func (*State) NetworkOutMsgQueue 

func (s *State) NetworkOutMsgQueue() interfaces.IQueue

func (*State) NewAck 

func (s *State) NewAck(msg interfaces.IMsg, balanceHash interfaces.IHash) interfaces.IMsg

Create a new Acknowledgement. Must be called by a leader. This call assumes all the pieces are in place to create a new acknowledgement

func (*State) NextCommit 

func (s *State) NextCommit(hash interfaces.IHash) interfaces.IMsg

Returns the oldest, not processed, Commit received

func (*State) NoEntryYet 

func (s *State) NoEntryYet(entryhash interfaces.IHash, ts interfaces.Timestamp) bool

Returns true if this hash exists nowhere in the Replay structures. Returns False if we have already seen this hash before. Replay is NOT updated yet.

func (*State) PassInputRegEx 

func (s *State) PassInputRegEx(RegEx *regexp.Regexp, RegExString string)

func (*State) PassOutputRegEx 

func (s *State) PassOutputRegEx(RegEx *regexp.Regexp, RegExString string)

func (*State) Print 

func (s *State) Print(a ...interface{}) (n int, err error)

func (*State) Println 

func (s *State) Println(a ...interface{}) (n int, err error)

func (*State) PrioritizedMsgQueue 

func (s *State) PrioritizedMsgQueue() chan interfaces.IMsg

func (*State) Process 

func (s *State) Process() (progress bool)

func (*State) ProcessAddServer 

func (s *State) ProcessAddServer(dbheight uint32, addServerMsg interfaces.IMsg) bool

func (*State) ProcessChangeServerKey 

func (s *State) ProcessChangeServerKey(dbheight uint32, changeServerKeyMsg interfaces.IMsg) bool

func (*State) ProcessCommitChain 

func (s *State) ProcessCommitChain(dbheight uint32, commitChain interfaces.IMsg) bool

func (*State) ProcessCommitEntry 

func (s *State) ProcessCommitEntry(dbheight uint32, commitEntry interfaces.IMsg) bool

func (*State) ProcessDBSig 

func (s *State) ProcessDBSig(dbheight uint32, msg interfaces.IMsg) bool

When we process the directory Signature, and we are the leader for said signature, it is then that we push it out to the rest of the network. Otherwise, if we are not the leader for the signature, it marks the sig complete for that list

func (*State) ProcessDBlock 

func (s *State) ProcessDBlock(finishedDBlocks chan int, finishedEntries chan int, dbrcs []*ReCheck)

func (*State) ProcessEOM 

func (s *State) ProcessEOM(dbheight uint32, msg interfaces.IMsg) bool

TODO: Should fault the server if we don't have the proper sequence of EOM messages.

func (*State) ProcessInvalidMsgQueue 

func (s *State) ProcessInvalidMsgQueue()

func (*State) ProcessRecentFERChainEntries 

func (this *State) ProcessRecentFERChainEntries()

Go through the factoid exchange rate chain and determine if an FER change should be scheduled

func (*State) ProcessRemoveServer 

func (s *State) ProcessRemoveServer(dbheight uint32, removeServerMsg interfaces.IMsg) bool

func (*State) ProcessRevealEntry 

func (s *State) ProcessRevealEntry(dbheight uint32, m interfaces.IMsg) (worked bool)

func (*State) PutCommit 

func (s *State) PutCommit(hash interfaces.IHash, msg interfaces.IMsg)

func (*State) PutE 

func (s *State) PutE(rt bool, adr [32]byte, v int64)

PutE() If rt == true, update the Temp balances. Otherwise update the Permanent balances. concurrency safe to call

func (*State) PutF 

func (s *State) PutF(rt bool, adr [32]byte, v int64)

PutF() If rt == true, update the Temp balances. Otherwise update the Permanent balances. concurrency safe to call

func (*State) PutNewEBlocks 

func (s *State) PutNewEBlocks(dbheight uint32, hash interfaces.IHash, eb interfaces.IEntryBlock)

func (*State) PutNewEntries 

func (s *State) PutNewEntries(dbheight uint32, hash interfaces.IHash, e interfaces.IEntry)

func (*State) ReadCfg 

func (s *State) ReadCfg(filename string) interfaces.IFactomConfig

ReadCfg forces a read of the Factom config file. However, it does not change the state of any cfg object held by other processes... Only what will be returned by future calls to Cfg().(s.Cfg.(*util.FactomdConfig)).String()

func (*State) RemoveAuditServer 

func (s *State) RemoveAuditServer(dbheight uint32, hash interfaces.IHash)

func (*State) RemoveFedServer 

func (s *State) RemoveFedServer(dbheight uint32, hash interfaces.IHash)

func (*State) RepairAuthorities 

func (s *State) RepairAuthorities()

RepairAuthorities will put the management chain of an identity in the authority if it is missing.

func (*State) RequestAndCollectMissingEntries 

func (s *State) RequestAndCollectMissingEntries()

RequestAndCollectMissingEntries() Manage go routines that are requesting and checking for missing entries

func (*State) Reset 

func (s *State) Reset()

func (*State) ReviewHolding 

func (s *State) ReviewHolding()

Places the entries in the holding map back into the XReview list for review if this is a leader, and those messages are that leader's responsibility

func (*State) RunUploadController 

func (s *State) RunUploadController()

func (*State) SendDBSig 

func (s *State) SendDBSig(dbheight uint32, vmIndex int)

dbheight is the height of the process list, and vmIndex is the vm that is missing the DBSig. If the DBSig isn't our responsibility, then this call will do nothing. Assumes the state for the leader is set properly

func (*State) SendHeartBeat 

func (s *State) SendHeartBeat()

func (*State) SendManager 

func (s *State) SendManager()

SendManager keeps us from double sending entries on repeats.

func (*State) SetAuthoritySetString 

func (s *State) SetAuthoritySetString(authSet string)

func (*State) SetDBStateManagerCompletedHeight 

func (s *State) SetDBStateManagerCompletedHeight(height uint32) error

func (*State) SetDBStatesSent 

func (s *State) SetDBStatesSent(sents []*interfaces.DBStateSent)

func (*State) SetDelay 

func (s *State) SetDelay(delay int64)

func (*State) SetDirectoryBlockInSeconds 

func (s *State) SetDirectoryBlockInSeconds(t int)

func (*State) SetDropRate 

func (s *State) SetDropRate(droprate int)

func (*State) SetEntryBlockDBHeightComplete 

func (s *State) SetEntryBlockDBHeightComplete(newHeight uint32)

func (*State) SetEntryBlockDBHeightProcessing 

func (s *State) SetEntryBlockDBHeightProcessing(newHeight uint32)

func (*State) SetFactoidState 

func (s *State) SetFactoidState(dbheight uint32, fs interfaces.IFactoidState)

func (*State) SetFactoshisPerEC 

func (s *State) SetFactoshisPerEC(factoshisPerEC uint64)

func (*State) SetFaultTimeout 

func (s *State) SetFaultTimeout(timeout int)

func (*State) SetFaultWait 

func (s *State) SetFaultWait(wait int)

func (*State) SetHighestAck 

func (s *State) SetHighestAck(dbht uint32)

func (*State) SetHighestKnownBlock 

func (s *State) SetHighestKnownBlock(dbht uint32)

func (*State) SetIdentityChainID 

func (s *State) SetIdentityChainID(chainID interfaces.IHash)

func (*State) SetIsDoneReplaying 

func (s *State) SetIsDoneReplaying()

func (*State) SetIsReplaying 

func (s *State) SetIsReplaying()

func (*State) SetLeaderTimestamp 

func (s *State) SetLeaderTimestamp(ts interfaces.Timestamp)

func (*State) SetMessageFilterTimestamp 

func (s *State) SetMessageFilterTimestamp(leaderTS interfaces.Timestamp)

the MessageFilterTimestamp is used to filter messages from the past or before the replay filter. We will not set it to a time that is before (20 minutes before) boot or more than one hour in the past. this ensure messages from prior boot and messages that predate the current replay filter are are dropped. It marks the start of the replay filter content

func (*State) SetNetStateOff 

func (s *State) SetNetStateOff(net bool)

func (*State) SetOut 

func (s *State) SetOut(o bool)

func (*State) SetPendingSigningKey 

func (s *State) SetPendingSigningKey(p *primitives.PrivateKey)

func (*State) SetPort 

func (s *State) SetPort(port int)

Allow us the ability to update the port number at run time....

func (*State) SetRpcAuthHash 

func (s *State) SetRpcAuthHash(authHash []byte)

func (*State) SetString 

func (s *State) SetString()

func (*State) SetStringConsensus 

func (s *State) SetStringConsensus()

func (*State) SetStringQueues 

func (s *State) SetStringQueues()

func (*State) SetTorrentUploader 

func (s *State) SetTorrentUploader(setVal bool)

Only called once to set the torrent flag.

func (*State) SetUseTorrent 

func (s *State) SetUseTorrent(setVal bool)

Only called once to set the torrent flag.

func (*State) SetupCrossBootReplay 

func (s *State) SetupCrossBootReplay(path string)

SetupCrossBootReplay will construct the database

func (*State) ShortString 

func (s *State) ShortString() string

func (*State) ShutdownNode 

func (s *State) ShutdownNode(exitCode int)

func (*State) Sign 

func (s *State) Sign(b []byte) interfaces.IFullSignature

func (*State) SimGetSigKey 

func (s *State) SimGetSigKey() string

func (*State) SimSetNewKeys 

func (s *State) SimSetNewKeys(p *primitives.PrivateKey)

func (*State) StartMMR 

func (s *State) StartMMR()

starts the MMR processing for this state

func (*State) StartTorrentSyncing 

func (s *State) StartTorrentSyncing() error

StartTorrentSyncing is an endless loop that uses torrents to sync missing blocks It will grab any block higher than the highest dblock saved in the database up to the highest known block.

func (*State) String 

func (s *State) String() string

func (*State) SummaryHeader 

func (s *State) SummaryHeader() string

func (*State) SyncIdentities 

func (st *State) SyncIdentities(d *DBState)

SyncIdentities will run through the identities and sync any identities that need to be updated. If the current height is equal to the eblock+1, then this entry can trigger a change in key to the admin block

func (*State) TallyReceived 

func (s *State) TallyReceived(msgType int)

func (*State) TallySent 

func (s *State) TallySent(msgType int)

func (*State) TickerQueue 

func (s *State) TickerQueue() chan int

func (*State) TimerMsgQueue 

func (s *State) TimerMsgQueue() chan interfaces.IMsg

func (*State) TorrentUploader 

func (s *State) TorrentUploader() bool

func (*State) TrimVMList 

func (s *State) TrimVMList(dbheight uint32, height uint32, vmIndex int)

func (*State) UpdateAuthSigningKeys 

func (st *State) UpdateAuthSigningKeys(height uint32)

We keep a 2 block history of their keys, this is so if we change their key and need to verify a message from 1 block ago, we still can. This function garbage collects old keys

func (*State) UpdateAuthorityFromABEntry 

func (st *State) UpdateAuthorityFromABEntry(entry interfaces.IABEntry) error

func (*State) UpdateECs 

func (s *State) UpdateECs(ec interfaces.IEntryCreditBlock)

func (*State) UpdateState 

func (s *State) UpdateState() (progress bool)

func (*State) UploadDBState 

func (s *State) UploadDBState(dbheight uint32)

All calls get sent here and redirected into the uploadcontroller queue.

func (*State) UsingTorrent 

func (s *State) UsingTorrent() bool

func (*State) Validate 

func (s *State) Validate(msg interfaces.IMsg) (validToSend int, validToExec int)

this is the common validation to all messages. they must not be a reply, they must not be out size the time window for the replay filter.

func (*State) ValidatePrevious 

func (s *State) ValidatePrevious(dbheight uint32) error

func (*State) ValidatorLoop 

func (s *State) ValidatorLoop()

func (*State) VerifyAuthoritySignature 

func (st *State) VerifyAuthoritySignature(msg []byte, sig *[constants.SIGNATURE_LENGTH]byte, dbheight uint32) (rval int, err error)

Checks the signature of a message. Returns an int based on who signed it: 

1  -> Federated Signature
0  -> Audit Signature
-1 -> Neither Fed or Audit Signature

func (*State) VerifyIsAuthority 

func (st *State) VerifyIsAuthority(cid interfaces.IHash) bool

Verifies if is authority 

Return true if authority, false if not

func (*State) WriteEntries 

func (s *State) WriteEntries()

WriteEntriesToTheDB() As Entries come in and are validated, then write them to the database

type StateSaverStruct 

type StateSaverStruct struct {
	FastBoot         bool
	FastBootLocation string

	TmpDBHt  uint32
	TmpState []byte
	Mutex    sync.Mutex
	Stop     bool
}

func (*StateSaverStruct) DeleteSaveState 

func (sss *StateSaverStruct) DeleteSaveState(networkName string) error

func (*StateSaverStruct) LoadDBStateList 

func (sss *StateSaverStruct) LoadDBStateList(s *State, statelist *DBStateList, networkName string) error

func (*StateSaverStruct) SaveDBStateList 

func (sss *StateSaverStruct) SaveDBStateList(s *State, ss *DBStateList, networkName string) error

func (*StateSaverStruct) StopSaving 

func (sss *StateSaverStruct) StopSaving()

type StatesMissing 

type StatesMissing struct {
	List *list.List
	// contains filtered or unexported fields
}

func NewStatesMissing 

func NewStatesMissing() *StatesMissing

NewStatesMissing creates a new list of missing DBStates.

func (*StatesMissing) Add 

func (l *StatesMissing) Add(height uint32)

Add adds a new MissingState to the list.

func (*StatesMissing) DeleteLockless 

func (l *StatesMissing) DeleteLockless(height uint32)

func (*StatesMissing) Get 

func (l *StatesMissing) Get(height uint32) *MissingState

func (*StatesMissing) GetFront 

func (l *StatesMissing) GetFront() *MissingState

func (*StatesMissing) GetNext 

func (l *StatesMissing) GetNext() *MissingState

GetNext pops the next MissingState from the list.

func (*StatesMissing) Len 

func (l *StatesMissing) Len() int

func (*StatesMissing) LockAndDelete 

func (l *StatesMissing) LockAndDelete(height uint32)

LockAndDelete removes a MissingState from the list.

func (*StatesMissing) NextConsecutiveMissing 

func (l *StatesMissing) NextConsecutiveMissing(n int) (uint32, uint32)

NextConsecutiveMissing returns the heights of the the next n or fewer consecutive missing states

type StatesReceived 

type StatesReceived struct {
	List   *list.List
	Notify chan *messages.DBStateMsg
	// contains filtered or unexported fields
}

StatesReceived is the list of DBStates received from the network. "base" represents the height of known saved states.

func NewStatesReceived 

func NewStatesReceived() *StatesReceived

func (*StatesReceived) Add 

func (l *StatesReceived) Add(height uint32, msg *messages.DBStateMsg)

Add adds a new received state to the list.

func (*StatesReceived) Base 

func (l *StatesReceived) Base() uint32

Base returns the base height of the StatesReceived list

func (*StatesReceived) Get 

func (l *StatesReceived) Get(height uint32) *ReceivedState

Get returns a member from the StatesReceived list

func (*StatesReceived) GetNext 

func (l *StatesReceived) GetNext() *ReceivedState

func (*StatesReceived) Has 

func (l *StatesReceived) Has(height uint32) bool

func (*StatesReceived) Heighestreceived 

func (l *StatesReceived) Heighestreceived() uint32

Heighestreceived returns the height of the last member in StatesReceived

func (*StatesReceived) ListAsSlice 

func (l *StatesReceived) ListAsSlice() []uint32

ListAsSlice will return the list as a slice to be iterated over in a threadsafe manner.

func (*StatesReceived) LockAndDelete 

func (l *StatesReceived) LockAndDelete(height uint32)

LockAndDelete removes a state from the StatesReceived list

func (*StatesReceived) SetBase 

func (l *StatesReceived) SetBase(height uint32)

func (*StatesReceived) SetBaseLockless 

func (l *StatesReceived) SetBaseLockless(height uint32)

type StatesWaiting 

type StatesWaiting struct {
	List *list.List
	// contains filtered or unexported fields
}

func NewStatesWaiting 

func NewStatesWaiting() *StatesWaiting

func (*StatesWaiting) Add 

func (l *StatesWaiting) Add(height uint32)

func (*StatesWaiting) Get 

func (l *StatesWaiting) Get(height uint32) *WaitingState

func (*StatesWaiting) GetEnd 

func (l *StatesWaiting) GetEnd() *WaitingState

func (*StatesWaiting) Has 

func (l *StatesWaiting) Has(height uint32) bool

func (*StatesWaiting) Len 

func (l *StatesWaiting) Len() int

func (*StatesWaiting) ListAsSlice 

func (l *StatesWaiting) ListAsSlice() []*WaitingState

func (*StatesWaiting) LockAndDelete 

func (l *StatesWaiting) LockAndDelete(height uint32)

type UploadController 

type UploadController struct {
	DBStateManager interfaces.IManagerController
	// contains filtered or unexported fields
}

Controls the flow of uploading torrents

func NewUploadController 

func NewUploadController(dbsm interfaces.IManagerController) *UploadController

func (*UploadController) Close 

func (u *UploadController) Close()

type VM 

type VM struct {
	List            []interfaces.IMsg // Lists of acknowledged messages
	ListAck         []*messages.Ack   // Acknowledgements
	Height          int               // Height of first unprocessed message (count of messages processed)
	EomMinuteIssued int               // Last Minute Issued on this VM (from the leader, when we are the leader)
	LeaderMinute    int               // Where the leader is in acknowledging messages
	Synced          bool              // Is this VM synced yet?

	Signed      bool                 // We have signed the previous block.
	WhenFaulted int64                // WhenFaulted is a timestamp of when this VM was faulted
	FaultFlag   int                  // FaultFlag tracks what the VM was faulted for (0 = EOM missing, 1 = negotiation issue)
	ProcessTime interfaces.Timestamp // Last time we made progress on this VM
	VmIndex     int                  // the index of this MV
	HighestAsk  int                  // highest ask sent to MMR for this VM
	HighestNil  int                  // Debug highest nil reported
	// contains filtered or unexported fields
}

func (*VM) ReportMissing 

func (vm *VM) ReportMissing(height int, delay int64)

Ask VM for an MMR for this height with delay ms before asking the network called from validation thread to notify MMR that we are missing a message

type WaitingState 

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

func NewWaitingState 

func NewWaitingState(height uint32) *WaitingState

func (*WaitingState) Height 

func (s *WaitingState) Height() uint32

func (*WaitingState) RequestAge 

func (s *WaitingState) RequestAge() time.Duration

func (*WaitingState) ResetRequestAge 

func (s *WaitingState) ResetRequestAge()

type WholeBlock 

type WholeBlock struct {
	// Header and entry headers
	DBlock interfaces.IDirectoryBlock

	// Block and admin block entries
	ABlock interfaces.IAdminBlock

	// Block and transactions
	FBlock interfaces.IFBlock

	// Block and entries
	ECBlock interfaces.IEntryCreditBlock

	EBlocks []interfaces.IEntryBlock

	Entries []interfaces.IEBEntry

	SigList []interfaces.IFullSignature
}

func NewWholeBlock 

func NewWholeBlock() *WholeBlock

func ReadDBStateFromDebugFile 

func ReadDBStateFromDebugFile(filename string) (*WholeBlock, error)

func (*WholeBlock) AddEblock 

func (wb *WholeBlock) AddEblock(eb interfaces.IEntryBlock)

func (*WholeBlock) AddEntry 

func (wb *WholeBlock) AddEntry(e interfaces.IEntry)

func (*WholeBlock) AddIEBEntry 

func (wb *WholeBlock) AddIEBEntry(e interfaces.IEBEntry)

func (*WholeBlock) BlockToDBStateMsg 

func (wb *WholeBlock) BlockToDBStateMsg() interfaces.IMsg

func (*WholeBlock) IsSameAs 

func (a *WholeBlock) IsSameAs(b *WholeBlock) (resp bool)

func (*WholeBlock) MarshalBinary 

func (wb *WholeBlock) MarshalBinary() (b []byte, err error)

func (*WholeBlock) UnmarshalBinary 

func (wb *WholeBlock) UnmarshalBinary(data []byte) (err error)

func (*WholeBlock) UnmarshalBinaryData 

func (wb *WholeBlock) UnmarshalBinaryData(data []byte) (newData []byte, err error)

func (*WholeBlock) UnmarshalBinaryDataBuffer 

func (wb *WholeBlock) UnmarshalBinaryDataBuffer(buffer io.ReadSeeker, whence int) (read int64, err error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.