View Source
const TypeLayers = "layers"

    TypeLayers is used for RootFS.Type for filesystems organized into layers.


    This section is empty.


    This section is empty.


    type DigestWalkFunc

    type DigestWalkFunc func(id digest.Digest) error

      DigestWalkFunc is function called by StoreBackend.Walk

      type Exporter

      type Exporter interface {
      	Load(io.ReadCloser, io.Writer, bool) error
      	// TODO: Load(net.Context, io.ReadCloser, <- chan StatusMessage) error
      	Save([]string, io.Writer) error

        Exporter provides interface for exporting and importing images

        type History

        type History struct {
        	// Created timestamp for build point
        	Created time.Time `json:"created"`
        	// Author of the build point
        	Author string `json:"author,omitempty"`
        	// CreatedBy keeps the Dockerfile command used while building image.
        	CreatedBy string `json:"created_by,omitempty"`
        	// Comment is custom message set by the user when creating the image.
        	Comment string `json:"comment,omitempty"`
        	// EmptyLayer is set to true if this history item did not generate a
        	// layer. Otherwise, the history item is associated with the next
        	// layer in the RootFS section.
        	EmptyLayer bool `json:"empty_layer,omitempty"`

          History stores build commands that were used to create an image

          type ID

          type ID digest.Digest

            ID is the content-addressable ID of an image.

            func IDFromDigest

            func IDFromDigest(digest digest.Digest) ID

              IDFromDigest creates an ID from a digest

              func (ID) Digest

              func (id ID) Digest() digest.Digest

                Digest converts ID into a digest

                func (ID) String

                func (id ID) String() string

                type Image

                type Image struct {
                	Parent     ID        `json:"parent,omitempty"`
                	RootFS     *RootFS   `json:"rootfs,omitempty"`
                	History    []History `json:"history,omitempty"`
                	OSVersion  string    `json:"os.version,omitempty"`
                	OSFeatures []string  `json:"os.features,omitempty"`
                	// contains filtered or unexported fields

                  Image stores the image configuration

                  func NewFromJSON

                  func NewFromJSON(src []byte) (*Image, error)

                    NewFromJSON creates an Image configuration from json.

                    func (*Image) ID

                    func (img *Image) ID() ID

                      ID returns the image's content-addressable ID.

                      func (*Image) ImageID

                      func (img *Image) ImageID() string

                        ImageID stringifies ID.

                        func (*Image) MarshalJSON

                        func (img *Image) MarshalJSON() ([]byte, error)

                          MarshalJSON serializes the image to JSON. It sorts the top-level keys so that JSON that's been manipulated by a push/pull cycle with a legacy registry won't end up with a different key order.

                          func (*Image) RawJSON

                          func (img *Image) RawJSON() []byte

                            RawJSON returns the immutable JSON associated with the image.

                            func (*Image) RunConfig

                            func (img *Image) RunConfig() *container.Config

                              RunConfig returns the image's container config.

                              type LayerGetReleaser

                              type LayerGetReleaser interface {
                              	Get(layer.ChainID) (layer.Layer, error)
                              	Release(layer.Layer) ([]layer.Metadata, error)

                                LayerGetReleaser is a minimal interface for getting and releasing images.

                                type RootFS

                                type RootFS struct {
                                	Type    string         `json:"type"`
                                	DiffIDs []layer.DiffID `json:"diff_ids,omitempty"`

                                  RootFS describes images root filesystem This is currently a placeholder that only supports layers. In the future this can be made into an interface that supports different implementations.

                                  func NewRootFS

                                  func NewRootFS() *RootFS

                                    NewRootFS returns empty RootFS struct

                                    func (*RootFS) Append

                                    func (r *RootFS) Append(id layer.DiffID)

                                      Append appends a new diffID to rootfs

                                      func (*RootFS) ChainID

                                      func (r *RootFS) ChainID() layer.ChainID

                                        ChainID returns the ChainID for the top layer in RootFS.

                                        type Store

                                        type Store interface {
                                        	Create(config []byte) (ID, error)
                                        	Get(id ID) (*Image, error)
                                        	Delete(id ID) ([]layer.Metadata, error)
                                        	Search(partialID string) (ID, error)
                                        	SetParent(id ID, parent ID) error
                                        	GetParent(id ID) (ID, error)
                                        	Children(id ID) []ID
                                        	Map() map[ID]*Image
                                        	Heads() map[ID]*Image

                                          Store is an interface for creating and accessing images

                                          func NewImageStore

                                          func NewImageStore(fs StoreBackend, ls LayerGetReleaser) (Store, error)

                                            NewImageStore returns new store object for given layer store

                                            type StoreBackend

                                            type StoreBackend interface {
                                            	Walk(f DigestWalkFunc) error
                                            	Get(id digest.Digest) ([]byte, error)
                                            	Set(data []byte) (digest.Digest, error)
                                            	Delete(id digest.Digest) error
                                            	SetMetadata(id digest.Digest, key string, data []byte) error
                                            	GetMetadata(id digest.Digest, key string) ([]byte, error)
                                            	DeleteMetadata(id digest.Digest, key string) error

                                              StoreBackend provides interface for image.Store persistence

                                              func NewFSStoreBackend

                                              func NewFSStoreBackend(root string) (StoreBackend, error)

                                                NewFSStoreBackend returns new filesystem based backend for image.Store

                                                type V1Image

                                                type V1Image struct {
                                                	// ID a unique 64 character identifier of the image
                                                	ID string `json:"id,omitempty"`
                                                	// Parent id of the image
                                                	Parent string `json:"parent,omitempty"`
                                                	// Comment user added comment
                                                	Comment string `json:"comment,omitempty"`
                                                	// Created timestamp when image was created
                                                	Created time.Time `json:"created"`
                                                	// Container is the id of the container used to commit
                                                	Container string `json:"container,omitempty"`
                                                	// ContainerConfig is the configuration of the container that is committed into the image
                                                	ContainerConfig container.Config `json:"container_config,omitempty"`
                                                	// DockerVersion specifies version on which image is built
                                                	DockerVersion string `json:"docker_version,omitempty"`
                                                	// Author of the image
                                                	Author string `json:"author,omitempty"`
                                                	// Config is the configuration of the container received from the client
                                                	Config *container.Config `json:"config,omitempty"`
                                                	// Architecture is the hardware that the image is build and runs on
                                                	Architecture string `json:"architecture,omitempty"`
                                                	// OS is the operating system used to build and run the image
                                                	OS string `json:"os,omitempty"`
                                                	// Size is the total size of the image including all layers it is composed of
                                                	Size int64 `json:",omitempty"`

                                                  V1Image stores the V1 image configuration.


                                                  Path Synopsis