| package graphdriver |
| |
| import ( |
| "errors" |
| "fmt" |
| "io" |
| "os" |
| "path/filepath" |
| "strings" |
| |
| "github.com/sirupsen/logrus" |
| "github.com/vbatts/tar-split/tar/storage" |
| |
| "github.com/docker/docker/pkg/archive" |
| "github.com/docker/docker/pkg/containerfs" |
| "github.com/docker/docker/pkg/idtools" |
| "github.com/docker/docker/pkg/plugingetter" |
| ) |
| |
| // FsMagic unsigned id of the filesystem in use. |
| type FsMagic uint32 |
| |
| const ( |
| // FsMagicUnsupported is a predefined constant value other than a valid filesystem id. |
| FsMagicUnsupported = FsMagic(0x00000000) |
| ) |
| |
| var ( |
| // All registered drivers |
| drivers map[string]InitFunc |
| |
| // ErrNotSupported returned when driver is not supported. |
| ErrNotSupported = errors.New("driver not supported") |
| // ErrPrerequisites returned when driver does not meet prerequisites. |
| ErrPrerequisites = errors.New("prerequisites for driver not satisfied (wrong filesystem?)") |
| // ErrIncompatibleFS returned when file system is not supported. |
| ErrIncompatibleFS = fmt.Errorf("backing file system is unsupported for this graph driver") |
| ) |
| |
| //CreateOpts contains optional arguments for Create() and CreateReadWrite() |
| // methods. |
| type CreateOpts struct { |
| MountLabel string |
| StorageOpt map[string]string |
| } |
| |
| // InitFunc initializes the storage driver. |
| type InitFunc func(root string, options []string, uidMaps, gidMaps []idtools.IDMap) (Driver, error) |
| |
| // ProtoDriver defines the basic capabilities of a driver. |
| // This interface exists solely to be a minimum set of methods |
| // for client code which choose not to implement the entire Driver |
| // interface and use the NaiveDiffDriver wrapper constructor. |
| // |
| // Use of ProtoDriver directly by client code is not recommended. |
| type ProtoDriver interface { |
| // String returns a string representation of this driver. |
| String() string |
| // CreateReadWrite creates a new, empty filesystem layer that is ready |
| // to be used as the storage for a container. Additional options can |
| // be passed in opts. parent may be "" and opts may be nil. |
| CreateReadWrite(id, parent string, opts *CreateOpts) error |
| // Create creates a new, empty, filesystem layer with the |
| // specified id and parent and options passed in opts. Parent |
| // may be "" and opts may be nil. |
| Create(id, parent string, opts *CreateOpts) error |
| // Remove attempts to remove the filesystem layer with this id. |
| Remove(id string) error |
| // Get returns the mountpoint for the layered filesystem referred |
| // to by this id. You can optionally specify a mountLabel or "". |
| // Returns the absolute path to the mounted layered filesystem. |
| Get(id, mountLabel string) (fs containerfs.ContainerFS, err error) |
| // Put releases the system resources for the specified id, |
| // e.g, unmounting layered filesystem. |
| Put(id string) error |
| // Exists returns whether a filesystem layer with the specified |
| // ID exists on this driver. |
| Exists(id string) bool |
| // Status returns a set of key-value pairs which give low |
| // level diagnostic status about this driver. |
| Status() [][2]string |
| // Returns a set of key-value pairs which give low level information |
| // about the image/container driver is managing. |
| GetMetadata(id string) (map[string]string, error) |
| // Cleanup performs necessary tasks to release resources |
| // held by the driver, e.g., unmounting all layered filesystems |
| // known to this driver. |
| Cleanup() error |
| } |
| |
| // DiffDriver is the interface to use to implement graph diffs |
| type DiffDriver interface { |
| // Diff produces an archive of the changes between the specified |
| // layer and its parent layer which may be "". |
| Diff(id, parent string) (io.ReadCloser, error) |
| // Changes produces a list of changes between the specified layer |
| // and its parent layer. If parent is "", then all changes will be ADD changes. |
| Changes(id, parent string) ([]archive.Change, error) |
| // ApplyDiff extracts the changeset from the given diff into the |
| // layer with the specified id and parent, returning the size of the |
| // new layer in bytes. |
| // The archive.Reader must be an uncompressed stream. |
| ApplyDiff(id, parent string, diff io.Reader) (size int64, err error) |
| // DiffSize calculates the changes between the specified id |
| // and its parent and returns the size in bytes of the changes |
| // relative to its base filesystem directory. |
| DiffSize(id, parent string) (size int64, err error) |
| } |
| |
| // Driver is the interface for layered/snapshot file system drivers. |
| type Driver interface { |
| ProtoDriver |
| DiffDriver |
| } |
| |
| // Capabilities defines a list of capabilities a driver may implement. |
| // These capabilities are not required; however, they do determine how a |
| // graphdriver can be used. |
| type Capabilities struct { |
| // Flags that this driver is capable of reproducing exactly equivalent |
| // diffs for read-only layers. If set, clients can rely on the driver |
| // for consistent tar streams, and avoid extra processing to account |
| // for potential differences (eg: the layer store's use of tar-split). |
| ReproducesExactDiffs bool |
| } |
| |
| // CapabilityDriver is the interface for layered file system drivers that |
| // can report on their Capabilities. |
| type CapabilityDriver interface { |
| Capabilities() Capabilities |
| } |
| |
| // DiffGetterDriver is the interface for layered file system drivers that |
| // provide a specialized function for getting file contents for tar-split. |
| type DiffGetterDriver interface { |
| Driver |
| // DiffGetter returns an interface to efficiently retrieve the contents |
| // of files in a layer. |
| DiffGetter(id string) (FileGetCloser, error) |
| } |
| |
| // FileGetCloser extends the storage.FileGetter interface with a Close method |
| // for cleaning up. |
| type FileGetCloser interface { |
| storage.FileGetter |
| // Close cleans up any resources associated with the FileGetCloser. |
| Close() error |
| } |
| |
| // Checker makes checks on specified filesystems. |
| type Checker interface { |
| // IsMounted returns true if the provided path is mounted for the specific checker |
| IsMounted(path string) bool |
| } |
| |
| func init() { |
| drivers = make(map[string]InitFunc) |
| } |
| |
| // Register registers an InitFunc for the driver. |
| func Register(name string, initFunc InitFunc) error { |
| if _, exists := drivers[name]; exists { |
| return fmt.Errorf("Name already registered %s", name) |
| } |
| drivers[name] = initFunc |
| |
| return nil |
| } |
| |
| // GetDriver initializes and returns the registered driver |
| func GetDriver(name string, pg plugingetter.PluginGetter, config Options) (Driver, error) { |
| if initFunc, exists := drivers[name]; exists { |
| return initFunc(filepath.Join(config.Root, name), config.DriverOptions, config.UIDMaps, config.GIDMaps) |
| } |
| |
| pluginDriver, err := lookupPlugin(name, pg, config) |
| if err == nil { |
| return pluginDriver, nil |
| } |
| logrus.WithError(err).WithField("driver", name).WithField("home-dir", config.Root).Error("Failed to GetDriver graph") |
| return nil, ErrNotSupported |
| } |
| |
| // getBuiltinDriver initializes and returns the registered driver, but does not try to load from plugins |
| func getBuiltinDriver(name, home string, options []string, uidMaps, gidMaps []idtools.IDMap) (Driver, error) { |
| if initFunc, exists := drivers[name]; exists { |
| return initFunc(filepath.Join(home, name), options, uidMaps, gidMaps) |
| } |
| logrus.Errorf("Failed to built-in GetDriver graph %s %s", name, home) |
| return nil, ErrNotSupported |
| } |
| |
| // Options is used to initialize a graphdriver |
| type Options struct { |
| Root string |
| DriverOptions []string |
| UIDMaps []idtools.IDMap |
| GIDMaps []idtools.IDMap |
| ExperimentalEnabled bool |
| } |
| |
| // New creates the driver and initializes it at the specified root. |
| func New(name string, pg plugingetter.PluginGetter, config Options) (Driver, error) { |
| if name != "" { |
| logrus.Debugf("[graphdriver] trying provided driver: %s", name) // so the logs show specified driver |
| return GetDriver(name, pg, config) |
| } |
| |
| // Guess for prior driver |
| driversMap := scanPriorDrivers(config.Root) |
| for _, name := range priority { |
| if name == "vfs" { |
| // don't use vfs even if there is state present. |
| continue |
| } |
| if _, prior := driversMap[name]; prior { |
| // of the state found from prior drivers, check in order of our priority |
| // which we would prefer |
| driver, err := getBuiltinDriver(name, config.Root, config.DriverOptions, config.UIDMaps, config.GIDMaps) |
| if err != nil { |
| // unlike below, we will return error here, because there is prior |
| // state, and now it is no longer supported/prereq/compatible, so |
| // something changed and needs attention. Otherwise the daemon's |
| // images would just "disappear". |
| logrus.Errorf("[graphdriver] prior storage driver %s failed: %s", name, err) |
| return nil, err |
| } |
| |
| // abort starting when there are other prior configured drivers |
| // to ensure the user explicitly selects the driver to load |
| if len(driversMap)-1 > 0 { |
| var driversSlice []string |
| for name := range driversMap { |
| driversSlice = append(driversSlice, name) |
| } |
| |
| return nil, fmt.Errorf("%s contains several valid graphdrivers: %s; Please cleanup or explicitly choose storage driver (-s <DRIVER>)", config.Root, strings.Join(driversSlice, ", ")) |
| } |
| |
| logrus.Infof("[graphdriver] using prior storage driver: %s", name) |
| return driver, nil |
| } |
| } |
| |
| // Check for priority drivers first |
| for _, name := range priority { |
| driver, err := getBuiltinDriver(name, config.Root, config.DriverOptions, config.UIDMaps, config.GIDMaps) |
| if err != nil { |
| if isDriverNotSupported(err) { |
| continue |
| } |
| return nil, err |
| } |
| return driver, nil |
| } |
| |
| // Check all registered drivers if no priority driver is found |
| for name, initFunc := range drivers { |
| driver, err := initFunc(filepath.Join(config.Root, name), config.DriverOptions, config.UIDMaps, config.GIDMaps) |
| if err != nil { |
| if isDriverNotSupported(err) { |
| continue |
| } |
| return nil, err |
| } |
| return driver, nil |
| } |
| return nil, fmt.Errorf("No supported storage backend found") |
| } |
| |
| // isDriverNotSupported returns true if the error initializing |
| // the graph driver is a non-supported error. |
| func isDriverNotSupported(err error) bool { |
| return err == ErrNotSupported || err == ErrPrerequisites || err == ErrIncompatibleFS |
| } |
| |
| // scanPriorDrivers returns an un-ordered scan of directories of prior storage drivers |
| func scanPriorDrivers(root string) map[string]bool { |
| driversMap := make(map[string]bool) |
| |
| for driver := range drivers { |
| p := filepath.Join(root, driver) |
| if _, err := os.Stat(p); err == nil && driver != "vfs" { |
| driversMap[driver] = true |
| } |
| } |
| return driversMap |
| } |