Port to and test on Windows (#3)

Author: AlekSi

.github/workflows/go.yml

@@ -20,7 +20,7 @@ jobs:
       fail-fast: false
       matrix:
         go: ["1.25.x"]
-        os: [ubuntu-24.04, macos-26]
+        os: [ubuntu-24.04, macos-26, windows-2025]
 
     steps:
       - name: Fix git settings on Windows

internal/caches/local/disk_other.go

@@ -1,4 +1,4 @@
-//go:build !unix
+//go:build !unix && !windows
 
 package local
 

internal/caches/local/disk_unix_test.go internal/caches/local/disk_test.gointernal/caches/local/disk_unix_test.go renamed to internal/caches/local/disk_test.go

@@ -0,0 +1,26 @@
+package local
+
+import (
+	"github.com/AlekSi/lazyerrors"
+	"golang.org/x/sys/windows"
+)
+
+// DiskInfo returns the total and free disk space in bytes.
+func DiskInfo(dir string) (total, free int64, err error) {
+	directoryName, err := windows.UTF16PtrFromString(dir)
+	if err != nil {
+		return -1, -1, lazyerrors.Error(err)
+	}
+
+	var freeBytesAvailableToCaller uint64
+	var totalNumberOfBytes uint64
+	var totalNumberOfFreeBytes uint64
+	err = windows.GetDiskFreeSpaceEx(directoryName, &freeBytesAvailableToCaller, &totalNumberOfBytes, &totalNumberOfFreeBytes)
+	if err != nil {
+		return -1, -1, lazyerrors.Error(err)
+	}
+
+	total = int64(totalNumberOfBytes)
+	free = int64(totalNumberOfFreeBytes)
+	return
+}

internal/caches/local/disk_windows.go

@@ -8,6 +8,7 @@
 package filelock
 
 import (
+	"errors"
 	"io/fs"
 )
 
@@ -73,3 +74,10 @@ func (lt lockType) String() string {
 		return "Unlock"
 	}
 }
+
+// IsNotSupported returns a boolean indicating whether the error is known to
+// report that a function is not supported (possibly for a specific input).
+// It is satisfied by errors.ErrUnsupported as well as some syscall errors.
+func IsNotSupported(err error) bool {
+	return errors.Is(err, errors.ErrUnsupported)
+}

internal/go/lockedfile/internal/filelock/filelock.go

@@ -7,29 +7,51 @@
 package filelock
 
 import (
-	"errors"
 	"io/fs"
+
+	"golang.org/x/sys/windows"
 )
 
 type lockType uint32
 
 const (
 	readLock  lockType = 0
-	writeLock lockType = 0x00000002
+	writeLock lockType = windows.LOCKFILE_EXCLUSIVE_LOCK
+)
+
+const (
+	reserved = 0
+	allBytes = ^uint32(0)
 )
 
 func lock(f File, lt lockType) error {
-	return &fs.PathError{
-		Op:   lt.String(),
-		Path: f.Name(),
-		Err:  errors.ErrUnsupported,
+	// Per https://golang.org/issue/19098, “Programs currently expect the Fd
+	// method to return a handle that uses ordinary synchronous I/O.”
+	// However, LockFileEx still requires an OVERLAPPED structure,
+	// which contains the file offset of the beginning of the lock range.
+	// We want to lock the entire file, so we leave the offset as zero.
+	ol := new(windows.Overlapped)
+
+	err := windows.LockFileEx(windows.Handle(f.Fd()), uint32(lt), reserved, allBytes, allBytes, ol)
+	if err != nil {
+		return &fs.PathError{
+			Op:   lt.String(),
+			Path: f.Name(),
+			Err:  err,
+		}
 	}
+	return nil
 }
 
 func unlock(f File) error {
-	return &fs.PathError{
-		Op:   "Unlock",
-		Path: f.Name(),
-		Err:  errors.ErrUnsupported,
+	ol := new(windows.Overlapped)
+	err := windows.UnlockFileEx(windows.Handle(f.Fd()), reserved, allBytes, allBytes, ol)
+	if err != nil {
+		return &fs.PathError{
+			Op:   "Unlock",
+			Path: f.Name(),
+			Err:  err,
+		}
 	}
+	return nil
 }

internal/go/lockedfile/internal/filelock/filelock_windows.go

@@ -52,13 +52,9 @@ func OpenFile(name string, flag int, perm fs.FileMode) (*File, error) {
 	// especially don't want to leave a file locked after we're done with it. Our
 	// Close method is what releases the locks, so use a cleanup to report
 	// missing Close calls on a best-effort basis.
-	f.cleanup = runtime.AddCleanup(
-		f,
-		func(fileName string) {
-			panic(fmt.Sprintf("lockedfile.File %s became unreachable without a call to Close", fileName))
-		},
-		f.Name(),
-	)
+	f.cleanup = runtime.AddCleanup(f, func(fileName string) {
+		panic(fmt.Sprintf("lockedfile.File %s became unreachable without a call to Close", fileName))
+	}, f.Name())
 
 	return f, nil
 }

internal/go/lockedfile/lockedfile.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// js and wasip1 do not support inter-process file locking.
+//
 //go:build !js && !wasip1
 
 package lockedfile_test
@@ -112,9 +114,9 @@ func TestReadWaitsForLock(t *testing.T) {
 	t.Logf("WriteString(%q) = <nil>", part1)
 
 	wait := mustBlock(t, "Read", func() {
-		b, err2 := lockedfile.Read(path)
-		if err2 != nil {
-			t.Errorf("Read: %v", err2)
+		b, err := lockedfile.Read(path)
+		if err != nil {
+			t.Errorf("Read: %v", err)
 			return
 		}
 

internal/go/lockedfile/lockedfile_test.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// js and wasip1 do not support inter-process file locking.
+//
 //go:build !js && !wasip1
 
 package lockedfile_test

internal/go/lockedfile/transform_test.go

@@ -5,9 +5,42 @@
 package mmap
 
 import (
+	"fmt"
 	"os"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
 )
 
 func mmapFile(f *os.File) (Data, error) {
-	panic("not implemented yet")
+	st, err := f.Stat()
+	if err != nil {
+		return Data{}, err
+	}
+	size := st.Size()
+	if size == 0 {
+		return Data{f, nil}, nil
+	}
+	h, err := windows.CreateFileMapping(windows.Handle(f.Fd()), nil, windows.PAGE_READONLY, 0, 0, nil)
+	if err != nil {
+		return Data{}, fmt.Errorf("CreateFileMapping %s: %w", f.Name(), err)
+	}
+
+	addr, err := windows.MapViewOfFile(h, windows.FILE_MAP_READ, 0, 0, 0)
+	if err != nil {
+		return Data{}, fmt.Errorf("MapViewOfFile %s: %w", f.Name(), err)
+	}
+	var info windows.MemoryBasicInformation
+	err = windows.VirtualQuery(addr, &info, unsafe.Sizeof(info))
+	if err != nil {
+		return Data{}, fmt.Errorf("VirtualQuery %s: %w", f.Name(), err)
+	}
+	data := unsafe.Slice((*byte)(unsafe.Pointer(addr)), int(info.RegionSize))
+	if len(data) < int(size) {
+		// In some cases, especially on 386, we may not receive a in incomplete mapping:
+		// one that is shorter than the file itself. Return an error in those cases because
+		// incomplete mappings are not useful.
+		return Data{}, fmt.Errorf("mmapFile: received incomplete mapping of file")
+	}
+	return Data{f, data[:int(size)]}, nil
 }