func init() { sda.ProtocolRegisterName("ProtocolHandlers", NewProtocolHandlers) sda.ProtocolRegisterName("ProtocolBlocking", NewProtocolBlocking) sda.ProtocolRegisterName("ProtocolChannels", NewProtocolChannels) sda.ProtocolRegisterName(testProto, NewProtocolTest) Incoming = make(chan struct { *sda.TreeNode NodeTestMsg }) }
func TestBftCoSi(t *testing.T) { defer log.AfterTest(t) log.TestOutput(testing.Verbose(), 4) // Register test protocol using BFTCoSi sda.ProtocolRegisterName(TestProtocolName, func(n *sda.TreeNodeInstance) (sda.ProtocolInstance, error) { return NewBFTCoSiProtocol(n, verify) }) for _, nbrHosts := range []int{3, 13} { countMut.Lock() veriCount = 0 countMut.Unlock() log.Lvl2("Running BFTCoSi with", nbrHosts, "hosts") local := sda.NewLocalTest() _, _, tree := local.GenBigTree(nbrHosts, nbrHosts, 3, true, true) done := make(chan bool) // create the message we want to sign for this round msg := []byte("Hello BFTCoSi") // Start the protocol node, err := local.CreateProtocol(tree, TestProtocolName) if err != nil { t.Fatal("Couldn't create new node:", err) } // Register the function generating the protocol instance var root *ProtocolBFTCoSi root = node.(*ProtocolBFTCoSi) root.Msg = msg // function that will be called when protocol is finished by the root root.RegisterOnDone(func() { done <- true }) go node.Start() // are we done yet? wait := time.Second * 3 select { case <-done: countMut.Lock() assert.Equal(t, veriCount, nbrHosts, "Each host should have called verification.") // if assert fails we don't care for unlocking (t.Fail) countMut.Unlock() sig := root.Signature() if err := cosi.VerifyCosiSignatureWithException(root.Suite(), root.AggregatedPublic, msg, sig.Sig, sig.Exceptions); err != nil { t.Fatal(fmt.Sprintf("%s Verification of the signature failed: %s", root.Name(), err.Error())) } case <-time.After(wait): t.Fatal("Waited", wait, "sec for BFTCoSi to finish ...") } local.CloseAll() } }
// This makes h2 the leader, so it creates a tree and entity list // and start a protocol. H1 should receive that message and request the entitity // list and the treelist and then instantiate the protocol. func TestProtocolAutomaticInstantiation(t *testing.T) { defer log.AfterTest(t) log.TestOutput(testing.Verbose(), 4) // setup chanH1 := make(chan bool) chanH2 := make(chan bool) chans := []chan bool{chanH1, chanH2} id := 0 // custom creation function so we know the step due to the channels fn := func(n *sda.TreeNodeInstance) (sda.ProtocolInstance, error) { ps := SimpleProtocol{ TreeNodeInstance: n, Chan: chans[id], } ps.RegisterHandler(ps.ReceiveMessage) id++ return &ps, nil } network.RegisterMessageType(SimpleMessage{}) sda.ProtocolRegisterName(simpleProto, fn) h1, h2 := SetupTwoHosts(t, true) defer h1.Close() defer h2.Close() h1.StartProcessMessages() // create small Tree el := sda.NewRoster([]*network.ServerIdentity{h1.ServerIdentity, h2.ServerIdentity}) h1.AddRoster(el) tree := el.GenerateBinaryTree() h1.AddTree(tree) // start the protocol go func() { _, err := h1.StartProtocol(simpleProto, tree) if err != nil { t.Fatal(fmt.Sprintf("Could not start protocol %v", err)) } }() // we are supposed to receive something from host1 from Start() select { case _ = <-chanH1: break case <-time.After(200 * time.Millisecond): t.Fatal("Could not receive from channel of host 1") } // Then we are supposed to receive from h2 after he got the tree and the // entity list from h1 select { case _ = <-chanH2: break case <-time.After(2 * time.Second): t.Fatal("Could not receive from channel of host 1") } }
// Test simple protocol-implementation // - registration func TestProtocolRegistration(t *testing.T) { testProtoID := sda.ProtocolRegisterName(testProto, NewProtocolTest) if !sda.ProtocolExists(testProtoID) { t.Fatal("Test should exist now") } if sda.ProtocolNameToID(testProto) != testProtoID { t.Fatal("Not correct translation from string to ID") } if sda.ProtocolIDToName(testProtoID) != testProto { t.Fatal("Not correct translation from ID to String") } }
func TestOverlayDone(t *testing.T) { defer log.AfterTest(t) log.TestOutput(testing.Verbose(), 4) // setup h1 := sda.NewLocalHost(2000) defer h1.Close() fn := func(n *sda.TreeNodeInstance) (sda.ProtocolInstance, error) { ps := ProtocolOverlay{ TreeNodeInstance: n, } return &ps, nil } el := sda.NewRoster([]*network.ServerIdentity{h1.ServerIdentity}) h1.AddRoster(el) tree := el.GenerateBinaryTree() h1.AddTree(tree) sda.ProtocolRegisterName("ProtocolOverlay", fn) p, err := h1.CreateProtocol("ProtocolOverlay", tree) if err != nil { t.Fatal("error starting new node", err) } po := p.(*ProtocolOverlay) // release the resources var count int po.OnDoneCallback(func() bool { count++ if count >= 2 { return true } return false }) po.Release() overlay := h1.Overlay() if _, ok := overlay.TokenToNode(po.Token()); !ok { t.Fatal("Node should exists after first call Done()") } po.Release() if _, ok := overlay.TokenToNode(po.Token()); ok { t.Fatal("Node should NOT exists after call Done()") } }
func init() { network.RegisterMessageType(Announce{}) network.RegisterMessageType(Reply{}) sda.ProtocolRegisterName("ExampleChannels", NewExampleChannels) }
func init() { sda.SimulationRegister("ByzCoin", NewSimulation) sda.ProtocolRegisterName("ByzCoin", func(n *sda.TreeNodeInstance) (sda.ProtocolInstance, error) { return NewByzCoinProtocol(n) }) }
func init() { network.RegisterMessageType(PrepareClose{}) network.RegisterMessageType(Close{}) sda.ProtocolRegisterName("CloseAll", NewCloseAll) }
func init() { // register network messages and protocol network.RegisterMessageType(Message{}) network.RegisterMessageType(SignatureReply{}) sda.ProtocolRegisterName("NaiveTree", NewProtocol) }
func init() { sda.ProtocolRegisterName("Propagate", NewPropagateProtocol) }
func init() { sda.ProtocolRegisterName("Broadcast", NewBroadcastProtocol) }
func init() { sda.ProtocolRegisterName("RandHound", NewRandHound) }
func init() { sda.ProtocolRegisterName("JVSS", NewJVSS) }