mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-08-26 22:47:51 +02:00
* Use vendored go-swagger * vendor go-swagger * revert un wanteed change * remove un-needed GO111MODULE * Update Makefile Co-Authored-By: techknowlogick <matti@mdranta.net>
290 lines
6.7 KiB
Go
Vendored
290 lines
6.7 KiB
Go
Vendored
package afero
|
|
|
|
import (
|
|
"os"
|
|
"syscall"
|
|
"time"
|
|
)
|
|
|
|
// If the cache duration is 0, cache time will be unlimited, i.e. once
|
|
// a file is in the layer, the base will never be read again for this file.
|
|
//
|
|
// For cache times greater than 0, the modification time of a file is
|
|
// checked. Note that a lot of file system implementations only allow a
|
|
// resolution of a second for timestamps... or as the godoc for os.Chtimes()
|
|
// states: "The underlying filesystem may truncate or round the values to a
|
|
// less precise time unit."
|
|
//
|
|
// This caching union will forward all write calls also to the base file
|
|
// system first. To prevent writing to the base Fs, wrap it in a read-only
|
|
// filter - Note: this will also make the overlay read-only, for writing files
|
|
// in the overlay, use the overlay Fs directly, not via the union Fs.
|
|
type CacheOnReadFs struct {
|
|
base Fs
|
|
layer Fs
|
|
cacheTime time.Duration
|
|
}
|
|
|
|
func NewCacheOnReadFs(base Fs, layer Fs, cacheTime time.Duration) Fs {
|
|
return &CacheOnReadFs{base: base, layer: layer, cacheTime: cacheTime}
|
|
}
|
|
|
|
type cacheState int
|
|
|
|
const (
|
|
// not present in the overlay, unknown if it exists in the base:
|
|
cacheMiss cacheState = iota
|
|
// present in the overlay and in base, base file is newer:
|
|
cacheStale
|
|
// present in the overlay - with cache time == 0 it may exist in the base,
|
|
// with cacheTime > 0 it exists in the base and is same age or newer in the
|
|
// overlay
|
|
cacheHit
|
|
// happens if someone writes directly to the overlay without
|
|
// going through this union
|
|
cacheLocal
|
|
)
|
|
|
|
func (u *CacheOnReadFs) cacheStatus(name string) (state cacheState, fi os.FileInfo, err error) {
|
|
var lfi, bfi os.FileInfo
|
|
lfi, err = u.layer.Stat(name)
|
|
if err == nil {
|
|
if u.cacheTime == 0 {
|
|
return cacheHit, lfi, nil
|
|
}
|
|
if lfi.ModTime().Add(u.cacheTime).Before(time.Now()) {
|
|
bfi, err = u.base.Stat(name)
|
|
if err != nil {
|
|
return cacheLocal, lfi, nil
|
|
}
|
|
if bfi.ModTime().After(lfi.ModTime()) {
|
|
return cacheStale, bfi, nil
|
|
}
|
|
}
|
|
return cacheHit, lfi, nil
|
|
}
|
|
|
|
if err == syscall.ENOENT || os.IsNotExist(err) {
|
|
return cacheMiss, nil, nil
|
|
}
|
|
|
|
return cacheMiss, nil, err
|
|
}
|
|
|
|
func (u *CacheOnReadFs) copyToLayer(name string) error {
|
|
return copyToLayer(u.base, u.layer, name)
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Chtimes(name string, atime, mtime time.Time) error {
|
|
st, _, err := u.cacheStatus(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch st {
|
|
case cacheLocal:
|
|
case cacheHit:
|
|
err = u.base.Chtimes(name, atime, mtime)
|
|
case cacheStale, cacheMiss:
|
|
if err := u.copyToLayer(name); err != nil {
|
|
return err
|
|
}
|
|
err = u.base.Chtimes(name, atime, mtime)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return u.layer.Chtimes(name, atime, mtime)
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Chmod(name string, mode os.FileMode) error {
|
|
st, _, err := u.cacheStatus(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch st {
|
|
case cacheLocal:
|
|
case cacheHit:
|
|
err = u.base.Chmod(name, mode)
|
|
case cacheStale, cacheMiss:
|
|
if err := u.copyToLayer(name); err != nil {
|
|
return err
|
|
}
|
|
err = u.base.Chmod(name, mode)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return u.layer.Chmod(name, mode)
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Stat(name string) (os.FileInfo, error) {
|
|
st, fi, err := u.cacheStatus(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch st {
|
|
case cacheMiss:
|
|
return u.base.Stat(name)
|
|
default: // cacheStale has base, cacheHit and cacheLocal the layer os.FileInfo
|
|
return fi, nil
|
|
}
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Rename(oldname, newname string) error {
|
|
st, _, err := u.cacheStatus(oldname)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch st {
|
|
case cacheLocal:
|
|
case cacheHit:
|
|
err = u.base.Rename(oldname, newname)
|
|
case cacheStale, cacheMiss:
|
|
if err := u.copyToLayer(oldname); err != nil {
|
|
return err
|
|
}
|
|
err = u.base.Rename(oldname, newname)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return u.layer.Rename(oldname, newname)
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Remove(name string) error {
|
|
st, _, err := u.cacheStatus(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch st {
|
|
case cacheLocal:
|
|
case cacheHit, cacheStale, cacheMiss:
|
|
err = u.base.Remove(name)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return u.layer.Remove(name)
|
|
}
|
|
|
|
func (u *CacheOnReadFs) RemoveAll(name string) error {
|
|
st, _, err := u.cacheStatus(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch st {
|
|
case cacheLocal:
|
|
case cacheHit, cacheStale, cacheMiss:
|
|
err = u.base.RemoveAll(name)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return u.layer.RemoveAll(name)
|
|
}
|
|
|
|
func (u *CacheOnReadFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
|
|
st, _, err := u.cacheStatus(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch st {
|
|
case cacheLocal, cacheHit:
|
|
default:
|
|
if err := u.copyToLayer(name); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if flag&(os.O_WRONLY|syscall.O_RDWR|os.O_APPEND|os.O_CREATE|os.O_TRUNC) != 0 {
|
|
bfi, err := u.base.OpenFile(name, flag, perm)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lfi, err := u.layer.OpenFile(name, flag, perm)
|
|
if err != nil {
|
|
bfi.Close() // oops, what if O_TRUNC was set and file opening in the layer failed...?
|
|
return nil, err
|
|
}
|
|
return &UnionFile{Base: bfi, Layer: lfi}, nil
|
|
}
|
|
return u.layer.OpenFile(name, flag, perm)
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Open(name string) (File, error) {
|
|
st, fi, err := u.cacheStatus(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch st {
|
|
case cacheLocal:
|
|
return u.layer.Open(name)
|
|
|
|
case cacheMiss:
|
|
bfi, err := u.base.Stat(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if bfi.IsDir() {
|
|
return u.base.Open(name)
|
|
}
|
|
if err := u.copyToLayer(name); err != nil {
|
|
return nil, err
|
|
}
|
|
return u.layer.Open(name)
|
|
|
|
case cacheStale:
|
|
if !fi.IsDir() {
|
|
if err := u.copyToLayer(name); err != nil {
|
|
return nil, err
|
|
}
|
|
return u.layer.Open(name)
|
|
}
|
|
case cacheHit:
|
|
if !fi.IsDir() {
|
|
return u.layer.Open(name)
|
|
}
|
|
}
|
|
// the dirs from cacheHit, cacheStale fall down here:
|
|
bfile, _ := u.base.Open(name)
|
|
lfile, err := u.layer.Open(name)
|
|
if err != nil && bfile == nil {
|
|
return nil, err
|
|
}
|
|
return &UnionFile{Base: bfile, Layer: lfile}, nil
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Mkdir(name string, perm os.FileMode) error {
|
|
err := u.base.Mkdir(name, perm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return u.layer.MkdirAll(name, perm) // yes, MkdirAll... we cannot assume it exists in the cache
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Name() string {
|
|
return "CacheOnReadFs"
|
|
}
|
|
|
|
func (u *CacheOnReadFs) MkdirAll(name string, perm os.FileMode) error {
|
|
err := u.base.MkdirAll(name, perm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return u.layer.MkdirAll(name, perm)
|
|
}
|
|
|
|
func (u *CacheOnReadFs) Create(name string) (File, error) {
|
|
bfh, err := u.base.Create(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lfh, err := u.layer.Create(name)
|
|
if err != nil {
|
|
// oops, see comment about OS_TRUNC above, should we remove? then we have to
|
|
// remember if the file did not exist before
|
|
bfh.Close()
|
|
return nil, err
|
|
}
|
|
return &UnionFile{Base: bfh, Layer: lfh}, nil
|
|
}
|