package v071 import ( "bytes" "errors" "fmt" "os" "path/filepath" ) // Publish without replacement: a second writer can only verify the already // committed bytes. Sync both the file and directory entries before returning an // anchor that another process may act on. This is not a power-loss test. func persistImmutableJSON(path string, raw []byte) error { directory := filepath.Dir(path) if err := ensureEvidenceDirectory(directory, syncEvidenceDirectory); err != nil { return err } info, err := os.Lstat(directory) if err != nil { return err } if !info.IsDir() || info.Mode()&os.ModeSymlink != 0 { return errors.New("immutable evidence directory is not a real directory") } existing := func() error { info, err := os.Lstat(path) if err != nil { return err } if !info.Mode().IsRegular() { return errors.New("immutable evidence is not a regular file") } body, err := os.ReadFile(path) if err != nil { return err } if !bytes.Equal(body, raw) { return errors.New("immutable evidence already exists with different bytes") } return syncEvidenceDirectory(directory) } if _, err := os.Lstat(path); err == nil { return existing() } else if !errors.Is(err, os.ErrNotExist) { return err } file, err := os.CreateTemp(directory, ".evidence-*") if err != nil { return err } temporary := file.Name() defer os.Remove(temporary) defer file.Close() if _, err := file.Write(raw); err != nil { return err } if err := file.Chmod(0444); err != nil { return err } if err := file.Sync(); err != nil { return err } if err := file.Close(); err != nil { return err } if err := os.Link(temporary, path); err != nil { if errors.Is(err, os.ErrExist) { return existing() } return fmt.Errorf("commit immutable evidence: %w", err) } if err := os.Remove(temporary); err != nil { return err } return syncEvidenceDirectory(directory) } func syncEvidenceDirectory(path string) error { directory, err := os.Open(path) if err != nil { return err } defer directory.Close() if err := directory.Sync(); err != nil { return fmt.Errorf("sync evidence directory: %w", err) } return nil }