neoneo-go/pkg/database/leveldb.go
2019-02-25 22:44:14 +00:00

143 lines
3.1 KiB
Go

package database
import (
"bytes"
"encoding/binary"
"fmt"
"github.com/CityOfZion/neo-go/pkg/wire/payload"
"github.com/CityOfZion/neo-go/pkg/wire/payload/transaction"
"github.com/CityOfZion/neo-go/pkg/wire/util"
"github.com/syndtr/goleveldb/leveldb"
"github.com/syndtr/goleveldb/leveldb/errors"
)
type LDB struct {
db *leveldb.DB
path string
}
type Database interface {
Has(key []byte) (bool, error)
Put(key []byte, value []byte) error
Get(key []byte) ([]byte, error)
Delete(key []byte) error
Close() error
}
var (
// TX, HEADER AND UTXO are the prefixes for the db
TX = []byte("TX")
HEADER = []byte("HEADER")
LATESTHEADER = []byte("LH")
UTXO = []byte("UTXO")
)
func New(path string) *LDB {
db, err := leveldb.OpenFile(path, nil)
if _, corrupted := err.(*errors.ErrCorrupted); corrupted {
db, err = leveldb.RecoverFile(path, nil)
}
if err != nil {
return nil
}
return &LDB{
db,
path,
}
}
func (l *LDB) Has(key []byte) (bool, error) {
return l.db.Has(key, nil)
}
func (l *LDB) Put(key []byte, value []byte) error {
return l.db.Put(key, value, nil)
}
func (l *LDB) Get(key []byte) ([]byte, error) {
return l.db.Get(key, nil)
}
func (l *LDB) Delete(key []byte) error {
return l.db.Delete(key, nil)
}
func (l *LDB) Close() error {
return l.db.Close()
}
func (l *LDB) AddHeader(header *payload.BlockBase) error {
table := NewTable(l, HEADER)
byt, err := header.Bytes()
if err != nil {
fmt.Println("Could not Get bytes from decoded BlockBase")
return nil
}
fmt.Println("Adding Header, This should be batched!!!!")
// This is the main mapping
//Key: HEADER+BLOCKHASH Value: contents of blockhash
key := header.Hash.Bytes()
err = table.Put(key, byt)
if err != nil {
fmt.Println("Error trying to add the original mapping into the DB for Header. Mapping is [Header]+[Hash]")
return err
}
// This is the secondary mapping
// Key: HEADER + BLOCKHEIGHT Value: blockhash
bh := uint32ToBytes(header.Index)
key = []byte(bh)
err = table.Put(key, header.Hash.Bytes())
if err != nil {
return err
}
// This is the third mapping
// WARNING: This assumes that headers are adding in order.
return table.Put(LATESTHEADER, header.Hash.Bytes())
}
func (l *LDB) AddTransactions(blockhash util.Uint256, txs []transaction.Transactioner) error {
// SHOULD BE DONE IN BATCH!!!!
for i, tx := range txs {
buf := new(bytes.Buffer)
fmt.Println(tx.ID())
tx.Encode(buf)
txByt := buf.Bytes()
txhash, err := tx.ID()
if err != nil {
fmt.Println("Error adding transaction with bytes", txByt)
return err
}
// This is the original mapping
// Key: [TX] + TXHASH
key := append(TX, txhash.Bytes()...)
l.Put(key, txByt)
// This is the index
// Key: [TX] + BLOCKHASH + I <- i is the incrementer from the for loop
//Value : TXHASH
key = append(TX, blockhash.Bytes()...)
key = append(key, uint32ToBytes(uint32(i))...)
err = l.Put(key, txhash.Bytes())
if err != nil {
fmt.Println("Error could not add tx index into db")
return err
}
}
return nil
}
// BigEndian
func uint32ToBytes(h uint32) []byte {
a := make([]byte, 4)
binary.BigEndian.PutUint32(a, h)
return a
}