// 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)
}
