PoS_EVM
/
woop
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

uncomment some code to get it built. alok will work on this later

Browse Source
pull/76/head
Minh Doan 6 years ago
parent 3009e5a332
commit de33e8a1a1
4 changed files with 84 additions and 89 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 23
      identitychain/identitychain.go
  2. 111
      identitychain/identitychain_handler.go
  3. 36
      node/node.go
  4. 3
      node/node_handler.go

23
identitychain/identitychain.go
Unescape View File

@ -2,7 +2,6 @@ package identitychain
import (
"fmt"
"math"
"math/rand"
"net"
"os"
@ -72,9 +71,9 @@ func (IDC *IdentityChain) BroadCastNewConfiguration() {
}
//BroadCast Peer Infor to Node
func (IDC *IdentityChain) SendPeerInfo(Node node) {
return
}
// func (IDC *IdentityChain) SendPeerInfo(Node node) {
// return
// }
//CreateShardAssignment
func (IDC *IdentityChain) CreateShardAssignment() {
@ -102,15 +101,15 @@ func (IDC *IdentityChain) generateRandomPermutations(num int) {
// SelectIds as
func (IDC *IdentityChain) SelectIds() {
selectNumber := IDC.NumberOfNodesInShard - len(IDC.Identities)
// selectNumber := IDC.NumberOfNodesInShard - len(IDC.Identities)
// Insert the lines below once you have a identity block
// IB := IDC.GetLatestBlock()
// currentIDS := IB.GetIdentities()
currentIDS := IDC.Identities
selectNumber = int(math.Min(float64(len(IDC.PendingIdentities)), float64(selectNumber)))
pending := IDC.PendingIdentities[:selectNumber]
IDC.SelectedIdentitites = append(currentIDS, pending...)
IDC.PendingIdentities = []*node.Node{}
// currentIDS := IDC.Identities
// selectNumber = int(math.Min(float64(len(IDC.PendingIdentities)), float64(selectNumber)))
// pending := IDC.PendingIdentities[:selectNumber]
// IDC.SelectedIdentitites = append(currentIDS, pending...)
// IDC.PendingIdentities = []*node.Node{}
}
@ -157,9 +156,9 @@ func New(Peer p2p.Peer) *IdentityChain {
IDC.NumberOfShards = 1 //to be filled via global config
IDC.NumberOfNodesInShard = 500 //to be filled via global config
IDC.Identities = make([]*node.Node, 0)
IDC.PendingIdentities = make([]*node.Node, 0)
// IDC.PendingIdentities = make([]*node.Node, 0)
IDC.SelectedIdentitites = make([]*node.Node, 0)
IDC.PowMap = make(map[p2p.Peer]string)
// IDC.PowMap = make(map[p2p.Peer]string)
return &IDC
}

111
identitychain/identitychain_handler.go
Unescape View File

@ -1,17 +1,11 @@
package identitychain
import (
"bytes"
"fmt"
"math/rand"
"net"
"os"
"strconv"
"time"
"github.com/simple-rules/harmony-benchmark/node"
"github.com/simple-rules/harmony-benchmark/p2p"
"github.com/simple-rules/harmony-benchmark/pow"
"github.com/simple-rules/harmony-benchmark/proto"
proto_identity "github.com/simple-rules/harmony-benchmark/proto/identity"
)
@ -56,9 +50,9 @@ func (IDC *IdentityChain) IdentityChainHandler(conn net.Conn) {
}
switch idMsgType {
case proto_identity.Register:
IDC.registerIdentity(msgPayload)
// IDC.registerIdentity(msgPayload)
case proto_identity.Announce:
IDC.acceptNewConnection(msgPayload)
// IDC.acceptNewConnection(msgPayload)
}
}
@ -66,55 +60,56 @@ func (IDC *IdentityChain) IdentityChainHandler(conn net.Conn) {
}
}
func (IDC *IdentityChain) registerIdentity(msgPayload []byte) {
payload, err := proto_identity.GetIdentityMessagePayload(msgPayload)
if err != nil {
IDC.log.Error("identity payload not read")
} else {
fmt.Println("identity payload read")
}
fmt.Println("we are now registering identities")
offset := 0
proof := payload[offset : offset+32]
offset = offset + 32
Node := node.DeserializeWaitNode(payload[offset:])
req := IDC.PowMap[Node.Self]
ok, err := pow.Check(req, string(proof), []byte(""))
fmt.Println(err)
if ok {
fmt.Println("Proof of work accepted")
IDC.PendingIdentities = append(IDC.PendingIdentities, Node)
fmt.Println(len(IDC.PendingIdentities)) //Fix why IDC does not have log working.
} else {
fmt.Println("identity proof of work not accepted")
}
}
// TODO(alok): You removed pow package.
// func (IDC *IdentityChain) registerIdentity(msgPayload []byte) {
// payload, err := proto_identity.GetIdentityMessagePayload(msgPayload)
// if err != nil {
// IDC.log.Error("identity payload not read")
// } else {
// fmt.Println("identity payload read")
// }
// fmt.Println("we are now registering identities")
// offset := 0
// proof := payload[offset : offset+32]
// offset = offset + 32
// Node := node.DeserializeWaitNode(payload[offset:])
// req := IDC.PowMap[Node.Self]
// ok, err := pow.Check(req, string(proof), []byte(""))
// fmt.Println(err)
// if ok {
// fmt.Println("Proof of work accepted")
// IDC.PendingIdentities = append(IDC.PendingIdentities, Node)
// fmt.Println(len(IDC.PendingIdentities)) //Fix why IDC does not have log working.
// } else {
// fmt.Println("identity proof of work not accepted")
// }
// }
func (IDC *IdentityChain) acceptNewConnection(msgPayload []byte) {
// func (IDC *IdentityChain) acceptNewConnection(msgPayload []byte) {
identityPayload, err := proto_identity.GetIdentityMessagePayload(msgPayload)
if err != nil {
fmt.Println("There was a error in reading the identity payload")
} else {
fmt.Println("accepted new connection")
}
fmt.Println("Sleeping for 2 secs ...")
time.Sleep(2 * time.Second)
Node := node.DeserializeWaitNode(identityPayload)
buffer := bytes.NewBuffer([]byte{})
src := rand.NewSource(time.Now().UnixNano())
rnd := rand.New(src)
challengeNonce := int((rnd.Int31()))
req := pow.NewRequest(5, []byte(strconv.Itoa(challengeNonce)))
IDC.PowMap[Node.Self] = req
buffer.Write([]byte(req))
// 32 byte block hash
// buffer.Write(prevBlockHash)
// The message is missing previous BlockHash, this is because we don't actively maintain a identitychain
// This canbe included in the fulfill request.
// Message should be encrypted and then signed to follow PKE.
//IDC should accept node publickey, encrypt the nonce and blockhash
// Then sign the message by own private key and send the message back.
msgToSend := proto_identity.ConstructIdentityMessage(proto_identity.Register, buffer.Bytes())
p2p.SendMessage(Node.Self, msgToSend)
}
// identityPayload, err := proto_identity.GetIdentityMessagePayload(msgPayload)
// if err != nil {
// fmt.Println("There was a error in reading the identity payload")
// } else {
// fmt.Println("accepted new connection")
// }
// fmt.Println("Sleeping for 2 secs ...")
// time.Sleep(2 * time.Second)
// Node := node.DeserializeWaitNode(identityPayload)
// buffer := bytes.NewBuffer([]byte{})
// src := rand.NewSource(time.Now().UnixNano())
// rnd := rand.New(src)
// challengeNonce := int((rnd.Int31()))
// req := pow.NewRequest(5, []byte(strconv.Itoa(challengeNonce)))
// IDC.PowMap[Node.Self] = req
// buffer.Write([]byte(req))
// // 32 byte block hash
// // buffer.Write(prevBlockHash)
// // The message is missing previous BlockHash, this is because we don't actively maintain a identitychain
// // This canbe included in the fulfill request.
// // Message should be encrypted and then signed to follow PKE.
// //IDC should accept node publickey, encrypt the nonce and blockhash
// // Then sign the message by own private key and send the message back.
// msgToSend := proto_identity.ConstructIdentityMessage(proto_identity.Register, buffer.Bytes())
// p2p.SendMessage(Node.Self, msgToSend)
// }

36
node/node.go
Unescape View File

@ -15,7 +15,6 @@ import (
"github.com/simple-rules/harmony-benchmark/db"
"github.com/simple-rules/harmony-benchmark/log"
"github.com/simple-rules/harmony-benchmark/p2p"
"github.com/simple-rules/harmony-benchmark/pow"
"github.com/simple-rules/harmony-benchmark/proto/identity"
"github.com/simple-rules/harmony-benchmark/syncing"
)
@ -168,23 +167,24 @@ func NewNodefromIDC(node *Node, consensus *consensus.Consensus, db *db.LDBDataba
return node
}
func (node *Node) processPOWMessage(message []byte) {
payload, err := identity.GetIdentityMessagePayload(message)
if err != nil {
fmt.Println("Could not read payload")
}
IDCPeer := node.IDCPeer
// 4 byte challengeNonce id
req := string(payload)
proof, _ := pow.Fulfil(req, []byte("")) //"This could be blockhasdata"
buffer := bytes.NewBuffer([]byte{})
proofBytes := make([]byte, 32) //proof seems to be 32 byte here
copy(proofBytes[:], proof)
buffer.Write(proofBytes)
buffer.Write(node.SerializeWaitNode())
msgPayload := buffer.Bytes()
p2p.SendMessage(IDCPeer, identity.ConstructIdentityMessage(identity.Register, msgPayload))
}
// TODO(alok): Fix it or revert the cl on 11/8.
// func (node *Node) processPOWMessage(message []byte) {
// payload, err := identity.GetIdentityMessagePayload(message)
// if err != nil {
// fmt.Println("Could not read payload")
// }
// IDCPeer := node.IDCPeer
// // 4 byte challengeNonce id
// req := string(payload)
// proof, _ := pow.Fulfil(req, []byte("")) //"This could be blockhasdata"
// buffer := bytes.NewBuffer([]byte{})
// proofBytes := make([]byte, 32) //proof seems to be 32 byte here
// copy(proofBytes[:], proof)
// buffer.Write(proofBytes)
// buffer.Write(node.SerializeWaitNode())
// msgPayload := buffer.Bytes()
// p2p.SendMessage(IDCPeer, identity.ConstructIdentityMessage(identity.Register, msgPayload))
// }
// SerializeWaitNode serializes the node
// https://stackoverflow.com/questions/12854125/how-do-i-dump-the-struct-into-the-byte-array-without-reflection/12854659#12854659

3
node/node_handler.go
Unescape View File

@ -77,7 +77,8 @@ func (node *Node) NodeHandler(conn net.Conn) {
switch messageType {
case proto_identity.Register:
fmt.Println("received a identity message")
node.processPOWMessage(msgPayload)
// TODO(ak): fix it.
// node.processPOWMessage(msgPayload)
case proto_identity.Announce:
node.log.Error("Announce message should be sent to IdentityChain")
}

Write Preview
Loading…
Cancel
Save