dotcloud/docker

package safepath

import (
    "context"
    "fmt"
    "sync"

    "github.com/containerd/log"
)

type SafePath struct {
    path    string
    cleanup func(ctx context.Context) error
    mutex   sync.Mutex

    // Immutable fields
    sourceBase, sourceSubpath string
}

// Close releases the resources used by the path.
func (s *SafePath) Close(ctx context.Context) error {
    s.mutex.Lock()
    defer s.mutex.Unlock()

    if s.path == "" {
        base, sub := s.SourcePath()
        log.G(ctx).WithFields(log.Fields{
            "path":          s.Path(),
            "sourceBase":    base,
            "sourceSubpath": sub,
        }).Warn("an attempt to close an already closed SafePath")
        return nil
    }

    s.path = ""
    if s.cleanup != nil {
        return s.cleanup(ctx)
    }
    return nil
}

// IsValid return true when path can still be used and wasn't cleaned up by Close.
func (s *SafePath) IsValid() bool {
    s.mutex.Lock()
    defer s.mutex.Unlock()
    return s.path != ""
}

// Path returns a safe, temporary path that can be used to access the original path.
func (s *SafePath) Path() string {
    s.mutex.Lock()
    defer s.mutex.Unlock()
    if s.path == "" {
        panic(fmt.Sprintf("use-after-close attempted for safepath with source [%s, %s]", s.sourceBase, s.sourceSubpath))
    }
    return s.path
}

// SourcePath returns the source path the safepath points to.
func (s *SafePath) SourcePath() (string, string) {
    // No mutex lock because these are immutable.
    return s.sourceBase, s.sourceSubpath
}