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