fusego/samples/flushfs/flush_fs.go

323 lines
6.6 KiB
Go
Raw Normal View History

// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package flushfs
2015-03-20 03:21:38 +03:00
import (
"context"
2015-03-20 03:49:45 +03:00
"fmt"
2015-03-20 03:34:16 +03:00
"os"
2015-03-20 03:38:40 +03:00
"sync"
2015-03-20 03:34:16 +03:00
2015-03-20 03:21:38 +03:00
"github.com/jacobsa/fuse"
2015-03-24 08:14:42 +03:00
"github.com/jacobsa/fuse/fuseops"
2015-03-25 01:33:04 +03:00
"github.com/jacobsa/fuse/fuseutil"
2015-03-20 03:21:38 +03:00
)
2015-03-24 04:02:48 +03:00
// Create a file system whose sole contents are a file named "foo" and a
// directory named "bar".
//
// The file may be opened for reading and/or writing. Its initial contents are
// empty. Whenever a flush or fsync is received, the supplied function will be
2015-03-20 03:52:54 +03:00
// called with the current contents of the file and its status returned.
2015-03-24 04:02:48 +03:00
//
// The directory cannot be modified.
func NewFileSystem(
2015-03-20 03:52:54 +03:00
reportFlush func(string) error,
reportFsync func(string) error) (fuse.Server, error) {
2015-03-25 01:33:04 +03:00
fs := &flushFS{
2015-03-20 05:27:27 +03:00
reportFlush: reportFlush,
reportFsync: reportFsync,
}
return fuseutil.NewFileSystemServer(fs), nil
2015-03-20 03:21:38 +03:00
}
2015-03-24 04:02:48 +03:00
const (
2015-03-24 08:14:42 +03:00
fooID = fuseops.RootInodeID + 1 + iota
2015-03-24 04:02:48 +03:00
barID
)
2015-03-20 03:38:40 +03:00
2015-03-20 03:21:38 +03:00
type flushFS struct {
2015-03-25 01:33:04 +03:00
fuseutil.NotImplementedFileSystem
2015-03-20 05:27:27 +03:00
reportFlush func(string) error
reportFsync func(string) error
2015-03-20 03:34:16 +03:00
2015-03-20 03:49:45 +03:00
mu sync.Mutex
fooContents []byte // GUARDED_BY(mu)
2015-03-20 03:21:38 +03:00
}
2015-03-20 03:22:16 +03:00
2015-03-20 03:38:40 +03:00
////////////////////////////////////////////////////////////////////////
// Helpers
////////////////////////////////////////////////////////////////////////
2015-03-20 03:40:14 +03:00
// LOCKS_REQUIRED(fs.mu)
2015-03-24 08:14:42 +03:00
func (fs *flushFS) rootAttributes() fuseops.InodeAttributes {
return fuseops.InodeAttributes{
2015-03-20 03:40:14 +03:00
Nlink: 1,
Mode: 0777 | os.ModeDir,
}
}
2015-03-20 03:38:40 +03:00
// LOCKS_REQUIRED(fs.mu)
2015-03-24 08:14:42 +03:00
func (fs *flushFS) fooAttributes() fuseops.InodeAttributes {
return fuseops.InodeAttributes{
2015-03-20 03:38:40 +03:00
Nlink: 1,
Mode: 0777,
2015-03-20 05:28:51 +03:00
Size: uint64(len(fs.fooContents)),
2015-03-20 03:38:40 +03:00
}
}
2015-03-24 04:02:48 +03:00
// LOCKS_REQUIRED(fs.mu)
2015-03-24 08:14:42 +03:00
func (fs *flushFS) barAttributes() fuseops.InodeAttributes {
return fuseops.InodeAttributes{
2015-03-24 04:02:48 +03:00
Nlink: 1,
Mode: 0777 | os.ModeDir,
}
}
// LOCKS_REQUIRED(fs.mu)
func (fs *flushFS) getAttributes(id fuseops.InodeID) (fuseops.InodeAttributes, error) {
switch id {
case fuseops.RootInodeID:
return fs.rootAttributes(), nil
case fooID:
return fs.fooAttributes(), nil
case barID:
return fs.barAttributes(), nil
default:
return fuseops.InodeAttributes{}, fuse.ENOENT
}
}
2015-03-20 03:38:40 +03:00
////////////////////////////////////////////////////////////////////////
2015-03-25 01:35:32 +03:00
// FileSystem methods
2015-03-20 03:38:40 +03:00
////////////////////////////////////////////////////////////////////////
2015-09-09 15:55:39 +03:00
func (fs *flushFS) StatFS(
ctx context.Context,
op *fuseops.StatFSOp) error {
return nil
2015-09-09 15:55:39 +03:00
}
2015-03-25 01:33:04 +03:00
func (fs *flushFS) LookUpInode(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.LookUpInodeOp) error {
2015-03-20 03:38:40 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
// Sanity check.
2015-03-24 08:17:10 +03:00
if op.Parent != fuseops.RootInodeID {
return fuse.ENOENT
2015-03-20 03:38:40 +03:00
}
2015-03-24 04:02:48 +03:00
// Set up the entry.
2015-03-24 08:17:10 +03:00
switch op.Name {
2015-03-24 04:02:48 +03:00
case "foo":
2015-03-24 08:17:10 +03:00
op.Entry = fuseops.ChildInodeEntry{
2015-03-24 04:02:48 +03:00
Child: fooID,
Attributes: fs.fooAttributes(),
}
case "bar":
2015-03-24 08:17:10 +03:00
op.Entry = fuseops.ChildInodeEntry{
2015-03-24 04:02:48 +03:00
Child: barID,
Attributes: fs.barAttributes(),
}
default:
return fuse.ENOENT
2015-03-20 03:38:40 +03:00
}
return nil
2015-03-20 03:38:40 +03:00
}
2015-03-20 03:40:14 +03:00
2015-03-25 01:33:04 +03:00
func (fs *flushFS) GetInodeAttributes(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.GetInodeAttributesOp) error {
2015-03-20 03:40:14 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
var err error
op.Attributes, err = fs.getAttributes(op.Inode)
return err
}
2015-03-20 03:40:14 +03:00
func (fs *flushFS) SetInodeAttributes(
ctx context.Context,
op *fuseops.SetInodeAttributesOp) error {
fs.mu.Lock()
defer fs.mu.Unlock()
2015-03-20 03:40:14 +03:00
// Ignore any changes and simply return existing attributes.
var err error
op.Attributes, err = fs.getAttributes(op.Inode)
return err
2015-03-20 03:40:14 +03:00
}
2015-03-20 03:40:53 +03:00
2015-03-25 01:33:04 +03:00
func (fs *flushFS) OpenFile(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.OpenFileOp) error {
2015-03-20 03:40:53 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
// Sanity check.
2015-03-24 08:17:10 +03:00
if op.Inode != fooID {
return fuse.ENOSYS
2015-03-20 03:40:53 +03:00
}
return nil
2015-03-20 03:40:53 +03:00
}
2015-03-20 03:49:45 +03:00
2015-03-25 01:33:04 +03:00
func (fs *flushFS) ReadFile(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.ReadFileOp) error {
2015-03-20 05:51:04 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
// Ensure the offset is in range.
2015-03-24 08:17:10 +03:00
if op.Offset > int64(len(fs.fooContents)) {
return nil
2015-03-20 05:51:04 +03:00
}
// Read what we can.
2015-07-29 03:23:51 +03:00
op.BytesRead = copy(op.Dst, fs.fooContents[op.Offset:])
2015-03-20 05:51:04 +03:00
return nil
2015-03-20 05:51:04 +03:00
}
2015-03-25 01:33:04 +03:00
func (fs *flushFS) WriteFile(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.WriteFileOp) error {
2015-03-20 03:49:45 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
// Ensure that the contents slice is long enough.
2015-03-24 08:17:10 +03:00
newLen := int(op.Offset) + len(op.Data)
2015-03-20 03:49:45 +03:00
if len(fs.fooContents) < newLen {
padding := make([]byte, newLen-len(fs.fooContents))
fs.fooContents = append(fs.fooContents, padding...)
}
// Copy in the data.
2015-03-24 08:17:10 +03:00
n := copy(fs.fooContents[op.Offset:], op.Data)
2015-03-20 03:49:45 +03:00
// Sanity check.
2015-03-24 08:17:10 +03:00
if n != len(op.Data) {
2015-03-20 03:49:45 +03:00
panic(fmt.Sprintf("Unexpected short copy: %v", n))
}
return nil
2015-03-20 03:49:45 +03:00
}
2015-03-20 05:27:27 +03:00
2015-03-25 01:33:04 +03:00
func (fs *flushFS) SyncFile(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.SyncFileOp) error {
2015-03-20 05:40:53 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
return fs.reportFsync(string(fs.fooContents))
2015-03-20 05:40:53 +03:00
}
2015-03-25 01:33:04 +03:00
func (fs *flushFS) FlushFile(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.FlushFileOp) error {
2015-03-20 05:27:27 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
return fs.reportFlush(string(fs.fooContents))
2015-03-20 05:27:27 +03:00
}
2015-03-24 04:02:48 +03:00
2015-03-25 01:33:04 +03:00
func (fs *flushFS) OpenDir(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.OpenDirOp) error {
2015-03-24 04:02:48 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
// Sanity check.
2015-05-18 02:58:40 +03:00
switch op.Inode {
case fuseops.RootInodeID:
case barID:
default:
return fuse.ENOENT
2015-03-24 04:02:48 +03:00
}
return nil
2015-03-24 04:02:48 +03:00
}
2015-05-18 03:06:19 +03:00
func (fs *flushFS) ReadDir(
2015-07-27 08:47:45 +03:00
ctx context.Context,
op *fuseops.ReadDirOp) error {
2015-05-18 03:06:19 +03:00
fs.mu.Lock()
defer fs.mu.Unlock()
// Create the appropriate listing.
var dirents []fuseutil.Dirent
switch op.Inode {
case fuseops.RootInodeID:
dirents = []fuseutil.Dirent{
fuseutil.Dirent{
Offset: 1,
Inode: fooID,
Name: "foo",
Type: fuseutil.DT_File,
},
fuseutil.Dirent{
Offset: 2,
Inode: barID,
Name: "bar",
Type: fuseutil.DT_Directory,
},
}
case barID:
default:
return fmt.Errorf("Unexpected inode: %v", op.Inode)
2015-05-18 03:06:19 +03:00
}
// If the offset is for the end of the listing, we're done. Otherwise we
// expect it to be for the start.
switch op.Offset {
case fuseops.DirOffset(len(dirents)):
return nil
2015-05-18 03:06:19 +03:00
case 0:
default:
return fmt.Errorf("Unexpected offset: %v", op.Offset)
2015-05-18 03:06:19 +03:00
}
// Fill in the listing.
for _, de := range dirents {
2015-07-29 03:23:51 +03:00
n := fuseutil.WriteDirent(op.Dst[op.BytesRead:], de)
2015-05-18 03:06:19 +03:00
2015-07-29 03:23:51 +03:00
// We don't support doing this in anything more than one shot.
if n == 0 {
return fmt.Errorf("Couldn't fit listing in %v bytes", len(op.Dst))
2015-07-29 03:23:51 +03:00
}
op.BytesRead += n
2015-05-18 03:06:19 +03:00
}
return nil
2015-05-18 03:06:19 +03:00
}