package llb

import "github.com/moby/buildkit/client/llb"

Index

Constants 

const (
	NetModeSandbox = pb.NetMode_UNSET
	NetModeHost    = pb.NetMode_HOST
	NetModeNone    = pb.NetMode_NONE
)
const (
	SecurityModeInsecure = pb.SecurityMode_INSECURE
	SecurityModeSandbox  = pb.SecurityMode_SANDBOX
)
const (
	GitAuthHeaderKey = "GIT_AUTH_HEADER"
	GitAuthTokenKey  = "GIT_AUTH_TOKEN"
)

Variables 

var (
	LinuxAmd64   = Platform(ocispecs.Platform{OS: "linux", Architecture: "amd64"})
	LinuxArmhf   = Platform(ocispecs.Platform{OS: "linux", Architecture: "arm", Variant: "v7"})
	LinuxArm     = LinuxArmhf
	LinuxArmel   = Platform(ocispecs.Platform{OS: "linux", Architecture: "arm", Variant: "v6"})
	LinuxArm64   = Platform(ocispecs.Platform{OS: "linux", Architecture: "arm64"})
	LinuxS390x   = Platform(ocispecs.Platform{OS: "linux", Architecture: "s390x"})
	LinuxPpc64   = Platform(ocispecs.Platform{OS: "linux", Architecture: "ppc64"})
	LinuxPpc64le = Platform(ocispecs.Platform{OS: "linux", Architecture: "ppc64le"})
	Darwin       = Platform(ocispecs.Platform{OS: "darwin", Architecture: "amd64"})
	Windows      = Platform(ocispecs.Platform{OS: "windows", Architecture: "amd64"})
)
var CDIDeviceOptional = cdiDeviceOptionFunc(func(ci *CDIDeviceInfo) {
	ci.Optional = true
})
var IgnoreCache = constraintsOptFunc(func(c *Constraints) {
	c.Metadata.IgnoreCache = true
})
var MarkImageInternal = imageOptionFunc(func(ii *ImageInfo) {
	ii.RecordType = "internal"
})
var SSHOptional = sshOptionFunc(func(si *SSHInfo) {
	si.Optional = true
})
var SecretOptional = secretOptionFunc(func(si *SecretInfo) {
	si.Optional = true
})

Functions

func ForceNoOutput 

func ForceNoOutput(m *mount)

func MarshalConstraints 

func MarshalConstraints(base, override *Constraints) (*pb.Op, *pb.OpMetadata)

func Readonly 

func Readonly(m *mount)

func WriteTo 

func WriteTo(def *Definition, w io.Writer) error

Types

type AuthOption 

type AuthOption interface {
	GitOption
	HTTPOption
}

AuthOption can be used with either HTTP or Git sources.

func AuthHeaderSecret 

func AuthHeaderSecret(secretName string) AuthOption

AuthHeaderSecret returns an AuthOption that defines the name of a secret to use for HTTP based authentication.

type CDIDeviceInfo 

type CDIDeviceInfo struct {
	Name     string
	Optional bool
}

type CDIDeviceOption 

type CDIDeviceOption interface {
	SetCDIDeviceOption(*CDIDeviceInfo)
}

func CDIDeviceName 

func CDIDeviceName(name string) CDIDeviceOption

type CacheMountSharingMode 

type CacheMountSharingMode int
const (
	CacheMountShared CacheMountSharingMode = iota
	CacheMountPrivate
	CacheMountLocked
)

type ChmodOpt 

type ChmodOpt struct {
	Mode    os.FileMode
	ModeStr string
}

func (ChmodOpt) SetCopyOption 

func (co ChmodOpt) SetCopyOption(mi *CopyInfo)

type ChownOpt 

type ChownOpt struct {
	User  *UserOpt
	Group *UserOpt
}

func (ChownOpt) SetCopyOption 

func (co ChownOpt) SetCopyOption(mi *CopyInfo)

func (ChownOpt) SetMkdirOption 

func (co ChownOpt) SetMkdirOption(mi *MkdirInfo)

func (ChownOpt) SetMkfileOption 

func (co ChownOpt) SetMkfileOption(mi *MkfileInfo)

func (ChownOpt) SetSymlinkOption 

func (co ChownOpt) SetSymlinkOption(si *SymlinkInfo)

type ChownOption 

type ChownOption interface {
	MkdirOption
	MkfileOption
	CopyOption
	SymlinkOption
}

func WithUIDGID 

func WithUIDGID(uid, gid int) ChownOption

func WithUser 

func WithUser(name string) ChownOption

type Constraints 

type Constraints struct {
	Platform          *ocispecs.Platform
	WorkerConstraints []string
	Metadata          OpMetadata
	LocalUniqueID     string
	Caps              *apicaps.CapSet
	SourceLocations   []*SourceLocation
}

func NewConstraints 

func NewConstraints(co ...ConstraintsOpt) *Constraints

type ConstraintsOpt 

type ConstraintsOpt interface {
	SetConstraintsOption(*Constraints)
	RunOption
	LocalOption
	HTTPOption
	ImageOption
	GitOption
	OCILayoutOption
}

func LocalUniqueID 

func LocalUniqueID(v string) ConstraintsOpt

func Platform 

func Platform(p ocispecs.Platform) ConstraintsOpt

func ProgressGroup 

func ProgressGroup(id, name string, weak bool) ConstraintsOpt

func Require 

func Require(filters ...string) ConstraintsOpt

func WithCaps 

func WithCaps(caps apicaps.CapSet) ConstraintsOpt

WithCaps exposes supported LLB caps to the marshaler

func WithCustomName 

func WithCustomName(name string) ConstraintsOpt

func WithCustomNamef 

func WithCustomNamef(name string, a ...any) ConstraintsOpt

func WithDescription 

func WithDescription(m map[string]string) ConstraintsOpt

func WithExportCache 

func WithExportCache() ConstraintsOpt

WithExportCache forces results for this vertex to be exported with the cache

func WithoutDefaultExportCache 

func WithoutDefaultExportCache() ConstraintsOpt

WithoutDefaultExportCache resets the cache export for the vertex to use the default defined by the build configuration.

func WithoutExportCache 

func WithoutExportCache() ConstraintsOpt

WithoutExportCache sets results for this vertex to be not exported with the cache

type CopyInfo 

type CopyInfo struct {
	Mode                           *ChmodOpt
	FollowSymlinks                 bool
	CopyDirContentsOnly            bool
	IncludePatterns                []string
	ExcludePatterns                []string
	AttemptUnpack                  bool
	CreateDestPath                 bool
	AllowWildcard                  bool
	AllowEmptyWildcard             bool
	ChownOpt                       *ChownOpt
	CreatedTime                    *time.Time
	AlwaysReplaceExistingDestPaths bool
}

func (*CopyInfo) SetCopyOption 

func (mi *CopyInfo) SetCopyOption(mi2 *CopyInfo)

type CopyInput 

type CopyInput interface {
	// contains filtered or unexported methods
}

CopyInput is either llb.State or *FileActionWithState It is used by Copy to to specify the source of the copy operation.

type CopyOption 

type CopyOption interface {
	SetCopyOption(*CopyInfo)
}

func WithExcludePatterns 

func WithExcludePatterns(patterns []string) CopyOption

type CreatedTime 

type CreatedTime time.Time

func WithCreatedTime 

func WithCreatedTime(t time.Time) CreatedTime

func (CreatedTime) SetCopyOption 

func (c CreatedTime) SetCopyOption(mi *CopyInfo)

func (CreatedTime) SetMkdirOption 

func (c CreatedTime) SetMkdirOption(mi *MkdirInfo)

func (CreatedTime) SetMkfileOption 

func (c CreatedTime) SetMkfileOption(mi *MkfileInfo)

func (CreatedTime) SetSymlinkOption 

func (c CreatedTime) SetSymlinkOption(si *SymlinkInfo)

type Definition 

type Definition struct {
	Def         [][]byte
	Metadata    map[digest.Digest]OpMetadata
	Source      *pb.Source
	Constraints *Constraints
}

Definition is the LLB definition structure with per-vertex metadata entries Corresponds to the Definition structure defined in solver/pb.Definition.

func ReadFrom 

func ReadFrom(r io.Reader) (*Definition, error)

func (*Definition) FromPB 

func (def *Definition) FromPB(x *pb.Definition)

func (*Definition) Head 

func (def *Definition) Head() (digest.Digest, error)

func (*Definition) ToPB 

func (def *Definition) ToPB() *pb.Definition

type DefinitionOp 

type DefinitionOp struct {
	// contains filtered or unexported fields
}

DefinitionOp implements llb.Vertex using a marshalled definition.

For example, after marshalling a LLB state and sending over the wire, the LLB state can be reconstructed from the definition.

func NewDefinitionOp 

func NewDefinitionOp(def *pb.Definition) (*DefinitionOp, error)

NewDefinitionOp returns a new operation from a marshalled definition.

func (*DefinitionOp) Inputs 

func (d *DefinitionOp) Inputs() []Output

func (*DefinitionOp) Marshal 

func (d *DefinitionOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)

func (*DefinitionOp) Output 

func (d *DefinitionOp) Output() Output

func (*DefinitionOp) ToInput 

func (d *DefinitionOp) ToInput(ctx context.Context, c *Constraints) (*pb.Input, error)

func (*DefinitionOp) Validate 

func (d *DefinitionOp) Validate(context.Context, *Constraints) error

func (*DefinitionOp) Vertex 

func (d *DefinitionOp) Vertex(context.Context, *Constraints) Vertex

type DiffOp 

type DiffOp struct {
	// contains filtered or unexported fields
}

func NewDiff 

func NewDiff(lower, upper State, c Constraints) *DiffOp

func (*DiffOp) Inputs 

func (m *DiffOp) Inputs() (out []Output)

func (*DiffOp) Marshal 

func (m *DiffOp) Marshal(ctx context.Context, constraints *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)

func (*DiffOp) Output 

func (m *DiffOp) Output() Output

func (*DiffOp) Validate 

func (m *DiffOp) Validate(ctx context.Context, constraints *Constraints) error

type DiffType 

type DiffType string
const (
	// DiffNone will do no file comparisons, all files in the Local source will
	// be retransmitted.
	DiffNone DiffType = pb.AttrLocalDifferNone
	// DiffMetadata will compare file metadata (size, modified time, mode, owner,
	// group, device and link name) to determine if the files in the Local source need
	// to be retransmitted.  This is the default behavior.
	DiffMetadata DiffType = pb.AttrLocalDifferMetadata
)

type DifferInfo 

type DifferInfo struct {
	Type     DiffType
	Required bool
}

type EnvList 

type EnvList struct {
	// contains filtered or unexported fields
}

func (*EnvList) AddOrReplace 

func (e *EnvList) AddOrReplace(k, v string) *EnvList

func (*EnvList) Delete 

func (e *EnvList) Delete(k string) EnvList

func (*EnvList) Get 

func (e *EnvList) Get(k string) (string, bool)

func (*EnvList) Keys 

func (e *EnvList) Keys() []string

func (*EnvList) SetDefault 

func (e *EnvList) SetDefault(k, v string) *EnvList

func (*EnvList) ToArray 

func (e *EnvList) ToArray() []string

type ExecInfo 

type ExecInfo struct {
	State          State
	Mounts         []MountInfo
	ReadonlyRootFS bool
	ProxyEnv       *ProxyEnv
	Secrets        []SecretInfo
	SSH            []SSHInfo
	CDIDevices     []CDIDeviceInfo
	// contains filtered or unexported fields
}

type ExecOp 

type ExecOp struct {
	// contains filtered or unexported fields
}

func NewExecOp 

func NewExecOp(base State, proxyEnv *ProxyEnv, readOnly bool, c Constraints) *ExecOp

func (*ExecOp) AddMount 

func (e *ExecOp) AddMount(target string, source Output, opt ...MountOption) Output

func (*ExecOp) GetMount 

func (e *ExecOp) GetMount(target string) Output

func (*ExecOp) Inputs 

func (e *ExecOp) Inputs() (inputs []Output)

func (*ExecOp) Marshal 

func (e *ExecOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)

func (*ExecOp) Output 

func (e *ExecOp) Output() Output

func (*ExecOp) Validate 

func (e *ExecOp) Validate(ctx context.Context, c *Constraints) error

type ExecState 

type ExecState struct {
	State
	// contains filtered or unexported fields
}

func (ExecState) AddMount 

func (e ExecState) AddMount(target string, source State, opt ...MountOption) State

func (ExecState) GetMount 

func (e ExecState) GetMount(target string) State

func (ExecState) Root 

func (e ExecState) Root() State

type FileAction 

type FileAction struct {
	// contains filtered or unexported fields
}

FileAction is used to specify a file operation on a State. It can be used to create a directory, create a file, or remove a file, etc. This is used by State.File Typically a FileAction is created by calling one of the helper functions such as Mkdir, Copy, Rm, Mkfile

func Copy 

func Copy(input CopyInput, src, dest string, opts ...CopyOption) *FileAction

Copy produces a FileAction which copies a file or directory from the source to the destination. The "input" parameter is the contents to copy from. "src" is the path to copy from within the "input". "dest" is the path to copy to within the destination (the state being operated on). See CopyInput for the valid types of input.

Example: 

st := llb.Local(".")
llb.Scratch().File(llb.Copy(st, "/foo", "/bar"))

The example copies the local (client) directory "./foo" to a new empty directory at /bar.

Note: Copying directories can have different behavior based on if the destination exists or not. When the destination already exists, the contents of the source directory is copied underneath the destination, including the directory itself. You may need to supply a copy option to copy the dir contents only. You may also need to pass in a CopyOption which creates parent directories if they do not exist.

See CopyOption for more details on what options are available.

func Mkdir 

func Mkdir(p string, m os.FileMode, opt ...MkdirOption) *FileAction

Mkdir creates a FileAction which creates a directory at the given path. Example: 

llb.Scratch().File(llb.Mkdir("/foo", 0755))

func Mkfile 

func Mkfile(p string, m os.FileMode, dt []byte, opts ...MkfileOption) *FileAction

Mkfile creates a FileAction which creates a file at the given path with the provided contents. Example: 

llb.Scratch().File(llb.Mkfile("/foo", 0644, []byte("hello world!")))

func Rm 

func Rm(p string, opts ...RmOption) *FileAction

Rm creates a FileAction which removes a file or directory at the given path. Example: 

llb.Scratch().File(Mkfile("/foo", 0644, []byte("not around for long..."))).File(llb.Rm("/foo"))

func Symlink(oldpath, newpath string, opts ...SymlinkOption) *FileAction

Symlink creates a symlink at `newpath` that points to `oldpath`

func (*FileAction) Copy 

func (fa *FileAction) Copy(input CopyInput, src, dest string, opt ...CopyOption) *FileAction

func (*FileAction) Mkdir 

func (fa *FileAction) Mkdir(p string, m os.FileMode, opt ...MkdirOption) *FileAction

func (*FileAction) Mkfile 

func (fa *FileAction) Mkfile(p string, m os.FileMode, dt []byte, opt ...MkfileOption) *FileAction

func (*FileAction) Rm 

func (fa *FileAction) Rm(p string, opt ...RmOption) *FileAction
func (fa *FileAction) Symlink(oldpath, newpath string, opt ...SymlinkOption) *FileAction

Symlink creates a symlink at `newpath` that points to `oldpath`

func (*FileAction) WithState 

func (fa *FileAction) WithState(s State) CopyInput

type FileOp 

type FileOp struct {
	MarshalCache
	// contains filtered or unexported fields
}

func NewFileOp 

func NewFileOp(s State, action *FileAction, c Constraints) *FileOp

func (*FileOp) Inputs 

func (f *FileOp) Inputs() []Output

func (*FileOp) Marshal 

func (f *FileOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)

func (*FileOp) Output 

func (f *FileOp) Output() Output

func (*FileOp) Validate 

func (f *FileOp) Validate(context.Context, *Constraints) error

type GitInfo 

type GitInfo struct {
	KeepGitDir       bool
	AuthTokenSecret  string
	AuthHeaderSecret string

	KnownSSHHosts string
	MountSSHSock  string
	// contains filtered or unexported fields
}

type GitOption 

type GitOption interface {
	SetGitOption(*GitInfo)
}

func AuthTokenSecret 

func AuthTokenSecret(v string) GitOption

func KeepGitDir 

func KeepGitDir() GitOption

func KnownSSHHosts 

func KnownSSHHosts(key string) GitOption

func MountSSHSock 

func MountSSHSock(sshID string) GitOption

type HTTPHeader 

type HTTPHeader struct {
	Accept    string
	UserAgent string
}

type HTTPInfo 

type HTTPInfo struct {
	Checksum         digest.Digest
	Filename         string
	Perm             int
	UID              int
	GID              int
	AuthHeaderSecret string
	Header           *HTTPHeader
	// contains filtered or unexported fields
}

type HTTPOption 

type HTTPOption interface {
	SetHTTPOption(*HTTPInfo)
}

func Checksum 

func Checksum(dgst digest.Digest) HTTPOption

func Chmod 

func Chmod(perm os.FileMode) HTTPOption

func Chown 

func Chown(uid, gid int) HTTPOption

func Filename 

func Filename(name string) HTTPOption
func Header(header HTTPHeader) HTTPOption

Header returns an HTTPOption that ensures additional request headers will be sent when retrieving the HTTP source.

type HostIP 

type HostIP struct {
	Host string
	IP   net.IP
}

type ImageInfo 

type ImageInfo struct {
	RecordType string
	// contains filtered or unexported fields
}

type ImageMetaResolver 

type ImageMetaResolver = sourceresolver.ImageMetaResolver

ImageMetaResolver can resolve image config metadata from a reference

type ImageOption 

type ImageOption interface {
	SetImageOption(*ImageInfo)
}

func ResolveDigest 

func ResolveDigest(v bool) ImageOption

ResolveDigest uses the meta resolver to update the ref of image with full digest before marshaling. This makes image ref immutable and is recommended if you want to make sure meta resolver data matches the image used during the build.

func WithLayerLimit 

func WithLayerLimit(l int) ImageOption

func WithMetaResolver 

func WithMetaResolver(mr ImageMetaResolver) ImageOption

WithMetaResolver adds a metadata resolver to an image

type LocalInfo 

type LocalInfo struct {
	SessionID              string
	IncludePatterns        string
	ExcludePatterns        string
	FollowPaths            string
	SharedKeyHint          string
	Differ                 DifferInfo
	MetadataOnlyCollector  bool
	MetadataOnlyExceptions string
	// contains filtered or unexported fields
}

type LocalOption 

type LocalOption interface {
	SetLocalOption(*LocalInfo)
}

func Differ 

func Differ(t DiffType, required bool) LocalOption

func ExcludePatterns 

func ExcludePatterns(p []string) LocalOption

func FollowPaths 

func FollowPaths(p []string) LocalOption

func IncludePatterns 

func IncludePatterns(p []string) LocalOption

func MetadataOnlyTransfer 

func MetadataOnlyTransfer(exceptions []string) LocalOption

func SessionID 

func SessionID(id string) LocalOption

func SharedKeyHint 

func SharedKeyHint(h string) LocalOption

type MarshalCache 

type MarshalCache struct {
	// contains filtered or unexported fields
}

func (*MarshalCache) Acquire 

func (mc *MarshalCache) Acquire() *MarshalCacheInstance

type MarshalCacheInstance 

type MarshalCacheInstance struct {
	*MarshalCache
}

func (*MarshalCacheInstance) Load 

func (mc *MarshalCacheInstance) Load(c *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)

func (*MarshalCacheInstance) Release 

func (mc *MarshalCacheInstance) Release()

func (*MarshalCacheInstance) Store 

func (mc *MarshalCacheInstance) Store(dt []byte, md *pb.OpMetadata, srcs []*SourceLocation, c *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)

type MergeOp 

type MergeOp struct {
	// contains filtered or unexported fields
}

func NewMerge 

func NewMerge(inputs []State, c Constraints) *MergeOp

func (*MergeOp) Inputs 

func (m *MergeOp) Inputs() []Output

func (*MergeOp) Marshal 

func (m *MergeOp) Marshal(ctx context.Context, constraints *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)

func (*MergeOp) Output 

func (m *MergeOp) Output() Output

func (*MergeOp) Validate 

func (m *MergeOp) Validate(ctx context.Context, constraints *Constraints) error

type MkdirInfo 

type MkdirInfo struct {
	MakeParents bool
	ChownOpt    *ChownOpt
	CreatedTime *time.Time
}

func (*MkdirInfo) SetMkdirOption 

func (mi *MkdirInfo) SetMkdirOption(mi2 *MkdirInfo)

type MkdirOption 

type MkdirOption interface {
	SetMkdirOption(*MkdirInfo)
}

func WithParents 

func WithParents(b bool) MkdirOption

WithParents is an option for Mkdir which creates parent directories if they do not exist.

type MkfileInfo 

type MkfileInfo struct {
	ChownOpt    *ChownOpt
	CreatedTime *time.Time
}

func (*MkfileInfo) SetMkfileOption 

func (mi *MkfileInfo) SetMkfileOption(mi2 *MkfileInfo)

type MkfileOption 

type MkfileOption interface {
	SetMkfileOption(*MkfileInfo)
}

type MountContentCache 

type MountContentCache int
const (
	MountContentCacheDefault MountContentCache = iota
	MountContentCacheOn
	MountContentCacheOff
)

type MountInfo 

type MountInfo struct {
	Target string
	Source Output
	Opts   []MountOption
}

type MountOption 

type MountOption func(*mount)

func AsPersistentCacheDir 

func AsPersistentCacheDir(id string, sharing CacheMountSharingMode) MountOption

func ContentCache 

func ContentCache(cache MountContentCache) MountOption

func SourcePath 

func SourcePath(src string) MountOption

func Tmpfs 

func Tmpfs(opts ...TmpfsOption) MountOption

type OCILayoutInfo 

type OCILayoutInfo struct {
	// contains filtered or unexported fields
}

type OCILayoutOption 

type OCILayoutOption interface {
	SetOCILayoutOption(*OCILayoutInfo)
}

func OCILayerLimit 

func OCILayerLimit(limit int) OCILayoutOption

func OCIStore 

func OCIStore(sessionID string, storeID string) OCILayoutOption

type OpMetadata 

type OpMetadata struct {
	IgnoreCache   bool                   `json:"ignore_cache,omitempty"`
	Description   map[string]string      `json:"description,omitempty"`
	ExportCache   *pb.ExportCache        `json:"export_cache,omitempty"`
	Caps          map[apicaps.CapID]bool `json:"caps,omitempty"`
	ProgressGroup *pb.ProgressGroup      `json:"progress_group,omitempty"`
}

OpMetadata has a more friendly interface for pb.OpMetadata.

func NewOpMetadata 

func NewOpMetadata(mpb *pb.OpMetadata) OpMetadata

func (*OpMetadata) FromPB 

func (m *OpMetadata) FromPB(mpb *pb.OpMetadata)

func (OpMetadata) ToPB 

func (m OpMetadata) ToPB() *pb.OpMetadata

type Output 

type Output interface {
	ToInput(context.Context, *Constraints) (*pb.Input, error)
	Vertex(context.Context, *Constraints) Vertex
}

type ProxyEnv 

type ProxyEnv struct {
	HTTPProxy  string
	HTTPSProxy string
	FTPProxy   string
	NoProxy    string
	AllProxy   string
}

type ResolveMode 

type ResolveMode int
const (
	ResolveModeDefault ResolveMode = iota
	ResolveModeForcePull
	ResolveModePreferLocal
)

func (ResolveMode) SetImageOption 

func (r ResolveMode) SetImageOption(ii *ImageInfo)

func (ResolveMode) String 

func (r ResolveMode) String() string

type RmInfo 

type RmInfo struct {
	AllowNotFound bool
	AllowWildcard bool
}

func (*RmInfo) SetRmOption 

func (mi *RmInfo) SetRmOption(mi2 *RmInfo)

type RmOption 

type RmOption interface {
	SetRmOption(*RmInfo)
}

func WithAllowNotFound 

func WithAllowNotFound(b bool) RmOption

func WithAllowWildcard 

func WithAllowWildcard(b bool) RmOption

type RunOption 

type RunOption interface {
	SetRunOption(es *ExecInfo)
}

func AddCDIDevice 

func AddCDIDevice(opts ...CDIDeviceOption) RunOption

func AddExtraHost 

func AddExtraHost(host string, ip net.IP) RunOption

func AddMount 

func AddMount(dest string, mountState State, opts ...MountOption) RunOption

func AddSSHSocket 

func AddSSHSocket(opts ...SSHOption) RunOption

func AddSecret 

func AddSecret(dest string, opts ...SecretOption) RunOption

AddSecret is a RunOption that adds a secret to the exec.

func AddSecretWithDest 

func AddSecretWithDest(src string, dest *string, opts ...SecretOption) RunOption

AddSecretWithDest is a RunOption that adds a secret to the exec with an optional destination.

func AddUlimit 

func AddUlimit(name UlimitName, soft int64, hard int64) RunOption

func Args 

func Args(a []string) RunOption

func ReadonlyRootFS 

func ReadonlyRootFS() RunOption

ReadonlyRootFS sets the execs's root filesystem to be read-only.

func Shlex 

func Shlex(str string) RunOption

func Shlexf 

func Shlexf(str string, v ...any) RunOption

func ValidExitCodes 

func ValidExitCodes(codes ...int) RunOption

func With 

func With(so ...StateOption) RunOption

func WithCgroupParent 

func WithCgroupParent(cp string) RunOption

func WithProxy 

func WithProxy(ps ProxyEnv) RunOption

WithProxy is a RunOption that sets the proxy environment variables in the resulting exec. For example `HTTP_PROXY` is a standard environment variable for unix systems that programs may read.

type SSHInfo 

type SSHInfo struct {
	ID       string
	Target   string
	Mode     int
	UID      int
	GID      int
	Optional bool
}

type SSHOption 

type SSHOption interface {
	SetSSHOption(*SSHInfo)
}

func SSHID 

func SSHID(id string) SSHOption

func SSHSocketOpt 

func SSHSocketOpt(target string, uid, gid, mode int) SSHOption

func SSHSocketTarget 

func SSHSocketTarget(target string) SSHOption

type SecretInfo 

type SecretInfo struct {
	ID string
	// Target optionally specifies the target for the secret mount
	Target *string
	// Env optionally names the environment variable for the secret
	Env      *string
	Mode     int
	UID      int
	GID      int
	Optional bool
}

type SecretOption 

type SecretOption interface {
	SetSecretOption(*SecretInfo)
}

func SecretAsEnv 

func SecretAsEnv(v bool) SecretOption

SecretAsEnv defines if the secret should be added as an environment variable

func SecretAsEnvName 

func SecretAsEnvName(v string) SecretOption

SecretAsEnvName defines if the secret should be added as an environment variable with the specified name

func SecretFileOpt 

func SecretFileOpt(uid, gid, mode int) SecretOption

SecretFileOpt sets the secret's target file uid, gid and permissions.

func SecretID 

func SecretID(id string) SecretOption

type SourceLocation 

type SourceLocation struct {
	SourceMap *SourceMap
	Ranges    []*pb.Range
}

type SourceMap 

type SourceMap struct {
	State      *State
	Definition *Definition
	Filename   string
	// Language should use names defined in https://github.com/github/linguist/blob/v7.24.1/lib/linguist/languages.yml
	Language string
	Data     []byte
}

SourceMap maps a source file/location to an LLB state/definition. SourceMaps are used to provide information for debugging and helpful error messages to the user. As an example, lets say you have a Dockerfile with the following content: 

FROM alpine
RUN exit 1

When the "RUN" statement exits with a non-zero exit code buildkit will treat it as an error and is able to provide the user with a helpful error message pointing to exactly the line in the Dockerfile that caused the error.

func NewSourceMap 

func NewSourceMap(st *State, filename string, lang string, dt []byte) *SourceMap

func (*SourceMap) Location 

func (s *SourceMap) Location(r []*pb.Range) ConstraintsOpt

type SourceOp 

type SourceOp struct {
	// contains filtered or unexported fields
}

func NewSource 

func NewSource(id string, attrs map[string]string, c Constraints) *SourceOp

func (*SourceOp) Inputs 

func (s *SourceOp) Inputs() []Output

func (*SourceOp) Marshal 

func (s *SourceOp) Marshal(ctx context.Context, constraints *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)

func (*SourceOp) Output 

func (s *SourceOp) Output() Output

func (*SourceOp) Validate 

func (s *SourceOp) Validate(ctx context.Context, c *Constraints) error

type State 

type State struct {
	// contains filtered or unexported fields
}

State represents all operations that must be done to produce a given output. States are immutable, and all operations return a new state linked to the previous one. State is the core type of the LLB API and is used to build a graph of operations. The graph is then marshaled into a definition that can be executed by a backend (such as buildkitd).

Operations performed on a State are executed lazily after the entire state graph is marshalled and sent to the backend.

func Diff 

func Diff(lower, upper State, opts ...ConstraintsOpt) State

Diff returns a state that represents the diff of the lower and upper states. The returned State is useful for use with Merge where you can merge the lower state with the diff.

func Git 

func Git(url, ref string, opts ...GitOption) State

Git returns a state that represents a git repository. Example: 

st := llb.Git("https://github.com/moby/buildkit.git", "v0.11.6")

The example fetches the v0.11.6 tag of the buildkit repository. You can also use a commit hash or a branch name.

Other URL formats are supported such as "git@github.com:moby/buildkit.git", "git://...", "ssh://..." Formats that utilize SSH may need to supply credentials as a GitOption. You may need to check the source code for a full list of supported formats.

By default the git repository is cloned with `--depth=1` to reduce the amount of data downloaded. Additionally the ".git" directory is removed after the clone, you can keep ith with the KeepGitDir GitOption.

func HTTP 

func HTTP(url string, opts ...HTTPOption) State

func Image 

func Image(ref string, opts ...ImageOption) State

Image returns a state that represents a docker image in a registry. Example: 

st := llb.Image("busybox:latest")

func Local 

func Local(name string, opts ...LocalOption) State

Local returns a state that represents a directory local to the client.

func Merge 

func Merge(inputs []State, opts ...ConstraintsOpt) State

Merge merges multiple states into a single state. This is useful in conjunction with Diff to create set of patches which are independent of each other to a base state without affecting the cache of other merged states. As an example, lets say you have a rootfs with the following directories: 

/ /bin /etc /opt /tmp

Now lets say you want to copy a directory /etc/foo from one state and a binary /bin/bar from another state. Copy makes a duplicate of file on top of another directory. Merge creates a directory whose contents is an overlay of 2 states on top of each other.

With "Merge" you can do this: 

fooState := Diff(rootfs, fooState)
barState := Diff(rootfs, barState)

Then merge the results with: 

Merge(rootfs, fooDiff, barDiff)

The resulting state will have both /etc/foo and /bin/bar, but because Merge was used, changing the contents of "fooDiff" does not require copying "barDiff" again.

func NewState 

func NewState(o Output) State

func OCILayout 

func OCILayout(ref string, opts ...OCILayoutOption) State

func Scratch 

func Scratch() State

Scratch returns a state that represents an empty filesystem.

func (State) AddEnv 

func (s State) AddEnv(key, value string) State

AddEnv returns a new State with the provided environment variable set. See AddEnv

func (State) AddEnvf 

func (s State) AddEnvf(key, value string, v ...any) State

AddEnvf is the same as State.AddEnv but with a format string.

func (State) AddExtraHost 

func (s State) AddExtraHost(host string, ip net.IP) State

AddExtraHost adds a host name to IP mapping to any containers created from this state.

func (State) AddUlimit 

func (s State) AddUlimit(name UlimitName, soft int64, hard int64) State

AddUlimit sets the hard/soft for the given ulimit. The ulimit is applied to containers created from this state. Ulimits are Linux specific and only applies to containers created from this state such as via `[State.Run]` Ulimits do not apply to image configs.

func (State) Async 

func (s State) Async(f func(context.Context, State, *Constraints) (State, error)) State

func (State) Dir 

func (s State) Dir(str string) State

Dir returns a new State with the provided working directory set. See Dir

func (State) Dirf 

func (s State) Dirf(str string, v ...any) State

Dirf is the same as State.Dir but with a format string.

func (State) Env 

func (s State) Env(ctx context.Context, co ...ConstraintsOpt) (*EnvList, error)

Env returns a new State with the provided environment variable set. See [Env]

func (State) File 

func (s State) File(a *FileAction, opts ...ConstraintsOpt) State

File performs a file operation on the current state. See FileAction for details on the operations that can be performed.

func (State) GetArgs 

func (s State) GetArgs(ctx context.Context, co ...ConstraintsOpt) ([]string, error)

func (State) GetDir 

func (s State) GetDir(ctx context.Context, co ...ConstraintsOpt) (string, error)

GetDir returns the current working directory for the state.

func (State) GetEnv 

func (s State) GetEnv(ctx context.Context, key string, co ...ConstraintsOpt) (string, bool, error)

GetEnv returns the value of the environment variable with the provided key.

func (State) GetHostname 

func (s State) GetHostname(ctx context.Context, co ...ConstraintsOpt) (string, error)

GetHostname returns the hostname set on the state. See Hostname for more details.

func (State) GetNetwork 

func (s State) GetNetwork(ctx context.Context, co ...ConstraintsOpt) (pb.NetMode, error)

GetNetwork returns the network mode for the state.

func (State) GetPlatform 

func (s State) GetPlatform(ctx context.Context, co ...ConstraintsOpt) (*ocispecs.Platform, error)

GetPlatform returns the platform for the state.

func (State) GetSecurity 

func (s State) GetSecurity(ctx context.Context, co ...ConstraintsOpt) (pb.SecurityMode, error)

GetSecurity returns the security mode for the state.

func (State) Hostname 

func (s State) Hostname(v string) State

Hostname sets the hostname for this state. See Hostname for more details.

func (State) Marshal 

func (s State) Marshal(ctx context.Context, co ...ConstraintsOpt) (*Definition, error)

Marshal marshals the state and all its parents into a Definition.

func (State) Network 

func (s State) Network(n pb.NetMode) State

Network sets the network mode for the state. Network modes are used by State.Run to determine the network mode used when running the container. Network modes are not applied to image configs.

func (State) Output 

func (s State) Output() Output

Output returns the output of the state.

func (State) Platform 

func (s State) Platform(p ocispecs.Platform) State

Platform sets the platform for the state. Platforms are used to determine image variants to pull and run as well as the platform metadata to set on the image config.

func (State) Reset 

func (s State) Reset(s2 State) State

Reset is used to return a new State with all of the current state and the provided State as the parent. In effect you can think of this as creating a new state with all the output from the current state but reparented to the provided state. See Reset for more details.

func (State) Run 

func (s State) Run(ro ...RunOption) ExecState

Run performs the command specified by the arguments within the context of the current State. The command is executed as a container with the State's filesystem as the root filesystem. As such any command you run must be present in the State's filesystem. Constraints such as [State.Ulimit], [State.ParentCgroup], State.Network, etc. are applied to the container.

Run is useful when none of the LLB ops are sufficient for the operation that you want to perform.

func (State) Security 

func (s State) Security(n pb.SecurityMode) State

Security sets the security mode for the state. Security modes are used by State.Run to the privileges that processes in the container will run with. Security modes are not applied to image configs.

func (State) SetMarshalDefaults 

func (s State) SetMarshalDefaults(co ...ConstraintsOpt) State

func (State) User 

func (s State) User(v string) State

User sets the user for this state. See User for more details.

func (State) Validate 

func (s State) Validate(ctx context.Context, c *Constraints) error

Validate validates the state. This validation, unlike most other operations on State, is not lazily performed.

func (State) Value 

func (s State) Value(ctx context.Context, k any, co ...ConstraintsOpt) (any, error)

func (State) With 

func (s State) With(so ...StateOption) State

With applies [StateOption]s to the State. Each applied StateOption creates a new State object with the previous as its parent.

func (State) WithCgroupParent 

func (s State) WithCgroupParent(cp string) State

WithCgroupParent sets the parent cgroup for any containers created from this state. This is useful when you want to apply resource constraints to a group of containers. Cgroups are Linux specific and only applies to containers created from this state such as via `[State.Run]` Cgroups do not apply to image configs.

func (State) WithImageConfig 

func (s State) WithImageConfig(c []byte) (State, error)

WithImageConfig adds the environment variables, working directory, and platform specified in the image config to the state.

func (State) WithOutput 

func (s State) WithOutput(o Output) State

WithOutput creates a new state with the output set to the given output.

func (State) WithValue 

func (s State) WithValue(k, v any) State

type StateOption 

type StateOption func(State) State

func AddEnv 

func AddEnv(key, value string) StateOption

AddEnv returns a StateOption whichs adds an environment variable to the state. Use this with State.With to create a new state with the environment variable set. This is the equivalent of `[State.AddEnv]`

func AddEnvf 

func AddEnvf(key, value string, v ...any) StateOption

AddEnvf is the same as AddEnv but allows for a format string. This is the equivalent of `[State.AddEnvf]`

func Dir 

func Dir(str string) StateOption

Dir returns a StateOption sets the working directory for the state which will be used to resolve relative paths as well as the working directory for State.Run. See State.With for where to use this.

func Dirf 

func Dirf(str string, v ...any) StateOption

Dirf is the same as Dir but allows for a format string.

func Hostname 

func Hostname(str string) StateOption

Hostname returns a StateOption which sets the hostname used for containers created by State.Run. This is the equivalent of State.Hostname See State.With for where to use this.

func Network 

func Network(v pb.NetMode) StateOption

Network returns a StateOption which sets the network mode used for containers created by State.Run. This is the equivalent of State.Network See State.With for where to use this.

func Reset 

func Reset(other State) StateOption

Reset returns a StateOption which creates a new State with just the output of the current State and the provided State is set as the parent. This is the equivalent of State.Reset

func Security 

func Security(v pb.SecurityMode) StateOption

Security returns a StateOption which sets the security mode used for containers created by State.Run. This is the equivalent of State.Security See State.With for where to use this.

func User 

func User(str string) StateOption

User returns a StateOption which sets the user for the state which will be used by State.Run. This is the equivalent of State.User See State.With for where to use this.

func (StateOption) SetRunOption 

func (fn StateOption) SetRunOption(ei *ExecInfo)

type SymlinkInfo 

type SymlinkInfo struct {
	ChownOpt    *ChownOpt
	CreatedTime *time.Time
}

SymlinkInfo is the modifiable options used to create symlinks

func (*SymlinkInfo) SetSymlinkOption 

func (si *SymlinkInfo) SetSymlinkOption(si2 *SymlinkInfo)

type SymlinkOption 

type SymlinkOption interface {
	SetSymlinkOption(*SymlinkInfo)
}

type TmpfsInfo 

type TmpfsInfo struct {
	Size int64
}

type TmpfsOption 

type TmpfsOption interface {
	SetTmpfsOption(*TmpfsInfo)
}

func TmpfsSize 

func TmpfsSize(b int64) TmpfsOption

type UlimitName 

type UlimitName string
const (
	UlimitCore       UlimitName = "core"
	UlimitCPU        UlimitName = "cpu"
	UlimitData       UlimitName = "data"
	UlimitFsize      UlimitName = "fsize"
	UlimitLocks      UlimitName = "locks"
	UlimitMemlock    UlimitName = "memlock"
	UlimitMsgqueue   UlimitName = "msgqueue"
	UlimitNice       UlimitName = "nice"
	UlimitNofile     UlimitName = "nofile"
	UlimitNproc      UlimitName = "nproc"
	UlimitRss        UlimitName = "rss"
	UlimitRtprio     UlimitName = "rtprio"
	UlimitRttime     UlimitName = "rttime"
	UlimitSigpending UlimitName = "sigpending"
	UlimitStack      UlimitName = "stack"
)

type UserOpt 

type UserOpt struct {
	UID  int
	Name string
}

type Vertex 

type Vertex interface {
	Validate(context.Context, *Constraints) error
	Marshal(context.Context, *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)
	Output() Output
	Inputs() []Output
}

Source Files

async.go definition.go diff.go exec.go fileop.go marshal.go merge.go meta.go resolver.go source.go sourcemap.go state.go

Directories

PathSynopsis
client/llb/imagemetaresolver
client/llb/llbbuild
client/llb/llbtest
client/llb/sourceresolver
Version
v0.21.0 (latest)
Published
Apr 11, 2025
Platform
linux/amd64
Imports
33 packages
Last checked
1 hour ago –

Tools for package owners.