examples/wimax_overlay.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from nepi.core.design import ExperimentDescription, FactoriesProvider
   5 from nepi.core.execute import ExperimentController
   6 from optparse import OptionParser, SUPPRESS_HELP
   7 from nepi.util.constants import DeploymentConfiguration as DC
   8 import os
   9 import shutil
  10 import tempfile
  11 import time
  12
  13 class WimaxOverlayExample(object):
  14     def __init__(self):
  15         #usage = "usage: %prog -m movie -u user"
  16         #parser = OptionParser(usage=usage)
  17         #parser.add_option("-u", "--user", dest="user", help="Valid linux system user (not root).", type="str")
  18         #parser.add_option("-m", "--movie", dest="movie", help="Path to movie file to play", type="str")
  19         #(options, args) = parser.parse_args()
  20         #if not options.movie:
  21         #    parser.error("Missing 'movie' option.")
  22         #if options.user == 'root':
  23         #    parser.error("Missing or invalid 'user' option.")
  24
  25         #self.user = options.user if options.user else os.getlogin()
  26         self.user = os.getlogin()
  27         #self.movie =  options.movie
  28         self.root_dir = tempfile.mkdtemp()
  29
  30     def add_ns3_node(self, ns3_desc):
  31         node = ns3_desc.create("ns3::Node")
  32         ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol")
  33         arp  = ns3_desc.create("ns3::ArpL3Protocol")
  34         icmp = ns3_desc.create("ns3::Icmpv4L4Protocol")
  35         udp = ns3_desc.create("ns3::UdpL4Protocol")
  36         tcp = ns3_desc.create("ns3::TcpL4Protocol")
  37         node.connector("protos").connect(ipv4.connector("node"))
  38         node.connector("protos").connect(arp.connector("node"))
  39         node.connector("protos").connect(icmp.connector("node"))
  40         node.connector("protos").connect(udp.connector("node"))
  41         node.connector("protos").connect(tcp.connector("node"))
  42         return node
  43
  44     def add_ns3_wimax_bs(self, ns3_desc, node, channel):
  45         bs = ns3_desc.create("ns3::BaseStationNetDevice")
  46         node.connector("devs").connect(bs.connector("node"))
  47         bs.connector("chan").connect(channel.connector("devs"))
  48         phy = ns3_desc.create("ns3::SimpleOfdmWimaxPhy")
  49         bs.connector("phy").connect(phy.connector("dev"))
  50         uplink = ns3_desc.create("ns3::UplinkSchedulerSimple")
  51         bs.connector("uplnk").connect(uplink.connector("dev"))
  52         bssched = ns3_desc.create("ns3::BSSchedulerSimple")
  53         bs.connector("dwnlnk").connect(bssched.connector("dev"))
  54         bs.enable_trace("WimaxPcapTrace")
  55         bs.enable_trace("WimaxAsciiTrace")
  56         return bs
  57
  58     def add_ns3_wimax_ss(self, ns3_desc, node, channel):
  59         ss = ns3_desc.create("ns3::SubscriberStationNetDevice")
  60         node.connector("devs").connect(ss.connector("node"))
  61         ss.connector("chan").connect(channel.connector("devs"))
  62         phy = ns3_desc.create("ns3::SimpleOfdmWimaxPhy")
  63         ss.connector("phy").connect(phy.connector("dev"))
  64         ss.enable_trace("WimaxPcapTrace")
  65         ss.enable_trace("WimaxAsciiTrace")
  66         return ss
  67
  68     def add_ns3_p2p(self, ns3_desc, node, channel):
  69         iface = ns3_desc.create("ns3::PointToPointNetDevice")
  70         queue = ns3_desc.create("ns3::DropTailQueue")
  71         node.connector("devs").connect(iface.connector("node"))
  72         iface.connector("queue").connect(queue.connector("dev"))
  73         trace = iface.enable_trace("P2PAsciiTrace")
  74         iface.connector("chan").connect(channel.connector("dev2"))
  75         return iface
  76
  77     def add_ns3_service_flow(self, ns3_desc, ss, src_address, src_mask,
  78             dst_address, dst_mask, src_portlow, src_porthigh, dst_portlow,
  79             dst_porthigh, protocol, priority, direction, scheduling_type):
  80         classifier = ns3_desc.create("ns3::IpcsClassifierRecord")
  81         classifier.set_attribute_value("SrcAddress", src_address)
  82         classifier.set_attribute_value("SrcMask", src_mask)
  83         classifier.set_attribute_value("DstAddress", dst_address)
  84         classifier.set_attribute_value("DstMask", dst_mask)
  85         classifier.set_attribute_value("SrcPortLow", src_portlow)
  86         classifier.set_attribute_value("SrcPortHigh",src_porthigh)
  87         classifier.set_attribute_value("DstPortLow", dst_portlow)
  88         classifier.set_attribute_value("DstPortHigh", dst_porthigh)
  89         classifier.set_attribute_value("Protocol", protocol)
  90         classifier.set_attribute_value("Priority", priority)
  91         sflow = ns3_desc.create("ns3::ServiceFlow")
  92         sflow.set_attribute_value("Direction", direction)
  93         sflow.set_attribute_value("SchedulingType", scheduling_type)
  94         sflow.connector("classif").connect(classifier.connector("sflow"))
  95         ss.connector("sflows").connect(sflow.connector("dev"))
  96
  97     def add_netns_tap(self, netns_desc, node):
  98         tap = netns_desc.create("TapNodeInterface")
  99         tap.set_attribute_value("up", True)
 100         node.connector("devs").connect(tap.connector("node"))
 101         return tap
 102
 103     def add_ns3_fdnd(self, ns3_desc, node):
 104         fdnd = ns3_desc.create("ns3::FdNetDevice")
 105         node.connector("devs").connect(fdnd.connector("node"))
 106         fdnd.enable_trace("FdPcapTrace")
 107         return fdnd
 108
 109     def add_ip_address(self, iface, address, netprefix):
 110         ip = iface.add_address()
 111         ip.set_attribute_value("Address", address)
 112         ip.set_attribute_value("NetPrefix", netprefix)
 113
 114     def add_route(self, node, destination, netprefix, nexthop):
 115         route = node.add_route()
 116         route.set_attribute_value("Destination", destination)
 117         route.set_attribute_value("NetPrefix", netprefix)
 118         route.set_attribute_value("NextHop", nexthop)
 119
 120     def run(self):
 121         base_addr = "192.168.4.%d"
 122         exp_desc = ExperimentDescription()
 123
 124         # NS3
 125         ns3_provider = FactoriesProvider("ns3")
 126         ns3_desc = exp_desc.add_testbed_description(ns3_provider)
 127         ns3_desc.set_attribute_value("homeDirectory", self.root_dir)
 128         ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl")
 129         ns3_desc.set_attribute_value("ChecksumEnabled", True)
 130
 131         ## WIMAX network 32/27
 132         node_bs = self.add_ns3_node(ns3_desc)
 133         node_ss1 = self.add_ns3_node(ns3_desc)
 134         node_ss2 = self.add_ns3_node(ns3_desc)
 135         node_ss3 = self.add_ns3_node(ns3_desc)
 136         node_ss4 = self.add_ns3_node(ns3_desc)
 137         node_ss5 = self.add_ns3_node(ns3_desc)
 138         node_ss6 = self.add_ns3_node(ns3_desc)
 139
 140         wimax_channel = ns3_desc.create("ns3::SimpleOfdmWimaxChannel")
 141
 142         bs = self.add_ns3_wimax_bs(ns3_desc, node_bs, wimax_channel)
 143         ss1 = self.add_ns3_wimax_ss(ns3_desc, node_ss1, wimax_channel)
 144         ss2 = self.add_ns3_wimax_ss(ns3_desc, node_ss2, wimax_channel)
 145         ss3 = self.add_ns3_wimax_ss(ns3_desc, node_ss3, wimax_channel)
 146         ss4 = self.add_ns3_wimax_ss(ns3_desc, node_ss4, wimax_channel)
 147         ss5 = self.add_ns3_wimax_ss(ns3_desc, node_ss5, wimax_channel)
 148         ss6 = self.add_ns3_wimax_ss(ns3_desc, node_ss6, wimax_channel)
 149
 150         self.add_ip_address(bs, (base_addr%33), 27)
 151         self.add_ip_address(ss1, (base_addr%34), 27)
 152         self.add_ip_address(ss2, (base_addr%35), 27)
 153         self.add_ip_address(ss3, (base_addr%36), 27)
 154         self.add_ip_address(ss4, (base_addr%37), 27)
 155         self.add_ip_address(ss5, (base_addr%38), 27)
 156         self.add_ip_address(ss6, (base_addr%39), 27)
 157
 158         #self.add_ns3_service_flow(ns3_desc, ss1, "0.0.0.0", "0.0.0.0",
 159         #        "10.1.1.1", "255.255.255.255", 0, 65000, 100, 100,
 160         #       "UdpL4Protocol", 1, "SF_DIRECTION_DOWN", "SF_TYPE_RTPS")
 161         #self.add_ns3_service_flow(ns3_desc, ss2, "10.1.1.2", "255.255.255.255",
 162         #        "0.0.0.0", "0.0.0.0", 0, 65000, 100, 100, "UdpL4Protocol",
 163         #        1, "SF_DIRECTION_UP", "SF_TYPE_RTPS")
 164
 165         self.add_ns3_service_flow(ns3_desc, ss1, "0.0.0.0", "0.0.0.0",
 166                 "192.168.4.35", "255.255.255.225", 0, 65000, 11, 11, "Icmpv4L4Protocol",
 167                 1, "SF_DIRECTION_DOWN", "SF_TYPE_RTPS")
 168
 169         self.add_ns3_service_flow(ns3_desc, ss2, "192.168.4.34", "255.255.255.255",
 170                 "0.0.0.0", "0.0.0.0", 0, 65000, 11, 11, "Icmpv4L4Protocol",
 171                 1, "SF_DIRECTION_UP", "SF_TYPE_RTPS")
 172
 173         ## Point-to-Point wimax/fdnd 224/30
 174         node_fdnd = self.add_ns3_node(ns3_desc)
 175         p2p_channel = ns3_desc.create("ns3::PointToPointChannel")
 176
 177         p2p1 = self.add_ns3_p2p(ns3_desc, node_ss1, p2p_channel)
 178         p2p2 = self.add_ns3_p2p(ns3_desc, node_fdnd, p2p_channel)
 179
 180         self.add_ip_address(p2p1, (base_addr%225), 30)
 181         self.add_ip_address(p2p2, (base_addr%226), 30)
 182
 183         # NETNS
 184         netns_provider = FactoriesProvider("netns")
 185         netns_desc = exp_desc.add_testbed_description(netns_provider)
 186         netns_desc.set_attribute_value("homeDirectory", self.root_dir)
 187         netns_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 188         netns_root_dir = os.path.join(self.root_dir, "netns_instance")
 189         os.mkdir(netns_root_dir)
 190         netns_desc.set_attribute_value(DC.ROOT_DIRECTORY, netns_root_dir)
 191         netns_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
 192         netns_desc.set_attribute_value(DC.USE_SUDO, True)
 193
 194         node_netns = netns_desc.create("Node")
 195         node_netns.set_attribute_value("forward_X11", True)
 196         tap = self.add_netns_tap(netns_desc, node_netns)
 197
 198         command = "xterm"
 199         app = netns_desc.create("Application")
 200         app.set_attribute_value("command", command)
 201         app.set_attribute_value("user", self.user)
 202         app.connector("node").connect(node_netns.connector("apps"))
 203
 204         ## Point-to-Point NS3::fdnd/NETNS::tap 228/30
 205         fdnd = self.add_ns3_fdnd(ns3_desc, node_fdnd)
 206
 207         fdnd.connector("->fd").connect(tap.connector("fd->"))
 208
 209         self.add_ip_address(fdnd, (base_addr%229), 30)
 210         self.add_ip_address(tap, (base_addr%230), 30)
 211
 212         # ROUTES
 213         self.add_route(node_netns, (base_addr%32), 27, (base_addr%229))
 214         self.add_route(node_netns, (base_addr%224), 30, (base_addr%229))
 215
 216         self.add_route(node_fdnd, (base_addr%32), 27, (base_addr%225))
 217         self.add_route(node_ss1, (base_addr%228), 30, (base_addr%226))
 218
 219         self.add_route(node_ss2, (base_addr%224), 30, (base_addr%34))
 220         self.add_route(node_ss2, (base_addr%228), 30, (base_addr%34))
 221         self.add_route(node_bs, (base_addr%224), 30, (base_addr%34))
 222         self.add_route(node_bs, (base_addr%228), 30, (base_addr%34))
 223
 224
 225         xml = exp_desc.to_xml()
 226         controller = ExperimentController(xml, self.root_dir)
 227         controller.start()
 228         while not controller.is_finished(app.guid):
 229             time.sleep(0.5)
 230         time.sleep(0.1)
 231         controller.stop()
 232         controller.shutdown()
 233
 234     def clean(self):
 235         #shutil.rmtree(self.root_dir)
 236         print self.root_dir
 237         pass
 238
 239 if __name__ == '__main__':
 240     example = WimaxOverlayExample()
 241     example.run()
 242     example.clean()
 243