Merge branch 'develop' of github.com-obscure:ethereum/go-ethereum into develop

rpc/api.go

@@ -21,7 +21,10 @@ type EthereumApi struct {
 
 func NewEthereumApi(xeth *xeth.XEth, dataDir string) *EthereumApi {
 	// What about when dataDir is empty?
-	db, _ := ethdb.NewLDBDatabase(path.Join(dataDir, "dapps"))
+	db, err := ethdb.NewLDBDatabase(path.Join(dataDir, "dapps"))
+	if err != nil {
+		panic(err)
+	}
 	api := &EthereumApi{
 		eth: xeth,
 		db:  db,
@@ -361,7 +364,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
 			return err
 		}
 
-		api.db.Put([]byte(args.Database+args.Key), []byte(args.Value))
+		api.db.Put([]byte(args.Database+args.Key), args.Value)
 		*reply = true
 	case "db_getString":
 		args := new(DbArgs)
@@ -375,8 +378,30 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
 
 		res, _ := api.db.Get([]byte(args.Database + args.Key))
 		*reply = string(res)
-	case "db_putHex", "db_getHex":
+	case "db_putHex":
-		return NewNotImplementedError(req.Method)
+		args := new(DbHexArgs)
+		if err := json.Unmarshal(req.Params, &args); err != nil {
+			return err
+		}
+
+		if err := args.requirements(); err != nil {
+			return err
+		}
+
+		api.db.Put([]byte(args.Database+args.Key), args.Value)
+		*reply = true
+	case "db_getHex":
+		args := new(DbHexArgs)
+		if err := json.Unmarshal(req.Params, &args); err != nil {
+			return err
+		}
+
+		if err := args.requirements(); err != nil {
+			return err
+		}
+
+		res, _ := api.db.Get([]byte(args.Database + args.Key))
+		*reply = common.ToHex(res)
 	case "shh_post":
 		args := new(WhisperMessageArgs)
 		if err := json.Unmarshal(req.Params, &args); err != nil {

rpc/api_test.go

@@ -5,6 +5,8 @@ import (
 	// "sync"
 	"testing"
 	// "time"
+
+	"github.com/ethereum/go-ethereum/xeth"
 )
 
 func TestWeb3Sha3(t *testing.T) {
@@ -24,6 +26,50 @@ func TestWeb3Sha3(t *testing.T) {
 	}
 }
 
+func TestDbStr(t *testing.T) {
+	jsonput := `{"jsonrpc":"2.0","method":"db_putString","params":["testDB","myKey","myString"],"id":64}`
+	jsonget := `{"jsonrpc":"2.0","method":"db_getString","params":["testDB","myKey"],"id":64}`
+	expected := "myString"
+
+	xeth := &xeth.XEth{}
+	api := NewEthereumApi(xeth, "")
+	defer api.db.Close()
+	var response interface{}
+
+	var req RpcRequest
+	json.Unmarshal([]byte(jsonput), &req)
+	_ = api.GetRequestReply(&req, &response)
+
+	json.Unmarshal([]byte(jsonget), &req)
+	_ = api.GetRequestReply(&req, &response)
+
+	if response.(string) != expected {
+		t.Errorf("Expected %s got %s", expected, response)
+	}
+}
+
+func TestDbHexStr(t *testing.T) {
+	jsonput := `{"jsonrpc":"2.0","method":"db_putHex","params":["testDB","beefKey","0xbeef"],"id":64}`
+	jsonget := `{"jsonrpc":"2.0","method":"db_getHex","params":["testDB","beefKey"],"id":64}`
+	expected := "0xbeef"
+
+	xeth := &xeth.XEth{}
+	api := NewEthereumApi(xeth, "")
+	defer api.db.Close()
+	var response interface{}
+
+	var req RpcRequest
+	json.Unmarshal([]byte(jsonput), &req)
+	_ = api.GetRequestReply(&req, &response)
+
+	json.Unmarshal([]byte(jsonget), &req)
+	_ = api.GetRequestReply(&req, &response)
+
+	if response.(string) != expected {
+		t.Errorf("Expected %s got %s", expected, response)
+	}
+}
+
 // func TestFilterClose(t *testing.T) {
 // 	t.Skip()
 // 	api := &EthereumApi{

rpc/args.go

@@ -497,24 +497,39 @@ func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
 type DbArgs struct {
 	Database string
 	Key      string
-	Value    string
+	Value    []byte
 }
 
 func (args *DbArgs) UnmarshalJSON(b []byte) (err error) {
 	var obj []interface{}
-	r := bytes.NewReader(b)
+	if err := json.Unmarshal(b, &obj); err != nil {
-	if err := json.NewDecoder(r).Decode(&obj); err != nil {
 		return NewDecodeParamError(err.Error())
 	}
 
 	if len(obj) < 2 {
 		return NewInsufficientParamsError(len(obj), 2)
 	}
-	args.Database = obj[0].(string)
+
-	args.Key = obj[1].(string)
+	var objstr string
+	var ok bool
+
+	if objstr, ok = obj[0].(string); !ok {
+		return NewDecodeParamError("Database is not a string")
+	}
+	args.Database = objstr
+
+	if objstr, ok = obj[1].(string); !ok {
+		return NewDecodeParamError("Key is not a string")
+	}
+	args.Key = objstr
 
 	if len(obj) > 2 {
-		args.Value = obj[2].(string)
+		objstr, ok = obj[2].(string)
+		if !ok {
+			return NewDecodeParamError("Value is not a string")
+		}
+
+		args.Value = []byte(objstr)
 	}
 
 	return nil
@@ -530,6 +545,57 @@ func (a *DbArgs) requirements() error {
 	return nil
 }
 
+type DbHexArgs struct {
+	Database string
+	Key      string
+	Value    []byte
+}
+
+func (args *DbHexArgs) UnmarshalJSON(b []byte) (err error) {
+	var obj []interface{}
+	if err := json.Unmarshal(b, &obj); err != nil {
+		return NewDecodeParamError(err.Error())
+	}
+
+	if len(obj) < 2 {
+		return NewInsufficientParamsError(len(obj), 2)
+	}
+
+	var objstr string
+	var ok bool
+
+	if objstr, ok = obj[0].(string); !ok {
+		return NewDecodeParamError("Database is not a string")
+	}
+	args.Database = objstr
+
+	if objstr, ok = obj[1].(string); !ok {
+		return NewDecodeParamError("Key is not a string")
+	}
+	args.Key = objstr
+
+	if len(obj) > 2 {
+		objstr, ok = obj[2].(string)
+		if !ok {
+			return NewDecodeParamError("Value is not a string")
+		}
+
+		args.Value = common.FromHex(objstr)
+	}
+
+	return nil
+}
+
+func (a *DbHexArgs) requirements() error {
+	if len(a.Database) == 0 {
+		return NewValidationError("Database", "cannot be blank")
+	}
+	if len(a.Key) == 0 {
+		return NewValidationError("Key", "cannot be blank")
+	}
+	return nil
+}
+
 type WhisperMessageArgs struct {
 	Payload  string
 	To       string

rpc/args_test.go

@@ -485,11 +485,11 @@ func TestBlockFilterArgsEmptyArgs(t *testing.T) {
 }
 
 func TestDbArgs(t *testing.T) {
-	input := `["0x74657374","0x6b6579","0x6d79537472696e67"]`
+	input := `["testDB","myKey","0xbeef"]`
 	expected := new(DbArgs)
-	expected.Database = "0x74657374"
+	expected.Database = "testDB"
-	expected.Key = "0x6b6579"
+	expected.Key = "myKey"
-	expected.Value = "0x6d79537472696e67"
+	expected.Value = []byte("0xbeef")
 
 	args := new(DbArgs)
 	if err := json.Unmarshal([]byte(input), &args); err != nil {
@@ -508,7 +508,36 @@ func TestDbArgs(t *testing.T) {
 		t.Errorf("Key shoud be %#v but is %#v", expected.Key, args.Key)
 	}
 
-	if expected.Value != args.Value {
+	if bytes.Compare(expected.Value, args.Value) != 0 {
+		t.Errorf("Value shoud be %#v but is %#v", expected.Value, args.Value)
+	}
+}
+
+func TestDbHexArgs(t *testing.T) {
+	input := `["testDB","myKey","0xbeef"]`
+	expected := new(DbHexArgs)
+	expected.Database = "testDB"
+	expected.Key = "myKey"
+	expected.Value = []byte{0xbe, 0xef}
+
+	args := new(DbHexArgs)
+	if err := json.Unmarshal([]byte(input), &args); err != nil {
+		t.Error(err)
+	}
+
+	if err := args.requirements(); err != nil {
+		t.Error(err)
+	}
+
+	if expected.Database != args.Database {
+		t.Errorf("Database shoud be %#v but is %#v", expected.Database, args.Database)
+	}
+
+	if expected.Key != args.Key {
+		t.Errorf("Key shoud be %#v but is %#v", expected.Key, args.Key)
+	}
+
+	if bytes.Compare(expected.Value, args.Value) != 0 {
 		t.Errorf("Value shoud be %#v but is %#v", expected.Value, args.Value)
 	}
 }