| package builder |
| |
| // This file contains the dispatchers for each command. Note that |
| // `nullDispatch` is not actually a command, but support for commands we parse |
| // but do nothing with. |
| // |
| // See evaluator.go for a higher level discussion of the whole evaluator |
| // package. |
| |
| import ( |
| "fmt" |
| "io/ioutil" |
| "path" |
| "path/filepath" |
| "regexp" |
| "runtime" |
| "sort" |
| "strings" |
| |
| "github.com/Sirupsen/logrus" |
| flag "github.com/docker/docker/pkg/mflag" |
| "github.com/docker/docker/pkg/nat" |
| "github.com/docker/docker/runconfig" |
| ) |
| |
| const ( |
| // NoBaseImageSpecifier is the symbol used by the FROM |
| // command to specify that no base image is to be used. |
| NoBaseImageSpecifier string = "scratch" |
| ) |
| |
| // dispatch with no layer / parsing. This is effectively not a command. |
| func nullDispatch(b *builder, args []string, attributes map[string]bool, original string) error { |
| return nil |
| } |
| |
| // ENV foo bar |
| // |
| // Sets the environment variable foo to bar, also makes interpolation |
| // in the dockerfile available from the next statement on via ${foo}. |
| // |
| func env(b *builder, args []string, attributes map[string]bool, original string) error { |
| if len(args) == 0 { |
| return fmt.Errorf("ENV requires at least one argument") |
| } |
| |
| if len(args)%2 != 0 { |
| // should never get here, but just in case |
| return fmt.Errorf("Bad input to ENV, too many args") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| // TODO/FIXME/NOT USED |
| // Just here to show how to use the builder flags stuff within the |
| // context of a builder command. Will remove once we actually add |
| // a builder command to something! |
| /* |
| flBool1 := b.BuilderFlags.AddBool("bool1", false) |
| flStr1 := b.BuilderFlags.AddString("str1", "HI") |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| fmt.Printf("Bool1:%v\n", flBool1) |
| fmt.Printf("Str1:%v\n", flStr1) |
| */ |
| |
| commitStr := "ENV" |
| |
| for j := 0; j < len(args); j++ { |
| // name ==> args[j] |
| // value ==> args[j+1] |
| newVar := args[j] + "=" + args[j+1] + "" |
| commitStr += " " + newVar |
| |
| gotOne := false |
| for i, envVar := range b.Config.Env { |
| envParts := strings.SplitN(envVar, "=", 2) |
| if envParts[0] == args[j] { |
| b.Config.Env[i] = newVar |
| gotOne = true |
| break |
| } |
| } |
| if !gotOne { |
| b.Config.Env = append(b.Config.Env, newVar) |
| } |
| j++ |
| } |
| |
| return b.commit("", b.Config.Cmd, commitStr) |
| } |
| |
| // MAINTAINER some text <maybe@an.email.address> |
| // |
| // Sets the maintainer metadata. |
| func maintainer(b *builder, args []string, attributes map[string]bool, original string) error { |
| if len(args) != 1 { |
| return fmt.Errorf("MAINTAINER requires exactly one argument") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| b.maintainer = args[0] |
| return b.commit("", b.Config.Cmd, fmt.Sprintf("MAINTAINER %s", b.maintainer)) |
| } |
| |
| // LABEL some json data describing the image |
| // |
| // Sets the Label variable foo to bar, |
| // |
| func label(b *builder, args []string, attributes map[string]bool, original string) error { |
| if len(args) == 0 { |
| return fmt.Errorf("LABEL requires at least one argument") |
| } |
| if len(args)%2 != 0 { |
| // should never get here, but just in case |
| return fmt.Errorf("Bad input to LABEL, too many args") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| commitStr := "LABEL" |
| |
| if b.Config.Labels == nil { |
| b.Config.Labels = map[string]string{} |
| } |
| |
| for j := 0; j < len(args); j++ { |
| // name ==> args[j] |
| // value ==> args[j+1] |
| newVar := args[j] + "=" + args[j+1] + "" |
| commitStr += " " + newVar |
| |
| b.Config.Labels[args[j]] = args[j+1] |
| j++ |
| } |
| return b.commit("", b.Config.Cmd, commitStr) |
| } |
| |
| // ADD foo /path |
| // |
| // Add the file 'foo' to '/path'. Tarball and Remote URL (git, http) handling |
| // exist here. If you do not wish to have this automatic handling, use COPY. |
| // |
| func add(b *builder, args []string, attributes map[string]bool, original string) error { |
| if len(args) < 2 { |
| return fmt.Errorf("ADD requires at least two arguments") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| return b.runContextCommand(args, true, true, "ADD") |
| } |
| |
| // COPY foo /path |
| // |
| // Same as 'ADD' but without the tar and remote url handling. |
| // |
| func dispatchCopy(b *builder, args []string, attributes map[string]bool, original string) error { |
| if len(args) < 2 { |
| return fmt.Errorf("COPY requires at least two arguments") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| return b.runContextCommand(args, false, false, "COPY") |
| } |
| |
| // FROM imagename |
| // |
| // This sets the image the dockerfile will build on top of. |
| // |
| func from(b *builder, args []string, attributes map[string]bool, original string) error { |
| if len(args) != 1 { |
| return fmt.Errorf("FROM requires one argument") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| name := args[0] |
| |
| if name == NoBaseImageSpecifier { |
| b.image = "" |
| b.noBaseImage = true |
| return nil |
| } |
| |
| image, err := b.Daemon.Repositories().LookupImage(name) |
| if b.Pull { |
| image, err = b.pullImage(name) |
| if err != nil { |
| return err |
| } |
| } |
| if err != nil { |
| if b.Daemon.Graph().IsNotExist(err, name) { |
| image, err = b.pullImage(name) |
| } |
| |
| // note that the top level err will still be !nil here if IsNotExist is |
| // not the error. This approach just simplifies the logic a bit. |
| if err != nil { |
| return err |
| } |
| } |
| |
| return b.processImageFrom(image) |
| } |
| |
| // ONBUILD RUN echo yo |
| // |
| // ONBUILD triggers run when the image is used in a FROM statement. |
| // |
| // ONBUILD handling has a lot of special-case functionality, the heading in |
| // evaluator.go and comments around dispatch() in the same file explain the |
| // special cases. search for 'OnBuild' in internals.go for additional special |
| // cases. |
| // |
| func onbuild(b *builder, args []string, attributes map[string]bool, original string) error { |
| if len(args) == 0 { |
| return fmt.Errorf("ONBUILD requires at least one argument") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| triggerInstruction := strings.ToUpper(strings.TrimSpace(args[0])) |
| switch triggerInstruction { |
| case "ONBUILD": |
| return fmt.Errorf("Chaining ONBUILD via `ONBUILD ONBUILD` isn't allowed") |
| case "MAINTAINER", "FROM": |
| return fmt.Errorf("%s isn't allowed as an ONBUILD trigger", triggerInstruction) |
| } |
| |
| original = regexp.MustCompile(`(?i)^\s*ONBUILD\s*`).ReplaceAllString(original, "") |
| |
| b.Config.OnBuild = append(b.Config.OnBuild, original) |
| return b.commit("", b.Config.Cmd, fmt.Sprintf("ONBUILD %s", original)) |
| } |
| |
| // WORKDIR /tmp |
| // |
| // Set the working directory for future RUN/CMD/etc statements. |
| // |
| func workdir(b *builder, args []string, attributes map[string]bool, original string) error { |
| if len(args) != 1 { |
| return fmt.Errorf("WORKDIR requires exactly one argument") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| // Note that workdir passed comes from the Dockerfile. Hence it is in |
| // Linux format using forward-slashes, even on Windows. However, |
| // b.Config.WorkingDir is in platform-specific notation (in other words |
| // on Windows will use `\` |
| workdir := args[0] |
| |
| isAbs := false |
| if runtime.GOOS == "windows" { |
| // Alternate processing for Windows here is necessary as we can't call |
| // filepath.IsAbs(workDir) as that would verify Windows style paths, |
| // along with drive-letters (eg c:\pathto\file.txt). We (arguably |
| // correctly or not) check for both forward and back slashes as this |
| // is what the 1.4.2 GoLang implementation of IsAbs() does in the |
| // isSlash() function. |
| isAbs = workdir[0] == '\\' || workdir[0] == '/' |
| } else { |
| isAbs = filepath.IsAbs(workdir) |
| } |
| |
| if !isAbs { |
| current := b.Config.WorkingDir |
| if runtime.GOOS == "windows" { |
| // Convert to Linux format before join |
| current = strings.Replace(current, "\\", "/", -1) |
| } |
| // Must use path.Join so works correctly on Windows, not filepath |
| workdir = path.Join("/", current, workdir) |
| } |
| |
| // Convert to platform specific format |
| if runtime.GOOS == "windows" { |
| workdir = strings.Replace(workdir, "/", "\\", -1) |
| } |
| b.Config.WorkingDir = workdir |
| |
| return b.commit("", b.Config.Cmd, fmt.Sprintf("WORKDIR %v", workdir)) |
| } |
| |
| // RUN some command yo |
| // |
| // run a command and commit the image. Args are automatically prepended with |
| // 'sh -c' under linux or 'cmd /S /C' under Windows, in the event there is |
| // only one argument. The difference in processing: |
| // |
| // RUN echo hi # sh -c echo hi (Linux) |
| // RUN echo hi # cmd /S /C echo hi (Windows) |
| // RUN [ "echo", "hi" ] # echo hi |
| // |
| func run(b *builder, args []string, attributes map[string]bool, original string) error { |
| if b.image == "" && !b.noBaseImage { |
| return fmt.Errorf("Please provide a source image with `from` prior to run") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| args = handleJSONArgs(args, attributes) |
| |
| if !attributes["json"] { |
| if runtime.GOOS != "windows" { |
| args = append([]string{"/bin/sh", "-c"}, args...) |
| } else { |
| args = append([]string{"cmd", "/S /C"}, args...) |
| } |
| } |
| |
| runCmd := flag.NewFlagSet("run", flag.ContinueOnError) |
| runCmd.SetOutput(ioutil.Discard) |
| runCmd.Usage = nil |
| |
| config, _, _, err := runconfig.Parse(runCmd, append([]string{b.image}, args...)) |
| if err != nil { |
| return err |
| } |
| |
| cmd := b.Config.Cmd |
| // set Cmd manually, this is special case only for Dockerfiles |
| b.Config.Cmd = config.Cmd |
| runconfig.Merge(b.Config, config) |
| |
| defer func(cmd *runconfig.Command) { b.Config.Cmd = cmd }(cmd) |
| |
| logrus.Debugf("[BUILDER] Command to be executed: %v", b.Config.Cmd) |
| |
| hit, err := b.probeCache() |
| if err != nil { |
| return err |
| } |
| if hit { |
| return nil |
| } |
| |
| c, err := b.create() |
| if err != nil { |
| return err |
| } |
| |
| // Ensure that we keep the container mounted until the commit |
| // to avoid unmounting and then mounting directly again |
| c.Mount() |
| defer c.Unmount() |
| |
| err = b.run(c) |
| if err != nil { |
| return err |
| } |
| if err := b.commit(c.ID, cmd, "run"); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| // CMD foo |
| // |
| // Set the default command to run in the container (which may be empty). |
| // Argument handling is the same as RUN. |
| // |
| func cmd(b *builder, args []string, attributes map[string]bool, original string) error { |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| cmdSlice := handleJSONArgs(args, attributes) |
| |
| if !attributes["json"] { |
| if runtime.GOOS != "windows" { |
| cmdSlice = append([]string{"/bin/sh", "-c"}, cmdSlice...) |
| } else { |
| cmdSlice = append([]string{"cmd", "/S /C"}, cmdSlice...) |
| } |
| } |
| |
| b.Config.Cmd = runconfig.NewCommand(cmdSlice...) |
| |
| if err := b.commit("", b.Config.Cmd, fmt.Sprintf("CMD %q", cmdSlice)); err != nil { |
| return err |
| } |
| |
| if len(args) != 0 { |
| b.cmdSet = true |
| } |
| |
| return nil |
| } |
| |
| // ENTRYPOINT /usr/sbin/nginx |
| // |
| // Set the entrypoint (which defaults to sh -c on linux, or cmd /S /C on Windows) to |
| // /usr/sbin/nginx. Will accept the CMD as the arguments to /usr/sbin/nginx. |
| // |
| // Handles command processing similar to CMD and RUN, only b.Config.Entrypoint |
| // is initialized at NewBuilder time instead of through argument parsing. |
| // |
| func entrypoint(b *builder, args []string, attributes map[string]bool, original string) error { |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| parsed := handleJSONArgs(args, attributes) |
| |
| switch { |
| case attributes["json"]: |
| // ENTRYPOINT ["echo", "hi"] |
| b.Config.Entrypoint = runconfig.NewEntrypoint(parsed...) |
| case len(parsed) == 0: |
| // ENTRYPOINT [] |
| b.Config.Entrypoint = nil |
| default: |
| // ENTRYPOINT echo hi |
| if runtime.GOOS != "windows" { |
| b.Config.Entrypoint = runconfig.NewEntrypoint("/bin/sh", "-c", parsed[0]) |
| } else { |
| b.Config.Entrypoint = runconfig.NewEntrypoint("cmd", "/S /C", parsed[0]) |
| } |
| } |
| |
| // when setting the entrypoint if a CMD was not explicitly set then |
| // set the command to nil |
| if !b.cmdSet { |
| b.Config.Cmd = nil |
| } |
| |
| if err := b.commit("", b.Config.Cmd, fmt.Sprintf("ENTRYPOINT %q", b.Config.Entrypoint)); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| // EXPOSE 6667/tcp 7000/tcp |
| // |
| // Expose ports for links and port mappings. This all ends up in |
| // b.Config.ExposedPorts for runconfig. |
| // |
| func expose(b *builder, args []string, attributes map[string]bool, original string) error { |
| portsTab := args |
| |
| if len(args) == 0 { |
| return fmt.Errorf("EXPOSE requires at least one argument") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| if b.Config.ExposedPorts == nil { |
| b.Config.ExposedPorts = make(nat.PortSet) |
| } |
| |
| ports, _, err := nat.ParsePortSpecs(portsTab) |
| if err != nil { |
| return err |
| } |
| |
| // instead of using ports directly, we build a list of ports and sort it so |
| // the order is consistent. This prevents cache burst where map ordering |
| // changes between builds |
| portList := make([]string, len(ports)) |
| var i int |
| for port := range ports { |
| if _, exists := b.Config.ExposedPorts[port]; !exists { |
| b.Config.ExposedPorts[port] = struct{}{} |
| } |
| portList[i] = string(port) |
| i++ |
| } |
| sort.Strings(portList) |
| return b.commit("", b.Config.Cmd, fmt.Sprintf("EXPOSE %s", strings.Join(portList, " "))) |
| } |
| |
| // USER foo |
| // |
| // Set the user to 'foo' for future commands and when running the |
| // ENTRYPOINT/CMD at container run time. |
| // |
| func user(b *builder, args []string, attributes map[string]bool, original string) error { |
| if runtime.GOOS == "windows" { |
| return fmt.Errorf("USER is not supported on Windows") |
| } |
| |
| if len(args) != 1 { |
| return fmt.Errorf("USER requires exactly one argument") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| b.Config.User = args[0] |
| return b.commit("", b.Config.Cmd, fmt.Sprintf("USER %v", args)) |
| } |
| |
| // VOLUME /foo |
| // |
| // Expose the volume /foo for use. Will also accept the JSON array form. |
| // |
| func volume(b *builder, args []string, attributes map[string]bool, original string) error { |
| if runtime.GOOS == "windows" { |
| return fmt.Errorf("VOLUME is not supported on Windows") |
| } |
| if len(args) == 0 { |
| return fmt.Errorf("VOLUME requires at least one argument") |
| } |
| |
| if err := b.BuilderFlags.Parse(); err != nil { |
| return err |
| } |
| |
| if b.Config.Volumes == nil { |
| b.Config.Volumes = map[string]struct{}{} |
| } |
| for _, v := range args { |
| v = strings.TrimSpace(v) |
| if v == "" { |
| return fmt.Errorf("Volume specified can not be an empty string") |
| } |
| b.Config.Volumes[v] = struct{}{} |
| } |
| if err := b.commit("", b.Config.Cmd, fmt.Sprintf("VOLUME %v", args)); err != nil { |
| return err |
| } |
| return nil |
| } |