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