ns3 sim node can basic run

core/BotMaster.py

@@ -74,7 +74,8 @@ def __init__(self, client_fsm=botmaster_fsm):
             '1234',
             2,
             -1,
-            'event=forward_to_bots;bot_event=send_ping;hostname=www.google.com;')
+            'event=forward_to_bots;bot_event=send_ping;hostname=127.0.0.1')
+            # 'event=forward_to_bots;bot_event=send_ping;hostname=www.google.com;')
 
 # if __name__ == "__main__":
     # cmd = BotMasterOneCMD(client_fsm,

core/CMD.py

@@ -30,6 +30,9 @@ def _trigger(self, event_name, *argv, **kwargv):
 
     def dispatcher(self, sock, data):
         self.logger.debug('dispatcher recv data' + data)
+        print 'data, ', data
+        if not data:
+            return
         dt_data = self._load_json(data)
         event_name = dt_data['event'][0]
         del dt_data['event']

core/Client.py

@@ -40,11 +40,15 @@ def _is_okay(self, node):
         return True
 
     def request_connect(self):
+        """request a connection to server"""
         sock = self.node.create_sock({'type':'server', 'proto':'tcp'})
-        print 'sock, ', sock
-        event = self.node.connect(sock, (self.srv_addr, self.srv_port))
         self.sock = sock
-        self._trigger(event)
+        if self.node.NODE_TYPE.startswith('real'):
+            event = self.node.connect(sock, (self.srv_addr, self.srv_port))
+            self._trigger(event)
+        elif self.node.NODE_TYPE.startswith('sim'):
+            event = self.node.connect(sock, (self.srv_addr, self.srv_port))
+            pass
 
     def connection_refused(self):
         self.logger.info("connection_refused, try 2 seconds later")
@@ -66,6 +70,8 @@ def echo(self, sock, data):
         self.logger.info("receive echo message, [%s]"%(data['msg'][0]))
         print '-->', data['msg'][0]
 
+    def start(self):
+        self.request_connect()
 
 # if __name__ == "__main__":
 #     from Node import PhyNode

core/Server.py

@@ -26,16 +26,51 @@ def __init__(self, fsm_desc=server_fsm):
 
     def _is_okay(self, node): return True
 
+    def start(self):
+        self.initialize()
+
+    @property
+    def addr(self):
+        return self.fsm_desc['info']['srv_addr']
+
+    @property
+    def port(self):
+        return self.fsm_desc['info']['srv_port']
+
     def initialize(self):
-        srv_sock = self.node.create_sock({'type':'server', 'proto':'tcp'})
-        self.node.bind(srv_sock, 3333)
-        self.node.listen(srv_sock, 5)
+        """ initialize the server.
+        If the server is real node. It will call Accept method in blocking way.
+        if the server is simulated. It will set the SetAcceptCallBack
+        """
+        self.srv_sock = self.node.create_sock({'type':'server', 'proto':'tcp'})
+        self.node.bind(self.srv_sock, (self.addr, self.port))
+        self.node.listen(self.srv_sock, 5)
         # self.node.set_state('waiting')
 
-        while True:
-            client_sock, address = self.node.accept(srv_sock)
+        # FIXME this part should be different for sim node and real node.
+        if self.node.NODE_TYPE.startswith('real'):
+            while True:
+                client_sock, address = self.node.accept(self.srv_sock)
+                self._trigger('recv_request_conn', client_sock, address)
+        elif self.node.NODE_TYPE.startswith('sim'):
+            self._sim_node_init()
+        else:
+            raise Exception("Unknown Node Type")
+
+    def _sim_node_init(self):
+        """initialize for ns3 simulated node, ns3 sim node doesn't support blocking mode
+        instead we need to set the callback"""
+        print 'sim node initialization'
+        def connect_request(sock, addr):
+            print 'connect_request'
+            return True
+
+        def connect_created(client_sock, address):
+            print 'connect_created, '
             self._trigger('recv_request_conn', client_sock, address)
 
+        self.srv_sock.SetAcceptCallback(connect_request, connect_created)
+
     def recv_request_conn(self, client_sock, address):
         self.logger.info('receive request from addr: %s'%(str(address)))
         self.node.send(client_sock, 'connect_ack')

core/__init__.py

@@ -1,8 +1,5 @@
-# import sys
-# sys.path.append("..")
 from CMD import *
 from Server import *
 from Client import *
-# from BaseNode import *
 import BaseNode
 import real

core/ns3/Experiment.py

@@ -1,6 +1,7 @@
 from core.ns3.netns3 import *
 from core.ns3.Node import *
 from core.ns3.csma_ping import *
+import ns3
 
 from util import load_module, get_scenario_option
 
@@ -9,139 +10,55 @@
 # class ImalseExperiment(NetnsExperiment):
 # class ImalseExperiment(PingCsmaExperiment):
 class ImalseExperiment(NetnsExperiment):
+    """Base Class for Imalse Experiment"""
+    server_id_set = [0]
+    botmaster_id_set = [1]
+    client_id_set = [2, 3]
+
     def get_node(self, i):
         return self.nodes[i]
     @property
     def node_num(self):
         return len(self.nodes)
 
     def _install_cmds(self):
+        """install different command set to nodes according to their type"""
         scen = load_module(self.options.scenario)
-        botmaster_id_set = [1]
-        server_id_set = [0]
         for i in xrange(self.node_num):
-            if i in botmaster_id_set:
-                cmd = scen.ClientCMD()
-            elif i in server_id_set:
+            if i in self.botmaster_id_set:
+                cmd = scen.BotMaster()
+            elif i in self.server_id_set:
                 cmd = scen.ServerCMD()
+            elif i in self.client_id_set:
+                cmd = scen.ClientCMD()
             else:
-                cmd = scen.BotMaster()
+                continue
             cmd.install(self.get_node(i))
 
-    def node_run(self, node, *args, **kwargs):
-        node.cmd_set._trigger(*args, **kwargs)
-
-from Topology import TopologyNet
-import os
-class ImalseTopoSimExperiment(ImalseExperiment):
-    """This is pure ns-3 topology Experiment without emulated node"""
-
-    def initparser(self, parser):
-        super(ImalseTopoSimExperiment, self).initparser(parser)
-        parser.set_defaults(topology_file="./net_config/Inet_small_toposample.txt",
-                topology_type = 'Inet',
-                )
-        parser.add_option("-f", "--topology_file", dest = "topology_file",
-                          help = "topology file name, default = %s" %(parser.defaults["topology_file"]))
-        parser.add_option('-p', '--topology_type', dest="topology_type",
-                help='type of topology file',
-                )
-        scenario_ops = get_scenario_option()
-        parser.add_option('-s', '--scenario', dest="scenario",
-                default='None',
-                help='specify the scenario you want to execute. Scenearios availiable are: %s'%(scenario_ops),
-                )
+    def _get_server_addr(self):
+        addr_set = []
+        for i in self.server_id_set:
+            ipv4Addr = self.get_node(i).GetObject(ns3.TypeId.LookupByName("ns3::Ipv4")).GetAddress(1, 0)
+            addr_set.append(ipv4Addr)
+        return addr_set
 
+    def _get_server_nodes(self):
+        return [self.get_node(i) for i in self.server_id_set]
 
-    def get_node(self, i):
-        return self.net.nodes.Get(i)
-    @property
-    def node_num(self):
-        return self.net.nodes.GetN()
-
-    def setup(self):
-        self.net = TopologyNet(os.path.abspath(self.options.topology_file),
-                self.options.topology_type,
-                ImalseNetnsSimNode)
-        self._install_cmds()
-        if self.node_num == 0: return
+    def _set_server_info(self):
+        """Only Set Server information for simulated nodes"""
+        server_addr_set = self._get_server_addr()
+        server_set = self._get_server_nodes()
         for i in xrange(self.node_num):
-            print 'node [%i] start at [%f]s'%(i, i)
-            self.event(i+1, self.node_run, self.get_node(i), 'start') # start server
-
-class ImalsePingCsmaExperiment(PingCsmaExperiment, ImalseExperiment):
-    def __init__(self, *argv, **kwargv):
-        PingCsmaExperiment.__init__(self, *argv, **kwargv)
-        ImalseExperiment.__init__(self)
-
-    def initparser(self, parser):
-        CsmaExperiment.initparser(self, parser)
-        parser.set_defaults(simtime = 10, pingcount = 3)
-        parser.add_option("-c", "--pingcount", dest = "pingcount",
-                          help = "ping count; default = %s" %
-                          parser.defaults["pingcount"])
-        scenario_ops = get_scenario_option()
-        parser.add_option('-s', '--scenario', dest="scenario",
-                default='None',
-                help='specify the scenario you want to execute. Scenearios availiable are: %s'%(scenario_ops),
-                )
-
-    def createnodes(self, numnodes, devhelper, prefix = "10.0.0.0/8",
-                    nodenum = 0):
-        addrhelper, mask = parseprefix(prefix)
-        nc = ns.network.NodeContainer()
-        for i in xrange(numnodes):
-            name = "n%s" % nodenum
-            n = ImalseNetnsNode(name, logfile = "/tmp/%s.log" % name)
-            self.nodes.append(n)
-            nc.Add(n)
-            nodenum += 1
-        self.createnet(devhelper, nc, addrhelper, mask)
-
-        self._install_cmds()
+            if i in self.server_id_set or self.get_node(i).NODE_TYPE.startswith('real'):
+                continue
+            self.get_node(i).server_addr_set = server_addr_set
+            self.get_node(i).server_set = server_set
 
-    def createnet(self, devhelper, nodecontainer,
-                  addrhelper, mask, ifnames = []):
-        tapbridge = ns.tap_bridge.TapBridgeHelper()
-        devices = devhelper.Install(nodecontainer)
-        for i in xrange(nodecontainer.GetN()):
-            n = nodecontainer.Get(i)
-            dev = devices.Get(i)
-            # install a TapBridge on the specified Node and forms the
-            # bridge with the net devices
-            tap = tapbridge.Install(n, dev)
-            tap.SetMode(ns.tap_bridge.TapBridge.CONFIGURE_LOCAL)
-            tapname = "ns3tap%d" % i
-            tap.SetAttribute("DeviceName", ns.core.StringValue(tapname))
-            addr = addrhelper.NewAddress()
-            tap.SetAttribute("IpAddress", ns.network.Ipv4AddressValue(addr))
-            tap.SetAttribute("Netmask", ns.network.Ipv4MaskValue(mask))
-            if ifnames:
-                ifname = ifnames[i]
-            else:
-                ifname = "eth0"
-            n.addnetif(tapname,
-                       ipaddrs = ["%s/%s" % (addr, mask.GetPrefixLength())],
-                       rename = ifname)
-            n.ipaddr = str(addr)
-
-    def create_topology(self):
-        pass
-
-    def setup(self):
-        print 'this is setup of experiment'
-        CsmaExperiment.setup(self)
-        for n in self.nodes:
-            self.event(0, self.config, n)
-        if not self.nodes:
-            return
-        for i in xrange(len(self.nodes)):
-            print 'node [%i] start at [%f]s'%(i, i)
-            self.event(i+1, self.node_run, self.nodes[i], 'start') # start server
-            # self.event(1, self.nodes[0], 'start') # start server
-            # self.event(1, self.nodes[1], 'start') # start botmaster
-            # self.event(1, self.nodes[1], 'start') # start botmaster
+    def node_run(self, node, *args, **kwargs):
+        node.cmd_set._trigger(*args, **kwargs)
 
-        # if self.nodes:
-            # self.event(1, self.ping, self.nodes[0],
-                       # "255.255.255.255", self.options.pingcount)
+    def print_srv_addr(self):
+        for i in self.server_id_set:
+            ipv4Addr = self.get_node(i).GetObject(ns3.TypeId.LookupByName("ns3::Ipv4")).GetAddress(1, 0)
+            print 'The server addr of server [%i ]: '%(i), ipv4Addr