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
|
# Copyright (c) 2018 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 ipaddress import IPv4Network, ip_address
from resources.libraries.python.ssh import SSH
from resources.libraries.python.Constants import Constants
from resources.libraries.python.ssh import exec_cmd_no_error, exec_cmd
from resources.libraries.python.topology import 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_ip_probe(node, interface, addr, if_type="key"):
"""Run ip probe on VPP node.
:param node: VPP node.
:param interface: Interface key or name.
:param addr: IPv4/IPv6 address.
:param if_type: Interface type
:type node: dict
:type interface: str
:type addr: str
:type if_type: str
:raises ValueError: If the if_type is unknown.
:raises Exception: If vpp probe fails.
"""
ssh = SSH()
ssh.connect(node)
if if_type == "key":
iface_name = Topology.get_interface_name(node, interface)
elif if_type == "name":
iface_name = interface
else:
raise ValueError("if_type unknown: {0}".format(if_type))
cmd = "{c}".format(c=Constants.VAT_BIN_NAME)
cmd_input = 'exec ip probe {dev} {ip}'.format(dev=iface_name, ip=addr)
(ret_code, _, _) = ssh.exec_command_sudo(cmd, cmd_input)
if int(ret_code) != 0:
raise Exception('VPP ip probe {dev} {ip} failed on {h}'.format(
dev=iface_name, ip=addr, h=node['host']))
@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: Node to set namespace on.
: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 vhost_if: 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: Node to enable forwarding on.
: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: Node where to execute command.
: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, '
'reason:{0}'.format(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: Node where to execute command.
: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)
ret_code, _, stderr = exec_cmd(node, cmd, timeout=30, sudo=True)
if ret_code != 0:
raise RuntimeError('Could not set the interface up, reason:{0}'.
format(stderr))
@staticmethod
def set_linux_interface_ip(node, interface, ip_addr, prefix,
namespace=None):
"""Set IP address to interface in linux.
:param node: Node where to execute command.
: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 {} ip addr add {}/{} dev {}'.format(
namespace, ip_addr, prefix, interface)
else:
cmd = 'ip addr add {}/{} dev {}'.format(ip_addr, prefix, interface)
(ret_code, _, stderr) = exec_cmd(node, cmd, timeout=5, sudo=True)
if ret_code != 0:
raise RuntimeError(
'Could not set IP for interface, reason:{}'.format(stderr))
@staticmethod
def set_linux_interface_route(node, interface, route, namespace=None):
"""Set route via interface in linux.
:param node: Node where to execute command.
:param interface: Interface in namespace.
:param route: Route to be added via interface.
:param namespace: Execute command in namespace. Optional parameter.
:type node: dict
:type interface: str
:type route: str
:type namespace: str
"""
if namespace is not None:
cmd = 'ip netns exec {} ip route add {} dev {}'.format(
namespace, route, interface)
else:
cmd = 'ip route add {} dev {}'.format(route, interface)
exec_cmd_no_error(node, cmd, sudo=True)
def convert_ipv4_netmask_prefix(network):
"""Convert network mask to equivalent network prefix length or vice versa.
Example: mask 255.255.0.0 -> prefix length 16
:param network: Network mask or network prefix length.
:type network: str or int
:returns: Network mask or network prefix length.
:rtype: str or int
"""
temp_address = "0.0.0.0"
net = IPv4Network(u"{0}/{1}".format(temp_address, network), False)
if isinstance(network, int) and (0 < network < 33):
return str(net.netmask)
elif isinstance(network, basestring):
return int(net.prefixlen)
else:
raise Exception("Value {0} is not a valid ipv4 netmask or network"
" prefix length".format(network))
|
