func GenerateGenesisBlocks(networkID uint32) (interfaces.IDirectoryBlock, interfaces.IAdminBlock, interfaces.IFBlock, interfaces.IEntryCreditBlock) {
dblk := directoryBlock.NewDirectoryBlock(nil)
ablk := adminBlock.NewAdminBlock(nil)
fblk := factoid.GetGenesisFBlock(networkID)
ecblk := entryCreditBlock.NewECBlock()
if networkID != constants.MAIN_NETWORK_ID {
if networkID == constants.TEST_NETWORK_ID {
ablk.AddFedServer(primitives.NewZeroHash())
} else {
ablk.AddFedServer(primitives.Sha([]byte("FNode0")))
}
} else {
ecblk.GetBody().AddEntry(entryCreditBlock.NewServerIndexNumber())
for i := 1; i < 11; i++ {
minute := entryCreditBlock.NewMinuteNumber(uint8(i))
ecblk.GetBody().AddEntry(minute)
}
}
dblk.SetABlockHash(ablk)
dblk.SetECBlockHash(ecblk)
dblk.SetFBlockHash(fblk)
dblk.GetHeader().SetNetworkID(networkID)
dblk.GetHeader().SetTimestamp(primitives.NewTimestampFromMinutes(24018960))
return dblk, ablk, fblk, ecblk
}
func (db *Overlay) FetchABlockHead() (interfaces.IAdminBlock, error) {
blk := adminBlock.NewAdminBlock()
block, err := db.FetchChainHeadByChainID([]byte{byte(ADMINBLOCK)}, primitives.NewHash(blk.GetChainID()), blk)
if err != nil {
return nil, err
}
if block == nil {
return nil, nil
}
return block.(interfaces.IAdminBlock), nil
}
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
}