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