copyOnWriteFs.go raw
1 package afero
2
3 import (
4 "fmt"
5 "os"
6 "path/filepath"
7 "syscall"
8 "time"
9 )
10
11 var _ Lstater = (*CopyOnWriteFs)(nil)
12
13 // The CopyOnWriteFs is a union filesystem: a read only base file system with
14 // a possibly writeable layer on top. Changes to the file system will only
15 // be made in the overlay: Changing an existing file in the base layer which
16 // is not present in the overlay will copy the file to the overlay ("changing"
17 // includes also calls to e.g. Chtimes(), Chmod() and Chown()).
18 //
19 // Reading directories is currently only supported via Open(), not OpenFile().
20 type CopyOnWriteFs struct {
21 base Fs
22 layer Fs
23 }
24
25 func NewCopyOnWriteFs(base Fs, layer Fs) Fs {
26 return &CopyOnWriteFs{base: base, layer: layer}
27 }
28
29 // Returns true if the file is not in the overlay
30 func (u *CopyOnWriteFs) isBaseFile(name string) (bool, error) {
31 if _, err := u.layer.Stat(name); err == nil {
32 return false, nil
33 }
34 _, err := u.base.Stat(name)
35 if err != nil {
36 if oerr, ok := err.(*os.PathError); ok {
37 if oerr.Err == os.ErrNotExist || oerr.Err == syscall.ENOENT || oerr.Err == syscall.ENOTDIR {
38 return false, nil
39 }
40 }
41 if err == syscall.ENOENT {
42 return false, nil
43 }
44 }
45 return true, err
46 }
47
48 func (u *CopyOnWriteFs) copyToLayer(name string) error {
49 return copyToLayer(u.base, u.layer, name)
50 }
51
52 func (u *CopyOnWriteFs) Chtimes(name string, atime, mtime time.Time) error {
53 b, err := u.isBaseFile(name)
54 if err != nil {
55 return err
56 }
57 if b {
58 if err := u.copyToLayer(name); err != nil {
59 return err
60 }
61 }
62 return u.layer.Chtimes(name, atime, mtime)
63 }
64
65 func (u *CopyOnWriteFs) Chmod(name string, mode os.FileMode) error {
66 b, err := u.isBaseFile(name)
67 if err != nil {
68 return err
69 }
70 if b {
71 if err := u.copyToLayer(name); err != nil {
72 return err
73 }
74 }
75 return u.layer.Chmod(name, mode)
76 }
77
78 func (u *CopyOnWriteFs) Chown(name string, uid, gid int) error {
79 b, err := u.isBaseFile(name)
80 if err != nil {
81 return err
82 }
83 if b {
84 if err := u.copyToLayer(name); err != nil {
85 return err
86 }
87 }
88 return u.layer.Chown(name, uid, gid)
89 }
90
91 func (u *CopyOnWriteFs) Stat(name string) (os.FileInfo, error) {
92 fi, err := u.layer.Stat(name)
93 if err != nil {
94 isNotExist := u.isNotExist(err)
95 if isNotExist {
96 return u.base.Stat(name)
97 }
98 return nil, err
99 }
100 return fi, nil
101 }
102
103 func (u *CopyOnWriteFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
104 llayer, ok1 := u.layer.(Lstater)
105 lbase, ok2 := u.base.(Lstater)
106
107 if ok1 {
108 fi, b, err := llayer.LstatIfPossible(name)
109 if err == nil {
110 return fi, b, nil
111 }
112
113 if !u.isNotExist(err) {
114 return nil, b, err
115 }
116 }
117
118 if ok2 {
119 fi, b, err := lbase.LstatIfPossible(name)
120 if err == nil {
121 return fi, b, nil
122 }
123 if !u.isNotExist(err) {
124 return nil, b, err
125 }
126 }
127
128 fi, err := u.Stat(name)
129
130 return fi, false, err
131 }
132
133 func (u *CopyOnWriteFs) SymlinkIfPossible(oldname, newname string) error {
134 if slayer, ok := u.layer.(Linker); ok {
135 return slayer.SymlinkIfPossible(oldname, newname)
136 }
137
138 return &os.LinkError{Op: "symlink", Old: oldname, New: newname, Err: ErrNoSymlink}
139 }
140
141 func (u *CopyOnWriteFs) ReadlinkIfPossible(name string) (string, error) {
142 if rlayer, ok := u.layer.(LinkReader); ok {
143 return rlayer.ReadlinkIfPossible(name)
144 }
145
146 if rbase, ok := u.base.(LinkReader); ok {
147 return rbase.ReadlinkIfPossible(name)
148 }
149
150 return "", &os.PathError{Op: "readlink", Path: name, Err: ErrNoReadlink}
151 }
152
153 func (u *CopyOnWriteFs) isNotExist(err error) bool {
154 if e, ok := err.(*os.PathError); ok {
155 err = e.Err
156 }
157 if err == os.ErrNotExist || err == syscall.ENOENT || err == syscall.ENOTDIR {
158 return true
159 }
160 return false
161 }
162
163 // Renaming files present only in the base layer is not permitted
164 func (u *CopyOnWriteFs) Rename(oldname, newname string) error {
165 b, err := u.isBaseFile(oldname)
166 if err != nil {
167 return err
168 }
169 if b {
170 return syscall.EPERM
171 }
172 return u.layer.Rename(oldname, newname)
173 }
174
175 // Removing files present only in the base layer is not permitted. If
176 // a file is present in the base layer and the overlay, only the overlay
177 // will be removed.
178 func (u *CopyOnWriteFs) Remove(name string) error {
179 err := u.layer.Remove(name)
180 switch err {
181 case syscall.ENOENT:
182 _, err = u.base.Stat(name)
183 if err == nil {
184 return syscall.EPERM
185 }
186 return syscall.ENOENT
187 default:
188 return err
189 }
190 }
191
192 func (u *CopyOnWriteFs) RemoveAll(name string) error {
193 err := u.layer.RemoveAll(name)
194 switch err {
195 case syscall.ENOENT:
196 _, err = u.base.Stat(name)
197 if err == nil {
198 return syscall.EPERM
199 }
200 return syscall.ENOENT
201 default:
202 return err
203 }
204 }
205
206 func (u *CopyOnWriteFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
207 b, err := u.isBaseFile(name)
208 if err != nil {
209 return nil, err
210 }
211
212 if flag&(os.O_WRONLY|os.O_RDWR|os.O_APPEND|os.O_CREATE|os.O_TRUNC) != 0 {
213 if b {
214 if err = u.copyToLayer(name); err != nil {
215 return nil, err
216 }
217 return u.layer.OpenFile(name, flag, perm)
218 }
219
220 dir := filepath.Dir(name)
221 isaDir, err := IsDir(u.base, dir)
222 if err != nil && !os.IsNotExist(err) {
223 return nil, err
224 }
225 if isaDir {
226 if err = u.layer.MkdirAll(dir, 0o777); err != nil {
227 return nil, err
228 }
229 return u.layer.OpenFile(name, flag, perm)
230 }
231
232 isaDir, err = IsDir(u.layer, dir)
233 if err != nil {
234 return nil, err
235 }
236 if isaDir {
237 return u.layer.OpenFile(name, flag, perm)
238 }
239
240 return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOTDIR} // ...or os.ErrNotExist?
241 }
242 if b {
243 return u.base.OpenFile(name, flag, perm)
244 }
245 return u.layer.OpenFile(name, flag, perm)
246 }
247
248 // This function handles the 9 different possibilities caused
249 // by the union which are the intersection of the following...
250 //
251 // layer: doesn't exist, exists as a file, and exists as a directory
252 // base: doesn't exist, exists as a file, and exists as a directory
253 func (u *CopyOnWriteFs) Open(name string) (File, error) {
254 // Since the overlay overrides the base we check that first
255 b, err := u.isBaseFile(name)
256 if err != nil {
257 return nil, err
258 }
259
260 // If overlay doesn't exist, return the base (base state irrelevant)
261 if b {
262 return u.base.Open(name)
263 }
264
265 // If overlay is a file, return it (base state irrelevant)
266 dir, err := IsDir(u.layer, name)
267 if err != nil {
268 return nil, err
269 }
270 if !dir {
271 return u.layer.Open(name)
272 }
273
274 // Overlay is a directory, base state now matters.
275 // Base state has 3 states to check but 2 outcomes:
276 // A. It's a file or non-readable in the base (return just the overlay)
277 // B. It's an accessible directory in the base (return a UnionFile)
278
279 // If base is file or nonreadable, return overlay
280 dir, err = IsDir(u.base, name)
281 if !dir || err != nil {
282 return u.layer.Open(name)
283 }
284
285 // Both base & layer are directories
286 // Return union file (if opens are without error)
287 bfile, bErr := u.base.Open(name)
288 lfile, lErr := u.layer.Open(name)
289
290 // If either have errors at this point something is very wrong. Return nil and the errors
291 if bErr != nil || lErr != nil {
292 return nil, fmt.Errorf("BaseErr: %v\nOverlayErr: %v", bErr, lErr)
293 }
294
295 return &UnionFile{Base: bfile, Layer: lfile}, nil
296 }
297
298 func (u *CopyOnWriteFs) Mkdir(name string, perm os.FileMode) error {
299 dir, err := IsDir(u.base, name)
300 if err != nil {
301 return u.layer.MkdirAll(name, perm)
302 }
303 if dir {
304 return ErrFileExists
305 }
306 return u.layer.MkdirAll(name, perm)
307 }
308
309 func (u *CopyOnWriteFs) Name() string {
310 return "CopyOnWriteFs"
311 }
312
313 func (u *CopyOnWriteFs) MkdirAll(name string, perm os.FileMode) error {
314 dir, err := IsDir(u.base, name)
315 if err != nil {
316 return u.layer.MkdirAll(name, perm)
317 }
318 if dir {
319 // This is in line with how os.MkdirAll behaves.
320 return nil
321 }
322 return u.layer.MkdirAll(name, perm)
323 }
324
325 func (u *CopyOnWriteFs) Create(name string) (File, error) {
326 return u.OpenFile(name, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0o666)
327 }
328