func (md *MDServerRemote) backgroundRekeyChecker(ctx context.Context) { for { select { case <-md.rekeyTimer.C: if !md.conn.IsConnected() { md.rekeyTimer.Reset(MdServerBackgroundRekeyPeriod) continue } // Assign an ID to this rekey check so we can track it. logTags := make(logger.CtxLogTags) logTags[CtxMDSRIDKey] = CtxMDSROpID newCtx := logger.NewContextWithLogTags(ctx, logTags) id, err := MakeRandomRequestID() if err != nil { md.log.CWarningf(ctx, "Couldn't generate a random request ID: %v", err) } else { newCtx = context.WithValue(newCtx, CtxMDSRIDKey, id) } md.log.CDebugf(newCtx, "Checking for rekey folders") if err := md.getFoldersForRekey(newCtx, md.client); err != nil { md.log.CWarningf(newCtx, "MDServerRemote: getFoldersForRekey "+ "failed with %v", err) } md.rekeyTimer.Reset(MdServerBackgroundRekeyPeriod) case <-ctx.Done(): return } } }
// WithContext adds app- and request-specific values to the context. // It is called by FUSE for normal runs, but may be called explicitly // in other settings, such as tests. func (f *FS) WithContext(ctx context.Context) context.Context { ctx = context.WithValue(ctx, CtxAppIDKey, f) logTags := make(logger.CtxLogTags) logTags[CtxIDKey] = CtxOpID ctx = logger.NewContextWithLogTags(ctx, logTags) // Add a unique ID to this context, identifying a particular // request. id, err := libkbfs.MakeRandomRequestID() if err != nil { f.log.Errorf("Couldn't make request ID: %v", err) } else { ctx = context.WithValue(ctx, CtxIDKey, id) } if runtime.GOOS == "darwin" { // Timeout operations before they hit the osxfuse time limit, // so we don't hose the entire mount (Fixed in OSXFUSE 3.2.0). // The timeout is 60 seconds, but it looks like sometimes it // tries multiple attempts within that 60 seconds, so let's go // a little under 60/3 to be safe. // // It should be safe to ignore the CancelFunc here because our // parent context will be canceled by the FUSE serve loop. ctx, _ = context.WithTimeout(ctx, 19*time.Second) } return ctx }
// 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 }
func ctxWithRandomID(ctx context.Context, tagKey interface{}, tagName string, log logger.Logger) context.Context { // Tag each request with a unique ID logTags := make(logger.CtxLogTags) logTags[tagKey] = tagName newCtx := logger.NewContextWithLogTags(ctx, logTags) id, err := MakeRandomRequestID() if err != nil { if log != nil { log.Warning("Couldn't generate a random request ID: %v", err) } } else { newCtx = context.WithValue(newCtx, tagKey, id) } return newCtx }
// Dedicated goroutine to process the rekey queue. func (rkq *RekeyQueueStandard) processRekeys(ctx context.Context, hasWorkCh chan struct{}) { for { select { case <-hasWorkCh: for { id := func() TlfID { rkq.queueMu.Lock() defer rkq.queueMu.Unlock() for first := range rkq.queue { return first } return NullTlfID }() if id == NullTlfID { break } // Assign an ID to this rekey operation so we can track it. logTags := make(logger.CtxLogTags) logTags[CtxRekeyIDKey] = CtxRekeyOpID newCtx := logger.NewContextWithLogTags(ctx, logTags) ctxID, err := MakeRandomRequestID() if err == nil { newCtx = context.WithValue(newCtx, CtxRekeyIDKey, ctxID) } err = rkq.config.KBFSOps().Rekey(newCtx, id) rkq.dequeue(id, err) if ctx.Err() != nil { close(hasWorkCh) return } } case <-ctx.Done(): close(hasWorkCh) return } } }