54196ebf52e5021ec12b1a9dea86f441e6c3b9c4
[csit.git] / resources / libraries / python / IPv6Util.py
1 # Copyright (c) 2016 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 """IPv6 utilities library."""
15
16 import re
17
18 from resources.libraries.python.ssh import SSH
19 from resources.libraries.python.VatExecutor import VatTerminal
20 from resources.libraries.python.topology import Topology
21
22
23 class IPv6Util(object):
24     """IPv6 utilities"""
25
26     @staticmethod
27     def ipv6_ping(src_node, dst_addr, count=3, data_size=56, timeout=1):
28         """IPv6 ping.
29
30         :param src_node: Node where ping run.
31         :param dst_addr: Destination IPv6 address.
32         :param count: Number of echo requests. (Optional)
33         :param data_size: Number of the data bytes. (Optional)
34         :param timeout: Time to wait for a response, in seconds. (Optional)
35         :type src_node: dict
36         :type dst_addr: str
37         :type count: int
38         :type data_size: int
39         :type timeout: int
40         :return: Number of lost packets.
41         :rtype: int
42         """
43         ssh = SSH()
44         ssh.connect(src_node)
45
46         cmd = "ping6 -c {c} -s {s} -W {W} {dst}".format(c=count, s=data_size,
47                                                         W=timeout,
48                                                         dst=dst_addr)
49         (ret_code, stdout, _) = ssh.exec_command(cmd)
50
51         regex = re.compile(r'(\d+) packets transmitted, (\d+) received')
52         match = regex.search(stdout)
53         sent, received = match.groups()
54         packet_lost = int(sent) - int(received)
55
56         return packet_lost
57
58     @staticmethod
59     def ipv6_ping_port(nodes_ip, src_node, dst_node, port, cnt=3,
60                        size=56, timeout=1):
61         """Send IPv6 ping to the node port.
62
63         :param nodes_ip: Nodes IPv6 addresses.
64         :param src_node: Node where ping run.
65         :param dst_node: Destination node.
66         :param port: Port on the destination node.
67         :param cnt: Number of echo requests. (Optional)
68         :param size: Number of the data bytes. (Optional)
69         :param timeout: Time to wait for a response, in seconds. (Optional)
70         :type nodes_ip: dict
71         :type src_node: dict
72         :type dst_node: dict
73         :type port: str
74         :type cnt: int
75         :type size: int
76         :type timeout: int
77         :return: Number of lost packets.
78         :rtype: int
79         """
80         dst_ip = IPv6Util.get_node_port_ipv6_address(dst_node, port, nodes_ip)
81         return IPv6Util.ipv6_ping(src_node, dst_ip, cnt, size, timeout)
82
83     @staticmethod
84     def get_node_port_ipv6_address(node, iface_key, nodes_addr):
85         """Return IPv6 address of the node port.
86
87         :param node: Node in the topology.
88         :param iface_key: Interface key of the node.
89         :param nodes_addr: Nodes IPv6 addresses.
90         :type node: dict
91         :type iface_key: str
92         :type nodes_addr: dict
93         :return: IPv6 address string.
94         :rtype: str
95         """
96         interface = Topology.get_interface_name(node, iface_key)
97         for net in nodes_addr.values():
98             for port in net['ports'].values():
99                 host = port.get('node')
100                 dev = port.get('if')
101                 if host == node['host'] and dev == interface:
102                     ip = port.get('addr')
103                     if ip is not None:
104                         return ip
105                     else:
106                         raise Exception(
107                             'Node {n} port {p} IPv6 address is not set'.format(
108                                 n=node['host'], p=interface))
109
110         raise Exception('Node {n} port {p} IPv6 address not found.'.format(
111             n=node['host'], p=interface))
112
113     @staticmethod
114     def add_ip_neighbor(node, interface, ip_address, mac_address, vrf=None):
115         """Add IP neighbor.
116
117         :param node: VPP node to add ip neighbor.
118         :param interface: Interface name or sw_if_index.
119         :param ip_address: IP address.
120         :param mac_address: MAC address.
121         :param vrf: VRF table ID (Optional).
122         :type node: dict
123         :type interface: str or int
124         :type ip_address: str
125         :type mac_address: str
126         :type vrf: int
127         """
128         vrf = "vrf {}".format(vrf) if vrf else ''
129
130         if isinstance(interface, basestring):
131             sw_if_index = Topology.get_interface_sw_index(node, interface)
132         else:
133             sw_if_index = interface
134
135         with VatTerminal(node) as vat:
136             vat.vat_terminal_exec_cmd_from_template("add_ip_neighbor.vat",
137                                                     sw_if_index=sw_if_index,
138                                                     ip_address=ip_address,
139                                                     mac_address=mac_address,
140                                                     vrf=vrf)

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.