github.com/hanwen/go-fuse@v1.0.0/fuse/lockingfs.go (about)

     1  // Copyright 2016 the Go-FUSE Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package fuse
     6  
     7  import (
     8  	"fmt"
     9  	"sync"
    10  )
    11  
    12  ////////////////////////////////////////////////////////////////
    13  // Locking raw FS.
    14  
    15  type lockingRawFileSystem struct {
    16  	RawFS RawFileSystem
    17  	lock  sync.Mutex
    18  }
    19  
    20  // Returns a Wrap
    21  func NewLockingRawFileSystem(fs RawFileSystem) RawFileSystem {
    22  	return &lockingRawFileSystem{
    23  		RawFS: fs,
    24  	}
    25  }
    26  
    27  func (fs *lockingRawFileSystem) FS() RawFileSystem {
    28  	return fs.RawFS
    29  }
    30  
    31  func (fs *lockingRawFileSystem) locked() func() {
    32  	fs.lock.Lock()
    33  	return func() { fs.lock.Unlock() }
    34  }
    35  
    36  func (fs *lockingRawFileSystem) Lookup(header *InHeader, name string, out *EntryOut) (code Status) {
    37  	defer fs.locked()()
    38  	return fs.RawFS.Lookup(header, name, out)
    39  }
    40  
    41  func (fs *lockingRawFileSystem) SetDebug(dbg bool) {
    42  	defer fs.locked()()
    43  	fs.RawFS.SetDebug(dbg)
    44  }
    45  
    46  func (fs *lockingRawFileSystem) Forget(nodeID uint64, nlookup uint64) {
    47  	defer fs.locked()()
    48  	fs.RawFS.Forget(nodeID, nlookup)
    49  }
    50  
    51  func (fs *lockingRawFileSystem) GetAttr(input *GetAttrIn, out *AttrOut) (code Status) {
    52  	defer fs.locked()()
    53  	return fs.RawFS.GetAttr(input, out)
    54  }
    55  
    56  func (fs *lockingRawFileSystem) Open(input *OpenIn, out *OpenOut) (status Status) {
    57  
    58  	defer fs.locked()()
    59  	return fs.RawFS.Open(input, out)
    60  }
    61  
    62  func (fs *lockingRawFileSystem) SetAttr(input *SetAttrIn, out *AttrOut) (code Status) {
    63  	defer fs.locked()()
    64  	return fs.RawFS.SetAttr(input, out)
    65  }
    66  
    67  func (fs *lockingRawFileSystem) Readlink(header *InHeader) (out []byte, code Status) {
    68  	defer fs.locked()()
    69  	return fs.RawFS.Readlink(header)
    70  }
    71  
    72  func (fs *lockingRawFileSystem) Mknod(input *MknodIn, name string, out *EntryOut) (code Status) {
    73  	defer fs.locked()()
    74  	return fs.RawFS.Mknod(input, name, out)
    75  }
    76  
    77  func (fs *lockingRawFileSystem) Mkdir(input *MkdirIn, name string, out *EntryOut) (code Status) {
    78  	defer fs.locked()()
    79  	return fs.RawFS.Mkdir(input, name, out)
    80  }
    81  
    82  func (fs *lockingRawFileSystem) Unlink(header *InHeader, name string) (code Status) {
    83  	defer fs.locked()()
    84  	return fs.RawFS.Unlink(header, name)
    85  }
    86  
    87  func (fs *lockingRawFileSystem) Rmdir(header *InHeader, name string) (code Status) {
    88  	defer fs.locked()()
    89  	return fs.RawFS.Rmdir(header, name)
    90  }
    91  
    92  func (fs *lockingRawFileSystem) Symlink(header *InHeader, pointedTo string, linkName string, out *EntryOut) (code Status) {
    93  	defer fs.locked()()
    94  	return fs.RawFS.Symlink(header, pointedTo, linkName, out)
    95  }
    96  
    97  func (fs *lockingRawFileSystem) Rename(input *RenameIn, oldName string, newName string) (code Status) {
    98  	defer fs.locked()()
    99  	return fs.RawFS.Rename(input, oldName, newName)
   100  }
   101  
   102  func (fs *lockingRawFileSystem) Link(input *LinkIn, name string, out *EntryOut) (code Status) {
   103  	defer fs.locked()()
   104  	return fs.RawFS.Link(input, name, out)
   105  }
   106  
   107  func (fs *lockingRawFileSystem) SetXAttr(input *SetXAttrIn, attr string, data []byte) Status {
   108  	defer fs.locked()()
   109  	return fs.RawFS.SetXAttr(input, attr, data)
   110  }
   111  
   112  func (fs *lockingRawFileSystem) GetXAttrData(header *InHeader, attr string) (data []byte, code Status) {
   113  	defer fs.locked()()
   114  	return fs.RawFS.GetXAttrData(header, attr)
   115  }
   116  
   117  func (fs *lockingRawFileSystem) GetXAttrSize(header *InHeader, attr string) (sz int, code Status) {
   118  	defer fs.locked()()
   119  	return fs.RawFS.GetXAttrSize(header, attr)
   120  }
   121  
   122  func (fs *lockingRawFileSystem) ListXAttr(header *InHeader) (data []byte, code Status) {
   123  	defer fs.locked()()
   124  	return fs.RawFS.ListXAttr(header)
   125  }
   126  
   127  func (fs *lockingRawFileSystem) RemoveXAttr(header *InHeader, attr string) Status {
   128  	defer fs.locked()()
   129  	return fs.RawFS.RemoveXAttr(header, attr)
   130  }
   131  
   132  func (fs *lockingRawFileSystem) Access(input *AccessIn) (code Status) {
   133  	defer fs.locked()()
   134  	return fs.RawFS.Access(input)
   135  }
   136  
   137  func (fs *lockingRawFileSystem) Create(input *CreateIn, name string, out *CreateOut) (code Status) {
   138  	defer fs.locked()()
   139  	return fs.RawFS.Create(input, name, out)
   140  }
   141  
   142  func (fs *lockingRawFileSystem) OpenDir(input *OpenIn, out *OpenOut) (status Status) {
   143  	defer fs.locked()()
   144  	return fs.RawFS.OpenDir(input, out)
   145  }
   146  
   147  func (fs *lockingRawFileSystem) Release(input *ReleaseIn) {
   148  	defer fs.locked()()
   149  	fs.RawFS.Release(input)
   150  }
   151  
   152  func (fs *lockingRawFileSystem) ReleaseDir(input *ReleaseIn) {
   153  	defer fs.locked()()
   154  	fs.RawFS.ReleaseDir(input)
   155  }
   156  
   157  func (fs *lockingRawFileSystem) Read(input *ReadIn, buf []byte) (ReadResult, Status) {
   158  	defer fs.locked()()
   159  	return fs.RawFS.Read(input, buf)
   160  }
   161  
   162  func (fs *lockingRawFileSystem) GetLk(in *LkIn, out *LkOut) (code Status) {
   163  	defer fs.locked()()
   164  	return fs.RawFS.GetLk(in, out)
   165  }
   166  
   167  func (fs *lockingRawFileSystem) SetLk(in *LkIn) (code Status) {
   168  	defer fs.locked()()
   169  	return fs.RawFS.SetLk(in)
   170  }
   171  
   172  func (fs *lockingRawFileSystem) SetLkw(in *LkIn) (code Status) {
   173  	defer fs.locked()()
   174  	return fs.RawFS.SetLkw(in)
   175  }
   176  
   177  func (fs *lockingRawFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status) {
   178  	defer fs.locked()()
   179  	return fs.RawFS.Write(input, data)
   180  }
   181  
   182  func (fs *lockingRawFileSystem) Flush(input *FlushIn) Status {
   183  	defer fs.locked()()
   184  	return fs.RawFS.Flush(input)
   185  }
   186  
   187  func (fs *lockingRawFileSystem) Fsync(input *FsyncIn) (code Status) {
   188  	defer fs.locked()()
   189  	return fs.RawFS.Fsync(input)
   190  }
   191  
   192  func (fs *lockingRawFileSystem) ReadDir(input *ReadIn, out *DirEntryList) Status {
   193  	defer fs.locked()()
   194  	return fs.RawFS.ReadDir(input, out)
   195  }
   196  
   197  func (fs *lockingRawFileSystem) ReadDirPlus(input *ReadIn, out *DirEntryList) Status {
   198  	defer fs.locked()()
   199  	return fs.RawFS.ReadDirPlus(input, out)
   200  }
   201  
   202  func (fs *lockingRawFileSystem) FsyncDir(input *FsyncIn) (code Status) {
   203  	defer fs.locked()()
   204  	return fs.RawFS.FsyncDir(input)
   205  }
   206  
   207  func (fs *lockingRawFileSystem) Init(s *Server) {
   208  	defer fs.locked()()
   209  	fs.RawFS.Init(s)
   210  }
   211  
   212  func (fs *lockingRawFileSystem) StatFs(header *InHeader, out *StatfsOut) (code Status) {
   213  	defer fs.locked()()
   214  	return fs.RawFS.StatFs(header, out)
   215  }
   216  
   217  func (fs *lockingRawFileSystem) Fallocate(in *FallocateIn) (code Status) {
   218  	defer fs.locked()()
   219  	return fs.RawFS.Fallocate(in)
   220  }
   221  
   222  func (fs *lockingRawFileSystem) String() string {
   223  	defer fs.locked()()
   224  	return fmt.Sprintf("Locked(%s)", fs.RawFS.String())
   225  }