// TODO(rh): tame copy/paste code from cammount func main() { client.AddFlags() flag.Parse() cacheDir, err := ioutil.TempDir("", "camlicache") if err != nil { log.Fatalf("Error creating temp cache directory: %v", err) } defer os.RemoveAll(cacheDir) diskcache, err := localdisk.New(cacheDir) if err != nil { log.Fatalf("Error setting up local disk cache: %v", err) } if flag.NArg() != 1 { log.Fatal("usage: camwebdav <blobref>") } br := blobref.Parse(flag.Arg(0)) if br == nil { log.Fatalf("%s was not a valid blobref.", flag.Arg(0)) } client := client.NewOrFail() fetcher := cacher.NewCachingFetcher(diskcache, client) f = fs.NewCamliFileSystem(fetcher, br) http.HandleFunc("/", webdav) err = http.ListenAndServe(*davaddr, nil) if err != nil { log.Fatalf("Error starting WebDAV server: %v", err) } }
func main() { // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") client.AddFlags() flag.Parse() errorf := func(msg string, args ...interface{}) { fmt.Fprintf(os.Stderr, msg, args...) os.Exit(2) } if n := flag.NArg(); n < 1 || n > 2 { errorf("usage: cammount <mountpoint> [<root-blobref>]\n") } mountPoint := flag.Arg(0) client := client.NewOrFail() // automatic from flags cacheDir, err := ioutil.TempDir("", "camlicache") if err != nil { errorf("Error creating temp cache directory: %v\n", err) } defer os.RemoveAll(cacheDir) diskcache, err := localdisk.New(cacheDir) if err != nil { errorf("Error setting up local disk cache: %v", err) } fetcher := cacher.NewCachingFetcher(diskcache, client) var camfs *fs.CamliFileSystem if flag.NArg() == 2 { root := blobref.Parse(flag.Arg(1)) if root == nil { errorf("Error parsing root blobref: %q\n", root) } var err error camfs, err = fs.NewRootedCamliFileSystem(fetcher, root) if err != nil { errorf("Error creating root with %v: %v", root, err) } } else { camfs = fs.NewCamliFileSystem(fetcher) log.Printf("starting with fs %#v", camfs) } if *debug { // TODO: set fs's logger } conn, err := fuse.Mount(mountPoint) if err != nil { log.Fatalf("Mount: %v", err) } err = conn.Serve(camfs) if err != nil { log.Fatalf("Serve: %v", err) } log.Printf("fuse process ending.") }
func main() { var conn *fuse.Conn // Scans the arg list and sets up flags client.AddFlags() flag.Parse() narg := flag.NArg() if narg > 2 { usage() } var mountPoint string var err error if narg > 0 { mountPoint = flag.Arg(0) } else { mountPoint, err = ioutil.TempDir("", "cammount") if err != nil { log.Fatal(err) } defer os.Remove(mountPoint) } errorf := func(msg string, args ...interface{}) { fmt.Fprintf(os.Stderr, msg, args...) fmt.Fprint(os.Stderr, "\n") usage() } var ( cl *client.Client root blob.Ref // nil if only one arg camfs *fs.CamliFileSystem ) if narg == 2 { rootArg := flag.Arg(1) // not trying very hard since NewFromShareRoot will do it better with a regex if strings.HasPrefix(rootArg, "http://") || strings.HasPrefix(rootArg, "https://") { if client.ExplicitServer() != "" { errorf("Can't use an explicit blobserver with a share URL; the blobserver is implicit from the share URL.") } var err error cl, root, err = client.NewFromShareRoot(rootArg) if err != nil { log.Fatal(err) } } else { cl = client.NewOrFail() // automatic from flags var ok bool root, ok = blob.Parse(rootArg) if !ok { log.Fatalf("Error parsing root blobref: %q\n", rootArg) } cl.SetHTTPClient(&http.Client{Transport: cl.TransportForConfig(nil)}) } } else { cl = client.NewOrFail() // automatic from flags cl.SetHTTPClient(&http.Client{Transport: cl.TransportForConfig(nil)}) } diskCacheFetcher, err := cacher.NewDiskCache(cl) if err != nil { log.Fatalf("Error setting up local disk cache: %v", err) } defer diskCacheFetcher.Clean() if root.Valid() { var err error camfs, err = fs.NewRootedCamliFileSystem(diskCacheFetcher, root) if err != nil { log.Fatalf("Error creating root with %v: %v", root, err) } } else { camfs = fs.NewCamliFileSystem(cl, diskCacheFetcher) } if *debug { fuse.Debugf = log.Printf // TODO: set fs's logger } // This doesn't appear to work on OS X: sigc := make(chan os.Signal, 1) conn, err = fuse.Mount(mountPoint) if err != nil { if err.Error() == "cannot find load_fusefs" && runtime.GOOS == "darwin" { log.Fatal("FUSE not available; install from http://osxfuse.github.io/") } log.Fatalf("Mount: %v", err) } xtermDone := make(chan bool, 1) if *xterm { cmd := exec.Command("xterm") cmd.Dir = mountPoint if err := cmd.Start(); err != nil { log.Printf("Error starting xterm: %v", err) } else { go func() { cmd.Wait() xtermDone <- true }() defer cmd.Process.Kill() } } if *open { if runtime.GOOS == "darwin" { cmd := exec.Command("open", mountPoint) go cmd.Run() } } signal.Notify(sigc, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT) doneServe := make(chan error, 1) go func() { doneServe <- conn.Serve(camfs) }() quitKey := make(chan bool, 1) go awaitQuitKey(quitKey) select { case err := <-doneServe: log.Printf("conn.Serve returned %v", err) case sig := <-sigc: log.Printf("Signal %s received, shutting down.", sig) case <-quitKey: log.Printf("Quit key pressed. Shutting down.") case <-xtermDone: log.Printf("xterm done") } time.AfterFunc(2*time.Second, func() { os.Exit(1) }) log.Printf("Unmounting...") err = fs.Unmount(mountPoint) log.Printf("Unmount = %v", err) log.Printf("cammount FUSE process ending.") }
func main() { // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") client.AddFlags() flag.Parse() errorf := func(msg string, args ...interface{}) { fmt.Fprintf(os.Stderr, msg, args...) fmt.Fprint(os.Stderr, "\n") usage() } nargs := flag.NArg() if nargs < 1 || nargs > 2 { usage() } mountPoint := flag.Arg(0) var ( cl *client.Client root *blobref.BlobRef // nil if only one arg camfs *fs.CamliFileSystem ) if nargs == 2 { rootArg := flag.Arg(1) // not trying very hard since NewFromShareRoot will do it better with a regex if strings.HasPrefix(rootArg, "http://") || strings.HasPrefix(rootArg, "https://") { if client.ExplicitServer() != "" { errorf("Can't use an explicit blobserver with a share URL; the blobserver is implicit from the share URL.") } var err error cl, root, err = client.NewFromShareRoot(rootArg) if err != nil { log.Fatal(err) } } else { cl = client.NewOrFail() // automatic from flags root = blobref.Parse(rootArg) if root == nil { log.Fatalf("Error parsing root blobref: %q\n", rootArg) } cl.SetHTTPClient(&http.Client{Transport: cl.TransportForConfig(nil)}) } } else { cl = client.NewOrFail() // automatic from flags cl.SetHTTPClient(&http.Client{Transport: cl.TransportForConfig(nil)}) } diskCacheFetcher, err := cacher.NewDiskCache(cl) if err != nil { log.Fatalf("Error setting up local disk cache: %v", err) } defer diskCacheFetcher.Clean() if root != nil { var err error camfs, err = fs.NewRootedCamliFileSystem(diskCacheFetcher, root) if err != nil { log.Fatalf("Error creating root with %v: %v", root, err) } } else { camfs = fs.NewCamliFileSystem(cl, diskCacheFetcher) log.Printf("starting with fs %#v", camfs) } if *debug { // TODO: set fs's logger } // This doesn't appear to work on OS X: sigc := make(chan os.Signal, 1) go func() { log.Fatalf("Signal %s received, shutting down.", <-sigc) }() signal.Notify(sigc, syscall.SIGQUIT, syscall.SIGTERM) conn, err := fuse.Mount(mountPoint) if err != nil { log.Fatalf("Mount: %v", err) } err = conn.Serve(camfs) if err != nil { log.Fatalf("Serve: %v", err) } log.Printf("fuse process ending.") }
func main() { // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") client.AddFlags() flag.Parse() errorf := func(msg string, args ...interface{}) { fmt.Fprintf(os.Stderr, msg, args...) os.Exit(2) } if n := flag.NArg(); n < 1 || n > 2 { errorf("usage: cammount <mountpoint> [<root-blobref>]\n") } mountPoint := flag.Arg(0) client := client.NewOrFail() // automatic from flags diskCacheFetcher, err := cacher.NewDiskCache(client) if err != nil { errorf("Error setting up local disk cache: %v", err) } defer diskCacheFetcher.Clean() var camfs *fs.CamliFileSystem if flag.NArg() == 2 { root := blobref.Parse(flag.Arg(1)) if root == nil { errorf("Error parsing root blobref: %q\n", root) } var err error camfs, err = fs.NewRootedCamliFileSystem(diskCacheFetcher, root) if err != nil { errorf("Error creating root with %v: %v", root, err) } } else { camfs = fs.NewCamliFileSystem(client, diskCacheFetcher) log.Printf("starting with fs %#v", camfs) } if *debug { // TODO: set fs's logger } // This doesn't appear to work on OS X: sigc := make(chan os.Signal, 1) go func() { log.Fatalf("Signal %s received, shutting down.", <-sigc) }() signal.Notify(sigc, syscall.SIGQUIT, syscall.SIGTERM) conn, err := fuse.Mount(mountPoint) if err != nil { log.Fatalf("Mount: %v", err) } err = conn.Serve(camfs) if err != nil { log.Fatalf("Serve: %v", err) } log.Printf("fuse process ending.") }