3 from __future__ import print_function
4 import unittest, sys, threading, struct, logging, os
5 from vpp_papi import VPP
6 from ipaddress import *
9 papi_event = threading.Event()
16 for root, dirnames, filenames in os.walk('../../../build-root/'):
17 if root.find('install-') == -1: continue
18 for filename in fnmatch.filter(filenames, '*.api.json'):
19 jsonfiles.append(os.path.join(root, filename))
21 class TestPAPI(unittest.TestCase):
22 show_version_msg = '''["show_version",
23 ["u16", "_vl_msg_id"],
24 ["u32", "client_index"],
26 {"crc" : "0xf18f9480"}
29 ip_address_details_msg = '''["ip_address_details",
30 ["u16", "_vl_msg_id"],
31 ["u32", "client_index"],
34 ["u8", "prefix_length"],
35 {"crc" : "0x87d522a1"}
38 cli_inband_msg = '''["cli_inband",
39 ["u16", "_vl_msg_id"],
40 ["u32", "client_index"],
43 ["u8", "cmd", 0, "length"],
44 {"crc" : "0x22345937"}
47 def test_adding_new_message_object(self):
48 p = json.loads(TestPAPI.show_version_msg)
49 msglist = VPP(testmode=json)
50 msgdef = msglist.add_message(p[0], p[1:])
52 # Verify that message can be retrieved
53 self.assertTrue(msglist['show_version'])
54 self.assertFalse(msglist['foobar'])
57 self.assertRaises(ValueError, msglist.add_message, p[0], p[1:])
59 # Look at return tuple
60 self.assertTrue(msglist.ret_tup('show_version'))
62 def test_adding_new_message_object_with_array(self):
63 p = json.loads(TestPAPI.ip_address_details_msg)
64 msglist = VPP(testmode=True)
65 msglist.add_message(p[0], p[1:])
67 self.assertTrue(msglist['ip_address_details'])
69 def test_message_to_bytes(self):
70 msglist = VPP(testmode=True)
71 p = json.loads(TestPAPI.show_version_msg)
72 msgdef = msglist.add_message(p[0], p[1:])
74 # Give me a byte string for given message and given arguments
76 b = msglist.encode(msgdef, {'_vl_msg_id' : 50, 'context' : 123 })
77 self.assertEqual(10, len(b))
78 rv = msglist.decode(msgdef, b)
79 self.assertEqual(rv._0, 50)
80 self.assertEqual(rv.context, 123)
83 p = json.loads(TestPAPI.ip_address_details_msg)
84 msgdef = msglist.add_message(p[0], p[1:])
86 # Give me a byte string for given message and given arguments
87 b = msglist.encode(msgdef, {'_vl_msg_id' : 50, 'context' : 123,
88 'ip' : b'\xf0\xf1\xf2',
89 'prefix_length' : 12})
90 self.assertEqual(27, len(b))
91 rv = msglist.decode(msgdef, b)
93 self.assertEqual(rv.context, 123)
94 self.assertEqual(rv.ip, b'\xf0\xf1\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
95 self.assertEqual(rv.prefix_length, 12)
97 p = json.loads(TestPAPI.cli_inband_msg)
98 msgdef = msglist.add_message(p[0], p[1:])
100 # Give me a byte string for given message and given arguments
101 b = msglist.encode(msgdef, { '_vl_msg_id' : 50, 'context' : 123,
102 'length' : 20, 'cmd' : 'show version verbose'})
103 self.assertEqual(34, len(b))
104 rv = msglist.decode(msgdef, b)
105 self.assertEqual(rv._0, 50)
106 self.assertEqual(rv.context, 123)
107 self.assertEqual(rv.cmd.decode('ascii'), 'show version verbose')
109 variable_array_16_msg = '''["variable_array_16",
111 ["u16", "list", 0, "length"]
114 p = json.loads(variable_array_16_msg)
115 msgdef = msglist.add_message(p[0], p[1:])
117 # Give me a byte string for given message and given arguments
118 b = msglist.encode(msgdef, { 'list' : [1, 2], 'length' :2})
119 self.assertEqual(8, len(b))
120 rv = msglist.decode(msgdef, b)
121 self.assertEqual(2, rv.length)
122 self.assertEqual([1,2], rv.list)
124 def test_add_new_types(self):
125 counter_type = '''["ip4_fib_counter",
127 ["u8", "address_length"],
130 {"crc" : "0xb2739495"}
133 with_type_msg = '''["with_type_msg",
135 ["u16", "list", 0, "length"],
136 ["vl_api_ip4_fib_counter_t", "counter"]
140 msglist = VPP(testmode=True)
141 p = json.loads(counter_type)
142 msglist.add_type(p[0], p[1:])
143 p = json.loads(with_type_msg)
144 msgdef = msglist.add_message(p[0], p[1:])
145 b = msglist.encode(msgdef, {'length' : 2, 'list' : [1,2],
146 'counter' : { 'address' : 4, 'address_length' : 12,
147 'packets': 1235, 'bytes' : 5678}})
148 self.assertEqual(29, len(b)) # feil
149 rv = msglist.decode(msgdef, b)
150 self.assertEqual(2, rv.length)
151 self.assertEqual(5678, rv.counter.bytes)
153 def test_add_new_compound_type_with_array(self):
154 counter_type = '''["ip4_fib_counter",
156 ["u8", "address_length"],
159 {"crc" : "0xb2739495"}
162 with_type_msg = '''["with_type_msg",
164 ["u16", "list", 0, "length"],
165 ["vl_api_ip4_fib_counter_t", "counter", 2]
170 msglist = VPP(testmode=True)
171 p = json.loads(counter_type)
172 msglist.add_type(p[0], p[1:])
173 p = json.loads(with_type_msg)
174 msgdef = msglist.add_message(p[0], p[1:])
175 b = msglist.encode(msgdef, {'length' : 2, 'list' : [1,2],
176 'counter' : [{ 'address' : 4, 'address_length' : 12,
177 'packets': 1235, 'bytes' : 5678},
178 { 'address' : 111, 'address_length' : 222,
179 'packets': 333, 'bytes' : 444}]})
180 self.assertEqual(50, len(b))
181 rv = msglist.decode(msgdef, b)
182 self.assertEqual([1,2], rv.list)
183 self.assertEqual(1235, rv.counter[0].packets)
185 with_type_variable_msg = '''["with_type_variable_msg",
187 ["vl_api_ip4_fib_counter_t", "counter", 0, "length"]
191 p = json.loads(with_type_variable_msg)
192 msgdef = msglist.add_message(p[0], p[1:])
193 b = msglist.encode(msgdef, {'length' : 2,
194 'counter' : [{ 'address' : 4, 'address_length' : 12,
195 'packets': 1235, 'bytes' : 5678},
196 { 'address' : 111, 'address_length' : 222,
197 'packets': 333, 'bytes' : 444}]})
198 self.assertEqual(46, len(b))
199 rv = msglist.decode(msgdef, b)
200 self.assertEqual(2, rv.length)
201 self.assertEqual(1235, rv.counter[0].packets)
202 self.assertEqual(333, rv.counter[1].packets)
204 def test_simple_array(self):
205 msglist = VPP(testmode=True)
207 simple_byte_array = '''["simple_byte_array",
209 ["u8", "namecommand", 64]
212 p = json.loads(simple_byte_array)
213 msgdef = msglist.add_message(p[0], p[1:])
214 b = msglist.encode(msgdef, {'length': 2, 'namecommand': 'foobar'})
215 self.assertEqual(68, len(b))
216 rv = msglist.decode(msgdef, b)
217 self.assertEqual(2, rv.length)
219 simple_array = '''["simple_array",
224 p = json.loads(simple_array)
225 msgdef = msglist.add_message(p[0], p[1:])
226 b = msglist.encode(msgdef, {'length': 2, 'list': [1,2]})
227 self.assertEqual(12, len(b))
228 rv = msglist.decode(msgdef, b)
229 self.assertEqual(2, rv.length)
230 self.assertEqual([1,2], rv.list)
232 simple_variable_array = '''["simple_variable_array",
234 ["u32", "list", 0, "length"]
237 p = json.loads(simple_variable_array)
238 msgdef = msglist.add_message(p[0], p[1:])
239 b = msglist.encode(msgdef, {'length':2, 'list': [1,2]})
240 self.assertEqual(12, len(b))
241 rv = msglist.decode(msgdef, b)
242 self.assertEqual(2, rv.length)
243 self.assertEqual([1,2], rv.list)
245 simple_variable_byte_array = '''["simple_variable_byte_array",
247 ["u8", "list", 0, "length"]
249 p = json.loads(simple_variable_byte_array)
250 msgdef =msglist.add_message(p[0], p[1:])
251 b = msglist.encode(msgdef, {'length': 6, 'list' : 'foobar'})
252 self.assertEqual(10, len(b))
253 rv = msglist.decode(msgdef, b)
254 self.assertEqual(6, rv.length)
255 self.assertEqual('foobar', rv.list)
257 def test_old_vla_array(self):
258 msglist = VPP(testmode = True)
261 vla_byte_array = '''["vla_byte_array",
264 ["u32", "propercount"],
265 ["u8", "propermask", 0, "propercount"],
266 ["u8", "oldmask", 0],
267 {"crc" : "0xb2739495"}
269 p = json.loads(vla_byte_array)
270 msgdef = msglist.add_message(p[0], p[1:])
271 b = msglist.encode(msgdef, {'list' : [123, 456], 'oldmask': b'foobar',
273 'propermask' : [8,9]})
274 self.assertEqual(24, len(b))
275 rv = msglist.decode(msgdef, b)
276 self.assertEqual(b'foobar', rv.oldmask)
278 def test_old_vla_array_not_last_member(self):
279 msglist = VPP(testmode = True)
282 vla_byte_array = '''["vla_byte_array",
283 ["u8", "oldmask", 0],
285 {"crc" : "0xb2739495"}
287 p = json.loads(vla_byte_array)
288 self.assertRaises(ValueError, msglist.add_message, p[0], p[1:])
290 def test_old_vla_array_u32(self):
291 msglist = VPP(testmode = True)
294 vla_byte_array = '''["vla_byte_array",
296 ["u32", "oldmask", 0],
297 {"crc" : "0xb2739495"}
299 p = json.loads(vla_byte_array)
300 msgdef = msglist.add_message(p[0], p[1:])
301 b = msglist.encode(msgdef, {'foobar' : 123, 'oldmask': [123, 456, 789]})
302 self.assertEqual(16, len(b))
303 rv = msglist.decode(msgdef, b)
304 self.assertEqual([123, 456, 789], rv.oldmask)
306 def test_old_vla_array_compound(self):
307 msglist = VPP(testmode = True)
310 counter_type = '''["ip4_fib_counter",
312 ["u8", "address_length"],
315 {"crc" : "0xb2739495"}
318 vla_byte_array = '''["vla_byte_array",
319 ["vl_api_ip4_fib_counter_t", "counter", 0],
320 {"crc" : "0xb2739495"}
323 p = json.loads(counter_type)
324 msglist.add_type(p[0], p[1:])
326 p = json.loads(vla_byte_array)
327 with self.assertRaises(NotImplementedError):
328 msgdef = msglist.add_message(p[0], p[1:])
330 def test_array_count_not_previous(self):
331 msglist = VPP(testmode = True)
334 vla_byte_array = '''["vla_byte_array",
337 ["u32", "lst", 0, "count"],
338 {"crc" : "0xb2739495"}
341 p = json.loads(vla_byte_array)
342 msgdef = msglist.add_message(p[0], p[1:])
343 b = msglist.encode(msgdef, {'count': 3, 'lst': [1,2,3], 'filler' : 1 })
344 rv = msglist.decode(msgdef, b)
345 self.assertEqual(rv.lst, [1,2,3])
347 def test_argument_name(self):
348 msglist = VPP(testmode=True)
351 simple_name = '''["simple_name",
355 p = json.loads(simple_name)
356 msgdef = msglist.add_message(p[0], p[1:])
357 b = msglist.encode(msgdef, {'length': 6, 'name': 1})
358 self.assertEqual(5, len(b))
359 rv = msglist.decode(msgdef, b)
360 self.assertEqual(6, rv.length)
361 self.assertEqual(1, rv.name)
363 class TestConnectedPAPI(unittest.TestCase):
364 def test_request_reply_function(self):
367 vpp.connect('test_vpp_papi2')
369 rv = vpp.show_version()
370 self.assertEqual(0, rv.retval)
371 self.assertEqual('vpe', rv.program.decode().rstrip('\0x00'))
375 def test_dump_details_function(self):
377 vpp.connect('test_vpp_papi3')
379 rv = vpp.sw_interface_dump()
380 #self.assertEqual(0, rv.retval)
387 vpp.connect('test_vpp_papi3')
389 cmd = 'show version verbose'
390 rv = vpp.cli_inband(length=len(cmd), cmd=cmd)
391 self.assertEqual(0, rv.retval)
392 print('RV', rv.reply)
394 cmd = 'show vlib graph'
395 rv = vpp.cli_inband(length=len(cmd), cmd=cmd)
396 self.assertEqual(0, rv.retval)
397 print('RV', rv.reply)
400 def test_events(self):
403 vpp.connect('test_vpp_papi3')
405 vpp.register_event_callback(event_handler)
407 rv = vpp.want_interface_events(enable_disable = True)
408 self.assertEqual(0, rv.retval)
411 rv = vpp.create_loopback()
413 self.assertEqual(0, rv.retval)
415 rv = vpp.sw_interface_set_flags(sw_if_index = 1, admin_up_down = 1)
417 self.assertEqual(0, rv.retval)
418 rv = vpp.sw_interface_set_flags(sw_if_index = 1, admin_up_down = 0)
420 self.assertEqual(0, rv.retval)
421 self.assertEqual(papi_event.wait(10), True)
425 def event_handler(msgname, result):
426 print('IN EVENT HANDLER:', msgname, result)
429 class TestACL(unittest.TestCase):
430 def test_acl_create(self):
433 vpp.connect('acl-test')
435 rv = vpp.acl_plugin_get_version()
437 self.assertEqual(rv.major, 1)
438 self.assertEqual(rv.minor, 1)
440 rv = vpp.acl_add_replace(acl_index = 0xFFFFFFFF,
445 "srcport_or_icmptype_first" : 80,
449 rv = vpp.acl_add_replace(acl_index = 0xFFFFFFFF,
454 "srcport_or_icmptype_first" : 81,
457 self.assertEqual(rv.retval, 0)
463 #rv = vpp.acl_del(acl_index = ai)
464 #self.assertEqual(rv.retval, 0)
467 #self.assertEqual([], vpp.acl_dump())
471 def test_status(self):
475 def test_acl_interface_get(self):
478 vpp.connect('test_vpp_papi2')
480 rv = vpp.macip_acl_interface_get()
486 if __name__ == '__main__':