unionFile.go

Documentation: github.com/spf13/afero

     1  package afero
     2  
     3  import (
     4  	"io"
     5  	"os"
     6  	"path/filepath"
     7  	"syscall"
     8  )
     9  
    10  // The UnionFile implements the afero.File interface and will be returned
    11  // when reading a directory present at least in the overlay or opening a file
    12  // for writing.
    13  //
    14  // The calls to
    15  // Readdir() and Readdirnames() merge the file os.FileInfo / names from the
    16  // base and the overlay - for files present in both layers, only those
    17  // from the overlay will be used.
    18  //
    19  // When opening files for writing (Create() / OpenFile() with the right flags)
    20  // the operations will be done in both layers, starting with the overlay. A
    21  // successful read in the overlay will move the cursor position in the base layer
    22  // by the number of bytes read.
    23  type UnionFile struct {
    24  	Base   File
    25  	Layer  File
    26  	Merger DirsMerger
    27  	off    int
    28  	files  []os.FileInfo
    29  }
    30  
    31  func (f *UnionFile) Close() error {
    32  	// first close base, so we have a newer timestamp in the overlay. If we'd close
    33  	// the overlay first, we'd get a cacheStale the next time we access this file
    34  	// -> cache would be useless ;-)
    35  	if f.Base != nil {
    36  		f.Base.Close()
    37  	}
    38  	if f.Layer != nil {
    39  		return f.Layer.Close()
    40  	}
    41  	return BADFD
    42  }
    43  
    44  func (f *UnionFile) Read(s []byte) (int, error) {
    45  	if f.Layer != nil {
    46  		n, err := f.Layer.Read(s)
    47  		if (err == nil || err == io.EOF) && f.Base != nil {
    48  			// advance the file position also in the base file, the next
    49  			// call may be a write at this position (or a seek with SEEK_CUR)
    50  			if _, seekErr := f.Base.Seek(int64(n), io.SeekCurrent); seekErr != nil {
    51  				// only overwrite err in case the seek fails: we need to
    52  				// report an eventual io.EOF to the caller
    53  				err = seekErr
    54  			}
    55  		}
    56  		return n, err
    57  	}
    58  	if f.Base != nil {
    59  		return f.Base.Read(s)
    60  	}
    61  	return 0, BADFD
    62  }
    63  
    64  func (f *UnionFile) ReadAt(s []byte, o int64) (int, error) {
    65  	if f.Layer != nil {
    66  		n, err := f.Layer.ReadAt(s, o)
    67  		if (err == nil || err == io.EOF) && f.Base != nil {
    68  			_, err = f.Base.Seek(o+int64(n), io.SeekStart)
    69  		}
    70  		return n, err
    71  	}
    72  	if f.Base != nil {
    73  		return f.Base.ReadAt(s, o)
    74  	}
    75  	return 0, BADFD
    76  }
    77  
    78  func (f *UnionFile) Seek(o int64, w int) (pos int64, err error) {
    79  	if f.Layer != nil {
    80  		pos, err = f.Layer.Seek(o, w)
    81  		if (err == nil || err == io.EOF) && f.Base != nil {
    82  			_, err = f.Base.Seek(o, w)
    83  		}
    84  		return pos, err
    85  	}
    86  	if f.Base != nil {
    87  		return f.Base.Seek(o, w)
    88  	}
    89  	return 0, BADFD
    90  }
    91  
    92  func (f *UnionFile) Write(s []byte) (n int, err error) {
    93  	if f.Layer != nil {
    94  		n, err = f.Layer.Write(s)
    95  		if err == nil && f.Base != nil { // hmm, do we have fixed size files where a write may hit the EOF mark?
    96  			_, err = f.Base.Write(s)
    97  		}
    98  		return n, err
    99  	}
   100  	if f.Base != nil {
   101  		return f.Base.Write(s)
   102  	}
   103  	return 0, BADFD
   104  }
   105  
   106  func (f *UnionFile) WriteAt(s []byte, o int64) (n int, err error) {
   107  	if f.Layer != nil {
   108  		n, err = f.Layer.WriteAt(s, o)
   109  		if err == nil && f.Base != nil {
   110  			_, err = f.Base.WriteAt(s, o)
   111  		}
   112  		return n, err
   113  	}
   114  	if f.Base != nil {
   115  		return f.Base.WriteAt(s, o)
   116  	}
   117  	return 0, BADFD
   118  }
   119  
   120  func (f *UnionFile) Name() string {
   121  	if f.Layer != nil {
   122  		return f.Layer.Name()
   123  	}
   124  	return f.Base.Name()
   125  }
   126  
   127  // DirsMerger is how UnionFile weaves two directories together.
   128  // It takes the FileInfo slices from the layer and the base and returns a
   129  // single view.
   130  type DirsMerger func(lofi, bofi []os.FileInfo) ([]os.FileInfo, error)
   131  
   132  var defaultUnionMergeDirsFn = func(lofi, bofi []os.FileInfo) ([]os.FileInfo, error) {
   133  	files := make(map[string]os.FileInfo)
   134  
   135  	for _, fi := range lofi {
   136  		files[fi.Name()] = fi
   137  	}
   138  
   139  	for _, fi := range bofi {
   140  		if _, exists := files[fi.Name()]; !exists {
   141  			files[fi.Name()] = fi
   142  		}
   143  	}
   144  
   145  	rfi := make([]os.FileInfo, len(files))
   146  
   147  	i := 0
   148  	for _, fi := range files {
   149  		rfi[i] = fi
   150  		i++
   151  	}
   152  
   153  	return rfi, nil
   154  }
   155  
   156  // Readdir will weave the two directories together and
   157  // return a single view of the overlayed directories.
   158  // At the end of the directory view, the error is io.EOF if c > 0.
   159  func (f *UnionFile) Readdir(c int) (ofi []os.FileInfo, err error) {
   160  	var merge DirsMerger = f.Merger
   161  	if merge == nil {
   162  		merge = defaultUnionMergeDirsFn
   163  	}
   164  
   165  	if f.off == 0 {
   166  		var lfi []os.FileInfo
   167  		if f.Layer != nil {
   168  			lfi, err = f.Layer.Readdir(-1)
   169  			if err != nil {
   170  				return nil, err
   171  			}
   172  		}
   173  
   174  		var bfi []os.FileInfo
   175  		if f.Base != nil {
   176  			bfi, err = f.Base.Readdir(-1)
   177  			if err != nil {
   178  				return nil, err
   179  			}
   180  
   181  		}
   182  		merged, err := merge(lfi, bfi)
   183  		if err != nil {
   184  			return nil, err
   185  		}
   186  		f.files = append(f.files, merged...)
   187  	}
   188  	files := f.files[f.off:]
   189  
   190  	if c <= 0 {
   191  		return files, nil
   192  	}
   193  
   194  	if len(files) == 0 {
   195  		return nil, io.EOF
   196  	}
   197  
   198  	if c > len(files) {
   199  		c = len(files)
   200  	}
   201  
   202  	defer func() { f.off += c }()
   203  	return files[:c], nil
   204  }
   205  
   206  func (f *UnionFile) Readdirnames(c int) ([]string, error) {
   207  	rfi, err := f.Readdir(c)
   208  	if err != nil {
   209  		return nil, err
   210  	}
   211  	var names []string
   212  	for _, fi := range rfi {
   213  		names = append(names, fi.Name())
   214  	}
   215  	return names, nil
   216  }
   217  
   218  func (f *UnionFile) Stat() (os.FileInfo, error) {
   219  	if f.Layer != nil {
   220  		return f.Layer.Stat()
   221  	}
   222  	if f.Base != nil {
   223  		return f.Base.Stat()
   224  	}
   225  	return nil, BADFD
   226  }
   227  
   228  func (f *UnionFile) Sync() (err error) {
   229  	if f.Layer != nil {
   230  		err = f.Layer.Sync()
   231  		if err == nil && f.Base != nil {
   232  			err = f.Base.Sync()
   233  		}
   234  		return err
   235  	}
   236  	if f.Base != nil {
   237  		return f.Base.Sync()
   238  	}
   239  	return BADFD
   240  }
   241  
   242  func (f *UnionFile) Truncate(s int64) (err error) {
   243  	if f.Layer != nil {
   244  		err = f.Layer.Truncate(s)
   245  		if err == nil && f.Base != nil {
   246  			err = f.Base.Truncate(s)
   247  		}
   248  		return err
   249  	}
   250  	if f.Base != nil {
   251  		return f.Base.Truncate(s)
   252  	}
   253  	return BADFD
   254  }
   255  
   256  func (f *UnionFile) WriteString(s string) (n int, err error) {
   257  	if f.Layer != nil {
   258  		n, err = f.Layer.WriteString(s)
   259  		if err == nil && f.Base != nil {
   260  			_, err = f.Base.WriteString(s)
   261  		}
   262  		return n, err
   263  	}
   264  	if f.Base != nil {
   265  		return f.Base.WriteString(s)
   266  	}
   267  	return 0, BADFD
   268  }
   269  
   270  func copyFile(base Fs, layer Fs, name string, bfh File) error {
   271  	// First make sure the directory exists
   272  	exists, err := Exists(layer, filepath.Dir(name))
   273  	if err != nil {
   274  		return err
   275  	}
   276  	if !exists {
   277  		err = layer.MkdirAll(filepath.Dir(name), 0o777) // FIXME?
   278  		if err != nil {
   279  			return err
   280  		}
   281  	}
   282  
   283  	// Create the file on the overlay
   284  	lfh, err := layer.Create(name)
   285  	if err != nil {
   286  		return err
   287  	}
   288  	n, err := io.Copy(lfh, bfh)
   289  	if err != nil {
   290  		// If anything fails, clean up the file
   291  		layer.Remove(name)
   292  		lfh.Close()
   293  		return err
   294  	}
   295  
   296  	bfi, err := bfh.Stat()
   297  	if err != nil || bfi.Size() != n {
   298  		layer.Remove(name)
   299  		lfh.Close()
   300  		return syscall.EIO
   301  	}
   302  
   303  	err = lfh.Close()
   304  	if err != nil {
   305  		layer.Remove(name)
   306  		lfh.Close()
   307  		return err
   308  	}
   309  	return layer.Chtimes(name, bfi.ModTime(), bfi.ModTime())
   310  }
   311  
   312  func copyToLayer(base Fs, layer Fs, name string) error {
   313  	bfh, err := base.Open(name)
   314  	if err != nil {
   315  		return err
   316  	}
   317  	defer bfh.Close()
   318  
   319  	return copyFile(base, layer, name, bfh)
   320  }
   321  
   322  func copyFileToLayer(base Fs, layer Fs, name string, flag int, perm os.FileMode) error {
   323  	bfh, err := base.OpenFile(name, flag, perm)
   324  	if err != nil {
   325  		return err
   326  	}
   327  	defer bfh.Close()
   328  
   329  	return copyFile(base, layer, name, bfh)
   330  }
   331
View as plain text