fmt and lint issues; init tests/

Author: arcolife

docs/DEV.md

@@ -140,8 +140,8 @@ Type `next` or `n`:
 Warning: debugging optimized function
     52:		//broadcast the request
     53:		for i := 0; i < cl.Cfg.N; i++ {
-    54:			//req := Request{RequestInner{cl.Cfg.N,0, 0, TYPE_REQU, MsgType(msg), timeStamp, nil}, "", msgSignature{nil, nil}}  // the N-th party is the client
-    55:			req := Request{RequestInner{cl.Cfg.N, 0, 0, TYPE_REQU, MsgType(msg), timeStamp}, "", MsgSignature{nil, nil}} // the N-th party is the client
+    54:			//req := Request{RequestInner{cl.Cfg.N,0, 0, typeRequest, MsgType(msg), timeStamp, nil}, "", msgSignature{nil, nil}}  // the N-th party is the client
+    55:			req := Request{RequestInner{cl.Cfg.N, 0, 0, typeRequest, MsgType(msg), timeStamp}, "", MsgSignature{nil, nil}} // the N-th party is the client
     56:			//req.inner.outer = &req
 =>  57:			req.addSig(&cl.privKey)
     58:			arg := ProxyNewClientRequestArg{req, cl.Me}
@@ -182,7 +182,7 @@ hmmm, what's cl anyway?
 			"127.0.0.1",
 		],
 		Ports: []int len: 4, cap: 4, [40540,40541,40542,40543],
-		HOSTS_FILE: "/home/username/hosts",},
+		HostsFile: "/home/username/hosts",},
 	privKey: crypto/ecdsa.PrivateKey {
 		PublicKey: (*crypto/ecdsa.PublicKey)(0xc4201fa030),
 		D: *math/big.Int nil,},

docs/TODO.md

@@ -31,7 +31,7 @@ pbft-core/node.go:653:43: cannot use nil as type Request in field value
 - [ ] Add checkpoint support
 - [ ] add counter whenever we found a PREP
 - [ ] nd.broadcast(viewChange) // TODO  broadcast view change RPC path.
-- [ ] func (nd *Node) NewClientRequest(req Request, clientId int) {  // TODO  change to single arg and single reply
+- [ ] func (nd *Node) NewClientRequest(req Request, clientID int) {  // TODO  change to single arg and single reply
 - [ ] nd.broadcast(m)  // TODO  broadcast pre-prepare RPC path.
 - [ ] initialize ECDSA keys and hello signature
 - [ ] if ok && val.dig == dig {   // TODO  check the diff!

engine.go

@@ -17,30 +17,24 @@ limitations under the License.
 package main
 
 import (
-	//"fmt"
+	"./pbft-core"
+	"fmt"
 	"os"
 	"path"
-	//"log"
-	"fmt"
 	"strconv"
-
-	"./pbft-core"
 	"time"
 )
 
-// NumQuest is the number of requests sent from client
-const NumQuest = 100
-
 func main() {
 
 	cfg := pbft.Config{}
-	cfg.HOSTS_FILE = path.Join(os.Getenv("HOME"), "hosts")
-	cfg.IPList, cfg.Ports = pbft.GetIPConfigs(cfg.HOSTS_FILE)
+	cfg.HostsFile = path.Join(os.Getenv("HOME"), "hosts")
+	cfg.IPList, cfg.Ports = pbft.GetIPConfigs(cfg.HostsFile)
 	fmt.Printf("Get IPList %v, Ports %v\n", cfg.IPList, cfg.Ports)
-	cfg.N = len(cfg.IPList) - 1 // we assume the number of client is 1
-	// cfg.GenerateKeys()
-	cfg.GenerateKeysToFile()
-	/////////////////
+	cfg.NumKeys = len(cfg.IPList)
+	cfg.N = cfg.NumKeys - 1 // we assume client count to be 1
+	cfg.NumQuest = 100
+	cfg.GenerateKeysToFile(cfg.NumKeys)
 
 	svList := make([]*pbft.Server, cfg.N)
 	for i := 0; i < cfg.N; i++ {
@@ -56,10 +50,10 @@ func main() {
 	}
 	fmt.Println("[!!!] Please allow the program to accept incoming connections if you are using Mac OS.")
 	time.Sleep(1 * time.Second) // wait for the servers to accept incoming connections
-	/////////////////
+
 	cl := pbft.BuildClient(cfg, cfg.IPList[cfg.N], cfg.Ports[cfg.N], 0)
 	start := time.Now()
-	for k := 0; k < NumQuest; k++ {
+	for k := 0; k < cfg.NumQuest; k++ {
 		cl.NewRequest("Request "+strconv.Itoa(k), int64(k))
 	}
 	fmt.Println("Finish sending the requests.")
@@ -68,7 +62,7 @@ func main() {
 		go func(ind int) {
 			for {
 				c := <-svList[ind].Out
-				if c.Index == NumQuest {
+				if c.Index == cfg.NumQuest {
 					finish <- true
 				}
 			}

pbft-core/client.go

@@ -17,22 +17,13 @@ limitations under the License.
 package pbft
 
 import (
-	"net/rpc"
-	//"path"
-	//"os"
-	"strconv"
-	//"fmt"
-	//"bytes"
 	"crypto/ecdsa"
-	//"encoding/gob"
 	"fmt"
-	//"io/ioutil"
+	"net/rpc"
 	"path"
+	"strconv"
 )
 
-// import "fmt"
-// import "net"
-
 type Client struct {
 	IP      string
 	Port    int
@@ -51,8 +42,8 @@ func (cl *Client) Start() {
 func (cl *Client) NewRequest(msg string, timeStamp int64) {
 	//broadcast the request
 	for i := 0; i < cl.Cfg.N; i++ {
-		//req := Request{RequestInner{cl.Cfg.N,0, 0, TYPE_REQU, MsgType(msg), timeStamp, nil}, "", msgSignature{nil, nil}}  // the N-th party is the client
-		req := Request{RequestInner{cl.Cfg.N, 0, 0, TYPE_REQU, MsgType(msg), timeStamp}, "", MsgSignature{nil, nil}} // the N-th party is the client
+		//req := Request{RequestInner{cl.Cfg.N,0, 0, typeRequest, MsgType(msg), timeStamp, nil}, "", msgSignature{nil, nil}}  // the N-th party is the client
+		req := Request{RequestInner{cl.Cfg.N, 0, 0, typeRequest, MsgType(msg), timeStamp}, "", MsgSignature{nil, nil}} // the N-th party is the client
 		//req.inner.outer = &req
 		req.addSig(cl.privKey)
 		arg := ProxyNewClientRequestArg{req, cl.Me}
@@ -78,7 +69,6 @@ func BuildClient(cfg Config, IP string, Port int, me int) *Client {
 	cl.peers = peers
 	pemkeyFile := fmt.Sprintf("sign%v.pem", cfg.N)
 	sk := FetchPrivateKey(path.Join(cfg.KD, pemkeyFile))
-	// sk := cfg.Keys[cfg.N]
 	fmt.Println("just fetched private key for Client")
 	fmt.Println(sk)
 	cl.privKey = sk

pbft-core/config.go

@@ -17,54 +17,32 @@ limitations under the License.
 package pbft
 
 import (
-	// "fmt"
-	// "log"
-	// "os"
-	"crypto/ecdsa"
-	"crypto/elliptic"
 	"path"
-	//"fmt"
-	//"bytes"
-	//"encoding/gob"
-	//"io/ioutil"
-	//"log"
-	"crypto/rand"
 )
 
-// const PORT_NUMBER = 40623
-// const MAX_FAIL = 1
-const OUTPUT_THRESHOLD = 0
-const BASE_PORT = 40540
+// MaxFail defines the number of faults to be tolerated
+const MaxFail = 1
+const OutputThreshold = 0
 
-const NUM_KEYS = 10
+// BasePort is used as base value of ports defined for initializng PBFT servers
+const BasePort = 40540
 
 type Config struct {
-	N          int
-	KD         string
-	LD         string
-	IPList     []string
-	Ports      []int
-	HOSTS_FILE string
-	Keys       []*ecdsa.PrivateKey
+	N         int      // number of nodes to be launchedt
+	KD        string   // key directory where pub/priva ECDSA keys are stored
+	LD        string   // log directory
+	IPList    []string // stores list of IP addresses belonging to BFT nodes
+	Ports     []int    // stores list of Ports belonging to BFT nodes
+	HostsFile string   // network config file, to read IP addresses from
+	NumQuest  int      // NumQuest is the number of requests sent from client
+	NumKeys   int      // NumKeys is the count of IP addresses (BFT nodes) participating
 }
 
-// type DecodeParams struct {
-//   pemEncoded, pemEncodedPub []byte
-// 	ktype string // ktype is whether public/private/both(nil)
-// }
-
-func (cfg *Config) GenerateKeys() {
-	cfg.Keys = make([]*ecdsa.PrivateKey, NUM_KEYS)
-	for k := 0; k < NUM_KEYS; k++ {
-		sk, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-		cfg.Keys[k] = sk
-	}
-}
-
-func (cfg *Config) GenerateKeysToFile() {
-	IdCount := 1000
+// GenerateKeysToFile generates ECDSA public-private keypairs to a folder
+func (cfg *Config) GenerateKeysToFile(numKeys int) {
+	// IdCount := 1000
 	cfg.KD = path.Join(GetCWD(), "keys/")
 	MakeDirIfNot(cfg.KD)
-	WriteNewKeys(IdCount, cfg.KD)
-	MyPrint(1, "Generated %d keys in %s folder..\n", IdCount, cfg.KD)
+	WriteNewKeys(numKeys, cfg.KD)
+	MyPrint(1, "Generated %d keypairs in %s folder..\n", numKeys, cfg.KD)
 }