-
Notifications
You must be signed in to change notification settings - Fork 1
/
tempfile.go
170 lines (151 loc) · 4.89 KB
/
tempfile.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
package renameio
import (
"errors"
"io/fs"
"os"
"path/filepath"
)
// TempDir checks whether os.TempDir() can be used as a temporary directory for
// later atomically replacing files within dest. If no (os.TempDir() resides on
// a different mount point), dest is returned.
//
// Note that the returned value ceases to be valid once either os.TempDir()
// changes (e.g. on Linux, once the TMPDIR environment variable changes) or the
// file system is unmounted.
func TempDir(dest string) string {
return tempDir("", filepath.Join(dest, "renameio-TempDir"))
}
func tempDir(dir, dest string) string {
if dir != "" {
return dir // caller-specified directory always wins
}
// Chose the destination directory as temporary directory so that we
// definitely can rename the file, for which both temporary and destination
// file need to point to the same mount point.
fallback := filepath.Dir(dest)
// The user might have overridden the os.TempDir() return value by setting
// the TMPDIR environment variable.
tmpdir := os.TempDir()
testsrc, err := os.CreateTemp(tmpdir, "."+filepath.Base(dest))
if err != nil {
return fallback
}
cleanup := true
defer func() {
if cleanup {
_ = os.Remove(testsrc.Name())
}
}()
_ = testsrc.Close()
testdest, err := os.CreateTemp(filepath.Dir(dest), "."+filepath.Base(dest))
if err != nil {
return fallback
}
defer func() {
_ = os.Remove(testdest.Name())
}()
_ = testdest.Close()
if err := os.Rename(testsrc.Name(), testdest.Name()); err != nil {
return fallback
}
cleanup = false // testsrc no longer exists
return tmpdir
}
// PendingFile is a pending temporary file, waiting to replace the destination
// path in a call to CloseAtomicallyReplace.
type PendingFile struct {
*os.File
path string
done bool
closed bool
}
// Cleanup is a no-op if CloseAtomicallyReplace succeeded, and otherwise closes
// and removes the temporary file.
func (t *PendingFile) Cleanup() error {
if t.done {
return nil
}
// An error occurred. Close and remove the tempfile. Errors are returned for
// reporting, there is nothing the caller can recover here.
var closeErr error
if !t.closed {
closeErr = t.Close()
}
if err := os.Remove(t.Name()); err != nil {
return err
}
return closeErr
}
// CloseAtomicallyReplace closes the temporary file and atomically replaces
// the destination file with it, i.e., a concurrent open(2) call will either
// open the file previously located at the destination path (if any), or the
// just written file, but the file will always be present.
func (t *PendingFile) CloseAtomicallyReplace() error {
// Even on an ordered file system (e.g. ext4 with data=ordered) or file
// systems with write barriers, we cannot skip the fsync(2) call as per
// Theodore Ts'o (ext2/3/4 lead developer):
//
// > data=ordered only guarantees the avoidance of stale data (e.g., the previous
// > contents of a data block showing up after a crash, where the previous data
// > could be someone's love letters, medical records, etc.). Without the fsync(2)
// > a zero-length file is a valid and possible outcome after the rename.
if err := t.Sync(); err != nil {
return err
}
t.closed = true
if err := t.Close(); err != nil {
return err
}
if err := os.Rename(t.Name(), t.path); err != nil {
return err
}
t.done = true
return nil
}
// TempFile wraps os.CreateTemp for the use case of atomically creating or
// replacing the destination file at path.
//
// If dir is the empty string, TempDir(filepath.Base(path)) is used. If you are
// going to write a large number of files to the same file system, store the
// result of TempDir(filepath.Base(path)) and pass it instead of the empty
// string.
//
// The file's permissions will be 0600 by default. You can change these by
// explicitly calling Chmod on the returned PendingFile.
func TempFile(dir, path string) (*PendingFile, error) {
f, err := os.CreateTemp(tempDir(dir, path), "."+filepath.Base(path))
if err != nil {
return nil, err
}
return &PendingFile{File: f, path: path}, nil
}
// Symlink wraps os.Symlink, replacing an existing symlink with the same name
// atomically (os.Symlink fails when newname already exists, at least on Linux).
func Symlink(oldname, newname string) error {
// Fast path: if newname does not exist yet, we can skip the whole dance
// below.
if err := os.Symlink(oldname, newname); err == nil || !errors.Is(err, fs.ErrExist) {
return err
}
// We need to use os.MkdirTemp, as we cannot overwrite a os.CreateTemp,
// and removing+symlinking creates a TOCTOU race.
d, err := os.MkdirTemp(filepath.Dir(newname), "."+filepath.Base(newname))
if err != nil {
return err
}
cleanup := true
defer func() {
if cleanup {
_ = os.RemoveAll(d)
}
}()
symlink := filepath.Join(d, "tmp.symlink")
if err := os.Symlink(oldname, symlink); err != nil {
return err
}
if err := os.Rename(symlink, newname); err != nil {
return err
}
cleanup = false
return os.RemoveAll(d)
}