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)
}
// 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
}