func TestNonexistentMountPoint(t *testing.T) {
ctx := context.Background()
// Set up a temporary directory.
dir, err := ioutil.TempDir("", "mount_test")
if err != nil {
t.Fatal("ioutil.TempDir: %v", err)
}
defer os.RemoveAll(dir)
// Attempt to mount into a sub-directory that doesn't exist.
fs := &minimalFS{}
mfs, err := fuse.Mount(
path.Join(dir, "foo"),
fuseutil.NewFileSystemServer(fs),
&fuse.MountConfig{})
if err == nil {
fuse.Unmount(mfs.Dir())
mfs.Join(ctx)
t.Fatal("fuse.Mount returned nil")
}
const want = "no such file"
if got := err.Error(); !strings.Contains(got, want) {
t.Errorf("Unexpected error: %v", got)
}
}
// Like SetUp, but doens't panic.
func (t *SampleTest) initialize(
ctx context.Context,
server fuse.Server,
config *fuse.MountConfig) (err error) {
// Initialize the context used by the test.
t.Ctx = ctx
// Make the server share that context, if the test hasn't already set some
// other one.
if config.OpContext == nil {
config.OpContext = ctx
}
// Initialize the clock.
t.Clock.SetTime(time.Date(2012, 8, 15, 22, 56, 0, 0, time.Local))
// Set up a temporary directory.
t.Dir, err = ioutil.TempDir("", "sample_test")
if err != nil {
err = fmt.Errorf("TempDir: %v", err)
return
}
// Mount the file system.
t.mfs, err = fuse.Mount(t.Dir, server, config)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
func TestSuccessfulMount(t *testing.T) {
ctx := context.Background()
// Set up a temporary directory.
dir, err := ioutil.TempDir("", "mount_test")
if err != nil {
t.Fatal("ioutil.TempDir: %v", err)
}
defer os.RemoveAll(dir)
// Mount.
fs := &minimalFS{}
mfs, err := fuse.Mount(
dir,
fuseutil.NewFileSystemServer(fs),
&fuse.MountConfig{})
if err != nil {
t.Fatalf("fuse.Mount: %v", err)
}
defer func() {
if err := mfs.Join(ctx); err != nil {
t.Errorf("Joining: %v", err)
}
}()
defer fuse.Unmount(mfs.Dir())
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
func mount(
ctx context.Context,
bucketName string,
mountPoint string,
flags *FlagStorage) (mfs *fuse.MountedFileSystem, err error) {
// Choose UID and GID.
uid, gid, err := MyUserAndGroup()
if err != nil {
err = fmt.Errorf("MyUserAndGroup: %v", err)
return
}
if int32(flags.Uid) == -1 {
flags.Uid = uid
}
if int32(flags.Gid) == -1 {
flags.Gid = gid
}
awsConfig := &aws.Config{
Region: aws.String("us-west-2"),
//LogLevel: aws.LogLevel(aws.LogDebug),
}
if len(flags.Endpoint) > 0 {
awsConfig.Endpoint = &flags.Endpoint
}
if flags.UsePathRequest {
awsConfig.S3ForcePathStyle = aws.Bool(true)
}
goofys := NewGoofys(bucketName, awsConfig, flags)
if goofys == nil {
err = fmt.Errorf("Mount: initialization failed")
return
}
server := fuseutil.NewFileSystemServer(goofys)
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: bucketName,
Options: flags.MountOptions,
ErrorLogger: log.New(os.Stderr, "fuse: ", log.Flags()),
DisableWritebackCaching: true,
}
if flags.DebugFuse {
mountCfg.DebugLogger = log.New(os.Stderr, "fuse_debug: ", 0)
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
func mount(
ctx context.Context,
bucketName string,
mountPoint string,
flags *FlagStorage) (mfs *fuse.MountedFileSystem, err error) {
awsConfig := &aws.Config{
Region: &flags.Region,
Logger: GetLogger("s3"),
//LogLevel: aws.LogLevel(aws.LogDebug),
}
if len(flags.Profile) > 0 {
awsConfig.Credentials = credentials.NewSharedCredentials("", flags.Profile)
}
if len(flags.Endpoint) > 0 {
awsConfig.Endpoint = &flags.Endpoint
}
// deprecate flags.UsePathRequest
if flags.UsePathRequest {
log.Infoln("--use-path-request is deprecated, it's always on")
}
awsConfig.S3ForcePathStyle = aws.Bool(true)
goofys := NewGoofys(bucketName, awsConfig, flags)
if goofys == nil {
err = fmt.Errorf("Mount: initialization failed")
return
}
server := fuseutil.NewFileSystemServer(goofys)
fuseLog := GetLogger("fuse")
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: bucketName,
Options: flags.MountOptions,
ErrorLogger: GetStdLogger(NewLogger("fuse"), logrus.ErrorLevel),
DisableWritebackCaching: true,
}
if flags.DebugFuse {
fuseLog.Level = logrus.DebugLevel
log.Level = logrus.DebugLevel
mountCfg.DebugLogger = GetStdLogger(fuseLog, logrus.DebugLevel)
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
func mount(
ctx context.Context,
bucketName string,
mountPoint string,
flags *flagStorage) (mfs *fuse.MountedFileSystem, err error) {
// Choose UID and GID.
uid, gid, err := MyUserAndGroup()
if err != nil {
err = fmt.Errorf("MyUserAndGroup: %v", err)
return
}
if flags.Uid >= 0 {
uid = uint32(flags.Uid)
}
if flags.Gid >= 0 {
gid = uint32(flags.Gid)
}
if err != nil {
err = fmt.Errorf("setUpBucket: %v", err)
return
}
awsConfig := &aws.Config{
Region: aws.String("us-west-2"),
//LogLevel: aws.LogLevel(aws.LogDebug),
}
server := fuseutil.NewFileSystemServer(NewGoofys(bucketName, awsConfig, uid, gid))
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: bucketName,
Options: flags.MountOptions,
ErrorLogger: log.New(os.Stderr, "fuse: ", log.Flags()),
}
if flags.DebugFuse {
mountCfg.DebugLogger = log.New(os.Stderr, "fuse_debug: ", 0)
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
func (s *GoofysTest) mount(t *C, mountPoint string) {
server := fuseutil.NewFileSystemServer(s.fs)
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: s.fs.bucket,
Options: s.fs.flags.MountOptions,
ErrorLogger: GetStdLogger(NewLogger("fuse"), logrus.ErrorLevel),
DisableWritebackCaching: true,
}
_, err := fuse.Mount(mountPoint, server, mountCfg)
t.Assert(err, IsNil)
}
func (t *TraceFS) Mount() (*fuse.MountedFileSystem, error) {
r, _ := t.newTrace(nil, "Mount", "Path=%s", t.MountPath)
defer r.Finish()
server := fuseutil.NewFileSystemServer(t)
fs, err := fuse.Mount(t.MountPath, server, t.MountConfig)
if err != nil {
r.LazyPrintf("KodingNetworkFS#Mount: err '%s'", err)
r.SetError()
return nil, err
}
return fs, nil
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
func mount(
ctx context.Context,
bucketName string,
mountPoint string,
flags *FlagStorage) (mfs *fuse.MountedFileSystem, err error) {
awsConfig := &aws.Config{
Region: aws.String("us-west-2"),
Logger: GetLogger("s3"),
//LogLevel: aws.LogLevel(aws.LogDebug),
}
if len(flags.Endpoint) > 0 {
awsConfig.Endpoint = &flags.Endpoint
}
if flags.UsePathRequest {
awsConfig.S3ForcePathStyle = aws.Bool(true)
}
goofys := NewGoofys(bucketName, awsConfig, flags)
if goofys == nil {
err = fmt.Errorf("Mount: initialization failed")
return
}
server := fuseutil.NewFileSystemServer(goofys)
fuseLog := GetLogger("fuse")
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: bucketName,
Options: flags.MountOptions,
ErrorLogger: GetStdLogger(NewLogger("fuse"), logrus.ErrorLevel),
DisableWritebackCaching: true,
}
if flags.DebugFuse {
fuseLog.Level = logrus.DebugLevel
mountCfg.DebugLogger = GetStdLogger(fuseLog, logrus.DebugLevel)
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
func main() {
flag.Parse()
// Allow parallelism in the file system implementation, to help flush out
// bugs like https://github.com/jacobsa/fuse/issues/4.
runtime.GOMAXPROCS(2)
// Grab the file to signal when ready.
readyFile, err := getReadyFile()
if err != nil {
log.Fatalf("getReadyFile:", err)
}
// Create an appropriate file system.
server, err := makeFS()
if err != nil {
log.Fatalf("makeFS: %v", err)
}
// Mount the file system.
if *fMountPoint == "" {
log.Fatalf("You must set --mount_point.")
}
cfg := &fuse.MountConfig{
ReadOnly: *fReadOnly,
}
if *fDebug {
cfg.DebugLogger = log.New(os.Stderr, "fuse: ", 0)
}
mfs, err := fuse.Mount(*fMountPoint, server, cfg)
if err != nil {
log.Fatalf("Mount: %v", err)
}
// Signal that it is ready.
_, err = readyFile.Write([]byte("x"))
if err != nil {
log.Fatalf("readyFile.Write: %v", err)
}
// Wait for it to be unmounted.
if err = mfs.Join(context.Background()); err != nil {
log.Fatalf("Join: %v", err)
}
}
func (t *fsTest) SetUp(ti *TestInfo) {
var err error
t.ctx = ti.Ctx
// Set up the clocks.
t.mtimeClock = timeutil.RealClock()
t.cacheClock.SetTime(time.Date(2015, 4, 5, 2, 15, 0, 0, time.Local))
t.serverCfg.CacheClock = &t.cacheClock
// And the bucket.
if t.bucket == nil {
t.bucket = gcsfake.NewFakeBucket(t.mtimeClock, "some_bucket")
}
t.serverCfg.Bucket = t.bucket
// Set up ownership.
t.serverCfg.Uid, t.serverCfg.Gid, err = perms.MyUserAndGroup()
AssertEq(nil, err)
// Set up permissions.
t.serverCfg.FilePerms = filePerms
t.serverCfg.DirPerms = dirPerms
// Set up the append optimization.
t.serverCfg.AppendThreshold = 0
t.serverCfg.TmpObjectPrefix = ".gcsfuse_tmp/"
// Set up a temporary directory for mounting.
t.Dir, err = ioutil.TempDir("", "fs_test")
AssertEq(nil, err)
// Create a file system server.
server, err := fs.NewServer(&t.serverCfg)
AssertEq(nil, err)
// Mount the file system.
mountCfg := t.mountCfg
mountCfg.OpContext = t.ctx
if *fDebug {
mountCfg.DebugLogger = log.New(os.Stderr, "fuse: ", 0)
}
t.mfs, err = fuse.Mount(t.Dir, server, &mountCfg)
AssertEq(nil, err)
}
func (t *fsTest) SetUp(ti *TestInfo) {
var err error
t.ctx = ti.Ctx
// Set up the clock.
t.clock.SetTime(time.Date(2015, 4, 5, 2, 15, 0, 0, time.Local))
t.serverCfg.Clock = &t.clock
// And the bucket.
if t.bucket == nil {
t.bucket = gcsfake.NewFakeBucket(&t.clock, "some_bucket")
}
t.serverCfg.Bucket = t.bucket
// Set up ownership.
t.serverCfg.Uid, t.serverCfg.Gid, err = perms.MyUserAndGroup()
AssertEq(nil, err)
// Set up permissions.
t.serverCfg.FilePerms = filePerms
t.serverCfg.DirPerms = dirPerms
// Use some temporary space to speed tests.
t.serverCfg.TempDirLimitNumFiles = 16
t.serverCfg.TempDirLimitBytes = 1 << 22 // 4 MiB
// Set up the append optimization.
t.serverCfg.AppendThreshold = 0
t.serverCfg.TmpObjectPrefix = ".gcsfuse_tmp/"
// Set up a temporary directory for mounting.
t.Dir, err = ioutil.TempDir("", "fs_test")
AssertEq(nil, err)
// Create a file system server.
server, err := fs.NewServer(&t.serverCfg)
AssertEq(nil, err)
// Mount the file system.
mountCfg := t.mountCfg
mountCfg.OpContext = t.ctx
t.mfs, err = fuse.Mount(t.Dir, server, &mountCfg)
AssertEq(nil, err)
}
func TestNonEmptyMountPoint(t *testing.T) {
ctx := context.Background()
// osxfuse appears to be happy to mount over a non-empty mount point.
//
// We leave this test in for Linux, because it tickles the behavior of
// fusermount writing to stderr and exiting with an error code. We want to
// make sure that a descriptive error makes it back to the user.
if runtime.GOOS == "darwin" {
return
}
// Set up a temporary directory.
dir, err := ioutil.TempDir("", "mount_test")
if err != nil {
t.Fatal("ioutil.TempDir: %v", err)
}
defer os.RemoveAll(dir)
// Add a file within it.
err = ioutil.WriteFile(path.Join(dir, "foo"), []byte{}, 0600)
if err != nil {
t.Fatalf("ioutil.WriteFile: %v", err)
}
// Attempt to mount.
fs := &minimalFS{}
mfs, err := fuse.Mount(
dir,
fuseutil.NewFileSystemServer(fs),
&fuse.MountConfig{})
if err == nil {
fuse.Unmount(mfs.Dir())
mfs.Join(ctx)
t.Fatal("fuse.Mount returned nil")
}
const want = "not empty"
if got := err.Error(); !strings.Contains(got, want) {
t.Errorf("Unexpected error: %v", got)
}
}
func (s *GoofysTest) runFuseTest(t *C, mountPoint string, umount bool, cmdArgs ...string) {
server := fuseutil.NewFileSystemServer(s.fs)
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: s.fs.bucket,
Options: s.fs.flags.MountOptions,
ErrorLogger: GetStdLogger(NewLogger("fuse"), logrus.ErrorLevel),
DisableWritebackCaching: true,
}
_, err := fuse.Mount(mountPoint, server, mountCfg)
t.Assert(err, IsNil)
if umount {
defer func() {
err := fuse.Unmount(mountPoint)
t.Assert(err, IsNil)
}()
}
cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
cmd.Env = append(cmd.Env, os.Environ()...)
cmd.Env = append(cmd.Env, "TRAVIS=true")
cmd.Env = append(cmd.Env, "FAST=true")
if isTravis() {
logger := NewLogger("test")
lvl := logrus.InfoLevel
logger.Formatter.(*logHandle).lvl = &lvl
w := logger.Writer()
cmd.Stdout = w
cmd.Stderr = w
}
err = cmd.Run()
t.Assert(err, IsNil)
}
func MakeDirDeviceNotConfigured(p string) error {
niFs := &NotImplementedFileSystem{&fuseutil.NotImplementedFileSystem{}}
config := &fuse.MountConfig{}
server := fuseutil.NewFileSystemServer(niFs)
f, err := fuse.Mount(p, server, config)
if err != nil {
return err
}
go f.Join(context.TODO())
// Sleep to give to mount time to execute.
time.Sleep(100 * time.Millisecond)
// Reading from it will cause the fs to crash, like we want.
if _, err = ioutil.ReadDir(p); err == nil {
// ReadDir should error with the panic from niFs.ReadDir, if it doesn't, return
// an error.
return errors.New("Expected ReadDir op to fail, but it did not.")
}
return nil
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
func mount(
ctx context.Context,
bucketName string,
mountPoint string,
flags *FlagStorage) (mfs *fuse.MountedFileSystem, err error) {
ossvfs := NewOssvfs(bucketName, flags)
if ossvfs == nil {
err = fmt.Errorf("Mount: initialization failed")
return
}
server := fuseutil.NewFileSystemServer(ossvfs)
fuseLog := GetLogger("fuse")
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: bucketName,
Options: flags.MountOptions,
ErrorLogger: GetStdLogger(NewLogger("fuse"), logrus.ErrorLevel),
DisableWritebackCaching: true,
}
if flags.DebugFuse {
fuseLog.Level = logrus.DebugLevel
mountCfg.DebugLogger = GetStdLogger(fuseLog, logrus.DebugLevel)
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
func mountWithConn(
ctx context.Context,
bucketName string,
mountPoint string,
flags *flagStorage,
conn gcs.Conn,
status *log.Logger) (mfs *fuse.MountedFileSystem, err error) {
// Sanity check: make sure the temporary directory exists and is writable
// currently. This gives a better user experience than harder to debug EIO
// errors when reading files in the future.
if flags.TempDir != "" {
var f *os.File
f, err = fsutil.AnonymousFile(flags.TempDir)
f.Close()
if err != nil {
err = fmt.Errorf(
"Error writing to temporary directory (%q); are you sure it exists "+
"with the correct permissions?",
err.Error())
return
}
}
// Find the current process's UID and GID. If it was invoked as root and the
// user hasn't explicitly overridden --uid, everything is going to be owned
// by root. This is probably not what the user wants, so print a warning.
uid, gid, err := perms.MyUserAndGroup()
if err != nil {
err = fmt.Errorf("MyUserAndGroup: %v", err)
return
}
if uid == 0 && flags.Uid < 0 {
fmt.Fprintln(os.Stderr, `
WARNING: gcsfuse invoked as root. This will cause all files to be owned by
root. If this is not what you intended, invoke gcsfuse as the user that will
be interacting with the file system.
`)
}
// Choose UID and GID.
if flags.Uid >= 0 {
uid = uint32(flags.Uid)
}
if flags.Gid >= 0 {
gid = uint32(flags.Gid)
}
// Set up the bucket.
status.Println("Opening bucket...")
bucket, err := setUpBucket(
ctx,
flags,
conn,
bucketName)
if err != nil {
err = fmt.Errorf("setUpBucket: %v", err)
return
}
// Create a file system server.
serverCfg := &fs.ServerConfig{
CacheClock: timeutil.RealClock(),
Bucket: bucket,
TempDir: flags.TempDir,
ImplicitDirectories: flags.ImplicitDirs,
InodeAttributeCacheTTL: flags.StatCacheTTL,
DirTypeCacheTTL: flags.TypeCacheTTL,
Uid: uid,
Gid: gid,
FilePerms: os.FileMode(flags.FileMode),
DirPerms: os.FileMode(flags.DirMode),
AppendThreshold: 1 << 21, // 2 MiB, a total guess.
TmpObjectPrefix: ".gcsfuse_tmp/",
}
server, err := fs.NewServer(serverCfg)
if err != nil {
err = fmt.Errorf("fs.NewServer: %v", err)
return
}
// Mount the file system.
status.Println("Mounting file system...")
mountCfg := &fuse.MountConfig{
FSName: bucket.Name(),
VolumeName: bucket.Name(),
Options: flags.MountOptions,
ErrorLogger: log.New(os.Stderr, "fuse: ", log.Flags()),
}
if flags.DebugFuse {
mountCfg.DebugLogger = log.New(os.Stderr, "fuse_debug: ", 0)
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
//
// In main, set flagSet to flag.CommandLine and pass in os.Args[1:]. In a test,
// pass in a virgin flag set and test arguments.
//
// Promises to pass on flag.ErrHelp from FlagSet.Parse.
func mount(
ctx context.Context,
args []string,
flagSet *flag.FlagSet,
conn gcs.Conn) (mfs *fuse.MountedFileSystem, err error) {
// Populate and parse flags.
flags := populateFlagSet(flagSet)
err = flagSet.Parse(args)
if err != nil {
// Special case: don't mangle ErrHelp.
if err != flag.ErrHelp {
err = fmt.Errorf("Parsing flags: %v", err)
}
return
}
// Extract positional arguments.
if flagSet.NArg() != 2 {
flagSet.Usage()
err = errors.New("Incorrect usage")
return
}
bucketName := flagSet.Arg(0)
mountPoint := flagSet.Arg(1)
// Sanity check: make sure the temporary directory exists and is writable
// currently. This gives a better user experience than harder to debug EIO
// errors when reading files in the future.
if flags.TempDir != "" {
var f *os.File
f, err = fsutil.AnonymousFile(flags.TempDir)
f.Close()
if err != nil {
err = fmt.Errorf(
"Error writing to temporary directory (%q); are you sure it exists "+
"with the correct permissions?",
err.Error())
return
}
}
// The file leaser used by the file system sizes its limit on number of
// temporary files based on the process's rlimit. If this is too low, we'll
// throw away cached content unnecessarily often. This is particularly a
// problem on OS X, which has a crazy low default limit (256 as of OS X
// 10.10.3). So print a warning if the limit is low.
var rlimit unix.Rlimit
if err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rlimit); err == nil {
const reasonableLimit = 4096
if rlimit.Cur < reasonableLimit {
log.Printf(
"Warning: low file rlimit of %d will cause cached content to be "+
"frequently evicted. Consider raising with `ulimit -n`.",
rlimit.Cur)
}
}
// Choose UID and GID.
uid, gid, err := perms.MyUserAndGroup()
if err != nil {
err = fmt.Errorf("MyUserAndGroup: %v", err)
return
}
if flags.Uid >= 0 {
uid = uint32(flags.Uid)
}
if flags.Gid >= 0 {
gid = uint32(flags.Gid)
}
// Set up the bucket.
bucket, err := setUpBucket(
ctx,
flags,
conn,
bucketName)
if err != nil {
err = fmt.Errorf("setUpBucket: %v", err)
return
}
// Create a file system server.
serverCfg := &fs.ServerConfig{
Clock: timeutil.RealClock(),
Bucket: bucket,
TempDir: flags.TempDir,
TempDirLimitNumFiles: fs.ChooseTempDirLimitNumFiles(),
TempDirLimitBytes: flags.TempDirLimit,
GCSChunkSize: flags.GCSChunkSize,
ImplicitDirectories: flags.ImplicitDirs,
DirTypeCacheTTL: flags.TypeCacheTTL,
Uid: uid,
Gid: gid,
FilePerms: os.FileMode(flags.FileMode),
DirPerms: os.FileMode(flags.DirMode),
AppendThreshold: 1 << 21, // 2 MiB, a total guess.
TmpObjectPrefix: ".gcsfuse_tmp/",
}
server, err := fs.NewServer(serverCfg)
if err != nil {
err = fmt.Errorf("fs.NewServer: %v", err)
return
}
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: bucket.Name(),
Options: flags.MountOptions,
ErrorLogger: log.New(os.Stderr, "fuse: ", log.Flags()),
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
// Mount mounts an specified folder on user VM using Fuse in the specificed
// local path.
func (k *KodingNetworkFS) Mount() (*fuse.MountedFileSystem, error) {
server := fuseutil.NewFileSystemServer(k)
return fuse.Mount(k.MountPath, server, k.MountConfig)
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
func mount(
ctx context.Context,
bucketName string,
mountPoint string,
flags *flagStorage,
conn gcs.Conn) (mfs *fuse.MountedFileSystem, err error) {
// Sanity check: make sure the temporary directory exists and is writable
// currently. This gives a better user experience than harder to debug EIO
// errors when reading files in the future.
if flags.TempDir != "" {
var f *os.File
f, err = fsutil.AnonymousFile(flags.TempDir)
f.Close()
if err != nil {
err = fmt.Errorf(
"Error writing to temporary directory (%q); are you sure it exists "+
"with the correct permissions?",
err.Error())
return
}
}
// Choose UID and GID.
uid, gid, err := perms.MyUserAndGroup()
if err != nil {
err = fmt.Errorf("MyUserAndGroup: %v", err)
return
}
if flags.Uid >= 0 {
uid = uint32(flags.Uid)
}
if flags.Gid >= 0 {
gid = uint32(flags.Gid)
}
// Set up the bucket.
bucket, err := setUpBucket(
ctx,
flags,
conn,
bucketName)
if err != nil {
err = fmt.Errorf("setUpBucket: %v", err)
return
}
// Create a file system server.
serverCfg := &fs.ServerConfig{
CacheClock: timeutil.RealClock(),
Bucket: bucket,
TempDir: flags.TempDir,
ImplicitDirectories: flags.ImplicitDirs,
InodeAttributeCacheTTL: flags.StatCacheTTL,
DirTypeCacheTTL: flags.TypeCacheTTL,
Uid: uid,
Gid: gid,
FilePerms: os.FileMode(flags.FileMode),
DirPerms: os.FileMode(flags.DirMode),
AppendThreshold: 1 << 21, // 2 MiB, a total guess.
TmpObjectPrefix: ".gcsfuse_tmp/",
}
server, err := fs.NewServer(serverCfg)
if err != nil {
err = fmt.Errorf("fs.NewServer: %v", err)
return
}
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: bucket.Name(),
Options: flags.MountOptions,
ErrorLogger: log.New(os.Stderr, "fuse: ", log.Flags()),
}
if flags.DebugFuse {
mountCfg.DebugLogger = log.New(os.Stderr, "fuse_debug: ", 0)
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}