resources/tools/topology/update_topology.py

   1 #!/usr/bin/env python2.7
   2 # Copyright (c) 2016 Cisco and/or its affiliates.
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at:
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 """This executable python module gathers MAC address data from topology nodes.
  16 It requires that all interfaces/port elements in topology have driver field.
  17 This script binds the port in given node to set linux kernel driver and
  18 extracts MAC address from it."""
  19
  20 import sys
  21 import os
  22 import re
  23 from argparse import ArgumentParser
  24
  25 import yaml
  26
  27 from resources.libraries.python.ssh import SSH
  28
  29
  30 def load_topology(args):
  31     """Load topology file referenced to by parameter passed to this script.
  32
  33     :param args: Arguments parsed from commandline.
  34     :type args: ArgumentParser().parse_args()
  35     :return: Python representation of topology YAML.
  36     :rtype: dict
  37     """
  38     data = None
  39     with open(args.topology, 'r') as stream:
  40         try:
  41             data = yaml.load(stream)
  42         except yaml.YAMLError as exc:
  43             print 'Failed to load topology file: {0}'.format(args.topology)
  44             print exc
  45             raise
  46
  47     return data
  48
  49
  50 def ssh_no_error(ssh, cmd):
  51     """Execute a command over ssh channel, and log and exit if the command
  52     fails.
  53
  54     :param ssh: SSH() object connected to a node.
  55     :param cmd: Command line to execute on remote node.
  56     :type ssh: SSH() object
  57     :type cmd: str
  58     :return: stdout from the SSH command.
  59     :rtype: str
  60     """
  61     ret, stdo, stde = ssh.exec_command(cmd)
  62     if ret != 0:
  63         print 'Command execution failed: "{}"'.format(cmd)
  64         print 'stdout: {0}'.format(stdo)
  65         print 'stderr: {0}'.format(stde)
  66         raise RuntimeError('Unexpected ssh command failure')
  67
  68     return stdo
  69
  70
  71 def update_mac_addresses_for_node(node):
  72     """For given node loop over all ports with PCI address and look for its MAC
  73     address.
  74
  75     This function firstly unbinds the PCI device from its current driver
  76     and binds it to linux kernel driver. After the device is bound to specific
  77     linux kernel driver the MAC address is extracted from /sys/bus/pci location
  78     and stored within the node dictionary that was passed to this function.
  79
  80     :param node: Node from topology.
  81     :type node: dict
  82     """
  83     for port_name, port in node['interfaces'].items():
  84         if 'driver' not in port:
  85             err_msg = '{0} port {1} has no driver element, exiting'.format(
  86                     node['host'], port_name)
  87             raise RuntimeError(err_msg)
  88
  89         ssh = SSH()
  90         ssh.connect(node)
  91
  92         # TODO: make following SSH commands into one-liner to save on SSH opers
  93
  94         # First unbind from current driver
  95         drvr_dir_path = '/sys/bus/pci/devices/{0}/driver'.format(
  96                 port['pci_address'])
  97         cmd = '''\
  98             if [ -d {0} ]; then
  99                 echo {1} | sudo tee {0}/unbind ;
 100             else
 101                 true Do not have to do anything, port already unbound ;
 102             fi'''.format(drvr_dir_path, port['pci_address'])
 103         ssh_no_error(ssh, cmd)
 104
 105         # Then bind to the 'driver' from topology for given port
 106         cmd = 'echo {0} | sudo tee /sys/bus/pci/drivers/{1}/bind'.\
 107               format(port['pci_address'], port['driver'])
 108         ssh_no_error(ssh, cmd)
 109
 110         # Then extract the mac address and store it in the topology
 111         cmd = 'cat /sys/bus/pci/devices/{0}/net/*/address'.format(
 112                 port['pci_address'])
 113         mac = ssh_no_error(ssh, cmd).strip()
 114         pattern = re.compile("^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$")
 115         if not pattern.match(mac):
 116             raise RuntimeError('MAC address read from host {0} {1} is in '
 117                                'bad format "{2}"'
 118                                .format(node['host'], port['pci_address'], mac))
 119         print '{0}: Found MAC address of PCI device {1}: {2}'.format(
 120                 node['host'], port['pci_address'], mac)
 121         port['mac_address'] = mac
 122
 123
 124 def update_nodes_mac_addresses(topology):
 125     """Loop over nodes in topology and get mac addresses for all listed ports
 126     based on PCI addresses.
 127
 128     :param topology: Topology information with nodes.
 129     :type topology: dict
 130     """
 131     for node in topology['nodes'].values():
 132         update_mac_addresses_for_node(node)
 133
 134
 135 def dump_updated_topology(topology, args):
 136     """Writes or prints out updated topology file.
 137
 138     :param topology: Topology information with nodes.
 139     :param args: Arguments parsed from command line.
 140     :type topology: dict
 141     :type args: ArgumentParser().parse_args()
 142     :return: 1 if error occurred, 0 if successful.
 143     :rtype: int
 144     """
 145     if args.output_file:
 146         if not args.force:
 147             if os.path.isfile(args.output_file):
 148                 print ('File {0} already exists. If you want to overwrite this '
 149                        'file, add -f as a parameter to this script'.format(
 150                            args.output_file))
 151                 return 1
 152         with open(args.output_file, 'w') as stream:
 153             yaml.dump(topology, stream, default_flow_style=False)
 154     else:
 155         print yaml.dump(topology, default_flow_style=False)
 156     return 0
 157
 158
 159 def main():
 160     """Main function"""
 161     parser = ArgumentParser()
 162     parser.add_argument('topology', help="Topology yaml file to read")
 163     parser.add_argument('--output-file', '-o', help='Output file')
 164     parser.add_argument('-f', '--force', help='Overwrite existing file',
 165                         action='store_const', const=True)
 166     parser.add_argument('--verbose', '-v', action='store_true')
 167     args = parser.parse_args()
 168
 169     topology = load_topology(args)
 170     update_nodes_mac_addresses(topology)
 171     ret = dump_updated_topology(topology, args)
 172
 173     return ret
 174
 175
 176 if __name__ == "__main__":
 177     sys.exit(main())