mirror of https://github.com/hashicorp/packer
Mitchell Hashimoto
12 years ago
parent
96b0ec5395
commit
8054e66db6
@ -1,283 +0,0 @@
|
||||
package build
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"flag"
|
||||
"fmt"
|
||||
cmdcommon "github.com/mitchellh/packer/common/command"
|
||||
"github.com/mitchellh/packer/packer"
|
||||
"log"
|
||||
"os"
|
||||
"os/signal"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
type Command byte
|
||||
|
||||
func (Command) Help() string {
|
||||
return strings.TrimSpace(helpText)
|
||||
}
|
||||
|
||||
func (c Command) Run(env packer.Environment, args []string) int {
|
||||
var cfgColor, cfgDebug, cfgForce, cfgParallel bool
|
||||
buildOptions := new(cmdcommon.BuildOptions)
|
||||
|
||||
cmdFlags := flag.NewFlagSet("build", flag.ContinueOnError)
|
||||
cmdFlags.Usage = func() { env.Ui().Say(c.Help()) }
|
||||
cmdFlags.BoolVar(&cfgColor, "color", true, "enable or disable color")
|
||||
cmdFlags.BoolVar(&cfgDebug, "debug", false, "debug mode for builds")
|
||||
cmdFlags.BoolVar(&cfgForce, "force", false, "force a build if artifacts exist")
|
||||
cmdFlags.BoolVar(&cfgParallel, "parallel", true, "enable/disable parallelization")
|
||||
cmdcommon.BuildOptionFlags(cmdFlags, buildOptions)
|
||||
if err := cmdFlags.Parse(args); err != nil {
|
||||
return 1
|
||||
}
|
||||
|
||||
args = cmdFlags.Args()
|
||||
if len(args) != 1 {
|
||||
cmdFlags.Usage()
|
||||
return 1
|
||||
}
|
||||
|
||||
if err := buildOptions.Validate(); err != nil {
|
||||
env.Ui().Error(err.Error())
|
||||
env.Ui().Error("")
|
||||
env.Ui().Error(c.Help())
|
||||
return 1
|
||||
}
|
||||
|
||||
userVars, err := buildOptions.AllUserVars()
|
||||
if err != nil {
|
||||
env.Ui().Error(fmt.Sprintf("Error compiling user variables: %s", err))
|
||||
env.Ui().Error("")
|
||||
env.Ui().Error(c.Help())
|
||||
return 1
|
||||
}
|
||||
|
||||
// Read the file into a byte array so that we can parse the template
|
||||
log.Printf("Reading template: %s", args[0])
|
||||
tpl, err := packer.ParseTemplateFile(args[0], userVars)
|
||||
if err != nil {
|
||||
env.Ui().Error(fmt.Sprintf("Failed to parse template: %s", err))
|
||||
return 1
|
||||
}
|
||||
|
||||
// The component finder for our builds
|
||||
components := &packer.ComponentFinder{
|
||||
Builder: env.Builder,
|
||||
Hook: env.Hook,
|
||||
PostProcessor: env.PostProcessor,
|
||||
Provisioner: env.Provisioner,
|
||||
}
|
||||
|
||||
// Go through each builder and compile the builds that we care about
|
||||
builds, err := buildOptions.Builds(tpl, components)
|
||||
if err != nil {
|
||||
env.Ui().Error(err.Error())
|
||||
return 1
|
||||
}
|
||||
|
||||
if cfgDebug {
|
||||
env.Ui().Say("Debug mode enabled. Builds will not be parallelized.")
|
||||
}
|
||||
|
||||
// Compile all the UIs for the builds
|
||||
colors := [5]packer.UiColor{
|
||||
packer.UiColorGreen,
|
||||
packer.UiColorCyan,
|
||||
packer.UiColorMagenta,
|
||||
packer.UiColorYellow,
|
||||
packer.UiColorBlue,
|
||||
}
|
||||
|
||||
buildUis := make(map[string]packer.Ui)
|
||||
for i, b := range builds {
|
||||
var ui packer.Ui
|
||||
ui = env.Ui()
|
||||
if cfgColor {
|
||||
ui = &packer.ColoredUi{
|
||||
Color: colors[i%len(colors)],
|
||||
Ui: env.Ui(),
|
||||
}
|
||||
}
|
||||
|
||||
buildUis[b.Name()] = ui
|
||||
ui.Say(fmt.Sprintf("%s output will be in this color.", b.Name()))
|
||||
}
|
||||
|
||||
// Add a newline between the color output and the actual output
|
||||
env.Ui().Say("")
|
||||
|
||||
log.Printf("Build debug mode: %v", cfgDebug)
|
||||
log.Printf("Force build: %v", cfgForce)
|
||||
|
||||
// Set the debug and force mode and prepare all the builds
|
||||
for _, b := range builds {
|
||||
log.Printf("Preparing build: %s", b.Name())
|
||||
b.SetDebug(cfgDebug)
|
||||
b.SetForce(cfgForce)
|
||||
|
||||
warnings, err := b.Prepare()
|
||||
if err != nil {
|
||||
env.Ui().Error(err.Error())
|
||||
return 1
|
||||
}
|
||||
if len(warnings) > 0 {
|
||||
ui := buildUis[b.Name()]
|
||||
ui.Say(fmt.Sprintf("Warnings for build '%s':\n", b.Name()))
|
||||
for _, warning := range warnings {
|
||||
ui.Say(fmt.Sprintf("* %s", warning))
|
||||
}
|
||||
ui.Say("")
|
||||
}
|
||||
}
|
||||
|
||||
// Run all the builds in parallel and wait for them to complete
|
||||
var interruptWg, wg sync.WaitGroup
|
||||
interrupted := false
|
||||
artifacts := make(map[string][]packer.Artifact)
|
||||
errors := make(map[string]error)
|
||||
for _, b := range builds {
|
||||
// Increment the waitgroup so we wait for this item to finish properly
|
||||
wg.Add(1)
|
||||
|
||||
// Handle interrupts for this build
|
||||
sigCh := make(chan os.Signal, 1)
|
||||
signal.Notify(sigCh, os.Interrupt)
|
||||
defer signal.Stop(sigCh)
|
||||
go func(b packer.Build) {
|
||||
<-sigCh
|
||||
interruptWg.Add(1)
|
||||
defer interruptWg.Done()
|
||||
interrupted = true
|
||||
|
||||
log.Printf("Stopping build: %s", b.Name())
|
||||
b.Cancel()
|
||||
log.Printf("Build cancelled: %s", b.Name())
|
||||
}(b)
|
||||
|
||||
// Run the build in a goroutine
|
||||
go func(b packer.Build) {
|
||||
defer wg.Done()
|
||||
|
||||
name := b.Name()
|
||||
log.Printf("Starting build run: %s", name)
|
||||
ui := buildUis[name]
|
||||
runArtifacts, err := b.Run(ui, env.Cache())
|
||||
|
||||
if err != nil {
|
||||
ui.Error(fmt.Sprintf("Build '%s' errored: %s", name, err))
|
||||
errors[name] = err
|
||||
} else {
|
||||
ui.Say(fmt.Sprintf("Build '%s' finished.", name))
|
||||
artifacts[name] = runArtifacts
|
||||
}
|
||||
}(b)
|
||||
|
||||
if cfgDebug {
|
||||
log.Printf("Debug enabled, so waiting for build to finish: %s", b.Name())
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
if !cfgParallel {
|
||||
log.Printf("Parallelization disabled, waiting for build to finish: %s", b.Name())
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
if interrupted {
|
||||
log.Println("Interrupted, not going to start any more builds.")
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Wait for both the builds to complete and the interrupt handler,
|
||||
// if it is interrupted.
|
||||
log.Printf("Waiting on builds to complete...")
|
||||
wg.Wait()
|
||||
|
||||
log.Printf("Builds completed. Waiting on interrupt barrier...")
|
||||
interruptWg.Wait()
|
||||
|
||||
if interrupted {
|
||||
env.Ui().Say("Cleanly cancelled builds after being interrupted.")
|
||||
return 1
|
||||
}
|
||||
|
||||
if len(errors) > 0 {
|
||||
env.Ui().Machine("error-count", strconv.FormatInt(int64(len(errors)), 10))
|
||||
|
||||
env.Ui().Error("\n==> Some builds didn't complete successfully and had errors:")
|
||||
for name, err := range errors {
|
||||
// Create a UI for the machine readable stuff to be targetted
|
||||
ui := &packer.TargettedUi{
|
||||
Target: name,
|
||||
Ui: env.Ui(),
|
||||
}
|
||||
|
||||
ui.Machine("error", err.Error())
|
||||
|
||||
env.Ui().Error(fmt.Sprintf("--> %s: %s", name, err))
|
||||
}
|
||||
}
|
||||
|
||||
if len(artifacts) > 0 {
|
||||
env.Ui().Say("\n==> Builds finished. The artifacts of successful builds are:")
|
||||
for name, buildArtifacts := range artifacts {
|
||||
// Create a UI for the machine readable stuff to be targetted
|
||||
ui := &packer.TargettedUi{
|
||||
Target: name,
|
||||
Ui: env.Ui(),
|
||||
}
|
||||
|
||||
// Machine-readable helpful
|
||||
ui.Machine("artifact-count", strconv.FormatInt(int64(len(buildArtifacts)), 10))
|
||||
|
||||
for i, artifact := range buildArtifacts {
|
||||
var message bytes.Buffer
|
||||
fmt.Fprintf(&message, "--> %s: ", name)
|
||||
|
||||
if artifact != nil {
|
||||
fmt.Fprintf(&message, artifact.String())
|
||||
} else {
|
||||
fmt.Fprint(&message, "<nothing>")
|
||||
}
|
||||
|
||||
iStr := strconv.FormatInt(int64(i), 10)
|
||||
if artifact != nil {
|
||||
ui.Machine("artifact", iStr, "builder-id", artifact.BuilderId())
|
||||
ui.Machine("artifact", iStr, "id", artifact.Id())
|
||||
ui.Machine("artifact", iStr, "string", artifact.String())
|
||||
|
||||
files := artifact.Files()
|
||||
ui.Machine("artifact",
|
||||
iStr,
|
||||
"files-count", strconv.FormatInt(int64(len(files)), 10))
|
||||
for fi, file := range files {
|
||||
fiStr := strconv.FormatInt(int64(fi), 10)
|
||||
ui.Machine("artifact", iStr, "file", fiStr, file)
|
||||
}
|
||||
} else {
|
||||
ui.Machine("artifact", iStr, "nil")
|
||||
}
|
||||
|
||||
ui.Machine("artifact", iStr, "end")
|
||||
env.Ui().Say(message.String())
|
||||
}
|
||||
}
|
||||
} else {
|
||||
env.Ui().Say("\n==> Builds finished but no artifacts were created.")
|
||||
}
|
||||
|
||||
if len(errors) > 0 {
|
||||
// If any errors occurred, exit with a non-zero exit status
|
||||
return 1
|
||||
}
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
func (Command) Synopsis() string {
|
||||
return "build image(s) from template"
|
||||
}
|
||||
@ -1,54 +0,0 @@
|
||||
package build
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"github.com/mitchellh/packer/packer"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func testEnvironment() packer.Environment {
|
||||
config := packer.DefaultEnvironmentConfig()
|
||||
config.Ui = &packer.BasicUi{
|
||||
Reader: new(bytes.Buffer),
|
||||
Writer: new(bytes.Buffer),
|
||||
}
|
||||
|
||||
env, err := packer.NewEnvironment(config)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
return env
|
||||
}
|
||||
|
||||
func TestCommand_Implements(t *testing.T) {
|
||||
var _ packer.Command = new(Command)
|
||||
}
|
||||
|
||||
func TestCommand_Run_NoArgs(t *testing.T) {
|
||||
command := new(Command)
|
||||
result := command.Run(testEnvironment(), make([]string, 0))
|
||||
if result != 1 {
|
||||
t.Fatalf("bad: %d", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCommand_Run_MoreThanOneArg(t *testing.T) {
|
||||
command := new(Command)
|
||||
|
||||
args := []string{"one", "two"}
|
||||
result := command.Run(testEnvironment(), args)
|
||||
if result != 1 {
|
||||
t.Fatalf("bad: %d", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCommand_Run_MissingFile(t *testing.T) {
|
||||
command := new(Command)
|
||||
|
||||
args := []string{"i-better-not-exist"}
|
||||
result := command.Run(testEnvironment(), args)
|
||||
if result != 1 {
|
||||
t.Fatalf("bad: %d", result)
|
||||
}
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
package build
|
||||
|
||||
const helpText = `
|
||||
Usage: packer build [options] TEMPLATE
|
||||
|
||||
Will execute multiple builds in parallel as defined in the template.
|
||||
The various artifacts created by the template will be outputted.
|
||||
|
||||
Options:
|
||||
|
||||
-debug Debug mode enabled for builds
|
||||
-force Force a build to continue if artifacts exist, deletes existing artifacts
|
||||
-machine-readable Machine-readable output
|
||||
-except=foo,bar,baz Build all builds other than these
|
||||
-only=foo,bar,baz Only build the given builds by name
|
||||
-parallel=false Disable parallelization (on by default)
|
||||
-var 'key=value' Variable for templates, can be used multiple times.
|
||||
-var-file=path JSON file containing user variables.
|
||||
`
|
||||
@ -1,14 +0,0 @@
|
||||
package inspect
|
||||
|
||||
import (
|
||||
"github.com/mitchellh/packer/packer"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestCommand_Impl(t *testing.T) {
|
||||
var raw interface{}
|
||||
raw = new(Command)
|
||||
if _, ok := raw.(packer.Command); !ok {
|
||||
t.Fatalf("must be a Command")
|
||||
}
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
package inspect
|
||||
|
||||
const helpText = `
|
||||
Usage: packer inspect TEMPLATE
|
||||
|
||||
Inspects a template, parsing and outputting the components a template
|
||||
defines. This does not validate the contents of a template (other than
|
||||
basic syntax by necessity).
|
||||
|
||||
Options:
|
||||
|
||||
-machine-readable Machine-readable output
|
||||
`
|
||||
@ -1,14 +0,0 @@
|
||||
package validate
|
||||
|
||||
import (
|
||||
"github.com/mitchellh/packer/packer"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestCommand_Impl(t *testing.T) {
|
||||
var raw interface{}
|
||||
raw = new(Command)
|
||||
if _, ok := raw.(packer.Command); !ok {
|
||||
t.Fatalf("must be a Command")
|
||||
}
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
package validate
|
||||
|
||||
const helpString = `
|
||||
Usage: packer validate [options] TEMPLATE
|
||||
|
||||
Checks the template is valid by parsing the template and also
|
||||
checking the configuration with the various builders, provisioners, etc.
|
||||
|
||||
If it is not valid, the errors will be shown and the command will exit
|
||||
with a non-zero exit status. If it is valid, it will exit with a zero
|
||||
exit status.
|
||||
|
||||
Options:
|
||||
|
||||
-syntax-only Only check syntax. Do not verify config of the template.
|
||||
-except=foo,bar,baz Validate all builds other than these
|
||||
-only=foo,bar,baz Validate only these builds
|
||||
-var 'key=value' Variable for templates, can be used multiple times.
|
||||
-var-file=path JSON file containing user variables.
|
||||
`
|
||||
@ -0,0 +1,29 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"io"
|
||||
"os"
|
||||
)
|
||||
|
||||
// These are the environmental variables that determine if we log, and if
|
||||
// we log whether or not the log should go to a file.
|
||||
const EnvLog = "PACKER_LOG" //Set to True
|
||||
const EnvLogFile = "PACKER_LOG_PATH" //Set to a file
|
||||
|
||||
// logOutput determines where we should send logs (if anywhere).
|
||||
func logOutput() (logOutput io.Writer, err error) {
|
||||
logOutput = nil
|
||||
if os.Getenv(EnvLog) != "" {
|
||||
logOutput = os.Stderr
|
||||
|
||||
if logPath := os.Getenv(EnvLogFile); logPath != "" {
|
||||
var err error
|
||||
logOutput, err = os.Create(logPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"github.com/mitchellh/packer/command/build"
|
||||
"github.com/mitchellh/packer/packer/plugin"
|
||||
)
|
||||
|
||||
func main() {
|
||||
server, err := plugin.Server()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
server.RegisterCommand(new(build.Command))
|
||||
server.Serve()
|
||||
}
|
||||
@ -1 +0,0 @@
|
||||
package main
|
||||
@ -1,15 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"github.com/mitchellh/packer/command/inspect"
|
||||
"github.com/mitchellh/packer/packer/plugin"
|
||||
)
|
||||
|
||||
func main() {
|
||||
server, err := plugin.Server()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
server.RegisterCommand(new(inspect.Command))
|
||||
server.Serve()
|
||||
}
|
||||
@ -1 +0,0 @@
|
||||
package main
|
||||
@ -1,15 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"github.com/mitchellh/packer/command/validate"
|
||||
"github.com/mitchellh/packer/packer/plugin"
|
||||
)
|
||||
|
||||
func main() {
|
||||
server, err := plugin.Server()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
server.RegisterCommand(new(validate.Command))
|
||||
server.Serve()
|
||||
}
|
||||
@ -1 +0,0 @@
|
||||
package main
|
||||
Loading…
Reference in new issue