Files
dokku/plugins/common/lock.go
T
Jose Diaz-Gonzalez 9df45f6a6e fix: serialize concurrent property updates
Concurrent commands for the same app could each read a setting, change it, and write it back, so all of them exited successfully while silently dropping changes made by the others. Updates to app settings are now serialized so every change is kept, and readers never see a partially written value.
2026-10-21 21:21:57 -04:00

61 lines
1.9 KiB
Go

package common
import (
"fmt"
"os"
"path/filepath"
"strings"
"syscall"
)
// LockedDirectoriesEnvVar names the environment variable a caller holding a
// directory lock exports to its child processes. It holds a newline-separated
// list of directories, and LockDirectory runs its callback without locking a
// directory found in that list, so a subprocess spawned while the lock is held
// does not deadlock waiting on its own parent.
const LockedDirectoriesEnvVar = "DOKKU_LOCKED_DIRECTORIES"
// LockDirectory holds an exclusive flock on dir for the duration of fn. The
// directory must already exist. The lock is advisory: it serializes callers
// that go through LockDirectory, and does not block plain reads. Locks are
// taken per open file description, so goroutines in a single process exclude
// each other as well as separate processes do.
//
// A directory listed in DOKKU_LOCKED_DIRECTORIES is treated as already held by
// a parent process, and fn runs without taking the lock again. LockDirectory is
// not reentrant otherwise: fn must not call LockDirectory on the same
// directory, as that would block forever.
func LockDirectory(dir string, fn func() error) error {
dir = filepath.Clean(dir)
if isDirectoryLockHeld(dir) {
return fn()
}
file, err := os.Open(dir)
if err != nil {
return fmt.Errorf("Unable to open %s for locking: %w", dir, err)
}
defer file.Close()
if err := syscall.Flock(int(file.Fd()), syscall.LOCK_EX); err != nil {
return fmt.Errorf("Unable to lock %s: %w", dir, err)
}
defer syscall.Flock(int(file.Fd()), syscall.LOCK_UN)
return fn()
}
// isDirectoryLockHeld reports whether dir is listed in DOKKU_LOCKED_DIRECTORIES
func isDirectoryLockHeld(dir string) bool {
for _, held := range strings.Split(os.Getenv(LockedDirectoriesEnvVar), "\n") {
held = strings.TrimSpace(held)
if held == "" {
continue
}
if filepath.Clean(held) == dir {
return true
}
}
return false
}