Revert "Check that only certain files are executable"

.circleci/config.yml

@@ -1,25 +0,0 @@
-# Golang CircleCI 2.0 configuration file
-#
-# Check https://circleci.com/docs/2.0/language-go/ for more details
-version: 2
-jobs:
-  build:
-    docker:
-      - image: circleci/golang:1.12
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - checkout
-      - run: make ci
-  check-vendor-vs-mod:
-    docker:
-      - image: circleci/golang:1.12
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - checkout
-      - run: make check-vendor-vs-mod
-workflows:
-  version: 2
-  build_and_check_vendor_vs_module:
-    jobs:
-      - build
-      - check-vendor-vs-mod

.github/CONTRIBUTING.md

@@ -1,7 +1,7 @@
 # Contributing to Packer
 
 **First:** if you're unsure or afraid of _anything_, just ask or submit the
-issue or pull request anyway. You won't be yelled at for giving your best
+issue or pull request anyways. You won't be yelled at for giving your best
 effort. The worst that can happen is that you'll be politely asked to change
 something. We appreciate any sort of contributions, and don't want a wall of
 rules to get in the way of that.
@@ -37,7 +37,7 @@ can quickly merge or address your contributions.
 
 2. The issue is verified and categorized by a Packer collaborator.
    Categorization is done via tags. For example, bugs are marked as "bugs" and
-   simple fixes are marked as "good first issue".
+   easy fixes are marked as "easy".
 
 3. Unless it is critical, the issue is left for a period of time (sometimes many
    weeks), giving outside contributors a chance to address the issue.
@@ -59,7 +59,7 @@ runtime in order to build packer.
 
 If/when you have go installed you can already `go get` packer and `make` in
 order to compile and test Packer. These instructions target
-POSIX-like environments (macOS, Linux, Cygwin, etc.) so you may need to
+POSIX-like environments (Mac OS X, Linux, Cygwin, etc.) so you may need to
 adjust them for Windows or other shells.
 The instructions below are for go 1.7. or later.
 
@@ -107,10 +107,6 @@ From there, open your fork in your browser to open a new pull-request.
 will break if you `git clone` your fork instead of using `go get` on the main
 Packer project.
 
-**Note:** See '[Working with
-forks](https://help.github.com/articles/working-with-forks/)' for a better way
-to use `git push ...`.
-
 ### Pull Request Lifecycle
 
 1. You are welcome to submit your pull request for commentary or review before
@@ -118,116 +114,57 @@ to use `git push ...`.
   "[WIP]" to indicate this. It's also a good idea to include specific questions
   or items you'd like feedback on.
 
-2. Once you believe your pull request is ready to be merged, you can remove any
-  "[WIP]" prefix from the title and a core team member will review.
+1. Once you believe your pull request is ready to be merged, you can remove any
+  "[WIP]" prefix from the title and a core team member will review. 
 
-3. One of Packer's core team members will look over your contribution and
-  either merge, or provide comments letting you know if there is anything left
-  to do. We do our best to provide feedback in a timely manner, but it may take
-  some time for us to respond. We may also have questions that we need answered
-  about the code, either because something doesn't make sense to us or because
-  we want to understand your thought process.
+1. One of Packer's core team members will look over your contribution and
+  either provide comments letting you know if there is anything left to do. We
+  do our best to provide feedback in a timely manner, but it may take some time
+  for us to respond.
 
-4. If we have requested changes, you can either make those changes or, if you
-  disagree with the suggested changes, we can have a conversation about our
-  reasoning and agree on a path forward. This may be a multi-step process. Our
-  view is that pull requests are a chance to collaborate, and we welcome
-  conversations about how to do things better. It is the contributor's
-  responsibility to address any changes requested. While reviewers are happy to
-  give guidance, it is unsustainable for us to perform the coding work necessary
-  to get a PR into a mergeable state.
-
-5. Once all outstanding comments and checklist items have been addressed, your
+1. Once all outstanding comments and checklist items have been addressed, your
   contribution will be merged! Merged PRs will be included in the next
-  Packer release. The core team takes care of updating the
-  [CHANGELOG.md](../CHANGELOG.md) as they merge.
-
-6. In rare cases, we might decide that a PR should be closed without merging.
-  We'll make sure to provide clear reasoning when this happens.
+  Packer release. The core team takes care of updating the CHANGELOG as they
+  merge.
 
+1. In rare cases, we might decide that a PR should be closed. We'll make sure to
+  provide clear reasoning when this happens.
 
 ### Tips for Working on Packer
 
-#### Getting Your Pull Requests Merged Faster
-
-It is much easier to review pull requests that are:
-
-1. Well-documented: Try to explain in the pull request comments what your
-   change does, why you have made the change, and provide instructions for how
-   to produce the new behavior introduced in the pull request. If you can,
-   provide screen captures or terminal output to show what the changes look
-   like. This helps the reviewers understand and test the change.
-
-2. Small: Try to only make one change per pull request. If you found two bugs
-   and want to fix them both, that's _awesome_, but it's still best to submit
-   the fixes as separate pull requests. This makes it much easier for reviewers
-   to keep in their heads all of the implications of individual code changes,
-   and that means the PR takes less effort and energy to merge. In general, the
-   smaller the pull request, the sooner reviewers will be able to make time to
-   review it.
-
-3. Passing Tests: Based on how much time we have, we may not review pull
-   requests which aren't passing our tests. (Look below for advice on how to
-   run unit tests). If you need help figuring out why tests are failing, please
-   feel free to ask, but while we're happy to give guidance it is generally
-   your responsibility to make sure that tests are passing. If your pull request
-   changes an interface or invalidates an assumption that causes a bunch of
-   tests to fail, then you need to fix those tests before we can merge your PR.
-
-If we request changes, try to make those changes in a timely manner. Otherwise,
-PRs can go stale and be a lot more work for all of us to merge in the future.
-
-Even with everyone making their best effort to be responsive, it can be
-time-consuming to get a PR merged. It can be frustrating to deal with
-the back-and-forth as we make sure that we understand the changes fully. Please
-bear with us, and please know that we appreciate the time and energy you put
-into the project.
-
 #### Working on forks
 
 The easiest way to work on a fork is to set it as a remote of the Packer
 project. After following the steps in "Setting up Go to work on Packer":
 
-1. Navigate to the code:
-
-   `cd $GOPATH/src/github.com/hashicorp/packer`
-
-2. Add the remote by running:
-
-   `git remote add <name of remote> <github url of fork>`
-
-   For example:
-
-   `git remote add mwhooker https://github.com/mwhooker/packer.git`
-
-3. Checkout a feature branch:
-
-   `git checkout -b new-feature`
-
-4. Make changes.
+1. Navigate to `$GOPATH/src/github.com/hashicorp/packer`
+2. Add the remote by running
+   `git remote add <name of remote> <github url of fork>`. For example:
+   `git remote add mwhooker https://github.com/mwhooker/packer.git`.
+3. Checkout a feature branch: `git checkout -b new-feature`
+4. Make changes
 5. (Optional) Push your changes to the fork:
-
    `git push -u <name of remote> new-feature`
 
 This way you can push to your fork to create a PR, but the code on disk still
 lives in the spot where the go cli tools are expecting to find it.
 
-#### Go modules & go vendor
+#### Govendor
 
-If you are submitting a change that requires new or updated dependencies,
-please include them in `go.mod`/`go.sum` and in the `vendor/` folder. This
-helps everything get tested properly in CI.
+If you are submitting a change that requires new or updated dependencies, please
+include them in `vendor/vendor.json` and in the `vendor/` folder. This helps
+everything get tested properly in CI.
 
-Note that you will need to use [go
-mod](https://github.com/golang/go/wiki/Modules) to do this. This step is
-recommended but not required.
+Note that you will need to use [govendor](https://github.com/kardianos/govendor)
+to do this. This step is recommended but not required; if you don't use govendor
+please indicate in your PR which dependencies have changed and to what versions.
 
-Use `go get <project>` to add dependencies to the project and `go mod vendor`
-to make vendored copy of dependencies. See [go mod quick
-start](https://github.com/golang/go/wiki/Modules#quick-start) for examples.
+Use `govendor fetch <project>` to add dependencies to the project. See
+[govendor quick start](https://github.com/kardianos/govendor#quick-start-also-see-the-faq)
+for examples.
 
-Please only apply the minimal vendor changes to get your PR to work. Packer
-does not attempt to track the latest version for each dependency.
+Please only apply the minimal vendor changes to get your PR to work. Packer does
+not attempt to track the latest version for each dependency.
 
 #### Running Unit Tests
 
@@ -243,7 +180,7 @@ Packer has [acceptance tests](https://en.wikipedia.org/wiki/Acceptance_testing)
 for various builders. These typically require an API key (AWS, GCE), or
 additional software to be installed on your computer (VirtualBox, VMware).
 
-If you're working on a new builder or builder feature and want to verify it is
+If you're working on a new builder or builder feature and want verify it is
 functioning (and also hasn't broken anything else), we recommend running the
 acceptance tests.
 

.github/ISSUE_TEMPLATE.md

@@ -2,7 +2,7 @@ _Please read these instructions before submitting_
 
 **DELETE THIS TEMPLATE BEFORE SUBMITTING**
 
-_Only use GitHub issues to report bugs or feature requests, see
+_Only use Github issues to report bugs or feature requests, see
 https://www.packer.io/community.html_
 
 For example, _Timeouts waiting for SSH/WinRM_ are generally not bugs within packer and are better addressed by the mailing list. Ask on the mailing list if you are unsure.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,11 +1,5 @@
 **DELETE THIS TEMPLATE BEFORE SUBMITTING**
 
-In order to have a good experience with our community, we recommend that you
-read the contributing guidelines for making a PR, and understand the lifecycle
-of a Packer PR:
-
-https://github.com/hashicorp/packer/blob/master/.github/CONTRIBUTING.md#opening-an-pull-request
-
 Describe the change you are making here!
 
 Please include tests. Check out these examples:

.gitignore

@@ -4,7 +4,6 @@
 /src
 /website/.sass-cache
 /website/build
-/website/tmp
 .DS_Store
 .vagrant
 .idea

.travis.yml

@@ -1,27 +1,19 @@
 env:
-  - USER=travis GO111MODULE=off
-
-os:
-  - windows
-  - linux
-  - osx
+    - USER=travis
 
 sudo: false
 
 language: go
 
 go:
-  - 1.12.x
+  - 1.11.x
+  - master
 
-before_install:
-  - >
-    if [[ "$TRAVIS_OS_NAME" == "windows" ]];
-    then choco install -y make;
-    fi
+install:
+  - make deps
 
 script:
-  - df -h
-  - make ci
+  - GOMAXPROCS=2 make ci
 
 branches:
   only:
@@ -29,5 +21,5 @@ branches:
 
 matrix:
   allow_failures:
-    - os: windows
+    - go: master
   fast_finish: true

CHANGELOG.md

@@ -1,370 +1,14 @@
-## 1.4.0 (April 11, 2019)
+## 1.2.6 (Unreleased)
 
 ### IMPROVEMENTS:
-* builder/alicloud: Improve error message for conflicting images name [GH-7415]
-* builder/amazon-chroot: Allow users to specify custom block device mapping
-    [GH-7370]
-* builder/ansible: Documentation fix explaining how to use ansible 2.7 + winrm
-    [GH-7461]
-* builder/azure-arm: specify zone resilient image from config [GH-7211]
-* builder/docker: Add support for windows containers [GH-7444]
-* builder/openstack: Allow both ports and networks in openstack builder
-    [GH-7451]
-* builder/openstack: Expose force_delete for openstack builder [GH-7395]
-* builder/OpenStack: Support Application Credential Authentication [GH-7300]
-* builder/virtualbox: Add validation for 'none' communicator. [GH-7419]
-* builder/virtualbox: create ephemeral SSH key pair for build process [GH-7287]
-* core: Add functionality to marshal a Template to valid Packer JSON [GH-7339]
-* core: Allow user variables to be interpreted within the variables section
-    [GH-7390]
-* core: Incorporate the go-getter to handle downloads [GH-6999]
-* core: Lock Packer VNC ports using a lock file to prevent collisions [GH-7422]
-* core: Print VerifyChecksum log for the download as ui.Message output
-    [GH-7387]
-* core: Users can now set provisioner timeouts [GH-7466]
-* core: Switch to using go mod for managing dependencies [GH-7270]
-* core: Select a new VNC port if initial port is busy [GH-7423]
-* post-processor/googlecompute-export: Set network project id to builder
-    [GH-7359]
-* post-processor/vagrant-cloud: support for the vagrant builder [GH-7397]
-* post-processor/Vagrant: Option to ignore SSL verification when using on-
-    premise vagrant cloud [GH-7377]
-* postprocessor/amazon-import: Support S3 and AMI encryption. [GH-7396]
-* provisioner/shell provisioner/windows-shell: allow to specify valid exit
-    codes [GH-7385]
-* core: Filter sensitive variables out of the ui as well as the logs
-    [GH-7462]
 
-### BUG FIXES:
-* builder/alibaba: Update to latest Alibaba Cloud official image to fix
-    acceptance tests [GH-7375]
-* builder/amazon-chroot: Fix building PV images and where mount_partition is
-    set [GH-7337]
-* builder/amazon: Fix http_proxy env var regression [GH-7361]
-* builder/azure: Fix: Power off before taking snapshot (windows) [GH-7464]
-* builder/hcloud: Fix usage of freebsd64 rescue image [GH-7381]
-* builder/vagrant: windows : fix docs and usage [GH-7416] [GH-7417]
-* builder/vmware-esxi: properly copy .vmxf files in remote vmx builds [GH-7357]
-* core: fix bug where Packer didn't pause in debug on certain linux platforms.
-    [GH-7352]
-* builder/amazon: Fix bug copying encrypted images between regions [GH-7342]
-
-### BACKWARDS INCOMPATIBILITIES:
-* builder/amazon: Change `temporary_security_group_source_cidr` to
-    `temporary_security_group_source_cidrs` and allow it to accept a list of
-    strings. [GH-7450]
-* builder/amazon: If users do not pass any encrypt setting, retain any initial
-    encryption setting of the AMI. [GH-6787]
-* builder/docker: Update docker's default config to use /bin/sh instead of
-    /bin/bash [GH-7106]
-* builder/hyperv: Change option names cpu->cpus and ram_size->memory to bring
-    naming in line with vmware and virtualbox builders [GH-7447]
-* builder/oracle-classic: Remove default ssh_username from oracle classic
-    builder, but add note to docs with oracle's default user. [GH-7446]
-* builder/scaleway: Renamed attribute api_access_key to organization_id.
-    [GH-6983]
-* Change clean_image name and clean_ami_name to a more general clean_resource
-    name for Googlecompute, Azure, and AWS builders. [GH-7456]
-* core/post-processors: Change interface for post-processors to allow an
-    overridable default for keeping input artifacts. [GH-7463]
-
-## 1.3.5 (February 28, 2019)
-
-### IMPROVEMENTS:
-* builder/alicloud: Update aliyun sdk to support eu-west-1 region [GH-7338]
-* builder/amazon: AWS users can now use the Vault AWS engine to generate
-    temporary credentials. [GH-7282]
-* builder/azure: IMDS to get subscription for Azure MSI [GH-7332]
-* builder/openstack: Replaced deprecated compute/ api with imageservice/
-    [GH-7038]
-* builder/virtualbox: New "guest_additions_interface" option to enable
-    attaching via a SATA interface. [GH-7298]
-* builder/vmware: Add `cores` option for specifying the number of cores per
-    socket. [GH-7191]
-* bulder/openstac: Deprecated compute/v2/images API [GH-7268]
-* core: Add validation check to help folks who swap their iso_path and
-    checksum_path [GH-7311]
-* fixer/amazon: Make the amazon-private-ip fixer errors more visible [GH-7336]
-* post-processor/googlecompute-export: Extend auth for the GCE-post-processors
-    to act like the GCE builder. [GH-7222]
-* post-processor/googlecompute-import: Extend auth for the GCE-post-processors
-    to act like the GCE builder. [GH-7222]
-* post-processor/manifest: Add "custom_data" key to packer manifest post-
-    processor [GH-7248]
-
-### BUG FIXES:
-* builder/amazon: Fix support for aws-us-gov [GH-7347]
-* builder/amazon: Move snapshot deletion to cleanup phase. [GH-7343]
-* builder/azure: Fixed Azure interactive authentication [GH-7276]
-* builder/cloudstack: Updated sdk version; can now use ostype name in
-    template_os option.  [GH-7264]
-* builder/google: Change metadata url to use a FQDN fixing bug stemming from
-    differing DNS/search domains. [GH-7260]
-* builder/hyper-v: Fix integer overflows in 32-bit builds [GH-7251]
-* builder/hyper-v: Fix regression where we improperly handled spaces in switch
-    names [GH-7266]
-* builder/openstack: Pass context So we know to cancel during WaitForImage
-    [GH-7341]
-* builder/vmware-esxi: Strip \r\n whitespace from end of names of
-    files stored on esxi. [GH-7310]
-* builder/vmware: Add "--noSSLVerify" to args in ovftool Validation [GH-7314]
-* core: clean up Makefile [GH-7254][GH-7265]
-* core: Fixes mismatches in checksums for dependencies for Go 1.11.4+ [GH-7261]
-* core: make sure 'only' option is completely ignored by post-processors
-    [GH-7262]
-* core: name a post-processor to its type when it is not named [GH-7330]
-* provisioner/salt: Force powershell to overwrite duplicate files [GH-7281]
-
-### Features:
-* **new builder** `vagrant` allows users to call vagrant to provision starting
-    from vagrant boxes and save them as new vagrant boxes. [GH-7221]
-* **new builder:** `hyperone` for building new images on HyperOne Platform on
-    top of existing image or from the scratch with the use of chroot. [GH-7294]
-* **new post-processor** `digitalocean-import`Add digitalocean-import post-
-    processor. [GH-7060]
-* **new provisioner**`inspec` Added inspec.io provisioner [GH-7180]
-* communicator: Add configurable pause after communicator can connect but
-    before it performs provisioning tasks [GH-7317] [GH-7351]
-
-## 1.3.4 (January 30, 2019)
-### IMPROVEMENTS:
-* builder/alicloud: delete copied image and snapshots if corresponding options
-    are specified [GH-7050]
-* builder/amazon: allow to interpolate more variables [GH-7059]
-* builder/amazon: Check that the KMS key ID is valid [GH-7090]
-* builder/amazon: Clean up logging for aws waiters so that it only runs once
-    per builder [GH-7080]
-* builder/amazon: don't Cleanup Temp Keys when there is no communicator to
-    avoid a panic [GH-7100] [GH-7095]
-* builder/amazon: Don't try to guess region from metadata if not set & update
-    aws-sdk-go [GH-7230]
-* builder/amazon: Import error messages should now contain reason for failure
-    [GH-7207]
-* builder/azure: add certificate authentication [GH-7189]
-* builder/azure: allow to configure disk caching [GH-7061]
-* builder/azure: use deallocate instead of just power-off [GH-7203]
-* builder/hyperv: Add support for legacy network adapters on Hyper-V. [GH-7128]
-* builder/hyperv: Allow user to set `version` option in the New-VM command.
-    [GH-7136]
-* builder/openstack: Add `volume_size` option [GH-7130]
-* builder/openstack: Don't require network v2 [GH-6933]
-* builder/openstack: Support for tagging new images [GH-7037]
-* builder/qemu: Add configuration options to specify cpu count and memory size
-    [GH-7156]
-* builder/qemu: Add support for whpx accelerator to qemu builder [GH-7151]
-* builder/vmware: Escape query as suggested in issue #7200 [GH-7223]
-* core/shell: Add env vars "PACKER_HTTP_IP" and "PACKER_HTTP_PORT" to shell
-    provisioners [GH-7075]
-* core: allow to use `-except` on post-processors [GH-7183]
-* core: Clean up internal handling and creation of temporary directories
-    [GH-7102]
-* core: Deprecate mitchellh/go-homedir package in favor of os/user [GH-7062]
-* core: Download checksum match failures will now log the received checksum.
-    [GH-7210]
-* core: Explicitly set ProxyFromEnvironment in httpclients when creating an aws
-    session [GH-7226]
-* core: make packer inspect not print sensitive variables [GH-7084]
-* post-processor/google: Add new `guest-os-features` option. [GH-7218]
-* postprocessor/docker-import: Added `change` support [GH-7127]
-* provisioner/ansible-remote: add `-o IdentitiesOnly=yes`as a default flag
-    [GH-7115]
-* provisioner/chef-client: Elevated support for chef-client provisioner
-    [GH-7078]
-* provisioner/puppet: Elevated support for puppet-* provisioner [GH-7078]
-* provisioner/windows-restart: wait for already-scheduled reboot [GH-7056] and
-    ignore reboot specific errors [GH-7071]
-
-
-### BUG FIXES:
-* builder/azure: Ensure the Windows Guest Agent is fully functional before
-    Sysprep is executed. [GH-7176]
-* builder/azure: Fix snapshot regression [GH-7111]
-* builder/docker: Ensure that entrypoint and arguments get passed to docker,
-    not the image. [GH-7091]
-* builder/hcloud: fix go mod dependency [GH-7099]
-* builder/hcloud: prevent panic when ssh key was not passed [GH-7118]
-* builder/hyperv: Fix the Hyper-V gen 1 guest boot order. [GH-7147]
-* builder/hyperv: hyper-v builder no longer ignores `ssh_host` option.
-    [GH-7154]
-* builder/oracle-oci: Fix crash that occurs when image is nil [GH-7126]
-* builder/parallels: Fix attaching prl tools [GH-7158]
-* builder/virtualbox: Fix handling of portcount argument for version 6 beta
-    [GH-7174] [GH-7094]
-* builder/vmware: Fix bug caused by 'nil' dir field in artifact struct when
-    building locally [GH-7116]
-* communicator/docker: Fix docker file provisioner on Windows [GH-7163]
-* core: prioritize AppData over default user directory ( UserProfile )
-    [GH-7166]
-* core: removed a flaky race condition in tests [GH-7119]
-* postprocessor/vsphere: Stop setting HDDOrder, since it was breaking uploads
-    [GH-7108]
-
-
-## 1.3.3 (December 5, 2018)
-### IMPROVEMENTS:
-* builder/alicloud: Add options for system disk properties [GH-6939]
-* builder/alicloud: Apply tags to relevant snapshots [GH-7040]
-* builder/alicloud: Support creating image without data disks [GH-7022]
-* builder/amazon: Add option for skipping TLS verification [GH-6842]
-* builder/azure: Add options for Managed Image OS Disk and Data Disk snapshots
-    [GH-6980]
-* builder/hcloud: Add `snapshot_labels` option to hcloud builder [GH-7046]
-* builder/hcloud: Add ssh_keys config to hcloud builder [GH-7028]
-* builder/hcloud: Update hcloud-go version and support builds using rescue mode
-    [GH-7034]
-* builder/oracle: Parameterized volume size support for Oracle classic builder
-    [GH-6918]
-* builder/parallels: Add configuration options to parallels builder to specify
-    cpu count and memory size [GH-7018]
-* builder/virtualbox: Add configuration options to virtualbox builder to
-    specify cpu count and memory size [GH-7017]
-* builder/virtualbox: expose the VBoxManage export --iso option [GH-5950]
-* builder/vmware: Add configuration options to vmware builder to specify cpu
-    count and memory size [GH-7019]
-* builder/vmware: Add new display_name template option [GH-6984]
-* builder/vmware: Extend vmware-vmx builder to allow esxi builds. [GH-4591]
-    [GH-6927]
-* builder/vmware: Validate username/password for ovftool during prepare.
-    [GH-6977]
-* builder/vmware: Warn users if their vmx_data overrides data that Packer uses
-    the template engine to set in its default vmx template. [GH-6987]
-* communicator/ssh: Expand user path for SSH private key [GH-6946]
-* core: Add a sed template engine [GH-6580]
-* core: More explicit error message in rpc/ui.go [GH-6981]
-* core: Replaced unsafe method of determining homedir with os/user
-    implementation [GH-7036]
-* core: Update vagrantfile's go version. [GH-6841]
-* post-processor/amazon-import: Support ova, raw, vmdk, and vhdx formats in the
-    amazon-import post-processor. [GH-6938]
-* post-processor/vsphere-template: Add option to snapshot vm before marking as
-    template [GH-6969]
-* provisioner/breakpoint: Add a new breakpoint provisioner. [GH-7058]
-* provisioner/powershell: Allow Powershell provisioner to use service accounts
-    [GH-6972]
-* provisioner/shell: Add PauseAfter option to shell provisioner [GH-6913]
-
-### BUG FIXES:
-* builder/amazon: Better error handling of region/credential guessing from
-    metadata [GH-6931]
-* builder/amazon: move region validation to run so that we don't break
-    validation when no credentials are set [GH-7032]
-* builder/hyperv: Remove -Copy:$false when calling Hyper-V\Compare-VM
-    compatability report [GH-7030]
-* builder/qemu: Do not set detect-zeroes option when we want it "off" [GH-7064]
-* builder/vmware-esxi: Create export directories for vmx and ovf file types
-    [GH-6985]
-* builder/vmware: Correctly parse version for VMware Fusion Tech Preview
-    [GH-7016]
-* builder/vmware: Escape vSphere username when putting it into the export call
-    [GH-6962]
-* post-processor/vagrant: Add "hvf" as a libvirt driver [GH-6955]
-* provisioner/ansible: inventory is no longer set to inventory_directory
-    [GH-7065]
-
-## 1.3.2 (October 29, 2018)
-### IMPROVEMENTS:
-* builder/alicloud: Add new `disable_stop_instance` option. [GH-6764]
-* builder/alicloud: Support adding tags to image. [GH-6719]
-* builder/alicloud: Support ssh with private ip address. [GH-6688]
-* builder/amazon: Add support to explicitly control ENA support [GH-6872]
-* builder/amazon: Add suppport for `vpc_filter`, `subnet_filter`, and
-    `security_group_filter`. [GH-6374]
-* builder/amazon: Add validation for required `device_name` parameter in
-    `block_device_mappings`. [GH-6845]
-* builder/amazon: Clean up security group wait code. [GH-6843]
-* builder/amazon: Update aws-sdk-go to v1.15.54, adding support for
-    `credential_source`. [GH-6849]
-* builder/amazon: Use DescribeRegions for aws region validation. [GH-6512],
-    [GH-6904]
-* builder/azure: Add new `shared_image_gallery` option. [GH-6798]
-* builder/googlecompute: Return an error if `startup_script_file` is specified,
-    but file does not exist. [GH-6848]
-* builder/hcloud: Add Hetzner Cloud builder. [GH-6871]
-* builder/openstack: Add new `disk_format` option. [GH-6702]
-* builder/openstack: Fix bug where `source_image_name` wasn't being used to
-    properly find a UUID. [GH-6751]
-* builder/openstack: Wait for volume availability when cleaning up [GH-6703]
-* builder/qemu: Add `disk_detect_zeroes` option. [GH-6827]
-* builder/scaleway: Add `boottype` parameter to config. [GH-6772]
-* builder/scaleway: Update scaleway-cli vendor. [GH-6771]
-* core: New option to add timestamps to UI output. [GH-6784]
-* post-processor/vagrant-cloud: Validate vagrant cloud auth token doing an auth
-    request [GH-6914]
-* provisioner/file: Improve error messaging when file destination is a
-    directory with no trailing slash. [GH-6756]
-* provisioner/powershell: Provide better error when Packer can't find
-    Powershell executable. [GH-6817]
-* provisioner/shell-local: Add ability to specify OSs where shell-local can run
-    [GH-6878]
-
-### BUG FIXES:
-* builder/alicloud: Fix ssh configuration pointer issues that could cause a bug
-    [GH-6720]
-* builder/alicloud: Fix type error in step_create_tags [GH-6763]
-* builder/amazon: Error validating credentials is no longer obscured by a
-    region validation error. and some region validation refactors and
-    improvements [GH-6865]
-* builder/amazon: Fix error calculating defaults in AWS waiters. [GH-6727]
-* builder/amazon: Increase default wait for image import to one hour. [GH-6818]
-* builder/amazon: Waiter now fails rather than hanging for extra time when an
-    image import fails. [GH-6747]
-* builder/azure: Updated Azure/go-ntlmssp dependency to resolve an issue with
-    the winrm communicator not connecting to Windows machines requiring NTLMv2
-    session security
-* builder/digitalocean: Fix ssh configuration pointer issues that could cause a
-    panic [GH-6729]
-* builder/hyperv/vmcx: Allow to set generation from buildfile [GH-6909]
-* builder/scaleway: Fix issues with ssh keys. [GH-6768]
-* core: Fix error where logging was always enabled when Packer was run from
-    inside Terraform. [GH-6758]
-* core: Fix issue with with names containing spaces in ESX5Driver and in ssh
-    communicator [GH-6891], [GH-6823]
-* core: Fix logger so it doesn't accidentally try to format unescaped strings.
-    [GH-6824]
-* core: Fix race conditions in progress bar code [GH-6858], [GH-6788],
-    [GH-6851]
-* core: Fix various places in multiple builders where config was not being
-    passed as a pointer. [GH-6739]
-* post-processor/manifest: No longer provides an empty ID string for Azure's
-    managed image artifact [GH-6822]
-* provisioner/powershell: Fix a bug in the way we set the ProgressPreference
-    variable in the default `execute_command` [GH-6838]
-* provisioner/windows-restart: Fix extraneous break which forced early exit
-    from our wait loop. [GH-6792]
-
-## 1.3.1 (September 13, 2018)
-
-### IMPROVEMENTS:
-* builder/amazon: automatically decode encoded authorization messages if
-    possible [GH-5415]
-* builder:amazon: Optional cleanup of the authorized keys file [GH-6713]
-* builder/qemu: Fixed bug where a -device in the qemuargs would override the default network settings, resulting in no network [GH-6807]
-
-### BUG FIXES:
-* builder/amazon: fix bugs relating to spot instances provisioning [GH-6697]
-    [GH-6693]
-* builder/openstack: fix ssh keypair not attached [GH-6701]
-* core: progressbar: fix deadlock locking builds afer first display [GH-6698]
-
-## 1.3.0 (September 11, 2018)
-
-### IMPROVEMENTS:
-* azure/arm: Retry cleanup of individual resources on error [GH-6644]
 * builder/alicloud: Support source image coming from marketplace [GH-6588]
-* builder/amazon-chroot: Add new `root_volume_type` option. [GH-6669]
-* builder/amazon-chroot: If you have a PV source AMI, with the Amazon Chroot
-    builder, and the destination AMI is type HVM, you can now enable
-    ena_support, example: [GH-6670]
 * builder/amazon-chroot: New feature `root_volume_tags` to tag the created
     volumes. [GH-6504]
-* builder/amazon: Create a random interim AMI name when encrypt_boot is true so
-    that ami name is not searchable. [GH-6657]
 * builder/azure: Implement clean_image_name template engine. [GH-6558]
 * builder/cloudstack: Add option to use a fixed port via public_port. [GH-6532]
 * builder/digitalocean: Add support for tagging to instances [GH-6546]
 * builder/googlecompute: Add new `min_cpu_platform` feature [GH-6607]
-* builder/googlecompute: Update the list of public image projects that we
-    search, based on GCE documentation. [GH-6648]
 * builder/lxc: Allow unplivileged LXC containers. [GH-6279]
 * builder/oci: Add `metadata` feature to Packer config. [GH-6498]
 * builder/openstack: Add support for getting config from clouds-public.yaml.
@@ -374,77 +18,34 @@
 * builder/openstack: Migrate floating IP usage to Network v2 API from Compute
     API. [GH-6373]
 * builder/openstack: Support Block Storage volumes as boot volume. [GH-6596]
-* builder/oracle-oci: Add support for freeform tagging of OCI images [GH-6338]
 * builder/qemu: add ssh agent support. [GH-6541]
 * builder/qemu: New `use_backing_file` feature [GH-6249]
-* builder/vmware-iso: Add support for disk compaction [GH-6411]
 * builder/vmware-iso: Try to use ISO files uploaded to the datastore when
     building remotely instead of uploading them freshly every time [GH-5165]
 * command/validate: Warn users if config needs fixing. [GH-6423]
-* core: Add a 'split' function to parse template variables. [GH-6357]
-* core: Add a template function allowing users to read keys from consul
-    [GH-6577]
-* core: Add a template function allowing users to read keys from vault
-    [GH-6533]
 * core: Add progress-bar to download step. [GH-5851]
-* core: Create a new root-level Packer template option, "sensitive-variables"
-    which allows users to list which variables they would like to have scrubbed
-    from the Packer logs. [GH-6610]
-* core: Create new config options, "boot_keygroup_interval" and
-    "boot_key_interval" that can be set at the builder-level to supercede
-    PACKER_KEY_INTERVAL for the bootcommand. [GH-6616]
 * core: Deduplicate ui and log lines that stream to terminal [GH-6611]
-* core: Refactor and deduplicate ssh code across builders. This should be a no-
-    op but is a big win for maintainability. [GH-6621] [GH-6613]
-* post-processor/compress: Add support for xz compression [GH-6534]
 * post-processor/vagrant: Support for Docker images. [GH-6494]
-* post-processor/vsphere: Add new `esxi_host` option. [GH-5366]
 * postprocessor/vagrant: Add support for Azure. [GH-6576]
-* provisioner/ansible: Add new "extra var", packer_http_addr. [GH-6501]
 * provisioner/ansible: Enable {{.WinRMPassword}} template engine. [GH-6450]
 * provisioner/shell-local: Create PACKER_HTTP_ADDR environment variable
     [GH-6503]
 
-
 ### BUG FIXES:
 * builder/amazon-ebssurrogate: Clean up volumes at end of build. [GH-6514]
-* builder/amazon: Increase default waiter timeout for AWS
-    WaitUntilImageAvailable command [GH-6601]
-* builder/amazon: Increase the MaxRetries in the Amazon client from the default
-    to 20, to work around users who regularly reach their requestlimit and are
-    being throttled. [GH-6641]
-* builder/amazon: Properly apply environment overrides to our custom-written
-    waiters. [GH-6649]
 * builder/azure: Generated password satisfies Azure password requirements
     [GH-6480]
-* builder/hyper-v: Buider no longer errors if skip_compaction isn't true when
-    skip_export is true, and compaction efficiency is improved [GH-6393]
 * builder/lxc: Correctly pass "config" option to "lxc launch". [GH-6563]
-* builder/lxc: Determine lxc root according to the running user [GH-6543]
-* builder/lxc: Fix file copying for unprivileged LXC containers [GH-6544]
-* builder/oracle-oci: Update OCI sdk, fixing validation bug that occurred when
-    RSA key was encrypted. [GH-6492]
 * builder/vmware-iso: Fix crash caused by invalid datacenter url. [GH-6529]
-* builder/vmware: Maintain original boot order during CreateVMX step for
-    vmware-iso builder [GH-6204]
-* communicator/chroot: Fix quote escaping so that ansible provisioner works
-    properly. [GH-6635]
 * core: Better error handling in downloader when connection error occurs.
     [GH-6557]
 * core: Fix broken pathing checks in checksum files. [GH-6525]
-* provisioner/shell Create new template option allowing users to choose to
-    source env vars from a file rather than declaring them inline. This
-    resolves a bug that occurred when users had complex quoting in their
-    `execute_command`s [GH-6636]
-* provisioner/shell-local: Windows inline scripts now default to being appended
-    with ".cmd", fixing a backwards incompatibility in v1.2.5 [GH-6626]
 * provisioner/windows-restart: Provisioner now works when used in conjuction
     with SSH communicator [GH-6606]
 
 ### BACKWARDS INCOMPATIBILITIES:
 * builder/amazon: "owners" field on source_ami_filter is now required for
     secuirty reasons. [GH-6585]
-* builder/vmware-iso: validation will fail for templates using esxi that have the "disk_type_id" set to something other than "thin" or "" and that do not have "skip_compaction": true also set. Use `packer fix` to fix this. [GH-6411]
 
 ## 1.2.5 (July 16, 2018)
 

CODEOWNERS

@@ -2,10 +2,10 @@
 
 # builders
 
-/builder/alicloud/                      @chhaj5236
+/builder/alicloud/                      dongxiao.zzh@alibaba-inc.com
 /builder/amazon/ebssurrogate/           @jen20
 /builder/amazon/ebsvolume/              @jen20
-/builder/azure/                         @paulmey
+/builder/azure/                         @boumenot
 /builder/hyperv/                        @taliesins
 /builder/lxc/                           @ChrisLundquist
 /builder/lxd/                           @ChrisLundquist
@@ -14,9 +14,7 @@
 /builder/profitbricks/                  @jasmingacic
 /builder/triton/                        @jen20 @sean-
 /builder/ncloud/                        @YuSungDuk
-/builder/scaleway/                      @sieben @mvaude @jqueuniet @fflorens @brmzkw
-/builder/hcloud/                        @LKaemmerling
-/builder/hyperone                       @m110 @gregorybrzeski @ad-m
+/builder/scaleway/                      @dimtion @edouardb
 
 # provisioners
 

Dockerfile

@@ -1,30 +0,0 @@
-FROM ubuntu:16.04
-
-ENV DEBIAN_FRONTEND noninteractive
-
-RUN apt-get update && apt-get install -y \
-    locales \
-    openssh-server \
-    sudo
-
-RUN locale-gen en_US.UTF-8
-
-RUN if ! getent passwd vagrant; then useradd -d /home/vagrant -m -s /bin/bash vagrant; fi \
-    && echo 'vagrant ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers \
-    && mkdir -p /etc/sudoers.d \
-    && echo 'vagrant ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers.d/vagrant \
-    && chmod 0440 /etc/sudoers.d/vagrant
-
-RUN mkdir -p /home/vagrant/.ssh \
-    && chmod 0700 /home/vagrant/.ssh \
-    && wget --no-check-certificate \
-      https://raw.github.com/hashicorp/vagrant/master/keys/vagrant.pub \
-      -O /home/vagrant/.ssh/authorized_keys \
-    && chmod 0600 /home/vagrant/.ssh/authorized_keys \
-    && chown -R vagrant /home/vagrant/.ssh
-
-RUN mkdir -p /run/sshd
-
-CMD /usr/sbin/sshd -D \
-    -o UseDNS=no \
-    -o PidFile=/tmp/sshd.pid

Makefile

@@ -1,5 +1,5 @@
-TEST?=$(shell go list ./...)
-VET?=$(shell go list ./...)
+TEST?=$(shell go list ./... | grep -v vendor)
+VET?=$(shell ls -d */ | grep -v vendor | grep -v website)
 # Get the current full sha from git
 GITSHA:=$(shell git rev-parse HEAD)
 # Get the current local branch name from git (if we can, this may be blank)
@@ -11,8 +11,6 @@ GOPATH=$(shell go env GOPATH)
 # gofmt
 UNFORMATTED_FILES=$(shell find . -not -path "./vendor/*" -name "*.go" | xargs gofmt -s -l)
 
-EXECUTABLE_FILES=$(shell find . -type f -executable | egrep -v '^\./(website/[vendor|tmp]|vendor/|\.git|bin/|scripts/|pkg/)' | egrep -v '.*(\.sh|\.bats|\.git)' | egrep -v './provisioner/(ansible|inspec)/test-fixtures/exit1')
-
 # Get the git commit
 GIT_DIRTY=$(shell test -n "`git status --porcelain`" && echo "+CHANGES" || true)
 GIT_COMMIT=$(shell git rev-parse --short HEAD)
@@ -21,18 +19,16 @@ GOLDFLAGS=-X $(GIT_IMPORT).GitCommit=$(GIT_COMMIT)$(GIT_DIRTY)
 
 export GOLDFLAGS
 
-.PHONY: bin checkversion ci default deps fmt fmt-docs fmt-examples generate releasebin test testacc testrace updatedeps
+default: deps generate test dev
 
-default: deps generate testrace dev releasebin package dev fmt fmt-check mode-check fmt-docs fmt-examples
-
-ci: testrace
+ci: deps test
 
 release: deps test releasebin package ## Build a release build
 
 bin: deps ## Build debug/test build
 	@go get github.com/mitchellh/gox
 	@echo "WARN: 'make bin' is for debug / test builds only. Use 'make release' for release builds."
-	@GO111MODULE=off sh -c "$(CURDIR)/scripts/build.sh"
+	@sh -c "$(CURDIR)/scripts/build.sh"
 
 releasebin: deps
 	@go get github.com/mitchellh/gox
@@ -40,7 +36,7 @@ releasebin: deps
 		echo "ERROR: You must remove prerelease tags from version/version.go prior to release."; \
 		exit 1; \
 	fi
-	@GO111MODULE=off sh -c "$(CURDIR)/scripts/build.sh"
+	@sh -c "$(CURDIR)/scripts/build.sh"
 
 package:
 	$(if $(VERSION),,@echo 'VERSION= needed to release; Use make package skip compilation'; exit 1)
@@ -50,6 +46,8 @@ deps:
 	@go get golang.org/x/tools/cmd/goimports
 	@go get golang.org/x/tools/cmd/stringer
 	@go get -u github.com/mna/pigeon
+	@go get github.com/kardianos/govendor
+	@go get golang.org/x/tools/cmd/goimports
 
 dev: deps ## Build and install a development build
 	@grep 'const VersionPrerelease = ""' version/version.go > /dev/null ; if [ $$? -eq 0 ]; then \
@@ -76,15 +74,6 @@ fmt-check: ## Check go code formatting
 		echo "Check passed."; \
 	fi
 
-mode-check: ## Check that only certain files are executable
-	@echo "==> Checking that only certain files are executable..."
-	@if [ ! -z "$(EXECUTABLE_FILES)" ]; then \
-		echo "These files should not be executable or they must be white listed in the Makefile:"; \
-		echo "$(EXECUTABLE_FILES)" | xargs -n1; \
-		exit 1; \
-	else \
-		echo "Check passed."; \
-	fi
 fmt-docs:
 	@find ./website/source/docs -name "*.md" -exec pandoc --wrap auto --columns 79 --atx-headers -s -f "markdown_github+yaml_metadata_block" -t "markdown_github+yaml_metadata_block" {} -o {} \;
 
@@ -100,32 +89,25 @@ generate: deps ## Generate dynamically generated code
 	goimports -w common/bootcommand/boot_command.go
 	gofmt -w command/plugin.go
 
-test: fmt-check mode-check vet ## Run unit tests
-	@go test $(TEST) $(TESTARGS) -timeout=3m
+test: deps fmt-check ## Run unit tests
+	@go test $(TEST) $(TESTARGS) -timeout=2m
+	@go tool vet $(VET)  ; if [ $$? -eq 1 ]; then \
+		echo "ERROR: Vet found problems in the code."; \
+		exit 1; \
+	fi
 
 # testacc runs acceptance tests
 testacc: deps generate ## Run acceptance tests
 	@echo "WARN: Acceptance tests will take a long time to run and may cost money. Ctrl-C if you want to cancel."
 	PACKER_ACC=1 go test -v $(TEST) $(TESTARGS) -timeout=45m
 
-testrace: fmt-check mode-check vet ## Test with race detection enabled
-	@GO111MODULE=off go test -race $(TEST) $(TESTARGS) -timeout=3m -p=8
-
-check-vendor-vs-mod:
-	@GO111MODULE=on go mod vendor 
-	@git diff --exit-code --ignore-space-change --ignore-space-at-eol -- vendor ; if [ $$? -eq 1 ]; then \
-		echo "ERROR: vendor dir is not on par with go modules definition." && \
-		exit 1; \
-	fi
+testrace: deps ## Test for race conditions
+	@go test -race $(TEST) $(TESTARGS) -timeout=2m
 
 updatedeps:
-	@echo "INFO: Packer deps are managed by go modules. See .github/CONTRIBUTING.md"
-
-vet: ## Vet Go code
-	@go vet $(VET)  ; if [ $$? -eq 1 ]; then \
-		echo "ERROR: Vet found problems in the code."; \
-		exit 1; \
-	fi
+	@echo "INFO: Packer deps are managed by govendor. See .github/CONTRIBUTING.md"
 
 help:
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+.PHONY: bin checkversion ci default deps fmt fmt-docs fmt-examples generate releasebin test testacc testrace updatedeps

README.md

@@ -80,7 +80,7 @@ Packer will build an AMI according to the "quick-start" template. The AMI
 will be available in your AWS account. To delete the AMI, you must manually
 delete it using the [AWS console](https://console.aws.amazon.com/). Packer
 builds your images, it does not manage their lifecycle. Where they go, how
-they're run, etc., is up to you.
+they're run, etc. is up to you.
 
 ## Documentation
 

Vagrantfile

@@ -5,9 +5,9 @@ LINUX_BASE_BOX = "bento/ubuntu-16.04"
 FREEBSD_BASE_BOX = "jen20/FreeBSD-12.0-CURRENT"
 
 Vagrant.configure(2) do |config|
-	if Vagrant.has_plugin?("vagrant-cachier")
-		config.cache.scope = :box
-	end
+        if Vagrant.has_plugin?("vagrant-cachier")
+                config.cache.scope = :box
+        end
 
 	# Compilation and development boxes
 	config.vm.define "linux", autostart: true, primary: true do |vmCfg|
@@ -73,12 +73,6 @@ def configureProviders(vmCfg, cpus: "2", memory: "2048")
 		end
 	end
 
-	vmCfg.vm.provider "docker" do |d, override|
-		d.build_dir = "."
-		d.has_ssh = true
-		override.vm.box = nil
-	end
-
 	return vmCfg
 end
 

appveyor.yml

@@ -16,8 +16,55 @@ environment:
 clone_folder: c:\gopath\src\github.com\hashicorp\packer
 
 install:
-  - set GO111MODULE=off
+  - ps: |
+        # Installs golang on Windows.
+        #
+        # # Run script:
+        # .\install-go.ps1
+        #
+        # # Download and run script:
+        # $env:GOVERSION = '1.5.3'
+        # iex ((new-object net.webclient).DownloadString('SCRIPT_URL_HERE'))
+
+        $version = '1.11'
+
+        $downloadDir = $env:TEMP
+        $packageName = 'golang'
+        $url32 = 'https://storage.googleapis.com/golang/go' + $version + '.windows-386.zip'
+        $url64 = 'https://storage.googleapis.com/golang/go' + $version + '.windows-amd64.zip'
+        $goroot = "C:\go$version"
+
+        # Determine type of system
+        if ($ENV:PROCESSOR_ARCHITECTURE -eq "AMD64") {
+          $url = $url64
+        } else {
+          $url = $url32
+        }
+
+        if (Test-Path "$goroot\bin\go") {
+          Write-Host "Go is installed to $goroot"
+          exit
+        }
+
+        echo "Downloading $url"
+        $zip = "$downloadDir\golang-$version.zip"
+        if (!(Test-Path "$zip")) {
+          $downloader = new-object System.Net.WebClient
+          $downloader.DownloadFile($url, $zip)
+        }
+
+        echo "Extracting $zip to $goroot"
+        if (Test-Path "$downloadDir\go") {
+          rm -Force -Recurse -Path "$downloadDir\go"
+        }
+        Add-Type -AssemblyName System.IO.Compression.FileSystem
+        [System.IO.Compression.ZipFile]::ExtractToDirectory("$zip", $downloadDir)
+        mv "$downloadDir\go" $goroot
+  - set GO15VENDOREXPERIMENT=1
+  - set GOROOT=C:\go1.11
+  - set Path=%GOROOT%\bin;%PATH%
   - echo %Path%
+  - echo %GOROOT%
   - go version
   - go env
   - go get github.com/mitchellh/gox
@@ -27,9 +74,10 @@ build_script:
   - git rev-parse HEAD
  # go test $(go list ./... | grep -v vendor)
   - ps: |
-      go.exe test -v -timeout=2m (go.exe list ./... `
+      go.exe test (go.exe list ./... `
       |? { -not $_.Contains('/vendor/') } `
       |? { $_ -ne 'github.com/hashicorp/packer/builder/parallels/common' } `
+      |? { $_ -ne 'github.com/hashicorp/packer/common' }`
       |? { $_ -ne 'github.com/hashicorp/packer/provisioner/ansible' })
 
 test: off

builder/alicloud/ecs/builder.go

@@ -3,7 +3,8 @@
 package ecs
 
 import (
-	"context"
+	"log"
+
 	"fmt"
 
 	"github.com/hashicorp/packer/common"
@@ -56,11 +57,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		return nil, err
 	}
 
-	if b.config.PackerConfig.PackerForce {
-		b.config.AlicloudImageForceDelete = true
-		b.config.AlicloudImageForceDeleteSnapshots = true
-	}
-
 	// Accumulate any errors
 	var errs *packer.MultiError
 	errs = packer.MultiErrorAppend(errs, b.config.AlicloudAccessConfig.Prepare(&b.config.ctx)...)
@@ -72,17 +68,18 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	packer.LogSecretFilter.Set(b.config.AlicloudAccessKey, b.config.AlicloudSecretKey)
+	log.Println(b.config)
 	return nil, nil
 }
 
-func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
 
 	client, err := b.config.Client()
 	if err != nil {
 		return nil, err
 	}
 	state := new(multistep.BasicStateBag)
-	state.Put("config", &b.config)
+	state.Put("config", b.config)
 	state.Put("client", client)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
@@ -142,12 +139,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			RegionId:                 b.config.AlicloudRegion,
 			InternetChargeType:       b.config.InternetChargeType,
 			InternetMaxBandwidthOut:  b.config.InternetMaxBandwidthOut,
-			SSHPrivateIp:             b.config.SSHPrivateIp,
 		})
 	} else {
 		steps = append(steps, &stepConfigAlicloudPublicIP{
-			RegionId:     b.config.AlicloudRegion,
-			SSHPrivateIp: b.config.SSHPrivateIp,
+			RegionId: b.config.AlicloudRegion,
 		})
 	}
 	steps = append(steps,
@@ -162,35 +157,15 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
 		},
 		&common.StepProvision{},
-		&common.StepCleanupTempKeys{
-			Comm: &b.config.RunConfig.Comm,
-		},
 		&stepStopAlicloudInstance{
-			ForceStop:   b.config.ForceStopInstance,
-			DisableStop: b.config.DisableStopInstance,
+			ForceStop: b.config.ForceStopInstance,
 		},
 		&stepDeleteAlicloudImageSnapshots{
 			AlicloudImageForceDeleteSnapshots: b.config.AlicloudImageForceDeleteSnapshots,
 			AlicloudImageForceDelete:          b.config.AlicloudImageForceDelete,
 			AlicloudImageName:                 b.config.AlicloudImageName,
-			AlicloudImageDestinationRegions:   b.config.AlicloudImageConfig.AlicloudImageDestinationRegions,
-			AlicloudImageDestinationNames:     b.config.AlicloudImageConfig.AlicloudImageDestinationNames,
-		})
-
-	if b.config.AlicloudImageIgnoreDataDisks {
-		steps = append(steps, &stepCreateAlicloudSnapshot{
-			WaitSnapshotReadyTimeout: b.getSnapshotReadyTimeout(),
-		})
-	}
-
-	steps = append(steps,
-		&stepCreateAlicloudImage{
-			AlicloudImageIgnoreDataDisks: b.config.AlicloudImageIgnoreDataDisks,
-			WaitSnapshotReadyTimeout:     b.getSnapshotReadyTimeout(),
-		},
-		&stepCreateTags{
-			Tags: b.config.AlicloudImageTags,
 		},
+		&stepCreateAlicloudImage{},
 		&stepRegionCopyAlicloudImage{
 			AlicloudImageDestinationRegions: b.config.AlicloudImageDestinationRegions,
 			AlicloudImageDestinationNames:   b.config.AlicloudImageDestinationNames,
@@ -204,7 +179,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	// Run!
 	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
-	b.runner.Run(ctx, state)
+	b.runner.Run(state)
 
 	// If there was an error, return that
 	if rawErr, ok := state.GetOk("error"); ok {
@@ -226,6 +201,13 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	return artifact, nil
 }
 
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}
+
 func (b *Builder) chooseNetworkType() InstanceNetWork {
 	if b.isVpcNetRequired() {
 		return VpcNet
@@ -255,11 +237,3 @@ func (b *Builder) isUserDataNeeded() bool {
 func (b *Builder) isKeyPairNeeded() bool {
 	return b.config.Comm.SSHKeyPairName != "" || b.config.Comm.SSHTemporaryKeyPairName != ""
 }
-
-func (b *Builder) getSnapshotReadyTimeout() int {
-	if b.config.WaitSnapshotReadyTimeout > 0 {
-		return b.config.WaitSnapshotReadyTimeout
-	}
-
-	return ALICLOUD_DEFAULT_LONG_TIMEOUT
-}

builder/alicloud/ecs/builder_acc_test.go

@@ -113,17 +113,6 @@ func TestBuilderAcc_forceDeleteSnapshot(t *testing.T) {
 	})
 }
 
-func TestBuilderAcc_imageTags(t *testing.T) {
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccImageTags,
-		Check:    checkImageTags(),
-	})
-}
-
 func checkSnapshotsDeleted(snapshotIds []string) builderT.TestCheckFunc {
 	return func(artifacts []packer.Artifact) error {
 		// Verify the snapshots are gone
@@ -218,51 +207,6 @@ func checkRegionCopy(regions []string) builderT.TestCheckFunc {
 	}
 }
 
-func checkImageTags() builderT.TestCheckFunc {
-	return func(artifacts []packer.Artifact) error {
-		if len(artifacts) > 1 {
-			return fmt.Errorf("more than 1 artifact")
-		}
-		// Get the actual *Artifact pointer so we can access the AMIs directly
-		artifactRaw := artifacts[0]
-		artifact, ok := artifactRaw.(*Artifact)
-		if !ok {
-			return fmt.Errorf("unknown artifact: %#v", artifactRaw)
-		}
-		// describe the image, get block devices with a snapshot
-		client, _ := testAliyunClient()
-		tags, _, err := client.DescribeTags(
-			&ecs.DescribeTagsArgs{
-				RegionId:     "cn-beijing",
-				ResourceType: ecs.TagResourceImage,
-				ResourceId:   artifact.AlicloudImages["cn-beijing"],
-			})
-		if err != nil {
-			return fmt.Errorf("Error retrieving Image Attributes for ECS Image Artifact (%#v) "+
-				"in ECS Image Tags Test: %s", artifact, err)
-		}
-		failed := false
-		if len(tags) != 2 {
-			failed = true
-		}
-		if !failed {
-			for i := 0; i < len(tags); i++ {
-				if tags[i].TagKey == "TagKey1" && tags[i].TagValue != "TagValue1" {
-					failed = true
-				} else if tags[i].TagKey == "TagKey2" && tags[i].TagValue != "TagValue2" {
-					failed = true
-				} else if tags[i].TagKey != "TagKey1" && tags[i].TagKey != "TagKey2" {
-					failed = true
-				}
-			}
-		}
-		if failed {
-			return fmt.Errorf("tags is not correctly set %#v", tags)
-		}
-		return nil
-	}
-}
-
 func testAccPreCheck(t *testing.T) {
 	if v := os.Getenv("ALICLOUD_ACCESS_KEY"); v == "" {
 		t.Fatal("ALICLOUD_ACCESS_KEY must be set for acceptance tests")
@@ -292,7 +236,8 @@ const testBuilderAccBasic = `
 		"type": "test",
 		"region": "cn-beijing",
 		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190223.vhd",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
+		"ssh_username": "ubuntu",
 		"io_optimized":"true",
 		"ssh_username":"root",
 		"image_name": "packer-test_{{timestamp}}"
@@ -305,7 +250,7 @@ const testBuilderAccRegionCopy = `
 		"type": "test",
 		"region": "cn-beijing",
 		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190223.vhd",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
 		"io_optimized":"true",
 		"ssh_username":"root",
 		"image_name": "packer-test_{{timestamp}}",
@@ -320,7 +265,7 @@ const testBuilderAccForceDelete = `
 		"type": "test",
 		"region": "cn-beijing",
 		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190223.vhd",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
 		"io_optimized":"true",
 		"ssh_username":"root",
 		"image_force_delete": "%s",
@@ -335,7 +280,7 @@ const testBuilderAccForceDeleteSnapshot = `
 		"type": "test",
 		"region": "cn-beijing",
 		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190223.vhd",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
 		"io_optimized":"true",
 		"ssh_username":"root",
 		"image_force_delete_snapshots": "%s",
@@ -352,7 +297,7 @@ const testBuilderAccSharing = `
 		"type": "test",
 		"region": "cn-beijing",
 		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190223.vhd",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
 		"io_optimized":"true",
 		"ssh_username":"root",
 		"image_name": "packer-test_{{timestamp}}",
@@ -361,22 +306,6 @@ const testBuilderAccSharing = `
 }
 `
 
-const testBuilderAccImageTags = `
-{	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190223.vhd",
-		"ssh_username": "root",
-		"io_optimized":"true",
-		"image_name": "packer-test_{{timestamp}}",
-		"tags": {
-			"TagKey1": "TagValue1",
-			"TagKey2": "TagValue2"
-        }
-	}]
-}`
-
 func buildForceDeregisterConfig(val, name string) string {
 	return fmt.Sprintf(testBuilderAccForceDelete, val, name)
 }

builder/alicloud/ecs/builder_test.go

@@ -1,7 +1,6 @@
 package ecs
 
 import (
-	"reflect"
 	"testing"
 
 	"github.com/hashicorp/packer/packer"
@@ -94,141 +93,3 @@ func TestBuilderPrepare_InvalidKey(t *testing.T) {
 		t.Fatal("should have error")
 	}
 }
-
-func TestBuilderPrepare_Devices(t *testing.T) {
-	var b Builder
-	config := testBuilderConfig()
-	config["system_disk_mapping"] = map[string]interface{}{
-		"disk_category":    "cloud",
-		"disk_description": "system disk",
-		"disk_name":        "system_disk",
-		"disk_size":        60,
-	}
-	config["image_disk_mappings"] = []map[string]interface{}{
-		{
-			"disk_category":             "cloud_efficiency",
-			"disk_name":                 "data_disk1",
-			"disk_size":                 100,
-			"disk_snapshot_id":          "s-1",
-			"disk_description":          "data disk1",
-			"disk_device":               "/dev/xvdb",
-			"disk_delete_with_instance": false,
-		},
-		{
-			"disk_name":   "data_disk2",
-			"disk_device": "/dev/xvdc",
-		},
-	}
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-	if !reflect.DeepEqual(b.config.ECSSystemDiskMapping, AlicloudDiskDevice{
-		DiskCategory: "cloud",
-		Description:  "system disk",
-		DiskName:     "system_disk",
-		DiskSize:     60,
-	}) {
-		t.Fatalf("system disk is not set properly, actual: %#v", b.config.ECSSystemDiskMapping)
-	}
-	if !reflect.DeepEqual(b.config.ECSImagesDiskMappings, []AlicloudDiskDevice{
-		{
-			DiskCategory:       "cloud_efficiency",
-			DiskName:           "data_disk1",
-			DiskSize:           100,
-			SnapshotId:         "s-1",
-			Description:        "data disk1",
-			Device:             "/dev/xvdb",
-			DeleteWithInstance: false,
-		},
-		{
-			DiskName: "data_disk2",
-			Device:   "/dev/xvdc",
-		},
-	}) {
-		t.Fatalf("data disks are not set properly, actual: %#v", b.config.ECSImagesDiskMappings)
-	}
-}
-
-func TestBuilderPrepare_IgnoreDataDisks(t *testing.T) {
-	var b Builder
-	config := testBuilderConfig()
-
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.AlicloudImageIgnoreDataDisks != false {
-		t.Fatalf("image_ignore_data_disks is not set properly, expect: %t, actual: %t", false, b.config.AlicloudImageIgnoreDataDisks)
-	}
-
-	config["image_ignore_data_disks"] = "false"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.AlicloudImageIgnoreDataDisks != false {
-		t.Fatalf("image_ignore_data_disks is not set properly, expect: %t, actual: %t", false, b.config.AlicloudImageIgnoreDataDisks)
-	}
-
-	config["image_ignore_data_disks"] = "true"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.AlicloudImageIgnoreDataDisks != true {
-		t.Fatalf("image_ignore_data_disks is not set properly, expect: %t, actual: %t", true, b.config.AlicloudImageIgnoreDataDisks)
-	}
-}
-
-func TestBuilderPrepare_WaitSnapshotReadyTimeout(t *testing.T) {
-	var b Builder
-	config := testBuilderConfig()
-
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.WaitSnapshotReadyTimeout != 0 {
-		t.Fatalf("wait_snapshot_ready_timeout is not set properly, expect: %d, actual: %d", 0, b.config.WaitSnapshotReadyTimeout)
-	}
-	if b.getSnapshotReadyTimeout() != ALICLOUD_DEFAULT_LONG_TIMEOUT {
-		t.Fatalf("default timeout is not set properly, expect: %d, actual: %d", ALICLOUD_DEFAULT_LONG_TIMEOUT, b.getSnapshotReadyTimeout())
-	}
-
-	config["wait_snapshot_ready_timeout"] = ALICLOUD_DEFAULT_TIMEOUT
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.WaitSnapshotReadyTimeout != ALICLOUD_DEFAULT_TIMEOUT {
-		t.Fatalf("wait_snapshot_ready_timeout is not set properly, expect: %d, actual: %d", ALICLOUD_DEFAULT_TIMEOUT, b.config.WaitSnapshotReadyTimeout)
-	}
-
-	if b.getSnapshotReadyTimeout() != ALICLOUD_DEFAULT_TIMEOUT {
-		t.Fatalf("default timeout is not set properly, expect: %d, actual: %d", ALICLOUD_DEFAULT_TIMEOUT, b.getSnapshotReadyTimeout())
-	}
-}

builder/alicloud/ecs/image_config.go

@@ -21,24 +21,21 @@ type AlicloudDiskDevice struct {
 }
 
 type AlicloudDiskDevices struct {
-	ECSSystemDiskMapping  AlicloudDiskDevice   `mapstructure:"system_disk_mapping"`
 	ECSImagesDiskMappings []AlicloudDiskDevice `mapstructure:"image_disk_mappings"`
 }
 
 type AlicloudImageConfig struct {
-	AlicloudImageName                 string            `mapstructure:"image_name"`
-	AlicloudImageVersion              string            `mapstructure:"image_version"`
-	AlicloudImageDescription          string            `mapstructure:"image_description"`
-	AlicloudImageShareAccounts        []string          `mapstructure:"image_share_account"`
-	AlicloudImageUNShareAccounts      []string          `mapstructure:"image_unshare_account"`
-	AlicloudImageDestinationRegions   []string          `mapstructure:"image_copy_regions"`
-	AlicloudImageDestinationNames     []string          `mapstructure:"image_copy_names"`
-	AlicloudImageForceDelete          bool              `mapstructure:"image_force_delete"`
-	AlicloudImageForceDeleteSnapshots bool              `mapstructure:"image_force_delete_snapshots"`
-	AlicloudImageForceDeleteInstances bool              `mapstructure:"image_force_delete_instances"`
-	AlicloudImageIgnoreDataDisks      bool              `mapstructure:"image_ignore_data_disks"`
-	AlicloudImageSkipRegionValidation bool              `mapstructure:"skip_region_validation"`
-	AlicloudImageTags                 map[string]string `mapstructure:"tags"`
+	AlicloudImageName                 string   `mapstructure:"image_name"`
+	AlicloudImageVersion              string   `mapstructure:"image_version"`
+	AlicloudImageDescription          string   `mapstructure:"image_description"`
+	AlicloudImageShareAccounts        []string `mapstructure:"image_share_account"`
+	AlicloudImageUNShareAccounts      []string `mapstructure:"image_unshare_account"`
+	AlicloudImageDestinationRegions   []string `mapstructure:"image_copy_regions"`
+	AlicloudImageDestinationNames     []string `mapstructure:"image_copy_names"`
+	AlicloudImageForceDelete          bool     `mapstructure:"image_force_delete"`
+	AlicloudImageForceDeleteSnapshots bool     `mapstructure:"image_force_delete_snapshots"`
+	AlicloudImageForceDeleteInstances bool     `mapstructure:"image_force_delete_instances"`
+	AlicloudImageSkipRegionValidation bool     `mapstructure:"skip_region_validation"`
 	AlicloudDiskDevices               `mapstructure:",squash"`
 }
 

builder/alicloud/ecs/image_config_test.go

@@ -55,24 +55,6 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 
 }
 
-func TestECSImageConfigPrepare_imageTags(t *testing.T) {
-	c := testAlicloudImageConfig()
-	c.AlicloudImageTags = map[string]string{
-		"TagKey1": "TagValue1",
-		"TagKey2": "TagValue2",
-	}
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-	if len(c.AlicloudImageTags) != 2 || c.AlicloudImageTags["TagKey1"] != "TagValue1" ||
-		c.AlicloudImageTags["TagKey2"] != "TagValue2" {
-		t.Fatalf("invalid value, expected: %s, actual: %s", map[string]string{
-			"TagKey1": "TagValue1",
-			"TagKey2": "TagValue2",
-		}, c.AlicloudImageTags)
-	}
-}
-
 func regionsToString() []string {
 	var regions []string
 	for _, region := range common.ValidRegions {

builder/alicloud/ecs/packer_helper.go

@@ -20,15 +20,3 @@ func message(state multistep.StateBag, module string) {
 	}
 
 }
-
-func halt(state multistep.StateBag, err error, prefix string) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-
-	if prefix != "" {
-		err = fmt.Errorf("%s: %s", prefix, err)
-	}
-
-	state.Put("error", err)
-	ui.Error(err.Error())
-	return multistep.ActionHalt
-}

builder/alicloud/ecs/run_config.go

@@ -19,7 +19,6 @@ type RunConfig struct {
 	Description              string `mapstructure:"description"`
 	AlicloudSourceImage      string `mapstructure:"source_image"`
 	ForceStopInstance        bool   `mapstructure:"force_stop_instance"`
-	DisableStopInstance      bool   `mapstructure:"disable_stop_instance"`
 	SecurityGroupId          string `mapstructure:"security_group_id"`
 	SecurityGroupName        string `mapstructure:"security_group_name"`
 	UserData                 string `mapstructure:"user_data"`
@@ -32,7 +31,6 @@ type RunConfig struct {
 	InstanceName             string `mapstructure:"instance_name"`
 	InternetChargeType       string `mapstructure:"internet_charge_type"`
 	InternetMaxBandwidthOut  int    `mapstructure:"internet_max_bandwidth_out"`
-	WaitSnapshotReadyTimeout int    `mapstructure:"wait_snapshot_ready_timeout"`
 
 	// Communicator settings
 	Comm         communicator.Config `mapstructure:",squash"`

builder/alicloud/ecs/run_config_test.go

@@ -123,54 +123,3 @@ func TestRunConfigPrepare_TemporaryKeyPairName(t *testing.T) {
 		t.Fatal("keypair name does not match")
 	}
 }
-
-func TestRunConfigPrepare_SSHPrivateIp(t *testing.T) {
-	c := testConfig()
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-	if c.SSHPrivateIp != false {
-		t.Fatalf("invalid value, expected: %t, actul: %t", false, c.SSHPrivateIp)
-	}
-	c.SSHPrivateIp = true
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-	if c.SSHPrivateIp != true {
-		t.Fatalf("invalid value, expected: %t, actul: %t", true, c.SSHPrivateIp)
-	}
-	c.SSHPrivateIp = false
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-	if c.SSHPrivateIp != false {
-		t.Fatalf("invalid value, expected: %t, actul: %t", false, c.SSHPrivateIp)
-	}
-}
-
-func TestRunConfigPrepare_DisableStopInstance(t *testing.T) {
-	c := testConfig()
-
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-	if c.DisableStopInstance != false {
-		t.Fatalf("invalid value, expected: %t, actul: %t", false, c.DisableStopInstance)
-	}
-
-	c.DisableStopInstance = true
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-	if c.DisableStopInstance != true {
-		t.Fatalf("invalid value, expected: %t, actul: %t", true, c.DisableStopInstance)
-	}
-
-	c.DisableStopInstance = false
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-	if c.DisableStopInstance != false {
-		t.Fatalf("invalid value, expected: %t, actul: %t", false, c.DisableStopInstance)
-	}
-}

builder/alicloud/ecs/step_attach_keypair.go

@@ -15,10 +15,10 @@ import (
 type stepAttachKeyPair struct {
 }
 
-func (s *stepAttachKeyPair) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepAttachKeyPair) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 	client := state.Get("client").(*ecs.Client)
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 	instance := state.Get("instance").(*ecs.InstanceAttributesType)
 	timeoutPoint := time.Now().Add(120 * time.Second)
 	keyPairName := config.Comm.SSHKeyPairName
@@ -52,7 +52,7 @@ func (s *stepAttachKeyPair) Run(ctx context.Context, state multistep.StateBag) m
 
 func (s *stepAttachKeyPair) Cleanup(state multistep.StateBag) {
 	client := state.Get("client").(*ecs.Client)
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 	ui := state.Get("ui").(packer.Ui)
 	instance := state.Get("instance").(*ecs.InstanceAttributesType)
 	keyPairName := config.Comm.SSHKeyPairName

builder/alicloud/ecs/step_check_source_image.go

@@ -14,9 +14,9 @@ type stepCheckAlicloudSourceImage struct {
 	SourceECSImageId string
 }
 
-func (s *stepCheckAlicloudSourceImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepCheckAlicloudSourceImage) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 	ui := state.Get("ui").(packer.Ui)
 	args := &ecs.DescribeImagesArgs{
 		RegionId: common.Region(config.AlicloudRegion),

builder/alicloud/ecs/step_config_eip.go

@@ -16,24 +16,12 @@ type stepConfigAlicloudEIP struct {
 	InternetChargeType       string
 	InternetMaxBandwidthOut  int
 	allocatedId              string
-	SSHPrivateIp             bool
 }
 
-func (s *stepConfigAlicloudEIP) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepConfigAlicloudEIP) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 	instance := state.Get("instance").(*ecs.InstanceAttributesType)
-
-	if s.SSHPrivateIp {
-		ipaddress := instance.VpcAttributes.PrivateIpAddress.IpAddress
-		if len(ipaddress) == 0 {
-			ui.Say("Failed to get private ip of instance")
-			return multistep.ActionHalt
-		}
-		state.Put("ipaddress", ipaddress[0])
-		return multistep.ActionContinue
-	}
-
 	ui.Say("Allocating eip")
 	ipaddress, allocateId, err := client.AllocateEipAddress(&ecs.AllocateEipAddressArgs{
 		RegionId: common.Region(s.RegionId), InternetChargeType: common.InternetChargeType(s.InternetChargeType),

builder/alicloud/ecs/step_config_key_pair.go

@@ -3,6 +3,7 @@ package ecs
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"runtime"
 
@@ -22,14 +23,15 @@ type stepConfigAlicloudKeyPair struct {
 	keyName string
 }
 
-func (s *stepConfigAlicloudKeyPair) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepConfigAlicloudKeyPair) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	if s.Comm.SSHPrivateKeyFile != "" {
 		ui.Say("Using existing SSH private key")
-		privateKeyBytes, err := s.Comm.ReadSSHPrivateKeyFile()
+		privateKeyBytes, err := ioutil.ReadFile(s.Comm.SSHPrivateKeyFile)
 		if err != nil {
-			state.Put("error", err)
+			state.Put("error", fmt.Errorf(
+				"Error loading configured private key file: %s", err))
 			return multistep.ActionHalt
 		}
 

builder/alicloud/ecs/step_config_public_ip.go

@@ -12,24 +12,13 @@ import (
 type stepConfigAlicloudPublicIP struct {
 	publicIPAddress string
 	RegionId        string
-	SSHPrivateIp    bool
 }
 
-func (s *stepConfigAlicloudPublicIP) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepConfigAlicloudPublicIP) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 	instance := state.Get("instance").(*ecs.InstanceAttributesType)
 
-	if s.SSHPrivateIp {
-		ipaddress := instance.InnerIpAddress.IpAddress
-		if len(ipaddress) == 0 {
-			ui.Say("Failed to get private ip of instance")
-			return multistep.ActionHalt
-		}
-		state.Put("ipaddress", ipaddress[0])
-		return multistep.ActionContinue
-	}
-
 	ipaddress, err := client.AllocatePublicIpAddress(instance.InstanceId)
 	if err != nil {
 		state.Put("error", err)

builder/alicloud/ecs/step_config_security_group.go

@@ -21,7 +21,7 @@ type stepConfigAlicloudSecurityGroup struct {
 	isCreate          bool
 }
 
-func (s *stepConfigAlicloudSecurityGroup) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepConfigAlicloudSecurityGroup) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 	networkType := state.Get("networktype").(InstanceNetWork)

builder/alicloud/ecs/step_config_vpc.go

@@ -19,8 +19,8 @@ type stepConfigAlicloudVPC struct {
 	isCreate  bool
 }
 
-func (s *stepConfigAlicloudVPC) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
+func (s *stepConfigAlicloudVPC) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(Config)
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 

builder/alicloud/ecs/step_config_vswitch.go

@@ -20,11 +20,11 @@ type stepConfigAlicloudVSwitch struct {
 	VSwitchName string
 }
 
-func (s *stepConfigAlicloudVSwitch) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepConfigAlicloudVSwitch) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 	vpcId := state.Get("vpcid").(string)
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 
 	if len(s.VSwitchId) != 0 {
 		vswitchs, _, err := client.DescribeVSwitches(&ecs.DescribeVSwitchesArgs{

builder/alicloud/ecs/step_create_image.go

@@ -11,13 +11,11 @@ import (
 )
 
 type stepCreateAlicloudImage struct {
-	AlicloudImageIgnoreDataDisks bool
-	WaitSnapshotReadyTimeout     int
-	image                        *ecs.ImageType
+	image *ecs.ImageType
 }
 
-func (s *stepCreateAlicloudImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
+func (s *stepCreateAlicloudImage) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(Config)
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 
@@ -26,53 +24,48 @@ func (s *stepCreateAlicloudImage) Run(ctx context.Context, state multistep.State
 	var imageId string
 	var err error
 
-	if s.AlicloudImageIgnoreDataDisks {
-		snapshotId := state.Get("alicloudsnapshot").(string)
-		imageId, err = client.CreateImage(&ecs.CreateImageArgs{
-			RegionId:     common.Region(config.AlicloudRegion),
-			SnapshotId:   snapshotId,
-			ImageName:    config.AlicloudImageName,
-			ImageVersion: config.AlicloudImageVersion,
-			Description:  config.AlicloudImageDescription})
-	} else {
-		instance := state.Get("instance").(*ecs.InstanceAttributesType)
-		imageId, err = client.CreateImage(&ecs.CreateImageArgs{
-			RegionId:     common.Region(config.AlicloudRegion),
-			InstanceId:   instance.InstanceId,
-			ImageName:    config.AlicloudImageName,
-			ImageVersion: config.AlicloudImageVersion,
-			Description:  config.AlicloudImageDescription})
-	}
+	instance := state.Get("instance").(*ecs.InstanceAttributesType)
+	imageId, err = client.CreateImage(&ecs.CreateImageArgs{
+		RegionId:     common.Region(config.AlicloudRegion),
+		InstanceId:   instance.InstanceId,
+		ImageName:    config.AlicloudImageName,
+		ImageVersion: config.AlicloudImageVersion,
+		Description:  config.AlicloudImageDescription})
 
 	if err != nil {
-		return halt(state, err, "Error creating image")
+		err := fmt.Errorf("Error creating image: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
-	err = client.WaitForImageReady(common.Region(config.AlicloudRegion), imageId, s.WaitSnapshotReadyTimeout)
+	err = client.WaitForImageReady(common.Region(config.AlicloudRegion),
+		imageId, ALICLOUD_DEFAULT_LONG_TIMEOUT)
 	if err != nil {
-		return halt(state, err, "Timeout waiting for image to be created")
+		err := fmt.Errorf("Timeout waiting for image to be created: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
 
 	images, _, err := client.DescribeImages(&ecs.DescribeImagesArgs{
 		RegionId: common.Region(config.AlicloudRegion),
 		ImageId:  imageId})
 	if err != nil {
-		return halt(state, err, "Error querying created imaged")
+		err := fmt.Errorf("Error querying created image: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
 
 	if len(images) == 0 {
-		return halt(state, err, "Unable to find created image")
+		err := fmt.Errorf("Unable to find created image: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
-
 	s.image = &images[0]
 
-	var snapshotIds = []string{}
-	for _, device := range images[0].DiskDeviceMappings.DiskDeviceMapping {
-		snapshotIds = append(snapshotIds, device.SnapshotId)
-	}
-
 	state.Put("alicloudimage", imageId)
-	state.Put("alicloudsnapshots", snapshotIds)
-
 	alicloudImages := make(map[string]string)
 	alicloudImages[config.AlicloudRegion] = images[0].ImageId
 	state.Put("alicloudimages", alicloudImages)
@@ -92,7 +85,7 @@ func (s *stepCreateAlicloudImage) Cleanup(state multistep.StateBag) {
 
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 
 	ui.Say("Deleting the image because of cancellation or error...")
 	if err := client.DeleteImage(common.Region(config.AlicloudRegion), s.image.ImageId); err != nil {

builder/alicloud/ecs/step_create_instance.go

@@ -26,9 +26,9 @@ type stepCreateAlicloudInstance struct {
 	instance                *ecs.InstanceAttributesType
 }
 
-func (s *stepCreateAlicloudInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepCreateAlicloudInstance) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 	ui := state.Get("ui").(packer.Ui)
 	source_image := state.Get("source_image").(*ecs.ImageType)
 	network_type := state.Get("networktype").(InstanceNetWork)
@@ -66,7 +66,6 @@ func (s *stepCreateAlicloudInstance) Run(ctx context.Context, state multistep.St
 			InstanceName:            s.InstanceName,
 			Password:                password,
 			ZoneId:                  s.ZoneId,
-			SystemDisk:              systemDeviceToDiskType(config.AlicloudImageConfig.ECSSystemDiskMapping),
 			DataDisk:                diskDeviceToDiskType(config.AlicloudImageConfig.ECSImagesDiskMappings),
 		})
 		if err != nil {
@@ -148,15 +147,6 @@ func (s *stepCreateAlicloudInstance) getUserData(state multistep.StateBag) (stri
 
 }
 
-func systemDeviceToDiskType(systemDisk AlicloudDiskDevice) ecs.SystemDiskType {
-	return ecs.SystemDiskType{
-		DiskName:    systemDisk.DiskName,
-		Category:    ecs.DiskCategory(systemDisk.DiskCategory),
-		Size:        systemDisk.DiskSize,
-		Description: systemDisk.Description,
-	}
-}
-
 func diskDeviceToDiskType(diskDevices []AlicloudDiskDevice) []ecs.DataDiskType {
 	result := make([]ecs.DataDiskType, len(diskDevices))
 	for _, diskDevice := range diskDevices {

builder/alicloud/ecs/step_create_snapshot.go

@@ -1,88 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepCreateAlicloudSnapshot struct {
-	snapshot                 *ecs.SnapshotType
-	WaitSnapshotReadyTimeout int
-}
-
-func (s *stepCreateAlicloudSnapshot) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-
-	instance := state.Get("instance").(*ecs.InstanceAttributesType)
-	disks, _, err := client.DescribeDisks(&ecs.DescribeDisksArgs{
-		RegionId:   common.Region(config.AlicloudRegion),
-		InstanceId: instance.InstanceId,
-		DiskType:   ecs.DiskTypeAllSystem,
-	})
-
-	if err != nil {
-		return halt(state, err, "Error describe disks")
-	}
-	if len(disks) == 0 {
-		return halt(state, err, "Unable to find system disk of instance")
-	}
-
-	// Create the alicloud snapshot
-	ui.Say(fmt.Sprintf("Creating snapshot from system disk: %s", disks[0].DiskId))
-
-	snapshotId, err := client.CreateSnapshot(&ecs.CreateSnapshotArgs{
-		DiskId: disks[0].DiskId,
-	})
-
-	if err != nil {
-		return halt(state, err, "Error creating snapshot")
-	}
-
-	err = client.WaitForSnapShotReady(common.Region(config.AlicloudRegion), snapshotId, s.WaitSnapshotReadyTimeout)
-	if err != nil {
-		return halt(state, err, "Timeout waiting for snapshot to be created")
-	}
-
-	snapshots, _, err := client.DescribeSnapshots(&ecs.DescribeSnapshotsArgs{
-		RegionId:    common.Region(config.AlicloudRegion),
-		SnapshotIds: []string{snapshotId},
-	})
-
-	if err != nil {
-		return halt(state, err, "Error querying created snapshot")
-	}
-	if len(snapshots) == 0 {
-		return halt(state, err, "Unable to find created snapshot")
-	}
-	s.snapshot = &snapshots[0]
-	state.Put("alicloudsnapshot", snapshotId)
-
-	return multistep.ActionContinue
-}
-
-func (s *stepCreateAlicloudSnapshot) Cleanup(state multistep.StateBag) {
-	if s.snapshot == nil {
-		return
-	}
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-	if !cancelled && !halted {
-		return
-	}
-
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Deleting the snapshot because of cancellation or error...")
-	if err := client.DeleteSnapshot(s.snapshot.SnapshotId); err != nil {
-		ui.Error(fmt.Sprintf("Error deleting snapshot, it may still be around: %s", err))
-		return
-	}
-}

builder/alicloud/ecs/step_create_tags.go

@@ -1,55 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepCreateTags struct {
-	Tags map[string]string
-}
-
-func (s *stepCreateTags) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-	imageId := state.Get("alicloudimage").(string)
-	snapshotIds := state.Get("alicloudsnapshots").([]string)
-
-	if len(s.Tags) == 0 {
-		return multistep.ActionContinue
-	}
-	ui.Say(fmt.Sprintf("Adding tags(%s) to image: %s", s.Tags, imageId))
-	err := client.AddTags(&ecs.AddTagsArgs{
-		ResourceId:   imageId,
-		ResourceType: ecs.TagResourceImage,
-		RegionId:     common.Region(config.AlicloudRegion),
-		Tag:          s.Tags,
-	})
-	if err != nil {
-		return halt(state, err, "Error Adding tags to image")
-	}
-
-	for _, snapshotId := range snapshotIds {
-		ui.Say(fmt.Sprintf("Adding tags(%s) to snapshot: %s", s.Tags, snapshotId))
-		err = client.AddTags(&ecs.AddTagsArgs{
-			ResourceId:   snapshotId,
-			ResourceType: ecs.TagResourceSnapshot,
-			RegionId:     common.Region(config.AlicloudRegion),
-			Tag:          s.Tags,
-		})
-		if err != nil {
-			return halt(state, err, "Error Adding tags to snapshot")
-		}
-	}
-
-	return multistep.ActionContinue
-}
-func (s *stepCreateTags) Cleanup(state multistep.StateBag) {
-	// Nothing need to do, tags will be cleaned when the resource is cleaned
-}

builder/alicloud/ecs/step_delete_images_snapshots.go

@@ -15,82 +15,50 @@ type stepDeleteAlicloudImageSnapshots struct {
 	AlicloudImageForceDelete          bool
 	AlicloudImageForceDeleteSnapshots bool
 	AlicloudImageName                 string
-	AlicloudImageDestinationRegions   []string
-	AlicloudImageDestinationNames     []string
 }
 
-func (s *stepDeleteAlicloudImageSnapshots) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-
+func (s *stepDeleteAlicloudImageSnapshots) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*ecs.Client)
+	ui := state.Get("ui").(packer.Ui)
+	config := state.Get("config").(Config)
+	ui.Say("Deleting image snapshots.")
 	// Check for force delete
 	if s.AlicloudImageForceDelete {
-		err := s.deleteImageAndSnapshots(state, s.AlicloudImageName, config.AlicloudRegion)
-		if err != nil {
-			return halt(state, err, "")
-		}
-
-		numberOfName := len(s.AlicloudImageDestinationNames)
-		if numberOfName == 0 {
+		images, _, err := client.DescribeImages(&ecs.DescribeImagesArgs{
+			RegionId:  common.Region(config.AlicloudRegion),
+			ImageName: s.AlicloudImageName,
+		})
+		if len(images) < 1 {
 			return multistep.ActionContinue
 		}
-
-		for index, destinationRegion := range s.AlicloudImageDestinationRegions {
-			if destinationRegion == config.AlicloudRegion {
+		for _, image := range images {
+			if image.ImageOwnerAlias != string(ecs.ImageOwnerSelf) {
+				log.Printf("You can only delete instances based on customized images %s ", image.ImageId)
 				continue
 			}
-
-			if index < numberOfName {
-				err = s.deleteImageAndSnapshots(state, s.AlicloudImageDestinationNames[index], destinationRegion)
-				if err != nil {
-					return halt(state, err, "")
+			err = client.DeleteImage(common.Region(config.AlicloudRegion), image.ImageId)
+			if err != nil {
+				err := fmt.Errorf("Failed to delete image: %s", err)
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
+			if s.AlicloudImageForceDeleteSnapshots {
+				for _, diskDevice := range image.DiskDeviceMappings.DiskDeviceMapping {
+					if err := client.DeleteSnapshot(diskDevice.SnapshotId); err != nil {
+						err := fmt.Errorf("Deleting ECS snapshot failed: %s", err)
+						state.Put("error", err)
+						ui.Error(err.Error())
+						return multistep.ActionHalt
+					}
 				}
-			} else {
-				break
 			}
 		}
+
 	}
 
 	return multistep.ActionContinue
 }
 
-func (s *stepDeleteAlicloudImageSnapshots) deleteImageAndSnapshots(state multistep.StateBag, imageName string, region string) error {
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-
-	images, _, err := client.DescribeImages(&ecs.DescribeImagesArgs{
-		RegionId:  common.Region(region),
-		ImageName: imageName,
-	})
-	if len(images) < 1 {
-		return nil
-	}
-
-	ui.Say(fmt.Sprintf("Deleting duplicated image and snapshot in %s: %s", region, imageName))
-
-	for _, image := range images {
-		if image.ImageOwnerAlias != string(ecs.ImageOwnerSelf) {
-			log.Printf("You can not delete non-customized images: %s ", image.ImageId)
-			continue
-		}
-
-		err = client.DeleteImage(common.Region(region), image.ImageId)
-		if err != nil {
-			err := fmt.Errorf("Failed to delete image: %s", err)
-			return err
-		}
-
-		if s.AlicloudImageForceDeleteSnapshots {
-			for _, diskDevice := range image.DiskDeviceMappings.DiskDeviceMapping {
-				if err := client.DeleteSnapshot(diskDevice.SnapshotId); err != nil {
-					err := fmt.Errorf("Deleting ECS snapshot failed: %s", err)
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
 func (s *stepDeleteAlicloudImageSnapshots) Cleanup(state multistep.StateBag) {
 }

builder/alicloud/ecs/step_mount_disk.go

@@ -12,9 +12,9 @@ import (
 type stepMountAlicloudDisk struct {
 }
 
-func (s *stepMountAlicloudDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepMountAlicloudDisk) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 	ui := state.Get("ui").(packer.Ui)
 	instance := state.Get("instance").(*ecs.InstanceAttributesType)
 	alicloudDiskDevices := config.ECSImagesDiskMappings

builder/alicloud/ecs/step_pre_validate.go

@@ -15,7 +15,7 @@ type stepPreValidate struct {
 	ForceDelete           bool
 }
 
-func (s *stepPreValidate) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepPreValidate) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 	if s.ForceDelete {
 		ui.Say("Force delete flag found, skipping prevalidating image name.")
@@ -23,7 +23,7 @@ func (s *stepPreValidate) Run(ctx context.Context, state multistep.StateBag) mul
 	}
 
 	client := state.Get("client").(*ecs.Client)
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 	ui.Say("Prevalidating image name...")
 	images, _, err := client.DescribeImages(&ecs.DescribeImagesArgs{
 		ImageName: s.AlicloudDestImageName,
@@ -37,7 +37,7 @@ func (s *stepPreValidate) Run(ctx context.Context, state multistep.StateBag) mul
 	}
 
 	if len(images) > 0 {
-		err := fmt.Errorf("Error: Image Name: '%s' is used by an existing alicloud image: %s", images[0].ImageName, images[0].ImageId)
+		err := fmt.Errorf("Error: name conflicts with an existing alicloud image: %s", images[0].ImageId)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt

builder/alicloud/ecs/step_region_copy_image.go

@@ -16,7 +16,7 @@ type stepRegionCopyAlicloudImage struct {
 	RegionId                        string
 }
 
-func (s *stepRegionCopyAlicloudImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepRegionCopyAlicloudImage) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	if len(s.AlicloudImageDestinationRegions) == 0 {
 		return multistep.ActionContinue
 	}

builder/alicloud/ecs/step_run_instance.go

@@ -12,7 +12,7 @@ import (
 type stepRunAlicloudInstance struct {
 }
 
-func (s *stepRunAlicloudInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepRunAlicloudInstance) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 	instance := state.Get("instance").(*ecs.InstanceAttributesType)
@@ -24,9 +24,7 @@ func (s *stepRunAlicloudInstance) Run(ctx context.Context, state multistep.State
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
-
-	ui.Say(fmt.Sprintf("Starting instance: %s", instance.InstanceId))
-
+	ui.Say("Starting instance.")
 	err = client.WaitForInstance(instance.InstanceId, ecs.Running, ALICLOUD_DEFAULT_TIMEOUT)
 	if err != nil {
 		err := fmt.Errorf("Timeout waiting for instance to start: %s", err)

builder/alicloud/ecs/step_share_image.go

@@ -16,7 +16,7 @@ type stepShareAlicloudImage struct {
 	RegionId                     string
 }
 
-func (s *stepShareAlicloudImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepShareAlicloudImage) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 	alicloudImages := state.Get("alicloudimages").(map[string]string)

builder/alicloud/ecs/step_stop_instance.go

@@ -10,18 +10,16 @@ import (
 )
 
 type stepStopAlicloudInstance struct {
-	ForceStop   bool
-	DisableStop bool
+	ForceStop bool
 }
 
-func (s *stepStopAlicloudInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepStopAlicloudInstance) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("client").(*ecs.Client)
 	instance := state.Get("instance").(*ecs.InstanceAttributesType)
 	ui := state.Get("ui").(packer.Ui)
 
-	if !s.DisableStop {
-		ui.Say(fmt.Sprintf("Stopping instance: %s", instance.InstanceId))
-		err := client.StopInstance(instance.InstanceId, s.ForceStop)
+	err := client.StopInstance(instance.InstanceId, s.ForceStop)
+	if err != nil {
 		if err != nil {
 			err := fmt.Errorf("Error stopping alicloud instance: %s", err)
 			state.Put("error", err)
@@ -30,9 +28,7 @@ func (s *stepStopAlicloudInstance) Run(ctx context.Context, state multistep.Stat
 		}
 	}
 
-	ui.Say(fmt.Sprintf("Waiting instance stopped: %s", instance.InstanceId))
-
-	err := client.WaitForInstance(instance.InstanceId, ecs.Stopped, ALICLOUD_DEFAULT_TIMEOUT)
+	err = client.WaitForInstance(instance.InstanceId, ecs.Stopped, ALICLOUD_DEFAULT_TIMEOUT)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for alicloud instance to stop: %s", err)
 		state.Put("error", err)

builder/amazon/chroot/builder.go

@@ -5,8 +5,8 @@
 package chroot
 
 import (
-	"context"
 	"errors"
+	"log"
 	"runtime"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
@@ -42,7 +42,6 @@ type Config struct {
 	PreMountCommands  []string                   `mapstructure:"pre_mount_commands"`
 	RootDeviceName    string                     `mapstructure:"root_device_name"`
 	RootVolumeSize    int64                      `mapstructure:"root_volume_size"`
-	RootVolumeType    string                     `mapstructure:"root_volume_type"`
 	SourceAmi         string                     `mapstructure:"source_ami"`
 	SourceAmiFilter   awscommon.AmiFilterOptions `mapstructure:"source_ami_filter"`
 	RootVolumeTags    awscommon.TagMap           `mapstructure:"root_volume_tags"`
@@ -102,6 +101,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 
 	// set default copy file if we're not giving our own
 	if b.config.CopyFiles == nil {
+		b.config.CopyFiles = make([]string, 0)
 		if !b.config.FromScratch {
 			b.config.CopyFiles = []string{"/etc/resolv.conf"}
 		}
@@ -164,20 +164,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			errs = packer.MultiErrorAppend(
 				errs, errors.New("source_ami or source_ami_filter is required."))
 		}
-		if len(b.config.AMIMappings) > 0 && b.config.RootDeviceName != "" {
-			if b.config.RootVolumeSize == 0 {
-				// Although, they can specify the device size in the block device mapping, it's easier to
-				// be specific here.
-				errs = packer.MultiErrorAppend(
-					errs, errors.New("root_volume_size is required if ami_block_device_mappings is specified"))
-			}
-			warns = append(warns, "ami_block_device_mappings from source image will be completely overwritten")
-		} else if len(b.config.AMIMappings) > 0 {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("If ami_block_device_mappings is specified, root_device_name must be specified"))
-		} else if b.config.RootDeviceName != "" {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("If root_device_name is specified, ami_block_device_mappings must be specified"))
+		if len(b.config.AMIMappings) != 0 {
+			warns = append(warns, "ami_block_device_mappings are unused when from_scratch is false")
+		}
+		if b.config.RootDeviceName != "" {
+			warns = append(warns, "root_device_name is unused when from_scratch is false")
 		}
 	}
 
@@ -186,10 +177,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	packer.LogSecretFilter.Set(b.config.AccessKey, b.config.SecretKey, b.config.Token)
+	log.Println(b.config)
 	return warns, nil
 }
 
-func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
 	if runtime.GOOS != "linux" {
 		return nil, errors.New("The amazon-chroot builder only works on Linux environments.")
 	}
@@ -201,16 +193,14 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	ec2conn := ec2.New(session)
 
 	wrappedCommand := func(command string) (string, error) {
-		ictx := b.config.ctx
-		ictx.Data = &wrappedCommandTemplate{Command: command}
-		return interpolate.Render(b.config.CommandWrapper, &ictx)
+		ctx := b.config.ctx
+		ctx.Data = &wrappedCommandTemplate{Command: command}
+		return interpolate.Render(b.config.CommandWrapper, &ctx)
 	}
 
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
-	state.Put("access_config", &b.config.AccessConfig)
-	state.Put("ami_config", &b.config.AMIConfig)
 	state.Put("ec2", ec2conn)
 	state.Put("awsSession", session)
 	state.Put("hook", hook)
@@ -233,7 +223,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 				EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
 				EnableAMIENASupport:      b.config.AMIENASupport,
 				AmiFilters:               b.config.SourceAmiFilter,
-				AMIVirtType:              b.config.AMIVirtType,
 			},
 			&StepCheckRootDevice{},
 		)
@@ -243,7 +232,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&StepFlock{},
 		&StepPrepareDevice{},
 		&StepCreateVolume{
-			RootVolumeType: b.config.RootVolumeType,
 			RootVolumeSize: b.config.RootVolumeSize,
 			RootVolumeTags: b.config.RootVolumeTags,
 			Ctx:            b.config.ctx,
@@ -277,6 +265,12 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
 			EnableAMIENASupport:      b.config.AMIENASupport,
 		},
+		&awscommon.StepCreateEncryptedAMICopy{
+			KeyID:             b.config.AMIKmsKeyId,
+			EncryptBootVolume: b.config.AMIEncryptBootVolume,
+			Name:              b.config.AMIName,
+			AMIMappings:       b.config.AMIBlockDevices.AMIMappings,
+		},
 		&awscommon.StepAMIRegionCopy{
 			AccessConfig:      &b.config.AccessConfig,
 			Regions:           b.config.AMIRegions,
@@ -302,7 +296,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	// Run!
 	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
-	b.runner.Run(ctx, state)
+	b.runner.Run(state)
 
 	// If there was an error, return that
 	if rawErr, ok := state.GetOk("error"); ok {
@@ -323,3 +317,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	return artifact, nil
 }
+
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}

builder/amazon/chroot/builder_test.go

@@ -11,8 +11,6 @@ func testConfig() map[string]interface{} {
 		"ami_name":   "foo",
 		"source_ami": "foo",
 		"region":     "us-east-1",
-		// region validation logic is checked in ami_config_test
-		"skip_region_validation": true,
 	}
 }
 
@@ -30,7 +28,6 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 
 	// Test good
 	config["ami_name"] = "foo"
-	config["skip_region_validation"] = true
 	warnings, err := b.Prepare(config)
 	if len(warnings) > 0 {
 		t.Fatalf("bad: %#v", warnings)
@@ -159,53 +156,6 @@ func TestBuilderPrepare_CopyFilesNoDefault(t *testing.T) {
 	}
 
 	if len(b.config.CopyFiles) > 0 {
-		t.Errorf("Was expecting no default value for copy_files. Found %v",
-			b.config.CopyFiles)
-	}
-}
-
-func TestBuilderPrepare_RootDeviceNameAndAMIMappings(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	config["root_device_name"] = "/dev/sda"
-	config["ami_block_device_mappings"] = []interface{}{map[string]string{}}
-	config["root_volume_size"] = 15
-	warnings, err := b.Prepare(config)
-	if len(warnings) == 0 {
-		t.Fatal("Missing warning, stating block device mappings will be overwritten")
-	} else if len(warnings) > 1 {
-		t.Fatalf("excessive warnings: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_AMIMappingsNoRootDeviceName(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	config["ami_block_device_mappings"] = []interface{}{map[string]string{}}
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatalf("should have error")
-	}
-}
-
-func TestBuilderPrepare_RootDeviceNameNoAMIMappings(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	config["root_device_name"] = "/dev/sda"
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatalf("should have error")
+		t.Errorf("Was expecting no default value for copy_files.")
 	}
 }

builder/amazon/chroot/communicator.go

@@ -2,9 +2,9 @@ package chroot
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -14,7 +14,6 @@ import (
 	"syscall"
 
 	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/packer/tmp"
 )
 
 // Communicator is a special communicator that works by executing
@@ -24,7 +23,7 @@ type Communicator struct {
 	CmdWrapper CommandWrapper
 }
 
-func (c *Communicator) Start(ctx context.Context, cmd *packer.RemoteCmd) error {
+func (c *Communicator) Start(cmd *packer.RemoteCmd) error {
 	// need extra escapes for the command since we're wrapping it in quotes
 	cmd.Command = strconv.Quote(cmd.Command)
 	command, err := c.CmdWrapper(
@@ -68,7 +67,7 @@ func (c *Communicator) Start(ctx context.Context, cmd *packer.RemoteCmd) error {
 func (c *Communicator) Upload(dst string, r io.Reader, fi *os.FileInfo) error {
 	dst = filepath.Join(c.Chroot, dst)
 	log.Printf("Uploading to chroot dir: %s", dst)
-	tf, err := tmp.File("packer-amazon-chroot")
+	tf, err := ioutil.TempFile("", "packer-amazon-chroot")
 	if err != nil {
 		return fmt.Errorf("Error preparing shell script: %s", err)
 	}

builder/amazon/chroot/run_local_commands.go

@@ -1,7 +1,6 @@
 package chroot
 
 import (
-	"context"
 	"fmt"
 
 	sl "github.com/hashicorp/packer/common/shell-local"
@@ -9,10 +8,9 @@ import (
 	"github.com/hashicorp/packer/template/interpolate"
 )
 
-func RunLocalCommands(commands []string, wrappedCommand CommandWrapper, ictx interpolate.Context, ui packer.Ui) error {
-	ctx := context.TODO()
+func RunLocalCommands(commands []string, wrappedCommand CommandWrapper, ctx interpolate.Context, ui packer.Ui) error {
 	for _, rawCmd := range commands {
-		intCmd, err := interpolate.Render(rawCmd, &ictx)
+		intCmd, err := interpolate.Render(rawCmd, &ctx)
 		if err != nil {
 			return fmt.Errorf("Error interpolating: %s", err)
 		}
@@ -27,13 +25,13 @@ func RunLocalCommands(commands []string, wrappedCommand CommandWrapper, ictx int
 			ExecuteCommand: []string{"sh", "-c", command},
 		}
 		cmd := &packer.RemoteCmd{Command: command}
-		if err := cmd.RunWithUi(ctx, comm, ui); err != nil {
+		if err := cmd.StartWithUi(comm, ui); err != nil {
 			return fmt.Errorf("Error executing command: %s", err)
 		}
-		if cmd.ExitStatus() != 0 {
+		if cmd.ExitStatus != 0 {
 			return fmt.Errorf(
 				"Received non-zero exit code %d from command: %s",
-				cmd.ExitStatus(),
+				cmd.ExitStatus,
 				command)
 		}
 	}

builder/amazon/chroot/step_check_root_device.go

@@ -12,7 +12,7 @@ import (
 // StepCheckRootDevice makes sure the root device on the AMI is EBS-backed.
 type StepCheckRootDevice struct{}
 
-func (s *StepCheckRootDevice) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCheckRootDevice) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	image := state.Get("source_image").(*ec2.Image)
 	ui := state.Get("ui").(packer.Ui)
 

builder/amazon/chroot/step_chroot_provision.go

@@ -12,7 +12,7 @@ import (
 type StepChrootProvision struct {
 }
 
-func (s *StepChrootProvision) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepChrootProvision) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	hook := state.Get("hook").(packer.Hook)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)
@@ -26,7 +26,7 @@ func (s *StepChrootProvision) Run(ctx context.Context, state multistep.StateBag)
 
 	// Provision
 	log.Println("Running the provision hook")
-	if err := hook.Run(ctx, packer.HookProvision, ui, comm, nil); err != nil {
+	if err := hook.Run(packer.HookProvision, ui, comm, nil); err != nil {
 		state.Put("error", err)
 		return multistep.ActionHalt
 	}

builder/amazon/chroot/step_copy_files.go

@@ -20,7 +20,7 @@ type StepCopyFiles struct {
 	files []string
 }
 
-func (s *StepCopyFiles) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCopyFiles) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)

builder/amazon/chroot/step_create_volume.go

@@ -2,7 +2,6 @@ package chroot
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"log"
 
@@ -22,7 +21,6 @@ import (
 type StepCreateVolume struct {
 	volumeId       string
 	RootVolumeSize int64
-	RootVolumeType string
 	RootVolumeTags awscommon.TagMap
 	Ctx            interpolate.Context
 }
@@ -55,21 +53,11 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
 
 	var createVolume *ec2.CreateVolumeInput
 	if config.FromScratch {
-		rootVolumeType := ec2.VolumeTypeGp2
-		if s.RootVolumeType == "io1" {
-			err := errors.New("Cannot use io1 volume when building from scratch")
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		} else if s.RootVolumeType != "" {
-			rootVolumeType = s.RootVolumeType
-		}
 		createVolume = &ec2.CreateVolumeInput{
 			AvailabilityZone: instance.Placement.AvailabilityZone,
 			Size:             aws.Int64(s.RootVolumeSize),
-			VolumeType:       aws.String(rootVolumeType),
+			VolumeType:       aws.String(ec2.VolumeTypeGp2),
 		}
-
 	} else {
 		// Determine the root device snapshot
 		image := state.Get("source_image").(*ec2.Image)
@@ -82,13 +70,26 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
 			}
 		}
 
-		ui.Say("Creating the root volume...")
-		createVolume, err = s.buildCreateVolumeInput(*instance.Placement.AvailabilityZone, rootDevice)
-		if err != nil {
+		if rootDevice == nil {
+			err := fmt.Errorf("Couldn't find root device!")
 			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
+
+		ui.Say("Creating the root volume...")
+		vs := *rootDevice.Ebs.VolumeSize
+		if s.RootVolumeSize > *rootDevice.Ebs.VolumeSize {
+			vs = s.RootVolumeSize
+		}
+
+		createVolume = &ec2.CreateVolumeInput{
+			AvailabilityZone: instance.Placement.AvailabilityZone,
+			Size:             aws.Int64(vs),
+			SnapshotId:       rootDevice.Ebs.SnapshotId,
+			VolumeType:       rootDevice.Ebs.VolumeType,
+			Iops:             rootDevice.Ebs.Iops,
+		}
 	}
 
 	if len(tagSpecs) > 0 {
@@ -136,33 +137,3 @@ func (s *StepCreateVolume) Cleanup(state multistep.StateBag) {
 		ui.Error(fmt.Sprintf("Error deleting EBS volume: %s", err))
 	}
 }
-
-func (s *StepCreateVolume) buildCreateVolumeInput(az string, rootDevice *ec2.BlockDeviceMapping) (*ec2.CreateVolumeInput, error) {
-	if rootDevice == nil {
-		return nil, fmt.Errorf("Couldn't find root device!")
-	}
-	createVolumeInput := &ec2.CreateVolumeInput{
-		AvailabilityZone: aws.String(az),
-		Size:             rootDevice.Ebs.VolumeSize,
-		SnapshotId:       rootDevice.Ebs.SnapshotId,
-		VolumeType:       rootDevice.Ebs.VolumeType,
-		Iops:             rootDevice.Ebs.Iops,
-	}
-	if s.RootVolumeSize > *rootDevice.Ebs.VolumeSize {
-		createVolumeInput.Size = aws.Int64(s.RootVolumeSize)
-	}
-
-	if s.RootVolumeType == "" || s.RootVolumeType == *rootDevice.Ebs.VolumeType {
-		return createVolumeInput, nil
-	}
-
-	if s.RootVolumeType == "io1" {
-		return nil, fmt.Errorf("Root volume type cannot be io1, because existing root volume type was %s", *rootDevice.Ebs.VolumeType)
-	}
-
-	createVolumeInput.VolumeType = aws.String(s.RootVolumeType)
-	// non io1 cannot set iops
-	createVolumeInput.Iops = nil
-
-	return createVolumeInput, nil
-}

builder/amazon/chroot/step_create_volume_test.go

@@ -1,74 +0,0 @@
-package chroot
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/stretchr/testify/assert"
-)
-
-func buildTestRootDevice() *ec2.BlockDeviceMapping {
-	return &ec2.BlockDeviceMapping{
-		Ebs: &ec2.EbsBlockDevice{
-			VolumeSize: aws.Int64(10),
-			SnapshotId: aws.String("snap-1234"),
-			VolumeType: aws.String("gp2"),
-		},
-	}
-}
-
-func TestCreateVolume_Default(t *testing.T) {
-	stepCreateVolume := new(StepCreateVolume)
-	_, err := stepCreateVolume.buildCreateVolumeInput("test-az", buildTestRootDevice())
-	assert.NoError(t, err)
-}
-
-func TestCreateVolume_Shrink(t *testing.T) {
-	stepCreateVolume := StepCreateVolume{RootVolumeSize: 1}
-	testRootDevice := buildTestRootDevice()
-	ret, err := stepCreateVolume.buildCreateVolumeInput("test-az", testRootDevice)
-	assert.NoError(t, err)
-	// Ensure that the new value is equal to the size of the old root device
-	assert.Equal(t, *ret.Size, *testRootDevice.Ebs.VolumeSize)
-}
-
-func TestCreateVolume_Expand(t *testing.T) {
-	stepCreateVolume := StepCreateVolume{RootVolumeSize: 25}
-	testRootDevice := buildTestRootDevice()
-	ret, err := stepCreateVolume.buildCreateVolumeInput("test-az", testRootDevice)
-	assert.NoError(t, err)
-	// Ensure that the new value is equal to the size of the value passed in
-	assert.Equal(t, *ret.Size, stepCreateVolume.RootVolumeSize)
-}
-
-func TestCreateVolume_io1_to_io1(t *testing.T) {
-	stepCreateVolume := StepCreateVolume{RootVolumeType: "io1"}
-	testRootDevice := buildTestRootDevice()
-	testRootDevice.Ebs.VolumeType = aws.String("io1")
-	testRootDevice.Ebs.Iops = aws.Int64(1000)
-	ret, err := stepCreateVolume.buildCreateVolumeInput("test-az", testRootDevice)
-	assert.NoError(t, err)
-	assert.Equal(t, *ret.VolumeType, stepCreateVolume.RootVolumeType)
-	assert.Equal(t, *ret.Iops, *testRootDevice.Ebs.Iops)
-}
-
-func TestCreateVolume_io1_to_gp2(t *testing.T) {
-	stepCreateVolume := StepCreateVolume{RootVolumeType: "gp2"}
-	testRootDevice := buildTestRootDevice()
-	testRootDevice.Ebs.VolumeType = aws.String("io1")
-	testRootDevice.Ebs.Iops = aws.Int64(1000)
-
-	ret, err := stepCreateVolume.buildCreateVolumeInput("test-az", testRootDevice)
-	assert.NoError(t, err)
-	assert.Equal(t, *ret.VolumeType, stepCreateVolume.RootVolumeType)
-	assert.Nil(t, ret.Iops)
-}
-
-func TestCreateVolume_gp2_to_io1(t *testing.T) {
-	stepCreateVolume := StepCreateVolume{RootVolumeType: "io1"}
-	testRootDevice := buildTestRootDevice()
-
-	_, err := stepCreateVolume.buildCreateVolumeInput("test-az", testRootDevice)
-	assert.Error(t, err)
-}

builder/amazon/chroot/step_early_cleanup.go

@@ -13,7 +13,7 @@ import (
 // prepare for snapshotting and creating an AMI.
 type StepEarlyCleanup struct{}
 
-func (s *StepEarlyCleanup) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepEarlyCleanup) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 	cleanupKeys := []string{
 		"copy_files_cleanup",

builder/amazon/chroot/step_early_unflock.go

@@ -12,7 +12,7 @@ import (
 // StepEarlyUnflock unlocks the flock.
 type StepEarlyUnflock struct{}
 
-func (s *StepEarlyUnflock) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepEarlyUnflock) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	cleanup := state.Get("flock_cleanup").(Cleanup)
 	ui := state.Get("ui").(packer.Ui)
 

builder/amazon/chroot/step_flock.go

@@ -19,7 +19,7 @@ type StepFlock struct {
 	fh *os.File
 }
 
-func (s *StepFlock) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepFlock) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	lockfile := "/var/lock/packer-chroot/lock"

builder/amazon/chroot/step_instance_info.go

@@ -15,7 +15,7 @@ import (
 // StepInstanceInfo verifies that this builder is running on an EC2 instance.
 type StepInstanceInfo struct{}
 
-func (s *StepInstanceInfo) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepInstanceInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	session := state.Get("awsSession").(*session.Session)
 	ui := state.Get("ui").(packer.Ui)

builder/amazon/chroot/step_mount_device.go

@@ -31,7 +31,7 @@ type StepMountDevice struct {
 	mountPath string
 }
 
-func (s *StepMountDevice) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepMountDevice) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
 	device := state.Get("device").(string)
@@ -42,7 +42,7 @@ func (s *StepMountDevice) Run(ctx context.Context, state multistep.StateBag) mul
 	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 
 	var virtualizationType string
-	if config.FromScratch || config.AMIVirtType != "" {
+	if config.FromScratch {
 		virtualizationType = config.AMIVirtType
 	} else {
 		image := state.Get("source_image").(*ec2.Image)
@@ -50,10 +50,10 @@ func (s *StepMountDevice) Run(ctx context.Context, state multistep.StateBag) mul
 		log.Printf("Source image virtualization type is: %s", virtualizationType)
 	}
 
-	ictx := config.ctx
+	ctx := config.ctx
 
-	ictx.Data = &mountPathData{Device: filepath.Base(device)}
-	mountPath, err := interpolate.Render(config.MountPath, &ictx)
+	ctx.Data = &mountPathData{Device: filepath.Base(device)}
+	mountPath, err := interpolate.Render(config.MountPath, &ctx)
 
 	if err != nil {
 		err := fmt.Errorf("Error preparing mount directory: %s", err)

builder/amazon/chroot/step_mount_extra.go

@@ -20,7 +20,7 @@ type StepMountExtra struct {
 	mounts []string
 }
 
-func (s *StepMountExtra) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepMountExtra) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)

builder/amazon/chroot/step_post_mount_commands.go

@@ -18,7 +18,7 @@ type StepPostMountCommands struct {
 	Commands []string
 }
 
-func (s *StepPostMountCommands) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepPostMountCommands) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	device := state.Get("device").(string)
 	mountPath := state.Get("mount_path").(string)
@@ -29,14 +29,14 @@ func (s *StepPostMountCommands) Run(ctx context.Context, state multistep.StateBa
 		return multistep.ActionContinue
 	}
 
-	ictx := config.ctx
-	ictx.Data = &postMountCommandsData{
+	ctx := config.ctx
+	ctx.Data = &postMountCommandsData{
 		Device:    device,
 		MountPath: mountPath,
 	}
 
 	ui.Say("Running post-mount commands...")
-	if err := RunLocalCommands(s.Commands, wrappedCommand, ictx, ui); err != nil {
+	if err := RunLocalCommands(s.Commands, wrappedCommand, ctx, ui); err != nil {
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt

builder/amazon/chroot/step_pre_mount_commands.go

@@ -16,7 +16,7 @@ type StepPreMountCommands struct {
 	Commands []string
 }
 
-func (s *StepPreMountCommands) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepPreMountCommands) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	device := state.Get("device").(string)
 	ui := state.Get("ui").(packer.Ui)
@@ -26,11 +26,11 @@ func (s *StepPreMountCommands) Run(ctx context.Context, state multistep.StateBag
 		return multistep.ActionContinue
 	}
 
-	ictx := config.ctx
-	ictx.Data = &preMountCommandsData{Device: device}
+	ctx := config.ctx
+	ctx.Data = &preMountCommandsData{Device: device}
 
 	ui.Say("Running device setup commands...")
-	if err := RunLocalCommands(s.Commands, wrappedCommand, ictx, ui); err != nil {
+	if err := RunLocalCommands(s.Commands, wrappedCommand, ctx, ui); err != nil {
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt

builder/amazon/chroot/step_prepare_device.go

@@ -14,7 +14,7 @@ import (
 type StepPrepareDevice struct {
 }
 
-func (s *StepPrepareDevice) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepPrepareDevice) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
 

builder/amazon/chroot/step_register_ami.go

@@ -14,26 +14,68 @@ import (
 // StepRegisterAMI creates the AMI.
 type StepRegisterAMI struct {
 	RootVolumeSize           int64
-	EnableAMIENASupport      *bool
+	EnableAMIENASupport      bool
 	EnableAMISriovNetSupport bool
 }
 
 func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ec2conn := state.Get("ec2").(*ec2.EC2)
-	snapshotID := state.Get("snapshot_id").(string)
+	snapshotId := state.Get("snapshot_id").(string)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Registering the AMI...")
 
-	var registerOpts *ec2.RegisterImageInput
+	var (
+		registerOpts   *ec2.RegisterImageInput
+		mappings       []*ec2.BlockDeviceMapping
+		image          *ec2.Image
+		rootDeviceName string
+	)
 
-	// Source Image is only required to be passed if the image is not from scratch
 	if config.FromScratch {
-		registerOpts = buildBaseRegisterOpts(config, nil, s.RootVolumeSize, snapshotID)
+		mappings = config.AMIBlockDevices.BuildAMIDevices()
+		rootDeviceName = config.RootDeviceName
 	} else {
-		image := state.Get("source_image").(*ec2.Image)
-		registerOpts = buildBaseRegisterOpts(config, image, s.RootVolumeSize, snapshotID)
+		image = state.Get("source_image").(*ec2.Image)
+		mappings = image.BlockDeviceMappings
+		rootDeviceName = *image.RootDeviceName
+	}
+
+	newMappings := make([]*ec2.BlockDeviceMapping, len(mappings))
+	for i, device := range mappings {
+		newDevice := device
+		if *newDevice.DeviceName == rootDeviceName {
+			if newDevice.Ebs != nil {
+				newDevice.Ebs.SnapshotId = aws.String(snapshotId)
+			} else {
+				newDevice.Ebs = &ec2.EbsBlockDevice{SnapshotId: aws.String(snapshotId)}
+			}
+
+			if config.FromScratch || s.RootVolumeSize > *newDevice.Ebs.VolumeSize {
+				newDevice.Ebs.VolumeSize = aws.Int64(s.RootVolumeSize)
+			}
+		}
+
+		// assume working from a snapshot, so we unset the Encrypted field if set,
+		// otherwise AWS API will return InvalidParameter
+		if newDevice.Ebs != nil && newDevice.Ebs.Encrypted != nil {
+			newDevice.Ebs.Encrypted = nil
+		}
+
+		newMappings[i] = newDevice
+	}
+
+	if config.FromScratch {
+		registerOpts = &ec2.RegisterImageInput{
+			Name:                &config.AMIName,
+			Architecture:        aws.String(ec2.ArchitectureValuesX8664),
+			RootDeviceName:      aws.String(rootDeviceName),
+			VirtualizationType:  aws.String(config.AMIVirtType),
+			BlockDeviceMappings: newMappings,
+		}
+	} else {
+		registerOpts = buildRegisterOpts(config, image, newMappings)
 	}
 
 	if s.EnableAMISriovNetSupport {
@@ -41,7 +83,7 @@ func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) mul
 		// As of February 2017, this applies to C3, C4, D2, I2, R3, and M4 (excluding m4.16xlarge)
 		registerOpts.SriovNetSupport = aws.String("simple")
 	}
-	if s.EnableAMIENASupport != nil && *s.EnableAMIENASupport {
+	if s.EnableAMIENASupport {
 		// Set EnaSupport to true
 		// As of February 2017, this applies to C5, I3, P2, R4, X1, and m4.16xlarge
 		registerOpts.EnaSupport = aws.Bool(true)
@@ -73,65 +115,11 @@ func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) mul
 
 func (s *StepRegisterAMI) Cleanup(state multistep.StateBag) {}
 
-// Builds the base register opts with architecture, name, root block device, mappings, virtualizationtype
-func buildBaseRegisterOpts(config *Config, sourceImage *ec2.Image, rootVolumeSize int64, snapshotID string) *ec2.RegisterImageInput {
-	var (
-		mappings       []*ec2.BlockDeviceMapping
-		rootDeviceName string
-	)
-
-	generatingNewBlockDeviceMappings := config.FromScratch || len(config.AMIMappings) > 0
-	if generatingNewBlockDeviceMappings {
-		mappings = config.AMIBlockDevices.BuildAMIDevices()
-		rootDeviceName = config.RootDeviceName
-	} else {
-		// If config.FromScratch is false, source image must be set
-		mappings = sourceImage.BlockDeviceMappings
-		rootDeviceName = *sourceImage.RootDeviceName
-	}
-
-	newMappings := make([]*ec2.BlockDeviceMapping, len(mappings))
-	for i, device := range mappings {
-		newDevice := device
-		if *newDevice.DeviceName == rootDeviceName {
-			if newDevice.Ebs != nil {
-				newDevice.Ebs.SnapshotId = aws.String(snapshotID)
-			} else {
-				newDevice.Ebs = &ec2.EbsBlockDevice{SnapshotId: aws.String(snapshotID)}
-			}
-
-			if generatingNewBlockDeviceMappings || rootVolumeSize > *newDevice.Ebs.VolumeSize {
-				newDevice.Ebs.VolumeSize = aws.Int64(rootVolumeSize)
-			}
-		}
-
-		// assume working from a snapshot, so we unset the Encrypted field if set,
-		// otherwise AWS API will return InvalidParameter
-		if newDevice.Ebs != nil && newDevice.Ebs.Encrypted != nil {
-			newDevice.Ebs.Encrypted = nil
-		}
-
-		newMappings[i] = newDevice
-	}
-
-	if config.FromScratch {
-		return &ec2.RegisterImageInput{
-			Name:                &config.AMIName,
-			Architecture:        aws.String(ec2.ArchitectureValuesX8664),
-			RootDeviceName:      aws.String(rootDeviceName),
-			VirtualizationType:  aws.String(config.AMIVirtType),
-			BlockDeviceMappings: newMappings,
-		}
-	}
-
-	return buildRegisterOptsFromExistingImage(config, sourceImage, newMappings, rootDeviceName)
-}
-
-func buildRegisterOptsFromExistingImage(config *Config, image *ec2.Image, mappings []*ec2.BlockDeviceMapping, rootDeviceName string) *ec2.RegisterImageInput {
+func buildRegisterOpts(config *Config, image *ec2.Image, mappings []*ec2.BlockDeviceMapping) *ec2.RegisterImageInput {
 	registerOpts := &ec2.RegisterImageInput{
 		Name:                &config.AMIName,
 		Architecture:        image.Architecture,
-		RootDeviceName:      &rootDeviceName,
+		RootDeviceName:      image.RootDeviceName,
 		BlockDeviceMappings: mappings,
 		VirtualizationType:  image.VirtualizationType,
 	}

builder/amazon/chroot/step_register_ami_test.go

@@ -3,9 +3,6 @@ package chroot
 import (
 	"testing"
 
-	amazon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/common"
-
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 )
@@ -24,13 +21,12 @@ func TestStepRegisterAmi_buildRegisterOpts_pv(t *testing.T) {
 	config.AMIName = "test_ami_name"
 	config.AMIDescription = "test_ami_description"
 	config.AMIVirtType = "paravirtual"
-	rootDeviceName := "foo"
 
 	image := testImage()
 
 	blockDevices := []*ec2.BlockDeviceMapping{}
 
-	opts := buildRegisterOptsFromExistingImage(&config, &image, blockDevices, rootDeviceName)
+	opts := buildRegisterOpts(&config, &image, blockDevices)
 
 	expected := config.AMIVirtType
 	if *opts.VirtualizationType != expected {
@@ -47,10 +43,6 @@ func TestStepRegisterAmi_buildRegisterOpts_pv(t *testing.T) {
 		t.Fatalf("Unexpected KernelId value: expected %s got %s\n", expected, *opts.KernelId)
 	}
 
-	expected = rootDeviceName
-	if *opts.RootDeviceName != expected {
-		t.Fatalf("Unexpected RootDeviceName value: expected %s got %s\n", expected, *opts.RootDeviceName)
-	}
 }
 
 func TestStepRegisterAmi_buildRegisterOpts_hvm(t *testing.T) {
@@ -58,13 +50,12 @@ func TestStepRegisterAmi_buildRegisterOpts_hvm(t *testing.T) {
 	config.AMIName = "test_ami_name"
 	config.AMIDescription = "test_ami_description"
 	config.AMIVirtType = "hvm"
-	rootDeviceName := "foo"
 
 	image := testImage()
 
 	blockDevices := []*ec2.BlockDeviceMapping{}
 
-	opts := buildRegisterOptsFromExistingImage(&config, &image, blockDevices, rootDeviceName)
+	opts := buildRegisterOpts(&config, &image, blockDevices)
 
 	expected := config.AMIVirtType
 	if *opts.VirtualizationType != expected {
@@ -79,142 +70,4 @@ func TestStepRegisterAmi_buildRegisterOpts_hvm(t *testing.T) {
 	if opts.KernelId != nil {
 		t.Fatalf("Unexpected KernelId value: expected nil got %s\n", *opts.KernelId)
 	}
-
-	expected = rootDeviceName
-	if *opts.RootDeviceName != expected {
-		t.Fatalf("Unexpected RootDeviceName value: expected %s got %s\n", expected, *opts.RootDeviceName)
-	}
-}
-
-func TestStepRegisterAmi_buildRegisterOptsFromScratch(t *testing.T) {
-	rootDeviceName := "/dev/sda"
-	snapshotID := "foo"
-	config := Config{
-		FromScratch:  true,
-		PackerConfig: common.PackerConfig{},
-		AMIBlockDevices: amazon.AMIBlockDevices{
-			AMIMappings: []amazon.BlockDevice{
-				{
-					DeviceName: rootDeviceName,
-				},
-			},
-		},
-		RootDeviceName: rootDeviceName,
-	}
-	registerOpts := buildBaseRegisterOpts(&config, nil, 10, snapshotID)
-
-	if len(registerOpts.BlockDeviceMappings) != 1 {
-		t.Fatal("Expected block device mapping of length 1")
-	}
-
-	if *registerOpts.BlockDeviceMappings[0].Ebs.SnapshotId != snapshotID {
-		t.Fatalf("Snapshot ID of root disk not set to snapshot id %s", rootDeviceName)
-	}
-}
-
-func TestStepRegisterAmi_buildRegisterOptFromExistingImage(t *testing.T) {
-	rootDeviceName := "/dev/sda"
-	snapshotID := "foo"
-
-	config := Config{
-		FromScratch:  false,
-		PackerConfig: common.PackerConfig{},
-	}
-	sourceImage := ec2.Image{
-		RootDeviceName: &rootDeviceName,
-		BlockDeviceMappings: []*ec2.BlockDeviceMapping{
-			{
-				DeviceName: &rootDeviceName,
-				Ebs: &ec2.EbsBlockDevice{
-					VolumeSize: aws.Int64(10),
-				},
-			},
-			// Throw in an ephemeral device, it seems like all devices in the return struct in a source AMI have
-			// a size, even if it's for ephemeral
-			{
-				DeviceName:  aws.String("/dev/sdb"),
-				VirtualName: aws.String("ephemeral0"),
-				Ebs: &ec2.EbsBlockDevice{
-					VolumeSize: aws.Int64(0),
-				},
-			},
-		},
-	}
-	registerOpts := buildBaseRegisterOpts(&config, &sourceImage, 15, snapshotID)
-
-	if len(registerOpts.BlockDeviceMappings) != 2 {
-		t.Fatal("Expected block device mapping of length 2")
-	}
-
-	for _, dev := range registerOpts.BlockDeviceMappings {
-		if dev.Ebs.SnapshotId != nil && *dev.Ebs.SnapshotId == snapshotID {
-			// Even though root volume size is in config, it isn't used, instead we use the root volume size
-			// that's derived when we build the step
-			if *dev.Ebs.VolumeSize != 15 {
-				t.Fatalf("Root volume size not 15 GB instead %d", *dev.Ebs.VolumeSize)
-			}
-			return
-		}
-	}
-	t.Fatalf("Could not find device with snapshot ID %s", snapshotID)
-}
-
-func TestStepRegisterAmi_buildRegisterOptFromExistingImageWithBlockDeviceMappings(t *testing.T) {
-	const (
-		rootDeviceName = "/dev/xvda"
-		oldRootDevice  = "/dev/sda1"
-	)
-	snapshotId := "foo"
-
-	config := Config{
-		FromScratch:  false,
-		PackerConfig: common.PackerConfig{},
-		AMIBlockDevices: amazon.AMIBlockDevices{
-			AMIMappings: []amazon.BlockDevice{
-				{
-					DeviceName: rootDeviceName,
-				},
-			},
-		},
-		RootDeviceName: rootDeviceName,
-	}
-
-	// Intentionally try to use a different root devicename
-	sourceImage := ec2.Image{
-		RootDeviceName: aws.String(oldRootDevice),
-		BlockDeviceMappings: []*ec2.BlockDeviceMapping{
-			{
-				DeviceName: aws.String(oldRootDevice),
-				Ebs: &ec2.EbsBlockDevice{
-					VolumeSize: aws.Int64(10),
-				},
-			},
-			// Throw in an ephemeral device, it seems like all devices in the return struct in a source AMI have
-			// a size, even if it's for ephemeral
-			{
-				DeviceName:  aws.String("/dev/sdb"),
-				VirtualName: aws.String("ephemeral0"),
-				Ebs: &ec2.EbsBlockDevice{
-					VolumeSize: aws.Int64(0),
-				},
-			},
-		},
-	}
-	registerOpts := buildBaseRegisterOpts(&config, &sourceImage, 15, snapshotId)
-
-	if len(registerOpts.BlockDeviceMappings) != 1 {
-		t.Fatal("Expected block device mapping of length 1")
-	}
-
-	if *registerOpts.BlockDeviceMappings[0].Ebs.SnapshotId != snapshotId {
-		t.Fatalf("Snapshot ID of root disk set to '%s' expected '%s'", *registerOpts.BlockDeviceMappings[0].Ebs.SnapshotId, rootDeviceName)
-	}
-
-	if *registerOpts.RootDeviceName != rootDeviceName {
-		t.Fatalf("Root device set to '%s' expected %s", *registerOpts.RootDeviceName, rootDeviceName)
-	}
-
-	if *registerOpts.BlockDeviceMappings[0].Ebs.VolumeSize != 15 {
-		t.Fatalf("Size of root disk not set to 15 GB, instead %d", *registerOpts.BlockDeviceMappings[0].Ebs.VolumeSize)
-	}
 }

builder/amazon/common/access_config.go

@@ -1,52 +1,32 @@
 package common
 
 import (
-	"crypto/tls"
 	"fmt"
 	"log"
-	"net/http"
 	"strings"
+	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/aws/ec2metadata"
 	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	cleanhttp "github.com/hashicorp/go-cleanhttp"
+	"github.com/hashicorp/go-cleanhttp"
 	"github.com/hashicorp/packer/template/interpolate"
-	vaultapi "github.com/hashicorp/vault/api"
 )
 
-type VaultAWSEngineOptions struct {
-	Name       string `mapstructure:"name"`
-	RoleARN    string `mapstructure:"role_arn"`
-	TTL        string `mapstructure:"ttl"`
-	EngineName string `mapstructure:"engine_name"`
-}
-
-func (v *VaultAWSEngineOptions) Empty() bool {
-	return len(v.Name) == 0 && len(v.RoleARN) == 0 &&
-		len(v.EngineName) == 0 && len(v.TTL) == 0
-}
-
 // AccessConfig is for common configuration related to AWS access
 type AccessConfig struct {
-	AccessKey             string `mapstructure:"access_key"`
-	CustomEndpointEc2     string `mapstructure:"custom_endpoint_ec2"`
-	DecodeAuthZMessages   bool   `mapstructure:"decode_authorization_messages"`
-	InsecureSkipTLSVerify bool   `mapstructure:"insecure_skip_tls_verify"`
-	MFACode               string `mapstructure:"mfa_code"`
-	ProfileName           string `mapstructure:"profile"`
-	RawRegion             string `mapstructure:"region"`
-	SecretKey             string `mapstructure:"secret_key"`
-	SkipValidation        bool   `mapstructure:"skip_region_validation"`
-	SkipMetadataApiCheck  bool   `mapstructure:"skip_metadata_api_check"`
-	Token                 string `mapstructure:"token"`
-	session               *session.Session
-	VaultAWSEngine        VaultAWSEngineOptions `mapstructure:"vault_aws_engine"`
-
-	getEC2Connection func() ec2iface.EC2API
+	AccessKey            string `mapstructure:"access_key"`
+	CustomEndpointEc2    string `mapstructure:"custom_endpoint_ec2"`
+	MFACode              string `mapstructure:"mfa_code"`
+	ProfileName          string `mapstructure:"profile"`
+	RawRegion            string `mapstructure:"region"`
+	SecretKey            string `mapstructure:"secret_key"`
+	SkipValidation       bool   `mapstructure:"skip_region_validation"`
+	SkipMetadataApiCheck bool   `mapstructure:"skip_metadata_api_check"`
+	Token                string `mapstructure:"token"`
+	session              *session.Session
 }
 
 // Config returns a valid aws.Config object for access to AWS services, or
@@ -65,21 +45,14 @@ func (c *AccessConfig) Session() (*session.Session, error) {
 
 	if c.RawRegion != "" {
 		config = config.WithRegion(c.RawRegion)
+	} else if region := c.metadataRegion(); region != "" {
+		config = config.WithRegion(region)
 	}
 
 	if c.CustomEndpointEc2 != "" {
 		config = config.WithEndpoint(c.CustomEndpointEc2)
 	}
 
-	config = config.WithHTTPClient(cleanhttp.DefaultClient())
-	transport := config.HTTPClient.Transport.(*http.Transport)
-	if c.InsecureSkipTLSVerify {
-		transport.TLSClientConfig = &tls.Config{
-			InsecureSkipVerify: true,
-		}
-	}
-	transport.Proxy = http.ProxyFromEnvironment
-
 	opts := session.Options{
 		SharedConfigState: session.SharedConfigEnable,
 		Config:            *config,
@@ -95,30 +68,26 @@ func (c *AccessConfig) Session() (*session.Session, error) {
 		}
 	}
 
-	sess, err := session.NewSessionWithOptions(opts)
-	if err != nil {
+	if sess, err := session.NewSessionWithOptions(opts); err != nil {
 		return nil, err
-	}
-	log.Printf("Found region %s", *sess.Config.Region)
-	c.session = sess
+	} else if *sess.Config.Region == "" {
+		return nil, fmt.Errorf("Could not find AWS region, make sure it's set.")
+	} else {
+		log.Printf("Found region %s", *sess.Config.Region)
+		c.session = sess
 
-	cp, err := c.session.Config.Credentials.Get()
-	if err != nil {
-		if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NoCredentialProviders" {
-			return nil, fmt.Errorf("No valid credential sources found for AWS Builder. " +
-				"Please see https://www.packer.io/docs/builders/amazon.html#specifying-amazon-credentials " +
-				"for more information on providing credentials for the AWS Builder.")
-		} else {
-			return nil, fmt.Errorf("Error loading credentials for AWS Provider: %s", err)
+		cp, err := c.session.Config.Credentials.Get()
+		if err != nil {
+			if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NoCredentialProviders" {
+				return nil, fmt.Errorf("No valid credential sources found for AWS Builder. " +
+					"Please see https://www.packer.io/docs/builders/amazon.html#specifying-amazon-credentials " +
+					"for more information on providing credentials for the AWS Builder.")
+			} else {
+				return nil, fmt.Errorf("Error loading credentials for AWS Provider: %s", err)
+			}
 		}
+		log.Printf("[INFO] AWS Auth provider used: %q", cp.ProviderName)
 	}
-	log.Printf("[INFO] AWS Auth provider used: %q", cp.ProviderName)
-
-	if c.DecodeAuthZMessages {
-		DecodeAuthZMessages(c.session)
-	}
-	LogEnvOverrideWarnings()
-
 	return c.session, nil
 }
 
@@ -137,37 +106,23 @@ func (c *AccessConfig) IsChinaCloud() bool {
 	return strings.HasPrefix(c.SessionRegion(), "cn-")
 }
 
-func (c *AccessConfig) GetCredsFromVault() error {
-	// const EnvVaultAddress = "VAULT_ADDR"
-	// const EnvVaultToken = "VAULT_TOKEN"
-	vaultConfig := vaultapi.DefaultConfig()
-	cli, err := vaultapi.NewClient(vaultConfig)
-	if err != nil {
-		return fmt.Errorf("Error getting Vault client: %s", err)
-	}
-	if c.VaultAWSEngine.EngineName == "" {
-		c.VaultAWSEngine.EngineName = "aws"
-	}
-	path := fmt.Sprintf("/%s/creds/%s", c.VaultAWSEngine.EngineName,
-		c.VaultAWSEngine.Name)
-	secret, err := cli.Logical().Read(path)
-	if err != nil {
-		return fmt.Errorf("Error reading vault secret: %s", err)
-	}
-	if secret == nil {
-		return fmt.Errorf("Vault Secret does not exist at the given path.")
-	}
+// metadataRegion returns the region from the metadata service
+func (c *AccessConfig) metadataRegion() string {
 
-	c.AccessKey = secret.Data["access_key"].(string)
-	c.SecretKey = secret.Data["secret_key"].(string)
-	token := secret.Data["security_token"]
-	if token != nil {
-		c.Token = token.(string)
-	} else {
-		c.Token = ""
-	}
+	client := cleanhttp.DefaultClient()
 
-	return nil
+	// Keep the default timeout (100ms) low as we don't want to wait in non-EC2 environments
+	client.Timeout = 100 * time.Millisecond
+	ec2meta := ec2metadata.New(session.New(), &aws.Config{
+		HTTPClient: client,
+	})
+	region, err := ec2meta.Region()
+	if err != nil {
+		log.Println("Error getting region from metadata service, "+
+			"probably because we're not running on AWS.", err)
+		return ""
+	}
+	return region
 }
 
 func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error {
@@ -176,41 +131,18 @@ func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error {
 	if c.SkipMetadataApiCheck {
 		log.Println("(WARN) skip_metadata_api_check ignored.")
 	}
-
-	// Make sure it's obvious from the config how we're getting credentials:
-	// Vault, Packer config, or environemnt.
-	if !c.VaultAWSEngine.Empty() {
-		if len(c.AccessKey) > 0 {
-			errs = append(errs,
-				fmt.Errorf("If you have set vault_aws_engine, you must not set"+
-					" the access_key or secret_key."))
-		}
-		// Go ahead and grab those credentials from Vault now, so we can set
-		// the keys and token now.
-		err := c.GetCredsFromVault()
-		if err != nil {
-			errs = append(errs, err)
-		}
-	}
-
+	// Either both access and secret key must be set or neither of them should
+	// be.
 	if (len(c.AccessKey) > 0) != (len(c.SecretKey) > 0) {
 		errs = append(errs,
 			fmt.Errorf("`access_key` and `secret_key` must both be either set or not set."))
 	}
 
+	if c.RawRegion != "" && !c.SkipValidation {
+		if valid := ValidateRegion(c.RawRegion); !valid {
+			errs = append(errs, fmt.Errorf("Unknown region: %s", c.RawRegion))
+		}
+	}
+
 	return errs
 }
-
-func (c *AccessConfig) NewEC2Connection() (ec2iface.EC2API, error) {
-	if c.getEC2Connection != nil {
-		return c.getEC2Connection(), nil
-	}
-	sess, err := c.Session()
-	if err != nil {
-		return nil, err
-	}
-
-	ec2conn := ec2.New(sess)
-
-	return ec2conn, nil
-}

builder/amazon/common/access_config_test.go

@@ -5,51 +5,41 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 )
 
 func testAccessConfig() *AccessConfig {
-	return &AccessConfig{
-		getEC2Connection: func() ec2iface.EC2API {
-			return &mockEC2Client{}
-		},
-	}
+	return &AccessConfig{}
 }
 
 func TestAccessConfigPrepare_Region(t *testing.T) {
 	c := testAccessConfig()
-
-	c.RawRegion = "us-east-12"
-	err := c.ValidateRegion(c.RawRegion)
-	if err == nil {
-		t.Fatalf("should have region validation err: %s", c.RawRegion)
-	}
-
-	c.RawRegion = "us-east-1"
-	err = c.ValidateRegion(c.RawRegion)
-	if err != nil {
-		t.Fatalf("shouldn't have region validation err: %s", c.RawRegion)
-	}
-
-	c.RawRegion = "custom"
-	err = c.ValidateRegion(c.RawRegion)
-	if err == nil {
-		t.Fatalf("should have region validation err: %s", c.RawRegion)
-	}
-
-	c.RawRegion = "custom"
-	c.SkipValidation = true
-	// testing whole prepare func here; this is checking that validation is
-	// skipped, so we don't need a mock connection
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-
-	c.SkipValidation = false
 	c.RawRegion = ""
 	if err := c.Prepare(nil); err != nil {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
+
+	c.RawRegion = "us-east-12"
+	if err := c.Prepare(nil); err == nil {
+		t.Fatal("should have error")
+	}
+
+	c.RawRegion = "us-east-1"
+	if err := c.Prepare(nil); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
+	}
+
+	c.RawRegion = "custom"
+	if err := c.Prepare(nil); err == nil {
+		t.Fatalf("should have err")
+	}
+
+	c.RawRegion = "custom"
+	c.SkipValidation = true
+	if err := c.Prepare(nil); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
+	}
+	c.SkipValidation = false
+
 }
 
 func TestAccessConfigPrepare_RegionRestricted(t *testing.T) {

builder/amazon/common/ami_config.go

@@ -3,7 +3,6 @@ package common
 import (
 	"fmt"
 	"log"
-	"regexp"
 
 	"github.com/hashicorp/packer/template/interpolate"
 )
@@ -19,11 +18,11 @@ type AMIConfig struct {
 	AMIRegions              []string          `mapstructure:"ami_regions"`
 	AMISkipRegionValidation bool              `mapstructure:"skip_region_validation"`
 	AMITags                 TagMap            `mapstructure:"tags"`
-	AMIENASupport           *bool             `mapstructure:"ena_support"`
+	AMIENASupport           bool              `mapstructure:"ena_support"`
 	AMISriovNetSupport      bool              `mapstructure:"sriov_support"`
 	AMIForceDeregister      bool              `mapstructure:"force_deregister"`
 	AMIForceDeleteSnapshot  bool              `mapstructure:"force_delete_snapshot"`
-	AMIEncryptBootVolume    *bool             `mapstructure:"encrypt_boot"`
+	AMIEncryptBootVolume    bool              `mapstructure:"encrypt_boot"`
 	AMIKmsKeyId             string            `mapstructure:"kms_key_id"`
 	AMIRegionKMSKeyIDs      map[string]string `mapstructure:"region_kms_key_ids"`
 	SnapshotTags            TagMap            `mapstructure:"snapshot_tags"`
@@ -57,62 +56,6 @@ func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context
 		}
 	}
 
-	errs = append(errs, c.prepareRegions(accessConfig)...)
-
-	if len(c.AMIUsers) > 0 && c.AMIEncryptBootVolume != nil && *c.AMIEncryptBootVolume {
-		errs = append(errs, fmt.Errorf("Cannot share AMI with encrypted boot volume"))
-	}
-
-	var kmsKeys []string
-	if len(c.AMIKmsKeyId) > 0 {
-		kmsKeys = append(kmsKeys, c.AMIKmsKeyId)
-	}
-	if len(c.AMIRegionKMSKeyIDs) > 0 {
-		for _, kmsKey := range c.AMIRegionKMSKeyIDs {
-			if len(kmsKey) == 0 {
-				kmsKeys = append(kmsKeys, c.AMIKmsKeyId)
-			}
-		}
-	}
-	for _, kmsKey := range kmsKeys {
-		if !validateKmsKey(kmsKey) {
-			errs = append(errs, fmt.Errorf("%s is not a valid KMS Key Id.", kmsKey))
-		}
-	}
-
-	if len(c.SnapshotUsers) > 0 {
-		if len(c.AMIKmsKeyId) == 0 && c.AMIEncryptBootVolume != nil && *c.AMIEncryptBootVolume {
-			errs = append(errs, fmt.Errorf("Cannot share snapshot encrypted with default KMS key"))
-		}
-		if len(c.AMIRegionKMSKeyIDs) > 0 {
-			for _, kmsKey := range c.AMIRegionKMSKeyIDs {
-				if len(kmsKey) == 0 {
-					errs = append(errs, fmt.Errorf("Cannot share snapshot encrypted with default KMS key"))
-				}
-			}
-		}
-	}
-
-	if len(c.AMIName) < 3 || len(c.AMIName) > 128 {
-		errs = append(errs, fmt.Errorf("ami_name must be between 3 and 128 characters long"))
-	}
-
-	if c.AMIName != templateCleanAMIName(c.AMIName) {
-		errs = append(errs, fmt.Errorf("AMIName should only contain "+
-			"alphanumeric characters, parentheses (()), square brackets ([]), spaces "+
-			"( ), periods (.), slashes (/), dashes (-), single quotes ('), at-signs "+
-			"(@), or underscores(_). You can use the `clean_resource_name` template "+
-			"filter to automatically clean your ami name."))
-	}
-
-	if len(errs) > 0 {
-		return errs
-	}
-
-	return nil
-}
-
-func (c *AMIConfig) prepareRegions(accessConfig *AccessConfig) (errs []error) {
 	if len(c.AMIRegions) > 0 {
 		regionSet := make(map[string]struct{})
 		regions := make([]string, 0, len(c.AMIRegions))
@@ -126,6 +69,13 @@ func (c *AMIConfig) prepareRegions(accessConfig *AccessConfig) (errs []error) {
 			// Mark that we saw the region
 			regionSet[region] = struct{}{}
 
+			if !c.AMISkipRegionValidation {
+				// Verify the region is real
+				if valid := ValidateRegion(region); !valid {
+					errs = append(errs, fmt.Errorf("Unknown region: %s", region))
+				}
+			}
+
 			// Make sure that if we have region_kms_key_ids defined,
 			// the regions in ami_regions are also in region_kms_key_ids
 			if len(c.AMIRegionKMSKeyIDs) > 0 {
@@ -144,25 +94,39 @@ func (c *AMIConfig) prepareRegions(accessConfig *AccessConfig) (errs []error) {
 
 		c.AMIRegions = regions
 	}
-	return errs
-}
 
-// See https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopyImage.html
-func validateKmsKey(kmsKey string) (valid bool) {
-	kmsKeyIdPattern := `[a-f0-9-]+$`
-	aliasPattern := `alias/[a-zA-Z0-9:/_-]+$`
-	kmsArnStartPattern := `^arn:aws(-us-gov)?:kms:([a-z]{2}-(gov-)?[a-z]+-\d{1})?:(\d{12}):`
-	if regexp.MustCompile(fmt.Sprintf("^%s", kmsKeyIdPattern)).MatchString(kmsKey) {
-		return true
+	if len(c.AMIUsers) > 0 && c.AMIEncryptBootVolume {
+		errs = append(errs, fmt.Errorf("Cannot share AMI with encrypted boot volume"))
 	}
-	if regexp.MustCompile(fmt.Sprintf("^%s", aliasPattern)).MatchString(kmsKey) {
-		return true
+
+	if len(c.SnapshotUsers) > 0 {
+		if len(c.AMIKmsKeyId) == 0 && c.AMIEncryptBootVolume {
+			errs = append(errs, fmt.Errorf("Cannot share snapshot encrypted with default KMS key"))
+		}
+		if len(c.AMIRegionKMSKeyIDs) > 0 {
+			for _, kmsKey := range c.AMIRegionKMSKeyIDs {
+				if len(kmsKey) == 0 {
+					errs = append(errs, fmt.Errorf("Cannot share snapshot encrypted with default KMS key"))
+				}
+			}
+		}
 	}
-	if regexp.MustCompile(fmt.Sprintf("%skey/%s", kmsArnStartPattern, kmsKeyIdPattern)).MatchString(kmsKey) {
-		return true
+
+	if len(c.AMIName) < 3 || len(c.AMIName) > 128 {
+		errs = append(errs, fmt.Errorf("ami_name must be between 3 and 128 characters long"))
 	}
-	if regexp.MustCompile(fmt.Sprintf("%s%s", kmsArnStartPattern, aliasPattern)).MatchString(kmsKey) {
-		return true
+
+	if c.AMIName != templateCleanAMIName(c.AMIName) {
+		errs = append(errs, fmt.Errorf("AMIName should only contain "+
+			"alphanumeric characters, parentheses (()), square brackets ([]), spaces "+
+			"( ), periods (.), slashes (/), dashes (-), single quotes ('), at-signs "+
+			"(@), or underscores(_). You can use the `clean_ami_name` template "+
+			"filter to automatically clean your ami name."))
 	}
-	return false
+
+	if len(errs) > 0 {
+		return errs
+	}
+
+	return nil
 }

builder/amazon/common/ami_config_test.go

@@ -1,13 +1,8 @@
 package common
 
 import (
-	"fmt"
 	"reflect"
 	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 )
 
 func testAMIConfig() *AMIConfig {
@@ -17,62 +12,43 @@ func testAMIConfig() *AMIConfig {
 }
 
 func getFakeAccessConfig(region string) *AccessConfig {
-	c := testAccessConfig()
-	c.RawRegion = region
-	return c
+	return &AccessConfig{
+		RawRegion: region,
+	}
 }
 
 func TestAMIConfigPrepare_name(t *testing.T) {
 	c := testAMIConfig()
-	accessConf := testAccessConfig()
-	if err := c.Prepare(accessConf, nil); err != nil {
+	if err := c.Prepare(nil, nil); err != nil {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
 
 	c.AMIName = ""
-	if err := c.Prepare(accessConf, nil); err == nil {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("should have error")
 	}
 }
 
-type mockEC2Client struct {
-	ec2iface.EC2API
-}
-
-func (m *mockEC2Client) DescribeRegions(*ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error) {
-	return &ec2.DescribeRegionsOutput{
-		Regions: []*ec2.Region{
-			{RegionName: aws.String("us-east-1")},
-			{RegionName: aws.String("us-east-2")},
-			{RegionName: aws.String("us-west-1")},
-		},
-	}, nil
-}
-
 func TestAMIConfigPrepare_regions(t *testing.T) {
 	c := testAMIConfig()
 	c.AMIRegions = nil
-
-	var errs []error
-	var err error
-	accessConf := testAccessConfig()
-	mockConn := &mockEC2Client{}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
-		t.Fatalf("shouldn't have err: %#v", errs)
+	if err := c.Prepare(nil, nil); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
 	}
 
-	c.AMIRegions, err = listEC2Regions(mockConn)
-	if err != nil {
-		t.Fatalf("shouldn't have err: %s", err.Error())
+	c.AMIRegions = listEC2Regions()
+	if err := c.Prepare(nil, nil); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
 	}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
-		t.Fatalf("shouldn't have err: %#v", errs)
+
+	c.AMIRegions = []string{"foo"}
+	if err := c.Prepare(nil, nil); err == nil {
+		t.Fatal("should have error")
 	}
-	errs = errs[:0]
 
 	c.AMIRegions = []string{"us-east-1", "us-west-1", "us-east-1"}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
-		t.Fatalf("bad: %s", errs[0])
+	if err := c.Prepare(nil, nil); err != nil {
+		t.Fatalf("bad: %s", err)
 	}
 
 	expected := []string{"us-east-1", "us-west-1"}
@@ -81,9 +57,11 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 	}
 
 	c.AMIRegions = []string{"custom"}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+	c.AMISkipRegionValidation = true
+	if err := c.Prepare(nil, nil); err != nil {
 		t.Fatal("shouldn't have error")
 	}
+	c.AMISkipRegionValidation = false
 
 	c.AMIRegions = []string{"us-east-1", "us-east-2", "us-west-1"}
 	c.AMIRegionKMSKeyIDs = map[string]string{
@@ -91,8 +69,8 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 		"us-west-1": "789-012-3456",
 		"us-east-2": "456-789-0123",
 	}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
-		t.Fatal(fmt.Sprintf("shouldn't have error: %s", errs[0]))
+	if err := c.Prepare(nil, nil); err != nil {
+		t.Fatal("shouldn't have error")
 	}
 
 	c.AMIRegions = []string{"us-east-1", "us-east-2", "us-west-1"}
@@ -101,7 +79,7 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 		"us-west-1": "789-012-3456",
 		"us-east-2": "",
 	}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+	if err := c.Prepare(nil, nil); err != nil {
 		t.Fatal("should have passed; we are able to use default KMS key if not sharing")
 	}
 
@@ -112,7 +90,7 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 		"us-west-1": "789-012-3456",
 		"us-east-2": "",
 	}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("should have an error b/c can't use default KMS key if sharing")
 	}
 
@@ -122,7 +100,7 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 		"us-west-1": "789-012-3456",
 		"us-east-2": "456-789-0123",
 	}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("should have error b/c theres a region in the key map that isn't in ami_regions")
 	}
 
@@ -131,28 +109,27 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 		"us-east-1": "123-456-7890",
 		"us-west-1": "789-012-3456",
 	}
-
-	if err := c.Prepare(accessConf, nil); err == nil {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("should have error b/c theres a region in in ami_regions that isn't in the key map")
 	}
 
 	c.SnapshotUsers = []string{"foo", "bar"}
 	c.AMIKmsKeyId = "123-abc-456"
-	c.AMIEncryptBootVolume = &[]bool{true}[0]
+	c.AMIEncryptBootVolume = true
 	c.AMIRegions = []string{"us-east-1", "us-west-1"}
 	c.AMIRegionKMSKeyIDs = map[string]string{
 		"us-east-1": "123-456-7890",
 		"us-west-1": "",
 	}
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("should have error b/c theres a region in in ami_regions that isn't in the key map")
 	}
 
 	// allow rawregion to exist in ami_regions list.
-	accessConf = getFakeAccessConfig("us-east-1")
+	accessConf := getFakeAccessConfig("us-east-1")
 	c.AMIRegions = []string{"us-east-1", "us-west-1", "us-east-2"}
 	c.AMIRegionKMSKeyIDs = nil
-	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+	if err := c.Prepare(accessConf, nil); err != nil {
 		t.Fatal("should allow user to have the raw region in ami_regions")
 	}
 
@@ -161,65 +138,24 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 func TestAMIConfigPrepare_Share_EncryptedBoot(t *testing.T) {
 	c := testAMIConfig()
 	c.AMIUsers = []string{"testAccountID"}
-	c.AMIEncryptBootVolume = &[]bool{true}[0]
-
-	accessConf := testAccessConfig()
+	c.AMIEncryptBootVolume = true
 
 	c.AMIKmsKeyId = ""
-	if err := c.Prepare(accessConf, nil); err == nil {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("shouldn't be able to share ami with encrypted boot volume")
 	}
 
 	c.AMIKmsKeyId = "89c3fb9a-de87-4f2a-aedc-fddc5138193c"
-	if err := c.Prepare(accessConf, nil); err == nil {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("shouldn't be able to share ami with encrypted boot volume")
 	}
 }
 
-func TestAMIConfigPrepare_ValidateKmsKey(t *testing.T) {
-	c := testAMIConfig()
-	c.AMIEncryptBootVolume = aws.Bool(true)
-
-	accessConf := testAccessConfig()
-
-	validCases := []string{
-		"abcd1234-e567-890f-a12b-a123b4cd56ef",
-		"alias/foo/bar",
-		"arn:aws:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef",
-		"arn:aws:kms:us-east-1:012345678910:alias/foo/bar",
-		"arn:aws-us-gov:kms:us-gov-east-1:123456789012:key/12345678-1234-abcd-0000-123456789012",
-	}
-	for _, validCase := range validCases {
-		c.AMIKmsKeyId = validCase
-		if err := c.Prepare(accessConf, nil); err != nil {
-			t.Fatalf("%s should not have failed KMS key validation", validCase)
-		}
-	}
-
-	invalidCases := []string{
-		"ABCD1234-e567-890f-a12b-a123b4cd56ef",
-		"ghij1234-e567-890f-a12b-a123b4cd56ef",
-		"ghij1234+e567_890f-a12b-a123b4cd56ef",
-		"foo/bar",
-		"arn:aws:kms:us-east-1:012345678910:foo/bar",
-		"arn:foo:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef",
-	}
-	for _, invalidCase := range invalidCases {
-		c.AMIKmsKeyId = invalidCase
-		if err := c.Prepare(accessConf, nil); err == nil {
-			t.Fatalf("%s should have failed KMS key validation", invalidCase)
-		}
-	}
-
-}
-
 func TestAMINameValidation(t *testing.T) {
 	c := testAMIConfig()
 
-	accessConf := testAccessConfig()
-
 	c.AMIName = "aa"
-	if err := c.Prepare(accessConf, nil); err == nil {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("shouldn't be able to have an ami name with less than 3 characters")
 	}
 
@@ -228,22 +164,22 @@ func TestAMINameValidation(t *testing.T) {
 		longAmiName += "a"
 	}
 	c.AMIName = longAmiName
-	if err := c.Prepare(accessConf, nil); err == nil {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("shouldn't be able to have an ami name with great than 128 characters")
 	}
 
 	c.AMIName = "+aaa"
-	if err := c.Prepare(accessConf, nil); err == nil {
+	if err := c.Prepare(nil, nil); err == nil {
 		t.Fatal("shouldn't be able to have an ami name with invalid characters")
 	}
 
 	c.AMIName = "fooBAR1()[] ./-'@_"
-	if err := c.Prepare(accessConf, nil); err != nil {
+	if err := c.Prepare(nil, nil); err != nil {
 		t.Fatal("should be able to use all of the allowed AMI characters")
 	}
 
 	c.AMIName = `xyz-base-2017-04-05-1934`
-	if err := c.Prepare(accessConf, nil); err != nil {
+	if err := c.Prepare(nil, nil); err != nil {
 		t.Fatalf("expected `xyz-base-2017-04-05-1934` to pass validation.")
 	}
 

builder/amazon/common/block_device.go

@@ -13,7 +13,7 @@ import (
 type BlockDevice struct {
 	DeleteOnTermination bool   `mapstructure:"delete_on_termination"`
 	DeviceName          string `mapstructure:"device_name"`
-	Encrypted           *bool  `mapstructure:"encrypted"`
+	Encrypted           bool   `mapstructure:"encrypted"`
 	IOPS                int64  `mapstructure:"iops"`
 	NoDevice            bool   `mapstructure:"no_device"`
 	SnapshotId          string `mapstructure:"snapshot_id"`
@@ -71,8 +71,9 @@ func buildBlockDevices(b []BlockDevice) []*ec2.BlockDeviceMapping {
 			// You cannot specify Encrypted if you specify a Snapshot ID
 			if blockDevice.SnapshotId != "" {
 				ebsBlockDevice.SnapshotId = aws.String(blockDevice.SnapshotId)
+			} else if blockDevice.Encrypted {
+				ebsBlockDevice.Encrypted = aws.Bool(blockDevice.Encrypted)
 			}
-			ebsBlockDevice.Encrypted = blockDevice.Encrypted
 
 			if blockDevice.KmsKeyId != "" {
 				ebsBlockDevice.KmsKeyId = aws.String(blockDevice.KmsKeyId)
@@ -87,12 +88,8 @@ func buildBlockDevices(b []BlockDevice) []*ec2.BlockDeviceMapping {
 }
 
 func (b *BlockDevice) Prepare(ctx *interpolate.Context) error {
-	if b.DeviceName == "" {
-		return fmt.Errorf("The `device_name` must be specified " +
-			"for every device in the block device mapping.")
-	}
 	// Warn that encrypted must be true when setting kms_key_id
-	if b.KmsKeyId != "" && b.Encrypted != nil && *b.Encrypted == false {
+	if b.KmsKeyId != "" && b.Encrypted == false {
 		return fmt.Errorf("The device %v, must also have `encrypted: "+
 			"true` when setting a kms_key_id.", b.DeviceName)
 	}

builder/amazon/common/block_device_test.go

@@ -71,7 +71,7 @@ func TestBlockDevice(t *testing.T) {
 				VolumeType:          "gp2",
 				VolumeSize:          8,
 				DeleteOnTermination: true,
-				Encrypted:           aws.Bool(true),
+				Encrypted:           true,
 			},
 
 			Result: &ec2.BlockDeviceMapping{
@@ -90,7 +90,7 @@ func TestBlockDevice(t *testing.T) {
 				VolumeType:          "gp2",
 				VolumeSize:          8,
 				DeleteOnTermination: true,
-				Encrypted:           aws.Bool(true),
+				Encrypted:           true,
 				KmsKeyId:            "2Fa48a521f-3aff-4b34-a159-376ac5d37812",
 			},
 

builder/amazon/common/build_filter.go

@@ -1,17 +0,0 @@
-package common
-
-import (
-	"github.com/aws/aws-sdk-go/service/ec2"
-)
-
-// Build a slice of EC2 (AMI/Subnet/VPC) filter options from the filters provided.
-func buildEc2Filters(input map[*string]*string) []*ec2.Filter {
-	var filters []*ec2.Filter
-	for k, v := range input {
-		filters = append(filters, &ec2.Filter{
-			Name:   k,
-			Values: []*string{v},
-		})
-	}
-	return filters
-}

builder/amazon/common/errors.go

@@ -1,58 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"log"
-	"regexp"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/sts"
-)
-
-var encodedFailureMessagePattern = regexp.MustCompile(`(?i)(.*) Encoded authorization failure message: ([\w-]+) ?( .*)?`)
-
-type stsDecoder interface {
-	DecodeAuthorizationMessage(input *sts.DecodeAuthorizationMessageInput) (*sts.DecodeAuthorizationMessageOutput, error)
-}
-
-// decodeError replaces encoded authorization messages with the
-// decoded results
-func decodeAWSError(decoder stsDecoder, err error) error {
-
-	groups := encodedFailureMessagePattern.FindStringSubmatch(err.Error())
-	if groups != nil && len(groups) > 1 {
-		result, decodeErr := decoder.DecodeAuthorizationMessage(&sts.DecodeAuthorizationMessageInput{
-			EncodedMessage: aws.String(groups[2]),
-		})
-		if decodeErr == nil {
-			msg := aws.StringValue(result.DecodedMessage)
-			return fmt.Errorf("%s Authorization failure message: '%s'%s", groups[1], msg, groups[3])
-		}
-		log.Printf("[WARN] Attempted to decode authorization message, but received: %v", decodeErr)
-	}
-	return err
-}
-
-// DecodeAuthZMessages enables automatic decoding of any
-// encoded authorization messages
-func DecodeAuthZMessages(sess *session.Session) {
-	azd := &authZMessageDecoder{
-		Decoder: sts.New(sess),
-	}
-	sess.Handlers.UnmarshalError.AfterEachFn = azd.afterEachFn
-}
-
-type authZMessageDecoder struct {
-	Decoder stsDecoder
-}
-
-func (a *authZMessageDecoder) afterEachFn(item request.HandlerListRunItem) bool {
-	if err, ok := item.Request.Error.(awserr.Error); ok && err.Code() == "UnauthorizedOperation" {
-		item.Request.Error = decodeAWSError(a.Decoder, err)
-	}
-	return true
-}

builder/amazon/common/errors_test.go

@@ -1,70 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/sts"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-type mockSTS struct {
-}
-
-func (m *mockSTS) DecodeAuthorizationMessage(input *sts.DecodeAuthorizationMessageInput) (*sts.DecodeAuthorizationMessageOutput, error) {
-	return &sts.DecodeAuthorizationMessageOutput{
-		DecodedMessage: aws.String(`{
-			"allowed": false,
-			"explicitDeny": true,
-			"matchedStatements": {}
-		}`),
-	}, nil
-}
-
-func TestErrorsParsing_RequestFailure(t *testing.T) {
-
-	ae := awserr.New("UnauthorizedOperation",
-		`You are not authorized to perform this operation. Encoded authorization failure message: D9Q7oicjOMr9l2CC-NPP1FiZXK9Ijia1k-3l0siBFCcrK3oSuMFMkBIO5TNj0HdXE-WfwnAcdycFOohfKroNO6toPJEns8RFVfy_M_IjNGmrEFJ6E62pnmBW0OLrMsXxR9FQE4gB4gJzSM0AD6cV6S3FOfqYzWBRX-sQdOT4HryGkFNRoFBr9Xbp-tRwiadwkbdHdfnV9fbRkXmnwCdULml16NBSofC4ZPepLMKmIB5rKjwk-m179UUh2XA-J5no0si6XcRo5GbHQB5QfCIwSHL4vsro2wLZUd16-8OWKyr3tVlTbQe0ERZskqRqRQ5E28QuiBCVV6XstUyo-T4lBSr75Fgnyr3wCO-dS3b_5Ns3WzA2JD4E2AJOAStXIU8IH5YuKkAg7C-dJMuBMPpmKCBEXhNoHDwCyOo5PsV3xMlc0jSb0qYGpfst_TDDtejcZfn7NssUjxVq9qkdH-OXz2gPoQB-hX8ycmZCL5UZwKc3TCLUr7TGnudHjmnMrE9cUo-yTCWfyHPLprhiYhTCKW18EikJ0O1EKI3FJ_b4F19_jFBPARjSwQc7Ut6MNCVzrPdZGYSF6acj5gPaxdy9uSkVQwWXK7Pd5MFP7EBDE1_DgYbzodgwDO2PXeVFUbSLBHKWo_ebZS9ZX2nYPcGss_sYaly0ZVSIJXp7G58B5BoFVhvVH6jYnF9XiAOjMltuP_ycu1pQP1lki500RY3baLvfeYeAsB38XZHKEgWZzq7Fei-uh89q0cjJTmlVyrfRU3q6`,
-		fmt.Errorf("You can't do it!!"))
-	rf := awserr.NewRequestFailure(ae, 400, "abc-def-123-456")
-
-	result := decodeAWSError(&mockSTS{}, rf)
-	if result == nil {
-		t.Error("Expected resulting error")
-	}
-	if !strings.Contains(result.Error(), "Authorization failure message:") {
-		t.Error("Expected authorization failure message")
-	}
-}
-
-func TestErrorsParsing_NonAuthorizationFailure(t *testing.T) {
-
-	ae := awserr.New("BadRequest",
-		`You did something wrong. Try again`,
-		fmt.Errorf("Request was no good."))
-	rf := awserr.NewRequestFailure(ae, 400, "abc-def-123-456")
-
-	result := decodeAWSError(&mockSTS{}, rf)
-	if result == nil {
-		t.Error("Expected resulting error")
-	}
-	if result != rf {
-		t.Error("Expected original error to be returned unchanged")
-	}
-}
-
-func TestErrorsParsing_NonAWSError(t *testing.T) {
-
-	err := fmt.Errorf("Random error occurred")
-
-	result := decodeAWSError(&mockSTS{}, err)
-	if result == nil {
-		t.Error("Expected resulting error")
-	}
-	if result != err {
-		t.Error("Expected original error to be returned unchanged")
-	}
-}

builder/amazon/common/regions.go

@@ -1,58 +1,38 @@
 package common
 
-import (
-	"fmt"
-
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-)
-
-func listEC2Regions(ec2conn ec2iface.EC2API) ([]string, error) {
-	var regions []string
-	resultRegions, err := ec2conn.DescribeRegions(nil)
-	if err != nil {
-		return []string{}, err
+// aws ec2 describe-regions --query 'Regions[].{Name:RegionName}' --output text | sed 's/\(.*\)/"\1",/' | sort
+func listEC2Regions() []string {
+	return []string{
+		"ap-northeast-1",
+		"ap-northeast-2",
+		"ap-northeast-3",
+		"ap-south-1",
+		"ap-southeast-1",
+		"ap-southeast-2",
+		"ca-central-1",
+		"eu-central-1",
+		"eu-west-1",
+		"eu-west-2",
+		"eu-west-3",
+		"sa-east-1",
+		"us-east-1",
+		"us-east-2",
+		"us-west-1",
+		"us-west-2",
+		// not part of autogenerated list
+		"us-gov-west-1",
+		"cn-north-1",
+		"cn-northwest-1",
 	}
-	for _, region := range resultRegions.Regions {
-		regions = append(regions, *region.RegionName)
-	}
-
-	return regions, nil
 }
 
-// ValidateRegion returns an nil if the regions are valid
-// and exists; otherwise an error.
-// ValidateRegion calls ec2conn.DescribeRegions to get the list of
-// regions available to this account.
-func (c *AccessConfig) ValidateRegion(regions ...string) error {
-	ec2conn, err := c.NewEC2Connection()
-	if err != nil {
-		return err
-	}
-
-	validRegions, err := listEC2Regions(ec2conn)
-	if err != nil {
-		return err
-	}
-
-	var invalidRegions []string
-	for _, region := range regions {
-		if region == "" {
-			continue
-		}
-		found := false
-		for _, validRegion := range validRegions {
-			if region == validRegion {
-				found = true
-				break
-			}
-		}
-		if !found {
-			invalidRegions = append(invalidRegions, region)
+// ValidateRegion returns true if the supplied region is a valid AWS
+// region and false if it's not.
+func ValidateRegion(region string) bool {
+	for _, valid := range listEC2Regions() {
+		if region == valid {
+			return true
 		}
 	}
-
-	if len(invalidRegions) > 0 {
-		return fmt.Errorf("Invalid region(s): %v, available regions: %v", invalidRegions, validRegions)
-	}
-	return nil
+	return false
 }

builder/amazon/common/run_config.go

@@ -29,62 +29,32 @@ func (d *AmiFilterOptions) NoOwner() bool {
 	return len(d.Owners) == 0
 }
 
-type SubnetFilterOptions struct {
-	Filters  map[*string]*string
-	MostFree bool `mapstructure:"most_free"`
-	Random   bool `mapstructure:"random"`
-}
-
-func (d *SubnetFilterOptions) Empty() bool {
-	return len(d.Filters) == 0
-}
-
-type VpcFilterOptions struct {
-	Filters map[*string]*string
-}
-
-func (d *VpcFilterOptions) Empty() bool {
-	return len(d.Filters) == 0
-}
-
-type SecurityGroupFilterOptions struct {
-	Filters map[*string]*string
-}
-
-func (d *SecurityGroupFilterOptions) Empty() bool {
-	return len(d.Filters) == 0
-}
-
 // RunConfig contains configuration for running an instance from a source
 // AMI and details on how to access that launched image.
 type RunConfig struct {
-	AssociatePublicIpAddress          bool                       `mapstructure:"associate_public_ip_address"`
-	AvailabilityZone                  string                     `mapstructure:"availability_zone"`
-	BlockDurationMinutes              int64                      `mapstructure:"block_duration_minutes"`
-	DisableStopInstance               bool                       `mapstructure:"disable_stop_instance"`
-	EbsOptimized                      bool                       `mapstructure:"ebs_optimized"`
-	EnableT2Unlimited                 bool                       `mapstructure:"enable_t2_unlimited"`
-	IamInstanceProfile                string                     `mapstructure:"iam_instance_profile"`
-	InstanceInitiatedShutdownBehavior string                     `mapstructure:"shutdown_behavior"`
-	InstanceType                      string                     `mapstructure:"instance_type"`
-	SecurityGroupFilter               SecurityGroupFilterOptions `mapstructure:"security_group_filter"`
-	RunTags                           map[string]string          `mapstructure:"run_tags"`
-	SecurityGroupId                   string                     `mapstructure:"security_group_id"`
-	SecurityGroupIds                  []string                   `mapstructure:"security_group_ids"`
-	SourceAmi                         string                     `mapstructure:"source_ami"`
-	SourceAmiFilter                   AmiFilterOptions           `mapstructure:"source_ami_filter"`
-	SpotPrice                         string                     `mapstructure:"spot_price"`
-	SpotPriceAutoProduct              string                     `mapstructure:"spot_price_auto_product"`
-	SpotTags                          map[string]string          `mapstructure:"spot_tags"`
-	SubnetFilter                      SubnetFilterOptions        `mapstructure:"subnet_filter"`
-	SubnetId                          string                     `mapstructure:"subnet_id"`
-	TemporaryKeyPairName              string                     `mapstructure:"temporary_key_pair_name"`
-	TemporarySGSourceCidrs            []string                   `mapstructure:"temporary_security_group_source_cidrs"`
-	UserData                          string                     `mapstructure:"user_data"`
-	UserDataFile                      string                     `mapstructure:"user_data_file"`
-	VpcFilter                         VpcFilterOptions           `mapstructure:"vpc_filter"`
-	VpcId                             string                     `mapstructure:"vpc_id"`
-	WindowsPasswordTimeout            time.Duration              `mapstructure:"windows_password_timeout"`
+	AssociatePublicIpAddress          bool              `mapstructure:"associate_public_ip_address"`
+	AvailabilityZone                  string            `mapstructure:"availability_zone"`
+	DisableStopInstance               bool              `mapstructure:"disable_stop_instance"`
+	EbsOptimized                      bool              `mapstructure:"ebs_optimized"`
+	EnableT2Unlimited                 bool              `mapstructure:"enable_t2_unlimited"`
+	IamInstanceProfile                string            `mapstructure:"iam_instance_profile"`
+	InstanceInitiatedShutdownBehavior string            `mapstructure:"shutdown_behavior"`
+	InstanceType                      string            `mapstructure:"instance_type"`
+	RunTags                           map[string]string `mapstructure:"run_tags"`
+	SecurityGroupId                   string            `mapstructure:"security_group_id"`
+	SecurityGroupIds                  []string          `mapstructure:"security_group_ids"`
+	SourceAmi                         string            `mapstructure:"source_ami"`
+	SourceAmiFilter                   AmiFilterOptions  `mapstructure:"source_ami_filter"`
+	SpotPrice                         string            `mapstructure:"spot_price"`
+	SpotPriceAutoProduct              string            `mapstructure:"spot_price_auto_product"`
+	SpotTags                          map[string]string `mapstructure:"spot_tags"`
+	SubnetId                          string            `mapstructure:"subnet_id"`
+	TemporaryKeyPairName              string            `mapstructure:"temporary_key_pair_name"`
+	TemporarySGSourceCidr             string            `mapstructure:"temporary_security_group_source_cidr"`
+	UserData                          string            `mapstructure:"user_data"`
+	UserDataFile                      string            `mapstructure:"user_data_file"`
+	VpcId                             string            `mapstructure:"vpc_id"`
+	WindowsPasswordTimeout            time.Duration     `mapstructure:"windows_password_timeout"`
 
 	// Communicator settings
 	Comm communicator.Config `mapstructure:",squash"`
@@ -141,11 +111,6 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 		errs = append(errs, fmt.Errorf("An instance_type must be specified"))
 	}
 
-	if c.BlockDurationMinutes%60 != 0 {
-		errs = append(errs, fmt.Errorf(
-			"block_duration_minutes must be multiple of 60"))
-	}
-
 	if c.SpotPrice == "auto" {
 		if c.SpotPriceAutoProduct == "" {
 			errs = append(errs, fmt.Errorf(
@@ -184,13 +149,11 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 		}
 	}
 
-	if len(c.TemporarySGSourceCidrs) == 0 {
-		c.TemporarySGSourceCidrs = []string{"0.0.0.0/0"}
+	if c.TemporarySGSourceCidr == "" {
+		c.TemporarySGSourceCidr = "0.0.0.0/0"
 	} else {
-		for _, cidr := range c.TemporarySGSourceCidrs {
-			if _, _, err := net.ParseCIDR(cidr); err != nil {
-				errs = append(errs, fmt.Errorf("Error parsing CIDR in temporary_security_group_source_cidrs: %s", err.Error()))
-			}
+		if _, _, err := net.ParseCIDR(c.TemporarySGSourceCidr); err != nil {
+			errs = append(errs, fmt.Errorf("Error parsing temporary_security_group_source_cidr: %s", err.Error()))
 		}
 	}
 

builder/amazon/common/state.go

@@ -1,7 +1,6 @@
 package common
 
 import (
-	"fmt"
 	"log"
 	"os"
 	"strconv"
@@ -170,8 +169,6 @@ func WaitForVolumeToBeAttached(c *ec2.EC2, ctx aws.Context, input *ec2.DescribeV
 			return req, nil
 		},
 	}
-	w.ApplyOptions(opts...)
-
 	return w.WaitWithContext(ctx)
 }
 
@@ -201,15 +198,13 @@ func WaitForVolumeToBeDetached(c *ec2.EC2, ctx aws.Context, input *ec2.DescribeV
 			return req, nil
 		},
 	}
-	w.ApplyOptions(opts...)
-
 	return w.WaitWithContext(ctx)
 }
 
 func WaitForImageToBeImported(c *ec2.EC2, ctx aws.Context, input *ec2.DescribeImportImageTasksInput, opts ...request.WaiterOption) error {
 	w := request.Waiter{
 		Name:        "DescribeImages",
-		MaxAttempts: 720,
+		MaxAttempts: 300,
 		Delay:       request.ConstantWaiterDelay(5 * time.Second),
 		Acceptors: []request.WaiterAcceptor{
 			{
@@ -218,12 +213,6 @@ func WaitForImageToBeImported(c *ec2.EC2, ctx aws.Context, input *ec2.DescribeIm
 				Argument: "ImportImageTasks[].Status",
 				Expected: "completed",
 			},
-			{
-				State:    request.FailureWaiterState,
-				Matcher:  request.PathAnyWaiterMatch,
-				Argument: "ImportImageTasks[].Status",
-				Expected: "deleted",
-			},
 		},
 		Logger: c.Config.Logger,
 		NewRequest: func(opts []request.Option) (*request.Request, error) {
@@ -238,8 +227,6 @@ func WaitForImageToBeImported(c *ec2.EC2, ctx aws.Context, input *ec2.DescribeIm
 			return req, nil
 		},
 	}
-	w.ApplyOptions(opts...)
-
 	return w.WaitWithContext(ctx)
 }
 
@@ -294,11 +281,11 @@ func getOverride(varInfo envInfo) envInfo {
 	return varInfo
 }
 func getEnvOverrides() overridableWaitVars {
-	// Load env vars from environment.
+	// Load env vars from environment, and use them to override defaults
 	envValues := overridableWaitVars{
 		envInfo{"AWS_POLL_DELAY_SECONDS", 2, false},
 		envInfo{"AWS_MAX_ATTEMPTS", 0, false},
-		envInfo{"AWS_TIMEOUT_SECONDS", 0, false},
+		envInfo{"AWS_TIMEOUT_SECONDS", 300, false},
 	}
 
 	envValues.awsMaxAttempts = getOverride(envValues.awsMaxAttempts)
@@ -308,36 +295,6 @@ func getEnvOverrides() overridableWaitVars {
 	return envValues
 }
 
-func LogEnvOverrideWarnings() {
-	pollDelay := os.Getenv("AWS_POLL_DELAY_SECONDS")
-	timeoutSeconds := os.Getenv("AWS_TIMEOUT_SECONDS")
-	maxAttempts := os.Getenv("AWS_MAX_ATTEMPTS")
-
-	if maxAttempts != "" && timeoutSeconds != "" {
-		warning := fmt.Sprintf("[WARNING] (aws): AWS_MAX_ATTEMPTS and " +
-			"AWS_TIMEOUT_SECONDS are both set. Packer will use " +
-			"AWS_MAX_ATTEMPTS and discard AWS_TIMEOUT_SECONDS.")
-		if pollDelay == "" {
-			warning = fmt.Sprintf("%s  Since you have not set the poll delay, "+
-				"Packer will default to a 2-second delay.", warning)
-		}
-		log.Printf(warning)
-	} else if timeoutSeconds != "" {
-		log.Printf("[WARNING] (aws): env var AWS_TIMEOUT_SECONDS is " +
-			"deprecated in favor of AWS_MAX_ATTEMPTS. If you have not " +
-			"explicitly set AWS_POLL_DELAY_SECONDS, we are defaulting to a " +
-			"poll delay of 2 seconds, regardless of the AWS waiter's default.")
-	}
-	if maxAttempts == "" && timeoutSeconds == "" && pollDelay == "" {
-		log.Printf("[INFO] (aws): No AWS timeout and polling overrides have been set. " +
-			"Packer will default to waiter-specific delays and timeouts. If you would " +
-			"like to customize the length of time between retries and max " +
-			"number of retries you may do so by setting the environment " +
-			"variables AWS_POLL_DELAY_SECONDS and AWS_MAX_ATTEMPTS to your " +
-			"desired values.")
-	}
-}
-
 func applyEnvOverrides(envOverrides overridableWaitVars) []request.WaiterOption {
 	waitOpts := make([]request.WaiterOption, 0)
 	// If user has set poll delay seconds, overwrite it. If user has NOT,
@@ -351,7 +308,18 @@ func applyEnvOverrides(envOverrides overridableWaitVars) []request.WaiterOption
 	// attempts, default to whatever the waiter has set as a default.
 	if envOverrides.awsMaxAttempts.overridden {
 		waitOpts = append(waitOpts, request.WithWaiterMaxAttempts(envOverrides.awsMaxAttempts.Val))
+	}
+
+	if envOverrides.awsMaxAttempts.overridden && envOverrides.awsTimeoutSeconds.overridden {
+		log.Printf("WARNING: AWS_MAX_ATTEMPTS and AWS_TIMEOUT_SECONDS are" +
+			" both set. Packer will be using AWS_MAX_ATTEMPTS and discarding " +
+			"AWS_TIMEOUT_SECONDS. If you have not set AWS_POLL_DELAY_SECONDS, " +
+			"Packer will default to a 2 second poll delay.")
 	} else if envOverrides.awsTimeoutSeconds.overridden {
+		log.Printf("DEPRECATION WARNING: env var AWS_TIMEOUT_SECONDS is " +
+			"deprecated in favor of AWS_MAX_ATTEMPTS. If you have not " +
+			"explicitly set AWS_POLL_DELAY_SECONDS, we are defaulting to a " +
+			"poll delay of 2 seconds, regardless of the AWS waiter's default.")
 		maxAttempts := envOverrides.awsTimeoutSeconds.Val / envOverrides.awsPollDelaySeconds.Val
 		// override the delay so we can get the timeout right
 		if !envOverrides.awsPollDelaySeconds.overridden {
@@ -360,6 +328,14 @@ func applyEnvOverrides(envOverrides overridableWaitVars) []request.WaiterOption
 		}
 		waitOpts = append(waitOpts, request.WithWaiterMaxAttempts(maxAttempts))
 	}
+	if len(waitOpts) == 0 {
+		log.Printf("No AWS timeout and polling overrides have been set. " +
+			"Packer will default to waiter-specific delays and timeouts. If you would " +
+			"like to customize the length of time between retries and max " +
+			"number of retries you may do so by setting the environment " +
+			"variables AWS_POLL_DELAY_SECONDS and AWS_MAX_ATTEMPTS to your " +
+			"desired values.")
+	}
 
 	return waitOpts
 }

builder/amazon/common/step_ami_region_copy.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
+
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -15,7 +16,7 @@ type StepAMIRegionCopy struct {
 	AccessConfig      *AccessConfig
 	Regions           []string
 	RegionKeyIds      map[string]string
-	EncryptBootVolume *bool // nil means preserve
+	EncryptBootVolume bool
 	Name              string
 }
 
@@ -26,13 +27,6 @@ func (s *StepAMIRegionCopy) Run(ctx context.Context, state multistep.StateBag) m
 	snapshots := state.Get("snapshots").(map[string][]string)
 	ami := amis[*ec2conn.Config.Region]
 
-	if s.EncryptBootVolume != nil {
-		// encrypt_boot was set, we now have to copy the temporary
-		// AMI with required encryption setting.
-		// temp image was created by stepCreateAMI.
-		s.Regions = append(s.Regions, *ec2conn.Config.Region)
-	}
-
 	if len(s.Regions) == 0 {
 		return multistep.ActionContinue
 	}
@@ -43,24 +37,23 @@ func (s *StepAMIRegionCopy) Run(ctx context.Context, state multistep.StateBag) m
 	var wg sync.WaitGroup
 	var regKeyID string
 	errs := new(packer.MultiError)
-
-	wg.Add(len(s.Regions))
 	for _, region := range s.Regions {
-		if region == *ec2conn.Config.Region && s.EncryptBootVolume == nil {
+		if region == *ec2conn.Config.Region {
 			ui.Message(fmt.Sprintf(
 				"Avoiding copying AMI to duplicate region %s", region))
 			continue
 		}
 
+		wg.Add(1)
 		ui.Message(fmt.Sprintf("Copying to: %s", region))
 
-		if s.EncryptBootVolume != nil && *s.EncryptBootVolume {
+		if s.EncryptBootVolume {
 			regKeyID = s.RegionKeyIds[region]
 		}
 
 		go func(region string) {
 			defer wg.Done()
-			id, snapshotIds, err := amiRegionCopy(ctx, state, s.AccessConfig, s.Name, ami, region, *ec2conn.Config.Region, regKeyID, s.EncryptBootVolume)
+			id, snapshotIds, err := amiRegionCopy(ctx, state, s.AccessConfig, s.Name, ami, region, *ec2conn.Config.Region, regKeyID)
 			lock.Lock()
 			defer lock.Unlock()
 			amis[region] = id
@@ -92,26 +85,30 @@ func (s *StepAMIRegionCopy) Cleanup(state multistep.StateBag) {
 
 // amiRegionCopy does a copy for the given AMI to the target region and
 // returns the resulting ID and snapshot IDs, or error.
-func amiRegionCopy(ctx context.Context, state multistep.StateBag, config *AccessConfig, name, imageId,
-	target, source, keyId string, encrypt *bool) (string, []string, error) {
+func amiRegionCopy(ctx context.Context, state multistep.StateBag, config *AccessConfig, name string, imageId string,
+	target string, source string, keyID string) (string, []string, error) {
 	snapshotIds := []string{}
+	isEncrypted := false
 
 	// Connect to the region where the AMI will be copied to
 	session, err := config.Session()
 	if err != nil {
 		return "", snapshotIds, err
 	}
-
+	// if we've provided a map of key ids to regions, use those keys.
+	if len(keyID) > 0 {
+		isEncrypted = true
+	}
 	regionconn := ec2.New(session.Copy(&aws.Config{
-		Region: aws.String(target),
-	}))
+		Region: aws.String(target)},
+	))
 
 	resp, err := regionconn.CopyImage(&ec2.CopyImageInput{
 		SourceRegion:  &source,
 		SourceImageId: &imageId,
 		Name:          &name,
-		Encrypted:     encrypt,
-		KmsKeyId:      aws.String(keyId),
+		Encrypted:     aws.Bool(isEncrypted),
+		KmsKeyId:      aws.String(keyID),
 	})
 
 	if err != nil {

builder/amazon/common/step_cleanup_volumes.go

@@ -17,7 +17,7 @@ type StepCleanupVolumes struct {
 	BlockDevices BlockDevices
 }
 
-func (s *StepCleanupVolumes) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCleanupVolumes) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	// stepCleanupVolumes is for Cleanup only
 	return multistep.ActionContinue
 }

builder/amazon/common/step_create_tags.go

@@ -3,13 +3,12 @@ package common
 import (
 	"context"
 	"fmt"
-	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common/retry"
+	retry "github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
@@ -21,7 +20,7 @@ type StepCreateTags struct {
 	Ctx          interpolate.Context
 }
 
-func (s *StepCreateTags) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	session := state.Get("awsSession").(*session.Session)
 	ui := state.Get("ui").(packer.Ui)
@@ -91,26 +90,17 @@ func (s *StepCreateTags) Run(ctx context.Context, state multistep.StateBag) mult
 		snapshotTags.Report(ui)
 
 		// Retry creating tags for about 2.5 minutes
-		err = retry.Config{
-			Tries: 11,
-			ShouldRetry: func(error) bool {
-				if awsErr, ok := err.(awserr.Error); ok {
-					switch awsErr.Code() {
-					case "InvalidAMIID.NotFound", "InvalidSnapshot.NotFound":
-						return true
-					}
-				}
-				return false
-			},
-			RetryDelay: (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30, Multiplier: 2}).Linear,
-		}.Run(ctx, func(ctx context.Context) error {
+		err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
 			// Tag images and snapshots
 			_, err := regionConn.CreateTags(&ec2.CreateTagsInput{
 				Resources: resourceIds,
 				Tags:      amiTags,
 			})
-			if err != nil {
-				return err
+			if awsErr, ok := err.(awserr.Error); ok {
+				if awsErr.Code() == "InvalidAMIID.NotFound" ||
+					awsErr.Code() == "InvalidSnapshot.NotFound" {
+					return false, nil
+				}
 			}
 
 			// Override tags on snapshots
@@ -120,7 +110,15 @@ func (s *StepCreateTags) Run(ctx context.Context, state multistep.StateBag) mult
 					Tags:      snapshotTags,
 				})
 			}
-			return err
+			if err == nil {
+				return true, nil
+			}
+			if awsErr, ok := err.(awserr.Error); ok {
+				if awsErr.Code() == "InvalidSnapshot.NotFound" {
+					return false, nil
+				}
+			}
+			return true, err
 		})
 
 		if err != nil {

builder/amazon/common/step_deregister_ami.go

@@ -18,7 +18,7 @@ type StepDeregisterAMI struct {
 	Regions             []string
 }
 
-func (s *StepDeregisterAMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepDeregisterAMI) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	// Check for force deregister
 	if !s.ForceDeregister {
 		return multistep.ActionContinue
@@ -26,7 +26,7 @@ func (s *StepDeregisterAMI) Run(ctx context.Context, state multistep.StateBag) m
 
 	ui := state.Get("ui").(packer.Ui)
 	ec2conn := state.Get("ec2").(*ec2.EC2)
-	// Add the session region to list of regions will deregister AMIs in
+	// Add the session region to list of regions will will deregister AMIs in
 	regions := append(s.Regions, *ec2conn.Config.Region)
 
 	for _, region := range regions {
@@ -37,8 +37,8 @@ func (s *StepDeregisterAMI) Run(ctx context.Context, state multistep.StateBag) m
 		}
 
 		regionconn := ec2.New(session.Copy(&aws.Config{
-			Region: aws.String(region),
-		}))
+			Region: aws.String(region)},
+		))
 
 		resp, err := regionconn.DescribeImages(&ec2.DescribeImagesInput{
 			Owners: aws.StringSlice([]string{"self"}),

builder/amazon/common/step_encrypted_ami.go

@@ -0,0 +1,174 @@
+package common
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+)
+
+type StepCreateEncryptedAMICopy struct {
+	image             *ec2.Image
+	KeyID             string
+	EncryptBootVolume bool
+	Name              string
+	AMIMappings       []BlockDevice
+}
+
+func (s *StepCreateEncryptedAMICopy) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
+	kmsKeyId := s.KeyID
+
+	// Encrypt boot not set, so skip step
+	if !s.EncryptBootVolume {
+		if kmsKeyId != "" {
+			log.Printf("Ignoring KMS Key ID: %s, encrypted=false", kmsKeyId)
+		}
+		return multistep.ActionContinue
+	}
+
+	ui.Say("Creating Encrypted AMI Copy")
+
+	amis := state.Get("amis").(map[string]string)
+	var region, id string
+	if amis != nil {
+		for region, id = range amis {
+			break // There is only ever one region:ami pair in this map
+		}
+	}
+
+	ui.Say(fmt.Sprintf("Copying AMI: %s(%s)", region, id))
+
+	if kmsKeyId != "" {
+		ui.Say(fmt.Sprintf("Encrypting with KMS Key ID: %s", kmsKeyId))
+	}
+
+	copyOpts := &ec2.CopyImageInput{
+		Name:          &s.Name, // Try to overwrite existing AMI
+		SourceImageId: aws.String(id),
+		SourceRegion:  aws.String(region),
+		Encrypted:     aws.Bool(true),
+		KmsKeyId:      aws.String(kmsKeyId),
+	}
+
+	copyResp, err := ec2conn.CopyImage(copyOpts)
+	if err != nil {
+		err := fmt.Errorf("Error copying AMI: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Wait for the copy to become ready
+	ui.Say("Waiting for AMI copy to become ready...")
+	if err := WaitUntilAMIAvailable(ctx, ec2conn, *copyResp.ImageId); err != nil {
+		err := fmt.Errorf("Error waiting for AMI Copy: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Get the encrypted AMI image, we need the new snapshot id's
+	encImagesResp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{ImageIds: []*string{aws.String(*copyResp.ImageId)}})
+	if err != nil {
+		err := fmt.Errorf("Error searching for AMI: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+	encImage := encImagesResp.Images[0]
+	var encSnapshots []string
+	for _, blockDevice := range encImage.BlockDeviceMappings {
+		if blockDevice.Ebs != nil && blockDevice.Ebs.SnapshotId != nil {
+			encSnapshots = append(encSnapshots, *blockDevice.Ebs.SnapshotId)
+		}
+	}
+
+	// Get the unencrypted AMI image
+	unencImagesResp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{ImageIds: []*string{aws.String(id)}})
+	if err != nil {
+		err := fmt.Errorf("Error searching for AMI: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+	unencImage := unencImagesResp.Images[0]
+
+	// Remove unencrypted AMI
+	ui.Say("Deregistering unencrypted AMI")
+	deregisterOpts := &ec2.DeregisterImageInput{ImageId: aws.String(id)}
+	if _, err := ec2conn.DeregisterImage(deregisterOpts); err != nil {
+		ui.Error(fmt.Sprintf("Error deregistering AMI, may still be around: %s", err))
+		return multistep.ActionHalt
+	}
+
+	// Remove associated unencrypted snapshot(s)
+	ui.Say("Deleting unencrypted snapshots")
+	snapshots := state.Get("snapshots").(map[string][]string)
+
+OuterLoop:
+	for _, blockDevice := range unencImage.BlockDeviceMappings {
+		if blockDevice.Ebs != nil && blockDevice.Ebs.SnapshotId != nil {
+			// If this packer run didn't create it, then don't delete it
+			for _, origDevice := range s.AMIMappings {
+				if origDevice.SnapshotId == *blockDevice.Ebs.SnapshotId {
+					ui.Message(fmt.Sprintf("Keeping Snapshot ID: %s", *blockDevice.Ebs.SnapshotId))
+					continue OuterLoop
+				}
+			}
+
+			ui.Message(fmt.Sprintf("Deleting Snapshot ID: %s", *blockDevice.Ebs.SnapshotId))
+			deleteSnapOpts := &ec2.DeleteSnapshotInput{
+				SnapshotId: aws.String(*blockDevice.Ebs.SnapshotId),
+			}
+			if _, err := ec2conn.DeleteSnapshot(deleteSnapOpts); err != nil {
+				ui.Error(fmt.Sprintf("Error deleting snapshot, may still be around: %s", err))
+				return multistep.ActionHalt
+			}
+		}
+	}
+
+	// Replace original AMI ID with Encrypted ID in state
+	amis[region] = *copyResp.ImageId
+	snapshots[region] = encSnapshots
+	state.Put("amis", amis)
+	state.Put("snapshots", snapshots)
+
+	imagesResp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{ImageIds: []*string{copyResp.ImageId}})
+	if err != nil {
+		err := fmt.Errorf("Error searching for AMI: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+	s.image = imagesResp.Images[0]
+
+	return multistep.ActionContinue
+}
+
+func (s *StepCreateEncryptedAMICopy) Cleanup(state multistep.StateBag) {
+	if s.image == nil {
+		return
+	}
+
+	_, cancelled := state.GetOk(multistep.StateCancelled)
+	_, halted := state.GetOk(multistep.StateHalted)
+	if !cancelled && !halted {
+		return
+	}
+
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
+
+	ui.Say("Deregistering the AMI because cancellation or error...")
+	deregisterOpts := &ec2.DeregisterImageInput{ImageId: s.image.ImageId}
+	if _, err := ec2conn.DeregisterImage(deregisterOpts); err != nil {
+		ui.Error(fmt.Sprintf("Error deregistering AMI, may still be around: %s", err))
+		return
+	}
+}

builder/amazon/common/step_get_password.go

@@ -12,7 +12,6 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	commonhelper "github.com/hashicorp/packer/helper/common"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -27,7 +26,7 @@ type StepGetPassword struct {
 	BuildName string
 }
 
-func (s *StepGetPassword) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepGetPassword) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	// Skip if we're not using winrm
@@ -95,15 +94,13 @@ WaitLoop:
 			"Password (since debug is enabled): %s", s.Comm.WinRMPassword))
 	}
 	// store so that we can access this later during provisioning
-
-	commonhelper.SetSharedState("winrm_password", s.Comm.WinRMPassword, s.BuildName)
+	state.Put("winrm_password", s.Comm.WinRMPassword)
 	packer.LogSecretFilter.Set(s.Comm.WinRMPassword)
 
 	return multistep.ActionContinue
 }
 
 func (s *StepGetPassword) Cleanup(multistep.StateBag) {
-	commonhelper.RemoveSharedStateFile("winrm_password", s.BuildName)
 }
 
 func (s *StepGetPassword) waitForPassword(state multistep.StateBag, cancel <-chan struct{}) (string, error) {

builder/amazon/common/step_key_pair.go

@@ -3,6 +3,7 @@ package common
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"runtime"
 
@@ -20,14 +21,15 @@ type StepKeyPair struct {
 	doCleanup bool
 }
 
-func (s *StepKeyPair) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepKeyPair) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	if s.Comm.SSHPrivateKeyFile != "" {
 		ui.Say("Using existing SSH private key")
-		privateKeyBytes, err := s.Comm.ReadSSHPrivateKeyFile()
+		privateKeyBytes, err := ioutil.ReadFile(s.Comm.SSHPrivateKeyFile)
 		if err != nil {
-			state.Put("error", err)
+			state.Put("error", fmt.Errorf(
+				"Error loading configured private key file: %s", err))
 			return multistep.ActionHalt
 		}
 

builder/amazon/common/step_modify_ami_attributes.go

@@ -22,7 +22,7 @@ type StepModifyAMIAttributes struct {
 	Ctx            interpolate.Context
 }
 
-func (s *StepModifyAMIAttributes) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepModifyAMIAttributes) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	session := state.Get("awsSession").(*session.Session)
 	ui := state.Get("ui").(packer.Ui)

builder/amazon/common/step_modify_ebs_instance.go

@@ -3,7 +3,6 @@ package common
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
@@ -12,11 +11,11 @@ import (
 )
 
 type StepModifyEBSBackedInstance struct {
-	EnableAMIENASupport      *bool
+	EnableAMIENASupport      bool
 	EnableAMISriovNetSupport bool
 }
 
-func (s *StepModifyEBSBackedInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepModifyEBSBackedInstance) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	instance := state.Get("instance").(*ec2.Instance)
 	ui := state.Get("ui").(packer.Ui)
@@ -38,22 +37,16 @@ func (s *StepModifyEBSBackedInstance) Run(ctx context.Context, state multistep.S
 		}
 	}
 
-	// Handle EnaSupport flag.
+	// Set EnaSupport to true.
 	// As of February 2017, this applies to C5, I3, P2, R4, X1, and m4.16xlarge
-	if s.EnableAMIENASupport != nil {
-		var prefix string
-		if *s.EnableAMIENASupport {
-			prefix = "En"
-		} else {
-			prefix = "Dis"
-		}
-		ui.Say(fmt.Sprintf("%sabling Enhanced Networking (ENA)...", prefix))
+	if s.EnableAMIENASupport {
+		ui.Say("Enabling Enhanced Networking (ENA)...")
 		_, err := ec2conn.ModifyInstanceAttribute(&ec2.ModifyInstanceAttributeInput{
 			InstanceId: instance.InstanceId,
-			EnaSupport: &ec2.AttributeBooleanValue{Value: aws.Bool(*s.EnableAMIENASupport)},
+			EnaSupport: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
 		})
 		if err != nil {
-			err := fmt.Errorf("Error %sabling Enhanced Networking (ENA) on %s: %s", strings.ToLower(prefix), *instance.InstanceId, err)
+			err := fmt.Errorf("Error enabling Enhanced Networking (ENA) on %s: %s", *instance.InstanceId, err)
 			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt

builder/amazon/common/step_network_info.go

@@ -1,154 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"math/rand"
-	"sort"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-// StepNetworkInfo queries AWS for information about
-// VPC's and Subnets that is used throughout the AMI creation process.
-//
-// Produces (adding them to the state bag):
-//   vpc_id string - the VPC ID
-//   subnet_id string - the Subnet ID
-//   availability_zone string - the AZ name
-type StepNetworkInfo struct {
-	VpcId               string
-	VpcFilter           VpcFilterOptions
-	SubnetId            string
-	SubnetFilter        SubnetFilterOptions
-	AvailabilityZone    string
-	SecurityGroupIds    []string
-	SecurityGroupFilter SecurityGroupFilterOptions
-}
-
-type subnetsSort []*ec2.Subnet
-
-func (a subnetsSort) Len() int      { return len(a) }
-func (a subnetsSort) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a subnetsSort) Less(i, j int) bool {
-	return *a[i].AvailableIpAddressCount < *a[j].AvailableIpAddressCount
-}
-
-// Returns the most recent AMI out of a slice of images.
-func mostFreeSubnet(subnets []*ec2.Subnet) *ec2.Subnet {
-	sortedSubnets := subnets
-	sort.Sort(subnetsSort(sortedSubnets))
-	return sortedSubnets[len(sortedSubnets)-1]
-}
-
-func (s *StepNetworkInfo) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ec2conn := state.Get("ec2").(*ec2.EC2)
-	ui := state.Get("ui").(packer.Ui)
-
-	// VPC
-	if s.VpcId == "" && !s.VpcFilter.Empty() {
-		params := &ec2.DescribeVpcsInput{}
-		params.Filters = buildEc2Filters(s.VpcFilter.Filters)
-		s.VpcFilter.Filters[aws.String("state")] = aws.String("available")
-
-		log.Printf("Using VPC Filters %v", params)
-
-		vpcResp, err := ec2conn.DescribeVpcs(params)
-		if err != nil {
-			err := fmt.Errorf("Error querying VPCs: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		if len(vpcResp.Vpcs) != 1 {
-			err := fmt.Errorf("Exactly one VPC should match the filter, but %d VPC's was found matching filters: %v", len(vpcResp.Vpcs), params)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		s.VpcId = *vpcResp.Vpcs[0].VpcId
-		ui.Message(fmt.Sprintf("Found VPC ID: %s", s.VpcId))
-	}
-
-	// Subnet
-	if s.SubnetId == "" && !s.SubnetFilter.Empty() {
-		params := &ec2.DescribeSubnetsInput{}
-		s.SubnetFilter.Filters[aws.String("state")] = aws.String("available")
-
-		if s.VpcId != "" {
-			s.SubnetFilter.Filters[aws.String("vpc-id")] = &s.VpcId
-		}
-		if s.AvailabilityZone != "" {
-			s.SubnetFilter.Filters[aws.String("availability-zone")] = &s.AvailabilityZone
-		}
-		params.Filters = buildEc2Filters(s.SubnetFilter.Filters)
-		log.Printf("Using Subnet Filters %v", params)
-
-		subnetsResp, err := ec2conn.DescribeSubnets(params)
-		if err != nil {
-			err := fmt.Errorf("Error querying Subnets: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		if len(subnetsResp.Subnets) == 0 {
-			err := fmt.Errorf("No Subnets was found matching filters: %v", params)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		if len(subnetsResp.Subnets) > 1 && !s.SubnetFilter.Random && !s.SubnetFilter.MostFree {
-			err := fmt.Errorf("Your filter matched %d Subnets. Please try a more specific search, or set random or most_free to true.", len(subnetsResp.Subnets))
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		var subnet *ec2.Subnet
-		switch {
-		case s.SubnetFilter.MostFree:
-			subnet = mostFreeSubnet(subnetsResp.Subnets)
-		case s.SubnetFilter.Random:
-			subnet = subnetsResp.Subnets[rand.Intn(len(subnetsResp.Subnets))]
-		default:
-			subnet = subnetsResp.Subnets[0]
-		}
-		s.SubnetId = *subnet.SubnetId
-		ui.Message(fmt.Sprintf("Found Subnet ID: %s", s.SubnetId))
-	}
-
-	// Try to find AZ and VPC Id from Subnet if they are not yet found/given
-	if s.SubnetId != "" && (s.AvailabilityZone == "" || s.VpcId == "") {
-		log.Printf("[INFO] Finding AZ and VpcId for the given subnet '%s'", s.SubnetId)
-		resp, err := ec2conn.DescribeSubnets(&ec2.DescribeSubnetsInput{SubnetIds: []*string{&s.SubnetId}})
-		if err != nil {
-			err := fmt.Errorf("Describing the subnet: %s returned error: %s.", s.SubnetId, err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-		if s.AvailabilityZone == "" {
-			s.AvailabilityZone = *resp.Subnets[0].AvailabilityZone
-			log.Printf("[INFO] AvailabilityZone found: '%s'", s.AvailabilityZone)
-		}
-		if s.VpcId == "" {
-			s.VpcId = *resp.Subnets[0].VpcId
-			log.Printf("[INFO] VpcId found: '%s'", s.VpcId)
-		}
-	}
-
-	state.Put("vpc_id", s.VpcId)
-	state.Put("availability_zone", s.AvailabilityZone)
-	state.Put("subnet_id", s.SubnetId)
-	return multistep.ActionContinue
-}
-
-func (s *StepNetworkInfo) Cleanup(multistep.StateBag) {}

builder/amazon/common/step_pre_validate.go

@@ -3,13 +3,9 @@ package common
 import (
 	"context"
 	"fmt"
-	"log"
-	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -22,56 +18,8 @@ type StepPreValidate struct {
 	ForceDeregister bool
 }
 
-func (s *StepPreValidate) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepPreValidate) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
-
-	if accessConfig, ok := state.GetOk("access_config"); ok {
-		accessconf := accessConfig.(*AccessConfig)
-		if !accessconf.VaultAWSEngine.Empty() {
-			// loop over the authentication a few times to give vault-created creds
-			// time to become eventually-consistent
-			ui.Say("You're using Vault-generated AWS credentials. It may take a " +
-				"few moments for them to become available on AWS. Waiting...")
-			err := retry.Config{
-				Tries: 11,
-				ShouldRetry: func(err error) bool {
-					if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "AuthFailure" {
-						log.Printf("Waiting for Vault-generated AWS credentials" +
-							" to pass authentication... trying again.")
-						return true
-					}
-					return false
-				},
-				RetryDelay: (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30 * time.Second, Multiplier: 2}).Linear,
-			}.Run(ctx, func(ctx context.Context) error {
-				ec2conn, err := accessconf.NewEC2Connection()
-				if err != nil {
-					return err
-				}
-				_, err = listEC2Regions(ec2conn)
-				return err
-			})
-
-			if err != nil {
-				state.Put("error", fmt.Errorf("Was unable to Authenticate to AWS using Vault-"+
-					"Generated Credentials within the retry timeout."))
-				return multistep.ActionHalt
-			}
-		}
-
-		if amiConfig, ok := state.GetOk("ami_config"); ok {
-			amiconf := amiConfig.(*AMIConfig)
-			if !amiconf.AMISkipRegionValidation {
-				regionsToValidate := append(amiconf.AMIRegions, accessconf.RawRegion)
-				err := accessconf.ValidateRegion(regionsToValidate...)
-				if err != nil {
-					state.Put("error", fmt.Errorf("error validating regions: %v", err))
-					return multistep.ActionHalt
-				}
-			}
-		}
-	}
-
 	if s.ForceDeregister {
 		ui.Say("Force Deregister flag found, skipping prevalidating AMI Name")
 		return multistep.ActionContinue
@@ -94,7 +42,7 @@ func (s *StepPreValidate) Run(ctx context.Context, state multistep.StateBag) mul
 	}
 
 	if len(resp.Images) > 0 {
-		err := fmt.Errorf("Error: AMI Name: '%s' is used by an existing AMI: %s", *resp.Images[0].Name, *resp.Images[0].ImageId)
+		err := fmt.Errorf("Error: name conflicts with an existing AMI: %s", *resp.Images[0].ImageId)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt

builder/amazon/common/step_run_source_instance.go

@@ -6,13 +6,12 @@ import (
 	"fmt"
 	"io/ioutil"
 	"log"
-	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
 
-	"github.com/hashicorp/packer/common/retry"
+	retry "github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -21,6 +20,7 @@ import (
 
 type StepRunSourceInstance struct {
 	AssociatePublicIpAddress          bool
+	AvailabilityZone                  string
 	BlockDevices                      BlockDevices
 	Comm                              *communicator.Config
 	Ctx                               interpolate.Context
@@ -33,6 +33,7 @@ type StepRunSourceInstance struct {
 	InstanceType                      string
 	IsRestricted                      bool
 	SourceAMI                         string
+	SubnetId                          string
 	Tags                              TagMap
 	UserData                          string
 	UserDataFile                      string
@@ -103,7 +104,6 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		return multistep.ActionHalt
 	}
 
-	az := state.Get("availability_zone").(string)
 	runOpts := &ec2.RunInstancesInput{
 		ImageId:             &s.SourceAMI,
 		InstanceType:        &s.InstanceType,
@@ -112,7 +112,7 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		MinCount:            aws.Int64(1),
 		IamInstanceProfile:  &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
 		BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
-		Placement:           &ec2.Placement{AvailabilityZone: &az},
+		Placement:           &ec2.Placement{AvailabilityZone: &s.AvailabilityZone},
 		EbsOptimized:        &s.EbsOptimized,
 	}
 
@@ -153,20 +153,18 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		runOpts.KeyName = &s.Comm.SSHKeyPairName
 	}
 
-	subnetId := state.Get("subnet_id").(string)
-
-	if subnetId != "" && s.AssociatePublicIpAddress {
+	if s.SubnetId != "" && s.AssociatePublicIpAddress {
 		runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
 			{
 				DeviceIndex:              aws.Int64(0),
 				AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
-				SubnetId:                 aws.String(subnetId),
+				SubnetId:                 &s.SubnetId,
 				Groups:                   securityGroupIds,
 				DeleteOnTermination:      aws.Bool(true),
 			},
 		}
 	} else {
-		runOpts.SubnetId = aws.String(subnetId)
+		runOpts.SubnetId = &s.SubnetId
 		runOpts.SecurityGroupIds = securityGroupIds
 	}
 
@@ -231,24 +229,20 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 	if s.IsRestricted {
 		ec2Tags.Report(ui)
 		// Retry creating tags for about 2.5 minutes
-		err = retry.Config{
-			Tries: 11,
-			ShouldRetry: func(error) bool {
-				if awsErr, ok := err.(awserr.Error); ok {
-					switch awsErr.Code() {
-					case "InvalidInstanceID.NotFound":
-						return true
-					}
-				}
-				return false
-			},
-			RetryDelay: (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30 * time.Second, Multiplier: 2}).Linear,
-		}.Run(ctx, func(ctx context.Context) error {
+		err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
 			_, err := ec2conn.CreateTags(&ec2.CreateTagsInput{
 				Tags:      ec2Tags,
 				Resources: []*string{instance.InstanceId},
 			})
-			return err
+			if err == nil {
+				return true, nil
+			}
+			if awsErr, ok := err.(awserr.Error); ok {
+				if awsErr.Code() == "InvalidInstanceID.NotFound" {
+					return false, nil
+				}
+			}
+			return true, err
 		})
 
 		if err != nil {

builder/amazon/common/step_run_spot_instance.go

@@ -13,7 +13,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
 
-	"github.com/hashicorp/packer/common/retry"
+	retry "github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -22,8 +22,8 @@ import (
 
 type StepRunSpotInstance struct {
 	AssociatePublicIpAddress          bool
+	AvailabilityZone                  string
 	BlockDevices                      BlockDevices
-	BlockDurationMinutes              int64
 	Debug                             bool
 	Comm                              *communicator.Config
 	EbsOptimized                      bool
@@ -35,6 +35,7 @@ type StepRunSpotInstance struct {
 	SpotPrice                         string
 	SpotPriceProduct                  string
 	SpotTags                          TagMap
+	SubnetId                          string
 	Tags                              TagMap
 	VolumeTags                        TagMap
 	UserData                          string
@@ -84,12 +85,7 @@ func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag)
 	}
 
 	spotPrice := s.SpotPrice
-	azConfig := ""
-	if azRaw, ok := state.GetOk("availability_zone"); ok {
-		azConfig = azRaw.(string)
-	}
-	az := azConfig
-
+	availabilityZone := s.AvailabilityZone
 	if spotPrice == "auto" {
 		ui.Message(fmt.Sprintf(
 			"Finding spot price for %s %s...",
@@ -100,7 +96,7 @@ func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag)
 		resp, err := ec2conn.DescribeSpotPriceHistory(&ec2.DescribeSpotPriceHistoryInput{
 			InstanceTypes:       []*string{&s.InstanceType},
 			ProductDescriptions: []*string{&s.SpotPriceProduct},
-			AvailabilityZone:    &az,
+			AvailabilityZone:    &s.AvailabilityZone,
 			StartTime:           &startTime,
 		})
 		if err != nil {
@@ -120,8 +116,8 @@ func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag)
 			}
 			if price == 0 || current < price {
 				price = current
-				if azConfig == "" {
-					az = *history.AvailabilityZone
+				if s.AvailabilityZone == "" {
+					availabilityZone = *history.AvailabilityZone
 				}
 			}
 		}
@@ -165,41 +161,35 @@ func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag)
 		UserData:           &userData,
 		IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
 		Placement: &ec2.SpotPlacement{
-			AvailabilityZone: &az,
+			AvailabilityZone: &availabilityZone,
 		},
 		BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
 		EbsOptimized:        &s.EbsOptimized,
 	}
 
-	subnetId := state.Get("subnet_id").(string)
-
-	if subnetId != "" && s.AssociatePublicIpAddress {
+	if s.SubnetId != "" && s.AssociatePublicIpAddress {
 		runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
 			{
 				DeviceIndex:              aws.Int64(0),
 				AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
-				SubnetId:                 &subnetId,
+				SubnetId:                 &s.SubnetId,
 				Groups:                   securityGroupIds,
 				DeleteOnTermination:      aws.Bool(true),
 			},
 		}
 	} else {
-		runOpts.SubnetId = &subnetId
+		runOpts.SubnetId = &s.SubnetId
 		runOpts.SecurityGroupIds = securityGroupIds
 	}
 
 	if s.Comm.SSHKeyPairName != "" {
 		runOpts.KeyName = &s.Comm.SSHKeyPairName
 	}
-	spotInstanceInput := &ec2.RequestSpotInstancesInput{
-		LaunchSpecification: runOpts,
-		SpotPrice:           &spotPrice,
-	}
-	if s.BlockDurationMinutes != 0 {
-		spotInstanceInput.BlockDurationMinutes = &s.BlockDurationMinutes
-	}
 
-	runSpotResp, err := ec2conn.RequestSpotInstances(spotInstanceInput)
+	runSpotResp, err := ec2conn.RequestSpotInstances(&ec2.RequestSpotInstancesInput{
+		SpotPrice:           &spotPrice,
+		LaunchSpecification: runOpts,
+	})
 	if err != nil {
 		err := fmt.Errorf("Error launching source spot instance: %s", err)
 		state.Put("error", err)
@@ -241,16 +231,13 @@ func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag)
 	spotTags.Report(ui)
 
 	if len(spotTags) > 0 && s.SpotTags.IsSet() {
-		err = retry.Config{
-			Tries:       11,
-			ShouldRetry: func(error) bool { return false },
-			RetryDelay:  (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30 * time.Second, Multiplier: 2}).Linear,
-		}.Run(ctx, func(ctx context.Context) error {
+		// Retry creating tags for about 2.5 minutes
+		err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
 			_, err := ec2conn.CreateTags(&ec2.CreateTagsInput{
 				Tags:      spotTags,
 				Resources: []*string{spotRequestId},
 			})
-			return err
+			return true, err
 		})
 		if err != nil {
 			err := fmt.Errorf("Error tagging spot request: %s", err)
@@ -287,24 +274,20 @@ func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag)
 	instance := r.Reservations[0].Instances[0]
 
 	// Retry creating tags for about 2.5 minutes
-	err = retry.Config{
-		Tries: 11,
-		ShouldRetry: func(error) bool {
-			if awsErr, ok := err.(awserr.Error); ok {
-				switch awsErr.Code() {
-				case "InvalidInstanceID.NotFound":
-					return true
-				}
-			}
-			return false
-		},
-		RetryDelay: (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30 * time.Second, Multiplier: 2}).Linear,
-	}.Run(ctx, func(ctx context.Context) error {
+	err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
 		_, err := ec2conn.CreateTags(&ec2.CreateTagsInput{
 			Tags:      ec2Tags,
 			Resources: []*string{instance.InstanceId},
 		})
-		return err
+		if err == nil {
+			return true, nil
+		}
+		if awsErr, ok := err.(awserr.Error); ok {
+			if awsErr.Code() == "InvalidInstanceID.NotFound" {
+				return false, nil
+			}
+		}
+		return true, err
 	})
 
 	if err != nil {

builder/amazon/common/step_security_group.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"log"
-	"strings"
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
@@ -17,18 +16,17 @@ import (
 )
 
 type StepSecurityGroup struct {
-	CommConfig             *communicator.Config
-	SecurityGroupFilter    SecurityGroupFilterOptions
-	SecurityGroupIds       []string
-	TemporarySGSourceCidrs []string
+	CommConfig            *communicator.Config
+	SecurityGroupIds      []string
+	VpcId                 string
+	TemporarySGSourceCidr string
 
 	createdGroupId string
 }
 
-func (s *StepSecurityGroup) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepSecurityGroup) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
-	vpcId := state.Get("vpc_id").(string)
 
 	if len(s.SecurityGroupIds) > 0 {
 		_, err := ec2conn.DescribeSecurityGroups(
@@ -47,35 +45,6 @@ func (s *StepSecurityGroup) Run(ctx context.Context, state multistep.StateBag) m
 		return multistep.ActionContinue
 	}
 
-	if !s.SecurityGroupFilter.Empty() {
-
-		params := &ec2.DescribeSecurityGroupsInput{}
-		if vpcId != "" {
-			s.SecurityGroupFilter.Filters[aws.String("vpc-id")] = &vpcId
-		}
-		params.Filters = buildEc2Filters(s.SecurityGroupFilter.Filters)
-
-		log.Printf("Using SecurityGroup Filters %v", params)
-
-		sgResp, err := ec2conn.DescribeSecurityGroups(params)
-		if err != nil {
-			err := fmt.Errorf("Couldn't find security groups for filter: %s", err)
-			log.Printf("[DEBUG] %s", err.Error())
-			state.Put("error", err)
-			return multistep.ActionHalt
-		}
-
-		securityGroupIds := []string{}
-		for _, sg := range sgResp.SecurityGroups {
-			securityGroupIds = append(securityGroupIds, *sg.GroupId)
-		}
-
-		ui.Message(fmt.Sprintf("Found Security Group(s): %s", strings.Join(securityGroupIds, ", ")))
-		state.Put("securityGroupIds", securityGroupIds)
-
-		return multistep.ActionContinue
-	}
-
 	port := s.CommConfig.Port()
 	if port == 0 {
 		if s.CommConfig.Type != "none" {
@@ -91,7 +60,9 @@ func (s *StepSecurityGroup) Run(ctx context.Context, state multistep.StateBag) m
 		Description: aws.String("Temporary group for Packer"),
 	}
 
-	group.VpcId = &vpcId
+	if s.VpcId != "" {
+		group.VpcId = &s.VpcId
+	}
 
 	groupResp, err := ec2conn.CreateSecurityGroup(group)
 	if err != nil {
@@ -103,7 +74,38 @@ func (s *StepSecurityGroup) Run(ctx context.Context, state multistep.StateBag) m
 	// Set the group ID so we can delete it later
 	s.createdGroupId = *groupResp.GroupId
 
-	// Wait for the security group become available for authorizing
+	// Authorize the SSH access for the security group
+	req := &ec2.AuthorizeSecurityGroupIngressInput{
+		GroupId:    groupResp.GroupId,
+		IpProtocol: aws.String("tcp"),
+		FromPort:   aws.Int64(int64(port)),
+		ToPort:     aws.Int64(int64(port)),
+		CidrIp:     aws.String(s.TemporarySGSourceCidr),
+	}
+
+	// We loop and retry this a few times because sometimes the security
+	// group isn't available immediately because AWS resources are eventually
+	// consistent.
+	ui.Say(fmt.Sprintf(
+		"Authorizing access to port %d from %s in the temporary security group...",
+		port, s.TemporarySGSourceCidr))
+	for i := 0; i < 5; i++ {
+		_, err = ec2conn.AuthorizeSecurityGroupIngress(req)
+		if err == nil {
+			break
+		}
+
+		log.Printf("Error authorizing. Will sleep and retry. %s", err)
+		time.Sleep((time.Duration(i) * time.Second) + 1)
+	}
+
+	if err != nil {
+		err := fmt.Errorf("Error creating temporary security group: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
 	log.Printf("[DEBUG] Waiting for temporary security group: %s", s.createdGroupId)
 	err = waitUntilSecurityGroupExists(ec2conn,
 		&ec2.DescribeSecurityGroupsInput{
@@ -119,41 +121,6 @@ func (s *StepSecurityGroup) Run(ctx context.Context, state multistep.StateBag) m
 		return multistep.ActionHalt
 	}
 
-	// map the list of temporary security group CIDRs bundled with config to
-	// types expected by EC2.
-	groupIpRanges := []*ec2.IpRange{}
-	for _, cidr := range s.TemporarySGSourceCidrs {
-		ipRange := ec2.IpRange{
-			CidrIp: aws.String(cidr),
-		}
-		groupIpRanges = append(groupIpRanges, &ipRange)
-	}
-
-	// Authorize the SSH access for the security group
-	groupRules := &ec2.AuthorizeSecurityGroupIngressInput{
-		GroupId: groupResp.GroupId,
-		IpPermissions: []*ec2.IpPermission{
-			{
-				FromPort:   aws.Int64(int64(port)),
-				ToPort:     aws.Int64(int64(port)),
-				IpRanges:   groupIpRanges,
-				IpProtocol: aws.String("tcp"),
-			},
-		},
-	}
-
-	ui.Say(fmt.Sprintf(
-		"Authorizing access to port %d from %v in the temporary security groups...",
-		port, s.TemporarySGSourceCidrs),
-	)
-	_, err = ec2conn.AuthorizeSecurityGroupIngress(groupRules)
-	if err != nil {
-		err := fmt.Errorf("Error authorizing temporary security group: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
 	// Set some state data for use in future steps
 	state.Put("securityGroupIds", []string{s.createdGroupId})
 

builder/amazon/common/step_source_ami_info.go

@@ -20,11 +20,22 @@ import (
 type StepSourceAMIInfo struct {
 	SourceAmi                string
 	EnableAMISriovNetSupport bool
-	EnableAMIENASupport      *bool
-	AMIVirtType              string
+	EnableAMIENASupport      bool
 	AmiFilters               AmiFilterOptions
 }
 
+// Build a slice of AMI filter options from the filters provided.
+func buildAmiFilters(input map[*string]*string) []*ec2.Filter {
+	var filters []*ec2.Filter
+	for k, v := range input {
+		filters = append(filters, &ec2.Filter{
+			Name:   k,
+			Values: []*string{v},
+		})
+	}
+	return filters
+}
+
 type imageSort []*ec2.Image
 
 func (a imageSort) Len() int      { return len(a) }
@@ -42,7 +53,7 @@ func mostRecentAmi(images []*ec2.Image) *ec2.Image {
 	return sortedImages[len(sortedImages)-1]
 }
 
-func (s *StepSourceAMIInfo) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepSourceAMIInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
@@ -54,7 +65,7 @@ func (s *StepSourceAMIInfo) Run(ctx context.Context, state multistep.StateBag) m
 
 	// We have filters to apply
 	if len(s.AmiFilters.Filters) > 0 {
-		params.Filters = buildEc2Filters(s.AmiFilters.Filters)
+		params.Filters = buildAmiFilters(s.AmiFilters.Filters)
 	}
 	if len(s.AmiFilters.Owners) > 0 {
 		params.Owners = s.AmiFilters.Owners
@@ -94,13 +105,11 @@ func (s *StepSourceAMIInfo) Run(ctx context.Context, state multistep.StateBag) m
 
 	// Enhanced Networking can only be enabled on HVM AMIs.
 	// See http://goo.gl/icuXh5
-	if (s.EnableAMIENASupport != nil && *s.EnableAMIENASupport) || s.EnableAMISriovNetSupport {
-		err = s.canEnableEnhancedNetworking(image)
-		if err != nil {
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
+	if (s.EnableAMIENASupport || s.EnableAMISriovNetSupport) && *image.VirtualizationType != "hvm" {
+		err := fmt.Errorf("Cannot enable enhanced networking, source AMI '%s' is not HVM", s.SourceAmi)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
 
 	state.Put("source_image", image)
@@ -108,16 +117,3 @@ func (s *StepSourceAMIInfo) Run(ctx context.Context, state multistep.StateBag) m
 }
 
 func (s *StepSourceAMIInfo) Cleanup(multistep.StateBag) {}
-
-func (s *StepSourceAMIInfo) canEnableEnhancedNetworking(image *ec2.Image) error {
-	if s.AMIVirtType == "hvm" {
-		return nil
-	}
-	if s.AMIVirtType != "" {
-		return fmt.Errorf("Cannot enable enhanced networking, AMIVirtType '%s' is not HVM", s.AMIVirtType)
-	}
-	if *image.VirtualizationType != "hvm" {
-		return fmt.Errorf("Cannot enable enhanced networking, source AMI '%s' is not HVM", s.SourceAmi)
-	}
-	return nil
-}

builder/amazon/common/step_source_ami_info_test.go

@@ -1,43 +0,0 @@
-package common
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestStepSourceAmiInfo_PVImage(t *testing.T) {
-	err := new(StepSourceAMIInfo).canEnableEnhancedNetworking(&ec2.Image{
-		VirtualizationType: aws.String("paravirtual"),
-	})
-	assert.Error(t, err)
-}
-
-func TestStepSourceAmiInfo_HVMImage(t *testing.T) {
-	err := new(StepSourceAMIInfo).canEnableEnhancedNetworking(&ec2.Image{
-		VirtualizationType: aws.String("hvm"),
-	})
-	assert.NoError(t, err)
-}
-
-func TestStepSourceAmiInfo_PVImageWithAMIVirtPV(t *testing.T) {
-	stepSourceAMIInfo := StepSourceAMIInfo{
-		AMIVirtType: "paravirtual",
-	}
-	err := stepSourceAMIInfo.canEnableEnhancedNetworking(&ec2.Image{
-		VirtualizationType: aws.String("paravirtual"),
-	})
-	assert.Error(t, err)
-}
-
-func TestStepSourceAmiInfo_PVImageWithAMIVirtHVM(t *testing.T) {
-	stepSourceAMIInfo := StepSourceAMIInfo{
-		AMIVirtType: "hvm",
-	}
-	err := stepSourceAMIInfo.canEnableEnhancedNetworking(&ec2.Image{
-		VirtualizationType: aws.String("paravirtual"),
-	})
-	assert.NoError(t, err)
-}

builder/amazon/common/step_stop_ebs_instance.go

@@ -3,11 +3,10 @@ package common
 import (
 	"context"
 	"fmt"
-	"time"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common/retry"
+	"github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -41,26 +40,29 @@ func (s *StepStopEBSBackedInstance) Run(ctx context.Context, state multistep.Sta
 		// does not exist.
 
 		// Work around this by retrying a few times, up to about 5 minutes.
-		err := retry.Config{
-			Tries: 6,
-			ShouldRetry: func(error) bool {
-				if awsErr, ok := err.(awserr.Error); ok {
-					switch awsErr.Code() {
-					case "InvalidInstanceID.NotFound":
-						return true
-					}
-				}
-				return false
-			},
-			RetryDelay: (&retry.Backoff{InitialBackoff: 10 * time.Second, MaxBackoff: 60 * time.Second, Multiplier: 2}).Linear,
-		}.Run(ctx, func(ctx context.Context) error {
-			ui.Message(fmt.Sprintf("Stopping instance"))
+		err := common.Retry(10, 60, 6, func(i uint) (bool, error) {
+			ui.Message(fmt.Sprintf("Stopping instance, attempt %d", i+1))
 
 			_, err = ec2conn.StopInstances(&ec2.StopInstancesInput{
 				InstanceIds: []*string{instance.InstanceId},
 			})
 
-			return err
+			if err == nil {
+				// success
+				return true, nil
+			}
+
+			if awsErr, ok := err.(awserr.Error); ok {
+				if awsErr.Code() == "InvalidInstanceID.NotFound" {
+					ui.Message(fmt.Sprintf(
+						"Error stopping instance; will retry ..."+
+							"Error: %s", err))
+					// retry
+					return false, nil
+				}
+			}
+			// errored, but not in expected way. Don't want to retry
+			return true, err
 		})
 
 		if err != nil {

builder/amazon/common/tags.go

@@ -24,16 +24,16 @@ func (t TagMap) IsSet() bool {
 	return len(t) > 0
 }
 
-func (t TagMap) EC2Tags(ictx interpolate.Context, region string, state multistep.StateBag) (EC2Tags, error) {
+func (t TagMap) EC2Tags(ctx interpolate.Context, region string, state multistep.StateBag) (EC2Tags, error) {
 	var ec2Tags []*ec2.Tag
-	ictx.Data = extractBuildInfo(region, state)
+	ctx.Data = extractBuildInfo(region, state)
 
 	for key, value := range t {
-		interpolatedKey, err := interpolate.Render(key, &ictx)
+		interpolatedKey, err := interpolate.Render(key, &ctx)
 		if err != nil {
 			return nil, fmt.Errorf("Error processing tag: %s:%s - %s", key, value, err)
 		}
-		interpolatedValue, err := interpolate.Render(value, &ictx)
+		interpolatedValue, err := interpolate.Render(value, &ctx)
 		if err != nil {
 			return nil, fmt.Errorf("Error processing tag: %s:%s - %s", key, value, err)
 		}

builder/amazon/common/template_funcs.go

@@ -3,8 +3,6 @@ package common
 import (
 	"bytes"
 	"text/template"
-
-	packertpl "github.com/hashicorp/packer/common/template"
 )
 
 func isalphanumeric(b byte) bool {
@@ -38,6 +36,5 @@ func templateCleanAMIName(s string) string {
 }
 
 var TemplateFuncs = template.FuncMap{
-	"clean_resource_name": templateCleanAMIName,
-	"clean_ami_name":      packertpl.DeprecatedTemplateFunc("clean_ami_name", "clean_resource_name", templateCleanAMIName),
+	"clean_ami_name": templateCleanAMIName,
 }

builder/amazon/ebs/builder.go

@@ -6,8 +6,8 @@
 package ebs
 
 import (
-	"context"
 	"fmt"
+	"log"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
@@ -70,7 +70,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	errs = packer.MultiErrorAppend(errs, b.config.BlockDevices.Prepare(&b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(&b.config.ctx)...)
 
-	if b.config.IsSpotInstance() && ((b.config.AMIENASupport != nil && *b.config.AMIENASupport) || b.config.AMISriovNetSupport) {
+	if b.config.IsSpotInstance() && (b.config.AMIENASupport || b.config.AMISriovNetSupport) {
 		errs = packer.MultiErrorAppend(errs,
 			fmt.Errorf("Spot instances do not support modification, which is required "+
 				"when either `ena_support` or `sriov_support` are set. Please ensure "+
@@ -82,23 +82,38 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	packer.LogSecretFilter.Set(b.config.AccessKey, b.config.SecretKey, b.config.Token)
+	log.Println(b.config)
 	return nil, nil
 }
 
-func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
 
 	session, err := b.config.Session()
 	if err != nil {
 		return nil, err
 	}
-
 	ec2conn := ec2.New(session)
 
+	// If the subnet is specified but not the VpcId or AZ, try to determine them automatically
+	if b.config.SubnetId != "" && (b.config.AvailabilityZone == "" || b.config.VpcId == "") {
+		log.Printf("[INFO] Finding AZ and VpcId for the given subnet '%s'", b.config.SubnetId)
+		resp, err := ec2conn.DescribeSubnets(&ec2.DescribeSubnetsInput{SubnetIds: []*string{&b.config.SubnetId}})
+		if err != nil {
+			return nil, err
+		}
+		if b.config.AvailabilityZone == "" {
+			b.config.AvailabilityZone = *resp.Subnets[0].AvailabilityZone
+			log.Printf("[INFO] AvailabilityZone found: '%s'", b.config.AvailabilityZone)
+		}
+		if b.config.VpcId == "" {
+			b.config.VpcId = *resp.Subnets[0].VpcId
+			log.Printf("[INFO] VpcId found: '%s'", b.config.VpcId)
+		}
+	}
+
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
-	state.Put("config", &b.config)
-	state.Put("access_config", &b.config.AccessConfig)
-	state.Put("ami_config", &b.config.AMIConfig)
+	state.Put("config", b.config)
 	state.Put("ec2", ec2conn)
 	state.Put("awsSession", session)
 	state.Put("hook", hook)
@@ -109,10 +124,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	if b.config.IsSpotInstance() {
 		instanceStep = &awscommon.StepRunSpotInstance{
 			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
+			AvailabilityZone:                  b.config.AvailabilityZone,
 			BlockDevices:                      b.config.BlockDevices,
-			BlockDurationMinutes:              b.config.BlockDurationMinutes,
 			Ctx:                               b.config.ctx,
-			Comm:                              &b.config.RunConfig.Comm,
 			Debug:                             b.config.PackerDebug,
 			EbsOptimized:                      b.config.EbsOptimized,
 			ExpectedRootDevice:                "ebs",
@@ -123,6 +137,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SpotPrice:                         b.config.SpotPrice,
 			SpotPriceProduct:                  b.config.SpotPriceAutoProduct,
 			SpotTags:                          b.config.SpotTags,
+			SubnetId:                          b.config.SubnetId,
 			Tags:                              b.config.RunTags,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
@@ -131,6 +146,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	} else {
 		instanceStep = &awscommon.StepRunSourceInstance{
 			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
+			AvailabilityZone:                  b.config.AvailabilityZone,
 			BlockDevices:                      b.config.BlockDevices,
 			Comm:                              &b.config.RunConfig.Comm,
 			Ctx:                               b.config.ctx,
@@ -143,6 +159,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			InstanceType:                      b.config.InstanceType,
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                         b.config.SourceAmi,
+			SubnetId:                          b.config.SubnetId,
 			Tags:                              b.config.RunTags,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
@@ -161,16 +178,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
 			EnableAMIENASupport:      b.config.AMIENASupport,
 			AmiFilters:               b.config.SourceAmiFilter,
-			AMIVirtType:              b.config.AMIVirtType,
-		},
-		&awscommon.StepNetworkInfo{
-			VpcId:               b.config.VpcId,
-			VpcFilter:           b.config.VpcFilter,
-			SecurityGroupIds:    b.config.SecurityGroupIds,
-			SecurityGroupFilter: b.config.SecurityGroupFilter,
-			SubnetId:            b.config.SubnetId,
-			SubnetFilter:        b.config.SubnetFilter,
-			AvailabilityZone:    b.config.AvailabilityZone,
 		},
 		&awscommon.StepKeyPair{
 			Debug:        b.config.PackerDebug,
@@ -178,10 +185,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			DebugKeyPath: fmt.Sprintf("ec2_%s.pem", b.config.PackerBuildName),
 		},
 		&awscommon.StepSecurityGroup{
-			SecurityGroupFilter:    b.config.SecurityGroupFilter,
-			SecurityGroupIds:       b.config.SecurityGroupIds,
-			CommConfig:             &b.config.RunConfig.Comm,
-			TemporarySGSourceCidrs: b.config.TemporarySGSourceCidrs,
+			SecurityGroupIds:      b.config.SecurityGroupIds,
+			CommConfig:            &b.config.RunConfig.Comm,
+			VpcId:                 b.config.VpcId,
+			TemporarySGSourceCidr: b.config.TemporarySGSourceCidr,
 		},
 		&awscommon.StepCleanupVolumes{
 			BlockDevices: b.config.BlockDevices,
@@ -201,9 +208,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
 		},
 		&common.StepProvision{},
-		&common.StepCleanupTempKeys{
-			Comm: &b.config.RunConfig.Comm,
-		},
 		&awscommon.StepStopEBSBackedInstance{
 			Skip:                b.config.IsSpotInstance(),
 			DisableStopInstance: b.config.DisableStopInstance,
@@ -220,6 +224,12 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			Regions:             b.config.AMIRegions,
 		},
 		&stepCreateAMI{},
+		&awscommon.StepCreateEncryptedAMICopy{
+			KeyID:             b.config.AMIKmsKeyId,
+			EncryptBootVolume: b.config.AMIEncryptBootVolume,
+			Name:              b.config.AMIName,
+			AMIMappings:       b.config.AMIBlockDevices.AMIMappings,
+		},
 		&awscommon.StepAMIRegionCopy{
 			AccessConfig:      &b.config.AccessConfig,
 			Regions:           b.config.AMIRegions,
@@ -245,7 +255,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	// Run!
 	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
-	b.runner.Run(ctx, state)
+	b.runner.Run(state)
 	// If there was an error, return that
 	if rawErr, ok := state.GetOk("error"); ok {
 		return nil, rawErr.(error)
@@ -265,3 +275,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	return artifact, nil
 }
+
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}

builder/amazon/ebs/builder_test.go

@@ -47,7 +47,6 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 
 	// Test good
 	config["ami_name"] = "foo"
-	config["skip_region_validation"] = true
 	warnings, err := b.Prepare(config)
 	if len(warnings) > 0 {
 		t.Fatalf("bad: %#v", warnings)
@@ -100,7 +99,6 @@ func TestBuilderPrepare_InvalidShutdownBehavior(t *testing.T) {
 
 	// Test good
 	config["shutdown_behavior"] = "terminate"
-	config["skip_region_validation"] = true
 	warnings, err := b.Prepare(config)
 	if len(warnings) > 0 {
 		t.Fatalf("bad: %#v", warnings)

builder/amazon/ebs/step_create_ami.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/common/random"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -17,23 +16,16 @@ type stepCreateAMI struct {
 }
 
 func (s *stepCreateAMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(Config)
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	instance := state.Get("instance").(*ec2.Instance)
 	ui := state.Get("ui").(packer.Ui)
 
 	// Create the image
-	amiName := config.AMIName
-	if config.AMIEncryptBootVolume != nil {
-		// encrypt_boot was set, so we will create a temporary image
-		// and then create a copy of it with the correct encrypt_boot
-		amiName = random.AlphaNum(7)
-	}
-
-	ui.Say(fmt.Sprintf("Creating AMI %s from instance %s", amiName, *instance.InstanceId))
+	ui.Say(fmt.Sprintf("Creating the AMI: %s", config.AMIName))
 	createOpts := &ec2.CreateImageInput{
 		InstanceId:          instance.InstanceId,
-		Name:                &amiName,
+		Name:                &config.AMIName,
 		BlockDeviceMappings: config.BlockDevices.BuildAMIDevices(),
 	}
 
@@ -94,19 +86,17 @@ func (s *stepCreateAMI) Cleanup(state multistep.StateBag) {
 	if s.image == nil {
 		return
 	}
-	config := state.Get("config").(*Config)
 
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
-	encryptBootSet := config.AMIEncryptBootVolume != nil
-	if !cancelled && !halted && !encryptBootSet {
+	if !cancelled && !halted {
 		return
 	}
 
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
-	ui.Say("Deregistering the AMI because cancellation, error or it was temporary (encrypt_boot was set)...")
+	ui.Say("Deregistering the AMI because cancellation or error...")
 	deregisterOpts := &ec2.DeregisterImageInput{ImageId: s.image.ImageId}
 	if _, err := ec2conn.DeregisterImage(deregisterOpts); err != nil {
 		ui.Error(fmt.Sprintf("Error deregistering AMI, may still be around: %s", err))

builder/amazon/ebssurrogate/builder.go

@@ -3,9 +3,9 @@
 package ebssurrogate
 
 import (
-	"context"
 	"errors"
 	"fmt"
+	"log"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
@@ -85,7 +85,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("no volume with name '%s' is found", b.config.RootDevice.SourceDeviceName))
 	}
 
-	if b.config.IsSpotInstance() && ((b.config.AMIENASupport != nil && *b.config.AMIENASupport) || b.config.AMISriovNetSupport) {
+	if b.config.IsSpotInstance() && (b.config.AMIENASupport || b.config.AMISriovNetSupport) {
 		errs = packer.MultiErrorAppend(errs,
 			fmt.Errorf("Spot instances do not support modification, which is required "+
 				"when either `ena_support` or `sriov_support` are set. Please ensure "+
@@ -97,21 +97,37 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	packer.LogSecretFilter.Set(b.config.AccessKey, b.config.SecretKey, b.config.Token)
+	log.Println(b.config)
 	return nil, nil
 }
 
-func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
 	session, err := b.config.Session()
 	if err != nil {
 		return nil, err
 	}
 	ec2conn := ec2.New(session)
 
+	// If the subnet is specified but not the VpcId or AZ, try to determine them automatically
+	if b.config.SubnetId != "" && (b.config.AvailabilityZone == "" || b.config.VpcId == "") {
+		log.Printf("[INFO] Finding AZ and VpcId for the given subnet '%s'", b.config.SubnetId)
+		resp, err := ec2conn.DescribeSubnets(&ec2.DescribeSubnetsInput{SubnetIds: []*string{&b.config.SubnetId}})
+		if err != nil {
+			return nil, err
+		}
+		if b.config.AvailabilityZone == "" {
+			b.config.AvailabilityZone = *resp.Subnets[0].AvailabilityZone
+			log.Printf("[INFO] AvailabilityZone found: '%s'", b.config.AvailabilityZone)
+		}
+		if b.config.VpcId == "" {
+			b.config.VpcId = *resp.Subnets[0].VpcId
+			log.Printf("[INFO] VpcId found: '%s'", b.config.VpcId)
+		}
+	}
+
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
-	state.Put("access_config", &b.config.AccessConfig)
-	state.Put("ami_config", &b.config.AMIConfig)
 	state.Put("ec2", ec2conn)
 	state.Put("awsSession", session)
 	state.Put("hook", hook)
@@ -122,10 +138,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	if b.config.IsSpotInstance() {
 		instanceStep = &awscommon.StepRunSpotInstance{
 			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
+			AvailabilityZone:                  b.config.AvailabilityZone,
 			BlockDevices:                      b.config.BlockDevices,
-			BlockDurationMinutes:              b.config.BlockDurationMinutes,
 			Ctx:                               b.config.ctx,
-			Comm:                              &b.config.RunConfig.Comm,
 			Debug:                             b.config.PackerDebug,
 			EbsOptimized:                      b.config.EbsOptimized,
 			ExpectedRootDevice:                "ebs",
@@ -136,6 +151,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SpotPrice:                         b.config.SpotPrice,
 			SpotPriceProduct:                  b.config.SpotPriceAutoProduct,
 			SpotTags:                          b.config.SpotTags,
+			SubnetId:                          b.config.SubnetId,
 			Tags:                              b.config.RunTags,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
@@ -144,6 +160,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	} else {
 		instanceStep = &awscommon.StepRunSourceInstance{
 			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
+			AvailabilityZone:                  b.config.AvailabilityZone,
 			BlockDevices:                      b.config.BlockDevices,
 			Comm:                              &b.config.RunConfig.Comm,
 			Ctx:                               b.config.ctx,
@@ -156,6 +173,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			InstanceType:                      b.config.InstanceType,
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                         b.config.SourceAmi,
+			SubnetId:                          b.config.SubnetId,
 			Tags:                              b.config.RunTags,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
@@ -177,16 +195,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
 			EnableAMIENASupport:      b.config.AMIENASupport,
 			AmiFilters:               b.config.SourceAmiFilter,
-			AMIVirtType:              b.config.AMIVirtType,
-		},
-		&awscommon.StepNetworkInfo{
-			VpcId:               b.config.VpcId,
-			VpcFilter:           b.config.VpcFilter,
-			SecurityGroupIds:    b.config.SecurityGroupIds,
-			SecurityGroupFilter: b.config.SecurityGroupFilter,
-			SubnetId:            b.config.SubnetId,
-			SubnetFilter:        b.config.SubnetFilter,
-			AvailabilityZone:    b.config.AvailabilityZone,
 		},
 		&awscommon.StepKeyPair{
 			Debug:        b.config.PackerDebug,
@@ -194,10 +202,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			DebugKeyPath: fmt.Sprintf("ec2_%s.pem", b.config.PackerBuildName),
 		},
 		&awscommon.StepSecurityGroup{
-			SecurityGroupFilter:    b.config.SecurityGroupFilter,
-			SecurityGroupIds:       b.config.SecurityGroupIds,
-			CommConfig:             &b.config.RunConfig.Comm,
-			TemporarySGSourceCidrs: b.config.TemporarySGSourceCidrs,
+			SecurityGroupIds:      b.config.SecurityGroupIds,
+			CommConfig:            &b.config.RunConfig.Comm,
+			VpcId:                 b.config.VpcId,
+			TemporarySGSourceCidr: b.config.TemporarySGSourceCidr,
 		},
 		&awscommon.StepCleanupVolumes{
 			BlockDevices: b.config.BlockDevices,
@@ -217,9 +225,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
 		},
 		&common.StepProvision{},
-		&common.StepCleanupTempKeys{
-			Comm: &b.config.RunConfig.Comm,
-		},
 		&awscommon.StepStopEBSBackedInstance{
 			Skip:                b.config.IsSpotInstance(),
 			DisableStopInstance: b.config.DisableStopInstance,
@@ -245,6 +250,11 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
 			EnableAMIENASupport:      b.config.AMIENASupport,
 		},
+		&awscommon.StepCreateEncryptedAMICopy{
+			KeyID:             b.config.AMIKmsKeyId,
+			EncryptBootVolume: b.config.AMIEncryptBootVolume,
+			Name:              b.config.AMIName,
+		},
 		&awscommon.StepAMIRegionCopy{
 			AccessConfig:      &b.config.AccessConfig,
 			Regions:           b.config.AMIRegions,
@@ -270,7 +280,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	// Run!
 	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
-	b.runner.Run(ctx, state)
+	b.runner.Run(state)
 
 	// If there was an error, return that
 	if rawErr, ok := state.GetOk("error"); ok {
@@ -290,3 +300,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	return nil, nil
 }
+
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}

builder/amazon/ebssurrogate/step_register_ami.go

@@ -16,7 +16,7 @@ type StepRegisterAMI struct {
 	RootDevice               RootBlockDevice
 	AMIDevices               []*ec2.BlockDeviceMapping
 	LaunchDevices            []*ec2.BlockDeviceMapping
-	EnableAMIENASupport      *bool
+	EnableAMIENASupport      bool
 	EnableAMISriovNetSupport bool
 	image                    *ec2.Image
 }
@@ -44,7 +44,7 @@ func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) mul
 		// As of February 2017, this applies to C3, C4, D2, I2, R3, and M4 (excluding m4.16xlarge)
 		registerOpts.SriovNetSupport = aws.String("simple")
 	}
-	if s.EnableAMIENASupport != nil && *s.EnableAMIENASupport {
+	if s.EnableAMIENASupport {
 		// Set EnaSupport to true
 		// As of February 2017, this applies to C5, I3, P2, R4, X1, and m4.16xlarge
 		registerOpts.EnaSupport = aws.Bool(true)

builder/amazon/ebsvolume/builder.go

@@ -3,8 +3,8 @@
 package ebsvolume
 
 import (
-	"context"
 	"fmt"
+	"log"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
@@ -24,7 +24,7 @@ type Config struct {
 	awscommon.RunConfig    `mapstructure:",squash"`
 
 	VolumeMappings     []BlockDevice `mapstructure:"ebs_volumes"`
-	AMIENASupport      *bool         `mapstructure:"ena_support"`
+	AMIENASupport      bool          `mapstructure:"ena_support"`
 	AMISriovNetSupport bool          `mapstructure:"sriov_support"`
 
 	launchBlockDevices awscommon.BlockDevices
@@ -36,22 +36,18 @@ type Builder struct {
 	runner multistep.Runner
 }
 
-type EngineVarsTemplate struct {
-	BuildRegion string
-	SourceAMI   string
-}
-
 func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	b.config.ctx.Funcs = awscommon.TemplateFuncs
-	// Create passthrough for {{ .BuildRegion }} and {{ .SourceAMI }} variables
-	// so we can fill them in later
-	b.config.ctx.Data = &EngineVarsTemplate{
-		BuildRegion: `{{ .BuildRegion }}`,
-		SourceAMI:   `{{ .SourceAMI }} `,
-	}
 	err := config.Decode(&b.config, &config.DecodeOpts{
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
+		InterpolateFilter: &interpolate.RenderFilter{
+			Exclude: []string{
+				"run_tags",
+				"spot_tags",
+				"ebs_volumes",
+			},
+		},
 	}, raws...)
 	if err != nil {
 		return nil, err
@@ -74,7 +70,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		errs = packer.MultiErrorAppend(errs, err)
 	}
 
-	if b.config.IsSpotInstance() && ((b.config.AMIENASupport != nil && *b.config.AMIENASupport) || b.config.AMISriovNetSupport) {
+	if b.config.IsSpotInstance() && (b.config.AMIENASupport || b.config.AMISriovNetSupport) {
 		errs = packer.MultiErrorAppend(errs,
 			fmt.Errorf("Spot instances do not support modification, which is required "+
 				"when either `ena_support` or `sriov_support` are set. Please ensure "+
@@ -86,20 +82,37 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	packer.LogSecretFilter.Set(b.config.AccessKey, b.config.SecretKey, b.config.Token)
+	log.Println(b.config)
 	return nil, nil
 }
 
-func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
 	session, err := b.config.Session()
 	if err != nil {
 		return nil, err
 	}
 	ec2conn := ec2.New(session)
 
+	// If the subnet is specified but not the VpcId or AZ, try to determine them automatically
+	if b.config.SubnetId != "" && (b.config.AvailabilityZone == "" || b.config.VpcId == "") {
+		log.Printf("[INFO] Finding AZ and VpcId for the given subnet '%s'", b.config.SubnetId)
+		resp, err := ec2conn.DescribeSubnets(&ec2.DescribeSubnetsInput{SubnetIds: []*string{&b.config.SubnetId}})
+		if err != nil {
+			return nil, err
+		}
+		if b.config.AvailabilityZone == "" {
+			b.config.AvailabilityZone = *resp.Subnets[0].AvailabilityZone
+			log.Printf("[INFO] AvailabilityZone found: '%s'", b.config.AvailabilityZone)
+		}
+		if b.config.VpcId == "" {
+			b.config.VpcId = *resp.Subnets[0].VpcId
+			log.Printf("[INFO] VpcId found: '%s'", b.config.VpcId)
+		}
+	}
+
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
-	state.Put("config", &b.config)
-	state.Put("access_config", &b.config.AccessConfig)
+	state.Put("config", b.config)
 	state.Put("ec2", ec2conn)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
@@ -109,10 +122,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	if b.config.IsSpotInstance() {
 		instanceStep = &awscommon.StepRunSpotInstance{
 			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
+			AvailabilityZone:                  b.config.AvailabilityZone,
 			BlockDevices:                      b.config.launchBlockDevices,
-			BlockDurationMinutes:              b.config.BlockDurationMinutes,
 			Ctx:                               b.config.ctx,
-			Comm:                              &b.config.RunConfig.Comm,
 			Debug:                             b.config.PackerDebug,
 			EbsOptimized:                      b.config.EbsOptimized,
 			ExpectedRootDevice:                "ebs",
@@ -123,6 +135,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SpotPrice:                         b.config.SpotPrice,
 			SpotPriceProduct:                  b.config.SpotPriceAutoProduct,
 			SpotTags:                          b.config.SpotTags,
+			SubnetId:                          b.config.SubnetId,
 			Tags:                              b.config.RunTags,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
@@ -130,6 +143,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	} else {
 		instanceStep = &awscommon.StepRunSourceInstance{
 			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
+			AvailabilityZone:                  b.config.AvailabilityZone,
 			BlockDevices:                      b.config.launchBlockDevices,
 			Comm:                              &b.config.RunConfig.Comm,
 			Ctx:                               b.config.ctx,
@@ -142,6 +156,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			InstanceType:                      b.config.InstanceType,
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                         b.config.SourceAmi,
+			SubnetId:                          b.config.SubnetId,
 			Tags:                              b.config.RunTags,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
@@ -156,25 +171,16 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EnableAMIENASupport:      b.config.AMIENASupport,
 			AmiFilters:               b.config.SourceAmiFilter,
 		},
-		&awscommon.StepNetworkInfo{
-			VpcId:               b.config.VpcId,
-			VpcFilter:           b.config.VpcFilter,
-			SecurityGroupIds:    b.config.SecurityGroupIds,
-			SecurityGroupFilter: b.config.SecurityGroupFilter,
-			SubnetId:            b.config.SubnetId,
-			SubnetFilter:        b.config.SubnetFilter,
-			AvailabilityZone:    b.config.AvailabilityZone,
-		},
 		&awscommon.StepKeyPair{
 			Debug:        b.config.PackerDebug,
 			Comm:         &b.config.RunConfig.Comm,
 			DebugKeyPath: fmt.Sprintf("ec2_%s.pem", b.config.PackerBuildName),
 		},
 		&awscommon.StepSecurityGroup{
-			SecurityGroupFilter:    b.config.SecurityGroupFilter,
-			SecurityGroupIds:       b.config.SecurityGroupIds,
-			CommConfig:             &b.config.RunConfig.Comm,
-			TemporarySGSourceCidrs: b.config.TemporarySGSourceCidrs,
+			SecurityGroupIds:      b.config.SecurityGroupIds,
+			CommConfig:            &b.config.RunConfig.Comm,
+			VpcId:                 b.config.VpcId,
+			TemporarySGSourceCidr: b.config.TemporarySGSourceCidr,
 		},
 		instanceStep,
 		&stepTagEBSVolumes{
@@ -195,9 +201,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
 		},
 		&common.StepProvision{},
-		&common.StepCleanupTempKeys{
-			Comm: &b.config.RunConfig.Comm,
-		},
 		&awscommon.StepStopEBSBackedInstance{
 			Skip:                b.config.IsSpotInstance(),
 			DisableStopInstance: b.config.DisableStopInstance,
@@ -210,7 +213,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	// Run!
 	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
-	b.runner.Run(ctx, state)
+	b.runner.Run(state)
 
 	// If there was an error, return that
 	if rawErr, ok := state.GetOk("error"); ok {
@@ -226,3 +229,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	ui.Say(fmt.Sprintf("Created Volumes: %s", artifact))
 	return artifact, nil
 }
+
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}

builder/amazon/ebsvolume/builder_test.go

@@ -61,7 +61,6 @@ func TestBuilderPrepare_InvalidShutdownBehavior(t *testing.T) {
 
 	// Test good
 	config["shutdown_behavior"] = "terminate"
-	config["skip_region_validation"] = true
 	warnings, err := b.Prepare(config)
 	if len(warnings) > 0 {
 		t.Fatalf("bad: %#v", warnings)

builder/amazon/ebsvolume/step_tag_ebs_volumes.go

@@ -15,7 +15,7 @@ type stepTagEBSVolumes struct {
 	Ctx           interpolate.Context
 }
 
-func (s *stepTagEBSVolumes) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *stepTagEBSVolumes) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	instance := state.Get("instance").(*ec2.Instance)
 	ui := state.Get("ui").(packer.Ui)

builder/amazon/instance/builder.go

@@ -3,9 +3,9 @@
 package instance
 
 import (
-	"context"
 	"errors"
 	"fmt"
+	"log"
 	"os"
 	"strings"
 
@@ -156,7 +156,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			errs, fmt.Errorf("x509_key_path points to bad file: %s", err))
 	}
 
-	if b.config.IsSpotInstance() && ((b.config.AMIENASupport != nil && *b.config.AMIENASupport) || b.config.AMISriovNetSupport) {
+	if b.config.IsSpotInstance() && (b.config.AMIENASupport || b.config.AMISriovNetSupport) {
 		errs = packer.MultiErrorAppend(errs,
 			fmt.Errorf("Spot instances do not support modification, which is required "+
 				"when either `ena_support` or `sriov_support` are set. Please ensure "+
@@ -167,21 +167,37 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		return nil, errs
 	}
 	packer.LogSecretFilter.Set(b.config.AccessKey, b.config.SecretKey, b.config.Token)
+	log.Println(b.config)
 	return nil, nil
 }
 
-func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
 	session, err := b.config.Session()
 	if err != nil {
 		return nil, err
 	}
 	ec2conn := ec2.New(session)
 
+	// If the subnet is specified but not the VpcId or AZ, try to determine them automatically
+	if b.config.SubnetId != "" && (b.config.AvailabilityZone == "" || b.config.VpcId == "") {
+		log.Printf("[INFO] Finding AZ and VpcId for the given subnet '%s'", b.config.SubnetId)
+		resp, err := ec2conn.DescribeSubnets(&ec2.DescribeSubnetsInput{SubnetIds: []*string{&b.config.SubnetId}})
+		if err != nil {
+			return nil, err
+		}
+		if b.config.AvailabilityZone == "" {
+			b.config.AvailabilityZone = *resp.Subnets[0].AvailabilityZone
+			log.Printf("[INFO] AvailabilityZone found: '%s'", b.config.AvailabilityZone)
+		}
+		if b.config.VpcId == "" {
+			b.config.VpcId = *resp.Subnets[0].VpcId
+			log.Printf("[INFO] VpcId found: '%s'", b.config.VpcId)
+		}
+	}
+
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
-	state.Put("access_config", &b.config.AccessConfig)
-	state.Put("ami_config", &b.config.AMIConfig)
 	state.Put("ec2", ec2conn)
 	state.Put("awsSession", session)
 	state.Put("hook", hook)
@@ -192,10 +208,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	if b.config.IsSpotInstance() {
 		instanceStep = &awscommon.StepRunSpotInstance{
 			AssociatePublicIpAddress: b.config.AssociatePublicIpAddress,
+			AvailabilityZone:         b.config.AvailabilityZone,
 			BlockDevices:             b.config.BlockDevices,
-			BlockDurationMinutes:     b.config.BlockDurationMinutes,
 			Ctx:                      b.config.ctx,
-			Comm:                     &b.config.RunConfig.Comm,
 			Debug:                    b.config.PackerDebug,
 			EbsOptimized:             b.config.EbsOptimized,
 			IamInstanceProfile:       b.config.IamInstanceProfile,
@@ -203,6 +218,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SourceAMI:                b.config.SourceAmi,
 			SpotPrice:                b.config.SpotPrice,
 			SpotPriceProduct:         b.config.SpotPriceAutoProduct,
+			SubnetId:                 b.config.SubnetId,
 			Tags:                     b.config.RunTags,
 			SpotTags:                 b.config.SpotTags,
 			UserData:                 b.config.UserData,
@@ -211,6 +227,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	} else {
 		instanceStep = &awscommon.StepRunSourceInstance{
 			AssociatePublicIpAddress: b.config.AssociatePublicIpAddress,
+			AvailabilityZone:         b.config.AvailabilityZone,
 			BlockDevices:             b.config.BlockDevices,
 			Comm:                     &b.config.RunConfig.Comm,
 			Ctx:                      b.config.ctx,
@@ -221,6 +238,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			InstanceType:             b.config.InstanceType,
 			IsRestricted:             b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                b.config.SourceAmi,
+			SubnetId:                 b.config.SubnetId,
 			Tags:                     b.config.RunTags,
 			UserData:                 b.config.UserData,
 			UserDataFile:             b.config.UserDataFile,
@@ -238,16 +256,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
 			EnableAMIENASupport:      b.config.AMIENASupport,
 			AmiFilters:               b.config.SourceAmiFilter,
-			AMIVirtType:              b.config.AMIVirtType,
-		},
-		&awscommon.StepNetworkInfo{
-			VpcId:               b.config.VpcId,
-			VpcFilter:           b.config.VpcFilter,
-			SecurityGroupIds:    b.config.SecurityGroupIds,
-			SecurityGroupFilter: b.config.SecurityGroupFilter,
-			SubnetId:            b.config.SubnetId,
-			SubnetFilter:        b.config.SubnetFilter,
-			AvailabilityZone:    b.config.AvailabilityZone,
 		},
 		&awscommon.StepKeyPair{
 			Debug:        b.config.PackerDebug,
@@ -255,10 +263,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			DebugKeyPath: fmt.Sprintf("ec2_%s.pem", b.config.PackerBuildName),
 		},
 		&awscommon.StepSecurityGroup{
-			CommConfig:             &b.config.RunConfig.Comm,
-			SecurityGroupFilter:    b.config.SecurityGroupFilter,
-			SecurityGroupIds:       b.config.SecurityGroupIds,
-			TemporarySGSourceCidrs: b.config.TemporarySGSourceCidrs,
+			CommConfig:            &b.config.RunConfig.Comm,
+			SecurityGroupIds:      b.config.SecurityGroupIds,
+			VpcId:                 b.config.VpcId,
+			TemporarySGSourceCidr: b.config.TemporarySGSourceCidr,
 		},
 		instanceStep,
 		&awscommon.StepGetPassword{
@@ -275,9 +283,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
 		},
 		&common.StepProvision{},
-		&common.StepCleanupTempKeys{
-			Comm: &b.config.RunConfig.Comm,
-		},
 		&StepUploadX509Cert{},
 		&StepBundleVolume{
 			Debug: b.config.PackerDebug,
@@ -321,7 +326,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	// Run!
 	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
-	b.runner.Run(ctx, state)
+	b.runner.Run(state)
 
 	// If there was an error, return that
 	if rawErr, ok := state.GetOk("error"); ok {
@@ -342,3 +347,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	return artifact, nil
 }
+
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}