// Run implements sda.Simulation interface
func (e *Simulation) Run(sdaConf *sda.SimulationConfig) error {
log.Lvl2("Naive Tree Simulation starting with: Rounds=", e.Rounds)
server := NewNtreeServer(e.Blocksize)
for round := 0; round < e.Rounds; round++ {
client := byzcoin.NewClient(server)
err := client.StartClientSimulation(blockchain.GetBlockDir(), e.Blocksize)
if err != nil {
log.Error("ClientSimulation:", err)
}
log.Lvl1("Starting round", round)
// create an empty node
node := sdaConf.Overlay.NewTreeNodeInstanceFromProtoName(sdaConf.Tree, "ByzCoinNtree")
// instantiate a byzcoin protocol
rComplete := monitor.NewTimeMeasure("round")
pi, err := server.Instantiate(node)
if err != nil {
return err
}
sdaConf.Overlay.RegisterProtocolInstance(pi)
nt := pi.(*Ntree)
// Register when the protocol is finished (all the nodes have finished)
done := make(chan bool)
nt.RegisterOnDone(func(sig *NtreeSignature) {
rComplete.Record()
log.Lvl3("Done")
done <- true
})
go func() {
if err := nt.Start(); err != nil {
log.Error("Couldn't start ntree protocol:", err)
}
}()
// wait for the end
<-done
log.Lvl3("Round", round, "finished")
}
return nil
}
// Run implements sda.Simulation interface
func (e *Simulation) Run(sdaConf *sda.SimulationConfig) error {
log.Lvl2("Simulation starting with: Rounds=", e.Rounds)
server := NewByzCoinServer(e.Blocksize, e.TimeoutMs, e.Fail)
pi, err := sdaConf.Overlay.CreateProtocolSDA(sdaConf.Tree, "Broadcast")
if err != nil {
return err
}
proto, _ := pi.(*manage.Broadcast)
// channel to notify we are done
broadDone := make(chan bool)
proto.RegisterOnDone(func() {
broadDone <- true
})
// ignore error on purpose: Broadcast.Start() always returns nil
_ = proto.Start()
// wait
<-broadDone
for round := 0; round < e.Rounds; round++ {
client := NewClient(server)
err := client.StartClientSimulation(blockchain.GetBlockDir(), e.Blocksize)
if err != nil {
log.Error("Error in ClientSimulation:", err)
return err
}
log.Lvl1("Starting round", round)
// create an empty node
tni := sdaConf.Overlay.NewTreeNodeInstanceFromProtoName(sdaConf.Tree, "ByzCoin")
if err != nil {
return err
}
// instantiate a byzcoin protocol
rComplete := monitor.NewTimeMeasure("round")
pi, err := server.Instantiate(tni)
if err != nil {
return err
}
sdaConf.Overlay.RegisterProtocolInstance(pi)
bz := pi.(*ByzCoin)
// Register callback for the generation of the signature !
bz.RegisterOnSignatureDone(func(sig *BlockSignature) {
rComplete.Record()
if err := verifyBlockSignature(tni.Suite(), tni.Roster().Aggregate, sig); err != nil {
log.Error("Round", round, "failed:", err)
} else {
log.Lvl2("Round", round, "success")
}
})
// Register when the protocol is finished (all the nodes have finished)
done := make(chan bool)
bz.RegisterOnDone(func() {
done <- true
})
if e.Fail > 0 {
go func() {
err := bz.startAnnouncementPrepare()
if err != nil {
log.Error("Error while starting "+
"announcment prepare:", err)
}
}()
// do not run bz.startAnnouncementCommit()
} else {
go func() {
if err := bz.Start(); err != nil {
log.Error("Couldn't start protocol",
err)
}
}()
}
// wait for the end
<-done
log.Lvl3("Round", round, "finished")
}
return nil
}
// Run runs the simulation
func (e *Simulation) Run(sdaConf *sda.SimulationConfig) error {
doneChan := make(chan bool)
doneCB := func() {
doneChan <- true
}
// FIXME use client instead
dir := blockchain.GetBlockDir()
parser, err := blockchain.NewParser(dir, magicNum)
if err != nil {
log.Error("Error: Couldn't parse blocks in", dir)
return err
}
transactions, err := parser.Parse(0, e.Blocksize)
if err != nil {
log.Error("Error while parsing transactions", err)
return err
}
// FIXME c&p from byzcoin.go
trlist := blockchain.NewTransactionList(transactions, len(transactions))
header := blockchain.NewHeader(trlist, "", "")
trblock := blockchain.NewTrBlock(trlist, header)
// Here we first setup the N^2 connections with a broadcast protocol
pi, err := sdaConf.Overlay.CreateProtocolSDA(sdaConf.Tree, "Broadcast")
if err != nil {
log.Error(err)
}
proto := pi.(*manage.Broadcast)
// channel to notify we are done
broadDone := make(chan bool)
proto.RegisterOnDone(func() {
broadDone <- true
})
// ignore error on purpose: Start always returns nil
_ = proto.Start()
// wait
<-broadDone
log.Lvl3("Simulation can start!")
for round := 0; round < e.Rounds; round++ {
log.Lvl1("Starting round", round)
p, err := sdaConf.Overlay.CreateProtocolSDA(sdaConf.Tree, "ByzCoinPBFT")
if err != nil {
return err
}
proto := p.(*Protocol)
proto.trBlock = trblock
proto.onDoneCB = doneCB
r := monitor.NewTimeMeasure("round_pbft")
err = proto.Start()
if err != nil {
log.Error("Couldn't start PrePrepare")
return err
}
// wait for finishing pbft:
<-doneChan
r.Record()
log.Lvl2("Finished round", round)
}
return nil
}