// Start the filesystem func Start(mounter Mounter, options StartOptions) *Error { c, err := mounter.Mount() if err != nil { return MountError(err.Error()) } defer c.Close() onInterruptFn := func() { select { case <-c.Ready: // Was mounted, so try to unmount if it was successful. if c.MountError == nil { err = mounter.Unmount() if err != nil { return } } default: // Was not mounted successfully yet, so do nothing. Note that the mount // could still happen, but that's a rare enough edge case. } } log := logger.NewWithCallDepth("", 1, os.Stderr) log.Info("KBFS version %s", libkbfs.VersionString()) config, err := libkbfs.Init(options.KbfsParams, onInterruptFn, log) if err != nil { return InitError(err.Error()) } defer libkbfs.Shutdown(options.KbfsParams.MemProfile) if options.RuntimeDir != "" { info := libkb.NewServiceInfo(libkbfs.Version, libkbfs.Build(), options.Label, os.Getpid()) err = info.WriteFile(path.Join(options.RuntimeDir, "kbfs.info")) if err != nil { return InitError(err.Error()) } } fs := NewFS(config, c, options.KbfsParams.Debug) ctx := context.WithValue(context.Background(), CtxAppIDKey, fs) logTags := make(logger.CtxLogTags) logTags[CtxIDKey] = CtxOpID ctx = logger.NewContextWithLogTags(ctx, logTags) fs.Serve(ctx) <-c.Ready err = c.MountError if err != nil { return MountError(err.Error()) } return nil }
// Init runs the Keybase services func Init(homeDir string, logFile string, runModeStr string, accessGroupOverride bool) error { fmt.Println("Go: Initializing") fmt.Printf("Go: Using log: %s\n", logFile) kbCtx = libkb.G kbCtx.Init() usage := libkb.Usage{ Config: true, API: true, KbKeyring: true, } runMode, err := libkb.StringToRunMode(runModeStr) if err != nil { return err } config := libkb.AppConfig{ HomeDir: homeDir, LogFile: logFile, RunMode: runMode, Debug: true, LocalRPCDebug: "Acsvip", SecurityAccessGroupOverride: accessGroupOverride, } err = kbCtx.Configure(config, usage) if err != nil { return err } svc := service.NewService(kbCtx, false) svc.StartLoopbackServer() kbCtx.SetService() kbCtx.SetUIRouter(service.NewUIRouter(kbCtx)) serviceLog := config.GetLogFile() logs := libkb.Logs{ Service: serviceLog, } logSendContext = libkb.LogSendContext{ Contextified: libkb.NewContextified(kbCtx), Logs: logs, } // FIXME (MBG): This is causing RPC responses to sometimes not be recieved // on iOS. Repro by hooking up getExtendedStatus to a button in the iOS // client and watching JS logs. Disabling until we have a root cause / fix. kbfsParams := libkbfs.DefaultInitParams(kbCtx) kbfsConfig, err = libkbfs.Init(kbCtx, kbfsParams, serviceCn{}, func() {}, kbCtx.Log) if err != nil { return err } return Reset() }
// Define this so deferred functions get executed before exit. func realMain() (exitStatus int) { kbfsParams := libkbfs.AddFlags(flag.CommandLine) flag.Parse() if *version { fmt.Printf("%s\n", libkbfs.VersionString()) return 0 } if len(flag.Args()) < 1 { fmt.Print(getUsageStr()) return 1 } log := logger.NewWithCallDepth("", 1) config, err := libkbfs.Init(*kbfsParams, nil, log) if err != nil { printError("kbfs", err) return 1 } defer libkbfs.Shutdown() // TODO: Make the logging level WARNING instead of INFO, or // figure out some other way to log the full folder-branch // name for kbfsfuse but not for kbfs. cmd := flag.Arg(0) args := flag.Args()[1:] ctx := context.Background() switch cmd { case "stat": return stat(ctx, config, args) case "ls": return ls(ctx, config, args) case "mkdir": return mkdir(ctx, config, args) case "read": return read(ctx, config, args) case "write": return write(ctx, config, args) default: printError("kbfs", fmt.Errorf("unknown command '%s'", cmd)) return 1 } }
// Start the filesystem func Start(mounter Mounter, options StartOptions) *libfs.Error { // InitLog errors are non-fatal and are ignored. log, _ := libkbfs.InitLog(options.KbfsParams) if options.RuntimeDir != "" { info := libkb.NewServiceInfo(libkbfs.Version, libkbfs.PrereleaseBuild, options.Label, os.Getpid()) err := info.WriteFile(path.Join(options.RuntimeDir, "kbfs.info")) if err != nil { return libfs.InitError(err.Error()) } } log.Debug("Mounting: %s", mounter.Dir()) c, err := mounter.Mount() if err != nil { return libfs.MountError(err.Error()) } defer c.Close() onInterruptFn := func() { select { case <-c.Ready: // Was mounted, so try to unmount if it was successful. if c.MountError == nil { err = mounter.Unmount() if err != nil { return } } default: // Was not mounted successfully yet, so do nothing. Note that the mount // could still happen, but that's a rare enough edge case. } } log.Debug("Initializing") config, err := libkbfs.Init(options.KbfsParams, onInterruptFn, log) if err != nil { return libfs.InitError(err.Error()) } defer libkbfs.Shutdown() log.Debug("Creating filesystem") fs := NewFS(config, c, options.KbfsParams.Debug) ctx, cancel := context.WithCancel(context.Background()) defer cancel() ctx = context.WithValue(ctx, CtxAppIDKey, fs) log.Debug("Serving filesystem") fs.Serve(ctx) <-c.Ready err = c.MountError if err != nil { return libfs.MountError(err.Error()) } log.Debug("Ending") return nil }