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

remove delted files

Browse Source
pull/76/head
ak 6 years ago
parent eb7d076ef5
commit 07acdf9c6c
3 changed files with 0 additions and 308 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. 98
      beaconchain/identitychain.go
  2. 95
      identitychain/identitychain.go
  3. 115
      identitychain/identitychain_handler.go

98
beaconchain/identitychain.go
Unescape View File

@ -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)
}
}

95
identitychain/identitychain.go
Unescape View File

@ -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)
}
}

115
identitychain/identitychain_handler.go
Unescape View File

@ -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)
// }
Write Preview
Loading…
Cancel
Save