ak
6 years ago
parent
eb7d076ef5
commit
07acdf9c6c
@ -1,98 +0,0 @@ |
||||
package beaconchain |
||||
|
||||
import ( |
||||
"fmt" |
||||
"net" |
||||
"os" |
||||
"sync" |
||||
|
||||
"github.com/dedis/kyber" |
||||
"github.com/simple-rules/harmony-benchmark/crypto/pki" |
||||
"github.com/simple-rules/harmony-benchmark/log" |
||||
"github.com/simple-rules/harmony-benchmark/node" |
||||
"github.com/simple-rules/harmony-benchmark/p2p" |
||||
proto_identity "github.com/simple-rules/harmony-benchmark/proto/identity" |
||||
) |
||||
|
||||
var mutex sync.Mutex |
||||
var identityPerBlock = 100000 |
||||
|
||||
// BeaconChain (Blockchain) keeps Identities per epoch, currently centralized!
|
||||
type BeaconChain struct { |
||||
//Identities []*IdentityBlock //No need to have the identity block as of now
|
||||
Identities []*node.Node |
||||
log log.Logger |
||||
PeerToShardMap map[*node.Node]int |
||||
ShardLeaderMap map[int]*node.Node |
||||
PubKey kyber.Point |
||||
NumberOfShards int |
||||
NumberOfLeadersAdded int |
||||
} |
||||
|
||||
//Init
|
||||
func Init(filename string) { |
||||
idc := BeaconChain{} |
||||
//idc.NumberOfShards = readConfigFile(filename)
|
||||
idc.NumberOfShards = 2 |
||||
idc.PubKey = generateIDCKeys() |
||||
idc.StartServer() |
||||
} |
||||
|
||||
func readConfigFile(filename string) int { |
||||
return 2 |
||||
} |
||||
|
||||
func generateIDCKeys() kyber.Point { |
||||
priKey := pki.GetPrivateKeyFromInt(10) |
||||
pubkey := pki.GetPublicKeyFromPrivateKey(priKey) |
||||
return pubkey |
||||
} |
||||
|
||||
//AcceptConnections welcomes new connections
|
||||
func (IDC *BeaconChain) AcceptConnections(b []byte) { |
||||
Node := node.DeserializeWaitNode(b) |
||||
IDC.registerNode(Node) //This copies lock value of sync.mutex, we need to have a way around it by creating auxiliary data struct.
|
||||
} |
||||
|
||||
func (IDC *BeaconChain) registerNode(Node *node.Node) { |
||||
IDC.Identities = append(IDC.Identities, Node) |
||||
IDC.CommunicatePublicKeyToNode(Node.Self) |
||||
return |
||||
} |
||||
|
||||
func (IDC *BeaconChain) CommunicatePublicKeyToNode(Peer p2p.Peer) { |
||||
pbkey := pki.GetBytesFromPublicKey(IDC.PubKey) |
||||
msgToSend := proto_identity.ConstructIdentityMessage(proto_identity.Acknowledge, pbkey[:]) |
||||
p2p.SendMessage(Peer, msgToSend) |
||||
} |
||||
|
||||
//StartServer a server and process the request by a handler.
|
||||
func (IDC *BeaconChain) StartServer() { |
||||
fmt.Println("Starting server...") |
||||
fmt.Println(IDC.PubKey) |
||||
IDC.log.Info("Starting IDC server...") //log.Info does nothing for me! (ak)
|
||||
IDC.listenOnPort() |
||||
} |
||||
|
||||
func (IDC *BeaconChain) listenOnPort() { |
||||
addr := net.JoinHostPort("", "8081") |
||||
listen, err := net.Listen("tcp4", addr) |
||||
if err != nil { |
||||
IDC.log.Crit("Socket listen port failed") |
||||
os.Exit(1) |
||||
} else { |
||||
fmt.Println("Starting server...now listening") |
||||
IDC.log.Info("Identity chain is now listening ..") //log.Info does nothing for me! (ak) remove this
|
||||
} |
||||
defer listen.Close() |
||||
for { |
||||
conn, err := listen.Accept() |
||||
if err != nil { |
||||
IDC.log.Crit("Error listening on port. Exiting", "8081") |
||||
continue |
||||
} else { |
||||
fmt.Println("I am accepting connections now") |
||||
} |
||||
go IDC.BeaconChainHandler(conn) |
||||
} |
||||
} |
||||
@ -1,95 +0,0 @@ |
||||
package identitychain |
||||
|
||||
import ( |
||||
"fmt" |
||||
"net" |
||||
"os" |
||||
"sync" |
||||
|
||||
"github.com/dedis/kyber" |
||||
"github.com/simple-rules/harmony-benchmark/crypto/pki" |
||||
"github.com/simple-rules/harmony-benchmark/log" |
||||
"github.com/simple-rules/harmony-benchmark/node" |
||||
"github.com/simple-rules/harmony-benchmark/p2p" |
||||
) |
||||
|
||||
var mutex sync.Mutex |
||||
var identityPerBlock = 100000 |
||||
|
||||
// IdentityChain (Blockchain) keeps Identities per epoch, currently centralized!
|
||||
type IdentityChain struct { |
||||
//Identities []*IdentityBlock //No need to have the identity block as of now
|
||||
Identities []*node.Node |
||||
log log.Logger |
||||
PeerToShardMap map[*node.Node]int |
||||
ShardLeaderMap map[int]*node.Node |
||||
PubKey kyber.Point |
||||
NumberOfShards int |
||||
NumberOfLeadersAdded int |
||||
} |
||||
|
||||
//Init
|
||||
func New(filename string) { |
||||
idc := IdentityChain{} |
||||
idc.NumberOfShards = readConfigFile(filename) |
||||
idc.PubKey = generateIDCKeys() |
||||
idc.StartServer() |
||||
} |
||||
|
||||
func readConfigFile(filename string) int { |
||||
return 2 |
||||
} |
||||
|
||||
func generateIDCKeys() kyber.Point { |
||||
priKey := pki.GetPrivateKeyFromInt(10) |
||||
pubkey := pki.GetPublicKeyFromPrivateKey(priKey) |
||||
return pubkey |
||||
} |
||||
|
||||
//AcceptConnections welcomes new connections
|
||||
func (IDC *IdentityChain) AcceptConnections(b []byte) { |
||||
Node := node.DeserializeWaitNode(b) |
||||
IDC.registerNode(Node) //This copies lock value of sync.mutex, we need to have a way around it by creating auxiliary data struct.
|
||||
} |
||||
|
||||
func (IDC *IdentityChain) registerNode(Node *node.Node) { |
||||
IDC.Identities = append(IDC.Identities, Node) |
||||
IDC.CommunicatePublicKeyToNode(Node.Self) |
||||
return |
||||
} |
||||
|
||||
func (IDC *IdentityChain) CommunicatePublicKeyToNode(Peer p2p.Peer) { |
||||
pbkey := pki.GetBytesFromPublicKey(IDC.PubKey) |
||||
fmt.Print(pbkey) |
||||
//proto_identity.ConstructIdentityMessage(Acknowledge, pbkey)
|
||||
} |
||||
|
||||
//StartServer a server and process the request by a handler.
|
||||
func (IDC *IdentityChain) StartServer() { |
||||
fmt.Println("Starting server...") |
||||
IDC.log.Info("Starting IDC server...") //log.Info does nothing for me! (ak)
|
||||
IDC.listenOnPort() |
||||
} |
||||
|
||||
func (IDC *IdentityChain) listenOnPort() { |
||||
addr := net.JoinHostPort("", "8081") |
||||
listen, err := net.Listen("tcp4", addr) |
||||
if err != nil { |
||||
IDC.log.Crit("Socket listen port failed") |
||||
os.Exit(1) |
||||
} else { |
||||
fmt.Println("Starting server...now listening") |
||||
IDC.log.Info("Identity chain is now listening ..") //log.Info does nothing for me! (ak) remove this
|
||||
} |
||||
defer listen.Close() |
||||
for { |
||||
conn, err := listen.Accept() |
||||
if err != nil { |
||||
IDC.log.Crit("Error listening on port. Exiting", "8081") |
||||
continue |
||||
} else { |
||||
fmt.Println("I am accepting connections now") |
||||
} |
||||
go IDC.IdentityChainHandler(conn) |
||||
} |
||||
} |
||||
@ -1,115 +0,0 @@ |
||||
package identitychain |
||||
|
||||
import ( |
||||
"fmt" |
||||
"net" |
||||
"os" |
||||
|
||||
"github.com/simple-rules/harmony-benchmark/p2p" |
||||
"github.com/simple-rules/harmony-benchmark/proto" |
||||
proto_identity "github.com/simple-rules/harmony-benchmark/proto/identity" |
||||
) |
||||
|
||||
//IdentityChainHandler handles registration of new Identities
|
||||
// This could have been its seperate package like consensus, but am avoiding creating a lot of packages.
|
||||
func (IDC *IdentityChain) IdentityChainHandler(conn net.Conn) { |
||||
content, err := p2p.ReadMessageContent(conn) |
||||
if err != nil { |
||||
IDC.log.Error("Read p2p data failed") |
||||
return |
||||
} |
||||
msgCategory, err := proto.GetMessageCategory(content) |
||||
if err != nil { |
||||
IDC.log.Error("Read message category failed", "err", err) |
||||
return |
||||
} |
||||
if msgCategory != proto.Identity { |
||||
IDC.log.Error("Identity Chain Recieved incorrect protocol message") |
||||
os.Exit(1) |
||||
} else { |
||||
fmt.Println("Message category is correct") |
||||
} |
||||
msgType, err := proto.GetMessageType(content) |
||||
if err != nil { |
||||
IDC.log.Error("Read action type failed") |
||||
return |
||||
} |
||||
msgPayload, err := proto.GetMessagePayload(content) |
||||
if err != nil { |
||||
IDC.log.Error("Read message payload failed") |
||||
return |
||||
} |
||||
switch msgCategory { |
||||
case proto.Identity: |
||||
actionType := proto_identity.IdentityMessageType(msgType) |
||||
switch actionType { |
||||
case proto_identity.Identity: |
||||
idMsgType, err := proto_identity.GetIdentityMessageType(msgPayload) |
||||
if err != nil { |
||||
fmt.Println("Error finding the identity message type") |
||||
} |
||||
switch idMsgType { |
||||
case proto_identity.Register: |
||||
IDC.AcceptConnections(msgPayload) |
||||
case proto_identity.Acknowledge: |
||||
// IDC.acceptNewConnection(msgPayload)
|
||||
} |
||||
|
||||
} |
||||
|
||||
} |
||||
} |
||||
|
||||
// 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) {
|
||||
|
||||
// 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)
|
||||
// }
|
||||
Loading…
Reference in new issue