// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. See LICENSE in the project root for license information. package cache import ( "context" "errors" "os" "path/filepath" "sync" "time" "github.com/AzureAD/microsoft-authentication-extensions-for-go/cache/accessor" "github.com/AzureAD/microsoft-authentication-extensions-for-go/cache/internal/lock" "github.com/AzureAD/microsoft-authentication-library-for-go/apps/cache" ) var ( // retryDelay lets tests prevent delays when faking errors in Replace retryDelay = 10 * time.Millisecond // timeout lets tests set the default amount of time allowed to read from the accessor timeout = time.Second ) // locker helps tests fake Lock type locker interface { Lock(context.Context) error Unlock() error } // Cache caches authentication data in external storage, using a file lock to coordinate // access with other processes. type Cache struct { // a provides read/write access to storage a accessor.Accessor // data is accessor's data as of the last sync data []byte // l coordinates with other processes l locker // m coordinates this process's goroutines m *sync.Mutex // sync is when this Cache last read from or wrote to a sync time.Time // ts is the path to a file used to timestamp Export and Replace operations ts string } // New is the constructor for Cache. "p" is the path to a file used to track when stored // data changes. [Cache.Export] will create this file and any directories in its path which don't // already exist. func New(a accessor.Accessor, p string) (*Cache, error) { lock, err := lock.New(p+".lockfile", retryDelay) if err != nil { return nil, err } return &Cache{a: a, l: lock, m: &sync.Mutex{}, ts: p}, err } // Export writes the bytes marshaled by "m" to the accessor. // MSAL clients call this method automatically. func (c *Cache) Export(ctx context.Context, m cache.Marshaler, h cache.ExportHints) (err error) { c.m.Lock() defer c.m.Unlock() data, err := m.Marshal() if err != nil { return err } err = c.l.Lock(ctx) if err != nil { return err } defer func() { e := c.l.Unlock() if err == nil { err = e } }() if err = c.a.Write(ctx, data); err == nil { // touch the timestamp file to record the time of this write; discard any // error because this is just an optimization to avoid redundant reads c.sync = time.Now() if er := os.Chtimes(c.ts, c.sync, c.sync); errors.Is(er, os.ErrNotExist) { if er = os.MkdirAll(filepath.Dir(c.ts), 0700); er == nil { f, _ := os.OpenFile(c.ts, os.O_CREATE, 0600) _ = f.Close() } } c.data = data } return err } // Replace reads bytes from the accessor and unmarshals them to "u". // MSAL clients call this method automatically. func (c *Cache) Replace(ctx context.Context, u cache.Unmarshaler, h cache.ReplaceHints) error { c.m.Lock() defer c.m.Unlock() // If the timestamp file indicates cached data hasn't changed since we last read or wrote it, // return c.data, which is the data as of that time. Discard any error from reading the timestamp // because this is just an optimization to prevent unnecessary reads. If we don't know whether // cached data has changed, we assume it has. read := true data := c.data f, err := os.Stat(c.ts) if err == nil { mt := f.ModTime() read = !mt.Equal(c.sync) } if _, hasDeadline := ctx.Deadline(); !hasDeadline { var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, timeout) defer cancel() } // Unmarshal the accessor's data, reading it first if needed. We don't acquire the file lock before // reading from the accessor because it isn't strictly necessary and is relatively expensive. In the // unlikely event that a read overlaps with a write and returns malformed data, Unmarshal will return // an error and we'll try another read. for { if read { data, err = c.a.Read(ctx) if err != nil { break } } err = u.Unmarshal(data) if err == nil { break } else if !read { // c.data is apparently corrupt; Read from the accessor before trying again read = true } select { case <-ctx.Done(): return ctx.Err() case <-time.After(retryDelay): // Unmarshal error; try again } } // Update the sync time only if we read from the accessor and unmarshaled its data. Otherwise // the data hasn't changed since the last read/write, or reading failed and we'll try again on // the next call. if err == nil && read { c.data = data if f, err := os.Stat(c.ts); err == nil { c.sync = f.ModTime() } } return err } var _ cache.ExportReplace = (*Cache)(nil)