func TestAddRoute(t *testing.T) { node1, node2 := NewNode(), NewNode() assert.Len(t, node1.RouteForwardingRules, 0, "Should be 0 routes") ccid := node1.AddControlChannel() node1.Tick() // run channels consuming tf := transport.NewTransportFactory() tf.ConnectNodeToNode(node1, node2) tr1, _ := tf.GetTransports() tid1 := tr1.Id incomingRouteId := messages.RandRouteId() outgoingRouteId := messages.RandRouteId() msg := messages.AddRouteControlMessage{ (messages.TransportId)(0), tr1.Id, incomingRouteId, outgoingRouteId, } msgS := messages.Serialize(messages.MsgAddRouteControlMessage, msg) controlMessage := messages.InControlMessage{ccid, msgS} node1.InjectControlMessage(controlMessage) time.Sleep(1 * time.Millisecond) assert.Len(t, node1.RouteForwardingRules, 1, "Should be 1 routes") assert.Equal(t, node1.RouteForwardingRules[incomingRouteId].IncomingRoute, incomingRouteId) assert.Equal(t, node1.RouteForwardingRules[incomingRouteId].OutgoingRoute, outgoingRouteId) assert.Equal(t, node1.RouteForwardingRules[incomingRouteId].OutgoingTransport, tid1) fmt.Println("--------------------\n") }
func closedCycle() { nm := nodemanager.NewNodeManager() id1, id2, id3 := nm.AddNewNode(), nm.AddNewNode(), nm.AddNewNode() node1, err := nm.GetNodeById(id1) if err != nil { panic(err) } node2, err := nm.GetNodeById(id2) if err != nil { panic(err) } node3, err := nm.GetNodeById(id3) if err != nil { panic(err) } tf12 := nm.ConnectNodeToNode(id1, id2) // transport pair between nodes 1 and 2 t12, t21 := tf12.GetTransports() tid12, tid21 := t12.Id, t21.Id tf13 := nm.ConnectNodeToNode(id1, id3) // transport pair between nodes 1 and 3 t13, t31 := tf13.GetTransports() tid13, tid31 := t13.Id, t31.Id tf23 := nm.ConnectNodeToNode(id2, id3) // transport pair between nodes 2 and 3 t23, t32 := tf23.GetTransports() tid23, tid32 := t23.Id, t32.Id t13.MaxSimulatedDelay = 1100 // a possible point of failure, going through this transport can lead to packet drop routeId123, routeId231, routeId312 := messages.RandRouteId(), messages.RandRouteId(), messages.RandRouteId() route123 := node.RouteRule{tid21, tid23, routeId123, routeId231} // route from 1 to 3 through 2 route231 := node.RouteRule{tid32, tid31, routeId231, routeId312} // route from 2 to 1 through 3 route312 := node.RouteRule{tid13, tid12, routeId312, routeId123} // route from 3 to 2 through 1 node1.RouteForwardingRules[routeId312] = &route312 node2.RouteForwardingRules[routeId123] = &route123 node3.RouteForwardingRules[routeId231] = &route231 nm.Tick() inRouteMessage := messages.InRouteMessage{tid21, routeId123, []byte{'t', 'e', 's', 't'}} serialized := messages.Serialize(messages.MsgInRouteMessage, inRouteMessage) node2.IncomingChannel <- serialized time.Sleep(10 * time.Second) }
func TestRemoveRoute(t *testing.T) { node1, node2 := NewNode(), NewNode() ccid := node1.AddControlChannel() node1.Tick() // run channels consuming tf := transport.NewTransportFactory() tf.ConnectNodeToNode(node1, node2) routeId := messages.RandRouteId() msg := messages.AddRouteControlMessage{} msg.IncomingRouteId = routeId msgS := messages.Serialize(messages.MsgAddRouteControlMessage, msg) controlMessage := messages.InControlMessage{ccid, msgS} node1.InjectControlMessage(controlMessage) msg2 := messages.RemoveRouteControlMessage{routeId} msgS2 := messages.Serialize(messages.MsgRemoveRouteControlMessage, msg2) controlMessage = messages.InControlMessage{ccid, msgS2} node1.InjectControlMessage(controlMessage) time.Sleep(1 * time.Millisecond) assert.Len(t, node1.RouteForwardingRules, 0, "Should be 0 routes") fmt.Println("--------------------\n") }
func (self *NodeManager) ConnectAll() { n := len(self.NodeIdList) // form transportFactories between the nodes sequentially for i := 0; i < n-1; i++ { id1, id2 := self.NodeIdList[i], self.NodeIdList[i+1] self.ConnectNodeToNode(id1, id2) } // create rules for building a route from the first node to the last one rules := []*node.RouteRule{} for i := 0; i < n; i++ { ruleId := messages.RandRouteId() rules = append(rules, &node.RouteRule{IncomingRoute: ruleId}) } for i := 0; i < n; i++ { routeRule := rules[i] nodeId := self.NodeIdList[i] if i > 0 { prevNodeId := self.NodeIdList[i-1] incomingTransport, err := self.NodeList[prevNodeId].GetTransportToNode(nodeId) if err != nil { panic(err) } routeRule.IncomingTransport = incomingTransport.StubPair.Id } else { routeRule.IncomingTransport = (messages.TransportId)(0) } if i < n-1 { nextNodeId := self.NodeIdList[i+1] outgoingTransport, err := self.NodeList[nodeId].GetTransportToNode(nextNodeId) if err != nil { panic(err) } routeRule.OutgoingTransport = outgoingTransport.Id routeRule.OutgoingRoute = rules[i+1].IncomingRoute } else { routeRule.OutgoingTransport = (messages.TransportId)(0) routeRule.OutgoingRoute = (messages.RouteId)(0) } addRouteMessage := messages.AddRouteControlMessage{ routeRule.IncomingTransport, routeRule.OutgoingTransport, routeRule.IncomingRoute, routeRule.OutgoingRoute, } serialized := messages.Serialize(messages.MsgAddRouteControlMessage, addRouteMessage) node0 := self.NodeList[nodeId] ccid := node0.AddControlChannel() controlMessage := messages.InControlMessage{ccid, serialized} node0.InjectControlMessage(controlMessage) } }
func TestAck(t *testing.T) { tf := NewTransportFactory() t1, _ := tf.CreateStubTransportPair() go tf.Tick() time.Sleep(1 * time.Second) for i := 0; i < 10; i++ { tdt := messages.OutRouteMessage{messages.RandRouteId(), []byte{'t', 'e', 's', 't'}} t1.sendTransportDatagramTransfer(&tdt) } time.Sleep(10 * time.Second) assert.Equal(t, t1.PacketsSent, t1.PacketsConfirmed) }