scripts: west_commands: sign: Remove deprecated west.log

The global state west.log is deprecated, replace with WestCommand
logging.

Signed-off-by: Pieter De Gendt <[email protected]>

Author: pdgendt

scripts/west_commands/sign.py

@@ -12,8 +12,8 @@
 import subprocess
 import sys
 
-from west import log
 from west import manifest
+from west.commands import Verbosity
 from west.util import quote_sh_list
 
 from build_helpers import find_build_dir, is_zephyr_build, \
@@ -189,16 +189,16 @@ def do_run(self, args, ignored):
         # Delegate to the signer.
         if args.tool == 'imgtool':
             if args.if_tool_available:
-                log.die('imgtool does not support --if-tool-available')
+                self.die('imgtool does not support --if-tool-available')
             signer = ImgtoolSigner()
         elif args.tool == 'rimage':
             signer = RimageSigner()
         # (Add support for other signers here in elif blocks)
         else:
             if args.tool is None:
-                log.die('one --tool is required')
+                self.die('one --tool is required')
             else:
-                log.die(f'invalid tool: {args.tool}')
+                self.die(f'invalid tool: {args.tool}')
 
         signer.sign(self, build_dir, build_conf, formats)
 
@@ -229,43 +229,43 @@ def sign(self, command, build_dir, build_conf, formats):
         args = command.args
         b = pathlib.Path(build_dir)
 
-        log.wrn("west sign using imgtool is deprecated and will be removed in a future release")
+        command.wrn("west sign using imgtool is deprecated and will be removed in a future release")
 
         imgtool = self.find_imgtool(command, args)
         # The vector table offset and application version are set in Kconfig:
         appver = self.get_cfg(command, build_conf, 'CONFIG_MCUBOOT_IMGTOOL_SIGN_VERSION')
         vtoff = self.get_cfg(command, build_conf, 'CONFIG_ROM_START_OFFSET')
         # Flash device write alignment and the partition's slot size
         # come from devicetree:
-        flash = self.edt_flash_node(b, args.quiet)
-        align, addr, size = self.edt_flash_params(flash)
+        flash = self.edt_flash_node(command, b, args.quiet)
+        align, addr, size = self.edt_flash_params(command, flash)
 
         if not build_conf.getboolean('CONFIG_BOOTLOADER_MCUBOOT'):
-            log.wrn("CONFIG_BOOTLOADER_MCUBOOT is not set to y in "
-                    f"{build_conf.path}; this probably won't work")
+            command.wrn("CONFIG_BOOTLOADER_MCUBOOT is not set to y in "
+                        f"{build_conf.path}; this probably won't work")
 
         kernel = build_conf.get('CONFIG_KERNEL_BIN_NAME', 'zephyr')
 
         if 'bin' in formats:
             in_bin = b / 'zephyr' / f'{kernel}.bin'
             if not in_bin.is_file():
-                log.die(f"no unsigned .bin found at {in_bin}")
+                command.die(f"no unsigned .bin found at {in_bin}")
             in_bin = os.fspath(in_bin)
         else:
             in_bin = None
         if 'hex' in formats:
             in_hex = b / 'zephyr' / f'{kernel}.hex'
             if not in_hex.is_file():
-                log.die(f"no unsigned .hex found at {in_hex}")
+                command.die(f"no unsigned .hex found at {in_hex}")
             in_hex = os.fspath(in_hex)
         else:
             in_hex = None
 
         if not args.quiet:
-            log.banner('image configuration:')
-            log.inf('partition offset: {0} (0x{0:x})'.format(addr))
-            log.inf('partition size: {0} (0x{0:x})'.format(size))
-            log.inf('rom start offset: {0} (0x{0:x})'.format(vtoff))
+            command.banner('image configuration:')
+            command.inf('partition offset: {0} (0x{0:x})'.format(addr))
+            command.inf('partition size: {0} (0x{0:x})'.format(size))
+            command.inf('rom start offset: {0} (0x{0:x})'.format(vtoff))
 
         # Base sign command.
         sign_base = imgtool + ['sign',
@@ -276,34 +276,34 @@ def sign(self, command, build_dir, build_conf, formats):
         sign_base.extend(args.tool_args)
 
         if not args.quiet:
-            log.banner('signing binaries')
+            command.banner('signing binaries')
         if in_bin:
             out_bin = args.sbin or str(b / 'zephyr' / 'zephyr.signed.bin')
             sign_bin = sign_base + [in_bin, out_bin]
             if not args.quiet:
-                log.inf(f'unsigned bin: {in_bin}')
-                log.inf(f'signed bin:   {out_bin}')
-                log.dbg(quote_sh_list(sign_bin))
+                command.inf(f'unsigned bin: {in_bin}')
+                command.inf(f'signed bin:   {out_bin}')
+                command.dbg(quote_sh_list(sign_bin))
             subprocess.check_call(sign_bin, stdout=subprocess.PIPE if args.quiet else None)
         if in_hex:
             out_hex = args.shex or str(b / 'zephyr' / 'zephyr.signed.hex')
             sign_hex = sign_base + [in_hex, out_hex]
             if not args.quiet:
-                log.inf(f'unsigned hex: {in_hex}')
-                log.inf(f'signed hex:   {out_hex}')
-                log.dbg(quote_sh_list(sign_hex))
+                command.inf(f'unsigned hex: {in_hex}')
+                command.inf(f'signed hex:   {out_hex}')
+                command.dbg(quote_sh_list(sign_hex))
             subprocess.check_call(sign_hex, stdout=subprocess.PIPE if args.quiet else None)
 
     @staticmethod
-    def find_imgtool(command, args):
+    def find_imgtool(cmd, args):
         if args.tool_path:
             imgtool = args.tool_path
             if not os.path.isfile(imgtool):
-                log.die(f'--tool-path {imgtool}: no such file')
+                cmd.die(f'--tool-path {imgtool}: no such file')
         else:
             imgtool = shutil.which('imgtool') or shutil.which('imgtool.py')
             if not imgtool:
-                log.die('imgtool not found; either install it',
+                cmd.die('imgtool not found; either install it',
                         '(e.g. "pip3 install imgtool") or provide --tool-path')
 
         if platform.system() == 'Windows' and imgtool.endswith('.py'):
@@ -327,18 +327,18 @@ def get_cfg(command, build_conf, item):
             return None
 
     @staticmethod
-    def edt_flash_node(b, quiet=False):
+    def edt_flash_node(cmd, b, quiet=False):
         # Get the EDT Node corresponding to the zephyr,flash chosen DT
         # node; 'b' is the build directory as a pathlib object.
 
         # Ensure the build directory has a compiled DTS file
         # where we expect it to be.
         dts = b / 'zephyr' / 'zephyr.dts'
         if not quiet:
-            log.dbg('DTS file:', dts, level=log.VERBOSE_VERY)
+            cmd.dbg('DTS file:', dts, level=Verbosity.DBG_MORE)
         edt_pickle = b / 'zephyr' / 'edt.pickle'
         if not edt_pickle.is_file():
-            log.die("can't load devicetree; expected to find:", edt_pickle)
+            cmd.die("can't load devicetree; expected to find:", edt_pickle)
 
         # Load the devicetree.
         with open(edt_pickle, 'rb') as f:
@@ -348,13 +348,13 @@ def edt_flash_node(b, quiet=False):
         # partition information about the zephyr image to sign.
         flash = edt.chosen_node('zephyr,flash')
         if not flash:
-            log.die('devicetree has no chosen zephyr,flash node;',
+            cmd.die('devicetree has no chosen zephyr,flash node;',
                     "can't infer flash write block or slot0_partition slot sizes")
 
         return flash
 
     @staticmethod
-    def edt_flash_params(flash):
+    def edt_flash_params(cmd, flash):
         # Get the flash device's write alignment and offset from the
         # slot0_partition and the size from slot1_partition , out of the
         # build directory's devicetree. slot1_partition size is used,
@@ -366,7 +366,7 @@ def edt_flash_params(flash):
         # with label slot1_partition. By convention, the slots for consumption by
         # imgtool are linked into these partitions.
         if 'partitions' not in flash.children:
-            log.die("DT zephyr,flash chosen node has no partitions,",
+            cmd.die("DT zephyr,flash chosen node has no partitions,",
                     "can't find partitions for MCUboot slots")
 
         partitions = flash.children['partitions']
@@ -377,31 +377,31 @@ def edt_flash_params(flash):
         }
 
         if 'slot0_partition' not in slots:
-            log.die("DT zephyr,flash chosen node has no slot0_partition partition,",
+            cmd.die("DT zephyr,flash chosen node has no slot0_partition partition,",
                     "can't determine its address")
 
         # Die on missing or zero alignment or slot_size.
         if "write-block-size" not in flash.props:
-            log.die('DT zephyr,flash node has no write-block-size;',
+            cmd.die('DT zephyr,flash node has no write-block-size;',
                     "can't determine imgtool write alignment")
         align = flash.props['write-block-size'].val
         if align == 0:
-            log.die('expected nonzero flash alignment, but got '
+            cmd.die('expected nonzero flash alignment, but got '
                     'DT flash device write-block-size {}'.format(align))
 
         # The partitions node, and its subnode, must provide
         # the size of slot1_partition or slot0_partition partition via the regs property.
         slot_key = 'slot1_partition' if 'slot1_partition' in slots else 'slot0_partition'
         if not slots[slot_key].regs:
-            log.die(f'{slot_key} flash partition has no regs property;',
+            cmd.die(f'{slot_key} flash partition has no regs property;',
                     "can't determine size of slot")
 
         # always use addr of slot0_partition, which is where slots are run
         addr = slots['slot0_partition'].regs[0].addr
 
         size = slots[slot_key].regs[0].size
         if size == 0:
-            log.die('expected nonzero slot size for {}'.format(slot_key))
+            cmd.die('expected nonzero slot size for {}'.format(slot_key))
 
         return (align, addr, size)
 
@@ -462,10 +462,10 @@ def sign(self, command, build_dir, build_conf, formats):
         if not target:
             msg = 'rimage target not defined in board.cmake'
             if args.if_tool_available:
-                log.inf(msg)
+                command.inf(msg)
                 sys.exit(0)
             else:
-                log.die(msg)
+                command.die(msg)
 
         kernel_name = build_conf.get('CONFIG_KERNEL_BIN_NAME', 'zephyr')
 
@@ -490,7 +490,7 @@ def sign(self, command, build_dir, build_conf, formats):
 
         tool_path = (
             args.tool_path if args.tool_path else
-            self.command.config_get('rimage.path', None)
+            command.config_get('rimage.path', None)
         )
         err_prefix = '--tool-path' if args.tool_path else 'west config'
 
@@ -502,16 +502,16 @@ def sign(self, command, build_dir, build_conf, formats):
             if not tool_path:
                 err_msg = 'rimage not found; either install it or provide --tool-path'
                 if args.if_tool_available:
-                    log.wrn(err_msg)
-                    log.wrn('zephyr binary _not_ signed!')
+                    command.wrn(err_msg)
+                    command.wrn('zephyr binary _not_ signed!')
                     return
                 else:
-                    log.die(err_msg)
+                    command.die(err_msg)
 
         #### -c sof/rimage/config/signing_schema.toml  ####
 
         if not args.quiet:
-            log.inf('Signing with tool {}'.format(tool_path))
+            command.inf('Signing with tool {}'.format(tool_path))
 
         try:
             sof_proj = command.manifest.get_projects(['sof'], allow_paths=False)
@@ -522,7 +522,7 @@ def sign(self, command, build_dir, build_conf, formats):
         self.sof_src_dir = sof_src_dir
 
 
-        log.inf('Signing for SOC target ' + target)
+        command.inf('Signing for SOC target ' + target)
 
         # FIXME: deprecate --no-manifest and replace it with a much
         # simpler and more direct `-- -e` which the user can _already_
@@ -555,15 +555,15 @@ def sign(self, command, build_dir, build_conf, formats):
         components = [ ] if bootloader is None else [ bootloader ]
         components += [ kernel ]
 
-        sign_config_extra_args = self.command.config_get_words('rimage.extra-args', [])
+        sign_config_extra_args = command.config_get_words('rimage.extra-args', [])
 
         if '-k' not in sign_config_extra_args + args.tool_args:
             # rimage requires a key argument even when it does not sign
             cmake_default_key = cache.get('RIMAGE_SIGN_KEY', 'key placeholder from sign.py')
             extra_ri_args += [ '-k', str(sof_src_dir / 'keys' / cmake_default_key) ]
 
         if args.tool_data and '-c' in args.tool_args:
-            log.wrn('--tool-data ' + args.tool_data + ' ignored! Overridden by: -- -c ... ')
+            command.wrn('--tool-data ' + args.tool_data + ' ignored! Overridden by: -- -c ... ')
 
         if '-c' not in sign_config_extra_args + args.tool_args:
             conf_dir = self.rimage_config_dir()
@@ -594,7 +594,7 @@ def sign(self, command, build_dir, build_conf, formats):
         else:
             filenames = [out_xman, out_bin]
             if not args.quiet:
-                log.inf('Prefixing ' + out_bin + ' with manifest ' + out_xman)
+                command.inf('Prefixing ' + out_bin + ' with manifest ' + out_xman)
         with open(out_tmp, 'wb') as outfile:
             for fname in filenames:
                 with open(fname, 'rb') as infile: