Handle recursive links in runtime sources.

internal/smartlink/smartlink.go

@@ -29,7 +29,7 @@ func LinkContents(src, dest string) error {
 		return errs.Wrap(err, "Reading dir %s failed", src)
 	}
 	for _, entry := range entries {
-		if err := Link(filepath.Join(src, entry.Name()), filepath.Join(dest, entry.Name())); err != nil {
+		if err := Link(filepath.Join(src, entry.Name()), filepath.Join(dest, entry.Name()), nil); err != nil {
 			return errs.Wrap(err, "Link failed")
 		}
 	}
@@ -39,13 +39,28 @@ func LinkContents(src, dest string) error {
 
 // Link creates a link from src to target. MS decided to support Symlinks but only if you opt into developer mode (go figure),
 // which we cannot reasonably force on our users. So on Windows we will instead create dirs and hardlinks.
-func Link(src, dest string) error {
+func Link(src, dest string, visited map[string]int) error {
 	var err error
 	src, dest, err = resolvePaths(src, dest)
 	if err != nil {
 		return errs.Wrap(err, "Could not resolve src and dest paths")
 	}
 
+	if visited == nil {
+		visited = make(map[string]int)
+	}
+	if count, exists := visited[src]; exists {
+		// We've encountered a recursive link. This is most often the case when the resolved src has
+		// already been visited. We will recurse into the directory no more than once, so that any
+		// runtime paths that reference the link will not silently fail.
+		if count > 1 {
+			return nil
+		}
+		visited[src]++
+	} else {
+		visited[src] = 1
+	}
+
 	if fileutils.IsDir(src) {
 		if err := fileutils.Mkdir(dest); err != nil {
 			return errs.Wrap(err, "could not create directory %s", dest)
@@ -55,7 +70,7 @@ func Link(src, dest string) error {
 			return errs.Wrap(err, "could not read directory %s", src)
 		}
 		for _, entry := range entries {
-			if err := Link(filepath.Join(src, entry.Name()), filepath.Join(dest, entry.Name())); err != nil {
+			if err := Link(filepath.Join(src, entry.Name()), filepath.Join(dest, entry.Name()), visited); err != nil {
 				return errs.Wrap(err, "sub link failed")
 			}
 		}

internal/smartlink/smartlink_test.go

@@ -0,0 +1,73 @@
+package smartlink
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestLinkContentsWithCircularLink(t *testing.T) {
+	srcDir, err := os.MkdirTemp("", "src")
+	require.NoError(t, err)
+	defer os.RemoveAll(srcDir)
+
+	destDir, err := os.MkdirTemp("", "dest")
+	require.NoError(t, err)
+	defer os.RemoveAll(destDir)
+
+	// Create test file structure:
+	// src/
+	//   ├── regular.txt
+	//   └── subdir/
+	//        ├── circle -> subdir (circular link)
+	//        └── subfile.txt
+
+	testFile := filepath.Join(srcDir, "regular.txt")
+	err = os.WriteFile(testFile, []byte("test content"), 0644)
+	require.NoError(t, err)
+
+	subDir := filepath.Join(srcDir, "subdir")
+	err = os.Mkdir(subDir, 0755)
+	require.NoError(t, err)
+
+	subFile := filepath.Join(subDir, "subfile.txt")
+	err = os.WriteFile(subFile, []byte("sub content"), 0644)
+	require.NoError(t, err)
+
+	circularLink := filepath.Join(subDir, "circle")
+	err = os.Symlink(subDir, circularLink)
+	require.NoError(t, err)
+
+	err = LinkContents(srcDir, destDir)
+	require.NoError(t, err)
+
+	// Verify file structure.
+	// src/
+	//   ├── regular.txt
+	//   └── subdir/
+	//        ├── circle
+	//        │   │   (no subdir/)
+	//        │   └── subfile.txt
+	//        └── subfile.txt
+	destFile := filepath.Join(destDir, "regular.txt")
+	require.FileExists(t, destFile)
+	content, err := os.ReadFile(destFile)
+	require.NoError(t, err)
+	require.Equal(t, "test content", string(content))
+
+	destSubFile := filepath.Join(destDir, "subdir", "subfile.txt")
+	require.FileExists(t, destSubFile)
+	subContent, err := os.ReadFile(destSubFile)
+	require.NoError(t, err)
+	require.Equal(t, "sub content", string(subContent))
+
+	require.NoDirExists(t, filepath.Join(destDir, "subdir", "circle", "circle"))
+
+	destCircularSubFile := filepath.Join(destDir, "subdir", "circle", "subfile.txt")
+	require.FileExists(t, destCircularSubFile)
+	subContent, err = os.ReadFile(destCircularSubFile)
+	require.NoError(t, err)
+	require.Equal(t, "sub content", string(subContent))
+}

pkg/runtime/depot.go

@@ -295,7 +295,7 @@ func (d *depot) Undeploy(id strfmt.UUID, relativeSrc, path string) error {
 	for sharedFile, relinkSrc := range redeploys {
 		switch deploy.Type {
 		case deploymentTypeLink:
-			if err := smartlink.Link(relinkSrc, sharedFile); err != nil {
+			if err := smartlink.Link(relinkSrc, sharedFile, nil); err != nil {
 				return errs.Wrap(err, "failed to relink file")
 			}
 		case deploymentTypeCopy:

pkg/runtime/links_windows.go

@@ -43,7 +43,7 @@ func supportsHardLinks(path string) (supported bool) {
 	}
 
 	logging.Debug("Attempting to link '%s' to '%s'", lnk, target)
-	err = smartlink.Link(target, lnk)
+	err = smartlink.Link(target, lnk, nil)
 	if err != nil {
 		logging.Debug("Test link creation failed: %v", err)
 		return false