path: root/swarm/api/fuse.go

// Copyright 2017 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

// +build linux darwin freebsd

// Data structures used for Fuse filesystem, serving directories and serving files to Fuse driver.

package api

import (
    "io"
    "os"

    "bazil.org/fuse"
    "bazil.org/fuse/fs"
    "github.com/ethereum/go-ethereum/log"
    "github.com/ethereum/go-ethereum/swarm/storage"
    "golang.org/x/net/context"
)

type FS struct {
    root *Dir
}

type Dir struct {
    inode       uint64
    name        string
    path        string
    directories []*Dir
    files       []*File
}

type File struct {
    inode    uint64
    name     string
    path     string
    key      storage.Key
    swarmApi *Api
    fileSize uint64
    reader   storage.LazySectionReader
}

// Functions which satisfy the Fuse File System requests
func (filesystem *FS) Root() (fs.Node, error) {
    return filesystem.root, nil
}

func (directory *Dir) Attr(ctx context.Context, a *fuse.Attr) error {
    a.Inode = directory.inode
    //TODO: need to get permission as argument
    a.Mode = os.ModeDir | 0500
    a.Uid = uint32(os.Getuid())
    a.Gid = uint32(os.Getegid())
    return nil
}

func (directory *Dir) Lookup(ctx context.Context, name string) (fs.Node, error) {
    if directory.files != nil {
        for _, n := range directory.files {
            if n.name == name {
                return n, nil
            }
        }
    }
    if directory.directories != nil {
        for _, n := range directory.directories {
            if n.name == name {
                return n, nil
            }
        }
    }
    return nil, fuse.ENOENT
}

func (d *Dir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) {
    var children []fuse.Dirent
    if d.files != nil {
        for _, file := range d.files {
            children = append(children, fuse.Dirent{Inode: file.inode, Type: fuse.DT_File, Name: file.name})
        }
    }
    if d.directories != nil {
        for _, dir := range d.directories {
            children = append(children, fuse.Dirent{Inode: dir.inode, Type: fuse.DT_Dir, Name: dir.name})
        }
    }
    return children, nil
}

func (file *File) Attr(ctx context.Context, a *fuse.Attr) error {
    a.Inode = file.inode
    //TODO: need to get permission as argument
    a.Mode = 0500
    a.Uid = uint32(os.Getuid())
    a.Gid = uint32(os.Getegid())

    reader := file.swarmApi.Retrieve(file.key)
    quitC := make(chan bool)
    size, err := reader.Size(quitC)
    if err != nil {
        log.Warn("Couldnt file size of file %s : %v", file.path, err)
        a.Size = uint64(0)
    }
    a.Size = uint64(size)
    file.fileSize = a.Size
    return nil
}

var _ = fs.HandleReader(&File{})

func (file *File) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
    buf := make([]byte, req.Size)
    reader := file.swarmApi.Retrieve(file.key)
    n, err := reader.ReadAt(buf, req.Offset)
    if err == io.ErrUnexpectedEOF || err == io.EOF {
        err = nil
    }
    resp.Data = buf[:n]
    return err
}