2013-03-23 02:00:23 -04:00
|
|
|
// This is the main package for the `packer` application.
|
|
|
|
package main
|
|
|
|
|
2013-03-25 19:29:26 -04:00
|
|
|
import (
|
2013-05-10 20:01:24 -04:00
|
|
|
"fmt"
|
2013-07-13 22:00:44 -04:00
|
|
|
"io"
|
2013-05-08 17:45:17 -04:00
|
|
|
"io/ioutil"
|
2013-05-08 12:46:37 -04:00
|
|
|
"log"
|
2013-03-25 19:29:26 -04:00
|
|
|
"os"
|
2013-06-20 15:37:17 -04:00
|
|
|
"path/filepath"
|
2013-05-08 21:30:39 -04:00
|
|
|
"runtime"
|
2014-10-27 23:31:02 -04:00
|
|
|
"sync"
|
2014-09-02 18:29:37 -04:00
|
|
|
|
2014-10-27 23:21:13 -04:00
|
|
|
"github.com/mitchellh/cli"
|
2015-05-27 23:09:52 -04:00
|
|
|
"github.com/mitchellh/packer/command"
|
2014-09-02 18:29:37 -04:00
|
|
|
"github.com/mitchellh/packer/packer"
|
|
|
|
"github.com/mitchellh/packer/packer/plugin"
|
|
|
|
"github.com/mitchellh/panicwrap"
|
2014-10-27 23:31:02 -04:00
|
|
|
"github.com/mitchellh/prefixedio"
|
2013-03-25 19:29:26 -04:00
|
|
|
)
|
2013-03-23 21:40:26 -04:00
|
|
|
|
2013-03-23 02:00:23 -04:00
|
|
|
func main() {
|
2013-08-13 23:54:35 -04:00
|
|
|
// Call realMain instead of doing the work here so we can use
|
|
|
|
// `defer` statements within the function and have them work properly.
|
|
|
|
// (defers aren't called with os.Exit)
|
|
|
|
os.Exit(realMain())
|
|
|
|
}
|
2013-07-13 22:00:44 -04:00
|
|
|
|
2013-08-13 23:54:35 -04:00
|
|
|
// realMain is executed from main and returns the exit status to exit with.
|
|
|
|
func realMain() int {
|
2014-10-27 23:31:02 -04:00
|
|
|
var wrapConfig panicwrap.WrapConfig
|
2013-05-08 21:30:39 -04:00
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
if !panicwrap.Wrapped(&wrapConfig) {
|
|
|
|
// Determine where logs should go in general (requested by the user)
|
|
|
|
logWriter, err := logOutput()
|
|
|
|
if err != nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "Couldn't setup log output: %s", err)
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
if logWriter == nil {
|
|
|
|
logWriter = ioutil.Discard
|
|
|
|
}
|
2013-08-13 23:54:35 -04:00
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
// We always send logs to a temporary file that we use in case
|
|
|
|
// there is a panic. Otherwise, we delete it.
|
|
|
|
logTempFile, err := ioutil.TempFile("", "packer-log")
|
|
|
|
if err != nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "Couldn't setup logging tempfile: %s", err)
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
defer os.Remove(logTempFile.Name())
|
|
|
|
defer logTempFile.Close()
|
|
|
|
|
|
|
|
// Tell the logger to log to this file
|
|
|
|
os.Setenv(EnvLog, "")
|
|
|
|
os.Setenv(EnvLogFile, "")
|
|
|
|
|
|
|
|
// Setup the prefixed readers that send data properly to
|
|
|
|
// stdout/stderr.
|
|
|
|
doneCh := make(chan struct{})
|
|
|
|
outR, outW := io.Pipe()
|
|
|
|
go copyOutput(outR, doneCh)
|
|
|
|
|
|
|
|
// Create the configuration for panicwrap and wrap our executable
|
|
|
|
wrapConfig.Handler = panicHandler(logTempFile)
|
|
|
|
wrapConfig.Writer = io.MultiWriter(logTempFile, logWriter)
|
|
|
|
wrapConfig.Stdout = outW
|
|
|
|
exitStatus, err := panicwrap.Wrap(&wrapConfig)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "Couldn't start Packer: %s", err)
|
|
|
|
return 1
|
|
|
|
}
|
2013-08-13 23:54:35 -04:00
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
// If >= 0, we're the parent, so just exit
|
|
|
|
if exitStatus >= 0 {
|
|
|
|
// Close the stdout writer so that our copy process can finish
|
|
|
|
outW.Close()
|
2013-08-13 23:54:35 -04:00
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
// Wait for the output copying to finish
|
|
|
|
<-doneCh
|
2013-08-13 23:54:35 -04:00
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
return exitStatus
|
|
|
|
}
|
2013-08-13 23:54:35 -04:00
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
// We're the child, so just close the tempfile we made in order to
|
|
|
|
// save file handles since the tempfile is only used by the parent.
|
|
|
|
logTempFile.Close()
|
2013-08-13 23:54:35 -04:00
|
|
|
}
|
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
// Call the real main
|
2013-08-13 23:54:35 -04:00
|
|
|
return wrappedMain()
|
|
|
|
}
|
|
|
|
|
|
|
|
// wrappedMain is called only when we're wrapped by panicwrap and
|
|
|
|
// returns the exit status to exit with.
|
|
|
|
func wrappedMain() int {
|
2014-10-27 23:31:02 -04:00
|
|
|
// If there is no explicit number of Go threads to use, then set it
|
|
|
|
if os.Getenv("GOMAXPROCS") == "" {
|
|
|
|
runtime.GOMAXPROCS(runtime.NumCPU())
|
|
|
|
}
|
|
|
|
|
2013-08-13 23:54:35 -04:00
|
|
|
log.SetOutput(os.Stderr)
|
|
|
|
|
2013-07-08 18:37:01 -04:00
|
|
|
log.Printf(
|
2014-10-27 23:51:34 -04:00
|
|
|
"[INFO] Packer version: %s %s %s",
|
|
|
|
Version, VersionPrerelease, GitCommit)
|
2013-07-01 12:34:43 -04:00
|
|
|
log.Printf("Packer Target OS/Arch: %s %s", runtime.GOOS, runtime.GOARCH)
|
2013-11-11 11:42:27 -05:00
|
|
|
log.Printf("Built with Go Version: %s", runtime.Version())
|
2013-07-01 10:37:03 -04:00
|
|
|
|
2013-07-26 02:27:13 -04:00
|
|
|
// Prepare stdin for plugin usage by switching it to a pipe
|
|
|
|
setupStdin()
|
|
|
|
|
2013-06-09 01:26:49 -04:00
|
|
|
config, err := loadConfig()
|
2013-05-08 21:13:15 -04:00
|
|
|
if err != nil {
|
2013-06-09 01:26:49 -04:00
|
|
|
fmt.Fprintf(os.Stderr, "Error loading configuration: \n\n%s\n", err)
|
2013-08-13 23:54:35 -04:00
|
|
|
return 1
|
2013-05-08 21:13:15 -04:00
|
|
|
}
|
2013-06-09 01:26:49 -04:00
|
|
|
log.Printf("Packer config: %+v", config)
|
2013-05-08 23:56:44 -04:00
|
|
|
|
2014-09-08 17:10:17 -04:00
|
|
|
// Fire off the checkpoint.
|
2014-09-08 17:17:27 -04:00
|
|
|
go runCheckpoint(config)
|
2014-09-08 17:10:17 -04:00
|
|
|
|
2013-06-20 15:18:03 -04:00
|
|
|
cacheDir := os.Getenv("PACKER_CACHE_DIR")
|
|
|
|
if cacheDir == "" {
|
|
|
|
cacheDir = "packer_cache"
|
|
|
|
}
|
2013-06-10 00:28:32 -04:00
|
|
|
|
2013-06-20 15:37:17 -04:00
|
|
|
cacheDir, err = filepath.Abs(cacheDir)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "Error preparing cache directory: \n\n%s\n", err)
|
2013-08-13 23:54:35 -04:00
|
|
|
return 1
|
2013-06-20 15:37:17 -04:00
|
|
|
}
|
|
|
|
|
2013-06-20 15:18:03 -04:00
|
|
|
log.Printf("Setting cache directory: %s", cacheDir)
|
|
|
|
cache := &packer.FileCache{CacheDir: cacheDir}
|
|
|
|
|
2013-08-12 02:12:20 -04:00
|
|
|
// Determine if we're in machine-readable mode by mucking around with
|
|
|
|
// the arguments...
|
|
|
|
args, machineReadable := extractMachineReadable(os.Args[1:])
|
|
|
|
|
2013-06-20 15:37:17 -04:00
|
|
|
defer plugin.CleanupClients()
|
|
|
|
|
2015-05-27 23:09:52 -04:00
|
|
|
// Setup the UI if we're being machine-readable
|
|
|
|
var ui packer.Ui = &packer.BasicUi{
|
|
|
|
Reader: os.Stdin,
|
|
|
|
Writer: os.Stdout,
|
|
|
|
ErrorWriter: os.Stdout,
|
|
|
|
}
|
2013-08-12 02:12:20 -04:00
|
|
|
if machineReadable {
|
2015-05-27 23:09:52 -04:00
|
|
|
ui = &packer.MachineReadableUi{
|
2013-08-12 02:12:20 -04:00
|
|
|
Writer: os.Stdout,
|
|
|
|
}
|
2013-12-16 17:10:28 -05:00
|
|
|
|
|
|
|
// Set this so that we don't get colored output in our machine-
|
|
|
|
// readable UI.
|
|
|
|
if err := os.Setenv("PACKER_NO_COLOR", "1"); err != nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "Packer failed to initialize UI: %s\n", err)
|
|
|
|
return 1
|
|
|
|
}
|
2013-08-12 02:12:20 -04:00
|
|
|
}
|
2013-04-21 22:04:35 -04:00
|
|
|
|
2015-05-27 23:09:52 -04:00
|
|
|
// Create the CLI meta
|
|
|
|
CommandMeta = &command.Meta{
|
|
|
|
CoreConfig: &packer.CoreConfig{
|
|
|
|
Components: packer.ComponentFinder{
|
|
|
|
Builder: config.LoadBuilder,
|
|
|
|
Hook: config.LoadHook,
|
|
|
|
PostProcessor: config.LoadPostProcessor,
|
|
|
|
Provisioner: config.LoadProvisioner,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Cache: cache,
|
|
|
|
Ui: ui,
|
|
|
|
}
|
|
|
|
|
2014-10-27 23:21:13 -04:00
|
|
|
//setupSignalHandlers(env)
|
2013-04-20 21:00:03 -04:00
|
|
|
|
2014-10-27 23:21:13 -04:00
|
|
|
cli := &cli.CLI{
|
|
|
|
Args: args,
|
|
|
|
Commands: Commands,
|
|
|
|
HelpFunc: cli.BasicHelpFunc("packer"),
|
|
|
|
HelpWriter: os.Stdout,
|
2014-12-13 13:26:58 -05:00
|
|
|
Version: Version,
|
2014-10-27 23:21:13 -04:00
|
|
|
}
|
2013-06-04 01:40:05 -04:00
|
|
|
|
2014-10-27 23:21:13 -04:00
|
|
|
exitCode, err := cli.Run()
|
2013-05-08 17:53:20 -04:00
|
|
|
if err != nil {
|
2014-10-27 23:21:13 -04:00
|
|
|
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err)
|
2013-08-13 23:54:35 -04:00
|
|
|
return 1
|
2013-05-08 17:53:20 -04:00
|
|
|
}
|
|
|
|
|
2013-08-13 23:54:35 -04:00
|
|
|
return exitCode
|
2013-03-23 02:00:23 -04:00
|
|
|
}
|
2013-06-09 01:26:49 -04:00
|
|
|
|
2013-08-12 02:12:20 -04:00
|
|
|
// extractMachineReadable checks the args for the machine readable
|
|
|
|
// flag and returns whether or not it is on. It modifies the args
|
|
|
|
// to remove this flag.
|
|
|
|
func extractMachineReadable(args []string) ([]string, bool) {
|
|
|
|
for i, arg := range args {
|
2013-08-12 02:26:24 -04:00
|
|
|
if arg == "-machine-readable" {
|
2013-08-12 02:12:20 -04:00
|
|
|
// We found it. Slice it out.
|
|
|
|
result := make([]string, len(args)-1)
|
|
|
|
copy(result, args[:i])
|
|
|
|
copy(result[i:], args[i+1:])
|
|
|
|
return result, true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return args, false
|
|
|
|
}
|
|
|
|
|
2013-06-09 01:26:49 -04:00
|
|
|
func loadConfig() (*config, error) {
|
|
|
|
var config config
|
2014-09-02 18:29:37 -04:00
|
|
|
config.PluginMinPort = 10000
|
|
|
|
config.PluginMaxPort = 25000
|
|
|
|
if err := config.Discover(); err != nil {
|
2013-06-09 01:26:49 -04:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2013-06-18 01:09:07 -04:00
|
|
|
configFilePath := os.Getenv("PACKER_CONFIG")
|
|
|
|
if configFilePath == "" {
|
|
|
|
var err error
|
|
|
|
configFilePath, err = configFile()
|
|
|
|
|
2013-06-09 01:26:49 -04:00
|
|
|
if err != nil {
|
2013-07-09 02:28:07 -04:00
|
|
|
log.Printf("Error detecting default config file path: %s", err)
|
2013-06-09 01:26:49 -04:00
|
|
|
}
|
2013-06-18 01:09:07 -04:00
|
|
|
}
|
2013-06-09 01:26:49 -04:00
|
|
|
|
2013-06-18 01:09:07 -04:00
|
|
|
if configFilePath == "" {
|
|
|
|
return &config, nil
|
2013-06-09 01:26:49 -04:00
|
|
|
}
|
|
|
|
|
2013-06-18 01:09:07 -04:00
|
|
|
log.Printf("Attempting to open config file: %s", configFilePath)
|
|
|
|
f, err := os.Open(configFilePath)
|
2013-06-09 01:26:49 -04:00
|
|
|
if err != nil {
|
|
|
|
if !os.IsNotExist(err) {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2015-06-13 10:17:42 -04:00
|
|
|
log.Println("[WARN] Config file doesn't exist: %s", configFilePath)
|
2013-06-09 01:26:49 -04:00
|
|
|
return &config, nil
|
|
|
|
}
|
|
|
|
defer f.Close()
|
|
|
|
|
|
|
|
if err := decodeConfig(f, &config); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return &config, nil
|
|
|
|
}
|
2013-08-13 23:54:35 -04:00
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
// copyOutput uses output prefixes to determine whether data on stdout
|
|
|
|
// should go to stdout or stderr. This is due to panicwrap using stderr
|
|
|
|
// as the log and error channel.
|
|
|
|
func copyOutput(r io.Reader, doneCh chan<- struct{}) {
|
|
|
|
defer close(doneCh)
|
|
|
|
|
|
|
|
pr, err := prefixedio.NewReader(r)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
stderrR, err := pr.Prefix(ErrorPrefix)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
stdoutR, err := pr.Prefix(OutputPrefix)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
defaultR, err := pr.Prefix("")
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
2013-08-13 23:54:35 -04:00
|
|
|
}
|
|
|
|
|
2014-10-27 23:31:02 -04:00
|
|
|
var wg sync.WaitGroup
|
|
|
|
wg.Add(3)
|
|
|
|
go func() {
|
|
|
|
defer wg.Done()
|
|
|
|
io.Copy(os.Stderr, stderrR)
|
|
|
|
}()
|
|
|
|
go func() {
|
|
|
|
defer wg.Done()
|
|
|
|
io.Copy(os.Stdout, stdoutR)
|
|
|
|
}()
|
|
|
|
go func() {
|
|
|
|
defer wg.Done()
|
|
|
|
io.Copy(os.Stdout, defaultR)
|
|
|
|
}()
|
|
|
|
|
|
|
|
wg.Wait()
|
2013-08-13 23:54:35 -04:00
|
|
|
}
|