// buildImage invokes a docker build on a particular directory func buildImage(client DockerClient, dir string, dockerfilePath string, noCache bool, tag string, tar tar.Tar, pullAuth *docker.AuthConfigurations, forcePull bool) error { // TODO: be able to pass a stream directly to the Docker build to avoid the double temp hit r, w := io.Pipe() go func() { defer util.HandleCrash() defer w.Close() if err := tar.CreateTarStream(dir, false, w); err != nil { w.CloseWithError(err) } }() defer w.Close() glog.V(5).Infof("Invoking Docker build to create %q", tag) opts := docker.BuildImageOptions{ Name: tag, RmTmpContainer: true, OutputStream: os.Stdout, InputStream: r, Dockerfile: dockerfilePath, NoCache: noCache, Pull: forcePull, } if pullAuth != nil { opts.AuthConfigs = *pullAuth } return client.BuildImage(opts) }
// BuildImage builds a docker image using a directory that contains a Dockerfile func (d *ImageManager) BuildImage(dockerfileDirPath, name string, stdoutWriter io.WriteCloser) error { bio := dockerclient.BuildImageOptions{ Name: name, NoCache: true, ContextDir: filepath.Dir(dockerfileDirPath), OutputStream: stdoutWriter, } for _, envVar := range []string{"http_proxy", "https_proxy", "no_proxy"} { for _, name := range []string{strings.ToLower(envVar), strings.ToUpper(envVar)} { if val, ok := os.LookupEnv(name); ok { bio.BuildArgs = append(bio.BuildArgs, dockerclient.BuildArg{ Name: name, Value: val, }) } } } if stdoutWriter != nil { defer func() { stdoutWriter.Close() }() } if err := d.client.BuildImage(bio); err != nil { return err } return nil }
// BuildImageFromCallback builds a docker image by letting a callback popuplate // a tar.Writer; the callback must write a Dockerfile into the tar stream (as // well as any additional build context). If stdoutWriter implements io.Closer, // it will be closed when done. func (d *ImageManager) BuildImageFromCallback(name string, stdoutWriter io.Writer, callback func(*tar.Writer) error) error { pipeReader, pipeWriter, err := os.Pipe() if err != nil { return err } bio := dockerclient.BuildImageOptions{ Name: name, NoCache: true, InputStream: pipeReader, OutputStream: stdoutWriter, } for _, envVar := range []string{"http_proxy", "https_proxy", "no_proxy"} { for _, name := range []string{strings.ToLower(envVar), strings.ToUpper(envVar)} { if val, ok := os.LookupEnv(name); ok { bio.BuildArgs = append(bio.BuildArgs, dockerclient.BuildArg{ Name: name, Value: val, }) } } } if stdoutCloser, ok := stdoutWriter.(io.Closer); ok { defer func() { stdoutCloser.Close() }() } writerErrorChan := make(chan error, 1) go func() { defer close(writerErrorChan) defer pipeWriter.Close() tarWriter := tar.NewWriter(pipeWriter) var err error if err = callback(tarWriter); err == nil { err = tarWriter.Close() } writerErrorChan <- err }() err = d.client.BuildImage(bio) // Prefer returning the error from the tar writer; that normally // has more useful details. if writerErr := <-writerErrorChan; writerErr != nil { return writerErr } return err }
func buildImageOptions(option BuildOptions, stream LogStream) api.BuildImageOptions { json, output := stream.OutputStream() opts := api.BuildImageOptions{ Name: option.Name, NoCache: option.NoCache, SuppressOutput: buildQuiet, RmTmpContainer: buildRm, ForceRmTmpContainer: buildForceRm, Pull: option.Pull, OutputStream: output, ContextDir: option.Directory, RawJSONStream: json, Memory: buildMemory, Memswap: buildMemswap, } if auth := getAuth(); auth != nil { opts.AuthConfigs = *auth } return opts }
// buildImage invokes a docker build on a particular directory func buildImage(client DockerClient, dir string, noCache bool, tag string, tar tar.Tar, pullAuth *docker.AuthConfigurations, forcePull bool) error { tarFile, err := tar.CreateTarFile("", dir) if err != nil { return err } tarStream, err := os.Open(tarFile) if err != nil { return err } defer tarStream.Close() opts := docker.BuildImageOptions{ Name: tag, RmTmpContainer: true, OutputStream: os.Stdout, InputStream: tarStream, NoCache: noCache, Pull: forcePull, } if pullAuth != nil { opts.AuthConfigs = *pullAuth } return client.BuildImage(opts) }
// buildImage invokes a docker build on a particular directory func buildImage(client DockerClient, dir string, tar tar.Tar, opts *docker.BuildImageOptions) error { // TODO: be able to pass a stream directly to the Docker build to avoid the double temp hit if opts == nil { return fmt.Errorf("%s", "build image options nil") } r, w := io.Pipe() go func() { defer utilruntime.HandleCrash() defer w.Close() if err := tar.CreateTarStream(dir, false, w); err != nil { w.CloseWithError(err) } }() defer w.Close() opts.InputStream = r glog.V(5).Infof("Invoking Docker build to create %q", opts.Name) return client.BuildImage(*opts) }
// dockerBuild performs a docker build on the source that has been retrieved func (d *DockerBuilder) dockerBuild(dir string, tag string, secrets []api.SecretBuildSource) error { var noCache bool var forcePull bool dockerfilePath := defaultDockerfilePath if d.build.Spec.Strategy.DockerStrategy != nil { if d.build.Spec.Source.ContextDir != "" { dir = filepath.Join(dir, d.build.Spec.Source.ContextDir) } if d.build.Spec.Strategy.DockerStrategy.DockerfilePath != "" { dockerfilePath = d.build.Spec.Strategy.DockerStrategy.DockerfilePath } noCache = d.build.Spec.Strategy.DockerStrategy.NoCache forcePull = d.build.Spec.Strategy.DockerStrategy.ForcePull } auth, err := d.setupPullSecret() if err != nil { return err } if err := d.copySecrets(secrets, dir); err != nil { return err } opts := docker.BuildImageOptions{ Name: tag, RmTmpContainer: true, OutputStream: os.Stdout, Dockerfile: dockerfilePath, NoCache: noCache, Pull: forcePull, } if d.cgLimits != nil { opts.Memory = d.cgLimits.MemoryLimitBytes opts.Memswap = d.cgLimits.MemorySwap opts.CPUShares = d.cgLimits.CPUShares opts.CPUPeriod = d.cgLimits.CPUPeriod opts.CPUQuota = d.cgLimits.CPUQuota } if auth != nil { opts.AuthConfigs = *auth } return buildImage(d.dockerClient, dir, d.tar, &opts) }
// BuildImage builds the image according to specified options func (d *stiDocker) BuildImage(opts BuildImageOptions) error { dockerOpts := docker.BuildImageOptions{ Name: opts.Name, NoCache: true, SuppressOutput: false, RmTmpContainer: true, ForceRmTmpContainer: true, InputStream: opts.Stdin, OutputStream: opts.Stdout, } if opts.CGroupLimits != nil { dockerOpts.Memory = opts.CGroupLimits.MemoryLimitBytes dockerOpts.Memswap = opts.CGroupLimits.MemorySwap dockerOpts.CPUShares = opts.CGroupLimits.CPUShares dockerOpts.CPUPeriod = opts.CGroupLimits.CPUPeriod dockerOpts.CPUQuota = opts.CGroupLimits.CPUQuota } glog.V(2).Info("Building container using config: %+v", dockerOpts) return d.client.BuildImage(dockerOpts) }