Custom target filename (#150)

Jussi Vatjus-Anttila · Juho Hovila · commit ef02f6eb8987 · 2018-12-19T14:41:38.000+02:00
diff --git a/README.md b/README.md
@@ -81,12 +81,24 @@ optional arguments:
                         targets can be given. Does not continue flashing
                         next device in case of failures. Short target_id
                         matches boards by prefix
+  --target_filename TARGET_FILENAME
+                        Custom target filename
   -t PLATFORM_NAME, --platform_name PLATFORM_NAME
                         Platform of the target device(s)
   --no-reset            Do not reset device before or after flashing
 
 ```
 
+`--target_filename TARGET_FILENAME` -option is used to select custom
+target filename when source file is copied to mbed target
+
+e.g.
+```
+$ mbedflash flash simple --tid 0240000032254e45000f800ab529001f3f31000097969900 -i setup.hex --target_filename asd.hex
+```
+input file in above example would be `setup.hex`, that must exists and filename
+that is created for target mount point would be `asd.hex`.
+
 **Erase help**
 
 ```
diff --git a/mbed_flasher/common.py b/mbed_flasher/common.py
@@ -146,18 +146,46 @@ def check_is_file_flashable(logger, file_path):
     :param file_path: file to be flashed (string)
     :return: None on success, raise FlashError otherwise
     """
+    check_file(logger, file_path)
+    check_file_exists(logger, file_path)
+    check_file_extension(logger, file_path)
+
+
+def check_file(logger, file_path):
+    """
+    CHeck if file_path is not "False"
+    :param logger: logger object
+    :param file_path: file to be flashed (string)
+    :return: None on success, raise FlashError otherwise
+    """
     if not file_path:
         msg = "File to be flashed was not given"
         logger.error(msg)
         # pylint: disable=superfluous-parens
         raise FlashError(message=msg, return_code=EXIT_CODE_FILE_MISSING)
 
+
+def check_file_exists(logger, file_path):
+    """
+    CHeck if file exists
+    :param logger: logger object
+    :param file_path: file to be flashed (string)
+    :return: None on success, raise FlashError otherwise
+    """
     if not os.path.isfile(file_path):
         msg = "Could not find given file: {}".format(file_path)
         logger.error(msg)
         # pylint: disable=superfluous-parens
         raise FlashError(message=msg, return_code=EXIT_CODE_FILE_MISSING)
 
+
+def check_file_extension(logger, file_path):
+    """
+    CHeck if file name extension is valid
+    :param logger: logger object
+    :param file_path: file to be flashed (string)
+    :return: None on success, raise FlashError otherwise
+    """
     if not file_path.lower().endswith(ALLOWED_FILE_EXTENSIONS):
         msg = "File extension is not supported: {}".format(file_path)
         logger.error(msg)
diff --git a/mbed_flasher/flash.py b/mbed_flasher/flash.py
@@ -14,7 +14,8 @@
 limitations under the License.
 """
 
-from mbed_flasher.common import Common, Logger, FlashError, check_is_file_flashable
+from mbed_flasher.common import Common, Logger, FlashError,\
+    check_file, check_file_exists, check_file_extension
 from mbed_flasher.flashers import AvailableFlashers
 from mbed_flasher.return_codes import EXIT_CODE_SUCCESS
 from mbed_flasher.return_codes import EXIT_CODE_PLATFORM_REQUIRED
@@ -149,14 +150,15 @@ def _verify_platform_coherence(device_mapping_table):
                                  return_code=EXIT_CODE_PLATFORM_REQUIRED)
 
     # pylint: disable=too-many-arguments
-    def flash_multiple(self, build, platform_name,
-                       method='simple', target_ids_or_prefix='', no_reset=None):
+    def flash_multiple(self, build, platform_name, method='simple',
+                       target_ids_or_prefix='', no_reset=None, target_filename=None):
         """
         :param build: build
         :param platform_name: platform name
         :param method: method
         :param target_ids_or_prefix: target ids or prefix
         :param no_reset: with/without reset
+        :param target_filename: optional target filename
         :return:
         """
         device_mapping_table = Common(self.logger).get_available_device_mapping(self._flashers)
@@ -192,34 +194,44 @@ def flash_multiple(self, build, platform_name,
         for item in device_mapping_table:
             self.logger.info(item['target_id'])
 
+        target_filename = target_filename or build
+
         for device in device_mapping_table:
             self.flash(build=build,
                        target_id=device['target_id'],
                        platform_name=None,
                        device_mapping_table=device_mapping_table,
                        method=method,
-                       no_reset=no_reset)
+                       no_reset=no_reset,
+                       target_filename=target_filename)
 
         return EXIT_CODE_SUCCESS
 
     # pylint: disable=too-many-return-statements
     def flash(self, build, target_id=None, platform_name=None,
-              device_mapping_table=None, method='simple', no_reset=None):
+              device_mapping_table=None, method='simple', no_reset=None,
+              target_filename=None):
         """Flash (mbed) device
-        :param build:  Build -object or string (file-path)
+        :param build: string (file-path)
         :param target_id: target_id
         :param platform_name: platform_name, to flash multiple devices of same type
         :param device_mapping_table: individual devices mapping table
         :param method: method for flashing i.e. simple, pyocd or edbg
         :param no_reset: whether to reset the board after flash
+        :param target_filename: optional Target filename
         """
 
         k64f_target_id_length = 48
 
         if target_id is None and platform_name is None:
             raise SyntaxError("target_id or target_name is required")
 
-        check_is_file_flashable(self.logger, build)
+        target_filename = target_filename or build
+
+        check_file(self.logger, target_filename)
+        check_file(self.logger, build)
+        check_file_extension(self.logger, target_filename)
+        check_file_exists(self.logger, build)
 
         if (isinstance(target_id, list) or
                 target_id.lower() == 'all' or
@@ -231,7 +243,8 @@ def flash(self, build, target_id=None, platform_name=None,
                 platform_name=platform_name,
                 method=method,
                 target_ids_or_prefix=target_id,
-                no_reset=no_reset)
+                no_reset=no_reset,
+                target_filename=target_filename)
 
         device_mapping_table = self._refine__device_mapping_table(
             device_mapping_table, target_id)
@@ -257,7 +270,8 @@ def flash(self, build, target_id=None, platform_name=None,
                                   build=build,
                                   target=target_mbed,
                                   method=method,
-                                  no_reset=no_reset)
+                                  no_reset=no_reset,
+                                  target_filename=target_filename)
         if retcode == EXIT_CODE_SUCCESS:
             self.logger.info("%s flash success", target_mbed["target_id"])
         else:
@@ -267,10 +281,14 @@ def flash(self, build, target_id=None, platform_name=None,
         return retcode
 
     @staticmethod
-    def _do_flash(flasher, build, target, method, no_reset):
+    def _do_flash(flasher, build, target, method, no_reset, target_filename):
         try:
             return flasher.flash(
-                source=build, target=target, method=method, no_reset=no_reset)
+                source=build,
+                target=target,
+                method=method,
+                no_reset=no_reset,
+                target_filename=target_filename)
         except KeyboardInterrupt:
             raise FlashError(message="Aborted by user",
                              return_code=EXIT_CODE_KEYBOARD_INTERRUPT)
diff --git a/mbed_flasher/flashers/FlasherAtmelAt.py b/mbed_flasher/flashers/FlasherAtmelAt.py
@@ -105,11 +105,14 @@ def get_available_devices():
             "Connected atprogrammer supported devices: %s", connected_devices)
         return connected_devices
 
-    # actual flash procedure
-    def flash(self, source, target):
-        """flash device
-        :param sn: device serial number to be flashed
-        :param binary: binary file to be flash
+    # pylint: disable=too-many-arguments, unused-argument
+    def flash(self, source, target, method, no_reset, target_filename):
+        """
+        :param source: binary file to be flash
+        :param target: target id
+        :param method:
+        :param no_reset:
+        :param target_filename:
         :return: 0 when flashing success
         """
         with tempfile.TemporaryFile() as temp:
diff --git a/mbed_flasher/flashers/FlasherBase.py b/mbed_flasher/flashers/FlasherBase.py
@@ -71,7 +71,8 @@ def is_executable_installed():
         """
         raise NotImplementedError
 
-    def flash(self, source, target, method, no_reset):
+    # pylint: disable=too-many-arguments
+    def flash(self, source, target, method, no_reset, target_filename=None):
         """flash device
         :param source: binary to be flashed
         :param target: target to be flashed
diff --git a/mbed_flasher/flashers/FlasherJLink.py b/mbed_flasher/flashers/FlasherJLink.py
@@ -86,12 +86,14 @@ def is_executable_installed():
         """
         return spawn.find_executable(FlasherJLink.executable) is not None
 
-    def flash(self, source, target, method, no_reset):
+    # pylint: disable=too-many-arguments
+    def flash(self, source, target, method, no_reset, target_filename=None):
         """flash device
         :param source: binary to be flashed
         :param target: target to be flashed
         :param method: method to use when flashing
         :param no_reset: do not reset flashed board at all
+        :param target_filename: target filename (not in use)
         :return: 0 when flashing success
         """
 
diff --git a/mbed_flasher/flashers/FlasherMbed.py b/mbed_flasher/flashers/FlasherMbed.py
@@ -87,13 +87,14 @@ def can_flash(target):
         """
         return True
 
-    # pylint: disable=too-many-return-statements, duplicate-except
-    def flash(self, source, target, method, no_reset):
+    # pylint: disable=too-many-return-statements, duplicate-except, too-many-arguments
+    def flash(self, source, target, method, no_reset, target_filename):
         """copy file to the destination
         :param source: binary to be flashed
         :param target: target to be flashed
         :param method: method to use when flashing
         :param no_reset: do not reset flashed board at all
+        :param target_filename: destination filename
         """
         if not isinstance(source, six.string_types):
             return
@@ -109,7 +110,7 @@ def flash(self, source, target, method, no_reset):
         return retry(
             logger=self.logger,
             func=self.try_drag_and_drop_flash,
-            func_args=(source, target, no_reset),
+            func_args=(source, target, target_filename, no_reset),
             retries=FlasherMbed.DRAG_AND_DROP_FLASH_RETRIES,
             conditions=[EXIT_CODE_OS_ERROR,
                         EXIT_CODE_DAPLINK_TRANSIENT_ERROR,
@@ -146,7 +147,7 @@ def try_pyocd_flash(self, source, target):
             raise FlashError(message="PyOCD flash failed",
                              return_code=EXIT_CODE_FLASH_FAILED)
 
-    def try_drag_and_drop_flash(self, source, target, no_reset):
+    def try_drag_and_drop_flash(self, source, target, target_filename, no_reset):
         """
         Try to flash the target using drag and drop method.
         :param source: file to be flashed
@@ -160,7 +161,7 @@ def try_drag_and_drop_flash(self, source, target, no_reset):
             raise FlashError(message="Target ID is missing",
                              return_code=EXIT_CODE_TARGET_ID_MISSING)
 
-        destination = MbedCommon.get_binary_destination(target["mount_point"], source)
+        destination = MbedCommon.get_binary_destination(target["mount_point"], target_filename)
 
         try:
             if 'serial_port' in target and not no_reset:
@@ -170,7 +171,7 @@ def try_drag_and_drop_flash(self, source, target, no_reset):
             self.copy_file(source, destination)
             self.logger.debug("copy finished")
 
-            target = MbedCommon.wait_for_file_disappear(target, source)
+            target = MbedCommon.wait_for_file_disappear(target, target_filename)
 
             if not no_reset:
                 Reset(logger=self.logger).reset_board(target["serial_port"])
@@ -179,7 +180,7 @@ def try_drag_and_drop_flash(self, source, target, no_reset):
             # verify flashing went as planned
             self.logger.debug("verifying flash")
             return self.verify_flash_success(
-                target, MbedCommon.get_binary_destination(target["mount_point"], source))
+                target, MbedCommon.get_binary_destination(target["mount_point"], target_filename))
         # In python3 IOError is just an alias for OSError
         except (OSError, IOError) as error:
             msg = "File copy failed due to: {}".format(str(error))
diff --git a/mbed_flasher/flashers/FlasherST.py b/mbed_flasher/flashers/FlasherST.py
@@ -84,12 +84,14 @@ def is_executable_installed():
         """
         return spawn.find_executable(FlasherSTLink.executable) is not None
 
-    def flash(self, source, target, method, no_reset):
+    # pylint: disable=too-many-arguments
+    def flash(self, source, target, method, no_reset, target_filename=None):
         """flash device
         :param source: binary to be flashed
         :param target: target to be flashed
         :param method: method to use when flashing
         :param no_reset: do not reset flashed board at all
+        :param target_filename: target filename (not in use)
         :return: 0 when flashing success
         """
         try:
diff --git a/mbed_flasher/main.py b/mbed_flasher/main.py
@@ -27,7 +27,7 @@
 import time
 
 from mbed_flasher.common import Common, FlashError, EraseError, ResetError, GeneralFatalError,\
-    check_is_file_flashable
+    check_file, check_file_extension, check_file_exists
 from mbed_flasher.flash import Flash
 from mbed_flasher.erase import Erase
 from mbed_flasher.reset import Reset
@@ -196,6 +196,9 @@ def argparser_setup(self, sysargs):
                                        'also multiple targets can be given. '
                                        'Short target_id matches boards by prefix',
                                   default=None, metavar='TARGET_ID', action='append')
+        parser_flash.add_argument('--target_filename',
+                                  help='Custom target filename',
+                                  default=None, metavar='TARGET_FILENAME')
         parser_flash.add_argument('-t', '--platform_name',
                                   help='Platform of the target device(s)',
                                   default=None)
@@ -292,7 +295,11 @@ def subcmd_flash_handler(self, args):
             raise FlashError(message=msg,
                              return_code=EXIT_CODE_TARGET_ID_MISSING)
 
-        check_is_file_flashable(self.logger, args.input)
+        check_file(self.logger, args.target_filename or args.input)
+        check_file(self.logger, args.input)
+        check_file_exists(self.logger, args.input)
+        check_file_extension(self.logger, args.target_filename or args.input)
+
 
         flasher = Flash()
         available = Common(self.logger).get_available_device_mapping(
@@ -309,6 +316,7 @@ def subcmd_flash_handler(self, args):
         if 'all' in args.tid:
             retcode = flasher.flash(build=args.input, target_id='all',
                                     platform_name=args.platform_name,
+                                    target_filename=args.target_filename,
                                     method=args.method, no_reset=args.no_reset)
 
         if len(available) <= 0:
@@ -333,6 +341,7 @@ def subcmd_flash_handler(self, args):
         else:
             retcode = flasher.flash(build=args.input,
                                     target_id=target_ids_to_flash,
+                                    target_filename=args.target_filename,
                                     platform_name=available_platforms[0],
                                     method=args.method,
                                     no_reset=args.no_reset)
diff --git a/test/hardware/test_cliapi.py b/test/hardware/test_cliapi.py
@@ -62,3 +62,11 @@ def test_flash_user_error_k64f(self):
         target_id = first_or_default['target_id']
         parameters = ['flash', '--no-reset', '-i', filename, '--tid', target_id]
         self.assertEqual(ApiTests.spawn(parameters), EXIT_CODE_DAPLINK_USER_ERROR)
+
+    # pylint:disable=invalid-name
+    def test_flash_success_with_target_filename(self):
+        first_or_default = self.find_platform('K64F')
+        filename = self.bin_hello_world
+        target_id = first_or_default['target_id']
+        parameters = ['flash', '-i', filename, '--tid', target_id, '--target_filename', 'test.bin']
+        self.assertEqual(ApiTests.spawn(parameters), EXIT_CODE_SUCCESS)
diff --git a/test/hardware/test_flash.py b/test/hardware/test_flash.py
diff --git a/test/hardware/test_verify_flash.py b/test/hardware/test_verify_flash.py
diff --git a/test/non_hardware/test_flash.py b/test/non_hardware/test_flash.py
diff --git a/test/non_hardware/test_flasherjlink.py b/test/non_hardware/test_flasherjlink.py
