Fix warnings reported by gen_doc.sh
[csit.git] / resources / libraries / python / IPv4Util.py
1 # Copyright (c) 2018 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 """Implements IPv4 RobotFramework keywords"""
15
16 from robot.api import logger as log
17 from robot.api.deco import keyword
18
19 from resources.libraries.python.topology import Topology
20 from resources.libraries.python.IPv4Setup import get_node
21 from resources.libraries.python.ssh import exec_cmd
22
23
24 class IPv4Util(object):
25     """Implements keywords for IPv4 tests."""
26
27     @staticmethod
28     @keyword('From node "${node}" interface "${port}" ARP-ping '
29              'IPv4 address "${ip_address}"')
30     def arp_ping(node, interface, ip_address):
31         """Send an ARP ping from the specified node.
32
33         :param node: Node in topology.
34         :param ip_address: Destination IP address for the ARP packet.
35         :param interface: Name of an interface to send the ARP packet from.
36         :type node: dict
37         :type ip_address: str
38         :type interface: str
39         """
40         log.debug('From node {} interface {} ARP-ping IPv4 address {}'.
41                   format(Topology.get_node_hostname(node),
42                          interface, ip_address))
43         get_node(node).arp_ping(ip_address, interface)
44
45     @staticmethod
46     def set_interface_address(node, interface, address, prefix_length):
47         """See IPv4Node.set_ip for more information.
48
49         :param node: Node where IP address should be set to.
50         :param interface: Interface name.
51         :param address: IP address.
52         :param prefix_length: Prefix length.
53         :type node: dict
54         :type interface: str
55         :type address: str
56         :type prefix_length: int
57         """
58         log.debug('Node {} interface {} has IPv4 address {} with prefix '
59                   'length {}'.format(Topology.get_node_hostname(node),
60                                      interface, address, prefix_length))
61         get_node(node).set_ip(interface, address, int(prefix_length))
62
63     @staticmethod
64     def set_route(node, network, prefix_length, interface, gateway):
65         """See IPv4Node.set_route for more information.
66
67         :param node: Node where IP address should be set to.
68         :param network: IP network.
69         :param prefix_length: Prefix length.
70         :param interface: Interface name.
71         :param gateway: Gateway.
72         :type node: dict
73         :type network: str
74         :type prefix_length: int
75         :type interface: str
76         :type gateway: str
77         """
78         log.debug('Node {} routes to network {} with prefix length {} '
79                   'via {} interface {}'.format(Topology.get_node_hostname(node),
80                                                network, prefix_length,
81                                                gateway, interface))
82         get_node(node).set_route(network, int(prefix_length),
83                                  gateway, interface)
84
85     @staticmethod
86     @keyword('Get IPv4 address prefix of node "${node}" interface "${port}" '
87              'from "${nodes_addr}"')
88     def get_ip_addr_prefix_length(node, port, nodes_addr):
89         """ Get IPv4 address prefix for specified interface.
90
91         :param node: Node dictionary.
92         :param port: Interface name.
93         :param nodes_addr: Available nodes IPv4 addresses.
94         :type node: dict
95         :type port: str
96         :type nodes_addr: dict
97         :returns: IPv4 prefix length.
98         :rtype: int
99         """
100         for net in nodes_addr.values():
101             for net_port in net['ports'].values():
102                 if net_port['node'] == node['host'] and net_port['if'] == port:
103                     return net['prefix']
104
105         raise Exception('Subnet not found for node {n} port {p}'.
106                         format(n=node['host'], p=port))
107
108     @staticmethod
109     @keyword('Get IPv4 subnet of node "${node}" interface "${port}" from '
110              '"${nodes_addr}"')
111     def get_ip_addr_subnet(node, port, nodes_addr):
112         """ Get IPv4 subnet of specified interface.
113
114         :param node: Node dictionary.
115         :param port: Interface name.
116         :param nodes_addr: Available nodes IPv4 addresses.
117         :type node: dict
118         :type port: int
119         :type nodes_addr: dict
120         :returns: IPv4 subnet.
121         :rtype: str
122         """
123         for net in nodes_addr.values():
124             for net_port in net['ports'].values():
125                 if net_port['node'] == node['host'] and net_port['if'] == port:
126                     return net['net_addr']
127
128         raise Exception('Subnet not found for node {n} port {p}'.
129                         format(n=node['host'], p=port))
130
131     @staticmethod
132     @keyword('Flush IPv4 addresses "${port}" "${node}"')
133     def flush_ip_addresses(port, node):
134         """See IPv4Node.flush_ip_addresses for more information.
135
136         :param port: FIXME
137         :param node: FIXME
138         :returns: FIXME
139         """
140         get_node(node).flush_ip_addresses(port)
141
142     @staticmethod
143     def get_link_address(link, nodes_addr):
144         """Get link IPv4 address.
145
146         :param link: Link name.
147         :param nodes_addr: Available nodes IPv4 addresses.
148         :type link: str
149         :type nodes_addr: dict
150         :returns: Link IPv4 address.
151         :rtype: str
152         """
153         net = nodes_addr.get(link)
154         if net is None:
155             raise ValueError('Link "{0}" not found'.format(link))
156         return net.get('net_addr')
157
158     @staticmethod
159     def get_link_prefix(link, nodes_addr):
160         """Get link IPv4 address prefix.
161
162         :param link: Link name.
163         :param nodes_addr: Available nodes IPv4 addresses.
164         :type link: str
165         :type nodes_addr: dict
166         :returns: Link IPv4 address prefix.
167         :rtype: int
168         """
169         net = nodes_addr.get(link)
170         if net is None:
171             raise ValueError('Link "{0}" not found'.format(link))
172         return net.get('prefix')
173
174     @staticmethod
175     def send_ping_from_node_to_dst(node, destination, namespace=None,
176                                    ping_count=3, interface=None):
177         """Send a ping from node to destination. Optionally, you can define a
178         namespace and interface from where to send a ping.
179
180         :param node: Node to start ping on.
181         :param destination: IPv4 address where to send ping.
182         :param namespace: Namespace to send ping from. Optional
183         :param ping_count: Number of pings to send. Default 3
184         :param interface: Interface from where to send ping. Optional
185         :type node: dict
186         :type destination: str
187         :type namespace: str
188         :type ping_count: int
189         :type interface: str
190         :raises RuntimeError: If no response for ping, raise error
191         """
192         cmd = ''
193         if namespace is not None:
194             cmd = 'ip netns exec {0} ping -c{1} {2}'.format(
195                 namespace, ping_count, destination)
196         elif interface is not None:
197             cmd = 'ping -I {0} -c{1} {2}'.format(
198                 interface, ping_count, destination)
199         else:
200             cmd = 'ping -c{0} {1}'.format(ping_count, destination)
201         ret_code, _, _ = exec_cmd(node, cmd, sudo=True)
202         if ret_code != 0:
203             raise RuntimeError("Ping Not Successful")
204
205     @staticmethod
206     def set_linux_interface_arp(node, interface, ip_addr, mac, namespace=None):
207         """Set arp on interface in linux.
208
209         :param node: Node where to execute command.
210         :param interface: Interface in namespace.
211         :param ip_addr: IP address for ARP entry.
212         :param mac: MAC address.
213         :param namespace: Execute command in namespace. Optional
214         :type node: dict
215         :type interface: str
216         :type ip_addr: str
217         :type mac: str
218         :type namespace: str
219         :raises RuntimeError: Could not set ARP properly.
220         """
221         if namespace is not None:
222             cmd = 'ip netns exec {} arp -i {} -s {} {}'.format(
223                 namespace, interface, ip_addr, mac)
224         else:
225             cmd = 'arp -i {} -s {} {}'.format(interface, ip_addr, mac)
226         ret_code, _, stderr = exec_cmd(node, cmd, sudo=True)
227         if ret_code != 0:
228             raise RuntimeError("Arp set not successful, reason:{}".
229                                format(stderr))

©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.