1820

pending completion

Build # 1820

Build Type

Pull #438

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/dedis/onet/commit/<a class=hub.com/dedis/onet/commit/<a class="double-link" href="https://git"><a class=hub.com/dedis/onet/commit/<a class="double-link" href="https://git"><a class=hub.com/dedis/onet/commit/<a class="double-link" href="https://git"><a class=hub.com/dedis/onet/commit/0eb9bfa033619b7ee78f17c69fd6d6232ae063cd">0eb9bfa03">&lt;a href=&quot;https://github.com/dedis/onet/commit/</a><a class="double-link" href="https://github.com/dedis/onet/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/dedis/onet/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/dedis/onet/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/dedis/onet/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/dedis/onet/commit/0eb9bfa033619b7ee78f17c69fd6d6232ae063cd">0eb9bfa03</a><a href="https://github.com/dedis/onet/commit/0eb9bfa033619b7ee78f17c69fd6d6232ae063cd">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/dedis/onet/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/dedis/onet/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/dedis/onet/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/dedis/onet/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/dedis/onet/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/dedis/onet/commit/0eb9bfa033619b7ee78f17c69fd6d6232ae063cd&quot;&gt;0eb9bfa03&lt;/a&gt;&lt;a href=&quot;https://github.com/dedis/onet/commit/0eb9bfa033619b7ee78f17c69fd6d6232ae063cd&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/dedis/onet/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/dedis/onet/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;... (continued)

Pull Request Pull Request #438:

Run Details

350 of 350 new or added lines in 17 files covered. (100.0%)

5234 of 8054 relevant lines covered (64.99%)

140.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/simul/platform/runsimul.go

package platform

import (
        "sync"
        "time"

        "gopkg.in/dedis/onet.v2"
        "gopkg.in/dedis/onet.v2/log"

        "github.com/BurntSushi/toml"
        "gopkg.in/dedis/onet.v2/network"
        "gopkg.in/dedis/onet.v2/simul/manage"
        "gopkg.in/dedis/onet.v2/simul/monitor"
)

type simulInit struct{}
type simulInitDone struct{}

// Simulate starts the server and will setup the protocol.
func Simulate(suite, serverAddress, simul, monitorAddress string) error {
        scs, err := onet.LoadSimulationConfig(suite, ".", serverAddress)
        if err != nil {
                // We probably are not needed
                log.Lvl2(err, serverAddress)
                return nil
        }
        measures := make([]*monitor.CounterIOMeasure, len(scs))
        if monitorAddress != "" {
                if err := monitor.ConnectSink(monitorAddress); err != nil {
                        log.Error("Couldn't connect monitor to sink:", err)
                }
        }
        sims := make([]onet.Simulation, len(scs))
        simulInitID := network.RegisterMessage(simulInit{})
        simulInitDoneID := network.RegisterMessage(simulInitDone{})
        var rootSC *onet.SimulationConfig
        var rootSim onet.Simulation
        // having a waitgroup so the binary stops when all servers are closed
        var wgServer, wgSimulInit sync.WaitGroup
        var ready = make(chan bool)
        measureNodeBW := true
        if len(scs) > 0 {
                cfg := &conf{}
                _, err := toml.Decode(scs[0].Config, cfg)
                if err != nil {
                        return err
                }
                measureNodeBW = cfg.IndividualStats == ""
        }
        for i, sc := range scs {
                // Starting all servers for that server
                server := sc.Server
                log.Lvl3(serverAddress, "Starting server", server.ServerIdentity.Address)
                if measureNodeBW {
                        measures[i] = monitor.NewCounterIOMeasure("bandwidth", server)
                }
                // Launch a server and notifies when it's done
                wgServer.Add(1)
                go func(c *onet.Server, m monitor.Measure) {
                        ready <- true
                        defer wgServer.Done()
                        c.Start()
                        // record bandwidth, except if we're measuring every
                        // round individually
                        if measureNodeBW {
                                m.Record()
                        }
                        log.Lvl3(serverAddress, "Simulation closed server", c.ServerIdentity)
                }(server, measures[i])
                // wait to be sure the goroutine started
                <-ready

                sim, err := onet.NewSimulation(simul, sc.Config)
                if err != nil {
                        return err
                }
                sims[i] = sim
                // Need to store sc in a tmp-variable so it's correctly passed
                // to the Register-functions.
                scTmp := sc
                server.RegisterProcessorFunc(simulInitID, func(env *network.Envelope) {
                        err = sim.Node(scTmp)
                        log.ErrFatal(err)
                        _, err := scTmp.Server.Send(env.ServerIdentity, &simulInitDone{})
                        log.ErrFatal(err)
                })
                server.RegisterProcessorFunc(simulInitDoneID, func(env *network.Envelope) {
                        wgSimulInit.Done()
                })
                if server.ServerIdentity.ID.Equal(sc.Tree.Root.ServerIdentity.ID) {
                        log.Lvl2(serverAddress, "is root-node, will start protocol")
                        rootSim = sim
                        rootSC = sc
                }
        }
        if rootSim != nil {
                // If this cothority has the root-server, it will start the simulation
                log.Lvl2("Starting protocol", simul, "on server", rootSC.Server.ServerIdentity.Address)
                log.Lvl5("Tree is", rootSC.Tree.Dump())

                // First count the number of available children
                childrenWait := monitor.NewTimeMeasure("ChildrenWait")
                wait := true
                // The timeout starts with 1 second, which is the time of response between
                // each level of the tree.
                timeout := 1 * time.Second
                for wait {
                        p, err := rootSC.Overlay.CreateProtocol("Count", rootSC.Tree, onet.NilServiceID)
                        if err != nil {
                                return err
                        }
                        proto := p.(*manage.ProtocolCount)
                        proto.SetTimeout(timeout)
                        proto.Start()
                        log.Lvl1("Started counting children with timeout of", timeout)
                        select {
                        case count := <-proto.Count:
                                if count == rootSC.Tree.Size() {
                                        log.Lvl1("Found all", count, "children")
                                        wait = false
                                } else {
                                        log.Lvl1("Found only", count, "children, counting again")
                                }
                        }
                        // Double the timeout and try again if not successful.
                        timeout *= 2
                }
                childrenWait.Record()
                log.Lvl2("Broadcasting start")
                syncWait := monitor.NewTimeMeasure("SimulSyncWait")
                wgSimulInit.Add(len(rootSC.Tree.Roster.List))
                for _, conode := range rootSC.Tree.Roster.List {
                        go func(si *network.ServerIdentity) {
                                _, err := rootSC.Server.Send(si, &simulInit{})
                                log.ErrFatal(err, "Couldn't send to conode:")
                        }(conode)
                }
                wgSimulInit.Wait()
                syncWait.Record()
                log.Lvl1("Starting new node", simul)
                measureNet := monitor.NewCounterIOMeasure("bandwidth_root", rootSC.Server)
                err := rootSim.Run(rootSC)
                if err != nil {
                        return err
                }
                measureNet.Record()

                // Test if all ServerIdentities are used in the tree, else we'll run into
                // troubles with CloseAll
                if !rootSC.Tree.UsesList() {
                        log.Error("The tree doesn't use all ServerIdentities from the list!\n" +
                                "This means that the CloseAll will fail and the experiment never ends!")
                }
                // Recreate a tree out of the original roster, to be sure all nodes are included and
                // that the tree is easy to close.
                closeTree := rootSC.Roster.GenerateBinaryTree()
                pi, err := rootSC.Overlay.CreateProtocol("CloseAll", closeTree, onet.NilServiceID)
                if err != nil {
                        return err
                }
                pi.Start()
        }

        log.Lvl3(serverAddress, scs[0].Server.ServerIdentity, "is waiting for all servers to close")
        wgServer.Wait()
        log.Lvl2(serverAddress, "has all servers closed")
        if monitorAddress != "" {
                monitor.EndAndCleanup()
        }
        return nil
}

type conf struct {
        IndividualStats string
}

1	package platform
2
3	import (
4	"sync"
5	"time"
6
7	"gopkg.in/dedis/onet.v2"
8	"gopkg.in/dedis/onet.v2/log"
9
10	"github.com/BurntSushi/toml"
11	"gopkg.in/dedis/onet.v2/network"
12	"gopkg.in/dedis/onet.v2/simul/manage"
13	"gopkg.in/dedis/onet.v2/simul/monitor"
14	)
15
16	type simulInit struct{}
17	type simulInitDone struct{}
18
19	// Simulate starts the server and will setup the protocol.
20	func Simulate(suite, serverAddress, simul, monitorAddress string) error {	×
21	scs, err := onet.LoadSimulationConfig(suite, ".", serverAddress)	×
22	if err != nil {	×
23	// We probably are not needed	×
24	log.Lvl2(err, serverAddress)	×
25	return nil	×
26	}	×
27	measures := make([]*monitor.CounterIOMeasure, len(scs))	×
28	if monitorAddress != "" {	×
29	if err := monitor.ConnectSink(monitorAddress); err != nil {	×
30	log.Error("Couldn't connect monitor to sink:", err)	×
31	}	×
32	}
33	sims := make([]onet.Simulation, len(scs))	×
34	simulInitID := network.RegisterMessage(simulInit{})	×
35	simulInitDoneID := network.RegisterMessage(simulInitDone{})	×
36	var rootSC *onet.SimulationConfig	×
37	var rootSim onet.Simulation	×
38	// having a waitgroup so the binary stops when all servers are closed	×
39	var wgServer, wgSimulInit sync.WaitGroup	×
40	var ready = make(chan bool)	×
41	measureNodeBW := true	×
42	if len(scs) > 0 {	×
43	cfg := &conf{}	×
44	_, err := toml.Decode(scs[0].Config, cfg)	×
45	if err != nil {	×
46	return err	×
47	}	×
48	measureNodeBW = cfg.IndividualStats == ""	×
49	}
50	for i, sc := range scs {	×
51	// Starting all servers for that server	×
52	server := sc.Server	×
53	log.Lvl3(serverAddress, "Starting server", server.ServerIdentity.Address)	×
54	if measureNodeBW {	×
55	measures[i] = monitor.NewCounterIOMeasure("bandwidth", server)	×
56	}	×
57	// Launch a server and notifies when it's done
58	wgServer.Add(1)	×
59	go func(c *onet.Server, m monitor.Measure) {	×
60	ready <- true	×
61	defer wgServer.Done()	×
62	c.Start()	×
63	// record bandwidth, except if we're measuring every	×
64	// round individually	×
65	if measureNodeBW {	×
66	m.Record()	×
67	}	×
68	log.Lvl3(serverAddress, "Simulation closed server", c.ServerIdentity)	×
69	}(server, measures[i])
70	// wait to be sure the goroutine started
71	<-ready	×
72		×
73	sim, err := onet.NewSimulation(simul, sc.Config)	×
74	if err != nil {	×
75	return err	×
76	}	×
77	sims[i] = sim	×
78	// Need to store sc in a tmp-variable so it's correctly passed	×
79	// to the Register-functions.	×
80	scTmp := sc	×
81	server.RegisterProcessorFunc(simulInitID, func(env *network.Envelope) {	×
82	err = sim.Node(scTmp)	×
83	log.ErrFatal(err)	×
84	_, err := scTmp.Server.Send(env.ServerIdentity, &simulInitDone{})	×
85	log.ErrFatal(err)	×
86	})	×
87	server.RegisterProcessorFunc(simulInitDoneID, func(env *network.Envelope) {	×
88	wgSimulInit.Done()	×
89	})	×
90	if server.ServerIdentity.ID.Equal(sc.Tree.Root.ServerIdentity.ID) {	×
91	log.Lvl2(serverAddress, "is root-node, will start protocol")	×
92	rootSim = sim	×
93	rootSC = sc	×
94	}	×
95	}
96	if rootSim != nil {	×
97	// If this cothority has the root-server, it will start the simulation	×
98	log.Lvl2("Starting protocol", simul, "on server", rootSC.Server.ServerIdentity.Address)	×
99	log.Lvl5("Tree is", rootSC.Tree.Dump())	×
100		×
101	// First count the number of available children	×
102	childrenWait := monitor.NewTimeMeasure("ChildrenWait")	×
103	wait := true	×
104	// The timeout starts with 1 second, which is the time of response between	×
105	// each level of the tree.	×
106	timeout := 1 * time.Second	×
107	for wait {	×
108	p, err := rootSC.Overlay.CreateProtocol("Count", rootSC.Tree, onet.NilServiceID)	×
109	if err != nil {	×
110	return err	×
111	}	×
112	proto := p.(*manage.ProtocolCount)	×
113	proto.SetTimeout(timeout)	×
114	proto.Start()	×
115	log.Lvl1("Started counting children with timeout of", timeout)	×
116	select {	×
117	case count := <-proto.Count:	×
118	if count == rootSC.Tree.Size() {	×
119	log.Lvl1("Found all", count, "children")	×
120	wait = false	×
121	} else {	×
122	log.Lvl1("Found only", count, "children, counting again")	×
123	}	×
124	}
125	// Double the timeout and try again if not successful.
126	timeout *= 2	×
127	}
128	childrenWait.Record()	×
129	log.Lvl2("Broadcasting start")	×
130	syncWait := monitor.NewTimeMeasure("SimulSyncWait")	×
131	wgSimulInit.Add(len(rootSC.Tree.Roster.List))	×
132	for _, conode := range rootSC.Tree.Roster.List {	×
133	go func(si *network.ServerIdentity) {	×
134	_, err := rootSC.Server.Send(si, &simulInit{})	×
135	log.ErrFatal(err, "Couldn't send to conode:")	×
136	}(conode)	×
137	}
138	wgSimulInit.Wait()	×
139	syncWait.Record()	×
140	log.Lvl1("Starting new node", simul)	×
141	measureNet := monitor.NewCounterIOMeasure("bandwidth_root", rootSC.Server)	×
142	err := rootSim.Run(rootSC)	×
143	if err != nil {	×
144	return err	×
145	}	×
146	measureNet.Record()	×
147		×
148	// Test if all ServerIdentities are used in the tree, else we'll run into	×
149	// troubles with CloseAll	×
150	if !rootSC.Tree.UsesList() {	×
151	log.Error("The tree doesn't use all ServerIdentities from the list!\n" +	×
152	"This means that the CloseAll will fail and the experiment never ends!")	×
153	}	×
154	// Recreate a tree out of the original roster, to be sure all nodes are included and
155	// that the tree is easy to close.
156	closeTree := rootSC.Roster.GenerateBinaryTree()	×
157	pi, err := rootSC.Overlay.CreateProtocol("CloseAll", closeTree, onet.NilServiceID)	×
158	if err != nil {	×
159	return err	×
160	}	×
161	pi.Start()	×
162	}
163
164	log.Lvl3(serverAddress, scs[0].Server.ServerIdentity, "is waiting for all servers to close")	×
165	wgServer.Wait()	×
166	log.Lvl2(serverAddress, "has all servers closed")	×
167	if monitorAddress != "" {	×
168	monitor.EndAndCleanup()	×
169	}	×
170	return nil	×
171	}
172
173	type conf struct {
174	IndividualStats string
175	}

dedis / onet / 1820

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous