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
|
#!/usr/bin/env python2.7
# Copyright (c) 2016 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.
"""This executable python module gathers MAC address data from topology nodes.
It requires that all interfaces/port elements in topology have driver field.
This script binds the port in given node to set linux kernel driver and
extracts MAC address from it."""
import sys
import os
import re
from argparse import ArgumentParser
import yaml
from resources.libraries.python.ssh import SSH
def load_topology(args):
"""Load topology file referenced to by parameter passed to this script.
:param args: Arguments parsed from commandline.
:type args: ArgumentParser().parse_args()
:return: Python representation of topology YAML.
:rtype: dict
"""
data = None
with open(args.topology, u"rt") as stream:
try:
data = yaml.safe_load(stream)
except yaml.YAMLError as exc:
print(f"Failed to load topology file: {args.topology}")
print(exc)
raise
return data
def ssh_no_error(ssh, cmd):
"""Execute a command over ssh channel, and log and exit if the command
fails.
:param ssh: SSH() object connected to a node.
:param cmd: Command line to execute on remote node.
:type ssh: SSH() object
:type cmd: str
:return: stdout from the SSH command.
:rtype: str
"""
ret, stdo, stde = ssh.exec_command(cmd)
if ret != 0:
print(f"Command execution failed: '{cmd}'")
print(f"stdout: {stdo}")
print(f"stderr: {stde}")
raise RuntimeError(u"Unexpected ssh command failure")
return stdo
def update_mac_addresses_for_node(node):
"""For given node loop over all ports with PCI address and look for its MAC
address.
This function firstly unbinds the PCI device from its current driver
and binds it to linux kernel driver. After the device is bound to specific
linux kernel driver the MAC address is extracted from /sys/bus/pci location
and stored within the node dictionary that was passed to this function.
:param node: Node from topology.
:type node: dict
"""
for port_name, port in node[u"interfaces"].items():
if u"driver" not in port:
raise RuntimeError(
f"{node[u'host']} port {port_name} has no driver element, "
f"exiting"
)
ssh = SSH()
ssh.connect(node)
# TODO: make following SSH commands into one-liner to save on SSH opers
# First unbind from current driver
drvr_dir_path = f"/sys/bus/pci/devices/{port[u'pci_address']}/driver"
cmd = f'''\
if [ -d {drvr_dir_path} ]; then
echo {port[u'pci_address']} | sudo tee {drvr_dir_path}/unbind ;
else
true Do not have to do anything, port already unbound ;
fi'''
ssh_no_error(ssh, cmd)
# Then bind to the 'driver' from topology for given port
cmd = f"echo {port[u'pci_address']} | " \
f"sudo tee /sys/bus/pci/drivers/{port[u'driver']}/bind"
ssh_no_error(ssh, cmd)
# Then extract the mac address and store it in the topology
cmd = f"cat /sys/bus/pci/devices/{port['pci_address']}/net/*/address"
mac = ssh_no_error(ssh, cmd).strip()
pattern = re.compile(u"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$")
if not pattern.match(mac):
raise RuntimeError(
f"MAC address read from host {node[u'host']} "
f"{port[u'pci_address']} is in bad format '{mac}'"
)
print(
f"{node[u'host']}: Found MAC address of PCI device "
f"{port[u'pci_address']}: {mac}"
)
port[u"mac_address"] = mac
def update_nodes_mac_addresses(topology):
"""Loop over nodes in topology and get mac addresses for all listed ports
based on PCI addresses.
:param topology: Topology information with nodes.
:type topology: dict
"""
for node in topology[u"nodes"].values():
update_mac_addresses_for_node(node)
def dump_updated_topology(topology, args):
"""Writes or prints out updated topology file.
:param topology: Topology information with nodes.
:param args: Arguments parsed from command line.
:type topology: dict
:type args: ArgumentParser().parse_args()
:return: 1 if error occurred, 0 if successful.
:rtype: int
"""
if args.output_file:
if not args.force:
if os.path.isfile(args.output_file):
print (
f"File {args.output_file} already exists. If you want to "
f"overwrite this file, add -f as a parameter to this script"
)
return 1
with open(args.output_file, u"wt") as stream:
yaml.dump(topology, stream, default_flow_style=False)
else:
print(yaml.dump(topology, default_flow_style=False))
return 0
def main():
"""Main function"""
parser = ArgumentParser()
parser.add_argument(u"topology", help=u"Topology yaml file to read")
parser.add_argument(u"--output-file", u"-o", help=u"Output file")
parser.add_argument(
u"-f", u"--force", help=u"Overwrite existing file",
action=u"store_const", const=True
)
parser.add_argument(u"--verbose", u"-v", action=u"store_true")
args = parser.parse_args()
topology = load_topology(args)
update_nodes_mac_addresses(topology)
ret = dump_updated_topology(topology, args)
return ret
if __name__ == u"__main__":
sys.exit(main())
|
