grim/convey

Bump the version
v0.14.0-alpha4
2018-02-20, Gary Kramlich
89afa53fab1b
Bump the version
// Convey
// Copyright 2016-2018 Gary Kramlich <grim@reaperworld.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
package docker
import (
"os"
"path/filepath"
"github.com/aphistic/gomol"
"bitbucket.org/rw_grim/convey/command"
"bitbucket.org/rw_grim/convey/environment"
"bitbucket.org/rw_grim/convey/state"
"bitbucket.org/rw_grim/convey/tasks"
"bitbucket.org/rw_grim/convey/yaml"
)
// Build defines the options for building a docker image.
type Build struct {
Dockerfile string `yaml:"dockerfile"`
Files yaml.StringOrSlice `yaml:"files"`
Tag string `yaml:"tag"`
Tags yaml.StringOrSlice `yaml:"tags"`
Target string `yaml:"target"`
Labels yaml.StringOrSlice `yaml:"labels"`
Arguments yaml.StringOrSlice `yaml:"arguments"`
}
// Execute runs the docker build command
func (b *Build) Execute(name string, logger *gomol.LogAdapter, env []string, st *state.State) error {
fullEnv := environment.Merge(env, st.GetEnv())
files, err := st.MapSlice(b.Files, fullEnv)
if err != nil {
return err
}
// create out build directory
buildDir := filepath.Join(st.Directory, name)
err = os.MkdirAll(buildDir, 0700)
if err != nil {
return err
}
dockerfile, err := environment.Mapper(b.Dockerfile, fullEnv)
if err != nil {
return err
}
// Export the files from the workspace
fileExport := &Export{
Files: append(files, dockerfile),
Path: buildDir,
}
err = fileExport.Valid()
if err != nil {
return err
}
err = fileExport.Execute(name, logger, fullEnv, st)
if err != nil {
return err
}
tags, err := st.MapSlice(b.Tags, fullEnv)
if err != nil {
return err
}
labels, err := st.MapSlice(b.Labels, fullEnv)
if err != nil {
return err
}
arguments, err := st.MapSlice(b.Arguments, fullEnv)
if err != nil {
return err
}
// create the basic command
cmd := command.NewGenerator(
"build",
"-f", filepath.Join(buildDir, filepath.Base(dockerfile)),
)
// add any and all tags
for _, tag := range tags {
cmd.Append("-t", tag)
}
// add any and all labels
for _, label := range labels {
cmd.Append("--label", label)
}
// add any and all build arguments
for _, arg := range arguments {
cmd.Append("--build-arg", arg)
}
// add the target if we have one
if b.Target != "" {
cmd.Append("--target", b.Target)
}
// finally add the build context
cmd.Append(buildDir)
return Docker(name, cmd.Command(), st)
}
// New creates a new docker build task.
func (b *Build) New() tasks.Task {
return &Build{}
}
// Valid checks that the build task is valid.
func (b *Build) Valid() error {
if b.Dockerfile == "" {
return errNoDockerFile
}
if b.Tag != "" {
b.Tags = append([]string{b.Tag}, b.Tags...)
}
if len(b.Tags) == 0 {
return errNoTag
}
return nil
}