2013-05-22 16:25:03 -04:00
|
|
|
package packer
|
|
|
|
|
2013-08-31 02:39:29 -04:00
|
|
|
import (
|
2019-03-19 12:29:00 -04:00
|
|
|
"context"
|
2013-12-21 00:39:23 -05:00
|
|
|
"fmt"
|
2017-03-12 18:46:35 -04:00
|
|
|
"log"
|
2013-08-31 02:39:29 -04:00
|
|
|
"sync"
|
2013-12-21 00:36:41 -05:00
|
|
|
"time"
|
2019-12-14 06:32:38 -05:00
|
|
|
|
|
|
|
"github.com/hashicorp/packer/helper/common"
|
2013-08-31 02:39:29 -04:00
|
|
|
)
|
|
|
|
|
2013-05-22 16:25:03 -04:00
|
|
|
// A provisioner is responsible for installing and configuring software
|
|
|
|
// on a machine prior to building the actual image.
|
|
|
|
type Provisioner interface {
|
2013-06-06 20:02:02 -04:00
|
|
|
// Prepare is called with a set of configurations to setup the
|
|
|
|
// internal state of the provisioner. The multiple configurations
|
|
|
|
// should be merged in some sane way.
|
2013-06-06 20:07:42 -04:00
|
|
|
Prepare(...interface{}) error
|
2013-05-22 16:25:03 -04:00
|
|
|
|
2019-03-19 13:11:19 -04:00
|
|
|
// Provision is called to actually provision the machine. A context is
|
|
|
|
// given for cancellation, a UI is given to communicate with the user, and
|
|
|
|
// a communicator is given that is guaranteed to be connected to some
|
|
|
|
// machine so that provisioning can be done.
|
2019-12-12 13:59:44 -05:00
|
|
|
Provision(context.Context, Ui, Communicator, map[string]interface{}) error
|
2013-05-22 16:25:03 -04:00
|
|
|
}
|
2013-05-24 00:13:18 -04:00
|
|
|
|
2017-11-04 16:06:36 -04:00
|
|
|
// A HookedProvisioner represents a provisioner and information describing it
|
|
|
|
type HookedProvisioner struct {
|
|
|
|
Provisioner Provisioner
|
|
|
|
Config interface{}
|
|
|
|
TypeName string
|
|
|
|
}
|
|
|
|
|
2013-05-24 00:13:18 -04:00
|
|
|
// A Hook implementation that runs the given provisioners.
|
|
|
|
type ProvisionHook struct {
|
|
|
|
// The provisioners to run as part of the hook. These should already
|
|
|
|
// be prepared (by calling Prepare) at some earlier stage.
|
2017-11-04 16:06:36 -04:00
|
|
|
Provisioners []*HookedProvisioner
|
2013-05-24 00:13:18 -04:00
|
|
|
}
|
|
|
|
|
2019-12-14 06:32:38 -05:00
|
|
|
// Provisioners interpolate most of their fields in the prepare stage; this
|
|
|
|
// placeholder map helps keep fields that are only generated at build time from
|
|
|
|
// accidentally being interpolated into empty strings at prepare time.
|
|
|
|
// This helper function generates the most basic placeholder data which should
|
|
|
|
// be accessible to the provisioners. It is used to initialize provisioners, to
|
|
|
|
// force validation using the `generated` template function. In the future,
|
|
|
|
// custom generated data could be passed into provisioners from builders to
|
|
|
|
// enable specialized builder-specific (but still validated!!) access to builder
|
|
|
|
// data.
|
|
|
|
func BasicPlaceholderData() map[string]string {
|
|
|
|
placeholderData := map[string]string{}
|
|
|
|
msg := "Generated_%s. " + common.PlaceholderMsg
|
|
|
|
placeholderData["ID"] = fmt.Sprintf(msg, "ID")
|
|
|
|
// The following correspond to communicator-agnostic functions that are
|
|
|
|
// part of the SSH and WinRM communicator implementations. These functions
|
|
|
|
// are not part of the communicator interface, but are stored on the
|
|
|
|
// Communicator Config and return the appropriate values rather than
|
|
|
|
// depending on the actual communicator config values. E.g "Password"
|
|
|
|
// reprosents either WinRMPassword or SSHPassword, which makes this more
|
|
|
|
// useful if a template contains multiple builds.
|
|
|
|
placeholderData["Host"] = fmt.Sprintf(msg, "Host")
|
|
|
|
placeholderData["Port"] = fmt.Sprintf(msg, "Port")
|
|
|
|
placeholderData["User"] = fmt.Sprintf(msg, "User")
|
|
|
|
placeholderData["Password"] = fmt.Sprintf(msg, "Password")
|
|
|
|
placeholderData["ConnType"] = fmt.Sprintf(msg, "Type")
|
|
|
|
placeholderData["PACKER_RUN_UUID"] = fmt.Sprintf(msg, "PACKER_RUN_UUID")
|
|
|
|
placeholderData["SSHPublicKey"] = fmt.Sprintf(msg, "SSHPublicKey")
|
|
|
|
placeholderData["SSHPrivateKey"] = fmt.Sprintf(msg, "SSHPrivateKey")
|
|
|
|
|
|
|
|
// Backwards-compatability: WinRM Password can get through without forcing
|
|
|
|
// the generated func validation.
|
|
|
|
placeholderData["WinRMPassword"] = "{{.WinRMPassword}}"
|
|
|
|
|
|
|
|
return placeholderData
|
|
|
|
}
|
|
|
|
|
2013-05-24 00:13:18 -04:00
|
|
|
// Runs the provisioners in order.
|
2019-03-19 13:11:19 -04:00
|
|
|
func (h *ProvisionHook) Run(ctx context.Context, name string, ui Ui, comm Communicator, data interface{}) error {
|
2015-06-15 13:26:46 -04:00
|
|
|
// Shortcut
|
|
|
|
if len(h.Provisioners) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if comm == nil {
|
|
|
|
return fmt.Errorf(
|
|
|
|
"No communicator found for provisioners! This is usually because the\n" +
|
|
|
|
"`communicator` config was set to \"none\". If you have any provisioners\n" +
|
|
|
|
"then a communicator is required. Please fix this to continue.")
|
|
|
|
}
|
2017-11-03 02:31:32 -04:00
|
|
|
for _, p := range h.Provisioners {
|
2017-11-04 16:06:36 -04:00
|
|
|
ts := CheckpointReporter.AddSpan(p.TypeName, "provisioner", p.Config)
|
2017-11-03 02:31:32 -04:00
|
|
|
|
2019-12-12 13:59:44 -05:00
|
|
|
// Provisioners expect a map[string]interface{} in their data field, but
|
|
|
|
// it gets converted into a map[interface]interface on the way over the
|
|
|
|
// RPC. Check that data can be cast into such a form, and cast it.
|
|
|
|
cast := make(map[string]interface{})
|
|
|
|
interMap, ok := data.(map[interface{}]interface{})
|
|
|
|
if !ok {
|
|
|
|
log.Printf("Unable to read map[string]interface out of data." +
|
|
|
|
"Using empty interface.")
|
|
|
|
} else {
|
|
|
|
for key, val := range interMap {
|
|
|
|
keyString, ok := key.(string)
|
|
|
|
if ok {
|
|
|
|
cast[keyString] = val
|
|
|
|
} else {
|
|
|
|
log.Printf("Error casting generated data key to a string.")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err := p.Provisioner.Provision(ctx, ui, comm, cast)
|
2017-11-03 02:31:32 -04:00
|
|
|
|
2017-05-04 19:29:21 -04:00
|
|
|
ts.End(err)
|
|
|
|
if err != nil {
|
2013-06-26 20:50:25 -04:00
|
|
|
return err
|
|
|
|
}
|
2013-05-24 00:13:18 -04:00
|
|
|
}
|
2013-06-26 20:50:25 -04:00
|
|
|
|
|
|
|
return nil
|
2013-05-24 00:13:18 -04:00
|
|
|
}
|
2013-08-30 20:03:55 -04:00
|
|
|
|
2013-12-21 00:36:41 -05:00
|
|
|
// PausedProvisioner is a Provisioner implementation that pauses before
|
|
|
|
// the provisioner is actually run.
|
|
|
|
type PausedProvisioner struct {
|
|
|
|
PauseBefore time.Duration
|
|
|
|
Provisioner Provisioner
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *PausedProvisioner) Prepare(raws ...interface{}) error {
|
|
|
|
return p.Provisioner.Prepare(raws...)
|
|
|
|
}
|
|
|
|
|
2019-12-12 13:59:44 -05:00
|
|
|
func (p *PausedProvisioner) Provision(ctx context.Context, ui Ui, comm Communicator, generatedData map[string]interface{}) error {
|
2013-12-21 00:36:41 -05:00
|
|
|
|
|
|
|
// Use a select to determine if we get cancelled during the wait
|
2013-12-21 00:39:23 -05:00
|
|
|
ui.Say(fmt.Sprintf("Pausing %s before the next provisioner...", p.PauseBefore))
|
2013-12-21 00:36:41 -05:00
|
|
|
select {
|
|
|
|
case <-time.After(p.PauseBefore):
|
2019-03-19 13:11:19 -04:00
|
|
|
case <-ctx.Done():
|
|
|
|
return ctx.Err()
|
2013-12-21 00:36:41 -05:00
|
|
|
}
|
|
|
|
|
2019-07-11 12:37:59 -04:00
|
|
|
return p.Provisioner.Provision(ctx, ui, comm, generatedData)
|
2013-12-21 00:36:41 -05:00
|
|
|
}
|
2017-03-12 18:46:35 -04:00
|
|
|
|
2018-06-07 18:35:36 -04:00
|
|
|
// DebuggedProvisioner is a Provisioner implementation that waits until a key
|
|
|
|
// press before the provisioner is actually run.
|
2017-03-12 18:46:35 -04:00
|
|
|
type DebuggedProvisioner struct {
|
|
|
|
Provisioner Provisioner
|
|
|
|
|
|
|
|
cancelCh chan struct{}
|
|
|
|
doneCh chan struct{}
|
|
|
|
lock sync.Mutex
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *DebuggedProvisioner) Prepare(raws ...interface{}) error {
|
|
|
|
return p.Provisioner.Prepare(raws...)
|
|
|
|
}
|
|
|
|
|
2019-12-12 13:59:44 -05:00
|
|
|
func (p *DebuggedProvisioner) Provision(ctx context.Context, ui Ui, comm Communicator, generatedData map[string]interface{}) error {
|
2017-03-12 18:46:35 -04:00
|
|
|
// Use a select to determine if we get cancelled during the wait
|
|
|
|
message := "Pausing before the next provisioner . Press enter to continue."
|
|
|
|
|
|
|
|
result := make(chan string, 1)
|
|
|
|
go func() {
|
|
|
|
line, err := ui.Ask(message)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("Error asking for input: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
result <- line
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-result:
|
2019-03-19 13:11:19 -04:00
|
|
|
case <-ctx.Done():
|
|
|
|
return ctx.Err()
|
2017-03-12 18:46:35 -04:00
|
|
|
}
|
|
|
|
|
2019-07-11 12:37:59 -04:00
|
|
|
return p.Provisioner.Provision(ctx, ui, comm, generatedData)
|
2017-03-12 18:46:35 -04:00
|
|
|
}
|