test/testbeds/netns/execute.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 import getpass
   5 from nepi.util.constants import ApplicationStatus as AS
   6 from nepi.testbeds import netns
   7 import os
   8 import shutil
   9 import tempfile
  10 import test_util
  11 import time
  12 import unittest
  13
  14 class NetnsExecuteTestCase(unittest.TestCase):
  15     def setUp(self):
  16         self.root_dir = tempfile.mkdtemp()
  17
  18     @test_util.skipUnless(os.getuid() == 0, "Test requires root privileges")
  19     def test_run_ping_if(self):
  20         user = getpass.getuser()
  21         testbed_version = "01"
  22         instance = netns.TestbedController(testbed_version)
  23         instance.defer_configure("homeDirectory", self.root_dir)
  24         instance.defer_create(2, "Node")
  25         instance.defer_create(3, "Node")
  26         instance.defer_create(4, "NodeInterface")
  27         instance.defer_create_set(4, "up", True)
  28         instance.defer_connect(2, "devs", 4, "node")
  29         instance.defer_add_address(4, "10.0.0.1", 24, None)
  30         instance.defer_create(5, "NodeInterface")
  31         instance.defer_create_set(5, "up", True)
  32         instance.defer_connect(3, "devs", 5, "node")
  33         instance.defer_add_address(5, "10.0.0.2", 24, None)
  34         instance.defer_create(6, "Switch")
  35         instance.defer_create_set(6, "up", True)
  36         instance.defer_connect(4, "switch", 6, "devs")
  37         instance.defer_connect(5, "switch", 6, "devs")
  38         instance.defer_create(7, "Application")
  39         instance.defer_create_set(7, "command", "ping -qc1 10.0.0.2")
  40         instance.defer_create_set(7, "user", user)
  41         instance.defer_add_trace(7, "stdout")
  42         instance.defer_connect(7, "node", 2, "apps")
  43
  44         instance.do_setup()
  45         instance.do_create()
  46         instance.do_connect_init()
  47         instance.do_connect_compl()
  48         instance.do_preconfigure()
  49         instance.do_configure()
  50         instance.do_prestart()
  51         instance.start()
  52         while instance.status(7) != AS.STATUS_FINISHED:
  53             time.sleep(0.5)
  54         ping_result = instance.trace(7, "stdout")
  55         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  56
  57 --- 10.0.0.2 ping statistics ---
  58 1 packets transmitted, 1 received, 0% packet loss, time 0ms
  59 """
  60         self.assertTrue(ping_result.startswith(comp_result))
  61         instance.stop()
  62         instance.shutdown()
  63
  64     @test_util.skipUnless(os.getuid() == 0, "Test requires root privileges")
  65     def test_run_ping_p2pif(self):
  66         user = getpass.getuser()
  67         testbed_version = "01"
  68         instance = netns.TestbedController(testbed_version)
  69         instance.defer_configure("homeDirectory", self.root_dir)
  70         instance.defer_create(2, "Node")
  71         instance.defer_create(3, "Node")
  72         instance.defer_create(4, "P2PNodeInterface")
  73         instance.defer_create_set(4, "up", True)
  74         instance.defer_connect(2, "devs", 4, "node")
  75         instance.defer_add_address(4, "10.0.0.1", 24, None)
  76         instance.defer_create(5, "P2PNodeInterface")
  77         instance.defer_create_set(5, "up", True)
  78         instance.defer_connect(3, "devs", 5, "node")
  79         instance.defer_add_address(5, "10.0.0.2", 24, None)
  80         instance.defer_connect(4, "p2p", 5, "p2p")
  81         instance.defer_create(6, "Application")
  82         instance.defer_create_set(6, "command", "ping -qc1 10.0.0.2")
  83         instance.defer_create_set(6, "user", user)
  84         instance.defer_add_trace(6, "stdout")
  85         instance.defer_connect(6, "node", 2, "apps")
  86
  87         instance.do_setup()
  88         instance.do_create()
  89         instance.do_connect_init()
  90         instance.do_connect_compl()
  91         instance.do_preconfigure()
  92         instance.do_configure()
  93         instance.do_prestart()
  94         instance.start()
  95         while instance.status(6) != AS.STATUS_FINISHED:
  96             time.sleep(0.5)
  97         ping_result = instance.trace(6, "stdout")
  98         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  99
 100 --- 10.0.0.2 ping statistics ---
 101 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 102 """
 103         self.assertTrue(ping_result.startswith(comp_result))
 104         instance.stop()
 105         instance.shutdown()
 106
 107     @test_util.skipUnless(os.getuid() == 0, "Test requires root privileges")
 108     def test_run_ping_routing(self):
 109         user = getpass.getuser()
 110         testbed_version = "01"
 111         instance = netns.TestbedController(testbed_version)
 112         instance.defer_configure("homeDirectory", self.root_dir)
 113         instance.defer_create(2, "Node")
 114         instance.defer_create(3, "Node")
 115         instance.defer_create(4, "Node")
 116         instance.defer_create(5, "NodeInterface")
 117         instance.defer_create_set(5, "up", True)
 118         instance.defer_connect(2, "devs", 5, "node")
 119         instance.defer_add_address(5, "10.0.0.1", 24, None)
 120         instance.defer_create(6, "NodeInterface")
 121         instance.defer_create_set(6, "up", True)
 122         instance.defer_connect(3, "devs", 6, "node")
 123         instance.defer_add_address(6, "10.0.0.2", 24, None)
 124         instance.defer_create(7, "NodeInterface")
 125         instance.defer_create_set(7, "up", True)
 126         instance.defer_connect(3, "devs", 7, "node")
 127         instance.defer_add_address(7, "10.0.1.1", 24, None)
 128         instance.defer_create(8, "NodeInterface")
 129         instance.defer_create_set(8, "up", True)
 130         instance.defer_connect(4, "devs", 8, "node")
 131         instance.defer_add_address(8, "10.0.1.2", 24, None)
 132         instance.defer_create(9, "Switch")
 133         instance.defer_create_set(9, "up", True)
 134         instance.defer_connect(5, "switch", 9, "devs")
 135         instance.defer_connect(6, "switch", 9, "devs")
 136         instance.defer_create(10, "Switch")
 137         instance.defer_create_set(10, "up", True)
 138         instance.defer_connect(7, "switch", 10, "devs")
 139         instance.defer_connect(8, "switch", 10, "devs")
 140         instance.defer_create(11, "Application")
 141         instance.defer_create_set(11, "command", "ping -qc1 10.0.1.2")
 142         instance.defer_create_set(11, "user", user)
 143         instance.defer_add_trace(11, "stdout")
 144         instance.defer_connect(11, "node", 2, "apps")
 145
 146         instance.defer_add_route(2, "10.0.1.0", 24, "10.0.0.2")
 147         instance.defer_add_route(4, "10.0.0.0", 24, "10.0.1.1")
 148
 149         instance.do_setup()
 150         instance.do_create()
 151         instance.do_connect_init()
 152         instance.do_connect_compl()
 153         instance.do_preconfigure()
 154         instance.do_configure()
 155         instance.do_prestart()
 156         instance.start()
 157         while instance.status(11) != AS.STATUS_FINISHED:
 158             time.sleep(0.5)
 159         ping_result = instance.trace(11, "stdout")
 160         comp_result = """PING 10.0.1.2 (10.0.1.2) 56(84) bytes of data.
 161
 162 --- 10.0.1.2 ping statistics ---
 163 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 164 """
 165         self.assertTrue(ping_result.startswith(comp_result))
 166         instance.stop()
 167         instance.shutdown()
 168
 169     @test_util.skipUnless(os.getuid() == 0, "Test requires root privileges")
 170     def test_node_pcap_trace(self):
 171         user = getpass.getuser()
 172         testbed_version = "01"
 173         instance = netns.TestbedController(testbed_version)
 174         instance.defer_configure("homeDirectory", self.root_dir)
 175         instance.defer_create(2, "Node")
 176         instance.defer_add_trace(2, "pcap")
 177         instance.defer_create(3, "Node")
 178         instance.defer_create(4, "P2PNodeInterface")
 179         instance.defer_create_set(4, "up", True)
 180         instance.defer_connect(2, "devs", 4, "node")
 181         instance.defer_add_address(4, "10.0.0.1", 24, None)
 182         instance.defer_create(5, "P2PNodeInterface")
 183         instance.defer_create_set(5, "up", True)
 184         instance.defer_connect(3, "devs", 5, "node")
 185         instance.defer_add_address(5, "10.0.0.2", 24, None)
 186         instance.defer_connect(4, "p2p", 5, "p2p")
 187         instance.defer_create(6, "Application")
 188         instance.defer_add_trace(6, "stdout")
 189         instance.defer_create_set(6, "command", "ping -qc5 10.0.0.2")
 190         instance.defer_create_set(6, "user", user)
 191         instance.defer_connect(6, "node", 2, "apps")
 192
 193         instance.do_setup()
 194         instance.do_create()
 195         instance.do_connect_init()
 196         instance.do_connect_compl()
 197         instance.do_preconfigure()
 198         instance.do_configure()
 199         instance.do_prestart()
 200         instance.start()
 201         while instance.status(6) != AS.STATUS_FINISHED:
 202             time.sleep(0.5)
 203         pcap_result = instance.trace(2, "pcap")
 204         self.assertEquals(len(pcap_result), 1024)
 205         instance.stop()
 206         instance.shutdown()
 207
 208     def tearDown(self):
 209         try:
 210             shutil.rmtree(self.root_dir)
 211         except:
 212             # retry
 213             time.sleep(0.1)
 214             shutil.rmtree(self.root_dir)
 215
 216 if __name__ == '__main__':
 217     unittest.main()
 218