aboutsummaryrefslogtreecommitdiffstats
path: root/resources/libraries/python/IPUtil.py
blob: 52640d16584219e3b9adcbe3bb7df4498889e0c7 (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
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
# Copyright (c) 2019 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.

"""Common IP utilities library."""

import re

from socket import AF_INET, AF_INET6, inet_ntop, inet_pton

from ipaddress import ip_address
from ipaddress import IPv4Network, IPv6Network, IPv4Address, IPv6Address
from ipaddress import AddressValueError, NetmaskValueError

from resources.libraries.python.Constants import Constants
from resources.libraries.python.InterfaceUtil import InterfaceUtil
from resources.libraries.python.PapiExecutor import PapiExecutor
from resources.libraries.python.ssh import exec_cmd_no_error, exec_cmd
from resources.libraries.python.topology import NodeType, Topology


class IPUtil(object):
    """Common IP utilities"""

    @staticmethod
    def ip_to_int(ip_str):
        """Convert IP address from string format (e.g. 10.0.0.1) to integer
        representation (167772161).

        :param ip_str: IP address in string representation.
        :type ip_str: str
        :returns: Integer representation of IP address.
        :rtype: int
        """
        return int(ip_address(unicode(ip_str)))

    @staticmethod
    def int_to_ip(ip_int):
        """Convert IP address from integer representation (e.g. 167772161) to
        string format (10.0.0.1).

        :param ip_int: IP address in integer representation.
        :type ip_int: int
        :returns: String representation of IP address.
        :rtype: str
        """
        return str(ip_address(ip_int))

    @staticmethod
    def vpp_get_interface_ip_addresses(node, interface, ip_version):
        """Get list of IP addresses from an interface on a VPP node.

        :param node: VPP node.
        :param interface: Name of an interface on the VPP node.
        :param ip_version: IP protocol version (ipv4 or ipv6).
        :type node: dict
        :type interface: str
        :type ip_version: str
        :returns: List of dictionaries, each containing IP address, subnet
            prefix length and also the subnet mask for ipv4 addresses.
            Note: A single interface may have multiple IP addresses assigned.
        :rtype: list
        """
        try:
            sw_if_index = Topology.convert_interface_reference(
                node, interface, 'sw_if_index')
        except RuntimeError:
            if isinstance(interface, basestring):
                sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
            else:
                raise

        is_ipv6 = 1 if ip_version == 'ipv6' else 0

        cmd = 'ip_address_dump'
        cmd_reply = 'ip_address_details'
        args = dict(sw_if_index=sw_if_index,
                    is_ipv6=is_ipv6)
        err_msg = 'Failed to get L2FIB dump on host {host}'.format(
            host=node['host'])

        with PapiExecutor(node) as papi_exec:
            papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)

        data = list()
        for item in papi_resp.reply[0]['api_reply']:
            item[cmd_reply]['ip'] = inet_ntop(AF_INET6, item[cmd_reply]['ip']) \
                if is_ipv6 else inet_ntop(AF_INET, item[cmd_reply]['ip'][0:4])
            item[cmd_reply]['netmask'] = str(
                IPv6Network(unicode('::/{pl}'.format(
                    pl=item[cmd_reply]['prefix_length']))).netmask) if is_ipv6 \
                else str(IPv4Network(unicode('0.0.0.0/{pl}'.format(
                    pl=item[cmd_reply]['prefix_length']))).netmask)
            data.append(item[cmd_reply])

        return data

    @staticmethod
    def get_interface_vrf_table(node, interface, ip_version='ipv4'):
        """Get vrf ID for the given interface.

        :param node: VPP node.
        :param interface: Name or sw_if_index of a specific interface.
        :type node: dict
        :param ip_version: IP protocol version (ipv4 or ipv6).
        :type interface: str or int
        :type ip_version: str
        :returns: vrf ID of the specified interface.
        :rtype: int
        """
        if isinstance(interface, basestring):
            sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
        else:
            sw_if_index = interface

        is_ipv6 = 1 if ip_version == 'ipv6' else 0

        cmd = 'sw_interface_get_table'
        args = dict(sw_if_index=sw_if_index,
                    is_ipv6=is_ipv6)
        err_msg = 'Failed to get VRF id assigned to interface {ifc}'.format(
            ifc=interface)

        with PapiExecutor(node) as papi_exec:
            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg). \
                verify_reply(err_msg=err_msg)

        return papi_resp['vrf_id']

    @staticmethod
    def vpp_ip_source_check_setup(node, if_name):
        """Setup Reverse Path Forwarding source check on interface.

        :param node: VPP node.
        :param if_name: Interface name to setup RPF source check.
        :type node: dict
        :type if_name: str
        """
        cmd = 'ip_source_check_interface_add_del'
        args = dict(
            sw_if_index=InterfaceUtil.get_interface_index(node, if_name),
            is_add=1,
            loose=0)
        err_msg = 'Failed to enable source check on interface {ifc}'.format(
            ifc=if_name)
        with PapiExecutor(node) as papi_exec:
            papi_exec.add(cmd, **args).get_replies(err_msg). \
                verify_reply(err_msg=err_msg)

    @staticmethod
    def vpp_ip_probe(node, interface, addr):
        """Run ip probe on VPP node.

        :param node: VPP node.
        :param interface: Interface key or name.
        :param addr: IPv4/IPv6 address.
        :type node: dict
        :type interface: str
        :type addr: str
        """
        cmd = 'ip_probe_neighbor'
        cmd_reply = 'proxy_arp_intfc_enable_disable_reply'
        args = dict(
            sw_if_index=InterfaceUtil.get_interface_index(node, interface),
            dst=str(addr))
        err_msg = 'VPP ip probe {dev} {ip} failed on {h}'.format(
            dev=interface, ip=addr, h=node['host'])

        with PapiExecutor(node) as papi_exec:
            papi_exec.add(cmd, **args).get_replies(err_msg). \
                verify_reply(cmd_reply=cmd_reply, err_msg=err_msg)

    @staticmethod
    def ip_addresses_should_be_equal(ip1, ip2):
        """Fails if the given IP addresses are unequal.

        :param ip1: IPv4 or IPv6 address.
        :param ip2: IPv4 or IPv6 address.
        :type ip1: str
        :type ip2: str
        """
        addr1 = ip_address(unicode(ip1))
        addr2 = ip_address(unicode(ip2))

        if addr1 != addr2:
            raise AssertionError('IP addresses are not equal: {0} != {1}'.
                                 format(ip1, ip2))

    @staticmethod
    def setup_network_namespace(node, namespace_name, interface_name,
                                ip_addr, prefix):
        """Setup namespace on given node and attach interface and IP to
        this namespace. Applicable also on TG node.

        :param node: VPP node.
        :param namespace_name: Namespace name.
        :param interface_name: Interface name.
        :param ip_addr: IP address of namespace's interface.
        :param prefix: IP address prefix length.
        :type node: dict
        :type namespace_name: str
        :type interface_name: str
        :type ip_addr: str
        :type prefix: int
        """
        cmd = ('ip netns add {0}'.format(namespace_name))
        exec_cmd_no_error(node, cmd, sudo=True)

        cmd = ('ip link set dev {0} up netns {1}'.format(interface_name,
                                                         namespace_name))
        exec_cmd_no_error(node, cmd, sudo=True)

        cmd = ('ip netns exec {0} ip addr add {1}/{2} dev {3}'.format(
            namespace_name, ip_addr, prefix, interface_name))
        exec_cmd_no_error(node, cmd, sudo=True)

    @staticmethod
    def linux_enable_forwarding(node, ip_ver='ipv4'):
        """Enable forwarding on a Linux node, e.g. VM.

        :param node: VPP node.
        :param ip_ver: IP version, 'ipv4' or 'ipv6'.
        :type node: dict
        :type ip_ver: str
        """
        cmd = 'sysctl -w net.{0}.ip_forward=1'.format(ip_ver)
        exec_cmd_no_error(node, cmd, sudo=True)

    @staticmethod
    def get_linux_interface_name(node, pci_addr):
        """Get the interface name.

        :param node: VPP/TG node.
        :param pci_addr: PCI address
        :type node: dict
        :type pci_addr: str
        :returns: Interface name
        :rtype: str
        :raises RuntimeError: If cannot get the information about interfaces.
        """
        regex_intf_info = r"pci@" \
                          r"([0-9a-f]{4}:[0-9a-f]{2}:[0-9a-f]{2}.[0-9a-f])\s*" \
                          r"([a-zA-Z0-9]*)\s*network"

        cmd = "lshw -class network -businfo"
        ret_code, stdout, stderr = exec_cmd(node, cmd, timeout=30, sudo=True)
        if ret_code != 0:
            raise RuntimeError('Could not get information about interfaces:\n'
                               '{err}'.format(err=stderr))

        for line in stdout.splitlines()[2:]:
            try:
                if re.search(regex_intf_info, line).group(1) == pci_addr:
                    return re.search(regex_intf_info, line).group(2)
            except AttributeError:
                continue
        return None

    @staticmethod
    def set_linux_interface_up(node, interface):
        """Set the specified interface up.

        :param node: VPP/TG node.
        :param interface: Interface in namespace.
        :type node: dict
        :type interface: str
        :raises RuntimeError: If the interface could not be set up.
        """
        cmd = "ip link set {0} up".format(interface)
        exec_cmd_no_error(node, cmd, timeout=30, sudo=True)

    @staticmethod
    def set_linux_interface_ip(node, interface, ip_addr, prefix,
                               namespace=None):
        """Set IP address to interface in linux.

        :param node: VPP/TG node.
        :param interface: Interface in namespace.
        :param ip_addr: IP to be set on interface.
        :param prefix: IP prefix.
        :param namespace: Execute command in namespace. Optional
        :type node: dict
        :type interface: str
        :type ip_addr: str
        :type prefix: int
        :type namespace: str
        :raises RuntimeError: IP could not be set.
        """
        if namespace is not None:
            cmd = 'ip netns exec {ns} ip addr add {ip}/{p} dev {dev}'.format(
                ns=namespace, ip=ip_addr, p=prefix, dev=interface)
        else:
            cmd = 'ip addr add {ip}/{p} dev {dev}'.format(
                ip=ip_addr, p=prefix, dev=interface)

        exec_cmd_no_error(node, cmd, timeout=5, sudo=True)

    @staticmethod
    def add_linux_route(node, ip_addr, prefix, gateway, namespace=None):
        """Add linux route in namespace.

        :param node: Node where to execute command.
        :param ip_addr: Route destination IP address.
        :param prefix: IP prefix.
        :param namespace: Execute command in namespace. Optional.
        :param gateway: Gateway address.
        :type node: dict
        :type ip_addr: str
        :type prefix: int
        :type gateway: str
        :type namespace: str
        """
        if namespace is not None:
            cmd = 'ip netns exec {} ip route add {}/{} via {}'.format(
                namespace, ip_addr, prefix, gateway)
        else:
            cmd = 'ip route add {}/{} via {}'.format(ip_addr, prefix, gateway)
        exec_cmd_no_error(node, cmd, sudo=True)

    @staticmethod
    def vpp_interface_set_ip_address(node, interface, address,
                                     prefix_length=None):
        """Set IP address to VPP interface.

        :param node: VPP node.
        :param interface: Interface name.
        :param address: IP address.
        :param prefix_length: Prefix length.
        :type node: dict
        :type interface: str
        :type address: str
        :type prefix_length: int
        """
        try:
            ip_addr = IPv6Address(unicode(address))
            af_inet = AF_INET6
            is_ipv6 = 1
        except (AddressValueError, NetmaskValueError):
            ip_addr = IPv4Address(unicode(address))
            af_inet = AF_INET
            is_ipv6 = 0

        cmd = 'sw_interface_add_del_address'
        args = dict(
            sw_if_index=InterfaceUtil.get_interface_index(node, interface),
            is_add=1,
            is_ipv6=is_ipv6,
            del_all=0,
            address_length=int(prefix_length) if prefix_length else 128
            if is_ipv6 else 32,
            address=inet_pton(af_inet, str(ip_addr)))
        err_msg = 'Failed to add IP address on interface {ifc}'.format(
            ifc=interface)
        with PapiExecutor(node) as papi_exec:
            papi_exec.add(cmd, **args).get_replies(err_msg). \
                verify_reply(err_msg=err_msg)

    @staticmethod
    def vpp_add_ip_neighbor(node, iface_key, ip_addr, mac_address):
        """Add IP neighbor on DUT node.

        :param node: VPP node.
        :param iface_key: Interface key.
        :param ip_addr: IP address of the interface.
        :param mac_address: MAC address of the interface.
        :type node: dict
        :type iface_key: str
        :type ip_addr: str
        :type mac_address: str
        """
        try:
            dst_ip = IPv6Address(unicode(ip_addr))
        except (AddressValueError, NetmaskValueError):
            dst_ip = IPv4Address(unicode(ip_addr))

        neighbor = dict(
            sw_if_index=Topology.get_interface_sw_index(
                node, iface_key),
            flags=0,
            mac_address=str(mac_address),
            ip_address=str(dst_ip))
        cmd = 'ip_neighbor_add_del'
        args = dict(
            is_add=1,
            neighbor=neighbor)
        err_msg = 'Failed to add IP neighbor on interface {ifc}'.format(
            ifc=iface_key)
        with PapiExecutor(node) as papi_exec:
            papi_exec.add(cmd, **args).get_replies(err_msg). \
                verify_reply(err_msg=err_msg)

    @staticmethod
    def vpp_route_add(node, network, prefix_len, **kwargs):
        """Add route to the VPP node.

        :param node: VPP node.
        :param network: Route destination network address.
        :param prefix_len: Route destination network prefix length.
        :param kwargs: Optional key-value arguments:

            gateway: Route gateway address. (str)
            interface: Route interface. (str)
            vrf: VRF table ID. (int)
            count: number of IP addresses to add starting from network IP (int)
            local: The route is local with same prefix (increment is 1).
                If None, then is not used. (bool)
            lookup_vrf: VRF table ID for lookup. (int)
            multipath: Enable multipath routing. (bool)
            weight: Weight value for unequal cost multipath routing. (int)

        :type node: dict
        :type network: str
        :type prefix_len: int
        :type kwargs: dict
        """
        interface = kwargs.get('interface', None)
        gateway = kwargs.get('gateway', None)

        try:
            net_addr = IPv6Address(unicode(network))
            af_inet = AF_INET6
            is_ipv6 = 1
        except (AddressValueError, NetmaskValueError):
            net_addr = IPv4Address(unicode(network))
            af_inet = AF_INET
            is_ipv6 = 0

        if gateway:
            try:
                gt_addr = IPv6Address(unicode(gateway))
                af_inet_gt = AF_INET6
            except (AddressValueError, NetmaskValueError):
                gt_addr = IPv4Address(unicode(gateway))
                af_inet_gt = AF_INET

        cmd = 'ip_add_del_route'
        args = dict(
            next_hop_sw_if_index=InterfaceUtil.get_interface_index(
                node, interface) if interface else Constants.BITWISE_NON_ZERO,
            table_id=int(kwargs.get('vrf', 0)),
            is_add=1,
            is_ipv6=is_ipv6,
            is_local=int(kwargs.get('local', False)),
            is_multipath=int(kwargs.get('multipath', False)),
            next_hop_weight=int(kwargs.get('weight', 1)),
            next_hop_proto=1 if is_ipv6 else 0,
            dst_address_length=int(prefix_len),
            next_hop_address=inet_pton(af_inet_gt, str(gt_addr)) if gateway
            else 0,
            next_hop_table_id=int(kwargs.get('lookup_vrf', 0)))
        err_msg = 'Failed to add route(s) on host {host}'.format(
            host=node['host'])
        with PapiExecutor(node) as papi_exec:
            for i in xrange(kwargs.get('count', 1)):
                papi_exec.add(cmd, dst_address=inet_pton(
                    af_inet, str(net_addr+i)), **args)
            papi_exec.get_replies(err_msg).verify_replies(err_msg=err_msg)

    @staticmethod
    def vpp_nodes_set_ipv4_addresses(nodes, nodes_addr):
        """Set IPv4 addresses on all VPP nodes in topology.

        :param nodes: Nodes of the test topology.
        :param nodes_addr: Available nodes IPv4 addresses.
        :type nodes: dict
        :type nodes_addr: dict
        :returns: Affected interfaces as list of (node, interface) tuples.
        :rtype: list
        """
        interfaces = []
        for net in nodes_addr.values():
            for port in net['ports'].values():
                host = port.get('node')
                if host is None:
                    continue
                topo = Topology()
                node = topo.get_node_by_hostname(nodes, host)
                if node is None:
                    continue
                if node['type'] != NodeType.DUT:
                    continue
                iface_key = topo.get_interface_by_name(node, port['if'])
                IPUtil.vpp_interface_set_ip_address(
                    node, iface_key, port['addr'], net['prefix'])
                interfaces.append((node, port['if']))

        return interfaces

    @staticmethod
    def flush_ip_addresses(node, interface):
        """Flush all IPv4addresses from specified interface.

        :param node: VPP node.
        :param interface: Interface name.
        :type node: dict
        :type interface: str
        """
        cmd = 'sw_interface_add_del_address'
        args = dict(
            sw_if_index=InterfaceUtil.get_interface_index(node, interface),
            del_all=1)
        err_msg = 'Failed to flush IP address on interface {ifc}'.format(
            ifc=interface)
        with PapiExecutor(node) as papi_exec:
            papi_exec.add(cmd, **args).get_replies(err_msg). \
                verify_reply(err_msg=err_msg)

    @staticmethod
    def add_fib_table(node, table_id, ipv6=False):
        """Create new FIB table according to ID.

        :param node: Node to add FIB on.
        :param table_id: FIB table ID.
        :param ipv6: Is this an IPv6 table
        :type node: dict
        :type table_id: int
        :type ipv6: bool
        """
        cmd = 'ip_table_add_del'
        args = dict(
            table_id=int(table_id),
            is_ipv6=int(ipv6),
            is_add=1)
        err_msg = 'Failed to add FIB table on host {host}'.format(
            host=node['host'])
        with PapiExecutor(node) as papi_exec:
            papi_exec.add(cmd, **args).get_replies(err_msg). \
                verify_reply(err_msg=err_msg)