fix(build): preserve symlink semantics and support cross-device migration

Vonng · Vonng · commit 3d8095951c88 · 2026-02-14T07:43:34.000+08:00
diff --git a/cli/build/spec.go b/cli/build/spec.go
@@ -1,15 +1,20 @@
 package build
 
 import (
+	"errors"
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 	"pig/internal/config"
 	"pig/internal/utils"
+	"syscall"
 
 	"github.com/sirupsen/logrus"
 )
 
+var renamePath = os.Rename
+
 // Spec configuration for build environments
 type specConfig struct {
 	Type      string   // "rpm" or "deb"
@@ -102,7 +107,8 @@ func setupBuildDirs(spec *specConfig, force bool) error {
 
 // createSymlink creates a symbolic link: linkPath -> target
 // In force mode, aggressively removes any existing file/dir/symlink at linkPath.
-// In non-force mode, existing directories are preserved to avoid accidental data loss.
+// In non-force mode, existing directories are migrated into target first, then
+// replaced by symlink to preserve data while keeping link semantics.
 func createSymlink(target, linkPath string, force bool) error {
 	if info, err := os.Lstat(linkPath); err == nil {
 		switch {
@@ -116,9 +122,14 @@ func createSymlink(target, linkPath string, force bool) error {
 			}
 		case info.IsDir():
 			if !force {
-				// Keep existing directories in non-force mode.
-				logrus.Debugf("keeping existing directory in non-force mode: %s", linkPath)
-				return nil
+				// Preserve existing content by moving it into target before relinking.
+				if err := migrateDirIntoTarget(linkPath, target); err != nil {
+					return err
+				}
+				if err := os.Remove(linkPath); err != nil && !os.IsNotExist(err) {
+					return fmt.Errorf("failed to remove existing directory after migration: %w", err)
+				}
+				break
 			}
 			if err := os.RemoveAll(linkPath); err != nil && !os.IsNotExist(err) {
 				return fmt.Errorf("failed to remove existing directory: %w", err)
@@ -152,6 +163,133 @@ func createSymlink(target, linkPath string, force bool) error {
 	return os.Symlink(target, linkPath)
 }
 
+func migrateDirIntoTarget(srcDir, targetDir string) error {
+	if srcDir == targetDir {
+		return nil
+	}
+	if err := os.MkdirAll(targetDir, 0755); err != nil {
+		return fmt.Errorf("failed to create target directory %s: %w", targetDir, err)
+	}
+	backupDir := filepath.Join(targetDir, ".migrated_from_"+filepath.Base(srcDir))
+
+	entries, err := os.ReadDir(srcDir)
+	if err != nil {
+		return fmt.Errorf("failed to read existing directory %s: %w", srcDir, err)
+	}
+	for _, entry := range entries {
+		srcPath := filepath.Join(srcDir, entry.Name())
+		dstPath := filepath.Join(targetDir, entry.Name())
+
+		if _, err := os.Lstat(dstPath); err == nil {
+			// Keep target entry untouched; move source entry into backup to avoid data loss.
+			if err := os.MkdirAll(backupDir, 0755); err != nil {
+				return fmt.Errorf("failed to create migration backup directory %s: %w", backupDir, err)
+			}
+			backupPath, err := uniqueBackupPath(filepath.Join(backupDir, entry.Name()))
+			if err != nil {
+				return fmt.Errorf("failed to allocate migration backup path: %w", err)
+			}
+			if err := os.Rename(srcPath, backupPath); err != nil {
+				return fmt.Errorf("failed to backup conflicting entry %s to %s: %w", srcPath, backupPath, err)
+			}
+			continue
+		} else if !os.IsNotExist(err) {
+			return fmt.Errorf("failed to inspect migration target %s: %w", dstPath, err)
+		}
+
+		if err := movePath(srcPath, dstPath); err != nil {
+			return fmt.Errorf("failed to migrate %s to %s: %w", srcPath, dstPath, err)
+		}
+	}
+	return nil
+}
+
+func movePath(src, dst string) error {
+	if err := renamePath(src, dst); err == nil {
+		return nil
+	} else if !errors.Is(err, syscall.EXDEV) {
+		return err
+	}
+
+	if err := copyPath(src, dst); err != nil {
+		return err
+	}
+	return os.RemoveAll(src)
+}
+
+func copyPath(src, dst string) error {
+	info, err := os.Lstat(src)
+	if err != nil {
+		return err
+	}
+
+	switch mode := info.Mode(); {
+	case mode&os.ModeSymlink != 0:
+		target, err := os.Readlink(src)
+		if err != nil {
+			return err
+		}
+		if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+			return err
+		}
+		return os.Symlink(target, dst)
+	case info.IsDir():
+		if err := os.MkdirAll(dst, info.Mode().Perm()); err != nil {
+			return err
+		}
+		entries, err := os.ReadDir(src)
+		if err != nil {
+			return err
+		}
+		for _, entry := range entries {
+			if err := copyPath(filepath.Join(src, entry.Name()), filepath.Join(dst, entry.Name())); err != nil {
+				return err
+			}
+		}
+		return nil
+	case mode.IsRegular():
+		if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+			return err
+		}
+		in, err := os.Open(src)
+		if err != nil {
+			return err
+		}
+		defer in.Close()
+
+		out, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, info.Mode().Perm())
+		if err != nil {
+			return err
+		}
+		defer out.Close()
+
+		if _, err := io.Copy(out, in); err != nil {
+			return err
+		}
+		return out.Close()
+	default:
+		return fmt.Errorf("unsupported file mode for cross-device move: %s", info.Mode().String())
+	}
+}
+
+func uniqueBackupPath(path string) (string, error) {
+	if _, err := os.Lstat(path); os.IsNotExist(err) {
+		return path, nil
+	} else if err != nil {
+		return "", err
+	}
+
+	for i := 1; i < 1000; i++ {
+		candidate := fmt.Sprintf("%s.%d", path, i)
+		if _, err := os.Lstat(candidate); os.IsNotExist(err) {
+			return candidate, nil
+		} else if err != nil {
+			return "", err
+		}
+	}
+	return "", fmt.Errorf("failed to allocate backup path for %s", path)
+}
+
 // syncSpec: Download tarball and perform incremental sync via rsync
 func syncSpec(spec *specConfig, force bool, mirror bool) error {
 	logrus.Info("sync extension specs")
diff --git a/cli/build/spec_test.go b/cli/build/spec_test.go
@@ -3,10 +3,11 @@ package build
 import (
 	"os"
 	"path/filepath"
+	"syscall"
 	"testing"
 )
 
-func TestCreateSymlinkNonForceKeepsExistingDirectory(t *testing.T) {
+func TestCreateSymlinkNonForceMigratesDirectoryThenLinks(t *testing.T) {
 	tmp := t.TempDir()
 	target := filepath.Join(tmp, "target")
 	if err := os.MkdirAll(target, 0o755); err != nil {
@@ -30,11 +31,23 @@ func TestCreateSymlinkNonForceKeepsExistingDirectory(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to stat link path: %v", err)
 	}
-	if info.Mode()&os.ModeSymlink != 0 {
-		t.Fatalf("expected existing directory to be preserved in non-force mode")
+	if info.Mode()&os.ModeSymlink == 0 {
+		t.Fatalf("expected link path to become symlink in non-force mode")
+	}
+	realTarget, err := os.Readlink(linkPath)
+	if err != nil {
+		t.Fatalf("failed to read symlink target: %v", err)
+	}
+	if realTarget != target {
+		t.Fatalf("symlink target mismatch: got %q want %q", realTarget, target)
+	}
+
+	migratedMarker := filepath.Join(target, "marker.txt")
+	if _, err := os.Stat(migratedMarker); err != nil {
+		t.Fatalf("expected marker file to be migrated to target, got: %v", err)
 	}
 	if _, err := os.Stat(marker); err != nil {
-		t.Fatalf("expected marker file to be preserved, got: %v", err)
+		t.Fatalf("expected marker file to remain reachable via symlink, got: %v", err)
 	}
 }
 
@@ -76,3 +89,81 @@ func TestCreateSymlinkForceReplacesDirectory(t *testing.T) {
 		t.Fatalf("expected old directory contents to be removed in force mode")
 	}
 }
+
+func TestCreateSymlinkNonForceConflictBackupsSourceThenLinks(t *testing.T) {
+	tmp := t.TempDir()
+	target := filepath.Join(tmp, "target")
+	if err := os.MkdirAll(target, 0o755); err != nil {
+		t.Fatalf("failed to create target directory: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(target, "marker.txt"), []byte("target"), 0o644); err != nil {
+		t.Fatalf("failed to create target marker: %v", err)
+	}
+
+	linkPath := filepath.Join(tmp, "link")
+	if err := os.MkdirAll(linkPath, 0o755); err != nil {
+		t.Fatalf("failed to create source dir: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(linkPath, "marker.txt"), []byte("source"), 0o644); err != nil {
+		t.Fatalf("failed to create source marker: %v", err)
+	}
+
+	if err := createSymlink(target, linkPath, false); err != nil {
+		t.Fatalf("createSymlink(non-force) returned error: %v", err)
+	}
+
+	info, err := os.Lstat(linkPath)
+	if err != nil {
+		t.Fatalf("failed to stat link path: %v", err)
+	}
+	if info.Mode()&os.ModeSymlink == 0 {
+		t.Fatalf("expected link path to become symlink in non-force mode")
+	}
+
+	targetContent, err := os.ReadFile(filepath.Join(target, "marker.txt"))
+	if err != nil {
+		t.Fatalf("failed to read target marker: %v", err)
+	}
+	if string(targetContent) != "target" {
+		t.Fatalf("target marker should remain unchanged, got: %q", string(targetContent))
+	}
+
+	matches, err := filepath.Glob(filepath.Join(target, ".migrated_from_link", "marker.txt*"))
+	if err != nil {
+		t.Fatalf("glob migration backup failed: %v", err)
+	}
+	if len(matches) == 0 {
+		t.Fatalf("expected conflicted source marker to be backed up")
+	}
+}
+
+func TestMovePathCrossDeviceFallback(t *testing.T) {
+	tmp := t.TempDir()
+	src := filepath.Join(tmp, "src.txt")
+	dst := filepath.Join(tmp, "dst.txt")
+
+	if err := os.WriteFile(src, []byte("hello"), 0o644); err != nil {
+		t.Fatalf("failed to create source file: %v", err)
+	}
+
+	oldRename := renamePath
+	defer func() { renamePath = oldRename }()
+	renamePath = func(oldPath, newPath string) error {
+		return &os.LinkError{Op: "rename", Old: oldPath, New: newPath, Err: syscall.EXDEV}
+	}
+
+	if err := movePath(src, dst); err != nil {
+		t.Fatalf("movePath returned error: %v", err)
+	}
+
+	if _, err := os.Stat(src); !os.IsNotExist(err) {
+		t.Fatalf("source should be removed after fallback move")
+	}
+	content, err := os.ReadFile(dst)
+	if err != nil {
+		t.Fatalf("failed to read destination file: %v", err)
+	}
+	if string(content) != "hello" {
+		t.Fatalf("unexpected destination content: %q", string(content))
+	}
+}
