Uniformize writing of FileSystem (was: Filesystem as well).

fuse/default.go

@@ -159,95 +159,95 @@ func (me *DefaultFuseFile) Fsync(*FsyncIn) (code Status) {
 }
 
 ////////////////////////////////////////////////////////////////
-// DefaultPathFilesystem
+// DefaultPathFileSystem
 
-func (me *DefaultPathFilesystem) GetAttr(name string) (*Attr, Status) {
+func (me *DefaultPathFileSystem) GetAttr(name string) (*Attr, Status) {
 	return nil, ENOSYS
 }
 
-func (me *DefaultPathFilesystem) GetXAttr(name string, attr string) ([]byte, Status) {
+func (me *DefaultPathFileSystem) GetXAttr(name string, attr string) ([]byte, Status) {
 	return nil, ENOSYS
 }
 
-func (me *DefaultPathFilesystem) SetXAttr(name string, attr string, data []byte, flags int) Status {
+func (me *DefaultPathFileSystem) SetXAttr(name string, attr string, data []byte, flags int) Status {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) ListXAttr(name string) ([]string, Status) {
+func (me *DefaultPathFileSystem) ListXAttr(name string) ([]string, Status) {
 	return nil, ENOSYS
 }
 
-func (me *DefaultPathFilesystem) RemoveXAttr(name string, attr string) Status {
+func (me *DefaultPathFileSystem) RemoveXAttr(name string, attr string) Status {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Readlink(name string) (string, Status) {
+func (me *DefaultPathFileSystem) Readlink(name string) (string, Status) {
 	return "", ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Mknod(name string, mode uint32, dev uint32) Status {
+func (me *DefaultPathFileSystem) Mknod(name string, mode uint32, dev uint32) Status {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Mkdir(name string, mode uint32) Status {
+func (me *DefaultPathFileSystem) Mkdir(name string, mode uint32) Status {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Unlink(name string) (code Status) {
+func (me *DefaultPathFileSystem) Unlink(name string) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Rmdir(name string) (code Status) {
+func (me *DefaultPathFileSystem) Rmdir(name string) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Symlink(value string, linkName string) (code Status) {
+func (me *DefaultPathFileSystem) Symlink(value string, linkName string) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Rename(oldName string, newName string) (code Status) {
+func (me *DefaultPathFileSystem) Rename(oldName string, newName string) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Link(oldName string, newName string) (code Status) {
+func (me *DefaultPathFileSystem) Link(oldName string, newName string) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Chmod(name string, mode uint32) (code Status) {
+func (me *DefaultPathFileSystem) Chmod(name string, mode uint32) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Chown(name string, uid uint32, gid uint32) (code Status) {
+func (me *DefaultPathFileSystem) Chown(name string, uid uint32, gid uint32) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Truncate(name string, offset uint64) (code Status) {
+func (me *DefaultPathFileSystem) Truncate(name string, offset uint64) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Open(name string, flags uint32) (file FuseFile, code Status) {
+func (me *DefaultPathFileSystem) Open(name string, flags uint32) (file FuseFile, code Status) {
 	return nil, ENOSYS
 }
 
-func (me *DefaultPathFilesystem) OpenDir(name string) (stream chan DirEntry, status Status) {
+func (me *DefaultPathFileSystem) OpenDir(name string) (stream chan DirEntry, status Status) {
 	return nil, ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Mount(conn *PathFileSystemConnector) Status {
+func (me *DefaultPathFileSystem) Mount(conn *PathFileSystemConnector) Status {
 	return OK
 }
 
-func (me *DefaultPathFilesystem) Unmount() {
+func (me *DefaultPathFileSystem) Unmount() {
 }
 
-func (me *DefaultPathFilesystem) Access(name string, mode uint32) (code Status) {
+func (me *DefaultPathFileSystem) Access(name string, mode uint32) (code Status) {
 	return ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Create(name string, flags uint32, mode uint32) (file FuseFile, code Status) {
+func (me *DefaultPathFileSystem) Create(name string, flags uint32, mode uint32) (file FuseFile, code Status) {
 	return nil, ENOSYS
 }
 
-func (me *DefaultPathFilesystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status) {
+func (me *DefaultPathFileSystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status) {
 	return ENOSYS
 }

fuse/default_test.go

 package fuse
 
-// Make sure library supplied Filesystems support the
+// Make sure library supplied FileSystems support the
 // required interface.
 
 import (
@@ -11,17 +11,17 @@ func TestRawFs(t *testing.T) {
 	var iface RawFileSystem
 
 	iface = new(DefaultRawFuseFileSystem)
-	iface = new(WrappingRawFilesystem)
-	iface = new(TimingRawFilesystem)
+	iface = new(WrappingRawFileSystem)
+	iface = new(TimingRawFileSystem)
 
 	_ = iface
 }
 
 func TestPathFs(t *testing.T) {
-	var iface PathFilesystem
-	iface = new(DefaultPathFilesystem)
-	iface = new(WrappingPathFilesystem)
-	iface = new(TimingPathFilesystem)
+	var iface PathFileSystem
+	iface = new(DefaultPathFileSystem)
+	iface = new(WrappingPathFileSystem)
+	iface = new(TimingPathFileSystem)
 
 	_ = iface
 }

fuse/loopback.go

@@ -18,7 +18,7 @@ var _ = log.Println
 type LoopbackFileSystem struct {
 	root string
 
-	DefaultPathFilesystem
+	DefaultPathFileSystem
 }
 
 func NewLoopbackFileSystem(root string) (out *LoopbackFileSystem) {

fuse/loopback_test.go

@@ -54,16 +54,16 @@ func (me *testCase) Setup(t *testing.T) {
 	me.origSubdir = filepath.Join(me.origDir, subdir)
 	me.origSubfile = filepath.Join(me.origSubdir, "subfile")
 
-	var pfs PathFilesystem
+	var pfs PathFileSystem
 	pfs = NewLoopbackFileSystem(me.origDir)
-	pfs = NewTimingPathFilesystem(pfs)
-	pfs = NewLockingPathFilesystem(pfs)
+	pfs = NewTimingPathFileSystem(pfs)
+	pfs = NewLockingPathFileSystem(pfs)
 
 	var rfs RawFileSystem
 	me.connector = NewPathFileSystemConnector(pfs)
 	rfs = me.connector
-	rfs = NewTimingRawFilesystem(rfs)
-	rfs = NewLockingRawFilesystem(rfs)
+	rfs = NewTimingRawFileSystem(rfs)
+	rfs = NewLockingRawFileSystem(rfs)
 
 	me.connector.Debug = true
 	me.state = NewMountState(rfs)

fuse/pathdebug.go

@@ -5,21 +5,21 @@ import (
 
 var _ = fmt.Println
 
-type PathFilesystemDebug struct {
+type PathFileSystemDebug struct {
 	// TODO - use a generic callback system instead.
 	Connector *PathFileSystemConnector
 
-	WrappingPathFilesystem
+	WrappingPathFileSystem
 }
 
-func (me *PathFilesystemDebug) Open(path string, flags uint32) (fuseFile FuseFile, status Status)  {
+func (me *PathFileSystemDebug) Open(path string, flags uint32) (fuseFile FuseFile, status Status)  {
 	if path == ".debug" && me.Connector != nil {
 		return NewReadOnlyFile([]byte(me.Connector.DebugString())), OK
 	}
 	return me.Original.Open(path, flags)
 }
 
-func (me *PathFilesystemDebug) GetAttr(path string) (*Attr, Status) {
+func (me *PathFileSystemDebug) GetAttr(path string) (*Attr, Status) {
 	if path == ".debug" && me.Connector != nil {
 		return &Attr{
 			Mode: S_IFREG,

fuse/pathfilesystem.go

@@ -11,7 +11,7 @@ import (
 
 type mountData struct {
 	// If non-nil the file system mounted here.
-	fs PathFilesystem
+	fs PathFileSystem
 
 	// Protects the variables below.
 	mutex sync.RWMutex
@@ -20,7 +20,7 @@ type mountData struct {
 	unmountPending bool
 }
 
-func newMount(fs PathFilesystem) *mountData {
+func newMount(fs PathFileSystem) *mountData {
 	return &mountData{fs: fs}
 }
 
@@ -378,7 +378,7 @@ func EmptyPathFileSystemConnector() (out *PathFileSystemConnector) {
 	return out;
 }
 
-func NewPathFileSystemConnector(fs PathFilesystem) (out *PathFileSystemConnector) {
+func NewPathFileSystemConnector(fs PathFileSystem) (out *PathFileSystemConnector) {
 	out = EmptyPathFileSystemConnector()
 	if code := out.Mount("/", fs); code != OK {
 		panic("root mount failed.")
@@ -392,7 +392,7 @@ func (me *PathFileSystemConnector) SetOptions(opts PathFileSystemConnectorOption
 	me.options = opts
 }
 
-func (me *PathFileSystemConnector) Mount(mountPoint string, fs PathFilesystem) Status {
+func (me *PathFileSystemConnector) Mount(mountPoint string, fs PathFileSystem) Status {
 	var node *inode
 
 	if mountPoint != "/" {

fuse/timingfs.go

@@ -11,9 +11,9 @@ import (
 var _ = log.Print
 var _ = fmt.Print
 
-// TimingPathFilesystem is a wrapper to collect timings for a PathFilesystem
-type TimingPathFilesystem struct {
-	WrappingPathFilesystem
+// TimingPathFileSystem is a wrapper to collect timings for a PathFileSystem
+type TimingPathFileSystem struct {
+	WrappingPathFileSystem
 
 	statisticsLock sync.Mutex
 	latencies      map[string]int64
@@ -21,8 +21,8 @@ type TimingPathFilesystem struct {
 	pathCounts     map[string]map[string]int64
 }
 
-func NewTimingPathFilesystem(fs PathFilesystem) *TimingPathFilesystem {
-	t := new(TimingPathFilesystem)
+func NewTimingPathFileSystem(fs PathFileSystem) *TimingPathFileSystem {
+	t := new(TimingPathFileSystem)
 	t.Original = fs
 	t.latencies = make(map[string]int64)
 	t.counts = make(map[string]int64)
@@ -30,7 +30,7 @@ func NewTimingPathFilesystem(fs PathFilesystem) *TimingPathFilesystem {
 	return t
 }
 
-func (me *TimingPathFilesystem) startTimer(name string, arg string) (closure func()) {
+func (me *TimingPathFileSystem) startTimer(name string, arg string) (closure func()) {
 	start := time.Nanoseconds()
 
 	return func() {
@@ -50,7 +50,7 @@ func (me *TimingPathFilesystem) startTimer(name string, arg string) (closure fun
 	}
 }
 
-func (me *TimingPathFilesystem) OperationCounts() map[string]int64 {
+func (me *TimingPathFileSystem) OperationCounts() map[string]int64 {
 	me.statisticsLock.Lock()
 	defer me.statisticsLock.Unlock()
 
@@ -61,7 +61,7 @@ func (me *TimingPathFilesystem) OperationCounts() map[string]int64 {
 	return r
 }
 
-func (me *TimingPathFilesystem) Latencies() map[string]float64 {
+func (me *TimingPathFileSystem) Latencies() map[string]float64 {
 	me.statisticsLock.Lock()
 	defer me.statisticsLock.Unlock()
 
@@ -72,7 +72,7 @@ func (me *TimingPathFilesystem) Latencies() map[string]float64 {
 	return r
 }
 
-func (me *TimingPathFilesystem) HotPaths(operation string) (paths []string, uniquePaths int) {
+func (me *TimingPathFileSystem) HotPaths(operation string) (paths []string, uniquePaths int) {
 	me.statisticsLock.Lock()
 	defer me.statisticsLock.Unlock()
 
@@ -86,117 +86,117 @@ func (me *TimingPathFilesystem) HotPaths(operation string) (paths []string, uniq
 	return results, len(counts)
 }
 
-func (me *TimingPathFilesystem) GetAttr(name string) (*Attr, Status) {
+func (me *TimingPathFileSystem) GetAttr(name string) (*Attr, Status) {
 	defer me.startTimer("GetAttr", name)()
 	return me.Original.GetAttr(name)
 }
 
-func (me *TimingPathFilesystem) GetXAttr(name string, attr string) ([]byte, Status) {
+func (me *TimingPathFileSystem) GetXAttr(name string, attr string) ([]byte, Status) {
 	defer me.startTimer("GetXAttr", name)()
 	return me.Original.GetXAttr(name, attr)
 }
 
-func (me *TimingPathFilesystem) SetXAttr(name string, attr string, data []byte, flags int) Status {
+func (me *TimingPathFileSystem) SetXAttr(name string, attr string, data []byte, flags int) Status {
 	defer me.startTimer("SetXAttr", name)()
 	return me.Original.SetXAttr(name, attr, data, flags)
 }
 
-func (me *TimingPathFilesystem) ListXAttr(name string) ([]string, Status) {
+func (me *TimingPathFileSystem) ListXAttr(name string) ([]string, Status) {
 	defer me.startTimer("ListXAttr", name)()
 	return me.Original.ListXAttr(name)
 }
 
-func (me *TimingPathFilesystem) RemoveXAttr(name string, attr string) Status {
+func (me *TimingPathFileSystem) RemoveXAttr(name string, attr string) Status {
 	defer me.startTimer("RemoveXAttr", name)()
 	return me.Original.RemoveXAttr(name, attr)
 }
 
-func (me *TimingPathFilesystem) Readlink(name string) (string, Status) {
+func (me *TimingPathFileSystem) Readlink(name string) (string, Status) {
 	defer me.startTimer("Readlink", name)()
 	return me.Original.Readlink(name)
 }
 
-func (me *TimingPathFilesystem) Mknod(name string, mode uint32, dev uint32) Status {
+func (me *TimingPathFileSystem) Mknod(name string, mode uint32, dev uint32) Status {
 	defer me.startTimer("Mknod", name)()
 	return me.Original.Mknod(name, mode, dev)
 }
 
-func (me *TimingPathFilesystem) Mkdir(name string, mode uint32) Status {
+func (me *TimingPathFileSystem) Mkdir(name string, mode uint32) Status {
 	defer me.startTimer("Mkdir", name)()
 	return me.Original.Mkdir(name, mode)
 }
 
-func (me *TimingPathFilesystem) Unlink(name string) (code Status) {
+func (me *TimingPathFileSystem) Unlink(name string) (code Status) {
 	defer me.startTimer("Unlink", name)()
 	return me.Original.Unlink(name)
 }
 
-func (me *TimingPathFilesystem) Rmdir(name string) (code Status) {
+func (me *TimingPathFileSystem) Rmdir(name string) (code Status) {
 	defer me.startTimer("Rmdir", name)()
 	return me.Original.Rmdir(name)
 }
 
-func (me *TimingPathFilesystem) Symlink(value string, linkName string) (code Status) {
+func (me *TimingPathFileSystem) Symlink(value string, linkName string) (code Status) {
 	defer me.startTimer("Symlink", linkName)()
 	return me.Original.Symlink(value, linkName)
 }
 
-func (me *TimingPathFilesystem) Rename(oldName string, newName string) (code Status) {
+func (me *TimingPathFileSystem) Rename(oldName string, newName string) (code Status) {
 	defer me.startTimer("Rename", oldName)()
 	return me.Original.Rename(oldName, newName)
 }
 
-func (me *TimingPathFilesystem) Link(oldName string, newName string) (code Status) {
+func (me *TimingPathFileSystem) Link(oldName string, newName string) (code Status) {
 	defer me.startTimer("Link", newName)()
 	return me.Original.Link(oldName, newName)
 }
 
-func (me *TimingPathFilesystem) Chmod(name string, mode uint32) (code Status) {
+func (me *TimingPathFileSystem) Chmod(name string, mode uint32) (code Status) {
 	defer me.startTimer("Chmod", name)()
 	return me.Original.Chmod(name, mode)
 }
 
-func (me *TimingPathFilesystem) Chown(name string, uid uint32, gid uint32) (code Status) {
+func (me *TimingPathFileSystem) Chown(name string, uid uint32, gid uint32) (code Status) {
 	defer me.startTimer("Chown", name)()
 	return me.Original.Chown(name, uid, gid)
 }
 
-func (me *TimingPathFilesystem) Truncate(name string, offset uint64) (code Status) {
+func (me *TimingPathFileSystem) Truncate(name string, offset uint64) (code Status) {
 	defer me.startTimer("Truncate", name)()
 	return me.Original.Truncate(name, offset)
 }
 
-func (me *TimingPathFilesystem) Open(name string, flags uint32) (file FuseFile, code Status) {
+func (me *TimingPathFileSystem) Open(name string, flags uint32) (file FuseFile, code Status) {
 	defer me.startTimer("Open", name)()
 	return me.Original.Open(name, flags)
 }
 
-func (me *TimingPathFilesystem) OpenDir(name string) (stream chan DirEntry, status Status) {
+func (me *TimingPathFileSystem) OpenDir(name string) (stream chan DirEntry, status Status) {
 	defer me.startTimer("OpenDir", name)()
 	return me.Original.OpenDir(name)
 }
 
-func (me *TimingPathFilesystem) Mount(conn *PathFileSystemConnector) Status {
+func (me *TimingPathFileSystem) Mount(conn *PathFileSystemConnector) Status {
 	defer me.startTimer("Mount", "")()
 	return me.Original.Mount(conn)
 }
 
-func (me *TimingPathFilesystem) Unmount() {
+func (me *TimingPathFileSystem) Unmount() {
 	defer me.startTimer("Unmount", "")()
 	me.Original.Unmount()
 }
 
-func (me *TimingPathFilesystem) Access(name string, mode uint32) (code Status) {
+func (me *TimingPathFileSystem) Access(name string, mode uint32) (code Status) {
 	defer me.startTimer("Access", name)()
 	return me.Original.Access(name, mode)
 }
 
-func (me *TimingPathFilesystem) Create(name string, flags uint32, mode uint32) (file FuseFile, code Status) {
+func (me *TimingPathFileSystem) Create(name string, flags uint32, mode uint32) (file FuseFile, code Status) {
 	defer me.startTimer("Create", name)()
 	return me.Original.Create(name, flags, mode)
 }
 
-func (me *TimingPathFilesystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status) {
+func (me *TimingPathFileSystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status) {
 	defer me.startTimer("Utimens", name)()
 	return me.Original.Utimens(name, AtimeNs, CtimeNs)
 }

fuse/types.go

@@ -558,7 +558,7 @@ type RawFuseDir interface {
 	Release()
 }
 
-type PathFilesystem interface {
+type PathFileSystem interface {
 	GetAttr(name string) (*Attr, Status)
 	Readlink(name string) (string, Status)
 	Mknod(name string, mode uint32, dev uint32) Status
@@ -596,6 +596,6 @@ type PathFilesystem interface {
 // Include this struct in your implementation to inherit default nop
 // implementations.
 
-type DefaultPathFilesystem struct{}
+type DefaultPathFileSystem struct{}
 type DefaultFuseFile struct{}
 type DefaultRawFuseFileSystem struct{}

fuse/xattr_test.go

@@ -15,7 +15,7 @@ type XAttrTestFs struct {
 	filename string
 	attrs    map[string][]byte
 
-	DefaultPathFilesystem
+	DefaultPathFileSystem
 }
 
 func NewXAttrFs(nm string, m map[string][]byte) *XAttrTestFs {
@@ -93,7 +93,7 @@ func TestXAttrRead(t *testing.T) {
 		"user.attr2": []byte("val2")}
 	xfs := NewXAttrFs(nm, golden)
 
-	connector := NewPathFileSystemConnector(NewLockingPathFilesystem(xfs))
+	connector := NewPathFileSystemConnector(NewLockingPathFileSystem(xfs))
 	mountPoint := MakeTempDir()
 
 	state := NewMountState(connector)

unionfs/autounion.go

@@ -18,10 +18,10 @@ import (
 //
 // A union for A/B/C will placed under directory A-B-C.
 type AutoUnionFs struct {
-	fuse.DefaultPathFilesystem
+	fuse.DefaultPathFileSystem
 
 	lock             sync.RWMutex
-	knownFilesystems map[string]*UnionFs
+	knownFileSystems map[string]*UnionFs
 	root             string
 
 	connector *fuse.PathFileSystemConnector
@@ -35,7 +35,7 @@ type AutoUnionFsOptions struct {
 
 func NewAutoUnionFs(directory string, options AutoUnionFsOptions) *AutoUnionFs {
 	a := new(AutoUnionFs)
-	a.knownFilesystems = make(map[string]*UnionFs)
+	a.knownFileSystems = make(map[string]*UnionFs)
 	a.options = &options
 	a.root = directory
 	return a
@@ -58,10 +58,10 @@ func (me *AutoUnionFs) addFs(roots []string) {
 
 	me.lock.Lock()
 	var gofs *UnionFs
-	if me.knownFilesystems[name] == nil {
+	if me.knownFileSystems[name] == nil {
 		log.Println("Adding UnionFs for roots", roots)
 		gofs = NewUnionFs(roots, me.options.UnionFsOptions)
-		me.knownFilesystems[name] = gofs
+		me.knownFileSystems[name] = gofs
 	}
 	me.lock.Unlock()
 
@@ -103,7 +103,7 @@ func (me *AutoUnionFs) Readlink(path string) (out string, code fuse.Status) {
 	name := comps[1]
 	me.lock.RLock()
 	defer me.lock.RUnlock()
-	fs := me.knownFilesystems[name]
+	fs := me.knownFileSystems[name]
 	if fs == nil {
 		return "", fuse.ENOENT
 	}
@@ -137,7 +137,7 @@ func (me *AutoUnionFs) GetAttr(path string) (*fuse.Attr, fuse.Status) {
 	me.lock.RLock()
 	defer me.lock.RUnlock()
 	if len(comps) > 1 && comps[0] == "config" {
-		fs := me.knownFilesystems[comps[1]]
+		fs := me.knownFileSystems[comps[1]]
 
 		if fs == nil {
 			return nil, fuse.ENOENT
@@ -149,7 +149,7 @@ func (me *AutoUnionFs) GetAttr(path string) (*fuse.Attr, fuse.Status) {
 		return a, fuse.OK
 	}
 
-	if me.knownFilesystems[path] != nil {
+	if me.knownFileSystems[path] != nil {
 		return &fuse.Attr{
 			Mode: fuse.S_IFDIR | 0755,
 		},fuse.OK
@@ -189,8 +189,8 @@ func (me *AutoUnionFs) OpenDir(name string) (stream chan fuse.DirEntry, status f
 	me.lock.RLock()
 	defer me.lock.RUnlock()
 
-	stream = make(chan fuse.DirEntry, len(me.knownFilesystems)+5)
-	for k, _ := range me.knownFilesystems {
+	stream = make(chan fuse.DirEntry, len(me.knownFileSystems)+5)
+	for k, _ := range me.knownFileSystems {
 		mode := fuse.S_IFDIR | 0755
 		if name == "config" {
 			mode = syscall.S_IFLNK | 0644

unionfs/cachingfs.go

@@ -22,7 +22,7 @@ type linkResponse struct {
 
 // Caches readdir and getattr()
 type CachingFileSystem struct {
-	fuse.WrappingPathFilesystem
+	fuse.WrappingPathFileSystem
 
 	attributesLock sync.RWMutex
 	attributes     map[string]attrResponse
@@ -34,7 +34,7 @@ type CachingFileSystem struct {
 	links     map[string]linkResponse
 }
 
-func NewCachingFileSystem(pfs fuse.PathFilesystem) *CachingFileSystem {
+func NewCachingFileSystem(pfs fuse.PathFileSystem) *CachingFileSystem {
 	c := new(CachingFileSystem)
 	c.Original = pfs
 	c.attributes = make(map[string]attrResponse)

unionfs/unionfs.go

@@ -58,12 +58,12 @@ func filePathHash(path string) string {
 
 */
 type UnionFs struct {
-	fuse.DefaultPathFilesystem
+	fuse.DefaultPathFileSystem
 
 	branches []*fuse.LoopbackFileSystem
 
 	// The same, but as interfaces.
-	fileSystems []fuse.PathFilesystem
+	fileSystems []fuse.PathFileSystem
 
 	// A file-existence cache.
 	deletionCache *DirCache
@@ -89,7 +89,7 @@ func NewUnionFs(roots []string, options UnionFsOptions) *UnionFs {
 		g.branches = append(g.branches, pt)
 
 		// We could use some sort of caching file system here.
-		g.fileSystems = append(g.fileSystems, fuse.PathFilesystem(pt))
+		g.fileSystems = append(g.fileSystems, fuse.PathFileSystem(pt))
 	}
 
 	deletionDir := g.deletionDir()
@@ -232,7 +232,7 @@ src *fuse.LoopbackFileSystem) os.Error {
 }
 
 ////////////////////////////////////////////////////////////////
-// Below: implement interface for a PathFilesystem.
+// Below: implement interface for a PathFileSystem.
 
 func (me *UnionFs) Mkdir(path string, mode uint32) (code fuse.Status) {
 	code = me.fileSystems[0].Mkdir(path, mode)
@@ -344,7 +344,7 @@ func (me *UnionFs) OpenDir(directory string) (stream chan fuse.DirEntry, status
 	for i, l := range me.fileSystems {
 		if i >= dirBranch {
 			wg.Add(1)
-			go func(j int, pfs fuse.PathFilesystem) {
+			go func(j int, pfs fuse.PathFileSystem) {
 				ch, s := pfs.OpenDir(directory)
 				statuses[j] = s
 				for s == fuse.OK {

zipfs/multizip.go

@@ -77,7 +77,7 @@ type MultiZipFs struct {
 	pendingZips  map[string]bool
 	zipFileNames map[string]string
 
-	fuse.DefaultPathFilesystem
+	fuse.DefaultPathFileSystem
 }
 
 func NewMultiZipFs() *MultiZipFs {

zipfs/zipfs.go

@@ -75,7 +75,7 @@ type ZipFileFuse struct {
 	tree        *ZipDirTree
 	ZipFileName string
 
-	fuse.DefaultPathFilesystem
+	fuse.DefaultPathFileSystem
 }
 
 func zipFilesToTree(files []*zip.File) *ZipDirTree {