chore: Release

[ovaistariq]

Note

Adds a one-line install script, switches to a positive --tigris-prefetch flag defaulting off, and hardens directory listing with generation tracking and lock-order fixes; updates docs to v1.2.1 and refactors semaphores in tests.

• Install/Docs:
  • One-line installer: New install.sh downloads the latest release, verifies checksums/signatures, detects OS/arch/pkg manager, and handles macFUSE on macOS.
  • README: Add one-line install; update downloads to v1.2.1; adjust mount paths to $HOME/mnt/tigris/<bucket> and /mnt/tigris/<bucket>; update macOS tarball URL.
• Core (directory handling):
  • Introduce directory generation tracking in DirInodeData/DirHandle to detect structural changes and reset iteration safely.
  • Avoid deadlocks by unlocking around sealDir, slurp, and list calls; revalidate generation after operations.
  • Increment generation on structural mutations (insert/remove/removeAllChildren/sealDir).
• Flags:
  • Replace --no-tigris-prefetch with --tigris-prefetch (default off); update flag parsing and defaults.
• Cluster:
  • Propagate dir-handle generation when opening/reading directories in cluster paths.
• Cache/Lookup:
  • Add recheckInodeByName and use it in RefreshInodeCache to avoid stale inode references.
• Tests/Utils:
  • Replace custom channel-based semaphore with golang.org/x/sync/semaphore via new Semaphore wrapper; update test helpers accordingly.

^{Written by Cursor Bugbot for commit d3e4661. This will update automatically on new commits. Configure here.}

[greptile-apps]

Greptile Overview

Summary

This release PR (v1.2.1) consolidates several important fixes and improvements:

• Deadlock Resolution: Implemented generation-based directory invalidation in core/dir.go to resolve deadlocks in directory operations, replacing direct handle manipulation with atomic counters
• Semaphore Modernization: Replaced deprecated custom semaphore implementation with golang.org/x/sync/semaphore
• Configuration Change: Changed Tigris prefetch to be disabled by default (performance optimization)
• Installation Improvements: Added comprehensive installation script with multi-platform support and macFUSE handling
• Documentation Updates: Version bumps to 1.2.1 and corrected mount path references

The most complex change is the directory operation deadlock fix using generation-based invalidation, which appears well-designed to avoid the mutex ordering issues that caused the original deadlock.

Confidence Score: 4/5

• This PR is mostly safe to merge with one identified logical issue in test code
• Score reflects solid engineering work on complex deadlock resolution and semaphore modernization, but the incorrect semaphore usage pattern in test code could lead to race conditions
• Pay close attention to core/goofys_common_test.go for the semaphore race condition fix

Important Files Changed

File Analysis

Filename	Score	Overview
core/dir.go	4/5	Complex deadlock fix using generation-based directory invalidation instead of direct handle manipulation; includes proper mutex ordering
core/goofys_common_test.go	5/5	Updated semaphore usage from custom implementation to golang.org/x/sync/semaphore with correct P/V semantics
core/utils.go	5/5	Replaced deprecated custom semaphore implementation with golang.org/x/sync/semaphore
install.sh	5/5	New installation script with comprehensive platform support, checksum verification, and macFUSE handling

_{8 files reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

[greptile-apps]

logic: Semaphore pattern incorrect: should acquire slots before starting goroutines, not inside them. This creates a race where more goroutines can start than the semaphore allows.

Suggested change

	sem := NewSemaphore(concurrency)
	var err error
	sem := NewSemaphore(concurrency)
	var err error
	for _, blobOuter := range blobs {
	sem.P(1) // Acquire slot before spawning goroutine
	go func(blob string) {
	defer sem.V(1) // Release slot when goroutine completes

Prompt To Fix With AI

This is a comment left during a code review.
Path: core/goofys_common_test.go
Line: 132:133

Comment:
logic: Semaphore pattern incorrect: should acquire slots before starting goroutines, not inside them. This creates a race where more goroutines can start than the semaphore allows.

```suggestion
	sem := NewSemaphore(concurrency)
	var err error
	for _, blobOuter := range blobs {
		sem.P(1) // Acquire slot before spawning goroutine
		go func(blob string) {
			defer sem.V(1) // Release slot when goroutine completes
```

How can I resolve this? If you propose a fix, please make it concise.