test/test_memif.py

   1 import socket
   2 import unittest
   3
   4 from scapy.layers.l2 import Ether
   5 from scapy.layers.inet import IP, ICMP
   6 import six
   7
   8 from framework import VppTestCase, VppTestRunner, running_extended_tests
   9 from remote_test import RemoteClass, RemoteVppTestCase
  10 from vpp_memif import MEMIF_MODE, MEMIF_ROLE, remove_all_memif_vpp_config, \
  11     VppSocketFilename, VppMemif
  12 from vpp_ip_route import VppIpRoute, VppRoutePath
  13
  14
  15 @unittest.skipIf(True, "doesn't work with VppEnums")
  16 class TestMemif(VppTestCase):
  17     """ Memif Test Case """
  18
  19     @classmethod
  20     def setUpClass(cls):
  21         # fork new process before client connects to VPP
  22         cls.remote_test = RemoteClass(RemoteVppTestCase)
  23         cls.remote_test.start_remote()
  24         cls.remote_test.set_request_timeout(10)
  25         super(TestMemif, cls).setUpClass()
  26         cls.remote_test.setUpClass(cls.tempdir)
  27         cls.create_pg_interfaces(range(1))
  28         for pg in cls.pg_interfaces:
  29             pg.config_ip4()
  30             pg.admin_up()
  31             pg.resolve_arp()
  32
  33     @classmethod
  34     def tearDownClass(cls):
  35         cls.remote_test.tearDownClass()
  36         cls.remote_test.quit_remote()
  37         for pg in cls.pg_interfaces:
  38             pg.unconfig_ip4()
  39             pg.set_table_ip4(0)
  40             pg.admin_down()
  41         super(TestMemif, cls).tearDownClass()
  42
  43     def tearDown(self):
  44         remove_all_memif_vpp_config(self)
  45         remove_all_memif_vpp_config(self.remote_test)
  46         super(TestMemif, self).tearDown()
  47
  48     def _check_socket_filename(self, dump, socket_id, filename):
  49         for d in dump:
  50             if (d.socket_id == socket_id) and (
  51                     d.socket_filename.rstrip(b"\0") == filename):
  52                 return True
  53         return False
  54
  55     def test_memif_socket_filename_add_del(self):
  56         """ Memif socket filename add/del """
  57
  58         # dump default socket filename
  59         dump = self.vapi.memif_socket_filename_dump()
  60         self.assertTrue(
  61             self._check_socket_filename(
  62                 dump, 0, b"%s/memif.sock" % six.ensure_binary(
  63                     self.tempdir, encoding='utf-8')))
  64
  65         memif_sockets = []
  66         # existing path
  67         memif_sockets.append(
  68             VppSocketFilename(
  69                 self, 1, b"%s/memif1.sock" % six.ensure_binary(
  70                     self.tempdir, encoding='utf-8')))
  71         # default path (test tempdir)
  72         memif_sockets.append(
  73             VppSocketFilename(
  74                 self,
  75                 2,
  76                 b"memif2.sock",
  77                 add_default_folder=True))
  78         # create new folder in default folder
  79         memif_sockets.append(
  80             VppSocketFilename(
  81                 self,
  82                 3,
  83                 b"sock/memif3.sock",
  84                 add_default_folder=True))
  85
  86         for sock in memif_sockets:
  87             sock.add_vpp_config()
  88             dump = sock.query_vpp_config()
  89             self.assertTrue(
  90                 self._check_socket_filename(
  91                     dump,
  92                     sock.socket_id,
  93                     sock.socket_filename))
  94
  95         for sock in memif_sockets:
  96             sock.remove_vpp_config()
  97
  98         dump = self.vapi.memif_socket_filename_dump()
  99         self.assertTrue(
 100             self._check_socket_filename(
 101                 dump, 0, b"%s/memif.sock" % six.ensure_binary(
 102                     self.tempdir, encoding='utf-8')))
 103
 104     def _create_delete_test_one_interface(self, memif):
 105         memif.add_vpp_config()
 106
 107         dump = memif.query_vpp_config()
 108
 109         self.assertTrue(dump)
 110         self.assertEqual(dump.sw_if_index, memif.sw_if_index)
 111         self.assertEqual(dump.role, memif.role)
 112         self.assertEqual(dump.mode, memif.mode)
 113         if (memif.socket_id is not None):
 114             self.assertEqual(dump.socket_id, memif.socket_id)
 115
 116         memif.remove_vpp_config()
 117
 118         dump = memif.query_vpp_config()
 119
 120         self.assertFalse(dump)
 121
 122     def _connect_test_one_interface(self, memif):
 123         self.assertTrue(memif.wait_for_link_up(5))
 124         dump = memif.query_vpp_config()
 125
 126         if memif.role == MEMIF_ROLE.SLAVE:
 127             self.assertEqual(dump.ring_size, memif.ring_size)
 128             self.assertEqual(dump.buffer_size, memif.buffer_size)
 129         else:
 130             self.assertEqual(dump.ring_size, 1)
 131             self.assertEqual(dump.buffer_size, 0)
 132
 133     def _connect_test_interface_pair(self, memif0, memif1):
 134         memif0.add_vpp_config()
 135         memif1.add_vpp_config()
 136
 137         memif0.admin_up()
 138         memif1.admin_up()
 139
 140         self._connect_test_one_interface(memif0)
 141         self._connect_test_one_interface(memif1)
 142
 143         memif0.remove_vpp_config()
 144         memif1.remove_vpp_config()
 145
 146     def test_memif_create_delete(self):
 147         """ Memif create/delete interface """
 148
 149         memif = VppMemif(self, MEMIF_ROLE.SLAVE, MEMIF_MODE.ETHERNET)
 150         self._create_delete_test_one_interface(memif)
 151         memif.role = MEMIF_ROLE.MASTER
 152         self._create_delete_test_one_interface(memif)
 153
 154     def test_memif_create_custom_socket(self):
 155         """ Memif create with non-default socket filename """
 156
 157         memif_sockets = []
 158         # existing path
 159         memif_sockets.append(
 160             VppSocketFilename(
 161                 self, 1, b"%s/memif1.sock" % six.ensure_binary(
 162                     self.tempdir, encoding='utf-8')))
 163         # default path (test tempdir)
 164         memif_sockets.append(
 165             VppSocketFilename(
 166                 self,
 167                 2,
 168                 b"memif2.sock",
 169                 add_default_folder=True))
 170         # create new folder in default folder
 171         memif_sockets.append(
 172             VppSocketFilename(
 173                 self,
 174                 3,
 175                 b"sock/memif3.sock",
 176                 add_default_folder=True))
 177
 178         memif = VppMemif(self, MEMIF_ROLE.SLAVE, MEMIF_MODE.ETHERNET)
 179
 180         for sock in memif_sockets:
 181             sock.add_vpp_config()
 182             memif.socket_id = sock.socket_id
 183             memif.role = MEMIF_ROLE.SLAVE
 184             self._create_delete_test_one_interface(memif)
 185             memif.role = MEMIF_ROLE.MASTER
 186             self._create_delete_test_one_interface(memif)
 187
 188     def test_memif_connect(self):
 189         """ Memif connect """
 190         memif = VppMemif(self, MEMIF_ROLE.SLAVE,  MEMIF_MODE.ETHERNET,
 191                          ring_size=1024, buffer_size=2048)
 192
 193         remote_socket = VppSocketFilename(self.remote_test, 1,
 194                                           b"%s/memif.sock" % six.ensure_binary(
 195                                               self.tempdir, encoding='utf-8'))
 196         remote_socket.add_vpp_config()
 197
 198         remote_memif = VppMemif(self.remote_test, MEMIF_ROLE.MASTER,
 199                                 MEMIF_MODE.ETHERNET, socket_id=1,
 200                                 ring_size=1024, buffer_size=2048)
 201
 202         self._connect_test_interface_pair(memif, remote_memif)
 203
 204         memif.role = MEMIF_ROLE.MASTER
 205         remote_memif.role = MEMIF_ROLE.SLAVE
 206
 207         self._connect_test_interface_pair(memif, remote_memif)
 208
 209     def _create_icmp(self, pg, memif, num):
 210         pkts = []
 211         for i in range(num):
 212             pkt = (Ether(dst=pg.local_mac, src=pg.remote_mac) /
 213                    IP(src=pg.remote_ip4, dst=memif.ip4_addr) /
 214                    ICMP(id=memif.if_id, type='echo-request', seq=i))
 215             pkts.append(pkt)
 216         return pkts
 217
 218     def _verify_icmp(self, pg, memif, rx, seq):
 219         ip = rx[IP]
 220         self.assertEqual(ip.src, memif.ip4_addr)
 221         self.assertEqual(ip.dst, pg.remote_ip4)
 222         self.assertEqual(ip.proto, 1)
 223         icmp = rx[ICMP]
 224         self.assertEqual(icmp.type, 0)  # echo-reply
 225         self.assertEqual(icmp.id, memif.if_id)
 226         self.assertEqual(icmp.seq, seq)
 227
 228     def test_memif_ping(self):
 229         """ Memif ping """
 230
 231         memif = VppMemif(self, MEMIF_ROLE.SLAVE,  MEMIF_MODE.ETHERNET)
 232
 233         remote_socket = VppSocketFilename(self.remote_test, 1,
 234                                           b"%s/memif.sock" % six.ensure_binary(
 235                                               self.tempdir, encoding='utf-8'))
 236         remote_socket.add_vpp_config()
 237
 238         remote_memif = VppMemif(self.remote_test, MEMIF_ROLE.MASTER,
 239                                 MEMIF_MODE.ETHERNET, socket_id=1)
 240
 241         memif.add_vpp_config()
 242         memif.config_ip4()
 243         memif.admin_up()
 244
 245         remote_memif.add_vpp_config()
 246         remote_memif.config_ip4()
 247         remote_memif.admin_up()
 248
 249         self.assertTrue(memif.wait_for_link_up(5))
 250         self.assertTrue(remote_memif.wait_for_link_up(5))
 251
 252         # add routing to remote vpp
 253         VppIpRoute(self.remote_test, self.pg0._local_ip4_subnet, 24,
 254                    [VppRoutePath(memif.ip4_addr, 0xffffffff)]).add_vpp_config()
 255
 256         # create ICMP echo-request from local pg to remote memif
 257         packet_num = 10
 258         pkts = self._create_icmp(self.pg0, remote_memif, packet_num)
 259
 260         self.pg0.add_stream(pkts)
 261         self.pg_enable_capture(self.pg_interfaces)
 262         self.pg_start()
 263         capture = self.pg0.get_capture(packet_num, timeout=2)
 264         seq = 0
 265         for c in capture:
 266             self._verify_icmp(self.pg0, remote_memif, c, seq)
 267             seq += 1
 268
 269
 270 if __name__ == '__main__':
 271     unittest.main(testRunner=VppTestRunner)