func TestNodeChannel(t *testing.T) { defer log.AfterTest(t) local := sda.NewLocalTest() _, _, tree := local.GenTree(2, false, true, true) defer local.CloseAll() p, err := local.CreateProtocol(tree, "ProtocolChannels") if err != nil { t.Fatal("Couldn't create new node:", err) } c := make(chan struct { *sda.TreeNode NodeTestMsg }, 1) tni := p.(*ProtocolChannels).TreeNodeInstance err = tni.RegisterChannel(c) if err != nil { t.Fatal("Couldn't register channel:", err) } err = tni.DispatchChannel([]*sda.ProtocolMsg{&sda.ProtocolMsg{ Msg: NodeTestMsg{3}, MsgType: network.RegisterMessageType(NodeTestMsg{}), From: &sda.Token{ TreeID: tree.ID, TreeNodeID: tree.Root.ID, }}, }) if err != nil { t.Fatal("Couldn't dispatch to channel:", err) } msg := <-c if msg.I != 3 { t.Fatal("Message should contain '3'") } }
// 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") } }
// Save takes everything in the SimulationConfig structure and saves it to // dir + SimulationFileName func (sc *SimulationConfig) Save(dir string) error { network.RegisterMessageType(&SimulationConfigFile{}) scf := &SimulationConfigFile{ TreeMarshal: sc.Tree.MakeTreeMarshal(), Roster: sc.Roster, PrivateKeys: sc.PrivateKeys, Config: sc.Config, } buf, err := network.MarshalRegisteredType(scf) if err != nil { log.Fatal(err) } err = ioutil.WriteFile(dir+"/"+SimulationFileName, buf, 0660) if err != nil { log.Fatal(err) } return nil }
func init() { network.RegisterMessageType(Tree{}) network.RegisterMessageType(tbmStruct{}) }
// All children from this tree. The top-node only has one child, which is // the root Children []*TreeMarshal } func (tm *TreeMarshal) String() string { s := fmt.Sprintf("%v", tm.ServerIdentityID) s += "\n" for i := range tm.Children { s += tm.Children[i].String() } return s } // TreeMarshalTypeID of TreeMarshal message as registered in network var TreeMarshalTypeID = network.RegisterMessageType(TreeMarshal{}) // TreeMarshalCopyTree takes a TreeNode and returns a corresponding // TreeMarshal func TreeMarshalCopyTree(tr *TreeNode) *TreeMarshal { tm := &TreeMarshal{ TreeNodeID: tr.ID, ServerIdentityID: tr.ServerIdentity.ID, } for i := range tr.Children { tm.Children = append(tm.Children, TreeMarshalCopyTree(tr.Children[i])) } return tm }
func init() { network.RegisterMessageType(Announce{}) network.RegisterMessageType(Reply{}) sda.ProtocolRegisterName("ExampleChannels", NewExampleChannels) }
func init() { dummyMsgType = network.RegisterMessageType(DummyMsg{}) }
}(i) } wg.Wait() } // BackForthProtocolForth & Back are messages that go down and up the tree. // => BackForthProtocol protocol / message type SimpleMessageForth struct { Val int } type SimpleMessageBack struct { Val int } var simpleMessageForthType = network.RegisterMessageType(SimpleMessageForth{}) var simpleMessageBackType = network.RegisterMessageType(SimpleMessageBack{}) type BackForthProtocol struct { *sda.TreeNodeInstance Val int counter int forthChan chan struct { *sda.TreeNode SimpleMessageForth } backChan chan struct { *sda.TreeNode SimpleMessageBack } handler func(val int)
func init() { network.RegisterMessageType(&StatusRet{}) }
// NewServiceFunc is the type of a function that is used to instantiate a given Service // A service is initialized with a Host (to send messages to someone), the // overlay (to register a Tree + Roster + start new node), and a path where // it can finds / write everything it needs type NewServiceFunc func(c *Context, path string) Service // GenericConfig is a config that can withhold any type of specific configs for // protocols. It is passed down to the service NewProtocol function. type GenericConfig struct { Type uuid.UUID //Data network.ProtocolMessage } // GenericConfigID is the ID used by the network library for sending / receiving // GenericCOnfig var GenericConfigID = network.RegisterMessageType(GenericConfig{}) // A serviceFactory is used to register a NewServiceFunc type serviceFactory struct { constructors map[ServiceID]NewServiceFunc // translations between name of a Service and its ServiceID. Used to register a // Service using a name. translations map[string]ServiceID // Inverse mapping of ServiceId => string inverseTr map[ServiceID]string } // ServiceFactory is the global service factory to instantiate Services var ServiceFactory = serviceFactory{ constructors: make(map[ServiceID]NewServiceFunc), translations: make(map[string]ServiceID),
package sda import ( "sync" "github.com/dedis/cothority/network" "github.com/satori/go.uuid" ) // SDADataMessageID is to be embedded in every message that is made for a // ID of SDAData message as registered in network var SDADataMessageID = network.RegisterMessageType(ProtocolMsg{}) // RequestTreeMessageID of RequestTree message as registered in network var RequestTreeMessageID = network.RegisterMessageType(RequestTree{}) // RequestRosterMessageID of RequestRoster message as registered in network var RequestRosterMessageID = network.RegisterMessageType(RequestRoster{}) // SendTreeMessageID of TreeMarshal message as registered in network var SendTreeMessageID = TreeMarshalTypeID // SendRosterMessageID of Roster message as registered in network var SendRosterMessageID = RosterTypeID // ProtocolMsg is to be embedded in every message that is made for a // ProtocolInstance type ProtocolMsg struct { // Token uniquely identify the protocol instance this msg is made for From *Token // The TreeNodeId Where the message goes to
func init() { network.RegisterMessageType(PropagateMsg{}) }
func init() { network.RegisterMessageType(PrepareClose{}) network.RegisterMessageType(Close{}) sda.ProtocolRegisterName("CloseAll", NewCloseAll) }
// LoadSimulationConfig gets all configuration from dir + SimulationFileName and instantiates the // corresponding host 'ha'. func LoadSimulationConfig(dir, ha string) ([]*SimulationConfig, error) { network.RegisterMessageType(SimulationConfigFile{}) bin, err := ioutil.ReadFile(dir + "/" + SimulationFileName) if err != nil { return nil, err } _, msg, err := network.UnmarshalRegisteredType(bin, network.DefaultConstructors(network.Suite)) if err != nil { return nil, err } scf := msg.(SimulationConfigFile) sc := &SimulationConfig{ Roster: scf.Roster, PrivateKeys: scf.PrivateKeys, Config: scf.Config, } sc.Tree, err = scf.TreeMarshal.MakeTree(sc.Roster) if err != nil { return nil, err } var ret []*SimulationConfig if ha != "" { if !strings.Contains(ha, ":") { // to correctly match hosts a column is needed, else // 10.255.0.1 would also match 10.255.0.10 and others ha += ":" } for _, e := range sc.Roster.List { for _, a := range e.Addresses { log.Lvl4("Searching for", ha, "in", a) // If we are started in Deterlab- or other // big-server-needs-multiple-hosts, we might // want to initialise all hosts in one instance // of 'cothority' so as to minimize memory // footprint if strings.Contains(a, ha) { log.Lvl3("Found host", a, "to match", ha) host := NewHost(e, scf.PrivateKeys[a]) scNew := *sc scNew.Host = host scNew.Overlay = host.overlay ret = append(ret, &scNew) } } } if len(ret) == 0 { return nil, errors.New("Didn't find address: " + ha) } } else { ret = append(ret, sc) } if strings.Contains(sc.Roster.List[0].Addresses[0], "localhost") { // Now strip all superfluous numbers of localhost for i := range sc.Roster.List { _, port, _ := net.SplitHostPort(sc.Roster.List[i].Addresses[0]) sc.Roster.List[i].Addresses[0] = "localhost:" + port } } return ret, nil }
func init() { // register network messages and protocol network.RegisterMessageType(Message{}) network.RegisterMessageType(SignatureReply{}) sda.ProtocolRegisterName("NaiveTree", NewProtocol) }
} return hosts[0], hosts[1] } // Test instantiation of ProtocolInstances // Test access of actual peer that received the message // - corner-case: accessing parent/children with multiple instances of the same peer // in the graph - ProtocolID + GraphID + InstanceID is not enough // XXX ??? // Test complete parsing of new incoming packet // - Test if it is SDAMessage // - reject if unknown ProtocolID // - setting up of graph and Hostlist // - instantiating ProtocolInstance // SimpleMessage is just used to transfer one integer type SimpleMessage struct { I int } var SimpleMessageType = network.RegisterMessageType(SimpleMessage{}) func testMessageSimple(t *testing.T, msg network.Packet) SimpleMessage { if msg.MsgType != SimpleMessageType { t.Fatal("Received non SimpleMessage type") } return msg.Msg.(SimpleMessage) }