{backup,snapshort}: Improve behaviour

This commit improves the behaviour of 'backup' and 'snapshot' by
treating symbolic links properly, as well as writes proper reports.

pkg/fsx/copy.go

@@ -3,13 +3,16 @@ package fsx
 import (
 	"errors"
 	"io"
+	"io/fs"
 	"os"
 	"path/filepath"
 )
 
-var ErrCopySameFile = errors.New("src and dst must be different files")
+var ErrCopySameFile = errors.New("src and dst must be different")
 
 // CopyFile copies a file from src to dst.
+// When src points to a symbolic link, will copy the symbolic link.
+//
 // When dst and src are the same file, returns ErrCopySameFile.
 func CopyFile(dst, src string) error {
 	if SameFile(src, dst) {
@@ -41,10 +44,37 @@ func CopyFile(dst, src string) error {
 	return err
 }
 
-var ErrCopyNoDirectory = errors.New("dst is not a directory")
+// CopyLink copies a link from src to dst.
+// If dst already exists, it is deleted and then re-created.
+func CopyLink(dst, src string) error {
+	// if they're the same file that is an error
+	if SameFile(dst, src) {
+		return ErrCopySameFile
+	}
+
+	// read the link target
+	target, err := os.Readlink(src)
+	if err != nil {
+		return err
+	}
+
+	// delete it if it already exists
+	if Exists(dst) {
+		if err := os.Remove(dst); err != nil {
+			return err
+		}
+	}
+
+	// make the symbolic link!
+	return os.Symlink(target, dst)
+}
+
+var ErrDstFile = errors.New("dst is a file")
 
 // CopyDirectory copies the directory src to dst recursively.
-// The destination directory must exist, or an error is returned.
+//
+// Existing files and directories are overwritten.
+// When a directory already exists, additional files are not deleted.
 //
 // onCopy, when not nil, is called for each file or directory being copied.
 func CopyDirectory(dst, src string, onCopy func(dst, src string)) error {
@@ -52,56 +82,51 @@ func CopyDirectory(dst, src string, onCopy func(dst, src string)) error {
 	if SameFile(src, dst) {
 		return ErrCopySameFile
 	}
-	if !IsDirectory(dst) {
-		return ErrCopyNoDirectory
+	if IsFile(dst) {
+		return ErrDstFile
 	}
 
-	// call onCopy for this directory!
-	if onCopy != nil {
-		onCopy(dst, src)
-	}
-
-	// iterate over the entries or bail out
-	entries, err := os.ReadDir(src)
-	if err != nil {
-		return err
-	}
-
-	for _, entry := range entries {
-		name := entry.Name()
-		eDest := filepath.Join(dst, name)
-		eSrc := filepath.Join(src, name)
-
-		// it is not a directory => Use CopyFile
-		if !entry.IsDir() {
-			if onCopy != nil {
-				onCopy(eDest, eSrc)
-			}
-
-			// do the copy!
-			if err := CopyFile(eDest, eSrc); err != nil {
-				return err
-			}
-
-			continue
-		}
-
-		// find out the mode of the entry
-		eInfo, err := entry.Info()
+	return filepath.WalkDir(src, func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
 
-		// make the target directory
-		if err := os.Mkdir(eDest, eInfo.Mode()); err != nil {
+		// determine the real target path
+		var relpath string
+		relpath, err = filepath.Rel(src, path)
+		if err != nil {
+			return err
+		}
+		dst := filepath.Join(dst, relpath)
+
+		// call the hook
+		if onCopy != nil {
+			onCopy(dst, src)
+		}
+
+		// stat the directory, so that we can get mode, and info later!
+		info, err := d.Info()
+		if err != nil {
 			return err
 		}
 
-		// do the copy!
-		if err := CopyDirectory(eDest, eSrc, onCopy); err != nil {
-			return err
+		// if we have a symbolic link, copy the link!
+		if info.Mode()&os.ModeSymlink != 0 {
+			return CopyLink(dst, path)
 		}
-	}
 
-	return nil
+		// if we got a file, we should copy it normally
+		if !d.IsDir() {
+			return CopyFile(dst, path)
+		}
+
+		// create the directory, but ignore an error if the directory already exists.
+		// this is so that we can copy one tree into another tree.
+		err = os.Mkdir(dst, info.Mode())
+		if os.IsExist(err) && IsDirectory(dst) {
+			err = nil
+		}
+
+		return err
+	})
 }

pkg/fsx/type.go

@@ -7,7 +7,7 @@ import (
 
 // Exists checks if the given path exists
 func Exists(path string) bool {
-	_, err := os.Stat(path)
+	_, err := os.Lstat(path)
 	return err == nil
 }
 
@@ -22,3 +22,9 @@ func IsFile(path string) bool {
 	info, err := os.Stat(path)
 	return err == nil && info.Mode().IsRegular()
 }
+
+// IsLink checks if the provided path exists and is a symlink
+func IsLink(path string) bool {
+	info, err := os.Lstat(path)
+	return err == nil && info.Mode()&os.ModeSymlink != 0
+}