cmd, codec, config, trie: ignore unexported struct fields, change tri…

…e.Genesis to genesis.GenesisData (#374) * update scale encode and decode to ignore unexported struct fields * remove trie.Genesis and create genesis.GenesisData which is the same as genesis.Genesis but with the initial state data unexported, since we don't need to store it in the DB again alongside the extra genesis data
ChainSafe · Jun 24, 2020 · 6e996ae · 6e996ae
1 parent b4fefbc
commit 6e996ae
Show file tree

Hide file tree

Showing 9 changed files with 190 additions and 176 deletions.
diff --git a/cmd/gossamer/configcmd.go b/cmd/gossamer/configcmd.go
@@ -26,6 +26,7 @@ import (
 	"github.com/ChainSafe/gossamer/cmd/utils"
 	"github.com/ChainSafe/gossamer/common"
 	cfg "github.com/ChainSafe/gossamer/config"
+	"github.com/ChainSafe/gossamer/config/genesis"
 	"github.com/ChainSafe/gossamer/core"
 	"github.com/ChainSafe/gossamer/dot"
 	"github.com/ChainSafe/gossamer/internal/api"
@@ -182,7 +183,7 @@ func setP2pConfig(ctx *cli.Context, fig *cfg.P2pCfg) {
 }
 
 // createP2PService starts a p2p network layer from provided config
-func createP2PService(fig *cfg.Config, gendata *trie.Genesis) (*p2p.Service, chan []byte) {
+func createP2PService(fig *cfg.Config, gendata *genesis.GenesisData) (*p2p.Service, chan []byte) {
 	config := p2p.Config{
 		BootstrapNodes: append(fig.P2p.BootstrapNodes, common.BytesToStringArray(gendata.Bootnodes)...),
 		Port:           fig.P2p.Port,

diff --git a/cmd/gossamer/configcmd_test.go b/cmd/gossamer/configcmd_test.go
@@ -33,7 +33,6 @@ import (
 	"github.com/ChainSafe/gossamer/config/genesis"
 	"github.com/ChainSafe/gossamer/internal/api"
 	"github.com/ChainSafe/gossamer/polkadb"
-	"github.com/ChainSafe/gossamer/trie"
 	log "github.com/ChainSafe/log15"
 	"github.com/urfave/cli"
 )
@@ -245,8 +244,8 @@ func TestSetGlobalConfig(t *testing.T) {
 }
 
 func TestCreateP2PService(t *testing.T) {
-	gendata := &trie.Genesis{
-		ProtocolId: []byte("gossamer"),
+	gendata := &genesis.GenesisData{
+		ProtocolId: "gossamer",
 	}
 
 	srv, _ := createP2PService(cfg.DefaultConfig(), gendata)

diff --git a/cmd/gossamer/genesis.go b/cmd/gossamer/genesis.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/ChainSafe/gossamer/cmd/utils"
+	"github.com/ChainSafe/gossamer/common"
 	cfg "github.com/ChainSafe/gossamer/config"
 	"github.com/ChainSafe/gossamer/config/genesis"
 	"github.com/ChainSafe/gossamer/polkadb"
@@ -20,19 +21,21 @@ func loadGenesis(ctx *cli.Context) error {
 
 	// read genesis file
 	fp := getGenesisPath(ctx)
-	gen, err := genesis.LoadGenesisJsonFile(fp)
+	log.Debug("Loading genesis", "genesisfile", fp, "datadir", fig.Global.DataDir)
+
+	gen, err := genesis.LoadGenesisData(fp)
 	if err != nil {
 		return err
 	}
 
+	log.Info("🕸\t Initializing node", "name", gen.Name, "id", gen.Id, "protocolID", gen.ProtocolId, "bootnodes", common.BytesToStringArray(gen.Bootnodes))
+
 	// DB: Create database dir and initialize stateDB and blockDB
 	dbSrv, err := polkadb.NewDbService(fig.Global.DataDir)
 	if err != nil {
 		return err
 	}
 
-	log.Info("🕸\t Initializing node", "genesisfile", fp, "datadir", fig.Global.DataDir, "name", gen.Name, "id", gen.Id, "protocolID", gen.ProtocolId, "bootnodes", gen.Bootnodes)
-
 	err = dbSrv.Start()
 	if err != nil {
 		return err
@@ -52,25 +55,24 @@ func loadGenesis(ctx *cli.Context) error {
 	// create and load storage trie with initial genesis state
 	t := trie.NewEmptyTrie(tdb)
 
-	err = t.Load(gen.Genesis.Raw)
+	err = t.Load(gen.GenesisFields().Raw)
 	if err != nil {
 		return fmt.Errorf("cannot load trie with initial state: %s", err)
 	}
 
 	// write initial genesis data to DB
 	err = t.StoreInDB()
 	if err != nil {
-		return err
+		return fmt.Errorf("cannot store genesis data in db: %s", err)
 	}
 
 	err = t.StoreHash()
 	if err != nil {
-		return err
+		return fmt.Errorf("cannot store genesis hash in db: %s", err)
 	}
 
 	// store node name, ID, p2p protocol, bootnodes in DB
-	tgen := trie.NewGenesisFromData(gen)
-	return t.Db().StoreGenesisData(tgen)
+	return t.Db().StoreGenesisData(gen)
 }
 
 // getGenesisPath gets the path to the genesis file

diff --git a/cmd/gossamer/genesis_test.go b/cmd/gossamer/genesis_test.go
@@ -60,10 +60,10 @@ func TestStoreGenesisInfo(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	expected := &trie.Genesis{
-		Name:       []byte(tmpGenesis.Name),
-		Id:         []byte(tmpGenesis.Id),
-		ProtocolId: []byte(tmpGenesis.ProtocolId),
+	expected := &genesis.GenesisData{
+		Name:       tmpGenesis.Name,
+		Id:         tmpGenesis.Id,
+		ProtocolId: tmpGenesis.ProtocolId,
 		Bootnodes:  common.StringArrayToBytes(tmpGenesis.Bootnodes),
 	}
 

diff --git a/codec/decode.go b/codec/decode.go
@@ -383,136 +383,139 @@ func (sd *Decoder) DecodeTuple(t interface{}) (interface{}, error) {
 	for i := 0; i < v.NumField(); i++ {
 		// get the field value at i
 		field := v.Field(i)
-		fieldValue := field.Addr().Interface()
 
-		switch v.Field(i).Interface().(type) {
-		case byte:
-			b := make([]byte, 1)
-			_, err = sd.Reader.Read(b)
-
-			ptr := fieldValue.(*byte)
-			*ptr = b[0]
-		case []byte:
-			o, err = sd.DecodeByteArray()
-			if err != nil {
-				break
-			}
-
-			// get the pointer to the value and set the value
-			ptr := fieldValue.(*[]byte)
-			*ptr = o.([]byte)
-		case int8:
-			o, err = sd.DecodeFixedWidthInt(int8(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int8)
-			*ptr = o.(int8)
-		case int16:
-			o, err = sd.DecodeFixedWidthInt(int16(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int16)
-			*ptr = o.(int16)
-		case int32:
-			o, err = sd.DecodeFixedWidthInt(int32(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int32)
-			*ptr = o.(int32)
-		case int64:
-			o, err = sd.DecodeFixedWidthInt(int64(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int64)
-			*ptr = o.(int64)
-		case uint16:
-			o, err = sd.DecodeFixedWidthInt(uint16(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*uint16)
-			*ptr = o.(uint16)
-		case uint32:
-			o, err = sd.DecodeFixedWidthInt(uint32(0))
-			if err != nil {
-				break
+		if field.CanInterface() {
+			fieldValue := field.Addr().Interface()
+
+			switch v.Field(i).Interface().(type) {
+			case byte:
+				b := make([]byte, 1)
+				_, err = sd.Reader.Read(b)
+
+				ptr := fieldValue.(*byte)
+				*ptr = b[0]
+			case []byte:
+				o, err = sd.DecodeByteArray()
+				if err != nil {
+					break
+				}
+
+				// get the pointer to the value and set the value
+				ptr := fieldValue.(*[]byte)
+				*ptr = o.([]byte)
+			case int8:
+				o, err = sd.DecodeFixedWidthInt(int8(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int8)
+				*ptr = o.(int8)
+			case int16:
+				o, err = sd.DecodeFixedWidthInt(int16(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int16)
+				*ptr = o.(int16)
+			case int32:
+				o, err = sd.DecodeFixedWidthInt(int32(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int32)
+				*ptr = o.(int32)
+			case int64:
+				o, err = sd.DecodeFixedWidthInt(int64(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int64)
+				*ptr = o.(int64)
+			case uint16:
+				o, err = sd.DecodeFixedWidthInt(uint16(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*uint16)
+				*ptr = o.(uint16)
+			case uint32:
+				o, err = sd.DecodeFixedWidthInt(uint32(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*uint32)
+				*ptr = o.(uint32)
+			case uint64:
+				o, err = sd.DecodeFixedWidthInt(uint64(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*uint64)
+				*ptr = o.(uint64)
+			case int:
+				o, err = sd.DecodeFixedWidthInt(int(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int)
+				*ptr = o.(int)
+			case uint:
+				o, err = sd.DecodeFixedWidthInt(uint(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*uint)
+				*ptr = o.(uint)
+			case bool:
+				o, err = sd.DecodeBool()
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*bool)
+				*ptr = o.(bool)
+			case *big.Int:
+				o, err = sd.DecodeBigInt()
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(**big.Int)
+				*ptr = o.(*big.Int)
+			case common.Hash:
+				b := make([]byte, 32)
+				_, err = sd.Reader.Read(b)
+
+				ptr := fieldValue.(*common.Hash)
+				*ptr = common.NewHash(b)
+			case string:
+				o, err = sd.DecodeByteArray()
+				if err != nil {
+					break
+				}
+
+				// get the pointer to the value and set the value
+				ptr := fieldValue.(*string)
+				*ptr = string(o.([]byte))
+			default:
+				_, err = sd.Decode(v.Field(i).Interface())
+				if err != nil {
+					break
+				}
 			}
 
-			ptr := fieldValue.(*uint32)
-			*ptr = o.(uint32)
-		case uint64:
-			o, err = sd.DecodeFixedWidthInt(uint64(0))
 			if err != nil {
 				break
 			}
-
-			ptr := fieldValue.(*uint64)
-			*ptr = o.(uint64)
-		case int:
-			o, err = sd.DecodeFixedWidthInt(int(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int)
-			*ptr = o.(int)
-		case uint:
-			o, err = sd.DecodeFixedWidthInt(uint(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*uint)
-			*ptr = o.(uint)
-		case bool:
-			o, err = sd.DecodeBool()
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*bool)
-			*ptr = o.(bool)
-		case *big.Int:
-			o, err = sd.DecodeBigInt()
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(**big.Int)
-			*ptr = o.(*big.Int)
-		case common.Hash:
-			b := make([]byte, 32)
-			_, err = sd.Reader.Read(b)
-
-			ptr := fieldValue.(*common.Hash)
-			*ptr = common.NewHash(b)
-		case string:
-			o, err = sd.DecodeByteArray()
-			if err != nil {
-				break
-			}
-
-			// get the pointer to the value and set the value
-			ptr := fieldValue.(*string)
-			*ptr = string(o.([]byte))
-		default:
-			_, err = sd.Decode(v.Field(i).Interface())
-			if err != nil {
-				break
-			}
-		}
-
-		if err != nil {
-			break
 		}
 	}
 

diff --git a/codec/encode.go b/codec/encode.go
@@ -233,10 +233,12 @@ func (se *Encoder) encodeTuple(t interface{}) (bytesEncoded int, err error) {
 		v = reflect.ValueOf(t)
 	}
 
-	values := make([]interface{}, v.NumField())
+	values := make([]interface{}, 0)
 
 	for i := 0; i < v.NumField(); i++ {
-		values[i] = v.Field(i).Interface()
+		if v.Field(i).CanInterface() {
+			values = append(values, v.Field(i).Interface())
+		}
 	}
 
 	for _, item := range values {