types

Documentation

Index

• Constants
• func FixPerms(rootfs string) (err error)
• type Bundle
  • func NewBundle(parentPath, tempDir string) (b *Bundle, err error)
  • func NewEncryptedBundle(parentPath, tempDir string, keyInfo *cryptkey.KeyInfo) (b *Bundle, err error)
  • func (b *Bundle) Remove() error
  • func (b *Bundle) RunSection(s string) bool
• type Data
• type Definition
  • func NewDefinitionFromJSON(r io.Reader) (d Definition, err error)
  • func NewDefinitionFromURI(uri string) (d Definition, err error)
• type FileTransport
• type Files
• type ImageData
• type ImageScripts
• type Options
• type Script
• type Scripts

Constants

const OCIConfigJSON = "oci-config"

Functions

func FixPerms

func FixPerms(rootfs string) (err error)

FixPerms will work through the rootfs of this bundle, making sure that all files and directories have permissions set such that the owner can read, modify, delete. This brings us to the situation of <=3.4

Types

type Bundle

type Bundle struct {
	JSONObjects map[string][]byte `json:"jsonObjects"`
	Recipe      Definition        `json:"rawDeffile"`
	Opts        Options           `json:"opts"`

	RootfsPath string `json:"rootfsPath"` // where actual fs to chroot will appear
	TmpDir     string `json:"tmpPath"`    // where temp files required during build will appear
	// contains filtered or unexported fields
}

Bundle is the temporary environment used during the image building process.

func NewBundle

func NewBundle(parentPath, tempDir string) (b *Bundle, err error)

NewBundle creates a Bundle environment.

func NewEncryptedBundle

func NewEncryptedBundle(parentPath, tempDir string, keyInfo *cryptkey.KeyInfo) (b *Bundle, err error)

NewEncryptedBundle creates an Encrypted Bundle environment.

func (*Bundle) Remove

func (b *Bundle) Remove() error

Remove cleans up any bundle files.

func (*Bundle) RunSection

func (b *Bundle) RunSection(s string) bool

RunSection iterates through the sections specified in a bundle and returns true if the given string, s, is a section of the definition that should be executed during the build process.

type Data

type Data struct {
	Files   []Files `json:"files"`
	Scripts `json:"buildScripts"`
}

Data contains any scripts, metadata, etc... that the Builder may need to know only at build time to build the image.

type Definition

type Definition struct {
	Header     map[string]string `json:"header"`
	ImageData  `json:"imageData"`
	BuildData  Data              `json:"buildData"`
	CustomData map[string]string `json:"customData"`
	Raw        []byte            `json:"raw"`
	// SCIF app sections must be processed in order from the definition file,
	// so we need to record the order of the items as they are parsed from the
	// file into unordered maps.
	AppOrder []string `json:"appOrder"`
}

Definition describes how to build an image.

func NewDefinitionFromJSON

func NewDefinitionFromJSON(r io.Reader) (d Definition, err error)

NewDefinitionFromJSON creates a new Definition using the supplied JSON.

func NewDefinitionFromURI

func NewDefinitionFromURI(uri string) (d Definition, err error)

NewDefinitionFromURI crafts a new Definition given a URI.

type FileTransport

type FileTransport struct {
	Src string `json:"source"`
	Dst string `json:"destination"`
}

FileTransport holds source and destination information of files to copy into the container.

type Files

type Files struct {
	Args  string          `json:"args"`
	Files []FileTransport `json:"files"`
}

Files describes a %files section of a definition.

type ImageData

type ImageData struct {
	Metadata     []byte            `json:"metadata"`
	Labels       map[string]string `json:"labels"`
	ImageScripts `json:"imageScripts"`
}

ImageData contains any scripts, metadata, etc... that needs to be present in some form in the final built image.

type ImageScripts

type ImageScripts struct {
	Help        Script `json:"help"`
	Environment Script `json:"environment"`
	Runscript   Script `json:"runScript"`
	Test        Script `json:"test"`
	Startscript Script `json:"startScript"`
}

ImageScripts contains scripts that are used after build time.

type Options

type Options struct {
	// Sections are the parts of the definition to run during the build.
	Sections []string `json:"sections"`
	// TmpDir specifies a non-standard temporary location to perform a build.
	TmpDir string
	// LibraryURL contains URL to library where base images can be pulled.
	LibraryURL string `json:"libraryURL"`
	// LibraryAuthToken contains authentication token to access specified library.
	LibraryAuthToken string `json:"libraryAuthToken"`
	// Path to fakeroot command will be empty if not needed or not available
	FakerootPath string `json:"fakerootPath"`
	// KeyServerOpts contains options for keyserver used for SIF fingerprint verification in builds.
	KeyServerOpts []keyClient.Option
	// contains docker credentials if specified.
	DockerAuthConfig *ocitypes.DockerAuthConfig
	// EncryptionKeyInfo specifies the key used for filesystem
	// encryption if applicable.
	// A nil value indicates encryption should not occur.
	EncryptionKeyInfo *cryptkey.KeyInfo
	// ImgCache stores a pointer to the image cache to use.
	ImgCache *cache.Handle
	// NoTest indicates if build should skip running the test script.
	NoTest bool `json:"noTest"`
	// Force automatically deletes an existing container at build destination while performing build.
	Force bool `json:"force"`
	// Update detects and builds using an existing sandbox container at build destination.
	Update bool `json:"update"`
	// NoHTTPS instructs builder not to use secure connection.
	NoHTTPS bool `json:"noHTTPS"`
	// NoCleanUp allows a user to prevent a bundle from being cleaned up after a failed build.
	// useful for debugging.
	NoCleanUp bool `json:"noCleanUp"`
	// NoCache when true, will not use any cache, or make cache.
	NoCache bool
	// FixPerms controls if we will ensure owner rwX on container content
	// to preserve <=3.4 behavior.
	// TODO: Deprecate in 3.6, remove in 3.8
	FixPerms bool
	// To warn when the above is needed, we need to know if the target of this
	// bundle will be a sandbox
	SandboxTarget bool
}

Options defines build time behavior to be executed on the bundle.

type Script

type Script struct {
	Args   string `json:"args"`
	Script string `json:"script"`
}

Script describes any script section of a definition.

type Scripts

type Scripts struct {
	Pre   Script `json:"pre"`
	Setup Script `json:"setup"`
	Post  Script `json:"post"`
	Test  Script `json:"test"`
}

Scripts defines scripts that are used at build time.