tools/mpremote: Make filesystem commands use transport API.

This introduces a Python filesystem API on `Transport` that is implemented
entirely with eval/exec provided by the underlying transport subclass.

Updates existing mpremote filesystem commands (and `edit) to use this API.

Also re-implements recursive `cp` to allow arbitrary source / destination.

This work was funded through GitHub Sponsors.

Signed-off-by: Jim Mussared <[email protected]>
Signed-off-by: Damien George <[email protected]>

Author: jimmo

tools/mpremote/mpremote/commands.py

@@ -4,8 +4,8 @@
 
 import serial.tools.list_ports
 
-from .transport import TransportError
-from .transport_serial import SerialTransport, stdout_write_bytes
+from .transport import TransportError, stdout_write_bytes
+from .transport_serial import SerialTransport
 
 
 class CommandError(Exception):
@@ -106,61 +106,238 @@ def show_progress_bar(size, total_size, op="copying"):
         )
 
 
+def _remote_path_join(a, *b):
+    if not a:
+        a = "./"
+    result = a.rstrip("/")
+    for x in b:
+        result += "/" + x.strip("/")
+    return result
+
+
+def _remote_path_dirname(a):
+    a = a.rsplit("/", 1)
+    if len(a) == 1:
+        return ""
+    else:
+        return a[0]
+
+
+def _remote_path_basename(a):
+    return a.rsplit("/", 1)[-1]
+
+
+def do_filesystem_cp(state, src, dest, multiple):
+    if dest.startswith(":"):
+        dest_exists = state.transport.fs_exists(dest[1:])
+        dest_isdir = dest_exists and state.transport.fs_isdir(dest[1:])
+    else:
+        dest_exists = os.path.exists(dest)
+        dest_isdir = dest_exists and os.path.isdir(dest)
+
+    if multiple:
+        if not dest_exists:
+            raise CommandError("cp: destination does not exist")
+        if not dest_isdir:
+            raise CommandError("cp: destination is not a directory")
+
+    # Download the contents of source.
+    try:
+        if src.startswith(":"):
+            data = state.transport.fs_readfile(src[1:], progress_callback=show_progress_bar)
+            filename = _remote_path_basename(src[1:])
+        else:
+            with open(src, "rb") as f:
+                data = f.read()
+            filename = os.path.basename(src)
+    except IsADirectoryError:
+        raise CommandError("cp: -r not specified; omitting directory")
+
+    # Write back to dest.
+    if dest.startswith(":"):
+        # If the destination path is just the directory, then add the source filename.
+        if dest_isdir:
+            dest = ":" + _remote_path_join(dest[1:], filename)
+
+        # Write to remote.
+        state.transport.fs_writefile(dest[1:], data, progress_callback=show_progress_bar)
+    else:
+        # If the destination path is just the directory, then add the source filename.
+        if dest_isdir:
+            dest = os.path.join(dest, filename)
+
+        # Write to local file.
+        with open(dest, "wb") as f:
+            f.write(data)
+
+
+def do_filesystem_recursive_cp(state, src, dest, multiple):
+    # Ignore trailing / on both src and dest. (Unix cp ignores them too)
+    src = src.rstrip("/" + os.path.sep + (os.path.altsep if os.path.altsep else ""))
+    dest = dest.rstrip("/" + os.path.sep + (os.path.altsep if os.path.altsep else ""))
+
+    # If the destination directory exists, then we copy into it. Otherwise we
+    # use the destination as the target.
+    if dest.startswith(":"):
+        dest_exists = state.transport.fs_exists(dest[1:])
+    else:
+        dest_exists = os.path.exists(dest)
+
+    # Recursively find all files to copy from a directory.
+    # `dirs` will be a list of dest split paths.
+    # `files` will be a list of `(dest split path, src joined path)`.
+    dirs = []
+    files = []
+
+    # For example, if src=/tmp/foo, with /tmp/foo/x.py and /tmp/foo/a/b/c.py,
+    # and if the destination directory exists, then we will have:
+    #   dirs = [['foo'], ['foo', 'a'], ['foo', 'a', 'b']]
+    #   files = [(['foo', 'x.py'], '/tmp/foo/x.py'), (['foo', 'a', 'b', 'c.py'], '/tmp/foo/a/b/c.py')]
+    # If the destination doesn't exist, then we will have:
+    #   dirs = [['a'], ['a', 'b']]
+    #   files = [(['x.py'], '/tmp/foo/x.py'), (['a', 'b', 'c.py'], '/tmp/foo/a/b/c.py')]
+
+    def _list_recursive(base, src_path, dest_path, src_join_fun, src_isdir_fun, src_listdir_fun):
+        src_path_joined = src_join_fun(base, *src_path)
+        if src_isdir_fun(src_path_joined):
+            if dest_path:
+                dirs.append(dest_path)
+            for entry in src_listdir_fun(src_path_joined):
+                _list_recursive(
+                    base,
+                    src_path + [entry],
+                    dest_path + [entry],
+                    src_join_fun,
+                    src_isdir_fun,
+                    src_listdir_fun,
+                )
+        else:
+            files.append(
+                (
+                    dest_path,
+                    src_path_joined,
+                )
+            )
+
+    if src.startswith(":"):
+        src_dirname = [_remote_path_basename(src[1:])]
+        dest_dirname = src_dirname if dest_exists else []
+        _list_recursive(
+            _remote_path_dirname(src[1:]),
+            src_dirname,
+            dest_dirname,
+            src_join_fun=_remote_path_join,
+            src_isdir_fun=state.transport.fs_isdir,
+            src_listdir_fun=lambda p: [x.name for x in state.transport.fs_listdir(p)],
+        )
+    else:
+        src_dirname = [os.path.basename(src)]
+        dest_dirname = src_dirname if dest_exists else []
+        _list_recursive(
+            os.path.dirname(src),
+            src_dirname,
+            dest_dirname,
+            src_join_fun=os.path.join,
+            src_isdir_fun=os.path.isdir,
+            src_listdir_fun=os.listdir,
+        )
+
+    # If no directories were encountered then we must have just had a file.
+    if not dirs:
+        return do_filesystem_cp(state, src, dest, multiple)
+
+    def _mkdir(a, *b):
+        try:
+            if a.startswith(":"):
+                state.transport.fs_mkdir(_remote_path_join(a[1:], *b))
+            else:
+                os.mkdir(os.path.join(a, *b))
+        except FileExistsError:
+            pass
+
+    # Create the destination if necessary.
+    if not dest_exists:
+        _mkdir(dest)
+
+    # Create all sub-directories relative to the destination.
+    for d in dirs:
+        _mkdir(dest, *d)
+
+    # Copy all files, in sorted order to help it be deterministic.
+    files.sort()
+    for dest_path_split, src_path_joined in files:
+        if src.startswith(":"):
+            src_path_joined = ":" + src_path_joined
+
+        if dest.startswith(":"):
+            dest_path_joined = ":" + _remote_path_join(dest[1:], *dest_path_split)
+        else:
+            dest_path_joined = os.path.join(dest, *dest_path_split)
+
+        do_filesystem_cp(state, src_path_joined, dest_path_joined, multiple=False)
+
+
 def do_filesystem(state, args):
     state.ensure_raw_repl()
     state.did_action()
 
-    def _list_recursive(files, path):
-        if os.path.isdir(path):
-            for entry in os.listdir(path):
-                _list_recursive(files, "/".join((path, entry)))
-        else:
-            files.append(os.path.split(path))
-
     command = args.command[0]
     paths = args.path
 
     if command == "cat":
-        # Don't be verbose by default when using cat, so output can be
-        # redirected to something.
+        # Don't do verbose output for `cat` unless explicitly requested.
         verbose = args.verbose is True
     else:
         verbose = args.verbose is not False
 
-    if command == "cp" and args.recursive:
-        if paths[-1] != ":":
-            raise CommandError("'cp -r' destination must be ':'")
-        paths.pop()
-        src_files = []
-        for path in paths:
-            if path.startswith(":"):
-                raise CommandError("'cp -r' source files must be local")
-            _list_recursive(src_files, path)
-        known_dirs = {""}
-        state.transport.exec("import os")
-        for dir, file in src_files:
-            dir_parts = dir.split("/")
-            for i in range(len(dir_parts)):
-                d = "/".join(dir_parts[: i + 1])
-                if d not in known_dirs:
-                    state.transport.exec(
-                        "try:\n os.mkdir('%s')\nexcept OSError as e:\n print(e)" % d
-                    )
-                    known_dirs.add(d)
-            state.transport.filesystem_command(
-                ["cp", "/".join((dir, file)), ":" + dir + "/"],
-                progress_callback=show_progress_bar,
-                verbose=verbose,
-            )
+    if command == "cp":
+        # Note: cp requires the user to specify local/remote explicitly via
+        # leading ':'.
+
+        # The last argument must be the destination.
+        if len(paths) <= 1:
+            raise CommandError("cp: missing destination path")
+        cp_dest = paths[-1]
+        paths = paths[:-1]
     else:
-        if args.recursive:
-            raise CommandError("'-r' only supported for 'cp'")
-        try:
-            state.transport.filesystem_command(
-                [command] + paths, progress_callback=show_progress_bar, verbose=verbose
-            )
-        except OSError as er:
-            raise CommandError(er)
+        # All other commands implicitly use remote paths. Strip the
+        # leading ':' if the user included them.
+        paths = [path[1:] if path.startswith(":") else path for path in paths]
+
+    # ls implicitly lists the cwd.
+    if command == "ls" and not paths:
+        paths = [""]
+
+    # Handle each path sequentially.
+    for path in paths:
+        if verbose:
+            if command == "cp":
+                print("{} {} {}".format(command, path, cp_dest))
+            else:
+                print("{} :{}".format(command, path))
+
+        if command == "cat":
+            state.transport.fs_printfile(path)
+        elif command == "ls":
+            for result in state.transport.fs_listdir(path):
+                print(
+                    "{:12} {}{}".format(
+                        result.st_size, result.name, "/" if result.st_mode & 0x4000 else ""
+                    )
+                )
+        elif command == "mkdir":
+            state.transport.fs_mkdir(path)
+        elif command == "rm":
+            state.transport.fs_rmfile(path)
+        elif command == "rmdir":
+            state.transport.fs_rmdir(path)
+        elif command == "touch":
+            state.transport.fs_touchfile(path)
+        elif command == "cp":
+            if args.recursive:
+                do_filesystem_recursive_cp(state, path, cp_dest, len(paths) > 1)
+            else:
+                do_filesystem_cp(state, path, cp_dest, len(paths) > 1)
 
 
 def do_edit(state, args):
@@ -174,11 +351,15 @@ def do_edit(state, args):
         dest_fd, dest = tempfile.mkstemp(suffix=os.path.basename(src))
         try:
             print("edit :%s" % (src,))
-            os.close(dest_fd)
-            state.transport.fs_touch(src)
-            state.transport.fs_get(src, dest, progress_callback=show_progress_bar)
+            state.transport.fs_touchfile(src)
+            data = state.transport.fs_readfile(src, progress_callback=show_progress_bar)
+            with open(dest_fd, "wb") as f:
+                f.write(data)
             if os.system('%s "%s"' % (os.getenv("EDITOR"), dest)) == 0:
-                state.transport.fs_put(dest, src, progress_callback=show_progress_bar)
+                with open(dest, "rb") as f:
+                    state.transport.fs_writefile(
+                        src, f.read(), progress_callback=show_progress_bar
+                    )
         finally:
             os.unlink(dest)
 

tools/mpremote/mpremote/main.py

@@ -190,7 +190,7 @@ def argparse_filesystem():
         "enable verbose output (defaults to True for all commands except cat)",
     )
     cmd_parser.add_argument(
-        "command", nargs=1, help="filesystem command (e.g. cat, cp, ls, rm, touch)"
+        "command", nargs=1, help="filesystem command (e.g. cat, cp, ls, rm, rmdir, touch)"
     )
     cmd_parser.add_argument("path", nargs="+", help="local and remote paths")
     return cmd_parser

tools/mpremote/mpremote/mip.py

@@ -12,13 +12,10 @@
 
 
 _PACKAGE_INDEX = "https://micropython.org/pi/v2"
-_CHUNK_SIZE = 128
 
 
 # This implements os.makedirs(os.dirname(path))
 def _ensure_path_exists(transport, path):
-    import os
-
     split = path.split("/")
 
     # Handle paths starting with "/".
@@ -34,22 +31,6 @@ def _ensure_path_exists(transport, path):
         prefix += "/"
 
 
-# Copy from src (stream) to dest (function-taking-bytes)
-def _chunk(src, dest, length=None, op="downloading"):
-    buf = memoryview(bytearray(_CHUNK_SIZE))
-    total = 0
-    if length:
-        show_progress_bar(0, length, op)
-    while True:
-        n = src.readinto(buf)
-        if n == 0:
-            break
-        dest(buf if n == _CHUNK_SIZE else buf[:n])
-        total += n
-        if length:
-            show_progress_bar(total, length, op)
-
-
 def _rewrite_url(url, branch=None):
     if not branch:
         branch = "HEAD"
@@ -83,15 +64,10 @@ def _rewrite_url(url, branch=None):
 def _download_file(transport, url, dest):
     try:
         with urllib.request.urlopen(url) as src:
-            fd, path = tempfile.mkstemp()
-            try:
-                print("Installing:", dest)
-                with os.fdopen(fd, "wb") as f:
-                    _chunk(src, f.write, src.length)
-                _ensure_path_exists(transport, dest)
-                transport.fs_put(path, dest, progress_callback=show_progress_bar)
-            finally:
-                os.unlink(path)
+            data = src.read()
+            print("Installing:", dest)
+            _ensure_path_exists(transport, dest)
+            transport.fs_writefile(dest, data, progress_callback=show_progress_bar)
     except urllib.error.HTTPError as e:
         if e.status == 404:
             raise CommandError(f"File not found: {url}")