2014-08-15 20:29:35 +04:00
|
|
|
// builder is the evaluation step in the Dockerfile parse/evaluate pipeline.
|
2014-08-07 09:56:44 +04:00
|
|
|
//
|
|
|
|
// It incorporates a dispatch table based on the parser.Node values (see the
|
|
|
|
// parser package for more information) that are yielded from the parser itself.
|
|
|
|
// Calling NewBuilder with the BuildOpts struct can be used to customize the
|
|
|
|
// experience for execution purposes only. Parsing is controlled in the parser
|
|
|
|
// package, and this division of resposibility should be respected.
|
|
|
|
//
|
|
|
|
// Please see the jump table targets for the actual invocations, most of which
|
|
|
|
// will call out to the functions in internals.go to deal with their tasks.
|
|
|
|
//
|
|
|
|
// ONBUILD is a special case, which is covered in the onbuild() func in
|
|
|
|
// dispatchers.go.
|
|
|
|
//
|
|
|
|
// The evaluator uses the concept of "steps", which are usually each processable
|
|
|
|
// line in the Dockerfile. Each step is numbered and certain actions are taken
|
|
|
|
// before and after each step, such as creating an image ID and removing temporary
|
|
|
|
// containers and images. Note that ONBUILD creates a kinda-sorta "sub run" which
|
|
|
|
// includes its own set of steps (usually only one of them).
|
2014-08-15 20:29:35 +04:00
|
|
|
package builder
|
2014-08-06 00:17:40 +04:00
|
|
|
|
|
|
|
import (
|
2014-08-06 02:41:09 +04:00
|
|
|
"errors"
|
2014-08-06 00:17:40 +04:00
|
|
|
"fmt"
|
|
|
|
"io"
|
2014-08-06 02:41:09 +04:00
|
|
|
"os"
|
2015-01-21 22:08:19 +03:00
|
|
|
"path/filepath"
|
2014-08-06 00:17:40 +04:00
|
|
|
"strings"
|
|
|
|
|
2014-10-24 21:12:35 +04:00
|
|
|
log "github.com/Sirupsen/logrus"
|
2015-02-17 21:25:36 +03:00
|
|
|
"github.com/docker/docker/api"
|
2015-02-12 08:18:48 +03:00
|
|
|
"github.com/docker/docker/builder/command"
|
2014-08-06 02:41:09 +04:00
|
|
|
"github.com/docker/docker/builder/parser"
|
2014-08-06 00:17:40 +04:00
|
|
|
"github.com/docker/docker/daemon"
|
|
|
|
"github.com/docker/docker/engine"
|
2015-02-21 07:48:23 +03:00
|
|
|
"github.com/docker/docker/pkg/common"
|
2014-10-24 01:30:11 +04:00
|
|
|
"github.com/docker/docker/pkg/fileutils"
|
2015-02-03 00:17:12 +03:00
|
|
|
"github.com/docker/docker/pkg/symlink"
|
2014-08-06 02:41:09 +04:00
|
|
|
"github.com/docker/docker/pkg/tarsum"
|
2014-08-06 00:17:40 +04:00
|
|
|
"github.com/docker/docker/registry"
|
|
|
|
"github.com/docker/docker/runconfig"
|
|
|
|
"github.com/docker/docker/utils"
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
2014-08-06 02:41:09 +04:00
|
|
|
ErrDockerfileEmpty = errors.New("Dockerfile cannot be empty")
|
2014-08-06 00:17:40 +04:00
|
|
|
)
|
|
|
|
|
2014-10-25 22:29:18 +04:00
|
|
|
// Environment variable interpolation will happen on these statements only.
|
|
|
|
var replaceEnvAllowed = map[string]struct{}{
|
2015-02-12 08:18:48 +03:00
|
|
|
command.Env: {},
|
2015-03-17 08:23:40 +03:00
|
|
|
command.Label: {},
|
2015-02-12 08:18:48 +03:00
|
|
|
command.Add: {},
|
|
|
|
command.Copy: {},
|
|
|
|
command.Workdir: {},
|
|
|
|
command.Expose: {},
|
|
|
|
command.Volume: {},
|
|
|
|
command.User: {},
|
2014-10-25 22:29:18 +04:00
|
|
|
}
|
|
|
|
|
2015-02-12 08:18:48 +03:00
|
|
|
var evaluateTable map[string]func(*Builder, []string, map[string]bool, string) error
|
2014-08-06 02:41:09 +04:00
|
|
|
|
|
|
|
func init() {
|
2015-02-12 08:18:48 +03:00
|
|
|
evaluateTable = map[string]func(*Builder, []string, map[string]bool, string) error{
|
|
|
|
command.Env: env,
|
2015-02-17 18:20:06 +03:00
|
|
|
command.Label: label,
|
2015-02-12 08:18:48 +03:00
|
|
|
command.Maintainer: maintainer,
|
|
|
|
command.Add: add,
|
|
|
|
command.Copy: dispatchCopy, // copy() is a go builtin
|
|
|
|
command.From: from,
|
|
|
|
command.Onbuild: onbuild,
|
|
|
|
command.Workdir: workdir,
|
|
|
|
command.Run: run,
|
|
|
|
command.Cmd: cmd,
|
|
|
|
command.Entrypoint: entrypoint,
|
|
|
|
command.Expose: expose,
|
|
|
|
command.Volume: volume,
|
|
|
|
command.User: user,
|
|
|
|
command.Insert: insert,
|
2014-08-06 02:41:09 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-07 09:56:44 +04:00
|
|
|
// internal struct, used to maintain configuration of the Dockerfile's
|
|
|
|
// processing as it evaluates the parsing result.
|
2014-08-26 23:25:44 +04:00
|
|
|
type Builder struct {
|
2014-08-07 09:56:44 +04:00
|
|
|
Daemon *daemon.Daemon
|
|
|
|
Engine *engine.Engine
|
|
|
|
|
|
|
|
// effectively stdio for the run. Because it is not stdio, I said
|
|
|
|
// "Effectively". Do not use stdio anywhere in this package for any reason.
|
|
|
|
OutStream io.Writer
|
|
|
|
ErrStream io.Writer
|
|
|
|
|
|
|
|
Verbose bool
|
|
|
|
UtilizeCache bool
|
2015-02-25 21:27:32 +03:00
|
|
|
cacheBusted bool
|
2014-08-07 09:56:44 +04:00
|
|
|
|
|
|
|
// controls how images and containers are handled between steps.
|
|
|
|
Remove bool
|
|
|
|
ForceRemove bool
|
2014-11-21 20:51:32 +03:00
|
|
|
Pull bool
|
2014-08-07 09:56:44 +04:00
|
|
|
|
2015-01-10 00:07:00 +03:00
|
|
|
// set this to true if we want the builder to not commit between steps.
|
|
|
|
// This is useful when we only want to use the evaluator table to generate
|
|
|
|
// the final configs of the Dockerfile but dont want the layers
|
|
|
|
disableCommit bool
|
|
|
|
|
2014-08-06 02:41:09 +04:00
|
|
|
AuthConfig *registry.AuthConfig
|
|
|
|
AuthConfigFile *registry.ConfigFile
|
|
|
|
|
|
|
|
// Deprecated, original writer used for ImagePull. To be removed.
|
2014-08-06 00:17:40 +04:00
|
|
|
OutOld io.Writer
|
|
|
|
StreamFormatter *utils.StreamFormatter
|
2014-08-26 23:25:44 +04:00
|
|
|
|
|
|
|
Config *runconfig.Config // runconfig for cmd, run, entrypoint etc.
|
|
|
|
|
|
|
|
// both of these are controlled by the Remove and ForceRemove options in BuildOpts
|
|
|
|
TmpContainers map[string]struct{} // a map of containers used for removes
|
|
|
|
|
2014-09-11 18:42:17 +04:00
|
|
|
dockerfileName string // name of Dockerfile
|
|
|
|
dockerfile *parser.Node // the syntax tree of the dockerfile
|
|
|
|
image string // image name for commit processing
|
|
|
|
maintainer string // maintainer name. could probably be removed.
|
|
|
|
cmdSet bool // indicates is CMD was set in current Dockerfile
|
|
|
|
context tarsum.TarSum // the context is a tarball that is uploaded by the client
|
|
|
|
contextPath string // the path of the temporary directory the local context is unpacked to (server side)
|
|
|
|
noBaseImage bool // indicates that this build does not start from any base image, but is being built from an empty file system.
|
2015-02-06 17:33:01 +03:00
|
|
|
|
|
|
|
// Set resource restrictions for build containers
|
|
|
|
cpuSetCpus string
|
|
|
|
cpuShares int64
|
|
|
|
memory int64
|
|
|
|
memorySwap int64
|
2014-08-06 00:17:40 +04:00
|
|
|
}
|
|
|
|
|
2014-08-07 09:56:44 +04:00
|
|
|
// Run the builder with the context. This is the lynchpin of this package. This
|
|
|
|
// will (barring errors):
|
|
|
|
//
|
|
|
|
// * call readContext() which will set up the temporary directory and unpack
|
|
|
|
// the context into it.
|
|
|
|
// * read the dockerfile
|
|
|
|
// * parse the dockerfile
|
|
|
|
// * walk the parse tree and execute it by dispatching to handlers. If Remove
|
|
|
|
// or ForceRemove is set, additional cleanup around containers happens after
|
|
|
|
// processing.
|
|
|
|
// * Print a happy message and return the image ID.
|
|
|
|
//
|
2014-08-26 23:25:44 +04:00
|
|
|
func (b *Builder) Run(context io.Reader) (string, error) {
|
2014-08-07 09:56:44 +04:00
|
|
|
if err := b.readContext(context); err != nil {
|
2014-08-06 02:41:09 +04:00
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2014-09-15 17:01:23 +04:00
|
|
|
defer func() {
|
|
|
|
if err := os.RemoveAll(b.contextPath); err != nil {
|
|
|
|
log.Debugf("[BUILDER] failed to remove temporary context: %s", err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2015-02-17 21:25:36 +03:00
|
|
|
if err := b.readDockerfile(); err != nil {
|
2014-08-06 02:41:09 +04:00
|
|
|
return "", err
|
|
|
|
}
|
2014-08-26 23:25:44 +04:00
|
|
|
|
|
|
|
// some initializations that would not have been supplied by the caller.
|
2014-10-24 04:23:25 +04:00
|
|
|
b.Config = &runconfig.Config{}
|
2015-02-06 17:33:01 +03:00
|
|
|
|
2014-08-26 23:25:44 +04:00
|
|
|
b.TmpContainers = map[string]struct{}{}
|
2014-08-06 00:17:40 +04:00
|
|
|
|
2014-08-26 23:25:44 +04:00
|
|
|
for i, n := range b.dockerfile.Children {
|
2014-08-06 00:17:40 +04:00
|
|
|
if err := b.dispatch(i, n); err != nil {
|
2014-08-26 23:25:44 +04:00
|
|
|
if b.ForceRemove {
|
2014-08-19 15:14:21 +04:00
|
|
|
b.clearTmp()
|
2014-08-06 02:41:09 +04:00
|
|
|
}
|
|
|
|
return "", err
|
2014-08-13 14:07:41 +04:00
|
|
|
}
|
2015-02-21 07:48:23 +03:00
|
|
|
fmt.Fprintf(b.OutStream, " ---> %s\n", common.TruncateID(b.image))
|
2014-08-26 23:25:44 +04:00
|
|
|
if b.Remove {
|
2014-08-19 15:14:21 +04:00
|
|
|
b.clearTmp()
|
2014-08-06 00:17:40 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-06 02:41:09 +04:00
|
|
|
if b.image == "" {
|
2015-02-10 22:10:10 +03:00
|
|
|
return "", fmt.Errorf("No image was generated. Is your Dockerfile empty?")
|
2014-08-06 02:41:09 +04:00
|
|
|
}
|
|
|
|
|
2015-02-21 07:48:23 +03:00
|
|
|
fmt.Fprintf(b.OutStream, "Successfully built %s\n", common.TruncateID(b.image))
|
2014-08-06 02:41:09 +04:00
|
|
|
return b.image, nil
|
2014-08-06 00:17:40 +04:00
|
|
|
}
|
|
|
|
|
2014-10-24 01:30:11 +04:00
|
|
|
// Reads a Dockerfile from the current context. It assumes that the
|
|
|
|
// 'filename' is a relative path from the root of the context
|
2015-02-17 21:25:36 +03:00
|
|
|
func (b *Builder) readDockerfile() error {
|
|
|
|
// If no -f was specified then look for 'Dockerfile'. If we can't find
|
|
|
|
// that then look for 'dockerfile'. If neither are found then default
|
|
|
|
// back to 'Dockerfile' and use that in the error message.
|
|
|
|
if b.dockerfileName == "" {
|
|
|
|
b.dockerfileName = api.DefaultDockerfileName
|
|
|
|
tmpFN := filepath.Join(b.contextPath, api.DefaultDockerfileName)
|
|
|
|
if _, err := os.Lstat(tmpFN); err != nil {
|
|
|
|
tmpFN = filepath.Join(b.contextPath, strings.ToLower(api.DefaultDockerfileName))
|
|
|
|
if _, err := os.Lstat(tmpFN); err == nil {
|
|
|
|
b.dockerfileName = strings.ToLower(api.DefaultDockerfileName)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
origFile := b.dockerfileName
|
|
|
|
|
2015-02-03 00:17:12 +03:00
|
|
|
filename, err := symlink.FollowSymlinkInScope(filepath.Join(b.contextPath, origFile), b.contextPath)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("The Dockerfile (%s) must be within the build context", origFile)
|
2015-01-21 22:08:19 +03:00
|
|
|
}
|
2014-10-24 01:30:11 +04:00
|
|
|
|
2015-02-03 00:17:12 +03:00
|
|
|
fi, err := os.Lstat(filename)
|
2014-10-24 01:30:11 +04:00
|
|
|
if os.IsNotExist(err) {
|
2015-01-21 22:08:19 +03:00
|
|
|
return fmt.Errorf("Cannot locate specified Dockerfile: %s", origFile)
|
2014-10-24 01:30:11 +04:00
|
|
|
}
|
|
|
|
if fi.Size() == 0 {
|
|
|
|
return ErrDockerfileEmpty
|
|
|
|
}
|
|
|
|
|
|
|
|
f, err := os.Open(filename)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
b.dockerfile, err = parser.Parse(f)
|
|
|
|
f.Close()
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// After the Dockerfile has been parsed, we need to check the .dockerignore
|
|
|
|
// file for either "Dockerfile" or ".dockerignore", and if either are
|
|
|
|
// present then erase them from the build context. These files should never
|
|
|
|
// have been sent from the client but we did send them to make sure that
|
|
|
|
// we had the Dockerfile to actually parse, and then we also need the
|
|
|
|
// .dockerignore file to know whether either file should be removed.
|
|
|
|
// Note that this assumes the Dockerfile has been read into memory and
|
|
|
|
// is now safe to be removed.
|
|
|
|
|
2015-01-21 22:08:19 +03:00
|
|
|
excludes, _ := utils.ReadDockerIgnore(filepath.Join(b.contextPath, ".dockerignore"))
|
2014-10-24 01:30:11 +04:00
|
|
|
if rm, _ := fileutils.Matches(".dockerignore", excludes); rm == true {
|
2015-01-21 22:08:19 +03:00
|
|
|
os.Remove(filepath.Join(b.contextPath, ".dockerignore"))
|
2014-10-24 01:30:11 +04:00
|
|
|
b.context.(tarsum.BuilderContext).Remove(".dockerignore")
|
|
|
|
}
|
2014-09-11 18:42:17 +04:00
|
|
|
if rm, _ := fileutils.Matches(b.dockerfileName, excludes); rm == true {
|
2015-01-21 22:08:19 +03:00
|
|
|
os.Remove(filepath.Join(b.contextPath, b.dockerfileName))
|
2014-09-11 18:42:17 +04:00
|
|
|
b.context.(tarsum.BuilderContext).Remove(b.dockerfileName)
|
2014-10-24 01:30:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-08-07 09:56:44 +04:00
|
|
|
// This method is the entrypoint to all statement handling routines.
|
|
|
|
//
|
|
|
|
// Almost all nodes will have this structure:
|
|
|
|
// Child[Node, Node, Node] where Child is from parser.Node.Children and each
|
|
|
|
// node comes from parser.Node.Next. This forms a "line" with a statement and
|
|
|
|
// arguments and we process them in this normalized form by hitting
|
2015-02-12 08:18:48 +03:00
|
|
|
// evaluateTable with the leaf nodes of the command and the Builder object.
|
2014-08-07 09:56:44 +04:00
|
|
|
//
|
|
|
|
// ONBUILD is a special case; in this case the parser will emit:
|
|
|
|
// Child[Node, Child[Node, Node...]] where the first node is the literal
|
|
|
|
// "onbuild" and the child entrypoint is the command of the ONBUILD statmeent,
|
|
|
|
// such as `RUN` in ONBUILD RUN foo. There is special case logic in here to
|
|
|
|
// deal with that, at least until it becomes more of a general concern with new
|
|
|
|
// features.
|
2014-08-26 23:25:44 +04:00
|
|
|
func (b *Builder) dispatch(stepN int, ast *parser.Node) error {
|
2014-08-06 00:17:40 +04:00
|
|
|
cmd := ast.Value
|
2014-08-13 14:07:41 +04:00
|
|
|
attrs := ast.Attributes
|
2014-10-14 00:14:35 +04:00
|
|
|
original := ast.Original
|
2014-08-06 00:17:40 +04:00
|
|
|
strs := []string{}
|
2014-08-13 14:07:41 +04:00
|
|
|
msg := fmt.Sprintf("Step %d : %s", stepN, strings.ToUpper(cmd))
|
2014-08-06 02:41:09 +04:00
|
|
|
|
|
|
|
if cmd == "onbuild" {
|
2015-02-04 20:34:25 +03:00
|
|
|
if ast.Next == nil {
|
|
|
|
return fmt.Errorf("ONBUILD requires at least one argument")
|
|
|
|
}
|
2014-08-06 02:41:09 +04:00
|
|
|
ast = ast.Next.Children[0]
|
2014-10-25 22:29:18 +04:00
|
|
|
strs = append(strs, ast.Value)
|
2014-08-13 14:07:41 +04:00
|
|
|
msg += " " + ast.Value
|
2014-08-06 02:41:09 +04:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:37:47 +03:00
|
|
|
// count the number of nodes that we are going to traverse first
|
|
|
|
// so we can pre-create the argument and message array. This speeds up the
|
|
|
|
// allocation of those list a lot when they have a lot of arguments
|
|
|
|
cursor := ast
|
|
|
|
var n int
|
|
|
|
for cursor.Next != nil {
|
|
|
|
cursor = cursor.Next
|
|
|
|
n++
|
|
|
|
}
|
|
|
|
l := len(strs)
|
|
|
|
strList := make([]string, n+l)
|
|
|
|
copy(strList, strs)
|
|
|
|
msgList := make([]string, n)
|
|
|
|
|
|
|
|
var i int
|
2014-08-06 00:17:40 +04:00
|
|
|
for ast.Next != nil {
|
|
|
|
ast = ast.Next
|
2014-10-25 22:29:18 +04:00
|
|
|
var str string
|
|
|
|
str = ast.Value
|
|
|
|
if _, ok := replaceEnvAllowed[cmd]; ok {
|
|
|
|
str = b.replaceEnv(ast.Value)
|
|
|
|
}
|
2014-11-11 22:37:47 +03:00
|
|
|
strList[i+l] = str
|
|
|
|
msgList[i] = ast.Value
|
|
|
|
i++
|
2014-08-06 00:17:40 +04:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:37:47 +03:00
|
|
|
msg += " " + strings.Join(msgList, " ")
|
2014-08-26 23:25:44 +04:00
|
|
|
fmt.Fprintln(b.OutStream, msg)
|
2014-08-06 00:17:40 +04:00
|
|
|
|
|
|
|
// XXX yes, we skip any cmds that are not valid; the parser should have
|
|
|
|
// picked these out already.
|
2015-02-12 08:18:48 +03:00
|
|
|
if f, ok := evaluateTable[cmd]; ok {
|
2014-11-11 22:37:47 +03:00
|
|
|
return f(b, strList, attrs, original)
|
2014-08-06 00:17:40 +04:00
|
|
|
}
|
|
|
|
|
2015-02-05 18:23:25 +03:00
|
|
|
return fmt.Errorf("Unknown instruction: %s", strings.ToUpper(cmd))
|
2014-08-06 00:17:40 +04:00
|
|
|
}
|