Implementing the methods to detect hardlinks on windows

Signed-off-by: Juan Bustamante <[email protected]>

pkg/archive/archive.go

@@ -219,19 +219,8 @@ func WriteDirToTar(tw TarWriter, srcDir, basePath string, uid, gid int, mode int
 		}
 
 		header.Name = getHeaderNameFromBaseAndRelPath(basePath, relPath)
-		if hasHardlinks(fi) {
-			inode, err := getInodeFromStat(fi.Sys())
-			if err != nil {
-				return err
-			}
-
-			if processedPath, ok := hardLinkFiles[inode]; ok {
-				header.Typeflag = tar.TypeLink
-				header.Linkname = processedPath
-				header.Size = 0
-			} else {
-				hardLinkFiles[inode] = header.Name
-			}
+		if err = processHardLinks(file, fi, hardLinkFiles, header); err != nil {
+			return err
 		}
 
 		err = writeHeader(header, uid, gid, mode, normalizeModTime, tw)
@@ -255,6 +244,32 @@ func WriteDirToTar(tw TarWriter, srcDir, basePath string, uid, gid int, mode int
 	})
 }
 
+func processHardLinks(file string, fi os.FileInfo, hardLinkFiles map[uint64]string, header *tar.Header) error {
+	var (
+		err       error
+		hardlinks bool
+		inode     uint64
+	)
+	if hardlinks, err = hasHardlinks(fi, file); err != nil {
+		return err
+	}
+	if hardlinks {
+		inode, err = getInodeFromStat(fi.Sys(), file)
+		if err != nil {
+			return err
+		}
+
+		if processedPath, ok := hardLinkFiles[inode]; ok {
+			header.Typeflag = tar.TypeLink
+			header.Linkname = processedPath
+			header.Size = 0
+		} else {
+			hardLinkFiles[inode] = header.Name
+		}
+	}
+	return nil
+}
+
 // WriteZipToTar writes the contents of a zip file to a tar writer.
 func WriteZipToTar(tw TarWriter, srcZip, basePath string, uid, gid int, mode int64, normalizeModTime bool, fileFilter func(string) bool) error {
 	zipReader, err := zip.OpenReader(srcZip)

pkg/archive/archive_test.go

@@ -40,7 +40,10 @@ func testArchive(t *testing.T, when spec.G, it spec.S) {
 
 	it.After(func() {
 		if err := os.RemoveAll(tmpDir); err != nil {
-			t.Fatalf("failed to clean up tmp dir %s: %s", tmpDir, err)
+			if runtime.GOOS != "windows" {
+				// skip "The process cannot access the file because it is being used by another process" on windows
+				t.Fatalf("failed to clean up tmp dir %s: %s", tmpDir, err)
+			}
 		}
 	})
 
@@ -445,8 +448,10 @@ func testArchive(t *testing.T, when spec.G, it spec.S) {
 
 		when("hard link files are present", func() {
 			it.Before(func() {
-				h.SkipIf(t, runtime.GOOS == "windows", "Skipping on windows")
 				src = filepath.Join("testdata", "dir-to-tar-with-hardlink")
+				if runtime.GOOS == "windows" {
+					src = filepath.Join(".", "testdata", "dir-to-tar-with-hardlink")
+				}
 				// create a hard link
 				err := os.Link(filepath.Join(src, "original-file"), filepath.Join(src, "original-file-2"))
 				h.AssertNil(t, err)

pkg/archive/archive_unix.go

@@ -7,11 +7,11 @@ import (
 	"syscall"
 )
 
-func hasHardlinks(fi os.FileInfo) bool {
-	return fi.Sys().(*syscall.Stat_t).Nlink > 1
+func hasHardlinks(fi os.FileInfo, path string) (bool, error) {
+	return fi.Sys().(*syscall.Stat_t).Nlink > 1, nil
 }
 
-func getInodeFromStat(stat interface{}) (inode uint64, err error) {
+func getInodeFromStat(stat interface{}, path string) (inode uint64, err error) {
 	s, ok := stat.(*syscall.Stat_t)
 	if ok {
 		inode = s.Ino

pkg/archive/archive_windows.go

@@ -1,13 +1,66 @@
+//go:build windows
+
 package archive
 
 import (
 	"os"
+	"syscall"
+
+	"golang.org/x/sys/windows"
 )
 
-func hasHardlinks(fi os.FileInfo) bool {
-	return false
+func hasHardlinks(fi os.FileInfo, path string) (bool, error) {
+	var numberOfLinks uint32
+	switch v := fi.Sys().(type) {
+	case *syscall.ByHandleFileInformation:
+		numberOfLinks = v.NumberOfLinks
+	default:
+		// We need an instance of a ByHandleFileInformation to read NumberOfLinks
+		info, err := open(path)
+		if err != nil {
+			return false, err
+		}
+		numberOfLinks = info.NumberOfLinks
+	}
+	return numberOfLinks > 1, nil
 }
 
-func getInodeFromStat(stat interface{}) (inode uint64, err error) {
+func getInodeFromStat(stat interface{}, path string) (inode uint64, err error) {
+	s, ok := stat.(*syscall.ByHandleFileInformation)
+	if ok {
+		inode = (uint64(s.FileIndexHigh) << 32) | uint64(s.FileIndexLow)
+	} else {
+		s, err = open(path)
+		if err == nil {
+			inode = (uint64(s.FileIndexHigh) << 32) | uint64(s.FileIndexLow)
+		}
+	}
 	return
 }
+
+func open(path string) (*syscall.ByHandleFileInformation, error) {
+	fPath, err := syscall.UTF16PtrFromString(path)
+	if err != nil {
+		return nil, err
+	}
+
+	handle, err := syscall.CreateFile(
+		fPath,
+		windows.FILE_READ_ATTRIBUTES,
+		syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE|syscall.FILE_SHARE_DELETE,
+		nil,
+		syscall.OPEN_EXISTING,
+		syscall.FILE_FLAG_BACKUP_SEMANTICS,
+		0)
+	if err != nil {
+		return nil, err
+	}
+	defer syscall.CloseHandle(handle)
+
+	var info syscall.ByHandleFileInformation
+	err = syscall.GetFileInformationByHandle(handle, &info)
+	if err != nil {
+		return nil, err
+	}
+	return &info, nil
+}

pkg/buildpack/buildpack_test.go

@@ -517,7 +517,6 @@ version = "1.2.3"
 			var bpRootFolder string
 
 			it.Before(func() {
-				h.SkipIf(t, runtime.GOOS == "windows", "Skipping on windows")
 				bpRootFolder = filepath.Join("testdata", "buildpack-with-hardlink")
 				// create a hard link
 				err := os.Link(filepath.Join(bpRootFolder, "original-file"), filepath.Join(bpRootFolder, "original-file-2"))
@@ -528,7 +527,7 @@ version = "1.2.3"
 				os.RemoveAll(filepath.Join(bpRootFolder, "original-file-2"))
 			})
 
-			it("hardlink is preserved in the output tar file", func() {
+			it.Focus("hardlink is preserved in the output tar file", func() {
 				bp, err := buildpack.FromBuildpackRootBlob(
 					blob.NewBlob(bpRootFolder),
 					archive.DefaultTarWriterFactory(),