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
}