diff options
Diffstat (limited to 'src/vpp-api/python')
| -rw-r--r-- | src/vpp-api/python/LICENSE.txt | 202 | ||||
| -rw-r--r-- | src/vpp-api/python/Makefile.am | 23 | ||||
| -rw-r--r-- | src/vpp-api/python/README.rst | 0 | ||||
| -rw-r--r-- | src/vpp-api/python/setup.cfg | 5 | ||||
| -rw-r--r-- | src/vpp-api/python/setup.py | 33 | ||||
| -rwxr-xr-x | src/vpp-api/python/tests/test_cli.py | 52 | ||||
| -rwxr-xr-x | src/vpp-api/python/tests/test_modules.py | 18 | ||||
| -rwxr-xr-x | src/vpp-api/python/tests/test_papi.py | 119 | ||||
| -rwxr-xr-x | src/vpp-api/python/tests/test_version.py | 35 | ||||
| -rwxr-xr-x | src/vpp-api/python/tests/test_vpp_papi2.py | 487 | ||||
| -rw-r--r-- | src/vpp-api/python/vpp_papi.py | 706 |
11 files changed, 1680 insertions, 0 deletions
diff --git a/src/vpp-api/python/LICENSE.txt b/src/vpp-api/python/LICENSE.txt new file mode 100644 index 00000000..8f71f43f --- /dev/null +++ b/src/vpp-api/python/LICENSE.txt @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/src/vpp-api/python/Makefile.am b/src/vpp-api/python/Makefile.am new file mode 100644 index 00000000..e6c064e1 --- /dev/null +++ b/src/vpp-api/python/Makefile.am @@ -0,0 +1,23 @@ +# Copyright (c) 2016 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +install-exec-local: + (cd $(srcdir) ; $(PYTHON) $(srcdir)/setup.py build \ + --build-base $(shell readlink -f $(builddir))/build \ + install \ + --root / \ + --prefix $(DESTDIR)$(prefix) \ + --single-version-externally-managed \ + --verbose \ + bdist_egg \ + --dist-dir=$(DESTDIR)$(prefix)) diff --git a/src/vpp-api/python/README.rst b/src/vpp-api/python/README.rst new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/vpp-api/python/README.rst diff --git a/src/vpp-api/python/setup.cfg b/src/vpp-api/python/setup.cfg new file mode 100644 index 00000000..79bc6784 --- /dev/null +++ b/src/vpp-api/python/setup.cfg @@ -0,0 +1,5 @@ +[bdist_wheel] +# This flag says that the code is written to work on both Python 2 and Python +# 3. If at all possible, it is good practice to do this. If you cannot, you +# will need to generate wheels for each Python version that you support. +universal=1 diff --git a/src/vpp-api/python/setup.py b/src/vpp-api/python/setup.py new file mode 100644 index 00000000..626dddee --- /dev/null +++ b/src/vpp-api/python/setup.py @@ -0,0 +1,33 @@ +# +# Copyright (c) 2016 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +try: + from setuptools import setup +except ImportError: + from distutils.core import setup + +setup (name = 'vpp_papi', + version = '1.4', + description = 'VPP Python binding', + author = 'Ole Troan', + author_email = 'ot@cisco.com', + url = 'https://wiki.fd.io/view/VPP/Python_API', + python_requires='>=2.7, >=3.3', + license = 'Apache-2.0', + test_suite = 'tests', + install_requires=['cffi >= 1.10'], + py_modules=['vpp_papi'], + long_description = '''VPP Python language binding.''', + zip_safe = True, +) diff --git a/src/vpp-api/python/tests/test_cli.py b/src/vpp-api/python/tests/test_cli.py new file mode 100755 index 00000000..66fb6943 --- /dev/null +++ b/src/vpp-api/python/tests/test_cli.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python + +from __future__ import print_function +import unittest, sys, time, threading, struct +import test_base +import vpp_papi +from ipaddress import * + +import glob, subprocess +class TestPAPI(unittest.TestCase): + @classmethod + def setUpClass(cls): + # + # Start main VPP process + cls.vpp_bin = glob.glob(test_base.scriptdir+'/../../../build-root/install-vpp*-native/vpp/bin/vpp')[0] + print("VPP BIN:", cls.vpp_bin) + cls.vpp = subprocess.Popen([cls.vpp_bin, "unix", "nodaemon"], stderr=subprocess.PIPE) + print('Started VPP') + # For some reason unless we let VPP start up the API cannot connect. + time.sleep(0.3) + @classmethod + def tearDownClass(cls): + cls.vpp.terminate() + + def setUp(self): + print("Connecting API") + r = vpp_papi.connect("test_papi") + self.assertEqual(r, 0) + + def tearDown(self): + r = vpp_papi.disconnect() + self.assertEqual(r, 0) + + # + # The tests themselves + # + + # + # Basic request / reply + # + def test_cli_request(self): + print(vpp_papi.cli_exec('show version verbose')) + #t = vpp_papi.cli_inband_request(len(cmd), cmd) + #print('T:',t) + #reply = t.reply[0].decode().rstrip('\x00') + #print(reply) + #program = t.program.decode().rstrip('\x00') + #self.assertEqual('vpe', program) + + +if __name__ == '__main__': + unittest.main() diff --git a/src/vpp-api/python/tests/test_modules.py b/src/vpp-api/python/tests/test_modules.py new file mode 100755 index 00000000..fdcd092c --- /dev/null +++ b/src/vpp-api/python/tests/test_modules.py @@ -0,0 +1,18 @@ +from __future__ import print_function +import unittest +import vpp_papi +import pot, snat +print('Plugins:') +vpp_papi.plugin_show() +r = vpp_papi.connect('ole') + +r = vpp_papi.show_version() +print('R:', r) + +r = snat.snat_interface_add_del_feature(1, 1, 1) +print('R:', r) + +list_name = 'foobar' +r = pot.pot_profile_add(0, 1, 123, 123, 0, 12, 0, 23, len(list_name), list_name) +print('R:', r) +vpp_papi.disconnect() diff --git a/src/vpp-api/python/tests/test_papi.py b/src/vpp-api/python/tests/test_papi.py new file mode 100755 index 00000000..8cbbfc59 --- /dev/null +++ b/src/vpp-api/python/tests/test_papi.py @@ -0,0 +1,119 @@ +from __future__ import print_function +import unittest, sys, time, threading, struct, logging, os +import vpp_papi +from ipaddress import * +scriptdir = os.path.dirname(os.path.realpath(__file__)) +papi_event = threading.Event() +print(vpp_papi.vpe.VL_API_SW_INTERFACE_SET_FLAGS) +def papi_event_handler(result): + if result.vl_msg_id == vpp_papi.vpe.VL_API_SW_INTERFACE_SET_FLAGS: + return + if result.vl_msg_id == vpp_papi.vpe.VL_API_VNET_INTERFACE_COUNTERS: + print('Interface counters', result) + return + if result.vl_msg_id == vpp_papi.vpe.VL_API_VNET_IP6_FIB_COUNTERS: + print('IPv6 FIB counters', result) + papi_event.set() + return + + print('Unknown message id:', result.vl_msg_id) + +import glob, subprocess +class TestPAPI(unittest.TestCase): + @classmethod + def setUpClass(cls): + # + # Start main VPP process + cls.vpp_bin = glob.glob(scriptdir+'/../../../build-root/install-vpp*-native/vpp/bin/vpp')[0] + print("VPP BIN:", cls.vpp_bin) + cls.vpp = subprocess.Popen([cls.vpp_bin, "unix", "nodaemon"], stderr=subprocess.PIPE) + print('Started VPP') + # For some reason unless we let VPP start up the API cannot connect. + time.sleep(0.3) + @classmethod + def tearDownClass(cls): + cls.vpp.terminate() + + def setUp(self): + print("Connecting API") + r = vpp_papi.connect("test_papi") + self.assertEqual(r, 0) + + def tearDown(self): + r = vpp_papi.disconnect() + self.assertEqual(r, 0) + + # + # The tests themselves + # + + # + # Basic request / reply + # + def test_show_version(self): + t = vpp_papi.show_version() + print('T', t); + program = t.program.decode().rstrip('\x00') + self.assertEqual('vpe', program) + + # + # Details / Dump + # + def test_details_dump(self): + t = vpp_papi.sw_interface_dump(0, b'') + print('Dump/details T', t) + + # + # Arrays + # + def test_arrays(self): + t = vpp_papi.vnet_get_summary_stats() + print('Summary stats', t) + print('Packets:', t.total_pkts[0]) + print('Packets:', t.total_pkts[1]) + # + # Variable sized arrays and counters + # + #@unittest.skip("stats") + def test_want_stats(self): + pid = 123 + vpp_papi.register_event_callback(papi_event_handler) + papi_event.clear() + + # Need to configure IPv6 to get som IPv6 FIB stats + t = vpp_papi.create_loopback('') + print(t) + self.assertEqual(t.retval, 0) + + ifindex = t.sw_if_index + addr = str(IPv6Address(u'1::1').packed) + t = vpp_papi.sw_interface_add_del_address(ifindex, 1, 1, 0, 16, addr) + print(t) + self.assertEqual(t.retval, 0) + + # Check if interface is up + # XXX: Add new API to query interface state based on ifindex, instead of dump all. + t = vpp_papi.sw_interface_set_flags(ifindex, 1, 1, 0) + self.assertEqual(t.retval, 0) + + t = vpp_papi.want_stats(True, pid) + + print (t) + + # + # Wait for some stats + # + self.assertEqual(papi_event.wait(15), True) + t = vpp_papi.want_stats(False, pid) + print (t) + + + # + # Plugins? + # + +if __name__ == '__main__': + #logging.basicConfig(level=logging.DEBUG) + unittest.main() +def test_papi(): + print('test') diff --git a/src/vpp-api/python/tests/test_version.py b/src/vpp-api/python/tests/test_version.py new file mode 100755 index 00000000..de39cc24 --- /dev/null +++ b/src/vpp-api/python/tests/test_version.py @@ -0,0 +1,35 @@ +from __future__ import print_function +import unittest, sys, time, threading, struct + +import vpp_papi +from ipaddress import * +import glob, subprocess +class TestPAPI(unittest.TestCase): + def setUp(self): + print("Connecting API") + r = vpp_papi.connect("test_papi") + self.assertEqual(r, 0) + + def tearDown(self): + r = vpp_papi.disconnect() + self.assertEqual(r, 0) + + # + # The tests themselves + # + + # + # Basic request / reply + # + def test_show_version(self): + print(vpp_papi.show_version()) + + # + # Details / Dump + # + def test_details_dump(self): + t = vpp_papi.sw_interface_dump(0, b'') + print('Dump/details T', t) + +if __name__ == '__main__': + unittest.main() diff --git a/src/vpp-api/python/tests/test_vpp_papi2.py b/src/vpp-api/python/tests/test_vpp_papi2.py new file mode 100755 index 00000000..f45f791e --- /dev/null +++ b/src/vpp-api/python/tests/test_vpp_papi2.py @@ -0,0 +1,487 @@ +#!/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(testmode=json) + 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(testmode=True) + msglist.add_message(p[0], p[1:]) + + self.assertTrue(msglist['ip_address_details']) + + def test_message_to_bytes(self): + msglist = VPP(testmode=True) + 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"], + ["vl_api_ip4_fib_counter_t", "counter"] + ]''' + + # Add new type + msglist = VPP(testmode=True) + 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"], + ["vl_api_ip4_fib_counter_t", "counter", 2] + + ]''' + + # Add new type + msglist = VPP(testmode=True) + 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"], + ["vl_api_ip4_fib_counter_t", "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_simple_array(self): + msglist = VPP(testmode=True) + + 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_old_vla_array(self): + msglist = VPP(testmode = True) + + # VLA + vla_byte_array = '''["vla_byte_array", + ["u32", "foobar"], + ["u32", "list", 2], + ["u32", "propercount"], + ["u8", "propermask", 0, "propercount"], + ["u8", "oldmask", 0], + {"crc" : "0xb2739495"} + ]''' + p = json.loads(vla_byte_array) + msgdef = msglist.add_message(p[0], p[1:]) + b = msglist.encode(msgdef, {'list' : [123, 456], 'oldmask': b'foobar', + 'propercount' : 2, + 'propermask' : [8,9]}) + self.assertEqual(24, len(b)) + rv = msglist.decode(msgdef, b) + self.assertEqual(b'foobar', rv.oldmask) + + def test_old_vla_array_not_last_member(self): + msglist = VPP(testmode = True) + + # VLA + vla_byte_array = '''["vla_byte_array", + ["u8", "oldmask", 0], + ["u32", "foobar"], + {"crc" : "0xb2739495"} + ]''' + p = json.loads(vla_byte_array) + self.assertRaises(ValueError, msglist.add_message, p[0], p[1:]) + + def test_old_vla_array_u32(self): + msglist = VPP(testmode = True) + + # VLA + vla_byte_array = '''["vla_byte_array", + ["u32", "foobar"], + ["u32", "oldmask", 0], + {"crc" : "0xb2739495"} + ]''' + p = json.loads(vla_byte_array) + msgdef = msglist.add_message(p[0], p[1:]) + b = msglist.encode(msgdef, {'foobar' : 123, 'oldmask': [123, 456, 789]}) + self.assertEqual(16, len(b)) + rv = msglist.decode(msgdef, b) + self.assertEqual([123, 456, 789], rv.oldmask) + + def test_old_vla_array_compound(self): + msglist = VPP(testmode = True) + + # VLA + counter_type = '''["ip4_fib_counter", + ["u32", "address"], + ["u8", "address_length"], + ["u64", "packets"], + ["u64", "bytes"], + {"crc" : "0xb2739495"} + ]''' + + vla_byte_array = '''["vla_byte_array", + ["vl_api_ip4_fib_counter_t", "counter", 0], + {"crc" : "0xb2739495"} + ]''' + + p = json.loads(counter_type) + msglist.add_type(p[0], p[1:]) + + p = json.loads(vla_byte_array) + with self.assertRaises(NotImplementedError): + msgdef = msglist.add_message(p[0], p[1:]) + + def test_array_count_not_previous(self): + msglist = VPP(testmode = True) + + # VLA + vla_byte_array = '''["vla_byte_array", + ["u32", "count"], + ["u32", "filler"], + ["u32", "lst", 0, "count"], + {"crc" : "0xb2739495"} + ]''' + + p = json.loads(vla_byte_array) + msgdef = msglist.add_message(p[0], p[1:]) + b = msglist.encode(msgdef, {'count': 3, 'lst': [1,2,3], 'filler' : 1 }) + rv = msglist.decode(msgdef, b) + self.assertEqual(rv.lst, [1,2,3]) + + def test_argument_name(self): + msglist = VPP(testmode=True) + + + 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) + self.assertEqual('vpe', 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, 1) + 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() + + def test_acl_interface_get(self): + vpp = VPP(jsonfiles) + + vpp.connect('test_vpp_papi2') + + rv = vpp.macip_acl_interface_get() + + print('RV', rv) + + vpp.disconnect() + +if __name__ == '__main__': + unittest.main() diff --git a/src/vpp-api/python/vpp_papi.py b/src/vpp-api/python/vpp_papi.py new file mode 100644 index 00000000..7b66c0f4 --- /dev/null +++ b/src/vpp-api/python/vpp_papi.py @@ -0,0 +1,706 @@ +#!/usr/bin/env python +# +# Copyright (c) 2016 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +from __future__ import print_function +import sys +import os +import logging +import collections +import struct +import json +import threading +import glob +import atexit +from cffi import FFI + +if sys.version[0] == '2': + import Queue as queue +else: + import queue as queue + +ffi = FFI() +ffi.cdef(""" +typedef void (*vac_callback_t)(unsigned char * data, int len); +typedef void (*vac_error_callback_t)(void *, unsigned char *, int); +int vac_connect(char * name, char * chroot_prefix, vac_callback_t cb, + int rx_qlen); +int vac_disconnect(void); +int vac_read(char **data, int *l, unsigned short timeout); +int vac_write(char *data, int len); +void vac_free(void * msg); + +int vac_get_msg_index(unsigned char * name); +int vac_msg_table_size(void); +int vac_msg_table_max_index(void); + +void vac_rx_suspend (void); +void vac_rx_resume (void); +void vac_set_error_handler(vac_error_callback_t); + """) + +# Barfs on failure, no need to check success. +vpp_api = ffi.dlopen('libvppapiclient.so') + + +def vpp_atexit(self): + """Clean up VPP connection on shutdown.""" + if self.connected: + self.logger.debug('Cleaning up VPP on exit') + self.disconnect() + +vpp_object = None + + +def vpp_iterator(d): + if sys.version[0] == '2': + return d.iteritems() + else: + return d.items() + + +@ffi.callback("void(unsigned char *, int)") +def vac_callback_sync(data, len): + vpp_object.msg_handler_sync(ffi.buffer(data, len)) + + +@ffi.callback("void(unsigned char *, int)") +def vac_callback_async(data, len): + vpp_object.msg_handler_async(ffi.buffer(data, len)) + + +@ffi.callback("void(void *, unsigned char *, int)") +def vac_error_handler(arg, msg, msg_len): + vpp_object.logger.warning("VPP API client:: %s", ffi.string(msg, msg_len)) + + +class Empty(object): + pass + + +class FuncWrapper(object): + def __init__(self, func): + self._func = func + self.__name__ = func.__name__ + + def __call__(self, **kwargs): + return self._func(**kwargs) + + +class VPP(): + """VPP interface. + + This class provides the APIs to VPP. The APIs are loaded + from provided .api.json files and makes functions accordingly. + These functions are documented in the VPP .api files, as they + are dynamically created. + + Additionally, VPP can send callback messages; this class + provides a means to register a callback function to receive + these messages in a background thread. + """ + def __init__(self, apifiles=None, testmode=False, async_thread=True, + logger=logging.getLogger('vpp_papi'), loglevel='debug'): + """Create a VPP API object. + + apifiles is a list of files containing API + descriptions that will be loaded - methods will be + dynamically created reflecting these APIs. If not + provided this will load the API files from VPP's + default install location. + """ + global vpp_object + vpp_object = self + self.logger = logger + logging.basicConfig(level=getattr(logging, loglevel.upper())) + + self.messages = {} + self.id_names = [] + self.id_msgdef = [] + self.connected = False + self.header = struct.Struct('>HI') + self.apifiles = [] + self.event_callback = None + self.message_queue = queue.Queue() + self.read_timeout = 0 + self.vpp_api = vpp_api + if async_thread: + self.event_thread = threading.Thread( + target=self.thread_msg_handler) + self.event_thread.daemon = True + self.event_thread.start() + + if not apifiles: + # Pick up API definitions from default directory + apifiles = glob.glob('/usr/share/vpp/api/*.api.json') + + for file in apifiles: + with open(file) as apidef_file: + api = json.load(apidef_file) + for t in api['types']: + self.add_type(t[0], t[1:]) + + for m in api['messages']: + self.add_message(m[0], m[1:]) + self.apifiles = apifiles + + # Basic sanity check + if len(self.messages) == 0 and not testmode: + raise ValueError(1, 'Missing JSON message definitions') + + # Make sure we allow VPP to clean up the message rings. + atexit.register(vpp_atexit, self) + + # Register error handler + vpp_api.vac_set_error_handler(vac_error_handler) + + class ContextId(object): + """Thread-safe provider of unique context IDs.""" + def __init__(self): + self.context = 0 + self.lock = threading.Lock() + + def __call__(self): + """Get a new unique (or, at least, not recently used) context.""" + with self.lock: + self.context += 1 + return self.context + get_context = ContextId() + + def status(self): + """Debug function: report current VPP API status to stdout.""" + print('Connected') if self.connected else print('Not Connected') + print('Read API definitions from', ', '.join(self.apifiles)) + + def __struct(self, t, n=None, e=-1, vl=None): + """Create a packing structure for a message.""" + base_types = {'u8': 'B', + 'u16': 'H', + 'u32': 'I', + 'i32': 'i', + 'u64': 'Q', + 'f64': 'd', } + pack = None + if t in base_types: + pack = base_types[t] + if not vl: + if e > 0 and t == 'u8': + # Fixed byte array + s = struct.Struct('>' + str(e) + 's') + return s.size, s + if e > 0: + # Fixed array of base type + s = struct.Struct('>' + base_types[t]) + return s.size, [e, s] + elif e == 0: + # Old style variable array + s = struct.Struct('>' + base_types[t]) + return s.size, [-1, s] + else: + # Variable length array + if t == 'u8': + s = struct.Struct('>s') + return s.size, [vl, s] + else: + s = struct.Struct('>' + base_types[t]) + return s.size, [vl, s] + + s = struct.Struct('>' + base_types[t]) + return s.size, s + + if t in self.messages: + size = self.messages[t]['sizes'][0] + + # Return a list in case of array + if e > 0 and not vl: + return size, [e, lambda self, encode, buf, offset, args: ( + self.__struct_type(encode, self.messages[t], buf, offset, + args))] + if vl: + return size, [vl, lambda self, encode, buf, offset, args: ( + self.__struct_type(encode, self.messages[t], buf, offset, + args))] + elif e == 0: + # Old style VLA + raise NotImplementedError(1, + 'No support for compound types ' + t) + return size, lambda self, encode, buf, offset, args: ( + self.__struct_type(encode, self.messages[t], buf, offset, args) + ) + + raise ValueError(1, 'Invalid message type: ' + t) + + def __struct_type(self, encode, msgdef, buf, offset, kwargs): + """Get a message packer or unpacker.""" + if encode: + return self.__struct_type_encode(msgdef, buf, offset, kwargs) + else: + return self.__struct_type_decode(msgdef, buf, offset) + + def __struct_type_encode(self, msgdef, buf, offset, kwargs): + off = offset + size = 0 + + for k in kwargs: + if k not in msgdef['args']: + raise ValueError(1,'Non existing argument [' + k + ']' + \ + ' used in call to: ' + \ + self.id_names[kwargs['_vl_msg_id']] + '()' ) + + for k, v in vpp_iterator(msgdef['args']): + off += size + if k in kwargs: + if type(v) is list: + if callable(v[1]): + e = kwargs[v[0]] if v[0] in kwargs else v[0] + if e != len(kwargs[k]): + raise (ValueError(1, 'Input list length mismatch: %s (%s != %s)' % (k, e, len(kwargs[k])))) + size = 0 + for i in range(e): + size += v[1](self, True, buf, off + size, + kwargs[k][i]) + else: + if v[0] in kwargs: + l = kwargs[v[0]] + if l != len(kwargs[k]): + raise ValueError(1, 'Input list length mistmatch: %s (%s != %s)' % (k, l, len(kwargs[k]))) + else: + l = len(kwargs[k]) + if v[1].size == 1: + buf[off:off + l] = bytearray(kwargs[k]) + size = l + else: + size = 0 + for i in kwargs[k]: + v[1].pack_into(buf, off + size, i) + size += v[1].size + else: + if callable(v): + size = v(self, True, buf, off, kwargs[k]) + else: + if type(kwargs[k]) is str and v.size < len(kwargs[k]): + raise ValueError(1, 'Input list length mistmatch: %s (%s < %s)' % (k, v.size, len(kwargs[k]))) + v.pack_into(buf, off, kwargs[k]) + size = v.size + else: + size = v.size if not type(v) is list else 0 + + return off + size - offset + + def __getitem__(self, name): + if name in self.messages: + return self.messages[name] + return None + + def get_size(self, sizes, kwargs): + total_size = sizes[0] + for e in sizes[1]: + if e in kwargs and type(kwargs[e]) is list: + total_size += len(kwargs[e]) * sizes[1][e] + return total_size + + def encode(self, msgdef, kwargs): + # Make suitably large buffer + size = self.get_size(msgdef['sizes'], kwargs) + buf = bytearray(size) + offset = 0 + size = self.__struct_type(True, msgdef, buf, offset, kwargs) + return buf[:offset + size] + + def decode(self, msgdef, buf): + return self.__struct_type(False, msgdef, buf, 0, None)[1] + + def __struct_type_decode(self, msgdef, buf, offset): + res = [] + off = offset + size = 0 + for k, v in vpp_iterator(msgdef['args']): + off += size + if type(v) is list: + lst = [] + if callable(v[1]): # compound type + size = 0 + if v[0] in msgdef['args']: # vla + e = res[v[2]] + else: # fixed array + e = v[0] + res.append(lst) + for i in range(e): + (s, l) = v[1](self, False, buf, off + size, None) + lst.append(l) + size += s + continue + if v[1].size == 1: + if type(v[0]) is int: + size = len(buf) - off + else: + size = res[v[2]] + res.append(buf[off:off + size]) + else: + e = v[0] if type(v[0]) is int else res[v[2]] + if e == -1: + e = (len(buf) - off) / v[1].size + lst = [] + res.append(lst) + size = 0 + for i in range(e): + lst.append(v[1].unpack_from(buf, off + size)[0]) + size += v[1].size + else: + if callable(v): + (s, l) = v(self, False, buf, off, None) + res.append(l) + size += s + else: + res.append(v.unpack_from(buf, off)[0]) + size = v.size + + return off + size - offset, msgdef['return_tuple']._make(res) + + def ret_tup(self, name): + if name in self.messages and 'return_tuple' in self.messages[name]: + return self.messages[name]['return_tuple'] + return None + + def add_message(self, name, msgdef, typeonly=False): + if name in self.messages: + raise ValueError('Duplicate message name: ' + name) + + args = collections.OrderedDict() + argtypes = collections.OrderedDict() + fields = [] + msg = {} + total_size = 0 + sizes = {} + for i, f in enumerate(msgdef): + if type(f) is dict and 'crc' in f: + msg['crc'] = f['crc'] + continue + field_type = f[0] + field_name = f[1] + if len(f) == 3 and f[2] == 0 and i != len(msgdef) - 2: + raise ValueError('Variable Length Array must be last: ' + name) + size, s = self.__struct(*f) + args[field_name] = s + if type(s) == list and type(s[0]) == int and type(s[1]) == struct.Struct: + if s[0] < 0: + sizes[field_name] = size + else: + sizes[field_name] = size + total_size += s[0] * size + else: + sizes[field_name] = size + total_size += size + + argtypes[field_name] = field_type + if len(f) == 4: # Find offset to # elements field + idx = list(args.keys()).index(f[3]) - i + args[field_name].append(idx) + fields.append(field_name) + msg['return_tuple'] = collections.namedtuple(name, fields, + rename=True) + self.messages[name] = msg + self.messages[name]['args'] = args + self.messages[name]['argtypes'] = argtypes + self.messages[name]['typeonly'] = typeonly + self.messages[name]['sizes'] = [total_size, sizes] + return self.messages[name] + + def add_type(self, name, typedef): + return self.add_message('vl_api_' + name + '_t', typedef, + typeonly=True) + + def make_function(self, name, i, msgdef, multipart, async): + if (async): + f = lambda **kwargs: (self._call_vpp_async(i, msgdef, **kwargs)) + else: + f = lambda **kwargs: (self._call_vpp(i, msgdef, multipart, + **kwargs)) + args = self.messages[name]['args'] + argtypes = self.messages[name]['argtypes'] + f.__name__ = str(name) + f.__doc__ = ", ".join(["%s %s" % + (argtypes[k], k) for k in args.keys()]) + return f + + @property + def api(self): + if not hasattr(self, "_api"): + raise Exception("Not connected, api definitions not available") + return self._api + + def _register_functions(self, async=False): + self.id_names = [None] * (self.vpp_dictionary_maxid + 1) + self.id_msgdef = [None] * (self.vpp_dictionary_maxid + 1) + self._api = Empty() + for name, msgdef in vpp_iterator(self.messages): + if self.messages[name]['typeonly']: + continue + crc = self.messages[name]['crc'] + n = name + '_' + crc[2:] + i = vpp_api.vac_get_msg_index(n.encode()) + if i > 0: + self.id_msgdef[i] = msgdef + self.id_names[i] = name + multipart = True if name.find('_dump') > 0 else False + f = self.make_function(name, i, msgdef, multipart, async) + setattr(self._api, name, FuncWrapper(f)) + + # old API stuff starts here - will be removed in 17.07 + if hasattr(self, name): + raise NameError( + 3, "Conflicting name in JSON definition: `%s'" % name) + setattr(self, name, f) + # old API stuff ends here + else: + self.logger.debug( + 'No such message type or failed CRC checksum: %s', n) + + def _write(self, buf): + """Send a binary-packed message to VPP.""" + if not self.connected: + raise IOError(1, 'Not connected') + return vpp_api.vac_write(ffi.from_buffer(buf), len(buf)) + + def _read(self): + if not self.connected: + raise IOError(1, 'Not connected') + mem = ffi.new("char **") + size = ffi.new("int *") + rv = vpp_api.vac_read(mem, size, self.read_timeout) + if rv: + raise IOError(rv, 'vac_read failed') + msg = bytes(ffi.buffer(mem[0], size[0])) + vpp_api.vac_free(mem[0]) + return msg + + def connect_internal(self, name, msg_handler, chroot_prefix, rx_qlen, + async): + pfx = chroot_prefix.encode() if chroot_prefix else ffi.NULL + rv = vpp_api.vac_connect(name.encode(), pfx, msg_handler, rx_qlen) + if rv != 0: + raise IOError(2, 'Connect failed') + self.connected = True + + self.vpp_dictionary_maxid = vpp_api.vac_msg_table_max_index() + self._register_functions(async=async) + + # Initialise control ping + crc = self.messages['control_ping']['crc'] + self.control_ping_index = vpp_api.vac_get_msg_index( + ('control_ping' + '_' + crc[2:]).encode()) + self.control_ping_msgdef = self.messages['control_ping'] + return rv + + def connect(self, name, chroot_prefix=None, async=False, rx_qlen=32): + """Attach to VPP. + + name - the name of the client. + chroot_prefix - if VPP is chroot'ed, the prefix of the jail + async - if true, messages are sent without waiting for a reply + rx_qlen - the length of the VPP message receive queue between + client and server. + """ + msg_handler = vac_callback_sync if not async else vac_callback_async + return self.connect_internal(name, msg_handler, chroot_prefix, rx_qlen, + async) + + def connect_sync(self, name, chroot_prefix=None, rx_qlen=32): + """Attach to VPP in synchronous mode. Application must poll for events. + + name - the name of the client. + chroot_prefix - if VPP is chroot'ed, the prefix of the jail + rx_qlen - the length of the VPP message receive queue between + client and server. + """ + + return self.connect_internal(name, ffi.NULL, chroot_prefix, rx_qlen, + async=False) + + def disconnect(self): + """Detach from VPP.""" + rv = vpp_api.vac_disconnect() + self.connected = False + return rv + + def msg_handler_sync(self, msg): + """Process an incoming message from VPP in sync mode. + + The message may be a reply or it may be an async notification. + """ + r = self.decode_incoming_msg(msg) + if r is None: + return + + # If we have a context, then use the context to find any + # request waiting for a reply + context = 0 + if hasattr(r, 'context') and r.context > 0: + context = r.context + + msgname = type(r).__name__ + + if context == 0: + # No context -> async notification that we feed to the callback + self.message_queue.put_nowait(r) + else: + raise IOError(2, 'RPC reply message received in event handler') + + def decode_incoming_msg(self, msg): + if not msg: + self.logger.warning('vpp_api.read failed') + return + + i, ci = self.header.unpack_from(msg, 0) + if self.id_names[i] == 'rx_thread_exit': + return + + # + # Decode message and returns a tuple. + # + msgdef = self.id_msgdef[i] + if not msgdef: + raise IOError(2, 'Reply message undefined') + + r = self.decode(msgdef, msg) + + return r + + def msg_handler_async(self, msg): + """Process a message from VPP in async mode. + + In async mode, all messages are returned to the callback. + """ + r = self.decode_incoming_msg(msg) + if r is None: + return + + msgname = type(r).__name__ + + if self.event_callback: + self.event_callback(msgname, r) + + def _control_ping(self, context): + """Send a ping command.""" + self._call_vpp_async(self.control_ping_index, + self.control_ping_msgdef, + context=context) + + def _call_vpp(self, i, msgdef, multipart, **kwargs): + """Given a message, send the message and await a reply. + + msgdef - the message packing definition + i - the message type index + multipart - True if the message returns multiple + messages in return. + context - context number - chosen at random if not + supplied. + The remainder of the kwargs are the arguments to the API call. + + The return value is the message or message array containing + the response. It will raise an IOError exception if there was + no response within the timeout window. + """ + + if 'context' not in kwargs: + context = self.get_context() + kwargs['context'] = context + else: + context = kwargs['context'] + kwargs['_vl_msg_id'] = i + b = self.encode(msgdef, kwargs) + + vpp_api.vac_rx_suspend() + self._write(b) + + if multipart: + # Send a ping after the request - we use its response + # to detect that we have seen all results. + self._control_ping(context) + + # Block until we get a reply. + rl = [] + while (True): + msg = self._read() + if not msg: + raise IOError(2, 'VPP API client: read failed') + + r = self.decode_incoming_msg(msg) + msgname = type(r).__name__ + if context not in r or r.context == 0 or context != r.context: + self.message_queue.put_nowait(r) + continue + + if not multipart: + rl = r + break + if msgname == 'control_ping_reply': + break + + rl.append(r) + + vpp_api.vac_rx_resume() + + return rl + + def _call_vpp_async(self, i, msgdef, **kwargs): + """Given a message, send the message and await a reply. + + msgdef - the message packing definition + i - the message type index + context - context number - chosen at random if not + supplied. + The remainder of the kwargs are the arguments to the API call. + """ + if 'context' not in kwargs: + context = self.get_context() + kwargs['context'] = context + else: + context = kwargs['context'] + kwargs['_vl_msg_id'] = i + b = self.encode(msgdef, kwargs) + + self._write(b) + + def register_event_callback(self, callback): + """Register a callback for async messages. + + This will be called for async notifications in sync mode, + and all messages in async mode. In sync mode, replies to + requests will not come here. + + callback is a fn(msg_type_name, msg_type) that will be + called when a message comes in. While this function is + executing, note that (a) you are in a background thread and + may wish to use threading.Lock to protect your datastructures, + and (b) message processing from VPP will stop (so if you take + a long while about it you may provoke reply timeouts or cause + VPP to fill the RX buffer). Passing None will disable the + callback. + """ + self.event_callback = callback + + def thread_msg_handler(self): + """Python thread calling the user registerd message handler. + + This is to emulate the old style event callback scheme. Modern + clients should provide their own thread to poll the event + queue. + """ + while True: + r = self.message_queue.get() + msgname = type(r).__name__ + if self.event_callback: + self.event_callback(msgname, r) |