sneak
7ae470e530
Fix every finding surfaced by the canonical .golangci.yml with golangci-lint v2.12.2 (refs #61), behavior-preserving throughout: - err113: dynamic errors replaced with package-level sentinels and %w wrapping; direct comparisons converted to errors.Is - goprintffuncname: printf-style helpers renamed with an f suffix (ui.Writer message methods, cli.ReportErrorf, database.Fatalf, vaultik stdoutf) and all call sites updated - revive: stuttering type names renamed (blob.Handler, blob.WithReader, blob.ChunkPosition, storage.URL, storage.Info), doc comments added, unused parameters blanked, package comments added - contextcheck/noctx: ctx threaded through blob.Packer (AddChunk/Flush/FinalizeBlob/PackChunks) and scanner call sites; context-aware exec and sql variants used - funlen/cyclop/gocognit/nestif/dupl: oversized or duplicated functions split into focused helpers across production and test code - paralleltest/tparallel/thelper/usetesting/testpackage: tests parallelized where safe (global log.Initialize kept in the serial phase), helpers marked, t.TempDir adopted, external test packages where only exported API is used - gosec: integer conversions clamped or justified, header timeouts added, remaining findings suppressed with per-site justifications - mnd/goconst/lll/wsl_v5/nlreturn/noinlineerr/errcheck and other mechanical findings fixed directly Remove the deprecated log.LogOptions alias (callers migrated to log.Options). make check is green.
122 lines
3.1 KiB
Go
122 lines
3.1 KiB
Go
// Package pidlock provides process-level locking using PID files.
|
|
// It prevents multiple instances of vaultik from running simultaneously,
|
|
// which would cause database locking conflicts.
|
|
package pidlock
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
)
|
|
|
|
// ErrAlreadyRunning indicates another vaultik instance is running.
|
|
var ErrAlreadyRunning = errors.New("another vaultik instance is already running")
|
|
|
|
// Lock represents an acquired PID lock.
|
|
type Lock struct {
|
|
path string
|
|
}
|
|
|
|
const (
|
|
// lockDirPerm is the mode for the lock directory (owner-only).
|
|
lockDirPerm = 0o700
|
|
// pidFilePerm is the mode for the PID file (owner-only).
|
|
pidFilePerm = 0o600
|
|
)
|
|
|
|
// Acquire attempts to acquire a PID lock in the specified directory.
|
|
// If the lock file exists and the process is still running, it returns
|
|
// ErrAlreadyRunning with details about the existing process.
|
|
// On success, it writes the current PID to the lock file and returns
|
|
// a Lock that must be released with Release().
|
|
func Acquire(lockDir string) (*Lock, error) {
|
|
// Ensure lock directory exists
|
|
err := os.MkdirAll(lockDir, lockDirPerm)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("creating lock directory: %w", err)
|
|
}
|
|
|
|
lockPath := filepath.Join(lockDir, "vaultik.pid")
|
|
|
|
// Check for existing lock
|
|
existingPID, err := readPIDFile(lockPath)
|
|
if err == nil {
|
|
// Lock file exists, check if process is running
|
|
if isProcessRunning(existingPID) {
|
|
return nil, fmt.Errorf("%w (PID %d)", ErrAlreadyRunning, existingPID)
|
|
}
|
|
// Process is not running, stale lock file - we can take over
|
|
}
|
|
|
|
// Write our PID
|
|
pid := os.Getpid()
|
|
|
|
err = os.WriteFile(lockPath, []byte(strconv.Itoa(pid)), pidFilePerm)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("writing PID file: %w", err)
|
|
}
|
|
|
|
return &Lock{path: lockPath}, nil
|
|
}
|
|
|
|
// Release removes the PID lock file.
|
|
// It is safe to call Release multiple times.
|
|
func (l *Lock) Release() error {
|
|
if l == nil || l.path == "" {
|
|
return nil
|
|
}
|
|
|
|
// Verify we still own the lock (our PID is in the file)
|
|
existingPID, err := readPIDFile(l.path)
|
|
if err != nil {
|
|
// File already gone or unreadable - that's fine
|
|
return nil //nolint:nilerr // unreadable lock file means nothing to release
|
|
}
|
|
|
|
if existingPID != os.Getpid() {
|
|
// Someone else wrote to our lock file - don't remove it
|
|
return nil
|
|
}
|
|
|
|
err = os.Remove(l.path)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return fmt.Errorf("removing PID file: %w", err)
|
|
}
|
|
|
|
l.path = "" // Prevent double-release
|
|
|
|
return nil
|
|
}
|
|
|
|
// readPIDFile reads and parses the PID from a lock file.
|
|
func readPIDFile(path string) (int, error) {
|
|
data, err := os.ReadFile(path) //nolint:gosec // G304: path is our own lock file
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
pid, err := strconv.Atoi(strings.TrimSpace(string(data)))
|
|
if err != nil {
|
|
return 0, fmt.Errorf("parsing PID: %w", err)
|
|
}
|
|
|
|
return pid, nil
|
|
}
|
|
|
|
// isProcessRunning checks if a process with the given PID is running.
|
|
func isProcessRunning(pid int) bool {
|
|
process, err := os.FindProcess(pid)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
|
|
// On Unix, FindProcess always succeeds. We need to send signal 0 to check.
|
|
err = process.Signal(syscall.Signal(0))
|
|
|
|
return err == nil
|
|
}
|