packer-cn/common/step_provision.go

147 lines
4.3 KiB
Go
Raw Normal View History

2013-07-16 02:43:01 -04:00
package common
import (
"context"
"fmt"
2013-07-16 02:43:01 -04:00
"log"
"os"
2013-08-31 02:28:31 -04:00
"time"
2018-01-22 20:21:10 -05:00
"github.com/hashicorp/packer/helper/communicator"
"github.com/hashicorp/packer/helper/multistep"
2018-01-22 20:21:10 -05:00
"github.com/hashicorp/packer/packer"
2013-07-16 02:43:01 -04:00
)
// StepProvision runs the provisioners.
//
// Uses:
// communicator packer.Communicator
// hook packer.Hook
// ui packer.Ui
//
// Produces:
// <nothing>
func PopulateProvisionHookData(state multistep.StateBag) map[string]interface{} {
2019-12-16 14:22:21 -05:00
hookData := make(map[string]interface{})
2019-12-14 06:44:09 -05:00
// Load Builder hook data from state, if it has been set.
2019-12-16 14:22:21 -05:00
hd, ok := state.GetOk("generated_data")
if ok {
hookData = hd.(map[string]interface{})
}
2019-12-14 06:44:09 -05:00
// instance_id is placed in state by the builders.
// Not yet implemented in Chroot, lxc/lxd, Azure, Qemu.
// Implemented in most others including digitalOcean (droplet id),
// docker (container_id), and clouds which use "server" internally instead
// of instance.
2019-12-14 06:44:09 -05:00
// Also note that Chroot and lxc/lxd builders tend to have their own custom
// step_provision, so they won't use this code path.
id, ok := state.GetOk("instance_id")
if ok {
hookData["ID"] = id
} else {
// Warn user that the id isn't implemented
hookData["ID"] = "ERR_ID_NOT_IMPLEMENTED_BY_BUILDER"
}
2019-12-16 14:22:21 -05:00
hookData["PackerRunUUID"] = os.Getenv("PACKER_RUN_UUID")
// Read communicator data into hook data
comm, ok := state.GetOk("communicator_config")
if !ok {
log.Printf("Unable to load config from state to populate provisionHookData")
return hookData
}
commConf := comm.(*communicator.Config)
// Loop over all field values and retrieve them from the ssh config
hookData["Host"] = commConf.Host()
hookData["Port"] = commConf.Port()
hookData["User"] = commConf.User()
hookData["Password"] = commConf.Password()
hookData["ConnType"] = commConf.Type
hookData["SSHPublicKey"] = commConf.SSHPublicKey
hookData["SSHPrivateKey"] = commConf.SSHPrivateKey
// Backwards compatibility; in practice, WinRMPassword is fulfilled by
// Password.
hookData["WinRMPassword"] = commConf.WinRMPassword
return hookData
}
type StepProvision struct {
Comm packer.Communicator
}
func (s *StepProvision) runWithHook(ctx context.Context, state multistep.StateBag, hooktype string) multistep.StepAction {
// hooktype will be either packer.HookProvision or packer.HookCleanupProvision
comm := s.Comm
if comm == nil {
raw, ok := state.Get("communicator").(packer.Communicator)
if ok {
comm = raw.(packer.Communicator)
}
}
2013-08-31 15:17:59 -04:00
hook := state.Get("hook").(packer.Hook)
ui := state.Get("ui").(packer.Ui)
2013-07-16 02:43:01 -04:00
hookData := PopulateProvisionHookData(state)
2013-08-31 02:28:31 -04:00
// Run the provisioner in a goroutine so we can continually check
// for cancellations...
if hooktype == packer.HookProvision {
log.Println("Running the provision hook")
} else if hooktype == packer.HookCleanupProvision {
ui.Say("Provisioning step had errors: Running the cleanup provisioner, if present...")
}
2013-08-31 02:28:31 -04:00
errCh := make(chan error, 1)
go func() {
errCh <- hook.Run(ctx, hooktype, ui, comm, hookData)
2013-08-31 02:28:31 -04:00
}()
for {
select {
case err := <-errCh:
if err != nil {
if hooktype == packer.HookProvision {
// We don't overwrite the error if it's a cleanup
// provisioner being run.
state.Put("error", err)
} else if hooktype == packer.HookCleanupProvision {
origErr := state.Get("error").(error)
state.Put("error", fmt.Errorf("Cleanup failed: %s. "+
"Original Provisioning error: %s", err, origErr))
}
2013-08-31 02:28:31 -04:00
return multistep.ActionHalt
}
2013-07-16 02:43:01 -04:00
2013-08-31 02:28:31 -04:00
return multistep.ActionContinue
case <-ctx.Done():
log.Printf("Cancelling provisioning due to context cancellation: %s", ctx.Err())
return multistep.ActionHalt
2013-08-31 02:28:31 -04:00
case <-time.After(1 * time.Second):
2013-08-31 15:17:59 -04:00
if _, ok := state.GetOk(multistep.StateCancelled); ok {
log.Println("Cancelling provisioning due to interrupt...")
2013-08-31 02:28:31 -04:00
return multistep.ActionHalt
}
}
}
2013-07-16 02:43:01 -04:00
}
func (s *StepProvision) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
return s.runWithHook(ctx, state, packer.HookProvision)
}
func (s *StepProvision) Cleanup(state multistep.StateBag) {
// We have a "final" provisioner that gets defined by "error-cleanup-provisioner"
// which we only call if there's an error during the provision run and
// the "error-cleanup-provisioner" is defined.
if _, ok := state.GetOk("error"); ok {
s.runWithHook(context.Background(), state, packer.HookCleanupProvision)
}
}