Merge branch 'master' of github.com:simple-rules/harmony-benchmark

benchmark.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/simple-rules/harmony-benchmark/attack"
 	"github.com/simple-rules/harmony-benchmark/consensus"
+	"github.com/simple-rules/harmony-benchmark/db"
 	"github.com/simple-rules/harmony-benchmark/log"
 	"github.com/simple-rules/harmony-benchmark/node"
 	"github.com/simple-rules/harmony-benchmark/utils"
@@ -38,12 +39,23 @@ func startProfiler(shardID string, logFolder string) {
 	}
 }
 
+func InitLDBDatabase(ip string, port string) (*db.LDBDatabase, error) {
+	// TODO(minhdoan): Refactor this.
+	dbFileName := "/tmp/harmony_" + ip + port + ".dat"
+	var err = os.RemoveAll(dbFileName)
+	if err != nil {
+		fmt.Println(err.Error())
+	}
+	return db.NewLDBDatabase(dbFileName, 0, 0)
+}
+
 func main() {
 	ip := flag.String("ip", "127.0.0.1", "IP of the node")
 	port := flag.String("port", "9000", "port of the node.")
 	configFile := flag.String("config_file", "config.txt", "file containing all ip addresses")
 	logFolder := flag.String("log_folder", "latest", "the folder collecting the logs of this execution")
 	attackedMode := flag.Int("attacked_mode", 0, "0 means not attacked, 1 means attacked, 2 means being open to be selected as attacked")
+	dbSupported := flag.Int("db_supported", 0, "0 means not db_supported, 1 means db_supported")
 	flag.Parse()
 
 	// Set up randomization seed.
@@ -74,6 +86,13 @@ func main() {
 	)
 	log.Root().SetHandler(h)
 
+	// Initialize leveldb if dbSupported.
+	var ldb *db.LDBDatabase = nil
+
+	if *dbSupported == 1 {
+		ldb, _ = InitLDBDatabase(*ip, *port)
+	}
+
 	// Consensus object.
 	consensus := consensus.NewConsensus(*ip, *port, shardID, peers, leader)
 
@@ -85,7 +104,7 @@ func main() {
 	// Set logger to attack model.
 	attack.GetInstance().SetLogger(consensus.Log)
 	// Current node.
-	currentNode := node.New(consensus)
+	currentNode := node.New(consensus, ldb)
 	// Create client peer.
 	clientPeer := distributionConfig.GetClientPeer()
 	// If there is a client configured in the node list.

blockchain/merkle_tree.go

@@ -0,0 +1,65 @@
+package blockchain
+
+import (
+	"crypto/sha256"
+)
+
+// MerkleTree represent a Merkle tree
+type MerkleTree struct {
+	RootNode *MerkleNode
+}
+
+// MerkleNode represent a Merkle tree node
+type MerkleNode struct {
+	Left  *MerkleNode
+	Right *MerkleNode
+	Data  []byte
+}
+
+// NewMerkleTree creates a new Merkle tree from a sequence of data
+func NewMerkleTree(data [][]byte) *MerkleTree {
+	var nodes []MerkleNode
+
+	if len(data)%2 != 0 {
+		data = append(data, data[len(data)-1])
+	}
+
+	for _, datum := range data {
+		node := NewMerkleNode(nil, nil, datum)
+		nodes = append(nodes, *node)
+	}
+
+	for i := 0; i < len(data)/2; i++ {
+		var newLevel []MerkleNode
+
+		for j := 0; j < len(nodes); j += 2 {
+			node := NewMerkleNode(&nodes[j], &nodes[j+1], nil)
+			newLevel = append(newLevel, *node)
+		}
+
+		nodes = newLevel
+	}
+
+	mTree := MerkleTree{&nodes[0]}
+
+	return &mTree
+}
+
+// NewMerkleNode creates a new Merkle tree node
+func NewMerkleNode(left, right *MerkleNode, data []byte) *MerkleNode {
+	mNode := MerkleNode{}
+
+	if left == nil && right == nil {
+		hash := sha256.Sum256(data)
+		mNode.Data = hash[:]
+	} else {
+		prevHashes := append(left.Data, right.Data...)
+		hash := sha256.Sum256(prevHashes)
+		mNode.Data = hash[:]
+	}
+
+	mNode.Left = left
+	mNode.Right = right
+
+	return &mNode
+}

client/btctxgen/main.go

@@ -200,13 +200,13 @@ func main() {
 	// Nodes containing utxopools to mirror the shards' data in the network
 	nodes := []*node.Node{}
 	for _, shardID := range shardIDs {
-		nodes = append(nodes, node.New(&consensus.Consensus{ShardID: shardID}))
+		nodes = append(nodes, node.New(&consensus.Consensus{ShardID: shardID}, nil))
 	}
 
 	// Client/txgenerator server node setup
 	clientPort := configr.GetClientPort()
 	consensusObj := consensus.NewConsensus("0", clientPort, "0", nil, p2p.Peer{})
-	clientNode := node.New(consensusObj)
+	clientNode := node.New(consensusObj, nil)
 
 	initClient(clientNode, clientPort, &leaders, &nodes)
 

client/txgen/main.go

@@ -276,7 +276,7 @@ func main() {
 	// Nodes containing utxopools to mirror the shards' data in the network
 	nodes := []*node.Node{}
 	for _, shardId := range shardIds {
-		node := node.New(&consensus.Consensus{ShardID: shardId})
+		node := node.New(&consensus.Consensus{ShardID: shardId}, nil)
 		// Assign many fake addresses so we have enough address to play with at first
 		node.AddTestingAddresses(setting.numOfAddress)
 		nodes = append(nodes, node)
@@ -285,7 +285,7 @@ func main() {
 	// Client/txgenerator server node setup
 	clientPort := configr.GetClientPort()
 	consensusObj := consensus.NewConsensus("0", clientPort, "0", nil, p2p.Peer{})
-	clientNode := node.New(consensusObj)
+	clientNode := node.New(consensusObj, nil)
 
 	if clientPort != "" {
 		clientNode.Client = client.NewClient(&leaders)

deploy.sh

@@ -25,6 +25,8 @@ if [ -z "$config" ]; then
    usage
 fi
 
+db_supported=$2
+
 # Kill nodes if any
 ./kill_node.sh
 
@@ -48,7 +50,11 @@ while IFS='' read -r line || [[ -n "$line" ]]; do
   IFS=' ' read ip port mode shardId <<< $line
 	#echo $ip $port $mode
   if [ "$mode" != "client" ]; then
-    ./bin/benchmark -ip $ip -port $port -config_file $config -log_folder $log_folder&
+    if [ -z "$db_supported" ]; then
+      ./bin/benchmark -ip $ip -port $port -config_file $config -log_folder $log_folder&
+    else
+      ./bin/benchmark -ip $ip -port $port -config_file $config -log_folder $log_folder  -db_supported 1&
+    fi
   fi
 done < $config
 

node/node.go

@@ -9,6 +9,7 @@ import (
 	"github.com/simple-rules/harmony-benchmark/client"
 	"github.com/simple-rules/harmony-benchmark/consensus"
 	"github.com/simple-rules/harmony-benchmark/crypto/pki"
+	"github.com/simple-rules/harmony-benchmark/db"
 	"github.com/simple-rules/harmony-benchmark/log"
 	"github.com/simple-rules/harmony-benchmark/p2p"
 )
@@ -21,6 +22,7 @@ type Node struct {
 	pendingTransactions    []*blockchain.Transaction          // All the transactions received but not yet processed for Consensus
 	transactionInConsensus []*blockchain.Transaction          // The transactions selected into the new block and under Consensus process
 	blockchain             *blockchain.Blockchain             // The blockchain for the shard where this node belongs
+	db                     *db.LDBDatabase                    // LevelDB to store blockchain.
 	UtxoPool               *blockchain.UTXOPool               // The corresponding UTXO pool of the current blockchain
 	CrossTxsInConsensus    []*blockchain.CrossShardTxAndProof // The cross shard txs that is under consensus, the proof is not filled yet.
 	CrossTxsToReturn       []*blockchain.CrossShardTxAndProof // The cross shard txs and proof that needs to be sent back to the user client.
@@ -95,7 +97,7 @@ func (node *Node) countNumTransactionsInBlockchain() int {
 }
 
 // Create a new Node
-func New(consensus *consensus.Consensus) *Node {
+func New(consensus *consensus.Consensus, db *db.LDBDatabase) *Node {
 	node := Node{}
 
 	// Consensus and associated channel to communicate blocks
@@ -116,5 +118,9 @@ func New(consensus *consensus.Consensus) *Node {
 
 	// Logger
 	node.log = node.Consensus.Log
+
+	// Initialize level db.
+	node.db = db
+
 	return &node
 }

node/node_handler.go

@@ -5,6 +5,7 @@ import (
 	"encoding/gob"
 	"net"
 	"os"
+	"strconv"
 	"time"
 
 	"github.com/simple-rules/harmony-benchmark/blockchain"
@@ -278,6 +279,11 @@ func (node *Node) PostConsensusProcessing(newBlock *blockchain.Block) {
 func (node *Node) AddNewBlock(newBlock *blockchain.Block) {
 	// Add it to blockchain
 	node.blockchain.Blocks = append(node.blockchain.Blocks, newBlock)
+	// Store it into leveldb.
+	if node.db != nil {
+		node.log.Info("Writing new block into disk.")
+		newBlock.Write(node.db, strconv.Itoa(len(node.blockchain.Blocks)))
+	}
 	// Update UTXO pool
 	node.UtxoPool.Update(newBlock.Transactions)
 	// Clear transaction-in-Consensus list

node/node_test.go

@@ -12,7 +12,7 @@ func TestNewNewNode(test *testing.T) {
 	validator := p2p.Peer{Ip: "3", Port: "5"}
 	consensus := consensus.NewConsensus("1", "2", "0", []p2p.Peer{leader, validator}, leader)
 
-	node := New(consensus)
+	node := New(consensus, nil)
 	if node.Consensus == nil {
 		test.Error("Consensus is not initialized for the node")
 	}
@@ -39,7 +39,7 @@ func TestCountNumTransactionsInBlockchain(test *testing.T) {
 	validator := p2p.Peer{Ip: "3", Port: "5"}
 	consensus := consensus.NewConsensus("1", "2", "0", []p2p.Peer{leader, validator}, leader)
 
-	node := New(consensus)
+	node := New(consensus, nil)
 	node.AddTestingAddresses(1000)
 	if node.countNumTransactionsInBlockchain() != 1001 {
 		test.Error("Count of transactions in the blockchain is incorrect")