atomic.go

package main

import (
	"os"
	"path/filepath"
)

// atomicWriteFile writes data to path atomically using a temp-file + rename strategy.
//
// HOW IT WORKS:
//  1. Write data to a temporary file in the same directory.
//  2. Sync to disk (fsync) so the data is physically written.
//  3. Rename the temp file over the target path.
//
// WHY THIS IS SAFE:
//  - If the process crashes during step 1 or 2, only the temp file is lost;
//    the original file at [path] is untouched (implicit rollback).
//  - os.Rename on the same filesystem is atomic on all POSIX systems and
//    on Windows NTFS — the target path either has the old content or the new
//    content, never a partial/corrupted state.
//  - The temp file is always cleaned up on failure.
func atomicWriteFile(path string, data []byte, perm os.FileMode) (err error) {
	dir := filepath.Dir(path)

	if err := os.MkdirAll(dir, 0o755); err != nil {
		return err
	}

	tmp, err := os.CreateTemp(dir, ".tmp-*.write")
	if err != nil {
		return err
	}
	tmpPath := tmp.Name()

	// Clean up temp file on any failure; on success the rename moves it away.
	defer func() {
		if err != nil {
			os.Remove(tmpPath) // best effort
		}
	}()

	if _, err = tmp.Write(data); err != nil {
		tmp.Close()
		return err
	}

	// Force flush to disk so a power loss after rename doesn't lose data.
	if err = tmp.Sync(); err != nil {
		tmp.Close()
		return err
	}

	if err = tmp.Chmod(perm); err != nil {
		tmp.Close()
		return err
	}

	if err = tmp.Close(); err != nil {
		return err
	}

	// Atomic swap — same filesystem, so this is truly atomic.
	return os.Rename(tmpPath, path)
}