func CreateTestEntryCreditBlock(prev interfaces.IEntryCreditBlock) interfaces.IEntryCreditBlock {
block, err := entryCreditBlock.NextECBlock(prev)
if err != nil {
panic(err)
}
return block
}
func (s *State) CreateDBlock() (b interfaces.IDirectoryBlock, err error) {
prev := s.GetCurrentDirectoryBlock()
b = new(directoryBlock.DirectoryBlock)
b.SetHeader(new(directoryBlock.DBlockHeader))
b.GetHeader().SetVersion(constants.VERSION_0)
if prev == nil {
b.GetHeader().SetPrevLedgerKeyMR(primitives.NewZeroHash())
b.GetHeader().SetPrevKeyMR(primitives.NewZeroHash())
b.GetHeader().SetDBHeight(0)
eb, _ := entryCreditBlock.NextECBlock(nil)
s.EntryCreditBlock = eb
} else {
bodyMR, err := prev.BuildBodyMR()
if err != nil {
return nil, err
}
prev.GetHeader().SetBodyMR(bodyMR)
prevLedgerKeyMR := prev.GetHash()
if prevLedgerKeyMR == nil {
return nil, errors.New("prevLedgerKeyMR is nil")
}
b.GetHeader().SetPrevLedgerKeyMR(prevLedgerKeyMR)
b.GetHeader().SetPrevKeyMR(prev.GetKeyMR())
b.GetHeader().SetDBHeight(prev.GetHeader().GetDBHeight() + 1)
eb, _ := entryCreditBlock.NextECBlock(s.EntryCreditBlock)
s.EntryCreditBlock = eb
}
b.SetDBEntries(make([]interfaces.IDBEntry, 0))
s.CurrentAdminBlock = s.NewAdminBlock()
b.AddEntry(primitives.NewHash(constants.ADMIN_CHAINID), primitives.NewZeroHash())
b.AddEntry(primitives.NewHash(constants.EC_CHAINID), primitives.NewZeroHash())
b.AddEntry(primitives.NewHash(constants.FACTOID_CHAINID), primitives.NewZeroHash())
return b, err
}
func NewProcessList(state interfaces.IState, previous *ProcessList, dbheight uint32) *ProcessList {
// We default to the number of Servers previous. That's because we always
// allocate the FUTURE directoryblock, not the current or previous...
pl := new(ProcessList)
pl.State = state.(*State)
// Make a copy of the previous FedServers
pl.FedServers = make([]interfaces.IFctServer, 0)
pl.AuditServers = make([]interfaces.IFctServer, 0)
pl.Requests = make(map[[32]byte]*Request)
//pl.Requests = make(map[[20]byte]*Request)
pl.FactoidBalancesT = map[[32]byte]int64{}
pl.ECBalancesT = map[[32]byte]int64{}
if previous != nil {
pl.FedServers = append(pl.FedServers, previous.FedServers...)
pl.AuditServers = append(pl.AuditServers, previous.AuditServers...)
for _, auditServer := range pl.AuditServers {
auditServer.SetOnline(false)
if state.GetIdentityChainID().IsSameAs(auditServer.GetChainID()) {
// Always consider yourself "online"
auditServer.SetOnline(true)
}
}
for _, fedServer := range pl.FedServers {
fedServer.SetOnline(true)
}
pl.SortFedServers()
} else {
pl.AddFedServer(state.GetNetworkBootStrapIdentity()) // Our default fed server, dependent on network type
// pl.AddFedServer(primitives.Sha([]byte("FNode0"))) // Our default for now fed server on LOCAL network
}
// We just make lots of VMs as they have nearly no impact if not used.
pl.VMs = make([]*VM, 65)
for i := 0; i < 65; i++ {
pl.VMs[i] = new(VM)
pl.VMs[i].List = make([]interfaces.IMsg, 0)
pl.VMs[i].Synced = true
pl.VMs[i].faultHeight = -1
pl.VMs[i].whenFaulted = 0
}
pl.DBHeight = dbheight
pl.MakeMap()
pl.OldMsgs = make(map[[32]byte]interfaces.IMsg)
pl.oldmsgslock = new(sync.Mutex)
pl.OldAcks = make(map[[32]byte]interfaces.IMsg)
pl.oldackslock = new(sync.Mutex)
pl.NewEBlocks = make(map[[32]byte]interfaces.IEntryBlock)
pl.neweblockslock = new(sync.Mutex)
pl.NewEntries = make(map[[32]byte]interfaces.IEntry)
pl.FaultMap = make(map[[32]byte]FaultState)
pl.AmINegotiator = false
pl.DBSignatures = make([]DBSig, 0)
// If a federated server, this is the server index, which is our index in the FedServers list
var err error
if previous != nil {
pl.DirectoryBlock = directoryBlock.NewDirectoryBlock(previous.DirectoryBlock)
pl.AdminBlock = adminBlock.NewAdminBlock(previous.AdminBlock)
pl.EntryCreditBlock, err = entryCreditBlock.NextECBlock(previous.EntryCreditBlock)
} else {
pl.DirectoryBlock = directoryBlock.NewDirectoryBlock(nil)
pl.AdminBlock = adminBlock.NewAdminBlock(nil)
pl.EntryCreditBlock, err = entryCreditBlock.NextECBlock(nil)
}
pl.ResetDiffSigTally()
if err != nil {
panic(err.Error())
}
return pl
}
func (p *ProcessList) Reset() bool {
previous := p.State.ProcessLists.Get(p.DBHeight - 1)
if previous == nil {
return false
}
// Make a copy of the previous FedServers
p.System.List = p.System.List[:0]
p.System.Height = 0
p.Requests = make(map[[32]byte]*Request)
//pl.Requests = make(map[[20]byte]*Request)
p.FactoidBalancesT = map[[32]byte]int64{}
p.ECBalancesT = map[[32]byte]int64{}
p.FedServers = append(p.FedServers[:0], previous.FedServers...)
p.AuditServers = append(p.AuditServers[:0], previous.AuditServers...)
for _, auditServer := range p.AuditServers {
auditServer.SetOnline(false)
if p.State.GetIdentityChainID().IsSameAs(auditServer.GetChainID()) {
// Always consider yourself "online"
auditServer.SetOnline(true)
}
}
for _, fedServer := range p.FedServers {
fedServer.SetOnline(true)
}
p.SortFedServers()
p.SortAuditServers()
p.OldMsgs = make(map[[32]byte]interfaces.IMsg)
p.OldAcks = make(map[[32]byte]interfaces.IMsg)
p.NewEBlocks = make(map[[32]byte]interfaces.IEntryBlock)
p.NewEntries = make(map[[32]byte]interfaces.IEntry)
p.FaultMap = make(map[[32]byte]FaultState)
p.AmINegotiator = false
p.DBSignatures = make([]DBSig, 0)
// If a federated server, this is the server index, which is our index in the FedServers list
var err error
if previous != nil {
p.DirectoryBlock = directoryBlock.NewDirectoryBlock(previous.DirectoryBlock)
p.AdminBlock = adminBlock.NewAdminBlock(previous.AdminBlock)
p.EntryCreditBlock, err = entryCreditBlock.NextECBlock(previous.EntryCreditBlock)
} else {
p.DirectoryBlock = directoryBlock.NewDirectoryBlock(nil)
p.AdminBlock = adminBlock.NewAdminBlock(nil)
p.EntryCreditBlock, err = entryCreditBlock.NextECBlock(nil)
}
if err != nil {
panic(err.Error())
}
p.ResetDiffSigTally()
for i := range p.FedServers {
vm := p.VMs[i]
vm.Height = 0 // Knock all the VMs back
vm.LeaderMinute = 0
vm.faultHeight = 0
vm.heartBeat = 0
vm.Signed = false
vm.Synced = false
vm.whenFaulted = 0
for _, msg := range vm.List {
if msg != nil {
p.State.Replay.Clear(constants.INTERNAL_REPLAY, msg.GetRepeatHash().Fixed())
p.State.Replay.Clear(constants.NETWORK_REPLAY, msg.GetRepeatHash().Fixed())
p.State.Replay.Clear(constants.REVEAL_REPLAY, msg.GetRepeatHash().Fixed())
if dbsig, ok := msg.(*messages.DirectoryBlockSignature); ok {
dbsig.Processed = false
}
if eom, ok := msg.(*messages.EOM); ok {
eom.Processed = false
}
}
}
p.State.Acks = make(map[[32]byte]interfaces.IMsg, 0)
p.VMs[i].List = p.VMs[i].List[:0] // Knock all the lists back.
p.VMs[i].ListAck = p.VMs[i].ListAck[:0] // Knock all the lists back.
//p.State.SendDBSig(p.DBHeight, i)
}
/*fs := p.State.FactoidState.(*FactoidState)
if previous.NextTimestamp != nil {
fs.Reset(previous)
}*/
index := p.DBHeight - p.State.DBStates.Base
p.State.DBStates.DBStates = p.State.DBStates.DBStates[:index]
s := p.State
s.LLeaderHeight--
s.Saving = true
s.Syncing = false
s.EOM = false
s.DBSig = false
s.CurrentMinute = 0
s.EOMProcessed = 0
s.DBSigProcessed = 0
s.StartDelay = s.GetTimestamp().GetTimeMilli()
s.RunLeader = false
s.Newblk = true
s.LLeaderHeight = s.GetHighestCompletedBlock() + 1
s.LeaderPL = s.ProcessLists.Get(s.LLeaderHeight)
s.Leader, s.LeaderVMIndex = s.LeaderPL.GetVirtualServers(s.CurrentMinute, s.IdentityChainID)
return true
}
