// Run starts the simulation on the simulation-side func (e *Simulation) Run(config *onet.SimulationConfig) error { msg := []byte(e.Message) size := config.Tree.Size() log.Lvl2("Size is:", size, "rounds:", e.Rounds) for round := 0; round < e.Rounds; round++ { log.Lvl1("Starting round", round, "with message", string(msg)) round := monitor.NewTimeMeasure("round") p, err := config.Overlay.CreateProtocolOnet("NaiveTree", config.Tree) if err != nil { log.Error("Quitting the simulation....", err) return err } pi := p.(*Protocol) pi.Message = msg pi.verifySignature = e.Checking done := make(chan bool) pi.TreeNodeInstance.OnDoneCallback(func() bool { done <- true return true }) err = pi.Start() if err != nil { log.Error("Quitting the simulation....", err) return err } <-done round.Record() } return nil }
// Run initiates a RandHound simulation func (rhs *RHSimulation) Run(config *onet.SimulationConfig) error { randM := monitor.NewTimeMeasure("tgen-randhound") bandW := monitor.NewCounterIOMeasure("bw-randhound", config.Conode) client, err := config.Overlay.CreateProtocolOnet("RandHound", config.Tree) if err != nil { return err } rh, _ := client.(*RandHound) err = rh.Setup(rhs.Hosts, rhs.Faulty, rhs.Groups, rhs.Purpose) if err != nil { return err } if err := rh.StartProtocol(); err != nil { log.Error("Error while starting protcol:", err) } select { case <-rh.Done: log.Lvlf1("RandHound - done") random, transcript, err := rh.Random() if err != nil { return err } randM.Record() bandW.Record() log.Lvlf1("RandHound - collective randomness: ok") verifyM := monitor.NewTimeMeasure("tver-randhound") err = rh.Verify(rh.Suite(), random, transcript) if err != nil { return err } verifyM.Record() log.Lvlf1("RandHound - verification: ok") //case <-time.After(time.Second * time.Duration(rhs.Hosts) * 5): //log.Print("RandHound - time out") } return nil }
// sendAndMeasureViewChange is a method that creates the viewchange request, // broadcast it and measures the time it takes to accept it. func (bz *ByzCoin) sendAndMeasureViewchange() { log.Lvl3(bz.Name(), "Created viewchange measure") bz.vcMeasure = monitor.NewTimeMeasure("viewchange") vc := newViewChange() var err error for _, n := range bz.Tree().List() { // don't send to ourself if n.ID.Equal(bz.TreeNode().ID) { continue } err = bz.SendTo(n, vc) if err != nil { log.Error(bz.Name(), "Error sending view change", err) } } }
// Run implements onet.Simulation interface func (e *Simulation) Run(onetConf *onet.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 := onetConf.Overlay.NewTreeNodeInstanceFromProtoName(onetConf.Tree, "ByzCoinNtree") // instantiate a byzcoin protocol rComplete := monitor.NewTimeMeasure("round") pi, err := server.Instantiate(node) if err != nil { return err } onetConf.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 is used on the destination machines and runs a number of // rounds func (e *simulation) Run(config *onet.SimulationConfig) error { size := config.Tree.Size() log.Lvl2("Size is:", size, "rounds:", e.Rounds) for round := 0; round < e.Rounds; round++ { log.Lvl1("Starting round", round) round := monitor.NewTimeMeasure("round") p, err := config.Overlay.CreateProtocolOnet("Count", config.Tree) if err != nil { return err } go p.Start() children := <-p.(*ProtocolCount).Count round.Record() if children != size { return errors.New("Didn't get " + strconv.Itoa(size) + " children") } } return nil }
// Run initiates a JVSS simulation func (jvs *Simulation) Run(config *onet.SimulationConfig) error { size := config.Tree.Size() msg := []byte("Test message for JVSS simulation") log.Lvl1("Size:", size, "rounds:", jvs.Rounds) p, err := config.Overlay.CreateProtocolOnet("JVSS", config.Tree) if err != nil { return err } proto := p.(*JVSS) log.Lvl1("Starting setup") proto.Start() log.Lvl1("Setup done") for round := 0; round < jvs.Rounds; round++ { log.Lvl1("Starting signing round", round) r := monitor.NewTimeMeasure("round") log.Lvl2("Requesting signature") sig, err := proto.Sign(msg) if err != nil { log.Error("Could not create signature") return err } if jvs.Verify { log.Lvl2("Signature received") if err := proto.Verify(msg, sig); err != nil { log.Error("Signature invalid") return err } log.Lvl2("Signature valid") } r.Record() } return nil }
// Run implements onet.Simulation. func (cs *Simulation) Run(config *onet.SimulationConfig) error { size := len(config.Roster.List) msg := []byte("Hello World Cosi Simulation") log.Lvl2("Simulation starting with: Size=", size, ", Rounds=", cs.Rounds) for round := 0; round < cs.Rounds; round++ { log.Lvl1("Starting round", round) roundM := monitor.NewTimeMeasure("round") // create the node with the protocol, but do NOT start it yet. node, err := config.Overlay.CreateProtocolOnet(Name, config.Tree) if err != nil { return err } // the protocol itself proto := node.(*CoSimul) // give the message to sign proto.SigningMessage(msg) // tell us when it is done done := make(chan bool) fn := func(sig []byte) { roundM.Record() publics := proto.Publics() if err := cosi.VerifySignature(network.Suite, publics, msg, sig); err != nil { log.Lvl1("Round", round, " => fail verification") } else { log.Lvl2("Round", round, " => success") } done <- true } proto.RegisterSignatureHook(fn) if err := proto.Start(); err != nil { log.Error("Couldn't start protocol in round", round) } <-done } log.Lvl1("Simulation finished") return nil }
// Run runs the simulation func (e *Simulation) Run(onetConf *onet.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 := onetConf.Overlay.CreateProtocolOnet("Broadcast", onetConf.Tree) 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 := onetConf.Overlay.CreateProtocolOnet("ByzCoinPBFT", onetConf.Tree) 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 }
// Run implements onet.Simulation interface func (e *Simulation) Run(onetConf *onet.SimulationConfig) error { log.Lvl2("Simulation starting with: Rounds=", e.Rounds) server := NewByzCoinServer(e.Blocksize, e.TimeoutMs, e.Fail) pi, err := onetConf.Overlay.CreateProtocolOnet("Broadcast", onetConf.Tree) 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 := onetConf.Overlay.NewTreeNodeInstanceFromProtoName(onetConf.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 } onetConf.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 }
func (m *monitorMut) NewMeasure(id string) { m.Lock() defer m.Unlock() m.TimeMeasure = monitor.NewTimeMeasure(id) }