graphdriver

Documentation

Index

• Variables
• func IsDriverNotSupported(err error) bool
• func ParseStorageOptKeyValue(opt string) (key string, value string, err error)
• func Register(name string, initFunc InitFunc) error
• type CreateOpts
• type DiffDriver
• type DiffGetterDriver
• type Driver
  • func GetDriver(name string, config Options) (Driver, error)
  • func New(name string, config Options) (Driver, error)
  • func NewNaiveDiffDriver(driver ProtoDriver, idMap idtools.IdentityMapping) Driver
• type ErrUnSupported
• type FileGetCloser
• type InitFunc
• type NaiveDiffDriver
  • func (gdw *NaiveDiffDriver) ApplyDiff(id, parent string, diff io.Reader) (size int64, err error)
  • func (gdw *NaiveDiffDriver) Changes(id, parent string) ([]archive.Change, error)
  • func (gdw *NaiveDiffDriver) Diff(id, parent string) (arch io.ReadCloser, err error)
  • func (gdw *NaiveDiffDriver) DiffSize(id, parent string) (size int64, err error)
• type NotSupportedError
  • func (e NotSupportedError) Error() string
  • func (e NotSupportedError) NotSupported()
• type Options
• type ProtoDriver

Variables

var ApplyUncompressedLayer = chrootarchive.ApplyUncompressedLayer

ApplyUncompressedLayer defines the unpack method used by the graph driver.

Functions

func IsDriverNotSupported

func IsDriverNotSupported(err error) bool

IsDriverNotSupported returns true if the error initializing the graph driver is a non-supported error.

func ParseStorageOptKeyValue

func ParseStorageOptKeyValue(opt string) (key string, value string, err error)

ParseStorageOptKeyValue parses and validates the specified string as a key/value pair (key=value).

func Register

func Register(name string, initFunc InitFunc) error

Register registers an InitFunc for the driver.

Types

type CreateOpts

type CreateOpts struct {
	MountLabel string
	StorageOpt map[string]string
}

CreateOpts contains optional arguments for Create() and CreateReadWrite() methods.

type DiffDriver

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

DiffDriver is the interface to use to implement graph diffs

type DiffGetterDriver

type DiffGetterDriver interface {
	Driver
	// DiffGetter returns an interface to efficiently retrieve the contents
	// of files in a layer.
	DiffGetter(id string) (FileGetCloser, error)
}

DiffGetterDriver is the interface for layered file system drivers that provide a specialized function for getting file contents for tar-split.

type Driver

type Driver interface {
	ProtoDriver
	DiffDriver
}

Driver is the interface for layered/snapshot file system drivers.

func GetDriver

func GetDriver(name string, config Options) (Driver, error)

GetDriver initializes and returns the registered driver.

Deprecated: this function was exported for (integration-)tests, but no longer used, and will be removed in the next release.

func New

func New(name string, config Options) (Driver, error)

New creates the driver and initializes it at the specified root.

It is recommended to pass a name for the driver to use, but If no name is provided, it attempts to detect the prior storage driver based on existing state, or otherwise selects a storage driver based on a priority list and the underlying filesystem.

It returns an error if the requested storage driver is not supported, if scanning prior drivers is ambiguous (i.e., if state is found for multiple drivers), or if no compatible driver is available for the platform and underlying filesystem.

func NewNaiveDiffDriver

func NewNaiveDiffDriver(driver ProtoDriver, idMap idtools.IdentityMapping) Driver

NewNaiveDiffDriver returns a fully functional driver that wraps the given ProtoDriver and adds the capability of the following methods which it may or may not support on its own:

Diff(id, parent string) (archive.Archive, error)
Changes(id, parent string) ([]archive.Change, error)
ApplyDiff(id, parent string, diff archive.Reader) (size int64, err error)
DiffSize(id, parent string) (size int64, err error)

type ErrUnSupported

type ErrUnSupported interface {
	NotSupported()
}

ErrUnSupported signals that the graph-driver is not supported on the current configuration

type FileGetCloser

type FileGetCloser interface {
	storage.FileGetter
	// Close cleans up any resources associated with the FileGetCloser.
	Close() error
}

FileGetCloser extends the storage.FileGetter interface with a Close method for cleaning up.

type InitFunc

type InitFunc func(root string, options []string, idMap idtools.IdentityMapping) (Driver, error)

InitFunc initializes the storage driver.

type NaiveDiffDriver

type NaiveDiffDriver struct {
	ProtoDriver
	IDMap idtools.IdentityMapping
	// If true, allow ApplyDiff to succeed in spite of failures to set
	// extended attributes on the unpacked files due to the destination
	// filesystem not supporting them or a lack of permissions. The
	// resulting unpacked layer may be subtly broken.
	BestEffortXattrs bool
}

NaiveDiffDriver takes a ProtoDriver and adds the capability of the Diffing methods on the local file system, which it may or may not support on its own. See the comment on the exported NewNaiveDiffDriver function below.

func (*NaiveDiffDriver) ApplyDiff

func (gdw *NaiveDiffDriver) ApplyDiff(id, parent string, diff io.Reader) (size int64, err 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.

func (*NaiveDiffDriver) Changes

func (gdw *NaiveDiffDriver) Changes(id, parent string) ([]archive.Change, 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.

func (*NaiveDiffDriver) Diff

func (gdw *NaiveDiffDriver) Diff(id, parent string) (arch io.ReadCloser, err error)

Diff produces an archive of the changes between the specified layer and its parent layer which may be "".

func (*NaiveDiffDriver) DiffSize

func (gdw *NaiveDiffDriver) DiffSize(id, parent string) (size int64, err error)

DiffSize calculates the changes between the specified layer and its parent and returns the size in bytes of the changes relative to its base filesystem directory.

type NotSupportedError

type NotSupportedError string

NotSupportedError signals that the graph-driver is not supported on the current configuration

const (
	// ErrNotSupported returned when driver is not supported.
	ErrNotSupported NotSupportedError = "driver not supported"
	// ErrPrerequisites returned when driver does not meet prerequisites.
	ErrPrerequisites NotSupportedError = "prerequisites for driver not satisfied (wrong filesystem?)"
	// ErrIncompatibleFS returned when file system is not supported.
	ErrIncompatibleFS NotSupportedError = "backing file system is unsupported for this graph driver"
)

func (NotSupportedError) Error

func (e NotSupportedError) Error() string

func (NotSupportedError) NotSupported

func (e NotSupportedError) NotSupported()

NotSupported signals that a graph-driver is not supported.

type Options

type Options struct {
	Root                string
	DriverOptions       []string
	IDMap               idtools.IdentityMapping
	ExperimentalEnabled bool
}

Options is used to initialize a graphdriver

type ProtoDriver

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 string, 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
	// GetMetadata returns a set of key-value pairs which give driver-specific
	// low-level information about the image/container that the 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
}

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.