From 664b621279e708b7c3133c3c4b8b9b9cef69dfdf Mon Sep 17 00:00:00 2001 From: Felix Lange Date: Fri, 24 Mar 2017 15:18:48 +0100 Subject: [PATCH] swarm/api: improve FUSE-related logging and APIs The API now returns JSON objects instead of strings. Log messages for invalid arguments are removed. --- swarm/api/fuse.go | 5 +- swarm/api/swarmfs_fallback.go | 20 ++--- swarm/api/swarmfs_unix.go | 133 ++++++++++++++-------------------- 3 files changed, 70 insertions(+), 88 deletions(-) diff --git a/swarm/api/fuse.go b/swarm/api/fuse.go index 58a5d18ae8..2a1cc9bf1b 100644 --- a/swarm/api/fuse.go +++ b/swarm/api/fuse.go @@ -14,7 +14,9 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -// +build !windows +// +build linux darwin freebsd + +// Data structures used for Fuse filesystem, serving directories and serving files to Fuse driver. package api @@ -29,7 +31,6 @@ import ( "golang.org/x/net/context" ) -// Data structures used for Fuse filesystem, serving directories and serving files to Fuse driver type FS struct { root *Dir } diff --git a/swarm/api/swarmfs_fallback.go b/swarm/api/swarmfs_fallback.go index 748c40cfc8..c6ac07d148 100644 --- a/swarm/api/swarmfs_fallback.go +++ b/swarm/api/swarmfs_fallback.go @@ -28,19 +28,21 @@ func isFUSEUnsupportedError(err error) bool { return err == errNoFUSE } -// Dummy struct and functions to satsfy windows build -type MountInfo struct{} - -func (self *SwarmFS) Mount(mhash, mountpoint string) error { - return errNoFUSE +type MountInfo struct { + MountPoint string + ManifestHash string } -func (self *SwarmFS) Unmount(mountpoint string) error { - return errNoFUSE +func (self *SwarmFS) Mount(mhash, mountpoint string) (*MountInfo, error) { + return nil, errNoFUSE } -func (self *SwarmFS) Listmounts() (string, error) { - return "", errNoFUSE +func (self *SwarmFS) Unmount(mountpoint string) (bool, error) { + return false, errNoFUSE +} + +func (self *SwarmFS) Listmounts() ([]*MountInfo, error) { + return nil, errNoFUSE } func (self *SwarmFS) Stop() error { diff --git a/swarm/api/swarmfs_unix.go b/swarm/api/swarmfs_unix.go index f650b43c5d..e696c6b9a6 100644 --- a/swarm/api/swarmfs_unix.go +++ b/swarm/api/swarmfs_unix.go @@ -19,6 +19,7 @@ package api import ( + "errors" "fmt" "os" "path/filepath" @@ -38,6 +39,12 @@ var ( inodeLock sync.RWMutex ) +var ( + errEmptyMountPoint = errors.New("need non-empty mount point") + errMaxMountCount = errors.New("max FUSE mount count reached") + errMountTimeout = errors.New("mount timeout") +) + func isFUSEUnsupportedError(err error) bool { if perr, ok := err.(*os.PathError); ok { return perr.Op == "open" && perr.Path == "/dev/fuse" @@ -45,51 +52,48 @@ func isFUSEUnsupportedError(err error) bool { return err == fuse.ErrOSXFUSENotFound } -// information about every active mount +// MountInfo contains information about every active mount type MountInfo struct { - mountPoint string - manifestHash string + MountPoint string + ManifestHash string resolvedKey storage.Key rootDir *Dir fuseConnection *fuse.Conn } +// newInode creates a new inode number. // Inode numbers need to be unique, they are used for caching inside fuse -func NewInode() uint64 { +func newInode() uint64 { inodeLock.Lock() defer inodeLock.Unlock() inode += 1 return inode } -func (self *SwarmFS) Mount(mhash, mountpoint string) (string, error) { +func (self *SwarmFS) Mount(mhash, mountpoint string) (*MountInfo, error) { + if mountpoint == "" { + return nil, errEmptyMountPoint + } + cleanedMountPoint, err := filepath.Abs(filepath.Clean(mountpoint)) + if err != nil { + return nil, err + } + self.activeLock.Lock() defer self.activeLock.Unlock() noOfActiveMounts := len(self.activeMounts) if noOfActiveMounts >= maxFuseMounts { - err := fmt.Errorf("Max mount count reached. Cannot mount %s ", mountpoint) - log.Warn(err.Error()) - return err.Error(), err - } - - cleanedMountPoint, err := filepath.Abs(filepath.Clean(mountpoint)) - if err != nil { - return err.Error(), err + return nil, errMaxMountCount } if _, ok := self.activeMounts[cleanedMountPoint]; ok { - err := fmt.Errorf("Mountpoint %s already mounted.", cleanedMountPoint) - log.Warn(err.Error()) - return err.Error(), err + return nil, fmt.Errorf("%s is already mounted", cleanedMountPoint) } - log.Info(fmt.Sprintf("Attempting to mount %s ", cleanedMountPoint)) key, _, path, err := self.swarmApi.parseAndResolve(mhash, true) if err != nil { - errStr := fmt.Sprintf("Could not resolve %s : %v", mhash, err) - log.Warn(errStr) - return errStr, err + return nil, fmt.Errorf("can't resolve %q: %v", mhash, err) } if len(path) > 0 { @@ -99,15 +103,13 @@ func (self *SwarmFS) Mount(mhash, mountpoint string) (string, error) { quitC := make(chan bool) trie, err := loadManifest(self.swarmApi.dpa, key, quitC) if err != nil { - errStr := fmt.Sprintf("fs.Download: loadManifestTrie error: %v", err) - log.Warn(errStr) - return errStr, err + return nil, fmt.Errorf("can't load manifest %v: %v", key.String(), err) } dirTree := map[string]*Dir{} rootDir := &Dir{ - inode: NewInode(), + inode: newInode(), name: "root", directories: nil, files: nil, @@ -130,7 +132,7 @@ func (self *SwarmFS) Mount(mhash, mountpoint string) (string, error) { if _, ok := dirTree[dirUntilNow]; !ok { dirTree[dirUntilNow] = &Dir{ - inode: NewInode(), + inode: newInode(), name: thisDir, path: dirUntilNow, directories: nil, @@ -146,7 +148,7 @@ func (self *SwarmFS) Mount(mhash, mountpoint string) (string, error) { } } thisFile := &File{ - inode: NewInode(), + inode: newInode(), name: filename, path: fullpath, key: key, @@ -158,107 +160,84 @@ func (self *SwarmFS) Mount(mhash, mountpoint string) (string, error) { fconn, err := fuse.Mount(cleanedMountPoint, fuse.FSName("swarmfs"), fuse.VolumeName(mhash)) if err != nil { fuse.Unmount(cleanedMountPoint) - errStr := fmt.Sprintf("Mounting %s encountered error: %v", cleanedMountPoint, err) - log.Warn(errStr) - return errStr, err + log.Warn("Error mounting swarm manifest", "mountpoint", cleanedMountPoint, "err", err) + return nil, err } mounterr := make(chan error, 1) go func() { - log.Info(fmt.Sprintf("Serving %s at %s", mhash, cleanedMountPoint)) filesys := &FS{root: rootDir} if err := fs.Serve(fconn, filesys); err != nil { - log.Warn(fmt.Sprintf("Could not Serve FS error: %v", err)) + mounterr <- err } }() // Check if the mount process has an error to report. select { - case <-time.After(mountTimeout): - err := fmt.Errorf("Mounting %s timed out.", cleanedMountPoint) - log.Warn(err.Error()) - return err.Error(), err + fuse.Unmount(cleanedMountPoint) + return nil, errMountTimeout case err := <-mounterr: - errStr := fmt.Sprintf("Mounting %s encountered error: %v", cleanedMountPoint, err) - log.Warn(errStr) - return errStr, err + log.Warn("Error serving swarm FUSE FS", "mountpoint", cleanedMountPoint, "err", err) + return nil, err case <-fconn.Ready: - log.Debug(fmt.Sprintf("Mounting connection succeeded for : %v", cleanedMountPoint)) + log.Info("Now serving swarm FUSE FS", "manifest", mhash, "mountpoint", cleanedMountPoint) } - //Assemble and Store the mount information for future use - mountInformation := &MountInfo{ - mountPoint: cleanedMountPoint, - manifestHash: mhash, + // Assemble and Store the mount information for future use + mi := &MountInfo{ + MountPoint: cleanedMountPoint, + ManifestHash: mhash, resolvedKey: key, rootDir: rootDir, fuseConnection: fconn, } - self.activeMounts[cleanedMountPoint] = mountInformation - - succString := fmt.Sprintf("Mounting successful for %s", cleanedMountPoint) - log.Info(succString) - - return succString, nil + self.activeMounts[cleanedMountPoint] = mi + return mi, nil } -func (self *SwarmFS) Unmount(mountpoint string) (string, error) { +func (self *SwarmFS) Unmount(mountpoint string) (bool, error) { self.activeLock.Lock() defer self.activeLock.Unlock() cleanedMountPoint, err := filepath.Abs(filepath.Clean(mountpoint)) if err != nil { - return err.Error(), err + return false, err } - // Get the mount information based on the mountpoint argument mountInfo := self.activeMounts[cleanedMountPoint] - - if mountInfo == nil || mountInfo.mountPoint != cleanedMountPoint { - err := fmt.Errorf("Could not find mount information for %s ", cleanedMountPoint) - log.Warn(err.Error()) - return err.Error(), err + if mountInfo == nil || mountInfo.MountPoint != cleanedMountPoint { + return false, fmt.Errorf("%s is not mounted", cleanedMountPoint) } - err = fuse.Unmount(cleanedMountPoint) if err != nil { - //TODO: try forceful unmount if normal unmount fails - errStr := fmt.Sprintf("UnMount error: %v", err) - log.Warn(errStr) - return errStr, err + // TODO(jmozah): try forceful unmount if normal unmount fails + return false, err } + // remove the mount information from the active map mountInfo.fuseConnection.Close() - - //remove the mount information from the active map delete(self.activeMounts, cleanedMountPoint) - - succString := fmt.Sprintf("UnMounting %v succeeded", cleanedMountPoint) - log.Info(succString) - return succString, nil + return true, nil } -func (self *SwarmFS) Listmounts() (string, error) { +func (self *SwarmFS) Listmounts() []*MountInfo { self.activeLock.RLock() defer self.activeLock.RUnlock() - var rows []string - for mp := range self.activeMounts { - mountInfo := self.activeMounts[mp] - rows = append(rows, fmt.Sprintf("Swarm Root: %s, Mount Point: %s ", mountInfo.manifestHash, mountInfo.mountPoint)) + rows := make([]*MountInfo, 0, len(self.activeMounts)) + for _, mi := range self.activeMounts { + rows = append(rows, mi) } - - return strings.Join(rows, "\n"), nil + return rows } func (self *SwarmFS) Stop() bool { for mp := range self.activeMounts { mountInfo := self.activeMounts[mp] - self.Unmount(mountInfo.mountPoint) + self.Unmount(mountInfo.MountPoint) } - return true }