Eine Datei atomar schreiben (tmp + fsync + rename) snippet

import fs from 'node:fs';

function writeFileAtomic(path, data) {
  const tmp = `${path}.${process.pid}.tmp`; // same directory → same filesystem
  const fd = fs.openSync(tmp, 'w');
  try {
    fs.writeFileSync(fd, data);
    fs.fsyncSync(fd);              // data hits the disk BEFORE the swap
  } finally {
    fs.closeSync(fd);
  }
  try {
    fs.renameSync(tmp, path);      // atomic within one filesystem
  } catch (err) {
    fs.unlinkSync(tmp);            // never leave the temp file behind
    throw err;
  }
}

import fs from 'node:fs';
import path from 'node:path';

export function atomicWrite(file: string, data: string): void {
  const tmp = path.join(
    path.dirname(file),
    `.${path.basename(file)}.tmp`,
  ); // provably the same directory
  const fd = fs.openSync(tmp, 'w');
  try {
    fs.writeFileSync(fd, data, 'utf8');
    fs.fsyncSync(fd);
  } finally {
    fs.closeSync(fd);
  }
  try {
    fs.renameSync(tmp, file);
  } catch (err) {
    try { fs.unlinkSync(tmp); } catch { /* already gone */ }
    throw err; // try/catch keeps the rename error AND drops the tmp
  }
}

import (
	"os"
	"path/filepath"
)

func writeFileAtomic(path string, data []byte) error {
	tmp, err := os.CreateTemp(filepath.Dir(path), filepath.Base(path)+".tmp*")
	if err != nil {
		return err
	}
	tmpName := tmp.Name() // CreateTemp put it in dir → same filesystem
	defer os.Remove(tmpName) // no-op once the rename succeeds
	if _, err := tmp.Write(data); err != nil {
		tmp.Close()
		return err
	}
	if err := tmp.Sync(); err != nil { // flush to disk before the swap
		tmp.Close()
		return err
	}
	if err := tmp.Close(); err != nil {
		return err
	}
	return os.Rename(tmpName, path) // atomic within one filesystem
}

use std::fs::{self, File};
use std::io::Write;
use std::path::Path;

fn write_atomic(path: &Path, data: &[u8]) -> std::io::Result<()> {
    let tmp = path.with_extension("tmp"); // sits beside the target
    let mut f = File::create(&tmp)?;
    f.write_all(data)?;
    f.sync_all()?; // data AND metadata — content is on disk
    drop(f); // close before the rename
    fs::rename(&tmp, path) // POSIX: atomic within one filesystem
}

function writeFileAtomic(string $path, string $data): void
{
    $tmp = $path . '.tmp'; // same directory → rename stays atomic
    if (file_put_contents($tmp, $data, LOCK_EX) === false) {
        throw new \RuntimeException("write failed: {$tmp}");
    }
    // fflush() only drains PHP's userspace buffer into the OS page cache —
    // PHP core has no fsync (see notes).
    if (!rename($tmp, $path)) {
        @unlink($tmp);
        throw new \RuntimeException("rename failed: {$tmp} → {$path}");
    }
}

import os
import tempfile

def write_file_atomic(path: str, data: str) -> None:
    d = os.path.dirname(path) or '.'
    fd, tmp = tempfile.mkstemp(dir=d, prefix='.tmp-')  # same directory
    try:
        with os.fdopen(fd, 'w', encoding='utf-8') as f:
            f.write(data)
            f.flush()
            os.fsync(f.fileno())     # to disk BEFORE the swap
        os.replace(tmp, path)        # atomic; overwrites; Windows-safe
    except BaseException:
        os.unlink(tmp)               # cleanup on ANY failure
        raise

using System.IO;

static void WriteFileAtomic(string path, byte[] data)
{
    string tmp = path + ".tmp"; // same directory
    using (var fs = new FileStream(tmp, FileMode.Create,
                                   FileAccess.Write, FileShare.None))
    {
        fs.Write(data, 0, data.Length);
        fs.Flush(flushToDisk: true);      // fsync, not just userspace
    }
    File.Move(tmp, path, overwrite: true); // atomic on POSIX
}

import java.io.IOException;
import java.nio.channels.FileChannel;
import java.nio.file.AtomicMoveNotSupportedException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

import static java.nio.file.StandardCopyOption.ATOMIC_MOVE;
import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

static void writeFileAtomic(Path path, byte[] data) throws IOException {
    Path dir = path.toAbsolutePath().getParent();
    Path tmp = Files.createTempFile(dir, path.getFileName().toString(), ".tmp");
    try {
        Files.write(tmp, data);
        try (FileChannel ch = FileChannel.open(tmp,
                StandardOpenOption.READ, StandardOpenOption.WRITE)) {
            ch.force(true); // data + metadata, before the swap
        }
        Files.move(tmp, path, ATOMIC_MOVE, REPLACE_EXISTING);
    } catch (AtomicMoveNotSupportedException e) {
        // the tmp escaped the target filesystem — surface it, never swallow
        throw new IOException("cross-filesystem move: " + tmp, e);
    } finally {
        Files.deleteIfExists(tmp); // no-op after a successful move
    }
}

import Foundation

func writeFileAtomic(at url: URL, data: Data) throws {
    let dir = url.deletingLastPathComponent()
    let tmp = dir.appendingPathComponent(".tmp-\(url.lastPathComponent)")
    try data.write(to: tmp) // same directory → same filesystem

    // Foundation exposes no public fsync; F_FULLFSYNC via raw fcntl on the fd
    // is private-API territory. The move below is the atomic step — crash
    // durability before it is the documented gap.
    if FileManager.default.fileExists(atPath: url.path) {
        _ = try FileManager.default.replaceItemAt(url, withItemAt: tmp)
    } else {
        try FileManager.default.moveItem(at: tmp, to: url)
    }
}

import java.nio.channels.FileChannel
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.StandardCopyOption.ATOMIC_MOVE
import java.nio.file.StandardCopyOption.REPLACE_EXISTING
import java.nio.file.StandardOpenOption.READ
import java.nio.file.StandardOpenOption.WRITE

fun writeFileAtomic(path: Path, data: ByteArray) {
    val dir = path.toAbsolutePath().parent
    val tmp = Files.createTempFile(dir, path.fileName.toString(), ".tmp")
    try {
        Files.write(tmp, data)
        FileChannel.open(tmp, READ, WRITE).use { it.force(true) }
        Files.move(tmp, path, ATOMIC_MOVE, REPLACE_EXISTING)
    } finally {
        Files.deleteIfExists(tmp) // no-op after the successful move
    }
}

require 'tempfile'

def write_file_atomic(path, data)
  dir = File.dirname(path)
  Tempfile.create('.tmp-', dir) do |tmp|  # created in the SAME directory
    tmp.write(data)
    tmp.flush                              # userspace → OS
    tmp.fsync                              # OS → disk
    File.rename(tmp.path, path)            # the atomic swap
  end
end

const std = @import("std");

fn writeFileAtomic(path: []const u8, data: []const u8) !void {
    var buf: [std.fs.max_path_bytes]u8 = undefined;
    const tmp = try std.fmt.bufPrint(&buf, "{s}.tmp", .{path});

    var f = try std.fs.cwd().createFile(tmp, .{});
    defer f.close();
    try f.writeAll(data);
    try std.posix.fsync(f.handle); // disk BEFORE the swap — order is the contract

    try std.posix.rename(tmp, path); // rename(2): atomic within one filesystem
}