func setup(t *testing.T) (workdir string, cleanup func()) {
wd, _ := ioutil.TempDir("", "")
err := os.Mkdir(wd+"/mnt", 0700)
fuse.CheckSuccess(err)
err = os.Mkdir(wd+"/store", 0700)
fuse.CheckSuccess(err)
os.Mkdir(wd+"/ro", 0700)
fuse.CheckSuccess(err)
WriteFile(wd+"/ro/file1", "file1")
WriteFile(wd+"/ro/file2", "file2")
fs := NewAutoUnionFs(wd+"/store", testAOpts)
state, conn, err := fuse.MountPathFileSystem(wd+"/mnt", fs, &testAOpts.FileSystemOptions)
CheckSuccess(err)
state.Debug = fuse.VerboseTest()
conn.Debug = fuse.VerboseTest()
go state.Loop()
return wd, func() {
state.Unmount()
os.RemoveAll(wd)
}
}
func main() {
debug := flag.Bool("debug", false, "debug on")
delcache_ttl := flag.Float64("deletion_cache_ttl", 5.0, "Deletion cache TTL in seconds.")
branchcache_ttl := flag.Float64("branchcache_ttl", 5.0, "Branch cache TTL in seconds.")
deldirname := flag.String(
"deletion_dirname", "GOUNIONFS_DELETIONS", "Directory name to use for deletions.")
flag.Parse()
if len(flag.Args()) < 2 {
fmt.Println("Usage:\n main MOUNTPOINT RW-DIRECTORY RO-DIRECTORY ...")
os.Exit(2)
}
ufsOptions := unionfs.UnionFsOptions{
DeletionCacheTTLSecs: *delcache_ttl,
BranchCacheTTLSecs: *branchcache_ttl,
DeletionDirName: *deldirname,
}
ufs, err := unionfs.NewUnionFsFromRoots(flag.Args()[1:], &ufsOptions, true)
if err != nil {
log.Fatal("Cannot create UnionFs", err)
os.Exit(1)
}
mountState, _, err := fuse.MountPathFileSystem(flag.Arg(0), ufs, nil)
if err != nil {
log.Fatal("Mount fail:", err)
}
mountState.Debug = *debug
mountState.Loop()
}
func main() {
flag.Parse()
if len(flag.Args()) < 1 {
log.Fatal("Usage:\n hello MOUNTPOINT")
}
state, _, err := fuse.MountPathFileSystem(flag.Arg(0), &HelloFs{}, nil)
if err != nil {
log.Fatal("Mount fail: %v\n", err)
}
state.Loop(true)
}
func setupDevNullFs() (wd string, clean func()) {
fs := NewDevnullFs()
mountPoint := fuse.MakeTempDir()
state, _, err := fuse.MountPathFileSystem(mountPoint, fs, nil)
if err != nil {
panic(err)
}
state.Debug = true
go state.Loop(false)
return mountPoint, func() {
state.Unmount()
os.RemoveAll(mountPoint)
}
}
func setupMzfs() (mountPoint string, cleanup func()) {
fs := NewMultiZipFs()
mountPoint = fuse.MakeTempDir()
state, _, err := fuse.MountPathFileSystem(mountPoint, fs, &fuse.FileSystemOptions{
EntryTimeout: testTtl,
AttrTimeout: testTtl,
NegativeTimeout: 0.0,
})
CheckSuccess(err)
state.Debug = true
go state.Loop(true)
return mountPoint, func() {
state.Unmount()
os.RemoveAll(mountPoint)
}
}
func setupFs(fs fuse.FileSystem, opts *fuse.FileSystemOptions) (string, func()) {
mountPoint, _ := ioutil.TempDir("", "stat_test")
state, _, err := fuse.MountPathFileSystem(mountPoint, fs, opts)
if err != nil {
panic(fmt.Sprintf("cannot mount %v", err)) // ugh - benchmark has no error methods.
}
// state.Debug = true
go state.Loop()
return mountPoint, func() {
err := state.Unmount()
if err != nil {
log.Println("error during unmount", err)
} else {
os.RemoveAll(mountPoint)
}
}
}
func main() {
// Scans the arg list and sets up flags
debug := flag.Bool("debug", false, "debug on")
flag.Parse()
if flag.NArg() < 1 {
// TODO - where to get program name?
fmt.Println("usage: main MOUNTPOINT")
os.Exit(2)
}
fs := zipfs.NewMultiZipFs()
state, _, err := fuse.MountPathFileSystem(flag.Arg(0), fs, nil)
if err != nil {
fmt.Printf("Mount fail: %v\n", err)
os.Exit(1)
}
state.Debug = *debug
state.Loop()
}
func setupUfs(t *testing.T) (workdir string, cleanup func()) {
wd, _ := ioutil.TempDir("", "")
err := os.Mkdir(wd+"/mount", 0700)
fuse.CheckSuccess(err)
err = os.Mkdir(wd+"/rw", 0700)
fuse.CheckSuccess(err)
os.Mkdir(wd+"/ro", 0700)
fuse.CheckSuccess(err)
var fses []fuse.FileSystem
fses = append(fses, fuse.NewLoopbackFileSystem(wd+"/rw"))
fses = append(fses,
NewCachingFileSystem(fuse.NewLoopbackFileSystem(wd+"/ro"), 0))
ufs := NewUnionFs(fses, testOpts)
// We configure timeouts are smaller, so we can check for
// UnionFs's cache consistency.
opts := &fuse.FileSystemOptions{
EntryTimeout: .5 * entryTtl,
AttrTimeout: .5 * entryTtl,
NegativeTimeout: .5 * entryTtl,
}
state, conn, err := fuse.MountPathFileSystem(wd+"/mount", ufs, opts)
CheckSuccess(err)
conn.Debug = true
state.Debug = true
go state.Loop()
return wd, func() {
state.Unmount()
os.RemoveAll(wd)
}
}
func TestDisappearing(t *testing.T) {
// This init is like setupUfs, but we want access to the
// writable Fs.
wd, _ := ioutil.TempDir("", "")
defer os.RemoveAll(wd)
err := os.Mkdir(wd+"/mount", 0700)
fuse.CheckSuccess(err)
err = os.Mkdir(wd+"/rw", 0700)
fuse.CheckSuccess(err)
os.Mkdir(wd+"/ro", 0700)
fuse.CheckSuccess(err)
wrFs := fuse.NewLoopbackFileSystem(wd + "/rw")
var fses []fuse.FileSystem
fses = append(fses, wrFs)
fses = append(fses, fuse.NewLoopbackFileSystem(wd+"/ro"))
ufs := NewUnionFs(fses, testOpts)
opts := &fuse.FileSystemOptions{
EntryTimeout: entryTtl,
AttrTimeout: entryTtl,
NegativeTimeout: entryTtl,
}
state, _, err := fuse.MountPathFileSystem(wd+"/mount", ufs, opts)
CheckSuccess(err)
defer state.Unmount()
state.Debug = true
go state.Loop()
log.Println("TestDisappearing2")
err = ioutil.WriteFile(wd+"/ro/file", []byte("blabla"), 0644)
CheckSuccess(err)
err = os.Remove(wd + "/mount/file")
CheckSuccess(err)
oldRoot := wrFs.Root
wrFs.Root = "/dev/null"
time.Sleep(1.5 * entryTtl * 1e9)
_, err = ioutil.ReadDir(wd + "/mount")
if err == nil {
t.Fatal("Readdir should have failed")
}
log.Println("expected readdir failure:", err)
err = ioutil.WriteFile(wd+"/mount/file2", []byte("blabla"), 0644)
if err == nil {
t.Fatal("write should have failed")
}
log.Println("expected write failure:", err)
// Restore, and wait for caches to catch up.
wrFs.Root = oldRoot
time.Sleep(1.5 * entryTtl * 1e9)
_, err = ioutil.ReadDir(wd + "/mount")
if err != nil {
t.Fatal("Readdir should succeed", err)
}
err = ioutil.WriteFile(wd+"/mount/file2", []byte("blabla"), 0644)
if err != nil {
t.Fatal("write should succeed", err)
}
}
func TestRpcFS(t *testing.T) {
tmp, _ := ioutil.TempDir("", "")
defer os.RemoveAll(tmp)
mnt := tmp + "/mnt"
orig := tmp + "/orig"
srvCache := tmp + "/server-cache"
clientCache := tmp + "/client-cache"
os.Mkdir(mnt, 0700)
os.Mkdir(orig, 0700)
os.Mkdir(orig+"/subdir", 0700)
content := "hello"
err := ioutil.WriteFile(orig+"/file.txt", []byte(content), 0644)
if err != nil {
t.Fatal(err)
}
cache := NewContentCache(srvCache)
server := NewFsServer(orig, cache, []string{})
l, r, err := fuse.Socketpair("unix")
if err != nil {
t.Fatal(err)
}
defer l.Close()
defer r.Close()
rpcServer := rpc.NewServer()
rpcServer.Register(server)
go rpcServer.ServeConn(l)
rpcClient := rpc.NewClient(r)
fs := NewRpcFs(rpcClient, NewContentCache(clientCache))
state, _, err := fuse.MountPathFileSystem(mnt, fs, nil)
state.Debug = true
if err != nil {
t.Fatal("Mount", err)
}
defer func() {
log.Println("unmounting")
err := state.Unmount()
if err == nil {
os.RemoveAll(tmp)
}
}()
go state.Loop(false)
fi, err := os.Lstat(mnt + "/subdir")
if fi == nil || !fi.IsDirectory() {
t.Fatal("subdir stat", fi, err)
}
c, err := ioutil.ReadFile(mnt + "/file.txt")
if err != nil || string(c) != "hello" {
t.Error("Readfile", c)
}
entries, err := ioutil.ReadDir(mnt)
if err != nil || len(entries) != 2 {
t.Error("Readdir", err, entries)
}
// This test implementation detail - should be separate?
storedHash := server.hashCache["/file.txt"]
if storedHash == "" || string(storedHash) != string(md5str(content)) {
t.Errorf("cache error %x (%v)", storedHash, storedHash)
}
newData := []FileAttr{
FileAttr{
Path: "/file.txt",
Hash: md5str("somethingelse"),
},
}
server.updateFiles(newData)
storedHash = server.hashCache["/file.txt"]
if storedHash == "" || storedHash != newData[0].Hash {
t.Errorf("cache error %x (%v)", storedHash, storedHash)
}
}
