aboutsummaryrefslogtreecommitdiffstats
path: root/resources/libraries/python/VPPUtil.py
blob: 0e69ec7fb684a68f1daf26247db757018f387172 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
# Copyright (c) 2023 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.

"""VPP util library."""

from robot.api import logger

from resources.libraries.python.Constants import Constants
from resources.libraries.python.DUTSetup import DUTSetup
from resources.libraries.python.PapiExecutor import PapiSocketExecutor
from resources.libraries.python.model.ExportResult import (
    export_dut_type_and_version
)
from resources.libraries.python.ssh import exec_cmd_no_error, exec_cmd
from resources.libraries.python.topology import Topology, SocketType, NodeType


class VPPUtil:
    """General class for any VPP related methods/functions."""

    @staticmethod
    def restart_vpp_service(node, node_key=None):
        """Restart VPP service on the specified topology node.

        Disconnect possibly connected PAPI executor.

        :param node: Topology node.
        :param node_key: Topology node key.
        :type node: dict
        :type node_key: str
        """
        # Containers have a separate lifecycle, but better be safe.
        PapiSocketExecutor.disconnect_all_sockets_by_node(node)

        VPPUtil.stop_vpp_service(node)
        command = "/usr/bin/vpp -c /etc/vpp/startup.conf"
        message = f"Node {node[u'host']} failed to start VPP!"
        exec_cmd_no_error(
            node, command, timeout=180, sudo=True, message=message
        )

        if node_key:
            Topology.add_new_socket(
                node, SocketType.CLI, node_key, Constants.SOCKCLI_PATH)
            Topology.add_new_socket(
                node, SocketType.PAPI, node_key, Constants.SOCKSVR_PATH)
            Topology.add_new_socket(
                node, SocketType.STATS, node_key, Constants.SOCKSTAT_PATH)

    @staticmethod
    def restart_vpp_service_on_all_duts(nodes):
        """Restart VPP service on all DUT nodes.

        :param nodes: Topology nodes.
        :type nodes: dict
        """
        for node_key, node in nodes.items():
            if node[u"type"] == NodeType.DUT:
                VPPUtil.restart_vpp_service(node, node_key)

    @staticmethod
    def stop_vpp_service(node, node_key=None):
        """Stop VPP service on the specified topology node.

        Disconnect possibly connected PAPI executor.

        :param node: Topology node.
        :param node_key: Topology node key.
        :type node: dict
        :type node_key: str
        """
        PapiSocketExecutor.disconnect_all_sockets_by_node(node)
        command = "pkill vpp"
        exec_cmd(node, command, timeout=180, sudo=True)
        command = (
            "/bin/rm -f /dev/shm/db /dev/shm/global_vm /dev/shm/vpe-api"
        )
        exec_cmd(node, command, timeout=180, sudo=True)

        if node_key:
            if Topology.get_node_sockets(node, socket_type=SocketType.PAPI):
                Topology.del_node_socket_id(node, SocketType.PAPI, node_key)
            if Topology.get_node_sockets(node, socket_type=SocketType.STATS):
                Topology.del_node_socket_id(node, SocketType.STATS, node_key)

    @staticmethod
    def stop_vpp_service_on_all_duts(nodes):
        """Stop VPP service on all DUT nodes.

        :param nodes: Topology nodes.
        :type nodes: dict
        """
        for node_key, node in nodes.items():
            if node[u"type"] == NodeType.DUT:
                VPPUtil.stop_vpp_service(node, node_key)

    @staticmethod
    def install_vpp_on_all_duts(nodes, vpp_pkg_dir):
        """Install VPP on all DUT nodes.

        :param nodes: Nodes in the topology.
        :param vpp_pkg_dir: Path to directory where VPP packages are stored.
        :type nodes: dict
        :type vpp_pkg_dir: str
        """
        VPPUtil.stop_vpp_service_on_all_duts(nodes)
        for node in nodes.values():
            message = f"Failed to install VPP on host {node['host']}!"
            if node["type"] == NodeType.DUT:
                command = "mkdir -p /var/log/vpp/"
                exec_cmd(node, command, sudo=True)

                command = "ln -s /dev/null /etc/systemd/system/vpp.service"
                exec_cmd(node, command, sudo=True)

                command = "ln -s /dev/null /etc/sysctl.d/80-vpp.conf"
                exec_cmd(node, command, sudo=True)

                command = "apt-get purge -y '*vpp*' || true"
                exec_cmd_no_error(node, command, timeout=120, sudo=True)

                command = f"dpkg -i --force-all {vpp_pkg_dir}*.deb"
                exec_cmd_no_error(
                    node, command, timeout=120, sudo=True, message=message
                )

                command = "dpkg -l | grep vpp"
                exec_cmd_no_error(node, command, sudo=True)

    @staticmethod
    def verify_vpp_installed(node):
        """Verify that VPP is installed on the specified topology node.

        :param node: Topology node.
        :type node: dict
        """
        DUTSetup.verify_program_installed(node, u"vpp")

    @staticmethod
    def adjust_privileges(node):
        """Adjust privileges to control VPP without sudo.

        :param node: Topology node.
        :type node: dict
        """
        cmd = u"chmod -R o+rwx /run/vpp"
        exec_cmd_no_error(
            node, cmd, sudo=True, message=u"Failed to adjust privileges!",
            retries=120)

    @staticmethod
    def verify_vpp_started(node):
        """Verify that VPP is started on the specified topology node.

        :param node: Topology node.
        :type node: dict
        """
        cmd = u"echo \"show pci\" | sudo socat - UNIX-CONNECT:/run/vpp/cli.sock"
        exec_cmd_no_error(
            node, cmd, sudo=False, message=u"VPP failed to start!", retries=120
        )

        cmd = u"vppctl show pci 2>&1 | fgrep -v \"Connection refused\" | " \
              u"fgrep -v \"No such file or directory\""
        exec_cmd_no_error(
            node, cmd, sudo=True, message=u"VPP failed to start!", retries=120
        )

        # Properly enable cards in case they were disabled. This will be
        # followed in https://jira.fd.io/browse/VPP-1934.
        cmd = u"for i in $(sudo vppctl sho int | grep Eth | cut -d' ' -f1); do"\
              u" sudo vppctl set int sta $i up; done"
        exec_cmd(node, cmd, sudo=False)

    @staticmethod
    def verify_vpp(node):
        """Verify that VPP is installed and started on the specified topology
        node. Adjust privileges so user can connect without sudo.

        :param node: Topology node.
        :type node: dict
        :raises RuntimeError: If VPP service fails to start.
        """
        DUTSetup.verify_program_installed(node, 'vpp')
        try:
            # Verify responsiveness of vppctl.
            VPPUtil.verify_vpp_started(node)
            # Adjust privileges.
            VPPUtil.adjust_privileges(node)
            # Verify responsiveness of PAPI.
            VPPUtil.show_log(node)
            VPPUtil.vpp_show_version(node)
        finally:
            DUTSetup.get_service_logs(node, Constants.VPP_UNIT)

    @staticmethod
    def verify_vpp_on_all_duts(nodes):
        """Verify that VPP is installed and started on all DUT nodes.

        :param nodes: Nodes in the topology.
        :type nodes: dict
        """
        for node in nodes.values():
            if node[u"type"] == NodeType.DUT:
                VPPUtil.verify_vpp(node)

    @staticmethod
    def vpp_show_version(
            node, remote_vpp_socket=Constants.SOCKSVR_PATH, log=True):
        """Run "show_version" PAPI command.

        Socket is configurable, so VPP inside container can be accessed.
        The result is exported to JSON UTI output as "dut-version".

        :param node: Node to run command on.
        :param remote_vpp_socket: Path to remote socket to target VPP.
        :param log: If true, show the result in Robot log.
        :type node: dict
        :type remote_vpp_socket: str
        :type log: bool
        :returns: VPP version.
        :rtype: str
        :raises RuntimeError: If PAPI connection fails.
        :raises AssertionError: If PAPI retcode is nonzero.
        """
        cmd = u"show_version"
        with PapiSocketExecutor(node, remote_vpp_socket) as papi_exec:
            reply = papi_exec.add(cmd).get_reply()
        if log:
            logger.info(f"VPP version: {reply[u'version']}\n")
        version = f"{reply[u'version']}"
        export_dut_type_and_version(u"VPP", version)
        return version

    @staticmethod
    def show_vpp_version_on_all_duts(nodes):
        """Show VPP version verbose on all DUTs.

        :param nodes: Nodes in the topology.
        :type nodes: dict
        """
        for node in nodes.values():
            if node[u"type"] == NodeType.DUT:
                VPPUtil.vpp_show_version(node)

    @staticmethod
    def vpp_show_interfaces(node):
        """Run "show interface" CLI command.

        :param node: Node to run command on.
        :type node: dict
        """

        cmd = u"sw_interface_dump"
        args = dict(
            name_filter_valid=False,
            name_filter=u""
        )
        err_msg = f"Failed to get interface dump on host {node[u'host']}"
        with PapiSocketExecutor(node) as papi_exec:
            details = papi_exec.add(cmd, **args).get_details(err_msg)

        for if_dump in details:
            if_dump[u"l2_address"] = str(if_dump[u"l2_address"])
            if_dump[u"b_dmac"] = str(if_dump[u"b_dmac"])
            if_dump[u"b_smac"] = str(if_dump[u"b_smac"])
            if_dump[u"flags"] = if_dump[u"flags"].value
            if_dump[u"type"] = if_dump[u"type"].value
            if_dump[u"link_duplex"] = if_dump[u"link_duplex"].value
            if_dump[u"sub_if_flags"] = if_dump[u"sub_if_flags"].value \
                if hasattr(if_dump[u"sub_if_flags"], u"value") \
                else int(if_dump[u"sub_if_flags"])
        # TODO: return only base data
        logger.trace(f"Interface data of host {node[u'host']}:\n{details}")

    @staticmethod
    def vpp_enable_traces_on_dut(node, fail_on_error=False):
        """Enable vpp packet traces on the DUT node.

        :param node: DUT node to set up.
        :param fail_on_error: If True, keyword fails if an error occurs,
            otherwise passes.
        :type node: dict
        :type fail_on_error: bool
        """
        cmds = [
            u"trace add dpdk-input 50",
            u"trace add vhost-user-input 50",
            u"trace add memif-input 50",
            u"trace add avf-input 50"
        ]

        for cmd in cmds:
            try:
                PapiSocketExecutor.run_cli_cmd_on_all_sockets(node, cmd)
            except AssertionError:
                if fail_on_error:
                    raise

    @staticmethod
    def vpp_enable_traces_on_all_duts(nodes, fail_on_error=False):
        """Enable vpp packet traces on all DUTs in the given topology.

        :param nodes: Nodes in the topology.
        :param fail_on_error: If True, keyword fails if an error occurs,
            otherwise passes.
        :type nodes: dict
        :type fail_on_error: bool
        """
        for node in nodes.values():
            if node[u"type"] == NodeType.DUT:
                VPPUtil.vpp_enable_traces_on_dut(node, fail_on_error)

    @staticmethod
    def vpp_enable_elog_traces(node):
        """Enable API/CLI/Barrier traces on the specified topology node.

        :param node: Topology node.
        :type node: dict
        """
        try:
            PapiSocketExecutor.run_cli_cmd_on_all_sockets(
                node, u"event-logger trace api cli barrier")
        except AssertionError:
            # Perhaps an older VPP build is tested.
            PapiSocketExecutor.run_cli_cmd_on_all_sockets(
                node, u"elog trace api cli barrier")

    @staticmethod
    def vpp_enable_elog_traces_on_all_duts(nodes):
        """Enable API/CLI/Barrier traces on all DUTs in the given topology.

        :param nodes: Nodes in the topology.
        :type nodes: dict
        """
        for node in nodes.values():
            if node[u"type"] == NodeType.DUT:
                VPPUtil.vpp_enable_elog_traces(node)

    @staticmethod
    def show_event_logger(node):
        """Show event logger on the specified topology node.

        :param node: Topology node.
        :type node: dict
        """
        PapiSocketExecutor.run_cli_cmd_on_all_sockets(
            node, u"show event-logger")

    @staticmethod
    def show_event_logger_on_all_duts(nodes):
        """Show event logger on all DUTs in the given topology.

        :param nodes: Nodes in the topology.
        :type nodes: dict
        """
        for node in nodes.values():
            if node[u"type"] == NodeType.DUT:
                VPPUtil.show_event_logger(node)

    @staticmethod
    def show_log(node):
        """Show logging on the specified topology node.

        :param node: Topology node.
        :type node: dict
        """
        PapiSocketExecutor.run_cli_cmd(node, u"show logging")

    @staticmethod
    def show_log_on_all_duts(nodes):
        """Show logging on all DUTs in the given topology.

        :param nodes: Nodes in the topology.
        :type nodes: dict
        """
        for node in nodes.values():
            if node[u"type"] == NodeType.DUT:
                VPPUtil.show_log(node)

    @staticmethod
    def vpp_show_threads(node):
        """Show VPP threads on node.

        :param node: Node to run command on.
        :type node: dict
        :returns: VPP thread data.
        :rtype: list
        """
        cmd = u"show_threads"
        with PapiSocketExecutor(node) as papi_exec:
            reply = papi_exec.add(cmd).get_reply()

        threads_data = reply[u"thread_data"]
        logger.trace(f"show threads:\n{threads_data}")

        return threads_data

    @staticmethod
    def vpp_add_graph_node_next(node, graph_node_name, graph_next_name):
        """Set the next node for a given node.

        :param node: Node to run command on.
        :param graph_node_name: Graph node to add the next node on.
        :param graph_next_name: Graph node to add as the next node.
        :type node: dict
        :type graph_node_name: str
        :type graph_next_name: str
        :returns: The index of the next graph node.
        :rtype: int
        """
        cmd = u"add_node_next"
        args = dict(
            node_name=graph_node_name,
            next_name=graph_next_name
        )
        with PapiSocketExecutor(node) as papi_exec:
            reply = papi_exec.add(cmd, **args).get_reply()

        return reply[u"next_index"]

    @staticmethod
    def vpp_set_neighbor_limit_on_all_duts(nodes, count):
        """VPP set neighbor count limit on all DUTs in the given topology.

        :param nodes: Nodes in the topology.
        :param count: Neighbor count need to set.
        :type nodes: dict
        :type count: int
        """
        for node in nodes.values():
            if node[u"type"] == NodeType.DUT:
                cmd = f"set ip neighbor-config ip4 limit {count}"
                PapiSocketExecutor.run_cli_cmd(node, cmd)

                cmd = f"set ip neighbor-config ip6 limit {count}"
                PapiSocketExecutor.run_cli_cmd(node, cmd)