func (db *BoltDB) Get(bucket []byte, key []byte, destination interfaces.BinaryMarshallable) (interfaces.BinaryMarshallable, error) {
db.Sem.RLock()
defer db.Sem.RUnlock()
var v []byte
db.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket(bucket)
if b == nil {
return nil
}
v = b.Get(key)
if v == nil {
return nil
}
return nil
})
if v == nil { // If the value is undefined, return nil
return nil, nil
}
_, err := destination.UnmarshalBinaryData(v)
if err != nil {
return nil, err
}
return destination, nil
}
// Make this stuff easier to read.
func Unmarshall(thing interfaces.BinaryMarshallable, err error, data []byte) ([]byte, error) {
if err != nil {
return nil, err
}
newdata, err := thing.UnmarshalBinaryData(data)
return newdata, err
}
func (db *MapDB) Get(bucket, key []byte, destination interfaces.BinaryMarshallable) (interfaces.BinaryMarshallable, error) {
db.createCache(bucket)
db.Sem.RLock()
defer db.Sem.RUnlock()
if db.Cache == nil {
db.Cache = map[string]map[string][]byte{}
}
_, ok := db.Cache[string(bucket)]
if ok == false {
db.Cache[string(bucket)] = map[string][]byte{}
}
v, ok := db.Cache[string(bucket)][string(key)]
if ok == false {
return nil, nil
}
if v == nil {
return nil, nil
}
_, err := destination.UnmarshalBinaryData(v)
if err != nil {
return nil, err
}
return destination, nil
}
func TestCommitMarshalUnmarshal(t *testing.T) {
blocks := testHelper.CreateFullTestBlockSet()
for _, block := range blocks {
for _, tx := range block.ECBlock.GetEntries() {
h1, err := tx.MarshalBinary()
if err != nil {
t.Errorf("Error marshalling - %v", err)
}
var h2 []byte
var e interfaces.BinaryMarshallable
switch tx.ECID() {
case ECIDChainCommit:
e = new(CommitChain)
break
case ECIDEntryCommit:
e = new(CommitEntry)
break
case ECIDBalanceIncrease:
e = new(IncreaseBalance)
break
case ECIDMinuteNumber:
e = new(MinuteNumber)
break
case ECIDServerIndexNumber:
e = new(ServerIndexNumber)
break
default:
t.Error("Wrong ECID")
break
}
h2, err = e.UnmarshalBinaryData(h1)
if err != nil {
t.Logf("Tried to unmarshal %x", h1)
t.Errorf("Error unmarshalling - %v", err)
continue
}
if len(h2) > 0 {
t.Errorf("Leftovers from unmarshalling - %x", h2)
}
h2, err = e.MarshalBinary()
if err != nil {
t.Errorf("Error marshalling2 - %v", err)
continue
}
if primitives.AreBytesEqual(h1, h2) == false {
t.Error("ECEntries are not identical - %x vs %x", h1, h2)
}
}
}
}
func (d *BoltDB) Put(bucket []byte, key []byte, data interfaces.BinaryMarshallable) error {
hex, err := data.MarshalBinary()
if err != nil {
return err
}
err = d.db.Update(func(tx *bolt.Tx) error {
_, err := tx.CreateBucketIfNotExists(bucket)
if err != nil {
return err
}
b := tx.Bucket(bucket)
err = b.Put(key, hex)
return err
})
return err
}
func (db *MapDB) rawPut(bucket, key []byte, data interfaces.BinaryMarshallable) error {
if db.Cache == nil {
db.Cache = map[string]map[string][]byte{}
}
_, ok := db.Cache[string(bucket)]
if ok == false {
db.Cache[string(bucket)] = map[string][]byte{}
}
var hex []byte
var err error
if data != nil {
hex, err = data.MarshalBinary()
if err != nil {
return err
}
}
db.Cache[string(bucket)][string(key)] = hex
return nil
}
func (db *LevelDB) Put(bucket []byte, key []byte, data interfaces.BinaryMarshallable) error {
if db.lbatch == nil {
db.lbatch = new(leveldb.Batch)
}
defer db.lbatch.Reset()
ldbKey := append(bucket, key...)
hex, err := data.MarshalBinary()
if err != nil {
return err
}
db.lbatch.Put(ldbKey, hex)
err = db.lDB.Write(db.lbatch, db.wo)
if err != nil {
return err
}
return nil
}
func (db *LevelDB) Get(bucket []byte, key []byte, destination interfaces.BinaryMarshallable) (interfaces.BinaryMarshallable, error) {
db.dbLock.Lock()
defer db.dbLock.Unlock()
ldbKey := append(bucket, key...)
data, err := db.lDB.Get(ldbKey, db.ro)
if err != nil {
if strings.Contains(err.Error(), "not found") {
return nil, nil
}
return nil, err
}
_, err = destination.UnmarshalBinaryData(data)
if err != nil {
return nil, err
}
return destination, nil
}
func AreBinaryMarshallablesEqual(b1, b2 interfaces.BinaryMarshallable) (bool, error) {
if b1 == nil {
if b2 == nil {
return true, nil
}
return false, nil
}
if b2 == nil {
return false, nil
}
bytes1, err := b1.MarshalBinary()
if err != nil {
return false, err
}
bytes2, err := b2.MarshalBinary()
if err != nil {
return false, err
}
return AreBytesEqual(bytes1, bytes2), nil
}
func HandleV2RawData(state interfaces.IState, params interface{}) (interface{}, *primitives.JSONError) {
hashkey := new(HashRequest)
err := MapToObject(params, hashkey)
if err != nil {
panic(reflect.TypeOf(params))
return nil, NewInvalidParamsError()
}
h, err := primitives.HexToHash(hashkey.Hash)
if err != nil {
return nil, NewInvalidHashError()
}
var block interfaces.BinaryMarshallable
var b []byte
if block, _ = state.FetchECTransactionByHash(h); block != nil {
b, _ = block.MarshalBinary()
} else if block, _ = state.FetchFactoidTransactionByHash(h); block != nil {
b, _ = block.MarshalBinary()
} else if block, _ = state.FetchEntryByHash(h); block != nil {
b, _ = block.MarshalBinary()
}
if b == nil {
dbase := state.GetAndLockDB()
defer state.UnlockDB()
// try to find the block data in db and return the first one found
if block, _ = dbase.FetchFBlock(h); block != nil {
b, _ = block.MarshalBinary()
} else if block, _ = dbase.FetchDBlock(h); block != nil {
b, _ = block.MarshalBinary()
} else if block, _ = dbase.FetchABlock(h); block != nil {
b, _ = block.MarshalBinary()
} else if block, _ = dbase.FetchEBlock(h); block != nil {
b, _ = block.MarshalBinary()
} else if block, _ = dbase.FetchECBlock(h); block != nil {
b, _ = block.MarshalBinary()
} else if block, _ = dbase.FetchFBlock(h); block != nil {
b, _ = block.MarshalBinary()
} else if block, _ = dbase.FetchEntry(h); block != nil {
b, _ = block.MarshalBinary()
} else {
return nil, NewEntryNotFoundError()
}
}
d := new(RawDataResponse)
d.Data = hex.EncodeToString(b)
return d, nil
}
// Sign signs msg with PrivateKey and return Signature
func (pk *PrivateKey) MarshalSign(msg interfaces.BinaryMarshallable) (sig interfaces.IFullSignature) {
data, _ := msg.MarshalBinary()
return pk.Sign(data)
}