a03f4efa92
These changes are incompatible with Python VPP API 1.2
There is now a new VPP Class and it can be used like:
from vpp_papi import VPP
jsonfiles = []
for root, dirnames, filenames in os.walk('../../../build-root/'):
if root.find('install-') == -1: continue
for filename in fnmatch.filter(filenames, '*.api.json'):
jsonfiles.append(os.path.join(root, filename))
vpp = VPP(jsonfiles)
rv = vpp.show_version()
print('RV', rv.program.decode().rstrip('\0x00'))
vpp.disconnect()
Change-Id: Ic92d226de2cf3626e750404012247e7fc24fb7fc
Signed-off-by: Ole Troan <ot@cisco.com>
402 lines
13 KiB
Python
Executable File
402 lines
13 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
from __future__ import print_function
|
|
import unittest, sys, threading, struct, logging, os
|
|
from vpp_papi import VPP
|
|
from ipaddress import *
|
|
import glob, json
|
|
|
|
papi_event = threading.Event()
|
|
import glob
|
|
|
|
import fnmatch
|
|
import os
|
|
|
|
jsonfiles = []
|
|
for root, dirnames, filenames in os.walk('../../../build-root/'):
|
|
if root.find('install-') == -1: continue
|
|
for filename in fnmatch.filter(filenames, '*.api.json'):
|
|
jsonfiles.append(os.path.join(root, filename))
|
|
|
|
class TestPAPI(unittest.TestCase):
|
|
show_version_msg = '''["show_version",
|
|
["u16", "_vl_msg_id"],
|
|
["u32", "client_index"],
|
|
["u32", "context"],
|
|
{"crc" : "0xf18f9480"}
|
|
]'''
|
|
|
|
ip_address_details_msg = '''["ip_address_details",
|
|
["u16", "_vl_msg_id"],
|
|
["u32", "client_index"],
|
|
["u32", "context"],
|
|
["u8", "ip", 16],
|
|
["u8", "prefix_length"],
|
|
{"crc" : "0x87d522a1"}
|
|
]'''
|
|
|
|
cli_inband_msg = '''["cli_inband",
|
|
["u16", "_vl_msg_id"],
|
|
["u32", "client_index"],
|
|
["u32", "context"],
|
|
["u32", "length"],
|
|
["u8", "cmd", 0, "length"],
|
|
{"crc" : "0x22345937"}
|
|
]'''
|
|
|
|
def test_adding_new_message_object(self):
|
|
p = json.loads(TestPAPI.show_version_msg)
|
|
msglist = VPP([])
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
|
|
# Verify that message can be retrieved
|
|
self.assertTrue(msglist['show_version'])
|
|
self.assertFalse(msglist['foobar'])
|
|
|
|
# Test duplicate
|
|
self.assertRaises(ValueError, msglist.add_message, p[0], p[1:])
|
|
|
|
# Look at return tuple
|
|
self.assertTrue(msglist.ret_tup('show_version'))
|
|
|
|
def test_adding_new_message_object_with_array(self):
|
|
p = json.loads(TestPAPI.ip_address_details_msg)
|
|
msglist = VPP([])
|
|
msglist.add_message(p[0], p[1:])
|
|
|
|
self.assertTrue(msglist['ip_address_details'])
|
|
|
|
def test_message_to_bytes(self):
|
|
msglist = VPP([])
|
|
p = json.loads(TestPAPI.show_version_msg)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
|
|
# Give me a byte string for given message and given arguments
|
|
|
|
b = msglist.encode(msgdef, {'_vl_msg_id' : 50, 'context' : 123 })
|
|
self.assertEqual(10, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(rv._0, 50)
|
|
self.assertEqual(rv.context, 123)
|
|
|
|
|
|
p = json.loads(TestPAPI.ip_address_details_msg)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
|
|
# Give me a byte string for given message and given arguments
|
|
b = msglist.encode(msgdef, {'_vl_msg_id' : 50, 'context' : 123,
|
|
'ip' : b'\xf0\xf1\xf2',
|
|
'prefix_length' : 12})
|
|
self.assertEqual(27, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
|
|
self.assertEqual(rv.context, 123)
|
|
self.assertEqual(rv.ip, b'\xf0\xf1\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
|
|
self.assertEqual(rv.prefix_length, 12)
|
|
|
|
p = json.loads(TestPAPI.cli_inband_msg)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
|
|
# Give me a byte string for given message and given arguments
|
|
b = msglist.encode(msgdef, { '_vl_msg_id' : 50, 'context' : 123,
|
|
'length' : 20, 'cmd' : 'show version verbose'})
|
|
self.assertEqual(34, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(rv._0, 50)
|
|
self.assertEqual(rv.context, 123)
|
|
self.assertEqual(rv.cmd.decode('ascii'), 'show version verbose')
|
|
|
|
variable_array_16_msg = '''["variable_array_16",
|
|
["u32", "length"],
|
|
["u16", "list", 0, "length"]
|
|
]'''
|
|
|
|
p = json.loads(variable_array_16_msg)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
|
|
# Give me a byte string for given message and given arguments
|
|
b = msglist.encode(msgdef, { 'list' : [1, 2], 'length' :2})
|
|
self.assertEqual(8, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(2, rv.length)
|
|
self.assertEqual([1,2], rv.list)
|
|
|
|
def test_add_new_types(self):
|
|
counter_type = '''["ip4_fib_counter",
|
|
["u32", "address"],
|
|
["u8", "address_length"],
|
|
["u64", "packets"],
|
|
["u64", "bytes"],
|
|
{"crc" : "0xb2739495"}
|
|
]'''
|
|
|
|
with_type_msg = '''["with_type_msg",
|
|
["u32", "length"],
|
|
["u16", "list", 0, "length"],
|
|
["ip4_fib_counter", "counter"]
|
|
|
|
]'''
|
|
|
|
# Add new type
|
|
msglist = VPP([])
|
|
p = json.loads(counter_type)
|
|
msglist.add_type(p[0], p[1:])
|
|
p = json.loads(with_type_msg)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
b = msglist.encode(msgdef, {'length' : 2, 'list' : [1,2],
|
|
'counter' : { 'address' : 4, 'address_length' : 12,
|
|
'packets': 1235, 'bytes' : 5678}})
|
|
self.assertEqual(29, len(b)) # feil
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(2, rv.length)
|
|
self.assertEqual(5678, rv.counter.bytes)
|
|
|
|
def test_add_new_compound_type_with_array(self):
|
|
counter_type = '''["ip4_fib_counter",
|
|
["u32", "address"],
|
|
["u8", "address_length"],
|
|
["u64", "packets"],
|
|
["u64", "bytes"],
|
|
{"crc" : "0xb2739495"}
|
|
]'''
|
|
|
|
with_type_msg = '''["with_type_msg",
|
|
["u32", "length"],
|
|
["u16", "list", 0, "length"],
|
|
["ip4_fib_counter", "counter", 2]
|
|
|
|
]'''
|
|
|
|
# Add new type
|
|
msglist = VPP([])
|
|
p = json.loads(counter_type)
|
|
msglist.add_type(p[0], p[1:])
|
|
p = json.loads(with_type_msg)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
b = msglist.encode(msgdef, {'length' : 2, 'list' : [1,2],
|
|
'counter' : [{ 'address' : 4, 'address_length' : 12,
|
|
'packets': 1235, 'bytes' : 5678},
|
|
{ 'address' : 111, 'address_length' : 222,
|
|
'packets': 333, 'bytes' : 444}]})
|
|
self.assertEqual(50, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual([1,2], rv.list)
|
|
self.assertEqual(1235, rv.counter[0].packets)
|
|
|
|
with_type_variable_msg = '''["with_type_variable_msg",
|
|
["u32", "length"],
|
|
["ip4_fib_counter", "counter", 0, "length"]
|
|
|
|
]'''
|
|
|
|
p = json.loads(with_type_variable_msg)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
b = msglist.encode(msgdef, {'length' : 2,
|
|
'counter' : [{ 'address' : 4, 'address_length' : 12,
|
|
'packets': 1235, 'bytes' : 5678},
|
|
{ 'address' : 111, 'address_length' : 222,
|
|
'packets': 333, 'bytes' : 444}]})
|
|
self.assertEqual(46, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(2, rv.length)
|
|
self.assertEqual(1235, rv.counter[0].packets)
|
|
self.assertEqual(333, rv.counter[1].packets)
|
|
|
|
|
|
def test_compound_data_type(self):
|
|
# Normal field
|
|
# Fixed array
|
|
# Variable array
|
|
pass
|
|
|
|
def test_return_tuple(self):
|
|
# Normal field
|
|
# Fixed array
|
|
# Variable array
|
|
pass
|
|
|
|
def test_simple_array(self):
|
|
msglist = VPP([])
|
|
|
|
simple_byte_array = '''["simple_byte_array",
|
|
["u32", "length"],
|
|
["u8", "namecommand", 64]
|
|
|
|
]'''
|
|
p = json.loads(simple_byte_array)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
b = msglist.encode(msgdef, {'length': 2, 'namecommand': 'foobar'})
|
|
self.assertEqual(68, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(2, rv.length)
|
|
|
|
simple_array = '''["simple_array",
|
|
["u32", "length"],
|
|
["u32", "list", 2]
|
|
|
|
]'''
|
|
p = json.loads(simple_array)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
b = msglist.encode(msgdef, {'length': 2, 'list': [1,2]})
|
|
self.assertEqual(12, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(2, rv.length)
|
|
self.assertEqual([1,2], rv.list)
|
|
|
|
simple_variable_array = '''["simple_variable_array",
|
|
["u32", "length"],
|
|
["u32", "list", 0, "length"]
|
|
|
|
]'''
|
|
p = json.loads(simple_variable_array)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
b = msglist.encode(msgdef, {'length':2, 'list': [1,2]})
|
|
self.assertEqual(12, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(2, rv.length)
|
|
self.assertEqual([1,2], rv.list)
|
|
|
|
simple_variable_byte_array = '''["simple_variable_byte_array",
|
|
["u32", "length"],
|
|
["u8", "list", 0, "length"]
|
|
]'''
|
|
p = json.loads(simple_variable_byte_array)
|
|
msgdef =msglist.add_message(p[0], p[1:])
|
|
b = msglist.encode(msgdef, {'length': 6, 'list' : 'foobar'})
|
|
self.assertEqual(10, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(6, rv.length)
|
|
self.assertEqual('foobar', rv.list)
|
|
|
|
def test_argument_name(self):
|
|
msglist = VPP([])
|
|
|
|
|
|
simple_name = '''["simple_name",
|
|
["u32", "length"],
|
|
["u8", "name"]
|
|
]'''
|
|
p = json.loads(simple_name)
|
|
msgdef = msglist.add_message(p[0], p[1:])
|
|
b = msglist.encode(msgdef, {'length': 6, 'name': 1})
|
|
self.assertEqual(5, len(b))
|
|
rv = msglist.decode(msgdef, b)
|
|
self.assertEqual(6, rv.length)
|
|
self.assertEqual(1, rv.name)
|
|
|
|
class TestConnectedPAPI(unittest.TestCase):
|
|
def test_request_reply_function(self):
|
|
vpp = VPP(jsonfiles)
|
|
|
|
vpp.connect('test_vpp_papi2')
|
|
|
|
rv = vpp.show_version()
|
|
self.assertEqual(0, rv.retval)
|
|
print('RV', rv.program.decode().rstrip('\0x00'))
|
|
vpp.disconnect()
|
|
|
|
|
|
def test_dump_details_function(self):
|
|
vpp = VPP(jsonfiles)
|
|
vpp.connect('test_vpp_papi3')
|
|
|
|
rv = vpp.sw_interface_dump()
|
|
#self.assertEqual(0, rv.retval)
|
|
print('RV', rv)
|
|
vpp.disconnect()
|
|
|
|
def test_vla(self):
|
|
vpp = VPP(jsonfiles)
|
|
|
|
vpp.connect('test_vpp_papi3')
|
|
|
|
cmd = 'show version verbose'
|
|
rv = vpp.cli_inband(length=len(cmd), cmd=cmd)
|
|
self.assertEqual(0, rv.retval)
|
|
print('RV', rv.reply)
|
|
|
|
cmd = 'show vlib graph'
|
|
rv = vpp.cli_inband(length=len(cmd), cmd=cmd)
|
|
self.assertEqual(0, rv.retval)
|
|
print('RV', rv.reply)
|
|
vpp.disconnect()
|
|
|
|
def test_events(self):
|
|
vpp = VPP(jsonfiles)
|
|
|
|
vpp.connect('test_vpp_papi3')
|
|
|
|
vpp.register_event_callback(event_handler)
|
|
|
|
rv = vpp.want_interface_events(enable_disable = True)
|
|
self.assertEqual(0, rv.retval)
|
|
print('RV', rv)
|
|
|
|
rv = vpp.create_loopback()
|
|
print('RV', rv)
|
|
self.assertEqual(0, rv.retval)
|
|
|
|
rv = vpp.sw_interface_set_flags(sw_if_index = 1, admin_up_down = 1)
|
|
print('RV', rv)
|
|
self.assertEqual(0, rv.retval)
|
|
rv = vpp.sw_interface_set_flags(sw_if_index = 1, admin_up_down = 0)
|
|
print('RV', rv)
|
|
self.assertEqual(0, rv.retval)
|
|
self.assertEqual(papi_event.wait(10), True)
|
|
|
|
vpp.disconnect()
|
|
|
|
def event_handler(msgname, result):
|
|
print('IN EVENT HANDLER:', msgname, result)
|
|
papi_event.set()
|
|
|
|
class TestACL(unittest.TestCase):
|
|
def test_acl_create(self):
|
|
vpp = VPP(jsonfiles)
|
|
|
|
vpp.connect('acl-test')
|
|
|
|
rv = vpp.acl_plugin_get_version()
|
|
print('RV', rv)
|
|
self.assertEqual(rv.major, 0)
|
|
self.assertEqual(rv.minor, 1)
|
|
|
|
rv = vpp.acl_add_replace(acl_index = 0xFFFFFFFF,
|
|
r = [{
|
|
"is_permit" : 1,
|
|
"is_ipv6" : 0,
|
|
"proto" : 6,
|
|
"srcport_or_icmptype_first" : 80,
|
|
}],
|
|
count = 1)
|
|
print ('RV', rv)
|
|
rv = vpp.acl_add_replace(acl_index = 0xFFFFFFFF,
|
|
r = [{
|
|
"is_permit" : 1,
|
|
"is_ipv6" : 0,
|
|
"proto" : 6,
|
|
"srcport_or_icmptype_first" : 81,
|
|
}],
|
|
count = 1)
|
|
self.assertEqual(rv.retval, 0)
|
|
print ('RV', rv)
|
|
ai = rv.acl_index
|
|
rv = vpp.acl_dump()
|
|
print ('RV', rv)
|
|
|
|
#rv = vpp.acl_del(acl_index = ai)
|
|
#self.assertEqual(rv.retval, 0)
|
|
|
|
#rv = vpp.acl_dump()
|
|
#self.assertEqual([], vpp.acl_dump())
|
|
|
|
vpp.disconnect()
|
|
|
|
def test_status(self):
|
|
vpp = VPP(jsonfiles)
|
|
vpp.status()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|