fix(vpp_device): pci address existence condition
[csit.git] / resources / tools / topology / update_topology.py
index a5711d0..37d64b1 100755 (executable)
@@ -20,6 +20,7 @@ extracts MAC address from it."""
 import sys
 import os
 import re
+
 from argparse import ArgumentParser
 
 import yaml
@@ -36,12 +37,12 @@ def load_topology(args):
     :rtype: dict
     """
     data = None
-    with open(args.topology, 'r') as stream:
+    with open(args.topology, u"rt") as stream:
         try:
-            data = yaml.load(stream)
+            data = yaml.safe_load(stream)
         except yaml.YAMLError as exc:
-            print 'Failed to load topology file: {0}'.format(args.topology)
-            print exc
+            print(f"Failed to load topology file: {args.topology}")
+            print(exc)
             raise
 
     return data
@@ -59,11 +60,11 @@ def ssh_no_error(ssh, cmd):
     :rtype: str
     """
     ret, stdo, stde = ssh.exec_command(cmd)
-    if 0 != ret:
-        print 'Command execution failed: "{}"'.format(cmd)
-        print 'stdout: {0}'.format(stdo)
-        print 'stderr: {0}'.format(stde)
-        raise RuntimeError('Unexpected ssh command failure')
+    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
 
@@ -79,13 +80,13 @@ def update_mac_addresses_for_node(node):
 
     :param node: Node from topology.
     :type node: dict
-    :return: None
     """
-    for port_name, port in node['interfaces'].items():
-        if 'driver' not in port:
-            err_msg = '{0} port {1} has no driver element, exiting'.format(
-                    node['host'], port_name)
-            raise RuntimeError(err_msg)
+    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)
@@ -93,33 +94,34 @@ def update_mac_addresses_for_node(node):
         # TODO: make following SSH commands into one-liner to save on SSH opers
 
         # First unbind from current driver
-        drvr_dir_path = '/sys/bus/pci/devices/{0}/driver'.format(
-                port['pci_address'])
-        cmd = '''\
-            if [ -d {0} ]; then
-                echo {1} | sudo tee {0}/unbind ;
+        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'''.format(drvr_dir_path, port['pci_address'])
+            fi'''
         ssh_no_error(ssh, cmd)
 
         # Then bind to the 'driver' from topology for given port
-        cmd = 'echo {0} | sudo tee /sys/bus/pci/drivers/{1}/bind'.\
-              format(port['pci_address'], port['driver'])
+        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 = 'cat /sys/bus/pci/devices/{0}/net/*/address'.format(
-                port['pci_address'])
+        cmd = f"cat /sys/bus/pci/devices/{port['pci_address']}/net/*/address"
         mac = ssh_no_error(ssh, cmd).strip()
-        pattern = re.compile("^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$")
+        pattern = re.compile(u"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$")
         if not pattern.match(mac):
-            raise RuntimeError('MAC address read from host {0} {1} is in '
-                               'bad format "{2}"'
-                               .format(node['host'], port['pci_address'], mac))
-        print '{0}: Found MAC address of PCI device {1}: {2}'.format(
-                node['host'], port['pci_address'], mac)
-        port['mac_address'] = 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):
@@ -128,9 +130,8 @@ def update_nodes_mac_addresses(topology):
 
     :param topology: Topology information with nodes.
     :type topology: dict
-    :return: None
     """
-    for node in topology['nodes'].values():
+    for node in topology[u"nodes"].values():
         update_mac_addresses_for_node(node)
 
 
@@ -147,25 +148,28 @@ def dump_updated_topology(topology, args):
     if args.output_file:
         if not args.force:
             if os.path.isfile(args.output_file):
-                print ('File {0} already exists. If you want to overwrite this '
-                       'file, add -f as a parameter to this script'.format(
-                           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, 'w') as stream:
+        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)
+        print(yaml.dump(topology, default_flow_style=False))
     return 0
 
 
 def main():
     """Main function"""
     parser = ArgumentParser()
-    parser.add_argument('topology', help="Topology yaml file to read")
-    parser.add_argument('--output-file', '-o', help='Output file')
-    parser.add_argument('-f', '--force', help='Overwrite existing file',
-                        action='store_const', const=True)
-    parser.add_argument('--verbose', '-v', action='store_true')
+    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)
@@ -175,5 +179,5 @@ def main():
     return ret
 
 
-if __name__ == "__main__":
+if __name__ == u"__main__":
     sys.exit(main())