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