cacheOnReadFs.go raw
1 package afero
2
3 import (
4 "os"
5 "syscall"
6 "time"
7 )
8
9 // If the cache duration is 0, cache time will be unlimited, i.e. once
10 // a file is in the layer, the base will never be read again for this file.
11 //
12 // For cache times greater than 0, the modification time of a file is
13 // checked. Note that a lot of file system implementations only allow a
14 // resolution of a second for timestamps... or as the godoc for os.Chtimes()
15 // states: "The underlying filesystem may truncate or round the values to a
16 // less precise time unit."
17 //
18 // This caching union will forward all write calls also to the base file
19 // system first. To prevent writing to the base Fs, wrap it in a read-only
20 // filter - Note: this will also make the overlay read-only, for writing files
21 // in the overlay, use the overlay Fs directly, not via the union Fs.
22 type CacheOnReadFs struct {
23 base Fs
24 layer Fs
25 cacheTime time.Duration
26 }
27
28 func NewCacheOnReadFs(base Fs, layer Fs, cacheTime time.Duration) Fs {
29 return &CacheOnReadFs{base: base, layer: layer, cacheTime: cacheTime}
30 }
31
32 type cacheState int
33
34 const (
35 // not present in the overlay, unknown if it exists in the base:
36 cacheMiss cacheState = iota
37 // present in the overlay and in base, base file is newer:
38 cacheStale
39 // present in the overlay - with cache time == 0 it may exist in the base,
40 // with cacheTime > 0 it exists in the base and is same age or newer in the
41 // overlay
42 cacheHit
43 // happens if someone writes directly to the overlay without
44 // going through this union
45 cacheLocal
46 )
47
48 func (u *CacheOnReadFs) cacheStatus(name string) (state cacheState, fi os.FileInfo, err error) {
49 var lfi, bfi os.FileInfo
50 lfi, err = u.layer.Stat(name)
51 if err == nil {
52 if u.cacheTime == 0 {
53 return cacheHit, lfi, nil
54 }
55 if lfi.ModTime().Add(u.cacheTime).Before(time.Now()) {
56 bfi, err = u.base.Stat(name)
57 if err != nil {
58 return cacheLocal, lfi, nil
59 }
60 if bfi.ModTime().After(lfi.ModTime()) {
61 return cacheStale, bfi, nil
62 }
63 }
64 return cacheHit, lfi, nil
65 }
66
67 if err == syscall.ENOENT || os.IsNotExist(err) {
68 return cacheMiss, nil, nil
69 }
70
71 return cacheMiss, nil, err
72 }
73
74 func (u *CacheOnReadFs) copyToLayer(name string) error {
75 return copyToLayer(u.base, u.layer, name)
76 }
77
78 func (u *CacheOnReadFs) copyFileToLayer(name string, flag int, perm os.FileMode) error {
79 return copyFileToLayer(u.base, u.layer, name, flag, perm)
80 }
81
82 func (u *CacheOnReadFs) Chtimes(name string, atime, mtime time.Time) error {
83 st, _, err := u.cacheStatus(name)
84 if err != nil {
85 return err
86 }
87 switch st {
88 case cacheLocal:
89 case cacheHit:
90 err = u.base.Chtimes(name, atime, mtime)
91 case cacheStale, cacheMiss:
92 if err := u.copyToLayer(name); err != nil {
93 return err
94 }
95 err = u.base.Chtimes(name, atime, mtime)
96 }
97 if err != nil {
98 return err
99 }
100 return u.layer.Chtimes(name, atime, mtime)
101 }
102
103 func (u *CacheOnReadFs) Chmod(name string, mode os.FileMode) error {
104 st, _, err := u.cacheStatus(name)
105 if err != nil {
106 return err
107 }
108 switch st {
109 case cacheLocal:
110 case cacheHit:
111 err = u.base.Chmod(name, mode)
112 case cacheStale, cacheMiss:
113 if err := u.copyToLayer(name); err != nil {
114 return err
115 }
116 err = u.base.Chmod(name, mode)
117 }
118 if err != nil {
119 return err
120 }
121 return u.layer.Chmod(name, mode)
122 }
123
124 func (u *CacheOnReadFs) Chown(name string, uid, gid int) error {
125 st, _, err := u.cacheStatus(name)
126 if err != nil {
127 return err
128 }
129 switch st {
130 case cacheLocal:
131 case cacheHit:
132 err = u.base.Chown(name, uid, gid)
133 case cacheStale, cacheMiss:
134 if err := u.copyToLayer(name); err != nil {
135 return err
136 }
137 err = u.base.Chown(name, uid, gid)
138 }
139 if err != nil {
140 return err
141 }
142 return u.layer.Chown(name, uid, gid)
143 }
144
145 func (u *CacheOnReadFs) Stat(name string) (os.FileInfo, error) {
146 st, fi, err := u.cacheStatus(name)
147 if err != nil {
148 return nil, err
149 }
150 switch st {
151 case cacheMiss:
152 return u.base.Stat(name)
153 default: // cacheStale has base, cacheHit and cacheLocal the layer os.FileInfo
154 return fi, nil
155 }
156 }
157
158 func (u *CacheOnReadFs) Rename(oldname, newname string) error {
159 st, _, err := u.cacheStatus(oldname)
160 if err != nil {
161 return err
162 }
163 switch st {
164 case cacheLocal:
165 case cacheHit:
166 err = u.base.Rename(oldname, newname)
167 case cacheStale, cacheMiss:
168 if err := u.copyToLayer(oldname); err != nil {
169 return err
170 }
171 err = u.base.Rename(oldname, newname)
172 }
173 if err != nil {
174 return err
175 }
176 return u.layer.Rename(oldname, newname)
177 }
178
179 func (u *CacheOnReadFs) Remove(name string) error {
180 st, _, err := u.cacheStatus(name)
181 if err != nil {
182 return err
183 }
184 switch st {
185 case cacheLocal:
186 case cacheHit, cacheStale, cacheMiss:
187 err = u.base.Remove(name)
188 }
189 if err != nil {
190 return err
191 }
192 return u.layer.Remove(name)
193 }
194
195 func (u *CacheOnReadFs) RemoveAll(name string) error {
196 st, _, err := u.cacheStatus(name)
197 if err != nil {
198 return err
199 }
200 switch st {
201 case cacheLocal:
202 case cacheHit, cacheStale, cacheMiss:
203 err = u.base.RemoveAll(name)
204 }
205 if err != nil {
206 return err
207 }
208 return u.layer.RemoveAll(name)
209 }
210
211 func (u *CacheOnReadFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
212 st, _, err := u.cacheStatus(name)
213 if err != nil {
214 return nil, err
215 }
216 switch st {
217 case cacheLocal, cacheHit:
218 default:
219 if err := u.copyFileToLayer(name, flag, perm); err != nil {
220 return nil, err
221 }
222 }
223 if flag&(os.O_WRONLY|syscall.O_RDWR|os.O_APPEND|os.O_CREATE|os.O_TRUNC) != 0 {
224 bfi, err := u.base.OpenFile(name, flag, perm)
225 if err != nil {
226 return nil, err
227 }
228 lfi, err := u.layer.OpenFile(name, flag, perm)
229 if err != nil {
230 bfi.Close() // oops, what if O_TRUNC was set and file opening in the layer failed...?
231 return nil, err
232 }
233 return &UnionFile{Base: bfi, Layer: lfi}, nil
234 }
235 return u.layer.OpenFile(name, flag, perm)
236 }
237
238 func (u *CacheOnReadFs) Open(name string) (File, error) {
239 st, fi, err := u.cacheStatus(name)
240 if err != nil {
241 return nil, err
242 }
243
244 switch st {
245 case cacheLocal:
246 return u.layer.Open(name)
247
248 case cacheMiss:
249 bfi, err := u.base.Stat(name)
250 if err != nil {
251 return nil, err
252 }
253 if bfi.IsDir() {
254 return u.base.Open(name)
255 }
256 if err := u.copyToLayer(name); err != nil {
257 return nil, err
258 }
259 return u.layer.Open(name)
260
261 case cacheStale:
262 if !fi.IsDir() {
263 if err := u.copyToLayer(name); err != nil {
264 return nil, err
265 }
266 return u.layer.Open(name)
267 }
268 case cacheHit:
269 if !fi.IsDir() {
270 return u.layer.Open(name)
271 }
272 }
273 // the dirs from cacheHit, cacheStale fall down here:
274 bfile, _ := u.base.Open(name)
275 lfile, err := u.layer.Open(name)
276 if err != nil && bfile == nil {
277 return nil, err
278 }
279 return &UnionFile{Base: bfile, Layer: lfile}, nil
280 }
281
282 func (u *CacheOnReadFs) Mkdir(name string, perm os.FileMode) error {
283 err := u.base.Mkdir(name, perm)
284 if err != nil {
285 return err
286 }
287 return u.layer.MkdirAll(name, perm) // yes, MkdirAll... we cannot assume it exists in the cache
288 }
289
290 func (u *CacheOnReadFs) Name() string {
291 return "CacheOnReadFs"
292 }
293
294 func (u *CacheOnReadFs) MkdirAll(name string, perm os.FileMode) error {
295 err := u.base.MkdirAll(name, perm)
296 if err != nil {
297 return err
298 }
299 return u.layer.MkdirAll(name, perm)
300 }
301
302 func (u *CacheOnReadFs) Create(name string) (File, error) {
303 bfh, err := u.base.Create(name)
304 if err != nil {
305 return nil, err
306 }
307 lfh, err := u.layer.Create(name)
308 if err != nil {
309 // oops, see comment about OS_TRUNC above, should we remove? then we have to
310 // remember if the file did not exist before
311 bfh.Close()
312 return nil, err
313 }
314 return &UnionFile{Base: bfh, Layer: lfh}, nil
315 }
316