func (db *Overlay) FetchEBlockHead(chainID interfaces.IHash) (interfaces.IEntryBlock, error) { block, err := db.FetchChainHeadByChainID([]byte{byte(ENTRYBLOCK)}, chainID, entryBlock.NewEBlock()) if err != nil { return nil, err } if block == nil { return nil, nil } return block.(*entryBlock.EBlock), nil }
// FetchEBlockByKeyMR gets an entry by hash from the database. func (db *Overlay) FetchEBlockByKeyMR(hash interfaces.IHash) (interfaces.IEntryBlock, error) { block, err := db.FetchBlock([]byte{byte(ENTRYBLOCK)}, hash, entryBlock.NewEBlock()) if err != nil { return nil, err } if block == nil { return nil, nil } return block.(interfaces.IEntryBlock), nil }
func (m *EntryBlockResponse) UnmarshalBinaryData(data []byte) (newData []byte, err error) { defer func() { if r := recover(); r != nil { err = fmt.Errorf("Error unmarshalling Directory Block State Missing Message: %v", r) } }() newData = data if newData[0] != m.Type() { return nil, fmt.Errorf("Invalid Message type") } newData = newData[1:] m.Peer2Peer = true // This is always a Peer2peer message m.Timestamp = new(primitives.Timestamp) newData, err = m.Timestamp.UnmarshalBinaryData(newData) if err != nil { return nil, err } m.EBlockCount, newData = binary.BigEndian.Uint32(newData[0:4]), newData[4:] for i := 0; i < int(m.EBlockCount); i++ { eBlock := entryBlock.NewEBlock() newData, err = eBlock.UnmarshalBinaryData(newData) if err != nil { return nil, err } m.EBlocks = append(m.EBlocks, eBlock) } m.EntryCount, newData = binary.BigEndian.Uint32(newData[0:4]), newData[4:] for i := 0; i < int(m.EntryCount); i++ { entry := entryBlock.NewEntry() newData, err = entry.UnmarshalBinaryData(newData) if err != nil { return nil, err } m.Entries = append(m.Entries, entry) } return }
func CreateTestAnchorEntryBlock(p interfaces.IEntryBlock, prevDBlock *directoryBlock.DirectoryBlock) (*entryBlock.EBlock, []*entryBlock.Entry) { prev, ok := p.(*entryBlock.EBlock) if ok == false { prev = nil } if prevDBlock == nil && prev != nil { return nil, nil } e := entryBlock.NewEBlock() entries := []*entryBlock.Entry{} if prev != nil { keyMR, err := prev.KeyMR() if err != nil { panic(err) } e.Header.SetPrevKeyMR(keyMR) hash, err := prev.Hash() if err != nil { panic(err) } e.Header.SetPrevFullHash(hash) e.Header.SetDBHeight(prev.GetHeader().GetDBHeight() + 1) e.Header.SetChainID(prev.GetHeader().GetChainID()) entry := CreateTestAnchorEnry(prevDBlock) e.AddEBEntry(entry) entries = append(entries, entry) } else { e.Header.SetPrevKeyMR(primitives.NewZeroHash()) e.Header.SetDBHeight(0) e.Header.SetChainID(GetAnchorChainID()) entry := CreateFirstAnchorEntry() e.AddEBEntry(entry) entries = append(entries, entry) } return e, entries }
func CreateTestEntryBlockForFER(p interfaces.IEntryBlock, height uint32) (*entryBlock.EBlock, []*entryBlock.Entry) { prev, ok := p.(*entryBlock.EBlock) if ok == false { prev = nil } e := entryBlock.NewEBlock() entries := []*entryBlock.Entry{} if prev != nil { keyMR, err := prev.KeyMR() if err != nil { panic(err) } e.Header.SetPrevKeyMR(keyMR) hash, err := prev.Hash() if err != nil { panic(err) } e.Header.SetPrevFullHash(hash) e.Header.SetDBHeight(prev.GetHeader().GetDBHeight() + 1) e.Header.SetChainID(prev.GetHeader().GetChainID()) entry := CreateTestFEREntry(e.Header.GetDBHeight()) e.AddEBEntry(entry) entries = append(entries, entry) } else { e.Header.SetPrevKeyMR(primitives.NewZeroHash()) e.Header.SetDBHeight(0) chainId := "111111118d918a8be684e0dac725493a75862ef96d2d3f43f84b26969329bf03" hexBytes, _ := hex.DecodeString(chainId) chainIdHash := primitives.NewHash(hexBytes) e.Header.SetChainID(chainIdHash) entry := CreateFirstTestEntry() e.AddEBEntry(entry) entries = append(entries, entry) } return e, entries }
func CreateTestEntryBlockWithContentN(p interfaces.IEntryBlock, content uint32) (*entryBlock.EBlock, []*entryBlock.Entry) { prev, ok := p.(*entryBlock.EBlock) if ok == false { prev = nil } e := entryBlock.NewEBlock() entries := []*entryBlock.Entry{} if prev != nil { keyMR, err := prev.KeyMR() if err != nil { panic(err) } e.Header.SetPrevKeyMR(keyMR) hash, err := prev.Hash() if err != nil { panic(err) } e.Header.SetPrevFullHash(hash) e.Header.SetDBHeight(prev.GetHeader().GetDBHeight() + 1) e.Header.SetChainID(prev.GetHeader().GetChainID()) entry := CreateTestEntry(content) e.AddEBEntry(entry) entries = append(entries, entry) } else { e.Header.SetPrevKeyMR(primitives.NewZeroHash()) e.Header.SetDBHeight(0) e.Header.SetChainID(GetChainID()) entry := CreateFirstTestEntry() e.AddEBEntry(entry) entries = append(entries, entry) } return e, entries }
func (m *DBStateMsg) UnmarshalBinaryData(data []byte) (newData []byte, err error) { //defer func() { // if r := recover(); r != nil { // err = fmt.Errorf("Error unmarshalling Directory Block State Message: %v", r) // } //}() newData = data if newData[0] != m.Type() { return nil, fmt.Errorf("Invalid Message type") } newData = newData[1:] m.Peer2Peer = true m.Timestamp = new(primitives.Timestamp) newData, err = m.Timestamp.UnmarshalBinaryData(newData) if err != nil { return nil, err } m.DirectoryBlock = new(directoryBlock.DirectoryBlock) newData, err = m.DirectoryBlock.UnmarshalBinaryData(newData) if err != nil { return nil, err } m.AdminBlock = new(adminBlock.AdminBlock) newData, err = m.AdminBlock.UnmarshalBinaryData(newData) if err != nil { return nil, err } m.FactoidBlock = new(factoid.FBlock) newData, err = m.FactoidBlock.UnmarshalBinaryData(newData) if err != nil { return nil, err } m.EntryCreditBlock = entryCreditBlock.NewECBlock() newData, err = m.EntryCreditBlock.UnmarshalBinaryData(newData) if err != nil { return nil, err } eBlockCount, newData := binary.BigEndian.Uint32(newData[0:4]), newData[4:] for i := uint32(0); i < eBlockCount; i++ { eBlock := entryBlock.NewEBlock() newData, err = eBlock.UnmarshalBinaryData(newData) if err != nil { panic(err.Error()) } m.EBlocks = append(m.EBlocks, eBlock) } entryCount, newData := binary.BigEndian.Uint32(newData[0:4]), newData[4:] for i := uint32(0); i < entryCount; i++ { var entrySize uint32 entrySize, newData = binary.BigEndian.Uint32(newData[0:4]), newData[4:] entry := entryBlock.NewEntry() newData, err = newData[int(entrySize):], entry.UnmarshalBinary(newData[:int(entrySize)]) if err != nil { panic(err.Error()) } m.Entries = append(m.Entries, entry) } return }
func (s *State) ProcessRevealEntry(dbheight uint32, m interfaces.IMsg) bool { msg := m.(*messages.RevealEntryMsg) myhash := msg.Entry.GetHash() chainID := msg.Entry.GetChainID() delete(s.Commits, msg.Entry.GetHash().Fixed()) eb := s.GetNewEBlocks(dbheight, chainID) eb_db := s.GetNewEBlocks(dbheight-1, chainID) if eb_db == nil { eb_db, _ = s.DB.FetchEBlockHead(chainID) } // Handle the case that this is a Entry Chain create // Must be built with CommitChain (i.e. !msg.IsEntry). Also // cannot have an existing chaing (eb and eb_db == nil) if !msg.IsEntry && eb == nil && eb_db == nil { // Create a new Entry Block for a new Entry Block Chain eb = entryBlock.NewEBlock() // Set the Chain ID eb.GetHeader().SetChainID(chainID) // Set the Directory Block Height for this Entry Block eb.GetHeader().SetDBHeight(dbheight) // Add our new entry eb.AddEBEntry(msg.Entry) // Put it in our list of new Entry Blocks for this Directory Block s.PutNewEBlocks(dbheight, chainID, eb) s.PutNewEntries(dbheight, myhash, msg.Entry) s.IncEntryChains() s.IncEntries() return true } // Create an entry (even if they used commitChain). Means there must // be a chain somewhere. If not, we return false. if eb == nil { if eb_db == nil { s.AddStatus("Failed to add to process Reveal Entry because no Entry Block found") return false } eb = entryBlock.NewEBlock() eb.GetHeader().SetEBSequence(eb_db.GetHeader().GetEBSequence() + 1) eb.GetHeader().SetPrevFullHash(eb_db.GetHash()) // Set the Chain ID eb.GetHeader().SetChainID(chainID) // Set the Directory Block Height for this Entry Block eb.GetHeader().SetDBHeight(dbheight) // Set the PrevKeyMR key, _ := eb_db.KeyMR() eb.GetHeader().SetPrevKeyMR(key) } // Add our new entry eb.AddEBEntry(msg.Entry) // Put it in our list of new Entry Blocks for this Directory Block s.PutNewEBlocks(dbheight, chainID, eb) s.PutNewEntries(dbheight, myhash, msg.Entry) // Monitor key changes for fed/audit servers LoadIdentityByEntry(msg.Entry, s, dbheight, false) s.IncEntries() return true }
// FetchEBlockByHash gets an entry block by merkle root from the database. func (db *Overlay) FetchEBlockBySecondary(hash interfaces.IHash) (interfaces.IEntryBlock, error) { block, err := db.FetchBlockBySecondaryIndex(ENTRYBLOCK_SECONDARYINDEX, ENTRYBLOCK, hash, entryBlock.NewEBlock()) if err != nil { return nil, err } if block == nil { return nil, nil } return block.(interfaces.IEntryBlock), nil }