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 }