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