func TestNonseekable(t *testing.T) {
fs := &nonseekFs{FileSystem: pathfs.NewDefaultFileSystem()}
fs.Length = 200 * 1024
dir, err := ioutil.TempDir("", "go-fuse-cache_test")
if err != nil {
t.Fatalf("failed: %v", err)
}
defer os.RemoveAll(dir)
nfs := pathfs.NewPathNodeFs(fs, nil)
state, _, err := nodefs.MountRoot(dir, nfs.Root(), nil)
if err != nil {
t.Fatalf("failed: %v", err)
}
state.SetDebug(VerboseTest())
defer state.Unmount()
go state.Serve()
f, err := os.Open(dir + "/file")
if err != nil {
t.Fatalf("failed: %v", err)
}
defer f.Close()
b := make([]byte, 200)
n, err := f.ReadAt(b, 20)
if err == nil || n > 0 {
t.Errorf("file was opened nonseekable, but seek successful")
}
}
func NewStatFS() *StatFS {
return &StatFS{
FileSystem: pathfs.NewDefaultFileSystem(),
entries: make(map[string]*fuse.Attr),
dirs: make(map[string][]fuse.DirEntry),
}
}
// New initializes a new TagsFs that uses the given AWS client
func New(client *ec2.EC2, instanceID string) *TagsFs {
return &TagsFs{
FileSystem: pathfs.NewReadonlyFileSystem(pathfs.NewDefaultFileSystem()),
Client: client,
InstanceID: instanceID,
}
}
func main() {
if len(os.Args) != 2 {
fmt.Println("Usage: %s <mountpath>")
os.Exit(1)
}
root := os.Args[1]
hfs := &HelloFs{FileSystem: pathfs.NewDefaultFileSystem()}
nfs := pathfs.NewPathNodeFs(hfs, nil)
fuseSrv, _, err := nodefs.MountRoot(root, nfs.Root(), nil)
if err != nil {
log.Fatal(err)
}
go fuseSrv.Serve()
l, err := net.Listen("tcp", "127.0.0.1:50000")
if err != nil {
log.Fatal(err)
}
s := grpc.NewServer()
pb.RegisterPathFSServer(s, server.New(hfs))
go s.Serve(l)
log.Printf("Listen on %s for dir %s", l.Addr(), root)
sigCh := make(chan os.Signal)
signal.Notify(sigCh, os.Interrupt)
for range sigCh {
fuseSrv.Unmount()
s.Stop()
os.Exit(0)
}
}
func defaultReadTest(t *testing.T) (root string, cleanup func()) {
fs := &DefaultReadFS{
FileSystem: pathfs.NewDefaultFileSystem(),
size: 22,
}
var err error
dir, err := ioutil.TempDir("", "go-fuse")
if err != nil {
t.Fatalf("TempDir failed: %v", err)
}
pathfs := pathfs.NewPathNodeFs(fs, nil)
opts := nodefs.NewOptions()
opts.Debug = VerboseTest()
state, _, err := nodefs.MountRoot(dir, pathfs.Root(), opts)
if err != nil {
t.Fatalf("MountNodeFileSystem failed: %v", err)
}
go state.Serve()
if err := state.WaitMount(); err != nil {
t.Fatal("WaitMount", err)
}
return dir, func() {
state.Unmount()
os.Remove(dir)
}
}
func newNotifyFs() *NotifyFs {
return &NotifyFs{
FileSystem: pathfs.NewDefaultFileSystem(),
sizeChan: make(chan uint64, 1),
existChan: make(chan bool, 1),
}
}
func NewUnionFs(fileSystems []pathfs.FileSystem, options UnionFsOptions) (pathfs.FileSystem, error) {
g := &unionFS{
options: &options,
fileSystems: fileSystems,
FileSystem: pathfs.NewDefaultFileSystem(),
}
writable := g.fileSystems[0]
code := g.createDeletionStore()
if !code.Ok() {
return nil, fmt.Errorf("could not create deletion path %v: %v", options.DeletionDirName, code)
}
g.deletionCache = newDirCache(writable, options.DeletionDirName, options.DeletionCacheTTL)
g.branchCache = NewTimedCache(
func(n string) (interface{}, bool) { return g.getBranchAttrNoCache(n), true },
options.BranchCacheTTL)
g.hiddenFiles = make(map[string]bool)
for _, name := range options.HiddenFiles {
g.hiddenFiles[name] = true
}
return g, nil
}
func New(config *conf.Fuse, logger log_driver.Logger) (*GitFs, error) {
gitfsDir, err := gitfsDir(logger)
if err != nil {
return nil, err
}
defaultfs := pathfs.NewDefaultFileSystem()
gitfs := &GitFs{FileSystem: pathfs.NewReadonlyFileSystem(defaultfs), GitRepoDir: config.GitRepoDir, GitFsDir: gitfsDir, logger: logger}
fs := pathfs.NewPathNodeFs(gitfs, nil)
server, _, err := nodefs.MountRoot(gitfsDir, fs.Root(), nil)
if err != nil {
logger.Errorf("Failed to mount GitFS on %s due to %s", gitfsDir, err)
return nil, err
}
logger.Debugf("Mount GitFs on %s", gitfsDir)
gitfs.server = server
server.SetDebug(config.Debug)
gitfs.cache, err = cache.New(1024)
if err != nil {
logger.Errorf("Failed to initialize object cache due to %s\n", err)
return nil, err
}
return gitfs, nil
}
// New initializes a new MetadataFs that uses the given endpoint as the
// target of metadata requests
func New(endpoint string) *MetadataFs {
return &MetadataFs{
FileSystem: pathfs.NewReadonlyFileSystem(pathfs.NewDefaultFileSystem()),
Client: &http.Client{},
Endpoint: endpoint,
}
}
func start(dataset string, mount mount) {
ds, err := spec.GetDataset(dataset)
if err != nil {
fmt.Fprintf(os.Stderr, "Could not create dataset: %s\n", err)
return
}
hv, ok := ds.MaybeHeadValue()
if ok {
if !types.IsSubtype(fsType, hv.Type()) {
fmt.Fprintf(os.Stderr, "Invalid dataset head: expected type '%s' but found type '%s'\n", fsType.Desc.(types.StructDesc).Name, hv.Type().Desc.(types.StructDesc).Name)
return
}
} else {
rootAttr := makeAttr(0777) // create the root directory with maximally permissive permissions
rootDir := types.NewStructWithType(directoryType, types.ValueSlice{types.NewMap()})
rootInode := types.NewStructWithType(inodeType, types.ValueSlice{rootAttr, rootDir})
hv = types.NewStructWithType(fsType, types.ValueSlice{rootInode})
}
mount(&nomsFS{
FileSystem: pathfs.NewDefaultFileSystem(),
ds: ds,
head: hv.(types.Struct),
mdLock: &sync.Mutex{},
nodes: make(map[hash.Hash]*nNode),
})
}
func TestNonseekable(t *testing.T) {
fs := &nonseekFs{FileSystem: pathfs.NewDefaultFileSystem()}
fs.Length = 200 * 1024
dir := testutil.TempDir()
defer os.RemoveAll(dir)
nfs := pathfs.NewPathNodeFs(fs, nil)
opts := nodefs.NewOptions()
opts.Debug = testutil.VerboseTest()
state, _, err := nodefs.MountRoot(dir, nfs.Root(), opts)
if err != nil {
t.Fatalf("failed: %v", err)
}
defer state.Unmount()
go state.Serve()
if err := state.WaitMount(); err != nil {
t.Fatal("WaitMount", err)
}
f, err := os.Open(dir + "/file")
if err != nil {
t.Fatalf("failed: %v", err)
}
defer f.Close()
b := make([]byte, 200)
n, err := f.ReadAt(b, 20)
if err == nil || n > 0 {
t.Errorf("file was opened nonseekable, but seek successful")
}
}
func NewMultiZipFs() *MultiZipFs {
m := &MultiZipFs{
zips: make(map[string]nodefs.Node),
dirZipFileMap: make(map[string]string),
FileSystem: pathfs.NewDefaultFileSystem(),
}
return m
}
func NewDriver(basepath, etcdendpoint string) dkvolume.Driver {
e := etcDriver{
etcdbackend: etcdfs.EtcdFs{FileSystem: pathfs.NewDefaultFileSystem(), EtcdEndpoint: etcdendpoint},
mountpoints: make(map[string]*etcdFuseServer),
basePath: basepath,
}
return &e
}
// NewKeywhizFs readies a KeywhizFs struct and its parent filesystem objects.
func NewFs(client *api.Client, owner keywhizfs.Ownership) (*fs, nodefs.Node) {
defaultfs := pathfs.NewDefaultFileSystem() // Returns ENOSYS by default
readonlyfs := pathfs.NewReadonlyFileSystem(defaultfs) // R/W calls return EPERM
kwfs := &fs{readonlyfs, client, owner}
nfs := pathfs.NewPathNodeFs(kwfs, nil)
nfs.SetDebug(true)
return kwfs, nfs.Root()
}
func MountFs(path string) {
LoadSession()
CacheInit()
nfs := pathfs.NewPathNodeFs(&DropboxFs{FileSystem: pathfs.NewDefaultFileSystem()}, nil)
server, _, err := nodefs.MountRoot(path, nfs.Root(), nil)
if err != nil {
log.Fatalf("Mount fail: %v\n", err)
}
server.Serve()
}
//
//func (me *HelloFs) OpenDir(name string, context *fuse.Context) (c []fuse.DirEntry, code fuse.Status) {
// if name == "" {
// c = []fuse.DirEntry{{Name: "file.txt", Mode: fuse.S_IFREG}}
// return c, fuse.OK
// }
// return nil, fuse.ENOENT
//}
//
//func (me *HelloFs) Open(name string, flags uint32, context *fuse.Context) (file nodefs.File, code fuse.Status) {
// if name != "file.txt" {
// return nil, fuse.ENOENT
// }
// if flags&fuse.O_ANYWRITE != 0 {
// return nil, fuse.EPERM
// }
// return nodefs.NewDataFile([]byte(name)), fuse.OK
//}
//
func main() {
use_hammer2 := false
flag.Parse()
if len(flag.Args()) < 1 {
log.Fatal("Usage:\n hello MOUNTPOINT")
}
var nfs *pathfs.PathNodeFs
if use_hammer2 {
nfs = pathfs.NewPathNodeFs(&Hammer2Fs{FileSystem: pathfs.NewDefaultFileSystem()}, nil)
} else {
nfs = pathfs.NewPathNodeFs(&HammerFs{FileSystem: pathfs.NewDefaultFileSystem()}, nil)
}
fmt.Println("nfs ==", nfs)
// server, _, err := nodefs.MountFileSystem(flag.Arg(0), nfs, nil)
// if err != nil {
// log.Fatal("Mount fail: %v\n", err)
// }
// server.Serve()
}
func TestHelloWorld(t *testing.T) {
tmpSrv, err := ioutil.TempDir("", "fuse-server-")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpSrv)
hfs := &HelloFs{FileSystem: pathfs.NewDefaultFileSystem()}
hsrv, err := startServer(tmpSrv, hfs)
if err != nil {
t.Fatal(err)
}
defer hsrv.Close()
tmpCli, err := ioutil.TempDir("", "fuse-client-")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpCli)
cliFs, err := startFs(tmpCli, hsrv.addr.String())
if err != nil {
t.Fatal(err)
}
defer cliFs.Close()
fis, err := ioutil.ReadDir(tmpCli)
if err != nil {
t.Fatal(err)
}
if len(fis) != 1 {
t.Fatalf("expected to find one file, got %d", len(fis))
}
fi := fis[0]
if fi.IsDir() {
t.Fatal("should be a file, got dir")
}
if fi.Name() != "file.txt" {
t.Fatalf("file should be \"file.txt\", got %s", fi.Name())
}
f, err := os.Open(filepath.Join(tmpCli, fi.Name()))
if err != nil {
t.Fatal(err)
}
defer f.Close()
data, err := ioutil.ReadAll(f)
if err != nil {
t.Fatal(err)
}
if string(data) != "file.txt" {
t.Fatalf("file content expected to be \"file.txt\", got %s", data)
}
if f, err := os.Open("whatever"); !os.IsNotExist(err) {
if err == nil {
f.Close()
}
t.Fatalf("error from open should be not exist, got %v", err)
}
}
func NewObjectFileSystem(c *config.Config, mapper *mapper.ObjectMapper) *objectFileSystem {
fs := &objectFileSystem{
containerName: c.ContainerName,
createContainer: c.CreateContainer,
mapper: mapper,
lock: sync.Mutex{},
FileSystem: pathfs.NewDefaultFileSystem(),
}
return fs
}
// NewKeywhizFs readies a KeywhizFs struct and its parent filesystem objects.
func NewKeywhizFs(client *Client, ownership Ownership, timeouts Timeouts, logConfig log.Config) (kwfs *KeywhizFs, root nodefs.Node, err error) {
logger := log.New("kwfs", logConfig)
cache := NewCache(client, timeouts, logConfig)
defaultfs := pathfs.NewDefaultFileSystem() // Returns ENOSYS by default
readonlyfs := pathfs.NewReadonlyFileSystem(defaultfs) // R/W calls return EPERM
kwfs = &KeywhizFs{readonlyfs, logger, client, cache, time.Now(), ownership}
nfs := pathfs.NewPathNodeFs(kwfs, nil)
nfs.SetDebug(logConfig.Debug)
return kwfs, nfs.Root(), nil
}
func main() {
flag.Parse()
if len(flag.Args()) < 1 {
log.Fatal("Usage:\n hello MOUNTPOINT")
}
nfs := pathfs.NewPathNodeFs(&HelloFs{FileSystem: pathfs.NewDefaultFileSystem()}, nil)
server, _, err := nodefs.MountRoot(flag.Arg(0), nfs.Root(), nil)
if err != nil {
log.Fatalf("Mount fail: %v\n", err)
}
server.Serve()
}
func main() {
flag.Parse()
if len(flag.Args()) < 2 {
log.Fatal("Usage:\n etcd-fs MOUNTPOINT ETCDENDPOINT")
}
etcdFs := EtcdFs{FileSystem: pathfs.NewDefaultFileSystem(), EtcdEndpoint: flag.Arg(1)}
nfs := pathfs.NewPathNodeFs(&etcdFs, nil)
server, _, err := nodefs.MountRoot(flag.Arg(0), nfs.Root(), nil)
if err != nil {
log.Fatalf("Mount fail: %v\n", err)
}
server.Serve()
}
func main() {
if len(os.Args) < 3 {
log.Fatal("More Args Pls. path username")
}
gf := &GistFs{FileSystem: pathfs.NewDefaultFileSystem(), user: os.Args[2]}
nfs := pathfs.NewPathNodeFs(gf, nil)
server, _, err := nodefs.MountRoot(os.Args[1], nfs.Root(), nil)
if err != nil {
log.Fatal(err)
}
server.Serve()
}
func main() {
flag.Parse()
if len(flag.Args()) < 1 {
log.Fatal("Usage:\n ./main MOUNTPOINT")
}
cli, err := client.New(1, "localhost:15524")
if err != nil {
log.Fatalf("cannot connect to cfs server %v\n", err)
}
log.Println("Connected to server")
nfs := pathfs.NewPathNodeFs(&CFuse{FileSystem: pathfs.NewDefaultFileSystem(),
client: cli}, nil)
server, _, err := nodefs.MountRoot(flag.Arg(0), nfs.Root(), nil)
if err != nil {
log.Fatalf("Mount fail: %v\n", err)
}
server.Serve()
}
func NewAutoUnionFs(directory string, options AutoUnionFsOptions) pathfs.FileSystem {
if options.HideReadonly {
options.HiddenFiles = append(options.HiddenFiles, _READONLY)
}
a := &autoUnionFs{
knownFileSystems: make(map[string]knownFs),
nameRootMap: make(map[string]string),
options: &options,
FileSystem: pathfs.NewDefaultFileSystem(),
}
directory, err := filepath.Abs(directory)
if err != nil {
panic("filepath.Abs returned err")
}
a.root = directory
return a
}
// NewFS returns an encrypted FUSE overlay filesystem.
// In this case (reverse mode) the backing directory is plain-text and
// ReverseFS provides an encrypted view.
func NewFS(args fusefrontend.Args) *ReverseFS {
if args.CryptoBackend != cryptocore.BackendAESSIV {
log.Panic("reverse mode must use AES-SIV, everything else is insecure")
}
initLongnameCache()
cryptoCore := cryptocore.New(args.Masterkey, args.CryptoBackend, contentenc.DefaultIVBits)
contentEnc := contentenc.New(cryptoCore, contentenc.DefaultBS)
nameTransform := nametransform.New(cryptoCore, args.LongNames, args.Raw64)
return &ReverseFS{
// pathfs.defaultFileSystem returns ENOSYS for all operations
FileSystem: pathfs.NewDefaultFileSystem(),
loopbackfs: pathfs.NewLoopbackFileSystem(args.Cipherdir),
args: args,
nameTransform: nameTransform,
contentEnc: contentEnc,
inoGen: newInoGen(),
inoMap: map[fusefrontend.DevInoStruct]uint64{},
}
}
func main() {
kingpin.Parse()
// Create a client
b, err := elastic.NewClient()
Check(err)
// Found the filesystem.
nfs := pathfs.NewPathNodeFs(&ElasticFs{
Index: *cliIndex,
Backend: b,
FileSystem: pathfs.NewDefaultFileSystem(),
}, nil)
s, _, err := nodefs.MountRoot(*cliDir, nfs.Root(), nil)
if err != nil {
log.Fatalf("Mount fail: %v\n", err)
}
s.Serve()
}
func TestDataReadLarge(t *testing.T) {
fs := &FSetAttrFs{
FileSystem: pathfs.NewDefaultFileSystem(),
}
dir, clean := setupFAttrTest(t, fs)
defer clean()
content := randomData(385 * 1023)
fn := dir + "/file"
err := ioutil.WriteFile(fn, []byte(content), 0644)
if err != nil {
t.Fatalf("WriteFile failed: %v", err)
}
back, err := ioutil.ReadFile(fn)
if err != nil {
t.Fatalf("ReadFile failed: %v", err)
}
CompareSlices(t, back, content)
}
func NewRpcFs(attrClient *attr.Client, cache *cba.Store, contentConn io.ReadWriteCloser) *RpcFs {
fs := &RpcFs{
FileSystem: pathfs.NewDefaultFileSystem(),
attrClient: attrClient,
contentClient: cache.NewClient(contentConn),
timings: stats.NewTimerStats(),
}
fs.attr = attr.NewAttributeCache(
func(n string) *attr.FileAttr {
a := attr.FileAttr{}
err := attrClient.GetAttr(n, &a)
if err != nil {
log.Printf("GetAttr %s: %v", n, err)
return nil
}
return &a
}, nil)
fs.cache = cache
return fs
}
func main() {
usage := `9pmount
Usage:
9pmount <mount_point> (--address <address>)
Options:
-h --help Show this screen.
--version Show version.
--address Address of 9pserver`
args, err := docopt.Parse(usage, nil, true, "9pmount 0.1", false)
mount_point := args["<mount_point>"].(string)
address = args["<address>"].(string)
nfs := pathfs.NewPathNodeFs(&P9Fs{FileSystem: pathfs.NewDefaultFileSystem()}, nil)
server, _, err := nodefs.MountRoot(mount_point, nfs.Root(), nil)
if err != nil {
log.Fatalf("Mount fail: %v\n", err)
}
server.Serve()
}
func (p *MountFUSEFS) ServeHTTP(w http.ResponseWriter, r *http.Request) {
_, err := os.Stat(fusemount)
if err == nil {
w.WriteHeader(http.StatusOK)
w.Write([]byte("already mounted"))
return
}
err = os.Mkdir(fusemount, 0755)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("mkdir fail: " + err.Error()))
}
nfs := pathfs.NewPathNodeFs(&HelloFs{FileSystem: pathfs.NewDefaultFileSystem()}, nil)
server, _, err := nodefs.MountRoot(fusemount, nfs.Root(), nil)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("mount fail: " + err.Error()))
}
go server.Serve()
}