Revert "Check that only certain files are executable"

.circleci/config.yml

@@ -1,202 +0,0 @@
-orbs:
-  win: circleci/windows@1.0.0
-version: 2.1
-
-executors:
-  golang:
-    docker:
-      - image: circleci/golang:1.13
-  darwin:
-    macos:
-      xcode: "9.0"
-
-commands:
-  install-go-run-tests-unix:
-    parameters:
-      GOOS:
-        type: string
-      GOVERSION:
-        type: string
-    steps:
-      - checkout
-      - run: curl https://dl.google.com/go/go<< parameters.GOVERSION >>.<< parameters.GOOS >>-amd64.tar.gz | tar -C ~/ -xz
-      - run: ~/go/bin/go test ./...
-  install-go-run-tests-windows:
-    parameters:
-      GOVERSION:
-        type: string
-    steps:
-      - checkout
-      - run: curl https://dl.google.com/go/go<< parameters.GOVERSION >>.windows-amd64.zip --output ~/go<< parameters.GOVERSION >>.windows-amd64.zip
-      - run: unzip ~/go<< parameters.GOVERSION >>.windows-amd64.zip -d ~/
-      - run: ~/go/bin/go test ./...
-  build-and-persist-packer-binary:
-    parameters:
-      GOOS:
-        type: string
-    steps:
-      - checkout
-      - run: GOOS=<< parameters.GOOS >> go build -ldflags="-s -w" -o ./pkg/packer_<< parameters.GOOS >>_$(go env GOARCH) .
-      - run: zip ./pkg/packer_<< parameters.GOOS >>_$(go env GOARCH).zip ./pkg/packer_<< parameters.GOOS >>_$(go env GOARCH)
-      - run: rm ./pkg/packer_<< parameters.GOOS >>_$(go env GOARCH)
-      - persist_to_workspace:
-          root: .
-          paths:
-            - ./pkg/
-# Golang CircleCI 2.0 configuration file
-#
-# Check https://circleci.com/docs/2.0/language-go/ for more details
-jobs:
-  test-linux:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - checkout
-      - run: make ci
-  test-darwin:
-    executor: darwin
-    working_directory: ~/go/src/github.com/hashicorp/packer
-    environment:
-      GO111MODULE: "off"
-    steps:
-      - install-go-run-tests-unix:
-          GOOS: darwin
-          GOVERSION: "1.13"
-  test-windows:
-    executor:
-      name: win/vs2019
-      shell: bash.exe
-    steps:
-      - install-go-run-tests-windows:
-          GOVERSION: "1.13"
-  check-vendor-vs-mod:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    environment:
-      GO111MODULE: "off"
-    steps:
-      - checkout
-      - run: GO111MODULE=on go run . --help
-      - run: make check-vendor-vs-mod
-  check-fmt:
-    executor: golang
-    steps:
-      - checkout
-      - run: make fmt-check
-  check-generate:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - checkout
-      - run: make generate-check
-  build_linux:
-    executor: golang
-    steps:
-      - build-and-persist-packer-binary:
-          GOOS: linux
-  build_windows:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - build-and-persist-packer-binary:
-          GOOS: windows
-  build_darwin:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - build-and-persist-packer-binary:
-          GOOS: darwin
-  build_freebsd:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - build-and-persist-packer-binary:
-          GOOS: freebsd
-  build_solaris:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - build-and-persist-packer-binary:
-          GOOS: solaris
-  build_openbsd:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - build-and-persist-packer-binary:
-          GOOS: openbsd
-  store_artifacts:
-    executor: golang
-    steps:
-      - attach_workspace:
-          at: .
-      - store_artifacts:
-          path: ./pkg/
-          destination: /
-  publish-github-tag-release:
-    docker:
-      - image: cibuilds/github:0.10
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - attach_workspace:
-          at: .
-      - run: |
-          ghr -prerelease -t ${GITHUB_TOKEN_AZR} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} -c ${CIRCLE_SHA1} -delete ${CIRCLE_TAG} ./pkg/
-workflows:
-  version: 2
-  test:
-    jobs:
-      - test-linux
-      - test-darwin
-      - test-windows
-  check-code:
-    jobs:
-      - check-vendor-vs-mod
-      - check-fmt
-      - check-generate
-  build_packer_binaries:
-    jobs:
-      - build_linux:
-          filters:
-            tags:
-              only: /.*/
-      - build_darwin:
-          filters:
-            tags:
-              only: /.*/
-      - build_windows:
-          filters:
-            tags:
-              only: /.*/
-      - build_freebsd:
-          filters:
-            tags:
-              only: /.*/
-      - build_openbsd:
-          filters:
-            tags:
-              only: /.*/
-      - build_solaris:
-          filters:
-            tags:
-              only: /.*/
-      - store_artifacts:
-          requires:
-            - build_linux
-            - build_darwin
-            - build_windows
-            - build_freebsd
-            - build_openbsd
-            - build_solaris
-      - publish-github-tag-release:
-          requires:
-            - build_linux
-            - build_darwin
-            - build_windows
-            - build_freebsd
-            - build_openbsd
-            - build_solaris
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: nightly

.gitattributes

@@ -1,7 +1,4 @@
 * text=auto
 *.go text eol=lf
 *.sh text eol=lf
-*.json text eol=lf
-*.md text eol=lf
-*.ps1 text eol=lf
 common/test-fixtures/root/*	eol=lf

.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.
@@ -53,16 +53,17 @@ can quickly merge or address your contributions.
 If you have never worked with Go before, you will have to install its
 runtime in order to build packer.
 
-1. This project always releases from the latest version of golang. [Install go](https://golang.org/doc/install#install)
+1. [Install go](https://golang.org/doc/install#install)
 
 ## Setting up Packer for dev
 
 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.
 
+
 1. Download the Packer source (and its dependencies) by running
    `go get github.com/hashicorp/packer`. This will download the Packer source to
    `$GOPATH/src/github.com/hashicorp/packer`.
@@ -85,24 +86,6 @@ The instructions below are for go 1.7. or later.
 5. If everything works well and the tests pass, run `go fmt` on your code before
    submitting a pull-request.
 
-### Windows Systems
-On windows systems you need at least the [MinGW Tools](http://www.mingw.org/), e.g. install via [choco](https://chocolatey.org/):
-
-```
-choco install mingw -y
-```
-
-This installs the GCC compiler, as well as a ```mingw32-make``` which can be used wherever
-this documentation mentions ```make```
-
-when building using ```go``` you also need to mention the windows
-executable extension
-
-```
-go build -o bin/packer.exe
-```
-
-
 ### Opening an Pull Request
 
 Thank you for contributing! When you are ready to open a pull-request, you will
@@ -124,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
@@ -135,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
 
@@ -260,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.
 
@@ -292,12 +212,3 @@ make testacc TEST=./builder/amazon/ebs TESTARGS="-run TestBuilderAcc_forceDelete
 Acceptance tests typically require other environment variables to be set for
 things such as API tokens and keys. Each test should error and tell you which
 credentials are missing, so those are not documented here.
-
-#### Debugging Plugins
-
-Each packer plugin runs in a separate process and communicates with RCP over a
-socket therefore using a debugger will not work (be complicated at least).
-
-But most of the Packer code is really simple and easy to follow with PACKER_LOG
-turned on. If that doesn't work adding some extra debug print outs when you have
-homed in on the problem is usually enough.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,26 @@
+_Please read these instructions before submitting_
+
+**DELETE THIS TEMPLATE BEFORE SUBMITTING**
+
+_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.
+
+If you are planning to open a pull-request just open the pull-request instead of making an issue first.
+
+FOR FEATURES:
+
+Describe the feature you want and your use case _clearly_.
+
+FOR BUGS:
+
+Describe the problem and include the following information:
+
+- Packer version from `packer version`
+- Host platform
+- Debug log output from `PACKER_LOG=1 packer build template.json`.
+  Please paste this in a gist https://gist.github.com
+- The _simplest example template and scripts_ needed to reproduce the bug.
+  Include these in your gist https://gist.github.com
+  

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,40 +0,0 @@
----
-name: Bug Report
-about: You're experiencing an issue with Packer that is different than the documented behavior.
-
----
-
-When filing a bug, please include the following headings if possible. Any
-example text in this template can be deleted.
-
-#### Overview of the Issue
-
-A paragraph or two about the issue you're experiencing.
-
-#### Reproduction Steps
-
-Steps to reproduce this issue
-
-### Packer version
-
-From `packer version`
-
-### Simplified Packer Buildfile
-
-If the file is longer than a few dozen lines, please include the URL to the
-[gist](https://gist.github.com/) of the log or use the [Github detailed
-format](https://gist.github.com/ericclemmons/b146fe5da72ca1f706b2ef72a20ac39d)
-instead of posting it directly in the issue.
-
-### Operating system and Environment details
-
-OS, Architecture, and any other information you can provide about the
-environment.
-
-### Log Fragments and crash.log files
-
-Include appropriate log fragments. If the log is longer than a few dozen lines,
-please include the URL to the [gist](https://gist.github.com/) of the log or
-use the [Github detailed format](https://gist.github.com/ericclemmons/b146fe5da72ca1f706b2ef72a20ac39d) instead of posting it directly in the issue.
-
-Set the env var `PACKER_LOG=1` for maximum log detail.

.github/ISSUE_TEMPLATE/feature_requests.md

@@ -1,18 +0,0 @@
----
-name: Feature Request
-about: If you have something you think Packer could improve or add support for.
-
----
-
-Please search the existing issues for relevant feature requests, and use the
-reaction feature
-(https://blog.github.com/2016-03-10-add-reactions-to-pull-requests-issues-and-comments/)
-to add upvotes to pre-existing requests.
-
-#### Feature Description
-
-A written overview of the feature.
-
-#### Use Case(s)
-
-Any relevant use-cases that you see.

.github/ISSUE_TEMPLATE/question.md

@@ -1,15 +0,0 @@
----
-name: Question
-about: If you have a question, please check out our other community resources instead of opening an issue.
-
----
-
-Issues on GitHub are intended to be related to bugs or feature requests, so we
-recommend using our other community resources instead of asking here if you
-have a question.
-
-- Packer Guides: https://www.packer.io/guides/index.html
-- Discussion List: https://groups.google.com/group/packer-tool
-- Any other questions can be sent to the packer section of the HashiCorp
-  forum: https://discuss.hashicorp.com/c/packer
-- Packer community links: https://www.packer.io/community.html

.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
@@ -26,4 +25,3 @@ packer-test*.log
 Thumbs.db
 /packer.exe
 .project
-cache

.travis.yml

@@ -1,23 +1,25 @@
 env:
-  - USER=travis GO111MODULE=off
-
-os:
-  - osx
+    - USER=travis
 
 sudo: false
 
 language: go
 
 go:
-  - 1.12.x
+  - 1.11.x
+  - master
+
+install:
+  - make deps
 
 script:
-  - df -h
-  - travis_wait make ci
+  - GOMAXPROCS=2 make ci
 
 branches:
   only:
     - master
 
 matrix:
+  allow_failures:
+    - go: master
   fast_finish: true

CHANGELOG.md

@@ -1,663 +1,14 @@
-## 1.4.4 (October 1, 2019)
+## 1.2.6 (Unreleased)
 
 ### IMPROVEMENTS:
-** new core feature** Error cleanup provisioner [GH-8155]
-* builder/amazon: Add ability to set `run_volume_tags` [GH-8051]
-* builder/amazon: Add AWS API call reties on AMI prevalidation [GH-8034]
-* builder/azure: Refactor client config [GH-8121]
-* builder/cloudstack: New step to detach iso. [GH-8106]
-* builder/googlecompute: Fail fast when image name is invalid. [GH-8112]
-* builder/googlecompute: Users can now query Vault for an Oauth token rather
-    than setting an account file [GH-8143]
-* builder/hcloud: Allow selecting image based on filters [GH-7945]
-* builder/hyper-v: Decrease the delay between Hyper-V VM startup and hyper-v
-    builder's ability to send keystrokes to the target VM. [GH-7970]
-* builder/openstack: Store WinRM password for provisioners to use [GH-7940]
-* builder/proxmox: Shorten default boot_key_interval to 5ms from 100ms
-    [GH-8088]
-* builder/proxmox: Allow running the template VM in a Proxmox resource pool
-    [GH-7862]
-* builder/ucloud: Make ucloud builder's base url configurable [GH-8095]
-* builder/virtualbox-vm: Make target snapshot optional [GH-8011] [GH-8004]
-* builder/vmware: Allow user to attach floppy files to remote vmx builds
-    [GH-8132]
-* builder/yandex: Add ability to retry API requests [GH-8142]
-* builder/yandex: Support GPU instances and set source image by name [GH-8091]
-* communicator/ssh: Support for SSH port tunneling [GH-7918]
-* core: Add a new `floppy_label` option [GH-8099]
-* core: Added version compatibility to console command [GH-8080]
-* post-processor/vagrant-cloud: Allow blank access_token for private vagrant
-    box hosting [GH-8097]
-* post-processor/vagrant-cloud: Allow use of the Artifice post-processor with
-    the Vagrant Cloud post-processor [GH-8018] [GH-8027]
-* post-processor/vsphere: Removed redundant whitelist check for builders,
-    allowing users to use post-processor withough the VMWare builder [GH-8064]
 
-### BUG FIXES:
-* builder/amazon: Fix FleetID crash. [GH-8013]
-* builder/amazon: Gracefully handle rate limiting when retrieving winrm
-    password. [GH-8087]
-* builder/amazon: Fix race condition in spot instance launching [GH-8165]
-* builder/amazon: Amazon builders now respect ssh_host option [GH-8162]
-* builder/amazon: Update the AWS sdk to resolve some credential handling issues
-    [GH-8131]
-* builder/azure: Avoid a panic in getObjectIdFromToken [GH-8047]
-* builder/googlecompute: Fix crash caused by nil account file. [GH-8102]
-* builder/hyper-v: Fix when management interface is not part of virtual switch
-    [GH-8017]
-* builder/openstack: Fix dropped error when creating image client. [GH-8110]
-* builder/openstack: Fix race condition created when adding metadata [GH-8016]
-* builder/outscale: Get SSH Host from VM.Nics instead of VM Root [GH-8077]
-* builder/proxmox: Bump proxmox api dep, fixing bug with checking http status
-    during boot command [GH-8083]
-* builder/proxmox: Check that disk format is set when pool type requires it
-    [GH-8084]
-* builder/proxmox: Fix panic caused by cancelling build [GH-8067] [GH-8072]
-* builder/qemu: Fix dropped error when retrieving version [GH-8050]
-* builder/vagrant: Fix dropped errors in code and tests. [GH-8118]
-* builder/vagrant: Fix provisioning boxes, define source and output boxes
-    [GH-7957]
-* builder/vagrant: Fix ssh and package steps to use source syntax. [GH-8125]
-* builder/vagrant: Use GlobalID when provided [GH-8092]
-* builder/virtualbox: Fix windows pathing problem for guest additions checksum
-    download. [GH-7996]
-* builder/virtualbox: LoadSnapshots succeeds even if machine has no snapshots
-    [GH-8096]
-* builder/vmware: fix dropped test errors [GH-8170]
-* core: Fix bug where sensitive variables contianing commas were not being
-    properly sanitized in UI calls. [GH-7997]
-* core: Fix handling of booleans where "unset" is a value distinct from
-    "false". [GH-8021]
-* core: Fix tests that swallowed errors in goroutines [GH-8094]
-* core: Fix bug where Packer could no longer run as background process [GH-8101]
-* core: Fix zsh auto-completion [GH-8160]
-* communicator/ssh: Friendlier message warning user that their creds may be
-    wrong [GH-8167]
-* post-processor/amazon-import: Fix non-default encryption. [GH-8113]
-* post-processor/vagrant-cloud: Fix dropped errors [GH-8156]
-* provisioner/ansible: Fix provisioner dropped errors [GH-8045]
-
-### BACKWARDS INCOMPATIBILITIES:
-* core: "sed" template function has been deprecated in favor of "replace" and
-    "replace_all" functins [GH-8119]
-
-## 1.4.3 (August 14, 2019)
-
-### IMPROVEMENTS:
-* **new builder** UCloud builder [GH-7775]
-* **new builder** Outscale [GH-7459]
-* **new builder** VirtualBox Snapshot [GH-7780]
-* **new builder** JDCloud [GH-7962]
-* **new post-processor** Exoscale Import post-processor [GH-7822] [GH-7946]
-* build: Change Makefile to behave differently inside and outside the gopath
-    when generating code. [GH-7827]
-* builder/amazon: Don't calculate spot bids; Amazon has changed spot pricing to
-    no longer require this. [GH-7813]
-* builder/google: Add suse-byos-cloud to list of public GCP cloud image
-    projects [GH-7935]
-* builder/openstack: New `image_min_disk` option [GH-7290]
-* builder/openstack: New option `use_blockstorage_volume` to set openstack
-    image metadata [GH-7792]
-* builder/openstack: Select instance network on which to assign floating ip
-    [GH-7884]
-* builder/qemu: Implement VNC password functionality [GH-7836]
-* builder/scaleway: Allow removing volume after image creation for Scaleway
-    builder [GH-7887]
-* builder/tencent: Add `run_tags` to option to tag instance. [GH-7810]
-* builder/tencent: Remove unnecessary image name validation check. [GH-7786]
-* builder/tencent: Support data disks for tencentcloud builder [GH-7815]
-* builder/vmware: Fix intense CPU usage because of poorly handled errors.
-    [GH-7877]
-* communicator: Use context for timeouts, interruption in ssh and winrm
-    communicators [GH-7868]
-* core: Change how on-error=abort is handled to prevent EOF errors that mask
-    real issues [GH-7913]
-* core: Clean up logging vs ui call in step download [GH-7936]
-* core: New environment var option to allow user to set location of config
-    directory [GH-7912]
-* core: Remove obsolete Cancel functions from builtin provisioners [GH-7917]
-* post-processor/vagrant:  Add option to allow box Vagrantfiles to be generated
-    during the build [GH-7951]
-* provisioner/ansible: Add support for installing roles with ansible-galaxy
-    [GH-7916
-* provisioner/salt-masterless: Modify file upload to handle non-root case.
-    [GH-7833]
-
-### BUG FIXES:
-* builder/amazon: Add error to warn users of spot_tags regression. [GH-7989]
-* builder/amazon: Allow EC2 Spot Fleet packer instances to run in parallel
-    [GH-7818]
-* builder/amazon: Fix failures and duplication in Amazon region copy and
-    encryption step. [GH-7870] [GH-7923]
-* builder/amazon: No longer store names of volumes which get deleted on
-    termination inside ebssurrogate artifact. [GH-7829]
-* builder/amazon: Update aws-sdk-go to v1.22.2, resolving some AssumeRole
-    issues [GH-7967]
-* builder/azure: Create configurable polling duration and set higher default
-    for image copies to prevent timeouts on successful copies [GH-7920]
-* builder/digitalocean: increase timeout for Digital Ocean snapshot creation.
-    [GH-7841]
-* builder/docker: Check container os, not host os, when creating container dir
-    default [GH-7939]
-* builder/docker: Fix bug where PACKER_TMP_DIR was created with root perms on
-    linux [GH-7905]
-* builder/docker: Fix file download hang caused by blocking ReadAll call
-    [GH-7814]
-* builder/google: Fix outdated oauth URL. [GH-7835] [GH-7927]
-* builder/hyperv: Improve code for detecting IP address [GH-7880]
-* builder/ucloud: Update the api about stop instance to fix the read-only image
-    build by ucloud-uhost [GH-7914]
-* builder/vagrant: Fix bug where source_path was being used instead of box_name
-    when generating the Vagrantfile. [GH-7859]
-* builder/virtualbox: Honor value of 'Comment' field in ssh keypair generation.
-    [GH-7922]
-* builder/vmware: Fix validation regression that occurred when user provided a
-    checksum file [GH-7804]
-* buildere/azure: Fix crash with managed images not published to shared image
-    gallery. [GH-7837]
-* communicator/ssh: Move ssh_interface back into individual builders from ssh
-    communicator to prevent validation issues where it isn't implemented.
-    [GH-7831]
-* console: Fix console help text [GH-7960]
-* core: Fix bug in template parsing where function errors were getting
-    swallowed. [GH-7854]
-* core: Fix regression where a local filepath containing `//` was no longer
-    properly resolving to `/`. [GH-7888]
-* core: Fix regression where we could no longer access isos on SMB shares.
-    [GH-7800]
-* core: Make ssh_host template option always override all builders' IP
-    discovery. [GH-7832]
-* core: Regenerate boot_command PEG code [GH-7977]
-* fix: clean up help text and fixer order to make sure all fixers are called
-    [GH-7903]
-* provisioner/inspec: Use --input-file instead of --attrs to avoid deprecation
-    warning [GH-7893]
-* provisioner/salt-masterless: Make salt-masterless provisioner respect
-    disable_sudo directive for all commands [GH-7774]
-
-## 1.4.2 (June 26, 2019)
-
-### IMPROVEMENTS:
-* **new feature:** Packer console [GH-7726]
-* builder/alicloud: cleanup image and snapshot if target image is still not
-    available after timeout [GH-7744]
-* builder/alicloud: let product API determine the default value of io_optimized
-    [GH-7747]
-* builder/amazon: Add new `skip_save_build_region` option to fix naming
-    conflicts when building in a region you don't want the final image saved
-    in. [GH-7759]
-* builder/amazon: Add retry for temp key-pair generation in amazon-ebs
-    [GH-7731]
-* builder/amazon: Enable encrypted AMI sharing across accounts [GH-7707]
-* builder/amazon: New SpotInstanceTypes feature for spot instance users.
-    [GH-7682]
-* builder/azure: Allow users to publish Managed Images to Azure Shared Image
-    Gallery (same Subscription) [GH-7778]
-* builder/azure: Update Azure SDK for Go to v30.0.0 [GH-7706]
-* builder/cloudstack: Add tags to instance upon creation [GH-7526]
-* builder/docker: Better windows defaults [GH-7678]
-* builder/google: Add feature to import user-data from a file [GH-7720]
-* builder/hyperv: Abort build if there's a name collision [GH-7746]
-* builder/hyperv: Clarify pathing requirements for hyperv-vmcx [GH-7790]
-* builder/hyperv: Increase MaxRamSize to match modern Windows [GH-7785]
-* builder/openstack: Add image filtering on properties. [GH-7597]
-* builder/qemu: Add additional disk support [GH-7791]
-* builder/vagrant: Allow user to override vagrant ssh-config details [GH-7782]
-* builder/yandex: Gracefully shutdown instance, allow metadata from file, and
-    create preemptible instance type [GH-7734]
-* core: scrub out sensitive variables in scrub out sensitive variables logs
-    [GH-7743]
-
-### BUG FIXES:
-* builder/alicloud: Fix describing snapshots issue when image_ignore_data_disks
-    is provided [GH-7736]
-* builder/amazon: Fix bug in region copy which produced badly-named AMIs in the
-    build region. [GH-7691]
-* builder/amazon: Fix failure that happened when spot_tags was set but ami_tags
-    wasn't [GH-7712]
-* builder/cloudstack: Update go-cloudstack sdk, fixing compatability with
-    CloudStack v 4.12 [GH-7694]
-* builder/proxmox: Update proxmox-api-go dependency, fixing issue calculating
-    VMIDs. [GH-7755]
-* builder/tencent: Correctly remove tencentcloud temporary keypair. [GH-7787]
-* core: Allow timestamped AND colorless ui messages [GH-7769]
-* core: Apply logSecretFilter to output from ui.Say [GH-7739]
-* core: Fix "make bin" command to use reasonbale defaults. [GH-7752]
-* core: Fix user var interpolation for variables set via -var-file and from
-    command line [GH-7733]
-* core: machine-readable UI now writes UI calls to logs. [GH-7745]
-* core: Switch makefile to use "GO111MODULE=auto" to allow for modern gomodule
-    usage. [GH-7753]
-* provisioner/ansible: prevent nil pointer dereference after a language change
-    [GH-7738]
-* provisioner/chef: Accept chef license by default to prevent hangs in latest
-    Chef [GH-7653]
-* provisioner/powershell: Fix crash caused by error in retry logic check in
-    powershell provisioner [GH-7657]
-* provisioner/powershell: Fix null file descriptor error that occurred when
-    remote_path provided is a directory and not a file. [GH-7705]
-
-## 1.4.1 (May 15, 2019)
-
-### IMPROVEMENTS:
-* **new builder:** new proxmox builder implemented [GH-7490]
-* **new builder:** new yandex cloud builder implemented [GH-7484]
-* **new builder:** new linode builder implemented [GH-7508]
-* build: Circle CI now generates test binaries for all pull requests [GH-7624]
-    [GH-7625] [GH-7630]
-* builder/alicloud: Support encryption with default service key [GH-7574]
-* builder/amazon: Users of chroot and ebssurrogate builders may now choose
-    between "x86_64" and "arm64" architectures when registering their AMIs.
-    [GH-7620]
-* builder/amazon: Users of the ebssurrogage builder may now choose to omit
-    certain launch_block_devices from the final AMI mapping by using the
-    omit_from_artifact feature. [GH-7612]
-* builder/azure: Update Azure SDK [GH-7563]
-* builder/docker: Better error messaging with container downloads. [GH-7513]
-* builder/google: add image encryption support [GH-7551]
-* builder/hyperv: Add keep_registered option to hyperv [GH-7498]
-* builder/qemu: Replace dot-based parsing with hashicorp/go-version [GH-7614]
-* builder/vmware: Add 30 minute timeout for destroying a VM [GH-7553]
-* core: Cleanup cache of used port after closing [GH-7613]
-* core: New option to set number of builds running in parallel & test
-    BuildCommand more [GH-7501]
-* packer compiles on s390x [GH-7567]
-* provisioner/file: Added warnings about writeable locations [GH-7494]
-
-
-### BUG FIXES:
-* builder/amazon: Fix bug that always encrypted build region with default key.
-    [GH-7507]
-* builder/amazon: Fix bug that wasn't deleting unencrypted temporary snapshots
-    [GH-7521]
-* builder/amazon: Fix EBSsurrogate copy, encryption, and deletion of temporary
-    unencrypted amis. [GH-7598]
-* builder/hyperv: Fixes IP detection error if more than one VMNetworkAdapter is
-    found [GH-7480]
-* builder/qemu: Fix mistake switching ssh port mix/max for vnc port min/max
-    [GH-7615]
-* builder/vagrant: Fix bug with builder and vagrant-libvirt plugin [GH-7633]
-* builder/virtualbox: Don't fail download when checksum is not set. [GH-7512]
-* builder/virtualbox: Fix ovf download failures by using local ovf files in
-    place instead of symlinking [GH-7497]
-* builder/vmware: Fix panic configuring VNC for remote builds [GH-7509]
-* core/build: Allow building Packer on solaris by removing progress bar and tty
-    imports on solaris [GH-7618]
-* core: Fix race condition causing hang [GH-7579]
-* core: Fix tty related panics [GH-7517]
-* core: Step download: Always copy local files on windows rather than
-    symlinking them [GH-7575]
-* packer compiles on Solaris again [GH-7589] [GH-7618]
-* post-processor/vagrant: Fix bug in retry logic that caused failed upload to
-    report success. [GH-7554]
-
-## 1.4.0 (April 11, 2019)
-
-### 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.
@@ -667,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,25 +2,19 @@
 
 # builders
 
-/builder/alicloud/                      @chhaj5236
-/builder/azure/                         @paulmey
+/builder/alicloud/                      dongxiao.zzh@alibaba-inc.com
+/builder/amazon/ebssurrogate/           @jen20
+/builder/amazon/ebsvolume/              @jen20
+/builder/azure/                         @boumenot
 /builder/hyperv/                        @taliesins
-/builder/jdcloud/                       @XiaohanLiang @remrain
-/builder/linode/                        @displague @ctreatma @stvnjacobs
 /builder/lxc/                           @ChrisLundquist
 /builder/lxd/                           @ChrisLundquist
 /builder/oneandone/                     @jasmingacic
 /builder/oracle/                        @prydie @owainlewis
 /builder/profitbricks/                  @jasmingacic
-/builder/triton/                        @sean-
+/builder/triton/                        @jen20 @sean-
 /builder/ncloud/                        @YuSungDuk
-/builder/proxmox/                       @carlpett
-/builder/scaleway/                      @sieben @mvaude @jqueuniet @fflorens @brmzkw
-/builder/hcloud/                        @LKaemmerling
-/builder/hyperone                       @m110 @gregorybrzeski @ad-m
-/builder/ucloud/                        @shawnmssu
-/builder/yandex                         @GennadySpb @alexanderKhaustov @seukyaso
-/builder/osc                            @marinsalinas
+/builder/scaleway/                      @dimtion @edouardb
 
 # provisioners
 
@@ -28,9 +22,7 @@
 /provisioner/converge/                  @stevendborrelli
 
 # post-processors
-
 /post-processor/alicloud-import/        dongxiao.zzh@alibaba-inc.com
 /post-processor/checksum/               v.tolstov@selfip.ru
-/post-processor/exoscale-import/        @falzm @mcorbin
 /post-processor/googlecompute-export/   crunkleton@google.com
 /post-processor/vsphere-template/       nelson@bennu.cl

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)
@@ -8,7 +8,8 @@ GOOS=$(shell go env GOOS)
 GOARCH=$(shell go env GOARCH)
 GOPATH=$(shell go env GOPATH)
 
-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')
+# gofmt
+UNFORMATTED_FILES=$(shell find . -not -path "./vendor/*" -name "*.go" | xargs gofmt -s -l)
 
 # Get the git commit
 GIT_DIRTY=$(shell test -n "`git status --porcelain`" && echo "+CHANGES" || true)
@@ -18,43 +19,37 @@ GOLDFLAGS=-X $(GIT_IMPORT).GitCommit=$(GIT_COMMIT)$(GIT_DIRTY)
 
 export GOLDFLAGS
 
-.PHONY: bin checkversion ci default install-build-deps install-gen-deps fmt fmt-docs fmt-examples generate releasebin test testacc testrace
+default: deps generate test dev
 
-default: install-build-deps install-gen-deps generate testrace dev releasebin package dev fmt fmt-check mode-check fmt-docs fmt-examples
+ci: deps test
 
-ci: testrace ## Test in continuous integration
+release: deps test releasebin package ## Build a release build
 
-release: install-build-deps test releasebin package ## Build a release build
-
-bin: install-build-deps ## Build debug/test 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=auto sh -c "$(CURDIR)/scripts/build.sh"
+	@sh -c "$(CURDIR)/scripts/build.sh"
 
-releasebin: install-build-deps
+releasebin: deps
+	@go get github.com/mitchellh/gox
 	@grep 'const VersionPrerelease = "dev"' version/version.go > /dev/null ; if [ $$? -eq 0 ]; then \
 		echo "ERROR: You must remove prerelease tags from version/version.go prior to release."; \
 		exit 1; \
 	fi
-	@GO111MODULE=auto 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)
 	@sh -c "$(CURDIR)/scripts/dist.sh $(VERSION)"
 
-install-build-deps: ## Install dependencies for bin build
-	@go get github.com/mitchellh/gox
+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
 
-install-gen-deps: ## Install dependencies for code generation
-	# to avoid having to tidy our go deps, we `go get` our binaries from a temp
-	# dir. `go get` will change our deps and the following deps are not part of
-	# out code dependencies; so a go mod tidy will remove them again. `go
-	# install` seems to install the last tagged version and we want to install
-	# master. 
-	@(cd $(TEMPDIR) && GO111MODULE=on go get github.com/mna/pigeon@master)
-	@(cd $(TEMPDIR) && GO111MODULE=on go get github.com/alvaroloes/enumer@master)
-	@go install ./cmd/struct-markdown
-
-dev: ## Build and install a development build
+dev: deps ## Build and install a development build
 	@grep 'const VersionPrerelease = ""' version/version.go > /dev/null ; if [ $$? -eq 0 ]; then \
 		echo "ERROR: You must add prerelease tags to version/version.go prior to making a dev build."; \
 		exit 1; \
@@ -66,25 +61,19 @@ dev: ## Build and install a development build
 	@cp $(GOPATH)/bin/packer pkg/$(GOOS)_$(GOARCH)
 
 fmt: ## Format Go code
-	@go fmt ./...
+	@gofmt -w -s main.go $(UNFORMATTED_FILES)
 
-fmt-check: fmt ## Check go code formatting
-	@echo "==> Checking that code complies with go fmt requirements..."
-	@git diff --exit-code; if [ $$? -eq 1 ]; then \
-		echo "Found files that are not fmt'ed."; \
+fmt-check: ## Check go code formatting
+	@echo "==> Checking that code complies with gofmt requirements..."
+	@if [ ! -z "$(UNFORMATTED_FILES)" ]; then \
+		echo "gofmt needs to be run on the following files:"; \
+		echo "$(UNFORMATTED_FILES)" | xargs -n1; \
 		echo "You can use the command: \`make fmt\` to reformat code."; \
 		exit 1; \
-	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 {} \;
 
@@ -94,44 +83,31 @@ fmt-examples:
 
 # generate runs `go generate` to build the dynamically generated
 # source files.
-generate: install-gen-deps ## Generate dynamically generated code
-	@echo "==> removing autogenerated markdown..."
-	@find website/source/ -type f | xargs grep -l '^<!-- Code generated' | xargs rm
-	go generate ./...
-	go fmt common/bootcommand/boot_command.go
-	go fmt command/plugin.go
+generate: deps ## Generate dynamically generated code
+	go generate .
+	gofmt -w common/bootcommand/boot_command.go
+	goimports -w common/bootcommand/boot_command.go
+	gofmt -w command/plugin.go
 
-generate-check: generate ## Check go code generation is on par
-	@echo "==> Checking that auto-generated code is not changed..."
-	@git diff --exit-code; if [ $$? -eq 1 ]; then \
-		echo "Found diffs in go generated code."; \
-		echo "You can use the command: \`make generate\` to reformat code."; \
-		exit 1; \
-	fi
-
-test: mode-check vet ## Run unit tests
-	@go test $(TEST) $(TESTARGS) -timeout=3m
-
-# testacc runs acceptance tests
-testacc: install-build-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: mode-check vet ## Test with race detection enabled
-	@GO111MODULE=off go test -race $(TEST) $(TESTARGS) -timeout=3m -p=8
-
-check-vendor-vs-mod: ## Check that go modules and vendored code are on par
-	@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
-
-vet: ## Vet Go code
-	@go vet $(VET)  ; if [ $$? -eq 1 ]; then \
+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: deps ## Test for race conditions
+	@go test -race $(TEST) $(TESTARGS) -timeout=2m
+
+updatedeps:
+	@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,18 +16,68 @@ 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
+  - go get golang.org/x/tools/cmd/stringer
 
 build_script:
   - git rev-parse HEAD
  # go test $(go list ./... | grep -v vendor)
   - ps: |
-      go.exe test -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

background_check.go

@@ -1,22 +0,0 @@
-// +build !openbsd
-
-package main
-
-import (
-	"fmt"
-
-	"github.com/shirou/gopsutil/process"
-)
-
-func checkProcess(currentPID int) (bool, error) {
-	myProc, err := process.NewProcess(int32(currentPID))
-	if err != nil {
-		return false, fmt.Errorf("Process check error: %s", err)
-	}
-	bg, err := myProc.Background()
-	if err != nil {
-		return bg, fmt.Errorf("Process background check error: %s", err)
-	}
-
-	return bg, nil
-}

background_check_openbsd.go

@@ -1,10 +0,0 @@
-package main
-
-import (
-	"fmt"
-)
-
-func checkProcess(currentPID int) (bool, error) {
-	return false, fmt.Errorf("cannot determine if process is backgrounded in " +
-		"openbsd")
-}

builder/alicloud/ecs/access_config.go

@@ -1,61 +1,39 @@
-//go:generate struct-markdown
-
 package ecs
 
 import (
 	"fmt"
 	"os"
-	"time"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/template/interpolate"
-	"github.com/hashicorp/packer/version"
 )
 
 // Config of alicloud
 type AlicloudAccessConfig struct {
-	// This is the Alicloud access key. It must be provided, but it can also be
-	// sourced from the ALICLOUD_ACCESS_KEY environment variable.
-	AlicloudAccessKey string `mapstructure:"access_key" required:"true"`
-	// This is the Alicloud secret key. It must be provided, but it can also be
-	// sourced from the ALICLOUD_SECRET_KEY environment variable.
-	AlicloudSecretKey string `mapstructure:"secret_key" required:"true"`
-	// This is the Alicloud region. It must be provided, but it can also be
-	// sourced from the ALICLOUD_REGION environment variables.
-	AlicloudRegion string `mapstructure:"region" required:"true"`
-	// The region validation can be skipped if this value is true, the default
-	// value is false.
-	AlicloudSkipValidation bool `mapstructure:"skip_region_validation" required:"false"`
-	// STS access token, can be set through template or by exporting as
-	// environment variable such as `export SECURITY_TOKEN=value`.
-	SecurityToken string `mapstructure:"security_token" required:"false"`
-
-	client *ClientWrapper
+	AlicloudAccessKey      string `mapstructure:"access_key"`
+	AlicloudSecretKey      string `mapstructure:"secret_key"`
+	AlicloudRegion         string `mapstructure:"region"`
+	AlicloudSkipValidation bool   `mapstructure:"skip_region_validation"`
+	SecurityToken          string `mapstructure:"security_token"`
 }
 
-const Packer = "HashiCorp-Packer"
-const DefaultRequestReadTimeout = 10 * time.Second
-
 // Client for AlicloudClient
-func (c *AlicloudAccessConfig) Client() (*ClientWrapper, error) {
-	if c.client != nil {
-		return c.client, nil
+func (c *AlicloudAccessConfig) Client() (*ecs.Client, error) {
+	if err := c.loadAndValidate(); err != nil {
+		return nil, err
 	}
 	if c.SecurityToken == "" {
 		c.SecurityToken = os.Getenv("SECURITY_TOKEN")
 	}
+	client := ecs.NewECSClientWithSecurityToken(c.AlicloudAccessKey, c.AlicloudSecretKey,
+		c.SecurityToken, common.Region(c.AlicloudRegion))
 
-	client, err := ecs.NewClientWithStsToken(c.AlicloudRegion, c.AlicloudAccessKey,
-		c.AlicloudSecretKey, c.SecurityToken)
-	if err != nil {
+	client.SetBusinessInfo("Packer")
+	if _, err := client.DescribeRegions(); err != nil {
 		return nil, err
 	}
-
-	client.AppendUserAgent(Packer, version.FormattedVersion())
-	client.SetReadTimeout(DefaultRequestReadTimeout)
-	c.client = &ClientWrapper{client}
-
-	return c.client, nil
+	return client, nil
 }
 
 func (c *AlicloudAccessConfig) Prepare(ctx *interpolate.Context) []error {
@@ -64,12 +42,10 @@ func (c *AlicloudAccessConfig) Prepare(ctx *interpolate.Context) []error {
 		errs = append(errs, err)
 	}
 
-	if c.AlicloudRegion == "" {
-		c.AlicloudRegion = os.Getenv("ALICLOUD_REGION")
-	}
-
-	if c.AlicloudRegion == "" {
-		errs = append(errs, fmt.Errorf("region option or ALICLOUD_REGION must be provided in template file or environment variables."))
+	if c.AlicloudRegion != "" && !c.AlicloudSkipValidation {
+		if c.validateRegion() != nil {
+			errs = append(errs, fmt.Errorf("Unknown alicloud region: %s", c.AlicloudRegion))
+		}
 	}
 
 	if len(errs) > 0 {
@@ -93,38 +69,21 @@ func (c *AlicloudAccessConfig) Config() error {
 
 }
 
-func (c *AlicloudAccessConfig) ValidateRegion(region string) error {
-
-	supportedRegions, err := c.getSupportedRegions()
-	if err != nil {
+func (c *AlicloudAccessConfig) loadAndValidate() error {
+	if err := c.validateRegion(); err != nil {
 		return err
 	}
 
-	for _, supportedRegion := range supportedRegions {
-		if region == supportedRegion {
+	return nil
+}
+
+func (c *AlicloudAccessConfig) validateRegion() error {
+
+	for _, valid := range common.ValidRegions {
+		if c.AlicloudRegion == string(valid) {
 			return nil
 		}
 	}
 
-	return fmt.Errorf("Not a valid alicloud region: %s", region)
-}
-
-func (c *AlicloudAccessConfig) getSupportedRegions() ([]string, error) {
-	client, err := c.Client()
-	if err != nil {
-		return nil, err
-	}
-
-	regionsRequest := ecs.CreateDescribeRegionsRequest()
-	regionsResponse, err := client.DescribeRegions(regionsRequest)
-	if err != nil {
-		return nil, err
-	}
-
-	validRegions := make([]string, len(regionsResponse.Regions.Region))
-	for _, valid := range regionsResponse.Regions.Region {
-		validRegions = append(validRegions, valid.RegionId)
-	}
-
-	return validRegions, nil
+	return fmt.Errorf("Not a valid alicloud region: %s", c.AlicloudRegion)
 }

builder/alicloud/ecs/access_config_test.go

@@ -1,7 +1,6 @@
 package ecs
 
 import (
-	"os"
 	"testing"
 )
 
@@ -15,10 +14,14 @@ func testAlicloudAccessConfig() *AlicloudAccessConfig {
 
 func TestAlicloudAccessConfigPrepareRegion(t *testing.T) {
 	c := testAlicloudAccessConfig()
-
 	c.AlicloudRegion = ""
+	if err := c.Prepare(nil); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
+	}
+
+	c.AlicloudRegion = "cn-beijing-3"
 	if err := c.Prepare(nil); err == nil {
-		t.Fatalf("should have err")
+		t.Fatal("should have error")
 	}
 
 	c.AlicloudRegion = "cn-beijing"
@@ -26,11 +29,16 @@ func TestAlicloudAccessConfigPrepareRegion(t *testing.T) {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
 
-	os.Setenv("ALICLOUD_REGION", "cn-hangzhou")
-	c.AlicloudRegion = ""
+	c.AlicloudRegion = "unknown"
+	if err := c.Prepare(nil); err == nil {
+		t.Fatalf("should have err")
+	}
+
+	c.AlicloudRegion = "unknown"
+	c.AlicloudSkipValidation = true
 	if err := c.Prepare(nil); err != nil {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
-
 	c.AlicloudSkipValidation = false
+
 }

builder/alicloud/ecs/artifact.go

@@ -6,7 +6,8 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/packer"
 )
 
@@ -18,7 +19,7 @@ type Artifact struct {
 	BuilderIdValue string
 
 	// Alcloud connection for performing API stuff.
-	Client *ClientWrapper
+	Client *ecs.Client
 }
 
 func (a *Artifact) BuilderId() string {
@@ -63,73 +64,53 @@ func (a *Artifact) State(name string) interface{} {
 func (a *Artifact) Destroy() error {
 	errors := make([]error, 0)
 
-	copyingImages := make(map[string]string, len(a.AlicloudImages))
-	sourceImage := make(map[string]*ecs.Image, 1)
-	for regionId, imageId := range a.AlicloudImages {
-		describeImagesRequest := ecs.CreateDescribeImagesRequest()
-		describeImagesRequest.RegionId = regionId
-		describeImagesRequest.ImageId = imageId
-		describeImagesRequest.Status = ImageStatusQueried
-		imagesResponse, err := a.Client.DescribeImages(describeImagesRequest)
+	for region, imageId := range a.AlicloudImages {
+		log.Printf("Delete alicloud image ID (%s) from region (%s)", imageId, region)
+
+		// Get alicloud image metadata
+		images, _, err := a.Client.DescribeImages(&ecs.DescribeImagesArgs{
+			RegionId: common.Region(region),
+			ImageId:  imageId})
 		if err != nil {
 			errors = append(errors, err)
 		}
-
-		images := imagesResponse.Images.Image
 		if len(images) == 0 {
 			err := fmt.Errorf("Error retrieving details for alicloud image(%s), no alicloud images found", imageId)
 			errors = append(errors, err)
 			continue
 		}
-
-		if images[0].IsCopied && images[0].Status != ImageStatusAvailable {
-			copyingImages[regionId] = imageId
-		} else {
-			sourceImage[regionId] = &images[0]
-		}
-	}
-
-	for regionId, imageId := range copyingImages {
-		log.Printf("Cancel copying alicloud image (%s) from region (%s)", imageId, regionId)
-
-		errs := a.unsharedAccountsOnImages(regionId, imageId)
-		if errs != nil {
-			errors = append(errors, errs...)
-		}
-
-		cancelImageCopyRequest := ecs.CreateCancelCopyImageRequest()
-		cancelImageCopyRequest.RegionId = regionId
-		cancelImageCopyRequest.ImageId = imageId
-		if _, err := a.Client.CancelCopyImage(cancelImageCopyRequest); err != nil {
+		//Unshared the shared account before destroy
+		sharePermissions, err := a.Client.DescribeImageSharePermission(&ecs.ModifyImageSharePermissionArgs{RegionId: common.Region(region), ImageId: imageId})
+		if err != nil {
 			errors = append(errors, err)
 		}
-	}
+		accountsNumber := len(sharePermissions.Accounts.Account)
+		if accountsNumber > 0 {
+			accounts := make([]string, accountsNumber)
+			for index, account := range sharePermissions.Accounts.Account {
+				accounts[index] = account.AliyunId
+			}
+			err := a.Client.ModifyImageSharePermission(&ecs.ModifyImageSharePermissionArgs{
 
-	for regionId, image := range sourceImage {
-		imageId := image.ImageId
-		log.Printf("Delete alicloud image (%s) from region (%s)", imageId, regionId)
-
-		errs := a.unsharedAccountsOnImages(regionId, imageId)
-		if errs != nil {
-			errors = append(errors, errs...)
-		}
-
-		deleteImageRequest := ecs.CreateDeleteImageRequest()
-		deleteImageRequest.RegionId = regionId
-		deleteImageRequest.ImageId = imageId
-		if _, err := a.Client.DeleteImage(deleteImageRequest); err != nil {
-			errors = append(errors, err)
-		}
-
-		//Delete the snapshot of this images
-		for _, diskDevices := range image.DiskDeviceMappings.DiskDeviceMapping {
-			deleteSnapshotRequest := ecs.CreateDeleteSnapshotRequest()
-			deleteSnapshotRequest.SnapshotId = diskDevices.SnapshotId
-			_, err := a.Client.DeleteSnapshot(deleteSnapshotRequest)
+				RegionId:      common.Region(region),
+				ImageId:       imageId,
+				RemoveAccount: accounts,
+			})
 			if err != nil {
 				errors = append(errors, err)
 			}
 		}
+		// Delete alicloud images
+		if err := a.Client.DeleteImage(common.Region(region), imageId); err != nil {
+			errors = append(errors, err)
+		}
+		//Delete the snapshot of this images
+		for _, diskDevices := range images[0].DiskDeviceMappings.DiskDeviceMapping {
+			if err := a.Client.DeleteSnapshot(diskDevices.SnapshotId); err != nil {
+				errors = append(errors, err)
+			}
+		}
+
 	}
 
 	if len(errors) > 0 {
@@ -143,38 +124,6 @@ func (a *Artifact) Destroy() error {
 	return nil
 }
 
-func (a *Artifact) unsharedAccountsOnImages(regionId string, imageId string) []error {
-	var errors []error
-
-	describeImageShareRequest := ecs.CreateDescribeImageSharePermissionRequest()
-	describeImageShareRequest.RegionId = regionId
-	describeImageShareRequest.ImageId = imageId
-	imageShareResponse, err := a.Client.DescribeImageSharePermission(describeImageShareRequest)
-	if err != nil {
-		errors = append(errors, err)
-		return errors
-	}
-
-	accountsNumber := len(imageShareResponse.Accounts.Account)
-	if accountsNumber > 0 {
-		accounts := make([]string, accountsNumber)
-		for index, account := range imageShareResponse.Accounts.Account {
-			accounts[index] = account.AliyunId
-		}
-
-		modifyImageShareRequest := ecs.CreateModifyImageSharePermissionRequest()
-		modifyImageShareRequest.RegionId = regionId
-		modifyImageShareRequest.ImageId = imageId
-		modifyImageShareRequest.RemoveAccount = &accounts
-		_, err := a.Client.ModifyImageSharePermission(modifyImageShareRequest)
-		if err != nil {
-			errors = append(errors, err)
-		}
-	}
-
-	return errors
-}
-
 func (a *Artifact) stateAtlasMetadata() interface{} {
 	metadata := make(map[string]string)
 	for region, imageId := range a.AlicloudImages {

builder/alicloud/ecs/builder.go

@@ -3,7 +3,8 @@
 package ecs
 
 import (
-	"context"
+	"log"
+
 	"fmt"
 
 	"github.com/hashicorp/packer/common"
@@ -34,6 +35,8 @@ type Builder struct {
 type InstanceNetWork string
 
 const (
+	ClassicNet                     = InstanceNetWork("classic")
+	VpcNet                         = InstanceNetWork("vpc")
 	ALICLOUD_DEFAULT_SHORT_TIMEOUT = 180
 	ALICLOUD_DEFAULT_TIMEOUT       = 1800
 	ALICLOUD_DEFAULT_LONG_TIMEOUT  = 3600
@@ -54,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)...)
@@ -70,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)
@@ -103,7 +102,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			RegionId:     b.config.AlicloudRegion,
 		},
 	}
-	if b.chooseNetworkType() == InstanceNetworkVpc {
+	if b.chooseNetworkType() == VpcNet {
 		steps = append(steps,
 			&stepConfigAlicloudVPC{
 				VpcId:     b.config.VpcId,
@@ -134,23 +133,22 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			InstanceName:            b.config.InstanceName,
 			ZoneId:                  b.config.ZoneId,
 		})
-	if b.chooseNetworkType() == InstanceNetworkVpc {
+	if b.chooseNetworkType() == VpcNet {
 		steps = append(steps, &stepConfigAlicloudEIP{
 			AssociatePublicIpAddress: b.config.AssociatePublicIpAddress,
 			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,
 		&stepAttachKeyPair{},
 		&stepRunAlicloudInstance{},
+		&stepMountAlicloudDisk{},
 		&communicator.StepConnect{
 			Config: &b.config.RunConfig.Comm,
 			Host: SSHHost(
@@ -159,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,
@@ -201,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 {
@@ -223,11 +201,18 @@ 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 InstanceNetworkVpc
+		return VpcNet
 	} else {
-		return InstanceNetworkClassic
+		return ClassicNet
 	}
 }
 
@@ -252,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

@@ -1,48 +1,18 @@
 package ecs
 
 import (
-	"encoding/json"
-	"fmt"
 	"os"
-	"strings"
 	"testing"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"fmt"
+
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	builderT "github.com/hashicorp/packer/helper/builder/testing"
 	"github.com/hashicorp/packer/packer"
 )
 
-const defaultTestRegion = "cn-beijing"
-
-func TestBuilderAcc_validateRegion(t *testing.T) {
-	t.Parallel()
-
-	if os.Getenv(builderT.TestEnvVar) == "" {
-		t.Skip(fmt.Sprintf("Acceptance tests skipped unless env '%s' set", builderT.TestEnvVar))
-		return
-	}
-
-	testAccPreCheck(t)
-
-	access := &AlicloudAccessConfig{AlicloudRegion: "cn-beijing"}
-	err := access.Config()
-	if err != nil {
-		t.Fatalf("init AlicloudAccessConfig failed: %s", err)
-	}
-
-	err = access.ValidateRegion("cn-hangzhou")
-	if err != nil {
-		t.Fatalf("Expect pass with valid region id but failed: %s", err)
-	}
-
-	err = access.ValidateRegion("invalidRegionId")
-	if err == nil {
-		t.Fatal("Expect failure due to invalid region id but passed")
-	}
-}
-
 func TestBuilderAcc_basic(t *testing.T) {
-	t.Parallel()
 	builderT.Test(t, builderT.TestCase{
 		PreCheck: func() {
 			testAccPreCheck(t)
@@ -52,326 +22,28 @@ func TestBuilderAcc_basic(t *testing.T) {
 	})
 }
 
-const testBuilderAccBasic = `
-{	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_name": "packer-test-basic_{{timestamp}}"
-	}]
-}`
+//func TestBuilderAcc_windows(t *testing.T) {
+//	builderT.Test(t, builderT.TestCase{
+//		PreCheck: func() {
+//			testAccPreCheck(t)
+//		},
+//		Builder:  &Builder{},
+//		Template: testBuilderAccWindows,
+//	})
+//}
 
-func TestBuilderAcc_withDiskSettings(t *testing.T) {
-	t.Parallel()
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccWithDiskSettings,
-		Check:    checkImageDisksSettings(),
-	})
-}
-
-const testBuilderAccWithDiskSettings = `
-{	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_name": "packer-test-withDiskSettings_{{timestamp}}",
-		"system_disk_mapping": {
-			"disk_size": 60
-		},
-		"image_disk_mappings": [
-			{
-				"disk_name": "datadisk1",
-				"disk_size": 25,
-				"disk_delete_with_instance": true
-			},
-			{
-				"disk_name": "datadisk2",
-				"disk_size": 25,
-				"disk_delete_with_instance": true
-			}
-		]
-	}]
-}`
-
-func checkImageDisksSettings() 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)
-		}
-		imageId := artifact.AlicloudImages[defaultTestRegion]
-
-		// describe the image, get block devices with a snapshot
-		client, _ := testAliyunClient()
-
-		describeImagesRequest := ecs.CreateDescribeImagesRequest()
-		describeImagesRequest.RegionId = defaultTestRegion
-		describeImagesRequest.ImageId = imageId
-		imagesResponse, err := client.DescribeImages(describeImagesRequest)
-		if err != nil {
-			return fmt.Errorf("describe images failed due to %s", err)
-		}
-
-		if len(imagesResponse.Images.Image) == 0 {
-			return fmt.Errorf("image %s generated can not be found", imageId)
-		}
-
-		image := imagesResponse.Images.Image[0]
-		if image.Size != 60 {
-			return fmt.Errorf("the size of image %s should be equal to 60G but got %dG", imageId, image.Size)
-		}
-		if len(image.DiskDeviceMappings.DiskDeviceMapping) != 3 {
-			return fmt.Errorf("image %s should contains 3 disks", imageId)
-		}
-
-		var snapshotIds []string
-		for _, mapping := range image.DiskDeviceMappings.DiskDeviceMapping {
-			if mapping.Type == DiskTypeSystem {
-				if mapping.Size != "60" {
-					return fmt.Errorf("the system snapshot size of image %s should be equal to 60G but got %sG", imageId, mapping.Size)
-				}
-			} else {
-				if mapping.Size != "25" {
-					return fmt.Errorf("the data disk size of image %s should be equal to 25G but got %sG", imageId, mapping.Size)
-				}
-
-				snapshotIds = append(snapshotIds, mapping.SnapshotId)
-			}
-		}
-
-		data, _ := json.Marshal(snapshotIds)
-
-		describeSnapshotRequest := ecs.CreateDescribeSnapshotsRequest()
-		describeSnapshotRequest.RegionId = defaultTestRegion
-		describeSnapshotRequest.SnapshotIds = string(data)
-		describeSnapshotsResponse, err := client.DescribeSnapshots(describeSnapshotRequest)
-		if err != nil {
-			return fmt.Errorf("describe data snapshots failed due to %s", err)
-		}
-		if len(describeSnapshotsResponse.Snapshots.Snapshot) != 2 {
-			return fmt.Errorf("expect %d data snapshots but got %d", len(snapshotIds), len(describeSnapshotsResponse.Snapshots.Snapshot))
-		}
-
-		var dataDiskIds []string
-		for _, snapshot := range describeSnapshotsResponse.Snapshots.Snapshot {
-			dataDiskIds = append(dataDiskIds, snapshot.SourceDiskId)
-		}
-		data, _ = json.Marshal(dataDiskIds)
-
-		describeDisksRequest := ecs.CreateDescribeDisksRequest()
-		describeDisksRequest.RegionId = defaultTestRegion
-		describeDisksRequest.DiskIds = string(data)
-		describeDisksResponse, err := client.DescribeDisks(describeDisksRequest)
-		if err != nil {
-			return fmt.Errorf("describe snapshots failed due to %s", err)
-		}
-		if len(describeDisksResponse.Disks.Disk) != 0 {
-			return fmt.Errorf("data disks should be deleted but %d left", len(describeDisksResponse.Disks.Disk))
-		}
-
-		return nil
-	}
-}
-
-func TestBuilderAcc_withIgnoreDataDisks(t *testing.T) {
-	t.Parallel()
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccIgnoreDataDisks,
-		Check:    checkIgnoreDataDisks(),
-	})
-}
-
-const testBuilderAccIgnoreDataDisks = `
-{	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.gn5-c8g1.2xlarge",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_name": "packer-test-ignoreDataDisks_{{timestamp}}",
-		"image_ignore_data_disks": true
-	}]
-}`
-
-func checkIgnoreDataDisks() 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)
-		}
-		imageId := artifact.AlicloudImages[defaultTestRegion]
-
-		// describe the image, get block devices with a snapshot
-		client, _ := testAliyunClient()
-
-		describeImagesRequest := ecs.CreateDescribeImagesRequest()
-		describeImagesRequest.RegionId = defaultTestRegion
-		describeImagesRequest.ImageId = imageId
-		imagesResponse, err := client.DescribeImages(describeImagesRequest)
-		if err != nil {
-			return fmt.Errorf("describe images failed due to %s", err)
-		}
-
-		if len(imagesResponse.Images.Image) == 0 {
-			return fmt.Errorf("image %s generated can not be found", imageId)
-		}
-
-		image := imagesResponse.Images.Image[0]
-		if len(image.DiskDeviceMappings.DiskDeviceMapping) != 1 {
-			return fmt.Errorf("image %s should only contain one disks", imageId)
-		}
-
-		return nil
-	}
-}
-
-func TestBuilderAcc_windows(t *testing.T) {
-	t.Parallel()
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccWindows,
-	})
-}
-
-const testBuilderAccWindows = `
-{	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"winsvr_64_dtcC_1809_en-us_40G_alibase_20190318.vhd",
-		"io_optimized":"true",
-		"communicator": "winrm",
-		"winrm_port": 5985,
-		"winrm_username": "Administrator",
-		"winrm_password": "Test1234",
-		"image_name": "packer-test-windows_{{timestamp}}",
-		"user_data_file": "../../../examples/alicloud/basic/winrm_enable_userdata.ps1"
-	}]
-}`
-
-func TestBuilderAcc_regionCopy(t *testing.T) {
-	t.Parallel()
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccRegionCopy,
-		Check:    checkRegionCopy([]string{"cn-hangzhou", "cn-shenzhen"}),
-	})
-}
-
-const testBuilderAccRegionCopy = `
-{
-	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_name": "packer-test-regionCopy_{{timestamp}}",
-		"image_copy_regions": ["cn-hangzhou", "cn-shenzhen"],
-		"image_copy_names": ["packer-copy-test-hz_{{timestamp}}", "packer-copy-test-sz_{{timestamp}}"]
-	}]
-}
-`
-
-func checkRegionCopy(regions []string) 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)
-		}
-
-		// Verify that we copied to only the regions given
-		regionSet := make(map[string]struct{})
-		for _, r := range regions {
-			regionSet[r] = struct{}{}
-		}
-
-		for r := range artifact.AlicloudImages {
-			if r == "cn-beijing" {
-				delete(regionSet, r)
-				continue
-			}
-
-			if _, ok := regionSet[r]; !ok {
-				return fmt.Errorf("region %s is not the target region but found in artifacts", r)
-			}
-
-			delete(regionSet, r)
-		}
-
-		if len(regionSet) > 0 {
-			return fmt.Errorf("following region(s) should be the copying targets but corresponding artifact(s) not found: %#v", regionSet)
-		}
-
-		client, _ := testAliyunClient()
-		for regionId, imageId := range artifact.AlicloudImages {
-			describeImagesRequest := ecs.CreateDescribeImagesRequest()
-			describeImagesRequest.RegionId = regionId
-			describeImagesRequest.ImageId = imageId
-			describeImagesRequest.Status = ImageStatusQueried
-			describeImagesResponse, err := client.DescribeImages(describeImagesRequest)
-			if err != nil {
-				return fmt.Errorf("describe generated image %s failed due to %s", imageId, err)
-			}
-			if len(describeImagesResponse.Images.Image) == 0 {
-				return fmt.Errorf("image %s in artifacts can not be found", imageId)
-			}
-
-			image := describeImagesResponse.Images.Image[0]
-			if image.IsCopied && regionId == "cn-hangzhou" && !strings.HasPrefix(image.ImageName, "packer-copy-test-hz") {
-				return fmt.Errorf("the name of image %s in artifacts should begin with %s but got %s", imageId, "packer-copy-test-hz", image.ImageName)
-			}
-			if image.IsCopied && regionId == "cn-shenzhen" && !strings.HasPrefix(image.ImageName, "packer-copy-test-sz") {
-				return fmt.Errorf("the name of image %s in artifacts should begin with %s but got %s", imageId, "packer-copy-test-sz", image.ImageName)
-			}
-		}
-
-		return nil
-	}
-}
+//func TestBuilderAcc_regionCopy(t *testing.T) {
+//	builderT.Test(t, builderT.TestCase{
+//		PreCheck: func() {
+//			testAccPreCheck(t)
+//		},
+//		Builder:  &Builder{},
+//		Template: testBuilderAccRegionCopy,
+//		Check:    checkRegionCopy([]string{"cn-hangzhou", "cn-shenzhen"}),
+//	})
+//}
 
 func TestBuilderAcc_forceDelete(t *testing.T) {
-	t.Parallel()
 	// Build the same alicloud image twice, with ecs_image_force_delete on the second run
 	builderT.Test(t, builderT.TestCase{
 		PreCheck: func() {
@@ -391,27 +63,7 @@ func TestBuilderAcc_forceDelete(t *testing.T) {
 	})
 }
 
-func buildForceDeregisterConfig(val, name string) string {
-	return fmt.Sprintf(testBuilderAccForceDelete, val, name)
-}
-
-const testBuilderAccForceDelete = `
-{
-	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_force_delete": "%s",
-		"image_name": "packer-test-forceDelete_%s"
-	}]
-}
-`
-
 func TestBuilderAcc_ECSImageSharing(t *testing.T) {
-	t.Parallel()
 	builderT.Test(t, builderT.TestCase{
 		PreCheck: func() {
 			testAccPreCheck(t)
@@ -422,58 +74,7 @@ func TestBuilderAcc_ECSImageSharing(t *testing.T) {
 	})
 }
 
-// share with catsby
-const testBuilderAccSharing = `
-{
-	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_name": "packer-test-ECSImageSharing_{{timestamp}}",
-		"image_share_account":["1309208528360047"]
-	}]
-}
-`
-
-func checkECSImageSharing(uid string) 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()
-
-		describeImageShareRequest := ecs.CreateDescribeImageSharePermissionRequest()
-		describeImageShareRequest.RegionId = "cn-beijing"
-		describeImageShareRequest.ImageId = artifact.AlicloudImages["cn-beijing"]
-		imageShareResponse, err := client.DescribeImageSharePermission(describeImageShareRequest)
-
-		if err != nil {
-			return fmt.Errorf("Error retrieving Image Attributes for ECS Image Artifact (%#v) "+
-				"in ECS Image Sharing Test: %s", artifact, err)
-		}
-
-		if len(imageShareResponse.Accounts.Account) != 1 && imageShareResponse.Accounts.Account[0].AliyunId != uid {
-			return fmt.Errorf("share account is incorrect %d", len(imageShareResponse.Accounts.Account))
-		}
-
-		return nil
-	}
-}
-
 func TestBuilderAcc_forceDeleteSnapshot(t *testing.T) {
-	t.Parallel()
 	destImageName := "delete"
 
 	// Build the same alicloud image name twice, with force_delete_snapshot on the second run
@@ -488,13 +89,11 @@ func TestBuilderAcc_forceDeleteSnapshot(t *testing.T) {
 
 	// Get image data by image image name
 	client, _ := testAliyunClient()
+	images, _, _ := client.DescribeImages(&ecs.DescribeImagesArgs{
+		ImageName: "packer-test-" + destImageName,
+		RegionId:  common.Region("cn-beijing")})
 
-	describeImagesRequest := ecs.CreateDescribeImagesRequest()
-	describeImagesRequest.RegionId = "cn-beijing"
-	describeImagesRequest.ImageName = "packer-test-" + destImageName
-	images, _ := client.DescribeImages(describeImagesRequest)
-
-	image := images.Images.Image[0]
+	image := images[0]
 
 	// Get snapshot ids for image
 	snapshotIds := []string{}
@@ -514,44 +113,17 @@ func TestBuilderAcc_forceDeleteSnapshot(t *testing.T) {
 	})
 }
 
-func buildForceDeleteSnapshotConfig(val, name string) string {
-	return fmt.Sprintf(testBuilderAccForceDeleteSnapshot, val, val, name)
-}
-
-const testBuilderAccForceDeleteSnapshot = `
-{
-	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_force_delete_snapshots": "%s",
-		"image_force_delete": "%s",
-		"image_name": "packer-test-%s"
-	}]
-}
-`
-
 func checkSnapshotsDeleted(snapshotIds []string) builderT.TestCheckFunc {
 	return func(artifacts []packer.Artifact) error {
 		// Verify the snapshots are gone
 		client, _ := testAliyunClient()
-		data, err := json.Marshal(snapshotIds)
-		if err != nil {
-			return fmt.Errorf("Marshal snapshotIds array failed %v", err)
-		}
-
-		describeSnapshotsRequest := ecs.CreateDescribeSnapshotsRequest()
-		describeSnapshotsRequest.RegionId = "cn-beijing"
-		describeSnapshotsRequest.SnapshotIds = string(data)
-		snapshotResp, err := client.DescribeSnapshots(describeSnapshotsRequest)
+		snapshotResp, _, err := client.DescribeSnapshots(
+			&ecs.DescribeSnapshotsArgs{RegionId: common.Region("cn-beijing"), SnapshotIds: snapshotIds},
+		)
 		if err != nil {
 			return fmt.Errorf("Query snapshot failed %v", err)
 		}
-		snapshots := snapshotResp.Snapshots.Snapshot
-		if len(snapshots) > 0 {
+		if len(snapshotResp) > 0 {
 			return fmt.Errorf("Snapshots weren't successfully deleted by " +
 				"`ecs_image_force_delete_snapshots`")
 		}
@@ -559,164 +131,43 @@ func checkSnapshotsDeleted(snapshotIds []string) builderT.TestCheckFunc {
 	}
 }
 
-func TestBuilderAcc_imageTags(t *testing.T) {
-	t.Parallel()
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccImageTags,
-		Check:    checkImageTags(),
-	})
-}
-
-const testBuilderAccImageTags = `
-{	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"ssh_username": "root",
-		"io_optimized":"true",
-		"image_name": "packer-test-imageTags_{{timestamp}}",
-		"tags": {
-			"TagKey1": "TagValue1",
-			"TagKey2": "TagValue2"
-       }
-	}]
-}`
-
-func checkImageTags() builderT.TestCheckFunc {
+func checkECSImageSharing(uid string) 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)
 		}
-		imageId := artifact.AlicloudImages[defaultTestRegion]
 
 		// describe the image, get block devices with a snapshot
 		client, _ := testAliyunClient()
+		imageSharePermissionResponse, err := client.DescribeImageSharePermission(
+			&ecs.ModifyImageSharePermissionArgs{
+				RegionId: "cn-beijing",
+				ImageId:  artifact.AlicloudImages["cn-beijing"],
+			})
 
-		describeImageTagsRequest := ecs.CreateDescribeTagsRequest()
-		describeImageTagsRequest.RegionId = defaultTestRegion
-		describeImageTagsRequest.ResourceType = TagResourceImage
-		describeImageTagsRequest.ResourceId = imageId
-		imageTagsResponse, err := client.DescribeTags(describeImageTagsRequest)
 		if err != nil {
 			return fmt.Errorf("Error retrieving Image Attributes for ECS Image Artifact (%#v) "+
-				"in ECS Image Tags Test: %s", artifact, err)
+				"in ECS Image Sharing Test: %s", artifact, err)
 		}
 
-		if len(imageTagsResponse.Tags.Tag) != 2 {
-			return fmt.Errorf("expect 2 tags set on image %s but got %d", imageId, len(imageTagsResponse.Tags.Tag))
-		}
-
-		for _, tag := range imageTagsResponse.Tags.Tag {
-			if tag.TagKey != "TagKey1" && tag.TagKey != "TagKey2" {
-				return fmt.Errorf("tags on image %s should be within the list of TagKey1 and TagKey2 but got %s", imageId, tag.TagKey)
-			}
-
-			if tag.TagKey == "TagKey1" && tag.TagValue != "TagValue1" {
-				return fmt.Errorf("the value for tag %s on image %s should be TagValue1 but got %s", tag.TagKey, imageId, tag.TagValue)
-			} else if tag.TagKey == "TagKey2" && tag.TagValue != "TagValue2" {
-				return fmt.Errorf("the value for tag %s on image %s should be TagValue2 but got %s", tag.TagKey, imageId, tag.TagValue)
-			}
-		}
-
-		describeImagesRequest := ecs.CreateDescribeImagesRequest()
-		describeImagesRequest.RegionId = defaultTestRegion
-		describeImagesRequest.ImageId = imageId
-		imagesResponse, err := client.DescribeImages(describeImagesRequest)
-		if err != nil {
-			return fmt.Errorf("describe images failed due to %s", err)
-		}
-
-		if len(imagesResponse.Images.Image) == 0 {
-			return fmt.Errorf("image %s generated can not be found", imageId)
-		}
-
-		image := imagesResponse.Images.Image[0]
-		for _, mapping := range image.DiskDeviceMappings.DiskDeviceMapping {
-			describeSnapshotTagsRequest := ecs.CreateDescribeTagsRequest()
-			describeSnapshotTagsRequest.RegionId = defaultTestRegion
-			describeSnapshotTagsRequest.ResourceType = TagResourceSnapshot
-			describeSnapshotTagsRequest.ResourceId = mapping.SnapshotId
-			snapshotTagsResponse, err := client.DescribeTags(describeSnapshotTagsRequest)
-			if err != nil {
-				return fmt.Errorf("failed to get snapshot tags due to %s", err)
-			}
-
-			if len(snapshotTagsResponse.Tags.Tag) != 2 {
-				return fmt.Errorf("expect 2 tags set on snapshot %s but got %d", mapping.SnapshotId, len(snapshotTagsResponse.Tags.Tag))
-			}
-
-			for _, tag := range snapshotTagsResponse.Tags.Tag {
-				if tag.TagKey != "TagKey1" && tag.TagKey != "TagKey2" {
-					return fmt.Errorf("tags on snapshot %s should be within the list of TagKey1 and TagKey2 but got %s", mapping.SnapshotId, tag.TagKey)
-				}
-
-				if tag.TagKey == "TagKey1" && tag.TagValue != "TagValue1" {
-					return fmt.Errorf("the value for tag %s on snapshot %s should be TagValue1 but got %s", tag.TagKey, mapping.SnapshotId, tag.TagValue)
-				} else if tag.TagKey == "TagKey2" && tag.TagValue != "TagValue2" {
-					return fmt.Errorf("the value for tag %s on snapshot %s should be TagValue2 but got %s", tag.TagKey, mapping.SnapshotId, tag.TagValue)
-				}
-			}
+		if len(imageSharePermissionResponse.Accounts.Account) != 1 &&
+			imageSharePermissionResponse.Accounts.Account[0].AliyunId != uid {
+			return fmt.Errorf("share account is incorrect %d",
+				len(imageSharePermissionResponse.Accounts.Account))
 		}
 
 		return nil
 	}
 }
 
-func TestBuilderAcc_dataDiskEncrypted(t *testing.T) {
-	t.Parallel()
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccDataDiskEncrypted,
-		Check:    checkDataDiskEncrypted(),
-	})
-}
-
-const testBuilderAccDataDiskEncrypted = `
-{	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_name": "packer-test-dataDiskEncrypted_{{timestamp}}",
-		"image_disk_mappings": [
-			{
-				"disk_name": "data_disk1",
-				"disk_size": 25,
-				"disk_encrypted": true,
-				"disk_delete_with_instance": true
-			},
-			{
-				"disk_name": "data_disk2",
-				"disk_size": 35,
-				"disk_encrypted": false,
-				"disk_delete_with_instance": true
-			},
-			{
-				"disk_name": "data_disk3",
-				"disk_size": 45,
-				"disk_delete_with_instance": true
-			}
-		]
-	}]
-}`
-
-func checkDataDiskEncrypted() builderT.TestCheckFunc {
+func checkRegionCopy(regions []string) builderT.TestCheckFunc {
 	return func(artifacts []packer.Artifact) error {
 		if len(artifacts) > 1 {
 			return fmt.Errorf("more than 1 artifact")
@@ -728,141 +179,30 @@ func checkDataDiskEncrypted() builderT.TestCheckFunc {
 		if !ok {
 			return fmt.Errorf("unknown artifact: %#v", artifactRaw)
 		}
-		imageId := artifact.AlicloudImages[defaultTestRegion]
 
-		// describe the image, get block devices with a snapshot
-		client, _ := testAliyunClient()
-
-		describeImagesRequest := ecs.CreateDescribeImagesRequest()
-		describeImagesRequest.RegionId = defaultTestRegion
-		describeImagesRequest.ImageId = imageId
-		imagesResponse, err := client.DescribeImages(describeImagesRequest)
-		if err != nil {
-			return fmt.Errorf("describe images failed due to %s", err)
+		// Verify that we copied to only the regions given
+		regionSet := make(map[string]struct{})
+		for _, r := range regions {
+			regionSet[r] = struct{}{}
 		}
-
-		if len(imagesResponse.Images.Image) == 0 {
-			return fmt.Errorf("image %s generated can not be found", imageId)
-		}
-		image := imagesResponse.Images.Image[0]
-
-		var snapshotIds []string
-		for _, mapping := range image.DiskDeviceMappings.DiskDeviceMapping {
-			snapshotIds = append(snapshotIds, mapping.SnapshotId)
-		}
-
-		data, _ := json.Marshal(snapshotIds)
-
-		describeSnapshotRequest := ecs.CreateDescribeSnapshotsRequest()
-		describeSnapshotRequest.RegionId = defaultTestRegion
-		describeSnapshotRequest.SnapshotIds = string(data)
-		describeSnapshotsResponse, err := client.DescribeSnapshots(describeSnapshotRequest)
-		if err != nil {
-			return fmt.Errorf("describe data snapshots failed due to %s", err)
-		}
-		if len(describeSnapshotsResponse.Snapshots.Snapshot) != 4 {
-			return fmt.Errorf("expect %d data snapshots but got %d", len(snapshotIds), len(describeSnapshotsResponse.Snapshots.Snapshot))
-		}
-		snapshots := describeSnapshotsResponse.Snapshots.Snapshot
-		for _, snapshot := range snapshots {
-			if snapshot.SourceDiskType == DiskTypeSystem {
-				if snapshot.Encrypted != false {
-					return fmt.Errorf("the system snapshot expected to be non-encrypted but got true")
-				}
-
+		for r := range artifact.AlicloudImages {
+			if r == "cn-beijing" {
+				delete(regionSet, r)
 				continue
 			}
-
-			if snapshot.SourceDiskSize == "25" && snapshot.Encrypted != true {
-				return fmt.Errorf("the first snapshot expected to be encrypted but got false")
+			if _, ok := regionSet[r]; !ok {
+				return fmt.Errorf("unknown region: %s", r)
 			}
 
-			if snapshot.SourceDiskSize == "35" && snapshot.Encrypted != false {
-				return fmt.Errorf("the second snapshot expected to be non-encrypted but got true")
-			}
-
-			if snapshot.SourceDiskSize == "45" && snapshot.Encrypted != false {
-				return fmt.Errorf("the third snapshot expected to be non-encrypted but got true")
-			}
+			delete(regionSet, r)
 		}
-		return nil
-	}
-}
-
-func TestBuilderAcc_systemDiskEncrypted(t *testing.T) {
-	t.Parallel()
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccSystemDiskEncrypted,
-		Check:    checkSystemDiskEncrypted(),
-	})
-}
-
-const testBuilderAccSystemDiskEncrypted = `
-{
-	"builders": [{
-		"type": "test",
-		"region": "cn-beijing",
-		"instance_type": "ecs.n1.tiny",
-		"source_image":"ubuntu_18_04_64_20G_alibase_20190509.vhd",
-		"io_optimized":"true",
-		"ssh_username":"root",
-		"image_name": "packer-test_{{timestamp}}",
-		"image_encrypted": "true"
-	}]
-}`
-
-func checkSystemDiskEncrypted() builderT.TestCheckFunc {
-	return func(artifacts []packer.Artifact) error {
-		if len(artifacts) > 1 {
-			return fmt.Errorf("more than 1 artifact")
+		if len(regionSet) > 0 {
+			return fmt.Errorf("didn't copy to: %#v", regionSet)
 		}
-
-		// 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()
-		imageId := artifact.AlicloudImages[defaultTestRegion]
-
-		describeImagesRequest := ecs.CreateDescribeImagesRequest()
-		describeImagesRequest.RegionId = defaultTestRegion
-		describeImagesRequest.ImageId = imageId
-		describeImagesRequest.Status = ImageStatusQueried
-		imagesResponse, err := client.DescribeImages(describeImagesRequest)
-		if err != nil {
-			return fmt.Errorf("describe images failed due to %s", err)
+		for key, value := range artifact.AlicloudImages {
+			client.WaitForImageReady(common.Region(key), value, 1800)
 		}
-
-		if len(imagesResponse.Images.Image) == 0 {
-			return fmt.Errorf("image %s generated can not be found", imageId)
-		}
-
-		image := imagesResponse.Images.Image[0]
-		if image.IsCopied == false {
-			return fmt.Errorf("image %s generated expexted to be copied but false", image.ImageId)
-		}
-
-		describeSnapshotRequest := ecs.CreateDescribeSnapshotsRequest()
-		describeSnapshotRequest.RegionId = defaultTestRegion
-		describeSnapshotRequest.SnapshotIds = fmt.Sprintf("[\"%s\"]", image.DiskDeviceMappings.DiskDeviceMapping[0].SnapshotId)
-		describeSnapshotsResponse, err := client.DescribeSnapshots(describeSnapshotRequest)
-		if err != nil {
-			return fmt.Errorf("describe system snapshots failed due to %s", err)
-		}
-		snapshots := describeSnapshotsResponse.Snapshots.Snapshot[0]
-
-		if snapshots.Encrypted != true {
-			return fmt.Errorf("system snapshot of image %s expected to be encrypted but got false", imageId)
-		}
-
 		return nil
 	}
 }
@@ -877,7 +217,7 @@ func testAccPreCheck(t *testing.T) {
 	}
 }
 
-func testAliyunClient() (*ClientWrapper, error) {
+func testAliyunClient() (*ecs.Client, error) {
 	access := &AlicloudAccessConfig{AlicloudRegion: "cn-beijing"}
 	err := access.Config()
 	if err != nil {
@@ -890,3 +230,102 @@ func testAliyunClient() (*ClientWrapper, error) {
 
 	return client, nil
 }
+
+const testBuilderAccBasic = `
+{	"builders": [{
+		"type": "test",
+		"region": "cn-beijing",
+		"instance_type": "ecs.n1.tiny",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
+		"ssh_username": "ubuntu",
+		"io_optimized":"true",
+		"ssh_username":"root",
+		"image_name": "packer-test_{{timestamp}}"
+	}]
+}`
+
+const testBuilderAccRegionCopy = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "cn-beijing",
+		"instance_type": "ecs.n1.tiny",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
+		"io_optimized":"true",
+		"ssh_username":"root",
+		"image_name": "packer-test_{{timestamp}}",
+		"image_copy_regions": ["cn-hangzhou", "cn-shenzhen"]
+	}]
+}
+`
+
+const testBuilderAccForceDelete = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "cn-beijing",
+		"instance_type": "ecs.n1.tiny",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
+		"io_optimized":"true",
+		"ssh_username":"root",
+		"image_force_delete": "%s",
+		"image_name": "packer-test_%s"
+	}]
+}
+`
+
+const testBuilderAccForceDeleteSnapshot = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "cn-beijing",
+		"instance_type": "ecs.n1.tiny",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
+		"io_optimized":"true",
+		"ssh_username":"root",
+		"image_force_delete_snapshots": "%s",
+		"image_force_delete": "%s",
+		"image_name": "packer-test-%s"
+	}]
+}
+`
+
+// share with catsby
+const testBuilderAccSharing = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "cn-beijing",
+		"instance_type": "ecs.n1.tiny",
+		"source_image":"ubuntu_16_0402_64_40G_base_20170222.vhd",
+		"io_optimized":"true",
+		"ssh_username":"root",
+		"image_name": "packer-test_{{timestamp}}",
+		"image_share_account":["1309208528360047"]
+	}]
+}
+`
+
+func buildForceDeregisterConfig(val, name string) string {
+	return fmt.Sprintf(testBuilderAccForceDelete, val, name)
+}
+
+func buildForceDeleteSnapshotConfig(val, name string) string {
+	return fmt.Sprintf(testBuilderAccForceDeleteSnapshot, val, val, name)
+}
+
+const testBuilderAccWindows = `
+{	"builders": [{
+		"type": "test",
+		"region": "cn-beijing",
+		"instance_type": "ecs.n1.tiny",
+		"source_image":"win2008_64_ent_r2_zh-cn_40G_alibase_20170301.vhd",
+		"io_optimized":"true",
+		"image_force_delete":"true",
+		"communicator": "winrm",
+		"winrm_port": 5985,
+		"winrm_username": "Administrator",
+		"winrm_password": "Test1234",
+		"image_name": "packer-test_{{timestamp}}"
+	}]
+}`

builder/alicloud/ecs/builder_test.go

@@ -1,10 +1,8 @@
 package ecs
 
 import (
-	"reflect"
 	"testing"
 
-	helperconfig "github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/packer"
 )
 
@@ -95,143 +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)
-	}
-	expected := AlicloudDiskDevice{
-		DiskCategory: "cloud",
-		Description:  "system disk",
-		DiskName:     "system_disk",
-		DiskSize:     60,
-		Encrypted:    helperconfig.TriUnset,
-	}
-	if !reflect.DeepEqual(b.config.ECSSystemDiskMapping, expected) {
-		t.Fatalf("system disk is not set properly, actual: %v; expected: %v", b.config.ECSSystemDiskMapping, expected)
-	}
-	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/client.go

@@ -1,310 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
-)
-
-type ClientWrapper struct {
-	*ecs.Client
-}
-
-const (
-	InstanceStatusRunning  = "Running"
-	InstanceStatusStarting = "Starting"
-	InstanceStatusStopped  = "Stopped"
-	InstanceStatusStopping = "Stopping"
-)
-
-const (
-	ImageStatusWaiting      = "Waiting"
-	ImageStatusCreating     = "Creating"
-	ImageStatusCreateFailed = "CreateFailed"
-	ImageStatusAvailable    = "Available"
-)
-
-var ImageStatusQueried = fmt.Sprintf("%s,%s,%s,%s", ImageStatusWaiting, ImageStatusCreating, ImageStatusCreateFailed, ImageStatusAvailable)
-
-const (
-	SnapshotStatusAll          = "all"
-	SnapshotStatusProgressing  = "progressing"
-	SnapshotStatusAccomplished = "accomplished"
-	SnapshotStatusFailed       = "failed"
-)
-
-const (
-	DiskStatusInUse     = "In_use"
-	DiskStatusAvailable = "Available"
-	DiskStatusAttaching = "Attaching"
-	DiskStatusDetaching = "Detaching"
-	DiskStatusCreating  = "Creating"
-	DiskStatusReIniting = "ReIniting"
-)
-
-const (
-	VpcStatusPending   = "Pending"
-	VpcStatusAvailable = "Available"
-)
-
-const (
-	VSwitchStatusPending   = "Pending"
-	VSwitchStatusAvailable = "Available"
-)
-
-const (
-	EipStatusAssociating   = "Associating"
-	EipStatusUnassociating = "Unassociating"
-	EipStatusInUse         = "InUse"
-	EipStatusAvailable     = "Available"
-)
-
-const (
-	ImageOwnerSystem      = "system"
-	ImageOwnerSelf        = "self"
-	ImageOwnerOthers      = "others"
-	ImageOwnerMarketplace = "marketplace"
-)
-
-const (
-	IOOptimizedNone      = "none"
-	IOOptimizedOptimized = "optimized"
-)
-
-const (
-	InstanceNetworkClassic = "classic"
-	InstanceNetworkVpc     = "vpc"
-)
-
-const (
-	DiskTypeSystem = "system"
-	DiskTypeData   = "data"
-)
-
-const (
-	TagResourceImage    = "image"
-	TagResourceInstance = "instance"
-	TagResourceSnapshot = "snapshot"
-	TagResourceDisk     = "disk"
-)
-
-const (
-	IpProtocolAll  = "all"
-	IpProtocolTCP  = "tcp"
-	IpProtocolUDP  = "udp"
-	IpProtocolICMP = "icmp"
-	IpProtocolGRE  = "gre"
-)
-
-const (
-	NicTypeInternet = "internet"
-	NicTypeIntranet = "intranet"
-)
-
-const (
-	DefaultPortRange = "-1/-1"
-	DefaultCidrIp    = "0.0.0.0/0"
-	DefaultCidrBlock = "172.16.0.0/24"
-)
-
-const (
-	defaultRetryInterval = 5 * time.Second
-	defaultRetryTimes    = 12
-	shortRetryTimes      = 36
-	mediumRetryTimes     = 360
-	longRetryTimes       = 720
-)
-
-type WaitForExpectEvalResult struct {
-	evalPass  bool
-	stopRetry bool
-}
-
-var (
-	WaitForExpectSuccess = WaitForExpectEvalResult{
-		evalPass:  true,
-		stopRetry: true,
-	}
-
-	WaitForExpectToRetry = WaitForExpectEvalResult{
-		evalPass:  false,
-		stopRetry: false,
-	}
-
-	WaitForExpectFailToStop = WaitForExpectEvalResult{
-		evalPass:  false,
-		stopRetry: true,
-	}
-)
-
-type WaitForExpectArgs struct {
-	RequestFunc   func() (responses.AcsResponse, error)
-	EvalFunc      func(response responses.AcsResponse, err error) WaitForExpectEvalResult
-	RetryInterval time.Duration
-	RetryTimes    int
-	RetryTimeout  time.Duration
-}
-
-func (c *ClientWrapper) WaitForExpected(args *WaitForExpectArgs) (responses.AcsResponse, error) {
-	if args.RetryInterval <= 0 {
-		args.RetryInterval = defaultRetryInterval
-	}
-	if args.RetryTimes <= 0 {
-		args.RetryTimes = defaultRetryTimes
-	}
-
-	var timeoutPoint time.Time
-	if args.RetryTimeout > 0 {
-		timeoutPoint = time.Now().Add(args.RetryTimeout)
-	}
-
-	var lastResponse responses.AcsResponse
-	var lastError error
-
-	for i := 0; ; i++ {
-		if args.RetryTimeout > 0 && time.Now().After(timeoutPoint) {
-			break
-		}
-
-		if args.RetryTimeout <= 0 && i >= args.RetryTimes {
-			break
-		}
-
-		response, err := args.RequestFunc()
-		lastResponse = response
-		lastError = err
-
-		evalResult := args.EvalFunc(response, err)
-		if evalResult.evalPass {
-			return response, nil
-		}
-		if evalResult.stopRetry {
-			return response, err
-		}
-
-		time.Sleep(args.RetryInterval)
-	}
-
-	if lastError == nil {
-		lastError = fmt.Errorf("<no error>")
-	}
-
-	if args.RetryTimeout > 0 {
-		return lastResponse, fmt.Errorf("evaluate failed after %d seconds timeout with %d seconds retry interval: %s", int(args.RetryTimeout.Seconds()), int(args.RetryInterval.Seconds()), lastError)
-	}
-
-	return lastResponse, fmt.Errorf("evaluate failed after %d times retry with %d seconds retry interval: %s", args.RetryTimes, int(args.RetryInterval.Seconds()), lastError)
-}
-
-func (c *ClientWrapper) WaitForInstanceStatus(regionId string, instanceId string, expectedStatus string) (responses.AcsResponse, error) {
-	return c.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateDescribeInstancesRequest()
-			request.RegionId = regionId
-			request.InstanceIds = fmt.Sprintf("[\"%s\"]", instanceId)
-			return c.DescribeInstances(request)
-		},
-		EvalFunc: func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-			if err != nil {
-				return WaitForExpectToRetry
-			}
-
-			instancesResponse := response.(*ecs.DescribeInstancesResponse)
-			instances := instancesResponse.Instances.Instance
-			for _, instance := range instances {
-				if instance.Status == expectedStatus {
-					return WaitForExpectSuccess
-				}
-			}
-			return WaitForExpectToRetry
-		},
-		RetryTimes: mediumRetryTimes,
-	})
-}
-
-func (c *ClientWrapper) WaitForImageStatus(regionId string, imageId string, expectedStatus string, timeout time.Duration) (responses.AcsResponse, error) {
-	return c.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateDescribeImagesRequest()
-			request.RegionId = regionId
-			request.ImageId = imageId
-			request.Status = ImageStatusQueried
-			return c.DescribeImages(request)
-		},
-		EvalFunc: func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-			if err != nil {
-				return WaitForExpectToRetry
-			}
-
-			imagesResponse := response.(*ecs.DescribeImagesResponse)
-			images := imagesResponse.Images.Image
-			for _, image := range images {
-				if image.Status == expectedStatus {
-					return WaitForExpectSuccess
-				}
-			}
-
-			return WaitForExpectToRetry
-		},
-		RetryTimeout: timeout,
-	})
-}
-
-func (c *ClientWrapper) WaitForSnapshotStatus(regionId string, snapshotId string, expectedStatus string, timeout time.Duration) (responses.AcsResponse, error) {
-	return c.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateDescribeSnapshotsRequest()
-			request.RegionId = regionId
-			request.SnapshotIds = fmt.Sprintf("[\"%s\"]", snapshotId)
-			return c.DescribeSnapshots(request)
-		},
-		EvalFunc: func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-			if err != nil {
-				return WaitForExpectToRetry
-			}
-
-			snapshotsResponse := response.(*ecs.DescribeSnapshotsResponse)
-			snapshots := snapshotsResponse.Snapshots.Snapshot
-			for _, snapshot := range snapshots {
-				if snapshot.Status == expectedStatus {
-					return WaitForExpectSuccess
-				}
-			}
-			return WaitForExpectToRetry
-		},
-		RetryTimeout: timeout,
-	})
-}
-
-type EvalErrorType bool
-
-const (
-	EvalRetryErrorType    = EvalErrorType(true)
-	EvalNotRetryErrorType = EvalErrorType(false)
-)
-
-func (c *ClientWrapper) EvalCouldRetryResponse(evalErrors []string, evalErrorType EvalErrorType) func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-	return func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-		if err == nil {
-			return WaitForExpectSuccess
-		}
-
-		e, ok := err.(errors.Error)
-		if !ok {
-			return WaitForExpectToRetry
-		}
-
-		if evalErrorType == EvalRetryErrorType && !ContainsInArray(evalErrors, e.ErrorCode()) {
-			return WaitForExpectFailToStop
-		}
-
-		if evalErrorType == EvalNotRetryErrorType && ContainsInArray(evalErrors, e.ErrorCode()) {
-			return WaitForExpectFailToStop
-		}
-
-		return WaitForExpectToRetry
-	}
-}

builder/alicloud/ecs/client_test.go

@@ -1,83 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-)
-
-func TestWaitForExpectedExceedRetryTimes(t *testing.T) {
-	c := ClientWrapper{}
-
-	iter := 0
-	waitDone := make(chan bool, 1)
-
-	go func() {
-		_, _ = c.WaitForExpected(&WaitForExpectArgs{
-			RequestFunc: func() (responses.AcsResponse, error) {
-				iter++
-				return nil, fmt.Errorf("test: let iteration %d failed", iter)
-			},
-			EvalFunc: func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-				if err != nil {
-					fmt.Printf("need retry: %s\n", err)
-					return WaitForExpectToRetry
-				}
-
-				return WaitForExpectSuccess
-			},
-		})
-
-		waitDone <- true
-	}()
-
-	timeTolerance := 1 * time.Second
-	select {
-	case <-waitDone:
-		if iter != defaultRetryTimes {
-			t.Fatalf("WaitForExpected should terminate at the %d iterations", defaultRetryTimes)
-		}
-	case <-time.After(defaultRetryTimes*defaultRetryInterval + timeTolerance):
-		t.Fatalf("WaitForExpected should terminate within %f seconds", (defaultRetryTimes*defaultRetryInterval + timeTolerance).Seconds())
-	}
-}
-
-func TestWaitForExpectedExceedRetryTimeout(t *testing.T) {
-	c := ClientWrapper{}
-
-	expectTimeout := 10 * time.Second
-	iter := 0
-	waitDone := make(chan bool, 1)
-
-	go func() {
-		_, _ = c.WaitForExpected(&WaitForExpectArgs{
-			RequestFunc: func() (responses.AcsResponse, error) {
-				iter++
-				return nil, fmt.Errorf("test: let iteration %d failed", iter)
-			},
-			EvalFunc: func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-				if err != nil {
-					fmt.Printf("need retry: %s\n", err)
-					return WaitForExpectToRetry
-				}
-
-				return WaitForExpectSuccess
-			},
-			RetryTimeout: expectTimeout,
-		})
-
-		waitDone <- true
-	}()
-
-	timeTolerance := 1 * time.Second
-	select {
-	case <-waitDone:
-		if iter > int(expectTimeout/defaultRetryInterval) {
-			t.Fatalf("WaitForExpected should terminate before the %d iterations", int(expectTimeout/defaultRetryInterval))
-		}
-	case <-time.After(expectTimeout + timeTolerance):
-		t.Fatalf("WaitForExpected should terminate within %f seconds", (expectTimeout + timeTolerance).Seconds())
-	}
-}

builder/alicloud/ecs/image_config.go

@@ -1,198 +1,42 @@
-//go:generate struct-markdown
-
 package ecs
 
 import (
 	"fmt"
+
 	"regexp"
 	"strings"
 
-	"github.com/hashicorp/packer/helper/config"
+	"github.com/denverdino/aliyungo/common"
 	"github.com/hashicorp/packer/template/interpolate"
 )
 
 type AlicloudDiskDevice struct {
-	// The value of disk name is blank by default. [2,
-	// 128] English or Chinese characters, must begin with an
-	// uppercase/lowercase letter or Chinese character. Can contain numbers,
-	// ., _ and -. The disk name will appear on the console. It cannot
-	// begin with http:// or https://.
-	DiskName string `mapstructure:"disk_name" required:"false"`
-	// Category of the system disk. Optional values
-	// are:
-	//     -   cloud - general cloud disk
-	//     -   cloud_efficiency - efficiency cloud disk
-	//     -   cloud_ssd - cloud SSD
-	DiskCategory string `mapstructure:"disk_category" required:"false"`
-	// Size of the system disk, measured in GiB. Value
-	// range: [20, 500]. The specified value must be equal to or greater
-	// than max{20, ImageSize}. Default value: max{40, ImageSize}.
-	DiskSize int `mapstructure:"disk_size" required:"false"`
-	// Snapshots are used to create the data
-	// disk After this parameter is specified, Size is ignored. The actual
-	// size of the created disk is the size of the specified snapshot.
-	SnapshotId string `mapstructure:"disk_snapshot_id" required:"false"`
-	// The value of disk description is blank by
-	// default. [2, 256] characters. The disk description will appear on the
-	// console. It cannot begin with http:// or https://.
-	Description string `mapstructure:"disk_description" required:"false"`
-	// Whether or not the disk is
-	// released along with the instance:
-	DeleteWithInstance bool `mapstructure:"disk_delete_with_instance" required:"false"`
-	// Device information of the related instance:
-	// such as /dev/xvdb It is null unless the Status is In_use.
-	Device string `mapstructure:"disk_device" required:"false"`
-	// Whether or not to encrypt the data disk.
-	// If this option is set to true, the data disk will be encryped and corresponding snapshot in the target image will also be encrypted. By
-	// default, if this is an extra data disk, Packer will not encrypt the
-	// data disk. Otherwise, Packer will keep the encryption setting to what
-	// it was in the source image. Please refer to Introduction of ECS disk encryption
-	// for more details.
-	Encrypted config.Trilean `mapstructure:"disk_encrypted" required:"false"`
+	DiskName           string `mapstructure:"disk_name"`
+	DiskCategory       string `mapstructure:"disk_category"`
+	DiskSize           int    `mapstructure:"disk_size"`
+	SnapshotId         string `mapstructure:"disk_snapshot_id"`
+	Description        string `mapstructure:"disk_description"`
+	DeleteWithInstance bool   `mapstructure:"disk_delete_with_instance"`
+	Device             string `mapstructure:"disk_device"`
 }
 
 type AlicloudDiskDevices struct {
-	// Image disk mapping for system
-	// disk.
-	// -   `disk_category` (string) - Category of the system disk. Optional values
-	//     are:
-	//         -   `cloud` - general cloud disk
-	//         -   `cloud_efficiency` - efficiency cloud disk
-	//         -   `cloud_ssd` - cloud SSD
-	//
-	//         For phased-out instance types and non-I/O optimized instances, the
-	//         default value is cloud. Otherwise, the default value is
-	//         cloud\_efficiency.
-	//
-	// -   `disk_description` (string) - The value of disk description is blank by
-	//     default. \[2, 256\] characters. The disk description will appear on the
-	//     console. It cannot begin with `http://` or `https://`.
-	//
-	// -   `disk_name` (string) - The value of disk name is blank by default. \[2,
-	//     128\] English or Chinese characters, must begin with an
-	//     uppercase/lowercase letter or Chinese character. Can contain numbers,
-	//     `.`, `_` and `-`. The disk name will appear on the console. It cannot
-	//     begin with `http://` or `https://`.
-	//
-	// -   `disk_size` (number) - Size of the system disk, measured in GiB. Value
-	//     range: \[20, 500\]. The specified value must be equal to or greater
-	//     than max{20, ImageSize}. Default value: max{40, ImageSize}.
-	//
-	ECSSystemDiskMapping AlicloudDiskDevice `mapstructure:"system_disk_mapping" required:"false"`
-	// Add one or more data
-	// disks to the image.
-	//
-	// -   `disk_category` (string) - Category of the data disk. Optional values
-	//     are:
-	//     -   `cloud` - general cloud disk
-	//     -   `cloud_efficiency` - efficiency cloud disk
-	//     -   `cloud_ssd` - cloud SSD
-	//
-	//     Default value: cloud.
-	//
-	// -   `disk_delete_with_instance` (boolean) - Whether or not the disk is
-	//     released along with the instance:
-	//     -   True indicates that when the instance is released, this disk will
-	//         be released with it
-	//     -   False indicates that when the instance is released, this disk will
-	//         be retained.
-	// -   `disk_description` (string) - The value of disk description is blank by
-	//     default. \[2, 256\] characters. The disk description will appear on the
-	//     console. It cannot begin with `http://` or `https://`.
-	//
-	// -   `disk_device` (string) - Device information of the related instance:
-	//     such as `/dev/xvdb` It is null unless the Status is In\_use.
-	//
-	// -   `disk_name` (string) - The value of disk name is blank by default. \[2,
-	//     128\] English or Chinese characters, must begin with an
-	//     uppercase/lowercase letter or Chinese character. Can contain numbers,
-	//     `.`, `_` and `-`. The disk name will appear on the console. It cannot
-	//     begin with `http://` or `https://`.
-	//
-	// -   `disk_size` (number) - Size of the data disk, in GB, values range:
-	//     -   `cloud` - 5 \~ 2000
-	//     -   `cloud_efficiency` - 20 \~ 2048
-	//     -   `cloud_ssd` - 20 \~ 2048
-	//
-	//     The value should be equal to or greater than the size of the specific
-	//     SnapshotId.
-	//
-	// -   `disk_snapshot_id` (string) - Snapshots are used to create the data
-	//     disk After this parameter is specified, Size is ignored. The actual
-	//     size of the created disk is the size of the specified snapshot.
-	//
-	//     Snapshots from on or before July 15, 2013 cannot be used to create a
-	//     disk.
-	//
-	// -   `disk_encrypted` (boolean) - Whether or not to encrypt the data disk.
-	//     If this option is set to true, the data disk will be encryped and corresponding snapshot in the target image will also be encrypted. By
-	//     default, if this is an extra data disk, Packer will not encrypt the
-	//     data disk. Otherwise, Packer will keep the encryption setting to what
-	//     it was in the source image. Please refer to Introduction of [ECS disk encryption](https://www.alibabacloud.com/help/doc-detail/59643.htm)
-	//     for more details.
-	//
-	ECSImagesDiskMappings []AlicloudDiskDevice `mapstructure:"image_disk_mappings" required:"false"`
+	ECSImagesDiskMappings []AlicloudDiskDevice `mapstructure:"image_disk_mappings"`
 }
 
 type AlicloudImageConfig struct {
-	// The name of the user-defined image, [2, 128]
-	// English or Chinese characters. It must begin with an uppercase/lowercase
-	// letter or a Chinese character, and may contain numbers, _ or -. It
-	// cannot begin with http:// or https://.
-	AlicloudImageName string `mapstructure:"image_name" required:"true"`
-	// The version number of the image, with a length
-	// limit of 1 to 40 English characters.
-	AlicloudImageVersion string `mapstructure:"image_version" required:"false"`
-	// The description of the image, with a length
-	// limit of 0 to 256 characters. Leaving it blank means null, which is the
-	// default value. It cannot begin with http:// or https://.
-	AlicloudImageDescription string `mapstructure:"image_description" required:"false"`
-	// The IDs of to-be-added Aliyun
-	// accounts to which the image is shared. The number of accounts is 1 to 10.
-	// If number of accounts is greater than 10, this parameter is ignored.
-	AlicloudImageShareAccounts   []string `mapstructure:"image_share_account" required:"false"`
-	AlicloudImageUNShareAccounts []string `mapstructure:"image_unshare_account"`
-	// Copy to the destination regionIds.
-	AlicloudImageDestinationRegions []string `mapstructure:"image_copy_regions" required:"false"`
-	// The name of the destination image,
-	// [2, 128] English or Chinese characters. It must begin with an
-	// uppercase/lowercase letter or a Chinese character, and may contain numbers,
-	// _ or -. It cannot begin with http:// or https://.
-	AlicloudImageDestinationNames []string `mapstructure:"image_copy_names" required:"false"`
-	// Whether or not to encrypt the target images,            including those copied if image_copy_regions is specified. If this option
-	// is set to true, a temporary image will be created from the provisioned
-	// instance in the main region and an encrypted copy will be generated in the
-	// same region. By default, Packer will keep the encryption setting to what
-	// it was in the source image.
-	ImageEncrypted config.Trilean `mapstructure:"image_encrypted" required:"false"`
-	// If this value is true, when the target image names including those
-	// copied are duplicated with existing images, it will delete the existing
-	// images and then create the target images, otherwise, the creation will
-	// fail. The default value is false. Check `image_name` and
-	// `image_copy_names` options for names of target images. If
-	// [-force](https://packer.io/docs/commands/build.html#force) option is
-	// provided in `build` command, this option can be omitted and taken as
-	// true.
-	AlicloudImageForceDelete bool `mapstructure:"image_force_delete" required:"false"`
-	// If this value is true, when delete the duplicated existing images, the
-	// source snapshots of those images will be delete either. If
-	// [-force](https://packer.io/docs/commands/build.html#force) option is
-	// provided in `build` command, this option can be omitted and taken as
-	// true.
-	AlicloudImageForceDeleteSnapshots bool `mapstructure:"image_force_delete_snapshots" required:"false"`
-	AlicloudImageForceDeleteInstances bool `mapstructure:"image_force_delete_instances"`
-	// If this value is true, the image
-	// created will not include any snapshot of data disks. This option would be
-	// useful for any circumstance that default data disks with instance types are
-	// not concerned. The default value is false.
-	AlicloudImageIgnoreDataDisks bool `mapstructure:"image_ignore_data_disks" required:"false"`
-	// The region validation can be skipped
-	// if this value is true, the default value is false.
-	AlicloudImageSkipRegionValidation bool `mapstructure:"skip_region_validation" required:"false"`
-	// Tags applied to the destination
-	// image and relevant snapshots.
-	AlicloudImageTags   map[string]string `mapstructure:"tags" required:"false"`
-	AlicloudDiskDevices `mapstructure:",squash"`
+	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"`
 }
 
 func (c *AlicloudImageConfig) Prepare(ctx *interpolate.Context) []error {
@@ -222,6 +66,15 @@ func (c *AlicloudImageConfig) Prepare(ctx *interpolate.Context) []error {
 
 			// Mark that we saw the region
 			regionSet[region] = struct{}{}
+
+			if !c.AlicloudImageSkipRegionValidation {
+				// Verify the region is real
+				if valid := validateRegion(region); valid != nil {
+					errs = append(errs, fmt.Errorf("Unknown region: %s", region))
+					continue
+				}
+			}
+
 			regions = append(regions, region)
 		}
 
@@ -234,3 +87,14 @@ func (c *AlicloudImageConfig) Prepare(ctx *interpolate.Context) []error {
 
 	return nil
 }
+
+func validateRegion(region string) error {
+
+	for _, valid := range common.ValidRegions {
+		if region == string(valid) {
+			return nil
+		}
+	}
+
+	return fmt.Errorf("Not a valid alicloud region: %s", region)
+}

builder/alicloud/ecs/image_config_test.go

@@ -2,6 +2,8 @@ package ecs
 
 import (
 	"testing"
+
+	"github.com/denverdino/aliyungo/common"
 )
 
 func testAlicloudImageConfig() *AlicloudImageConfig {
@@ -29,33 +31,34 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
 
+	c.AlicloudImageDestinationRegions = regionsToString()
+	if err := c.Prepare(nil); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
+	}
+
+	c.AlicloudImageDestinationRegions = []string{"foo"}
+	if err := c.Prepare(nil); err == nil {
+		t.Fatal("should have error")
+	}
+
 	c.AlicloudImageDestinationRegions = []string{"cn-beijing", "cn-hangzhou", "eu-central-1"}
 	if err := c.Prepare(nil); err != nil {
 		t.Fatalf("bad: %s", err)
 	}
 
-	c.AlicloudImageDestinationRegions = nil
+	c.AlicloudImageDestinationRegions = []string{"unknow"}
 	c.AlicloudImageSkipRegionValidation = true
 	if err := c.Prepare(nil); err != nil {
 		t.Fatal("shouldn't have error")
 	}
 	c.AlicloudImageSkipRegionValidation = false
+
 }
 
-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 {
+		regions = append(regions, string(region))
 	}
+	return regions
 }

builder/alicloud/ecs/packer_helper.go

@@ -2,13 +2,12 @@ package ecs
 
 import (
 	"fmt"
-	"strconv"
 
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
 
-func cleanUpMessage(state multistep.StateBag, module string) {
+func message(state multistep.StateBag, module string) {
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
 
@@ -19,34 +18,5 @@ func cleanUpMessage(state multistep.StateBag, module string) {
 	} else {
 		ui.Say(fmt.Sprintf("Cleaning up '%s'", module))
 	}
-}
-
-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
-}
-
-func convertNumber(value int) string {
-	if value <= 0 {
-		return ""
-	}
-
-	return strconv.Itoa(value)
-}
-
-func ContainsInArray(arr []string, value string) bool {
-	for _, item := range arr {
-		if item == value {
-			return true
-		}
-	}
-
-	return false
+
 }

builder/alicloud/ecs/run_config.go

@@ -1,5 +1,3 @@
-//go:generate struct-markdown
-
 package ecs
 
 import (
@@ -10,115 +8,33 @@ import (
 
 	"github.com/hashicorp/packer/common/uuid"
 	"github.com/hashicorp/packer/helper/communicator"
-	"github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/template/interpolate"
 )
 
 type RunConfig struct {
-	AssociatePublicIpAddress bool `mapstructure:"associate_public_ip_address"`
-	// ID of the zone to which the disk belongs.
-	ZoneId string `mapstructure:"zone_id" required:"false"`
-	// Whether an ECS instance is I/O optimized or not. If this option is not
-	// provided, the value will be determined by product API according to what
-	// `instance_type` is used.
-	IOOptimized config.Trilean `mapstructure:"io_optimized" required:"false"`
-	// Type of the instance. For values, see [Instance Type
-	// Table](https://www.alibabacloud.com/help/doc-detail/25378.htm?spm=a3c0i.o25499en.a3.9.14a36ac8iYqKRA).
-	// You can also obtain the latest instance type table by invoking the
-	// [Querying Instance Type
-	// Table](https://intl.aliyun.com/help/doc-detail/25620.htm?spm=a3c0i.o25499en.a3.6.Dr1bik)
-	// interface.
-	InstanceType string `mapstructure:"instance_type" required:"true"`
-	Description  string `mapstructure:"description"`
-	// This is the base image id which you want to
-	// create your customized images.
-	AlicloudSourceImage string `mapstructure:"source_image" required:"true"`
-	// Whether to force shutdown upon device
-	// restart. The default value is `false`.
-	//
-	// If it is set to `false`, the system is shut down normally; if it is set to
-	// `true`, the system is forced to shut down.
-	ForceStopInstance bool `mapstructure:"force_stop_instance" required:"false"`
-	// If this option is set to true, Packer
-	// will not stop the instance for you, and you need to make sure the instance
-	// will be stopped in the final provisioner command. Otherwise, Packer will
-	// timeout while waiting the instance to be stopped. This option is provided
-	// for some specific scenarios that you want to stop the instance by yourself.
-	// E.g., Sysprep a windows which may shutdown the instance within its command.
-	// The default value is false.
-	DisableStopInstance bool `mapstructure:"disable_stop_instance" required:"false"`
-	// ID of the security group to which a newly
-	// created instance belongs. Mutual access is allowed between instances in one
-	// security group. If not specified, the newly created instance will be added
-	// to the default security group. If the default group doesn’t exist, or the
-	// number of instances in it has reached the maximum limit, a new security
-	// group will be created automatically.
-	SecurityGroupId string `mapstructure:"security_group_id" required:"false"`
-	// The security group name. The default value
-	// is blank. [2, 128] English or Chinese characters, must begin with an
-	// uppercase/lowercase letter or Chinese character. Can contain numbers, .,
-	// _ or -. It cannot begin with http:// or https://.
-	SecurityGroupName string `mapstructure:"security_group_name" required:"false"`
-	// User data to apply when launching the instance. Note
-	// that you need to be careful about escaping characters due to the templates
-	// being JSON. It is often more convenient to use user_data_file, instead.
-	// Packer will not automatically wait for a user script to finish before
-	// shutting down the instance this must be handled in a provisioner.
-	UserData string `mapstructure:"user_data" required:"false"`
-	// Path to a file that will be used for the user
-	// data when launching the instance.
-	UserDataFile string `mapstructure:"user_data_file" required:"false"`
-	// VPC ID allocated by the system.
-	VpcId string `mapstructure:"vpc_id" required:"false"`
-	// The VPC name. The default value is blank. [2, 128]
-	// English or Chinese characters, must begin with an uppercase/lowercase
-	// letter or Chinese character. Can contain numbers, _ and -. The disk
-	// description will appear on the console. Cannot begin with http:// or
-	// https://.
-	VpcName string `mapstructure:"vpc_name" required:"false"`
-	// Value options: 192.168.0.0/16 and
-	// 172.16.0.0/16. When not specified, the default value is 172.16.0.0/16.
-	CidrBlock string `mapstructure:"vpc_cidr_block" required:"false"`
-	// The ID of the VSwitch to be used.
-	VSwitchId string `mapstructure:"vswitch_id" required:"false"`
-	// The ID of the VSwitch to be used.
-	VSwitchName string `mapstructure:"vswitch_name" required:"false"`
-	// Display name of the instance, which is a string of 2 to 128 Chinese or
-	// English characters. It must begin with an uppercase/lowercase letter or
-	// a Chinese character and can contain numerals, `.`, `_`, or `-`. The
-	// instance name is displayed on the Alibaba Cloud console. If this
-	// parameter is not specified, the default value is InstanceId of the
-	// instance. It cannot begin with `http://` or `https://`.
-	InstanceName string `mapstructure:"instance_name" required:"false"`
-	// Internet charge type, which can be
-	// `PayByTraffic` or `PayByBandwidth`. Optional values:
-	// -   `PayByBandwidth`
-	// -   `PayByTraffic`
-	//
-	// If this parameter is not specified, the default value is `PayByBandwidth`.
-	// For the regions out of China, currently only support `PayByTraffic`, you
-	// must set it manfully.
-	InternetChargeType string `mapstructure:"internet_charge_type" required:"false"`
-	// Maximum outgoing bandwidth to the
-	// public network, measured in Mbps (Mega bits per second).
-	//
-	// Value range:
-	// -   `PayByBandwidth`: \[0, 100\]. If this parameter is not specified, API
-	//     automatically sets it to 0 Mbps.
-	// -   `PayByTraffic`: \[1, 100\]. If this parameter is not specified, an
-	//     error is returned.
-	InternetMaxBandwidthOut int `mapstructure:"internet_max_bandwidth_out" required:"false"`
-	// Timeout of creating snapshot(s).
-	// The default timeout is 3600 seconds if this option is not set or is set
-	// to 0. For those disks containing lots of data, it may require a higher
-	// timeout value.
-	WaitSnapshotReadyTimeout int `mapstructure:"wait_snapshot_ready_timeout" required:"false"`
+	AssociatePublicIpAddress bool   `mapstructure:"associate_public_ip_address"`
+	ZoneId                   string `mapstructure:"zone_id"`
+	IOOptimized              bool   `mapstructure:"io_optimized"`
+	InstanceType             string `mapstructure:"instance_type"`
+	Description              string `mapstructure:"description"`
+	AlicloudSourceImage      string `mapstructure:"source_image"`
+	ForceStopInstance        bool   `mapstructure:"force_stop_instance"`
+	SecurityGroupId          string `mapstructure:"security_group_id"`
+	SecurityGroupName        string `mapstructure:"security_group_name"`
+	UserData                 string `mapstructure:"user_data"`
+	UserDataFile             string `mapstructure:"user_data_file"`
+	VpcId                    string `mapstructure:"vpc_id"`
+	VpcName                  string `mapstructure:"vpc_name"`
+	CidrBlock                string `mapstructure:"vpc_cidr_block"`
+	VSwitchId                string `mapstructure:"vswitch_id"`
+	VSwitchName              string `mapstructure:"vswitch_id"`
+	InstanceName             string `mapstructure:"instance_name"`
+	InternetChargeType       string `mapstructure:"internet_charge_type"`
+	InternetMaxBandwidthOut  int    `mapstructure:"internet_max_bandwidth_out"`
+
 	// Communicator settings
-	Comm communicator.Config `mapstructure:",squash"`
-	// If this value is true, packer will connect to
-	// the ECS created through private ip instead of allocating a public ip or an
-	// EIP. The default value is false.
-	SSHPrivateIp bool `mapstructure:"ssh_private_ip" required:"false"`
+	Comm         communicator.Config `mapstructure:",squash"`
+	SSHPrivateIp bool                `mapstructure:"ssh_private_ip"`
 }
 
 func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {

builder/alicloud/ecs/run_config_test.go

@@ -13,9 +13,7 @@ func testConfig() *RunConfig {
 		AlicloudSourceImage: "alicloud_images",
 		InstanceType:        "ecs.n1.tiny",
 		Comm: communicator.Config{
-			SSH: communicator.SSH{
-				SSHUsername: "alicloud",
-			},
+			SSHUsername: "alicloud",
 		},
 	}
 }
@@ -125,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

@@ -4,8 +4,10 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"time"
+
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -13,57 +15,53 @@ import (
 type stepAttachKeyPair struct {
 }
 
-var attachKeyPairNotRetryErrors = []string{
-	"MissingParameter",
-	"DependencyViolation.WindowsInstance",
-	"InvalidKeyPairName.NotFound",
-	"InvalidRegionId.NotFound",
-}
-
-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").(*ClientWrapper)
-	config := state.Get("config").(*Config)
-	instance := state.Get("instance").(*ecs.Instance)
+	client := state.Get("client").(*ecs.Client)
+	config := state.Get("config").(Config)
+	instance := state.Get("instance").(*ecs.InstanceAttributesType)
+	timeoutPoint := time.Now().Add(120 * time.Second)
 	keyPairName := config.Comm.SSHKeyPairName
 	if keyPairName == "" {
 		return multistep.ActionContinue
 	}
-
-	_, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateAttachKeyPairRequest()
-			request.RegionId = config.AlicloudRegion
-			request.KeyPairName = keyPairName
-			request.InstanceIds = "[\"" + instance.InstanceId + "\"]"
-			return client.AttachKeyPair(request)
-		},
-		EvalFunc: client.EvalCouldRetryResponse(attachKeyPairNotRetryErrors, EvalNotRetryErrorType),
-	})
-
-	if err != nil {
-		return halt(state, err, fmt.Sprintf("Error attaching keypair %s to instance %s", keyPairName, instance.InstanceId))
+	for {
+		err := client.AttachKeyPair(&ecs.AttachKeyPairArgs{RegionId: common.Region(config.AlicloudRegion),
+			KeyPairName: keyPairName, InstanceIds: "[\"" + instance.InstanceId + "\"]"})
+		if err != nil {
+			e, _ := err.(*common.Error)
+			if (!(e.Code == "MissingParameter" || e.Code == "DependencyViolation.WindowsInstance" ||
+				e.Code == "InvalidKeyPairName.NotFound" || e.Code == "InvalidRegionId.NotFound")) &&
+				time.Now().Before(timeoutPoint) {
+				time.Sleep(5 * time.Second)
+				continue
+			}
+			err := fmt.Errorf("Error attaching keypair %s to instance %s : %s",
+				keyPairName, instance.InstanceId, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		break
 	}
 
 	ui.Message(fmt.Sprintf("Attach keypair %s to instance: %s", keyPairName, instance.InstanceId))
+
 	return multistep.ActionContinue
 }
 
 func (s *stepAttachKeyPair) Cleanup(state multistep.StateBag) {
-	client := state.Get("client").(*ClientWrapper)
-	config := state.Get("config").(*Config)
+	client := state.Get("client").(*ecs.Client)
+	config := state.Get("config").(Config)
 	ui := state.Get("ui").(packer.Ui)
-	instance := state.Get("instance").(*ecs.Instance)
+	instance := state.Get("instance").(*ecs.InstanceAttributesType)
 	keyPairName := config.Comm.SSHKeyPairName
 	if keyPairName == "" {
 		return
 	}
 
-	detachKeyPairRequest := ecs.CreateDetachKeyPairRequest()
-	detachKeyPairRequest.RegionId = config.AlicloudRegion
-	detachKeyPairRequest.KeyPairName = keyPairName
-	detachKeyPairRequest.InstanceIds = fmt.Sprintf("[\"%s\"]", instance.InstanceId)
-	_, err := client.DetachKeyPair(detachKeyPairRequest)
+	err := client.DetachKeyPair(&ecs.DetachKeyPairArgs{RegionId: common.Region(config.AlicloudRegion),
+		KeyPairName: keyPairName, InstanceIds: "[\"" + instance.InstanceId + "\"]"})
 	if err != nil {
 		err := fmt.Errorf("Error Detaching keypair %s to instance %s : %s", keyPairName,
 			instance.InstanceId, err)

builder/alicloud/ecs/step_check_source_image.go

@@ -4,7 +4,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -13,36 +14,41 @@ type stepCheckAlicloudSourceImage struct {
 	SourceECSImageId string
 }
 
-func (s *stepCheckAlicloudSourceImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
-	config := state.Get("config").(*Config)
+func (s *stepCheckAlicloudSourceImage) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*ecs.Client)
+	config := state.Get("config").(Config)
 	ui := state.Get("ui").(packer.Ui)
-
-	describeImagesRequest := ecs.CreateDescribeImagesRequest()
-	describeImagesRequest.RegionId = config.AlicloudRegion
-	describeImagesRequest.ImageId = config.AlicloudSourceImage
-	imagesResponse, err := client.DescribeImages(describeImagesRequest)
+	args := &ecs.DescribeImagesArgs{
+		RegionId: common.Region(config.AlicloudRegion),
+		ImageId:  config.AlicloudSourceImage,
+	}
+	args.PageSize = 50
+	images, _, err := client.DescribeImages(args)
 	if err != nil {
-		return halt(state, err, "Error querying alicloud image")
+		err := fmt.Errorf("Error querying alicloud image: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
 
-	images := imagesResponse.Images.Image
-
-	// Describe marketplace image
-	describeImagesRequest.ImageOwnerAlias = "marketplace"
-	marketImagesResponse, err := client.DescribeImages(describeImagesRequest)
+	// Describe markerplace image
+	args.ImageOwnerAlias = ecs.ImageOwnerMarketplace
+	imageMarkets, _, err := client.DescribeImages(args)
 	if err != nil {
-		return halt(state, err, "Error querying alicloud marketplace image")
+		err := fmt.Errorf("Error querying alicloud marketplace image: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
-
-	marketImages := marketImagesResponse.Images.Image
-	if len(marketImages) > 0 {
-		images = append(images, marketImages...)
+	if len(imageMarkets) > 0 {
+		images = append(images, imageMarkets...)
 	}
 
 	if len(images) == 0 {
 		err := fmt.Errorf("No alicloud image was found matching filters: %v", config.AlicloudSourceImage)
-		return halt(state, err, "")
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
 
 	ui.Message(fmt.Sprintf("Found image ID: %s", images[0].ImageId))

builder/alicloud/ecs/step_config_eip.go

@@ -4,11 +4,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
-	"github.com/hashicorp/packer/common/uuid"
-
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -19,70 +16,43 @@ type stepConfigAlicloudEIP struct {
 	InternetChargeType       string
 	InternetMaxBandwidthOut  int
 	allocatedId              string
-	SSHPrivateIp             bool
 }
 
-var allocateEipAddressRetryErrors = []string{
-	"LastTokenProcessing",
-}
-
-func (s *stepConfigAlicloudEIP) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
+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.Instance)
-
-	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...")
-
-	allocateEipAddressRequest := s.buildAllocateEipAddressRequest(state)
-	allocateEipAddressResponse, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			return client.AllocateEipAddress(allocateEipAddressRequest)
-		},
-		EvalFunc: client.EvalCouldRetryResponse(allocateEipAddressRetryErrors, EvalRetryErrorType),
+	instance := state.Get("instance").(*ecs.InstanceAttributesType)
+	ui.Say("Allocating eip")
+	ipaddress, allocateId, err := client.AllocateEipAddress(&ecs.AllocateEipAddressArgs{
+		RegionId: common.Region(s.RegionId), InternetChargeType: common.InternetChargeType(s.InternetChargeType),
+		Bandwidth: s.InternetMaxBandwidthOut,
 	})
-
 	if err != nil {
-		return halt(state, err, "Error allocating eip")
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Error allocating eip: %s", err))
+		return multistep.ActionHalt
 	}
-
-	ipaddress := allocateEipAddressResponse.(*ecs.AllocateEipAddressResponse).EipAddress
-	ui.Message(fmt.Sprintf("Allocated eip: %s", ipaddress))
-
-	allocateId := allocateEipAddressResponse.(*ecs.AllocateEipAddressResponse).AllocationId
 	s.allocatedId = allocateId
-
-	err = s.waitForEipStatus(client, instance.RegionId, s.allocatedId, EipStatusAvailable)
-	if err != nil {
-		return halt(state, err, "Error wait eip available timeout")
+	if err = client.WaitForEip(common.Region(s.RegionId), allocateId,
+		ecs.EipStatusAvailable, ALICLOUD_DEFAULT_SHORT_TIMEOUT); err != nil {
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Error allocating eip: %s", err))
+		return multistep.ActionHalt
 	}
 
-	associateEipAddressRequest := ecs.CreateAssociateEipAddressRequest()
-	associateEipAddressRequest.AllocationId = allocateId
-	associateEipAddressRequest.InstanceId = instance.InstanceId
-	if _, err := client.AssociateEipAddress(associateEipAddressRequest); err != nil {
-		e, ok := err.(errors.Error)
-		if !ok || e.ErrorCode() != "TaskConflict" {
-			return halt(state, err, "Error associating eip")
-		}
-
-		ui.Error(fmt.Sprintf("Error associate eip: %s", err))
+	if err = client.AssociateEipAddress(allocateId, instance.InstanceId); err != nil {
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Error binding eip: %s", err))
+		return multistep.ActionHalt
 	}
 
-	err = s.waitForEipStatus(client, instance.RegionId, s.allocatedId, EipStatusInUse)
-	if err != nil {
-		return halt(state, err, "Error wait eip associated timeout")
+	if err = client.WaitForEip(common.Region(s.RegionId), allocateId,
+		ecs.EipStatusInUse, ALICLOUD_DEFAULT_SHORT_TIMEOUT); err != nil {
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Error associating eip: %s", err))
+		return multistep.ActionHalt
 	}
-
+	ui.Say(fmt.Sprintf("Allocated eip %s", ipaddress))
 	state.Put("ipaddress", ipaddress)
 	return multistep.ActionContinue
 }
@@ -92,74 +62,21 @@ func (s *stepConfigAlicloudEIP) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	cleanUpMessage(state, "EIP")
-
-	client := state.Get("client").(*ClientWrapper)
-	instance := state.Get("instance").(*ecs.Instance)
+	client := state.Get("client").(*ecs.Client)
+	instance := state.Get("instance").(*ecs.InstanceAttributesType)
 	ui := state.Get("ui").(packer.Ui)
 
-	unassociateEipAddressRequest := ecs.CreateUnassociateEipAddressRequest()
-	unassociateEipAddressRequest.AllocationId = s.allocatedId
-	unassociateEipAddressRequest.InstanceId = instance.InstanceId
-	if _, err := client.UnassociateEipAddress(unassociateEipAddressRequest); err != nil {
-		ui.Say(fmt.Sprintf("Failed to unassociate eip: %s", err))
+	message(state, "EIP")
+
+	if err := client.UnassociateEipAddress(s.allocatedId, instance.InstanceId); err != nil {
+		ui.Say(fmt.Sprintf("Failed to unassociate eip."))
 	}
 
-	if err := s.waitForEipStatus(client, instance.RegionId, s.allocatedId, EipStatusAvailable); err != nil {
-		ui.Say(fmt.Sprintf("Timeout while unassociating eip: %s", err))
+	if err := client.WaitForEip(common.Region(s.RegionId), s.allocatedId, ecs.EipStatusAvailable, ALICLOUD_DEFAULT_SHORT_TIMEOUT); err != nil {
+		ui.Say(fmt.Sprintf("Timeout while unassociating eip."))
+	}
+	if err := client.ReleaseEipAddress(s.allocatedId); err != nil {
+		ui.Say(fmt.Sprintf("Failed to release eip."))
 	}
 
-	releaseEipAddressRequest := ecs.CreateReleaseEipAddressRequest()
-	releaseEipAddressRequest.AllocationId = s.allocatedId
-	if _, err := client.ReleaseEipAddress(releaseEipAddressRequest); err != nil {
-		ui.Say(fmt.Sprintf("Failed to release eip: %s", err))
-	}
-}
-
-func (s *stepConfigAlicloudEIP) waitForEipStatus(client *ClientWrapper, regionId string, allocationId string, expectedStatus string) error {
-	describeEipAddressesRequest := ecs.CreateDescribeEipAddressesRequest()
-	describeEipAddressesRequest.RegionId = regionId
-	describeEipAddressesRequest.AllocationId = s.allocatedId
-
-	_, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			response, err := client.DescribeEipAddresses(describeEipAddressesRequest)
-			if err == nil && len(response.EipAddresses.EipAddress) == 0 {
-				err = fmt.Errorf("eip allocated is not find")
-			}
-
-			return response, err
-		},
-		EvalFunc: func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-			if err != nil {
-				return WaitForExpectToRetry
-			}
-
-			eipAddressesResponse := response.(*ecs.DescribeEipAddressesResponse)
-			eipAddresses := eipAddressesResponse.EipAddresses.EipAddress
-
-			for _, eipAddress := range eipAddresses {
-				if eipAddress.Status == expectedStatus {
-					return WaitForExpectSuccess
-				}
-			}
-
-			return WaitForExpectToRetry
-		},
-		RetryTimes: shortRetryTimes,
-	})
-
-	return err
-}
-
-func (s *stepConfigAlicloudEIP) buildAllocateEipAddressRequest(state multistep.StateBag) *ecs.AllocateEipAddressRequest {
-	instance := state.Get("instance").(*ecs.Instance)
-
-	request := ecs.CreateAllocateEipAddressRequest()
-	request.ClientToken = uuid.TimeOrderedUUID()
-	request.RegionId = instance.RegionId
-	request.InternetChargeType = s.InternetChargeType
-	request.Bandwidth = string(convertNumber(s.InternetMaxBandwidthOut))
-
-	return request
 }

builder/alicloud/ecs/step_config_key_pair.go

@@ -3,10 +3,12 @@ package ecs
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"runtime"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -21,18 +23,20 @@ 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
 		}
 
 		s.Comm.SSHPrivateKey = privateKeyBytes
+
 		return multistep.ActionContinue
 	}
 
@@ -52,15 +56,16 @@ func (s *stepConfigAlicloudKeyPair) Run(ctx context.Context, state multistep.Sta
 		return multistep.ActionContinue
 	}
 
-	client := state.Get("client").(*ClientWrapper)
-	ui.Say(fmt.Sprintf("Creating temporary keypair: %s", s.Comm.SSHTemporaryKeyPairName))
+	client := state.Get("client").(*ecs.Client)
 
-	createKeyPairRequest := ecs.CreateCreateKeyPairRequest()
-	createKeyPairRequest.RegionId = s.RegionId
-	createKeyPairRequest.KeyPairName = s.Comm.SSHTemporaryKeyPairName
-	keyResp, err := client.CreateKeyPair(createKeyPairRequest)
+	ui.Say(fmt.Sprintf("Creating temporary keypair: %s", s.Comm.SSHTemporaryKeyPairName))
+	keyResp, err := client.CreateKeyPair(&ecs.CreateKeyPairArgs{
+		KeyPairName: s.Comm.SSHTemporaryKeyPairName,
+		RegionId:    common.Region(s.RegionId),
+	})
 	if err != nil {
-		return halt(state, err, "Error creating temporary keypair")
+		state.Put("error", fmt.Errorf("Error creating temporary keypair: %s", err))
+		return multistep.ActionHalt
 	}
 
 	// Set the keyname so we know to delete it later
@@ -107,16 +112,15 @@ func (s *stepConfigAlicloudKeyPair) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	client := state.Get("client").(*ClientWrapper)
+	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 
 	// Remove the keypair
 	ui.Say("Deleting temporary keypair...")
-
-	deleteKeyPairsRequest := ecs.CreateDeleteKeyPairsRequest()
-	deleteKeyPairsRequest.RegionId = s.RegionId
-	deleteKeyPairsRequest.KeyPairNames = fmt.Sprintf("[\"%s\"]", s.keyName)
-	_, err := client.DeleteKeyPairs(deleteKeyPairsRequest)
+	err := client.DeleteKeyPairs(&ecs.DeleteKeyPairsArgs{
+		RegionId:     common.Region(s.RegionId),
+		KeyPairNames: "[\"" + s.keyName + "\"]",
+	})
 	if err != nil {
 		ui.Error(fmt.Sprintf(
 			"Error cleaning up keypair. Please delete the key manually: %s", s.keyName))

builder/alicloud/ecs/step_config_public_ip.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -12,34 +12,22 @@ import (
 type stepConfigAlicloudPublicIP struct {
 	publicIPAddress string
 	RegionId        string
-	SSHPrivateIp    bool
 }
 
-func (s *stepConfigAlicloudPublicIP) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
+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.Instance)
+	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
-	}
-
-	allocatePublicIpAddressRequest := ecs.CreateAllocatePublicIpAddressRequest()
-	allocatePublicIpAddressRequest.InstanceId = instance.InstanceId
-	ipaddress, err := client.AllocatePublicIpAddress(allocatePublicIpAddressRequest)
+	ipaddress, err := client.AllocatePublicIpAddress(instance.InstanceId)
 	if err != nil {
-		return halt(state, err, "Error allocating public ip")
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Error allocating public ip: %s", err))
+		return multistep.ActionHalt
 	}
-
-	s.publicIPAddress = ipaddress.IpAddress
-	ui.Say(fmt.Sprintf("Allocated public ip address %s.", ipaddress.IpAddress))
-	state.Put("ipaddress", ipaddress.IpAddress)
+	s.publicIPAddress = ipaddress
+	ui.Say(fmt.Sprintf("Allocated public ip address %s.", ipaddress))
+	state.Put("ipaddress", ipaddress)
 	return multistep.ActionContinue
 }
 

builder/alicloud/ecs/step_config_security_group.go

@@ -2,11 +2,12 @@ package ecs
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"time"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
-	"github.com/hashicorp/packer/common/uuid"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -20,34 +21,31 @@ type stepConfigAlicloudSecurityGroup struct {
 	isCreate          bool
 }
 
-var createSecurityGroupRetryErrors = []string{
-	"IdempotentProcessing",
-}
-
-var deleteSecurityGroupRetryErrors = []string{
-	"DependencyViolation",
-}
-
-func (s *stepConfigAlicloudSecurityGroup) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
+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)
 
+	var securityGroupItems []ecs.SecurityGroupItemType
+	var err error
 	if len(s.SecurityGroupId) != 0 {
-		describeSecurityGroupsRequest := ecs.CreateDescribeSecurityGroupsRequest()
-		describeSecurityGroupsRequest.RegionId = s.RegionId
-
-		if networkType == InstanceNetworkVpc {
+		if networkType == VpcNet {
 			vpcId := state.Get("vpcid").(string)
-			describeSecurityGroupsRequest.VpcId = vpcId
+			securityGroupItems, _, err = client.DescribeSecurityGroups(&ecs.DescribeSecurityGroupsArgs{
+				VpcId:    vpcId,
+				RegionId: common.Region(s.RegionId),
+			})
+		} else {
+			securityGroupItems, _, err = client.DescribeSecurityGroups(&ecs.DescribeSecurityGroupsArgs{
+				RegionId: common.Region(s.RegionId),
+			})
 		}
 
-		securityGroupsResponse, err := client.DescribeSecurityGroups(describeSecurityGroupsRequest)
 		if err != nil {
-			return halt(state, err, "Failed querying security group")
+			ui.Say(fmt.Sprintf("Failed querying security group: %s", err))
+			state.Put("error", err)
+			return multistep.ActionHalt
 		}
-
-		securityGroupItems := securityGroupsResponse.SecurityGroups.SecurityGroup
 		for _, securityGroupItem := range securityGroupItems {
 			if securityGroupItem.SecurityGroupId == s.SecurityGroupId {
 				state.Put("securitygroupid", s.SecurityGroupId)
@@ -55,55 +53,61 @@ func (s *stepConfigAlicloudSecurityGroup) Run(ctx context.Context, state multist
 				return multistep.ActionContinue
 			}
 		}
-
 		s.isCreate = false
-		err = fmt.Errorf("The specified security group {%s} doesn't exist.", s.SecurityGroupId)
-		return halt(state, err, "")
+		message := fmt.Sprintf("The specified security group {%s} doesn't exist.", s.SecurityGroupId)
+		state.Put("error", errors.New(message))
+		ui.Say(message)
+		return multistep.ActionHalt
+
+	}
+	var securityGroupId string
+	ui.Say("Creating security groups...")
+	if networkType == VpcNet {
+		vpcId := state.Get("vpcid").(string)
+		securityGroupId, err = client.CreateSecurityGroup(&ecs.CreateSecurityGroupArgs{
+			RegionId:          common.Region(s.RegionId),
+			SecurityGroupName: s.SecurityGroupName,
+			VpcId:             vpcId,
+		})
+	} else {
+		securityGroupId, err = client.CreateSecurityGroup(&ecs.CreateSecurityGroupArgs{
+			RegionId:          common.Region(s.RegionId),
+			SecurityGroupName: s.SecurityGroupName,
+		})
 	}
-
-	ui.Say("Creating security group...")
-
-	createSecurityGroupRequest := s.buildCreateSecurityGroupRequest(state)
-	securityGroupResponse, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			return client.CreateSecurityGroup(createSecurityGroupRequest)
-		},
-		EvalFunc: client.EvalCouldRetryResponse(createSecurityGroupRetryErrors, EvalRetryErrorType),
-	})
-
 	if err != nil {
-		return halt(state, err, "Failed creating security group")
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Failed creating security group %s.", err))
+		return multistep.ActionHalt
 	}
-
-	securityGroupId := securityGroupResponse.(*ecs.CreateSecurityGroupResponse).SecurityGroupId
-
-	ui.Message(fmt.Sprintf("Created security group: %s", securityGroupId))
 	state.Put("securitygroupid", securityGroupId)
 	s.isCreate = true
 	s.SecurityGroupId = securityGroupId
-
-	authorizeSecurityGroupEgressRequest := ecs.CreateAuthorizeSecurityGroupEgressRequest()
-	authorizeSecurityGroupEgressRequest.SecurityGroupId = securityGroupId
-	authorizeSecurityGroupEgressRequest.RegionId = s.RegionId
-	authorizeSecurityGroupEgressRequest.IpProtocol = IpProtocolAll
-	authorizeSecurityGroupEgressRequest.PortRange = DefaultPortRange
-	authorizeSecurityGroupEgressRequest.NicType = NicTypeInternet
-	authorizeSecurityGroupEgressRequest.DestCidrIp = DefaultCidrIp
-
-	if _, err := client.AuthorizeSecurityGroupEgress(authorizeSecurityGroupEgressRequest); err != nil {
-		return halt(state, err, "Failed authorizing security group")
+	err = client.AuthorizeSecurityGroupEgress(&ecs.AuthorizeSecurityGroupEgressArgs{
+		SecurityGroupId: securityGroupId,
+		RegionId:        common.Region(s.RegionId),
+		IpProtocol:      ecs.IpProtocolAll,
+		PortRange:       "-1/-1",
+		NicType:         ecs.NicTypeInternet,
+		DestCidrIp:      "0.0.0.0/0", //The input parameter "DestGroupId" or "DestCidrIp" cannot be both blank.
+	})
+	if err != nil {
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Failed authorizing security group: %s", err))
+		return multistep.ActionHalt
 	}
-
-	authorizeSecurityGroupRequest := ecs.CreateAuthorizeSecurityGroupRequest()
-	authorizeSecurityGroupRequest.SecurityGroupId = securityGroupId
-	authorizeSecurityGroupRequest.RegionId = s.RegionId
-	authorizeSecurityGroupRequest.IpProtocol = IpProtocolAll
-	authorizeSecurityGroupRequest.PortRange = DefaultPortRange
-	authorizeSecurityGroupRequest.NicType = NicTypeInternet
-	authorizeSecurityGroupRequest.SourceCidrIp = DefaultCidrIp
-
-	if _, err := client.AuthorizeSecurityGroup(authorizeSecurityGroupRequest); err != nil {
-		return halt(state, err, "Failed authorizing security group")
+	err = client.AuthorizeSecurityGroup(&ecs.AuthorizeSecurityGroupArgs{
+		SecurityGroupId: securityGroupId,
+		RegionId:        common.Region(s.RegionId),
+		IpProtocol:      ecs.IpProtocolAll,
+		PortRange:       "-1/-1",
+		NicType:         ecs.NicTypeInternet,
+		SourceCidrIp:    "0.0.0.0/0", //The input parameter "SourceGroupId" or "SourceCidrIp" cannot be both blank.
+	})
+	if err != nil {
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Failed authorizing security group: %s", err))
+		return multistep.ActionHalt
 	}
 
 	return multistep.ActionContinue
@@ -114,39 +118,21 @@ func (s *stepConfigAlicloudSecurityGroup) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	cleanUpMessage(state, "security group")
-
-	client := state.Get("client").(*ClientWrapper)
+	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 
-	_, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateDeleteSecurityGroupRequest()
-			request.RegionId = s.RegionId
-			request.SecurityGroupId = s.SecurityGroupId
-			return client.DeleteSecurityGroup(request)
-		},
-		EvalFunc:   client.EvalCouldRetryResponse(deleteSecurityGroupRetryErrors, EvalRetryErrorType),
-		RetryTimes: shortRetryTimes,
-	})
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("Failed to delete security group, it may still be around: %s", err))
+	message(state, "security group")
+	timeoutPoint := time.Now().Add(120 * time.Second)
+	for {
+		if err := client.DeleteSecurityGroup(common.Region(s.RegionId), s.SecurityGroupId); err != nil {
+			e, _ := err.(*common.Error)
+			if e.Code == "DependencyViolation" && time.Now().Before(timeoutPoint) {
+				time.Sleep(5 * time.Second)
+				continue
+			}
+			ui.Error(fmt.Sprintf("Failed to delete security group, it may still be around: %s", err))
+			return
+		}
+		break
 	}
 }
-
-func (s *stepConfigAlicloudSecurityGroup) buildCreateSecurityGroupRequest(state multistep.StateBag) *ecs.CreateSecurityGroupRequest {
-	networkType := state.Get("networktype").(InstanceNetWork)
-
-	request := ecs.CreateCreateSecurityGroupRequest()
-	request.ClientToken = uuid.TimeOrderedUUID()
-	request.RegionId = s.RegionId
-	request.SecurityGroupName = s.SecurityGroupName
-
-	if networkType == InstanceNetworkVpc {
-		vpcId := state.Get("vpcid").(string)
-		request.VpcId = vpcId
-	}
-
-	return request
-}

builder/alicloud/ecs/step_config_vpc.go

@@ -2,12 +2,12 @@ package ecs
 
 import (
 	"context"
-	errorsNew "errors"
+	"errors"
 	"fmt"
+	"time"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
-	"github.com/hashicorp/packer/common/uuid"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -19,94 +19,54 @@ type stepConfigAlicloudVPC struct {
 	isCreate  bool
 }
 
-var createVpcRetryErrors = []string{
-	"TOKEN_PROCESSING",
-}
-
-var deleteVpcRetryErrors = []string{
-	"DependencyViolation.Instance",
-	"DependencyViolation.RouteEntry",
-	"DependencyViolation.VSwitch",
-	"DependencyViolation.SecurityGroup",
-	"Forbbiden",
-	"TaskConflict",
-}
-
-func (s *stepConfigAlicloudVPC) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	client := state.Get("client").(*ClientWrapper)
+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)
 
 	if len(s.VpcId) != 0 {
-		describeVpcsRequest := ecs.CreateDescribeVpcsRequest()
-		describeVpcsRequest.VpcId = s.VpcId
-		describeVpcsRequest.RegionId = config.AlicloudRegion
-
-		vpcsResponse, err := client.DescribeVpcs(describeVpcsRequest)
+		vpcs, _, err := client.DescribeVpcs(&ecs.DescribeVpcsArgs{
+			VpcId:    s.VpcId,
+			RegionId: common.Region(config.AlicloudRegion),
+		})
 		if err != nil {
-			return halt(state, err, "Failed querying vpcs")
+			ui.Say(fmt.Sprintf("Failed querying vpcs: %s", err))
+			state.Put("error", err)
+			return multistep.ActionHalt
 		}
-
-		vpcs := vpcsResponse.Vpcs.Vpc
 		if len(vpcs) > 0 {
-			state.Put("vpcid", vpcs[0].VpcId)
+			vpc := vpcs[0]
+			state.Put("vpcid", vpc.VpcId)
 			s.isCreate = false
 			return multistep.ActionContinue
 		}
-
 		message := fmt.Sprintf("The specified vpc {%s} doesn't exist.", s.VpcId)
-		return halt(state, errorsNew.New(message), "")
+		state.Put("error", errors.New(message))
+		ui.Say(message)
+		return multistep.ActionHalt
+
 	}
-
-	ui.Say("Creating vpc...")
-
-	createVpcRequest := s.buildCreateVpcRequest(state)
-	createVpcResponse, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			return client.CreateVpc(createVpcRequest)
-		},
-		EvalFunc: client.EvalCouldRetryResponse(createVpcRetryErrors, EvalRetryErrorType),
+	ui.Say("Creating vpc")
+	vpc, err := client.CreateVpc(&ecs.CreateVpcArgs{
+		RegionId:  common.Region(config.AlicloudRegion),
+		CidrBlock: s.CidrBlock,
+		VpcName:   s.VpcName,
 	})
 	if err != nil {
-		return halt(state, err, "Failed creating vpc")
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Failed creating vpc: %s", err))
+		return multistep.ActionHalt
 	}
-
-	vpcId := createVpcResponse.(*ecs.CreateVpcResponse).VpcId
-	_, err = client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateDescribeVpcsRequest()
-			request.RegionId = config.AlicloudRegion
-			request.VpcId = vpcId
-			return client.DescribeVpcs(request)
-		},
-		EvalFunc: func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-			if err != nil {
-				return WaitForExpectToRetry
-			}
-
-			vpcsResponse := response.(*ecs.DescribeVpcsResponse)
-			vpcs := vpcsResponse.Vpcs.Vpc
-			if len(vpcs) > 0 {
-				for _, vpc := range vpcs {
-					if vpc.Status == VpcStatusAvailable {
-						return WaitForExpectSuccess
-					}
-				}
-			}
-
-			return WaitForExpectToRetry
-		},
-		RetryTimes: shortRetryTimes,
-	})
-
+	err = client.WaitForVpcAvailable(common.Region(config.AlicloudRegion), vpc.VpcId, ALICLOUD_DEFAULT_SHORT_TIMEOUT)
 	if err != nil {
-		return halt(state, err, "Failed waiting for vpc to become available")
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Failed waiting for vpc to become available: %s", err))
+		return multistep.ActionHalt
 	}
 
-	ui.Message(fmt.Sprintf("Created vpc: %s", vpcId))
-	state.Put("vpcid", vpcId)
+	state.Put("vpcid", vpc.VpcId)
 	s.isCreate = true
-	s.VpcId = vpcId
+	s.VpcId = vpc.VpcId
 	return multistep.ActionContinue
 }
 
@@ -115,34 +75,24 @@ func (s *stepConfigAlicloudVPC) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	cleanUpMessage(state, "VPC")
-
-	client := state.Get("client").(*ClientWrapper)
+	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
 
-	_, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateDeleteVpcRequest()
-			request.VpcId = s.VpcId
-			return client.DeleteVpc(request)
-		},
-		EvalFunc:   client.EvalCouldRetryResponse(deleteVpcRetryErrors, EvalRetryErrorType),
-		RetryTimes: shortRetryTimes,
-	})
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error deleting vpc, it may still be around: %s", err))
+	message(state, "VPC")
+	timeoutPoint := time.Now().Add(60 * time.Second)
+	for {
+		if err := client.DeleteVpc(s.VpcId); err != nil {
+			e, _ := err.(*common.Error)
+			if (e.Code == "DependencyViolation.Instance" || e.Code == "DependencyViolation.RouteEntry" ||
+				e.Code == "DependencyViolation.VSwitch" ||
+				e.Code == "DependencyViolation.SecurityGroup" ||
+				e.Code == "Forbbiden") && time.Now().Before(timeoutPoint) {
+				time.Sleep(1 * time.Second)
+				continue
+			}
+			ui.Error(fmt.Sprintf("Error deleting vpc, it may still be around: %s", err))
+			return
+		}
+		break
 	}
 }
-
-func (s *stepConfigAlicloudVPC) buildCreateVpcRequest(state multistep.StateBag) *ecs.CreateVpcRequest {
-	config := state.Get("config").(*Config)
-
-	request := ecs.CreateCreateVpcRequest()
-	request.ClientToken = uuid.TimeOrderedUUID()
-	request.RegionId = config.AlicloudRegion
-	request.CidrBlock = s.CidrBlock
-	request.VpcName = s.VpcName
-
-	return request
-}

builder/alicloud/ecs/step_config_vswitch.go

@@ -2,11 +2,12 @@ package ecs
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"time"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
-	"github.com/hashicorp/packer/common/uuid"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -19,65 +20,52 @@ type stepConfigAlicloudVSwitch struct {
 	VSwitchName string
 }
 
-var createVSwitchRetryErrors = []string{
-	"TOKEN_PROCESSING",
-}
-
-var deleteVSwitchRetryErrors = []string{
-	"IncorrectVSwitchStatus",
-	"DependencyViolation",
-	"DependencyViolation.HaVip",
-	"IncorrectRouteEntryStatus",
-	"TaskConflict",
-}
-
-func (s *stepConfigAlicloudVSwitch) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
+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 {
-		describeVSwitchesRequest := ecs.CreateDescribeVSwitchesRequest()
-		describeVSwitchesRequest.VpcId = vpcId
-		describeVSwitchesRequest.VSwitchId = s.VSwitchId
-		describeVSwitchesRequest.ZoneId = s.ZoneId
-
-		vswitchesResponse, err := client.DescribeVSwitches(describeVSwitchesRequest)
+		vswitchs, _, err := client.DescribeVSwitches(&ecs.DescribeVSwitchesArgs{
+			VpcId:     vpcId,
+			VSwitchId: s.VSwitchId,
+			ZoneId:    s.ZoneId,
+		})
 		if err != nil {
-			return halt(state, err, "Failed querying vswitch")
+			ui.Say(fmt.Sprintf("Failed querying vswitch: %s", err))
+			state.Put("error", err)
+			return multistep.ActionHalt
 		}
-
-		vswitch := vswitchesResponse.VSwitches.VSwitch
-		if len(vswitch) > 0 {
-			state.Put("vswitchid", vswitch[0].VSwitchId)
+		if len(vswitchs) > 0 {
+			vswitch := vswitchs[0]
+			state.Put("vswitchid", vswitch.VSwitchId)
 			s.isCreate = false
 			return multistep.ActionContinue
 		}
-
 		s.isCreate = false
-		return halt(state, fmt.Errorf("The specified vswitch {%s} doesn't exist.", s.VSwitchId), "")
+		message := fmt.Sprintf("The specified vswitch {%s} doesn't exist.", s.VSwitchId)
+		state.Put("error", errors.New(message))
+		ui.Say(message)
+		return multistep.ActionHalt
+
 	}
-
 	if s.ZoneId == "" {
-		describeZonesRequest := ecs.CreateDescribeZonesRequest()
-		describeZonesRequest.RegionId = config.AlicloudRegion
 
-		zonesResponse, err := client.DescribeZones(describeZonesRequest)
+		zones, err := client.DescribeZones(common.Region(config.AlicloudRegion))
 		if err != nil {
-			return halt(state, err, "Query for available zones failed")
+			ui.Say(fmt.Sprintf("Query for available zones failed: %s", err))
+			state.Put("error", err)
+			return multistep.ActionHalt
 		}
-
 		var instanceTypes []string
-		zones := zonesResponse.Zones.Zone
 		for _, zone := range zones {
 			isVSwitchSupported := false
 			for _, resourceType := range zone.AvailableResourceCreation.ResourceTypes {
-				if resourceType == "VSwitch" {
+				if resourceType == ecs.ResourceTypeVSwitch {
 					isVSwitchSupported = true
 				}
 			}
-
 			if isVSwitchSupported {
 				for _, instanceType := range zone.AvailableInstanceTypes.InstanceTypes {
 					if instanceType == config.InstanceType {
@@ -109,62 +97,29 @@ func (s *stepConfigAlicloudVSwitch) Run(ctx context.Context, state multistep.Sta
 			}
 		}
 	}
-
 	if config.CidrBlock == "" {
-		s.CidrBlock = DefaultCidrBlock //use the default CirdBlock
+		s.CidrBlock = "172.16.0.0/24" //use the default CirdBlock
 	}
-
 	ui.Say("Creating vswitch...")
-
-	createVSwitchRequest := s.buildCreateVSwitchRequest(state)
-	createVSwitchResponse, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			return client.CreateVSwitch(createVSwitchRequest)
-		},
-		EvalFunc: client.EvalCouldRetryResponse(createVSwitchRetryErrors, EvalRetryErrorType),
+	vswitchId, err := client.CreateVSwitch(&ecs.CreateVSwitchArgs{
+		CidrBlock:   s.CidrBlock,
+		ZoneId:      s.ZoneId,
+		VpcId:       vpcId,
+		VSwitchName: s.VSwitchName,
 	})
 	if err != nil {
-		return halt(state, err, "Error Creating vswitch")
+		state.Put("error", err)
+		ui.Say(fmt.Sprintf("Create vswitch failed %v", err))
+		return multistep.ActionHalt
 	}
-
-	vSwitchId := createVSwitchResponse.(*ecs.CreateVSwitchResponse).VSwitchId
-
-	describeVSwitchesRequest := ecs.CreateDescribeVSwitchesRequest()
-	describeVSwitchesRequest.VpcId = vpcId
-	describeVSwitchesRequest.VSwitchId = vSwitchId
-
-	_, err = client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			return client.DescribeVSwitches(describeVSwitchesRequest)
-		},
-		EvalFunc: func(response responses.AcsResponse, err error) WaitForExpectEvalResult {
-			if err != nil {
-				return WaitForExpectToRetry
-			}
-
-			vSwitchesResponse := response.(*ecs.DescribeVSwitchesResponse)
-			vSwitches := vSwitchesResponse.VSwitches.VSwitch
-			if len(vSwitches) > 0 {
-				for _, vSwitch := range vSwitches {
-					if vSwitch.Status == VSwitchStatusAvailable {
-						return WaitForExpectSuccess
-					}
-				}
-			}
-
-			return WaitForExpectToRetry
-		},
-		RetryTimes: shortRetryTimes,
-	})
-
-	if err != nil {
-		return halt(state, err, "Timeout waiting for vswitch to become available")
+	if err := client.WaitForVSwitchAvailable(vpcId, s.VSwitchId, ALICLOUD_DEFAULT_TIMEOUT); err != nil {
+		state.Put("error", err)
+		ui.Error(fmt.Sprintf("Timeout waiting for vswitch to become available: %v", err))
+		return multistep.ActionHalt
 	}
-
-	ui.Message(fmt.Sprintf("Created vswitch: %s", vSwitchId))
-	state.Put("vswitchid", vSwitchId)
+	state.Put("vswitchid", vswitchId)
 	s.isCreate = true
-	s.VSwitchId = vSwitchId
+	s.VSwitchId = vswitchId
 	return multistep.ActionContinue
 }
 
@@ -173,35 +128,22 @@ func (s *stepConfigAlicloudVSwitch) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	cleanUpMessage(state, "vSwitch")
-
-	client := state.Get("client").(*ClientWrapper)
+	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
-
-	_, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateDeleteVSwitchRequest()
-			request.VSwitchId = s.VSwitchId
-			return client.DeleteVSwitch(request)
-		},
-		EvalFunc:   client.EvalCouldRetryResponse(deleteVSwitchRetryErrors, EvalRetryErrorType),
-		RetryTimes: shortRetryTimes,
-	})
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error deleting vswitch, it may still be around: %s", err))
+	message(state, "vSwitch")
+	timeoutPoint := time.Now().Add(10 * time.Second)
+	for {
+		if err := client.DeleteVSwitch(s.VSwitchId); err != nil {
+			e, _ := err.(*common.Error)
+			if (e.Code == "IncorrectVSwitchStatus" || e.Code == "DependencyViolation" ||
+				e.Code == "DependencyViolation.HaVip" ||
+				e.Code == "IncorrectRouteEntryStatus") && time.Now().Before(timeoutPoint) {
+				time.Sleep(1 * time.Second)
+				continue
+			}
+			ui.Error(fmt.Sprintf("Error deleting vswitch, it may still be around: %s", err))
+			return
+		}
+		break
 	}
 }
-
-func (s *stepConfigAlicloudVSwitch) buildCreateVSwitchRequest(state multistep.StateBag) *ecs.CreateVSwitchRequest {
-	vpcId := state.Get("vpcid").(string)
-
-	request := ecs.CreateCreateVSwitchRequest()
-	request.ClientToken = uuid.TimeOrderedUUID()
-	request.CidrBlock = s.CidrBlock
-	request.ZoneId = s.ZoneId
-	request.VpcId = vpcId
-	request.VSwitchName = s.VSwitchName
-
-	return request
-}

builder/alicloud/ecs/step_create_image.go

@@ -3,75 +3,69 @@ package ecs
 import (
 	"context"
 	"fmt"
-	"time"
 
-	"github.com/hashicorp/packer/common/random"
-
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
-	"github.com/hashicorp/packer/common/uuid"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
 
 type stepCreateAlicloudImage struct {
-	AlicloudImageIgnoreDataDisks bool
-	WaitSnapshotReadyTimeout     int
-	image                        *ecs.Image
+	image *ecs.ImageType
 }
 
-var createImageRetryErrors = []string{
-	"IdempotentProcessing",
-}
-
-func (s *stepCreateAlicloudImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	client := state.Get("client").(*ClientWrapper)
+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)
 
-	tempImageName := config.AlicloudImageName
-	if config.ImageEncrypted.True() {
-		tempImageName = fmt.Sprintf("packer_%s", random.AlphaNum(7))
-		ui.Say(fmt.Sprintf("Creating temporary image for encryption: %s", tempImageName))
-	} else {
-		ui.Say(fmt.Sprintf("Creating image: %s", tempImageName))
-	}
+	// Create the alicloud image
+	ui.Say(fmt.Sprintf("Creating image: %s", config.AlicloudImageName))
+	var imageId string
+	var err error
 
-	createImageRequest := s.buildCreateImageRequest(state, tempImageName)
-	createImageResponse, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			return client.CreateImage(createImageRequest)
-		},
-		EvalFunc: client.EvalCouldRetryResponse(createImageRetryErrors, EvalRetryErrorType),
-	})
+	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, ALICLOUD_DEFAULT_LONG_TIMEOUT)
+	if err != nil {
+		err := fmt.Errorf("Timeout waiting for image to be created: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
 
-	imageId := createImageResponse.(*ecs.CreateImageResponse).ImageId
+	images, _, err := client.DescribeImages(&ecs.DescribeImagesArgs{
+		RegionId: common.Region(config.AlicloudRegion),
+		ImageId:  imageId})
+	if err != nil {
+		err := fmt.Errorf("Error querying created image: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
 
-	imagesResponse, err := client.WaitForImageStatus(config.AlicloudRegion, imageId, ImageStatusAvailable, time.Duration(s.WaitSnapshotReadyTimeout)*time.Second)
-
-	// save image first for cleaning up if timeout
-	images := imagesResponse.(*ecs.DescribeImagesResponse).Images.Image
 	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]
 
-	if err != nil {
-		return halt(state, err, "Timeout waiting for image to be created")
-	}
-
-	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)
@@ -83,62 +77,19 @@ func (s *stepCreateAlicloudImage) Cleanup(state multistep.StateBag) {
 	if s.image == nil {
 		return
 	}
-
-	config := state.Get("config").(*Config)
-	encryptedSet := config.ImageEncrypted.True()
-
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
-
-	if !cancelled && !halted && !encryptedSet {
+	if !cancelled && !halted {
 		return
 	}
 
-	client := state.Get("client").(*ClientWrapper)
+	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
+	config := state.Get("config").(Config)
 
-	if !cancelled && !halted && encryptedSet {
-		ui.Say(fmt.Sprintf("Deleting temporary image %s(%s) and related snapshots after finishing encryption...", s.image.ImageId, s.image.ImageName))
-	} else {
-		ui.Say("Deleting the image and related snapshots because of cancellation or error...")
-	}
-
-	deleteImageRequest := ecs.CreateDeleteImageRequest()
-	deleteImageRequest.RegionId = config.AlicloudRegion
-	deleteImageRequest.ImageId = s.image.ImageId
-	if _, err := client.DeleteImage(deleteImageRequest); err != nil {
+	ui.Say("Deleting the image because of cancellation or error...")
+	if err := client.DeleteImage(common.Region(config.AlicloudRegion), s.image.ImageId); err != nil {
 		ui.Error(fmt.Sprintf("Error deleting image, it may still be around: %s", err))
 		return
 	}
-
-	//Delete the snapshot of this image
-	for _, diskDevices := range s.image.DiskDeviceMappings.DiskDeviceMapping {
-		deleteSnapshotRequest := ecs.CreateDeleteSnapshotRequest()
-		deleteSnapshotRequest.SnapshotId = diskDevices.SnapshotId
-		if _, err := client.DeleteSnapshot(deleteSnapshotRequest); err != nil {
-			ui.Error(fmt.Sprintf("Error deleting snapshot, it may still be around: %s", err))
-			return
-		}
-	}
-}
-
-func (s *stepCreateAlicloudImage) buildCreateImageRequest(state multistep.StateBag, imageName string) *ecs.CreateImageRequest {
-	config := state.Get("config").(*Config)
-
-	request := ecs.CreateCreateImageRequest()
-	request.ClientToken = uuid.TimeOrderedUUID()
-	request.RegionId = config.AlicloudRegion
-	request.ImageName = imageName
-	request.ImageVersion = config.AlicloudImageVersion
-	request.Description = config.AlicloudImageDescription
-
-	if s.AlicloudImageIgnoreDataDisks {
-		snapshotId := state.Get("alicloudsnapshot").(string)
-		request.SnapshotId = snapshotId
-	} else {
-		instance := state.Get("instance").(*ecs.Instance)
-		request.InstanceId = instance.InstanceId
-	}
-
-	return request
 }

builder/alicloud/ecs/step_create_instance.go

@@ -2,23 +2,18 @@ package ecs
 
 import (
 	"context"
-	"encoding/base64"
 	"fmt"
 	"io/ioutil"
-	"strconv"
+	"log"
 
-	"github.com/hashicorp/packer/common/uuid"
-
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
-	confighelper "github.com/hashicorp/packer/helper/config"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
 
 type stepCreateAlicloudInstance struct {
-	IOOptimized             confighelper.Trilean
+	IOOptimized             bool
 	InstanceType            string
 	UserData                string
 	UserDataFile            string
@@ -28,55 +23,98 @@ type stepCreateAlicloudInstance struct {
 	InternetMaxBandwidthOut int
 	InstanceName            string
 	ZoneId                  string
-	instance                *ecs.Instance
+	instance                *ecs.InstanceAttributesType
 }
 
-var createInstanceRetryErrors = []string{
-	"IdempotentProcessing",
-}
-
-var deleteInstanceRetryErrors = []string{
-	"IncorrectInstanceStatus.Initializing",
-}
-
-func (s *stepCreateAlicloudInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
+func (s *stepCreateAlicloudInstance) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*ecs.Client)
+	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)
+	securityGroupId := state.Get("securitygroupid").(string)
+	var instanceId string
+	var err error
 
-	ui.Say("Creating instance...")
-	createInstanceRequest, err := s.buildCreateInstanceRequest(state)
-	if err != nil {
-		return halt(state, err, "")
+	ioOptimized := ecs.IoOptimizedNone
+	if s.IOOptimized {
+		ioOptimized = ecs.IoOptimizedOptimized
 	}
-
-	createInstanceResponse, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			return client.CreateInstance(createInstanceRequest)
-		},
-		EvalFunc: client.EvalCouldRetryResponse(createInstanceRetryErrors, EvalRetryErrorType),
-	})
-
-	if err != nil {
-		return halt(state, err, "Error creating instance")
+	password := config.Comm.SSHPassword
+	if password == "" && config.Comm.WinRMPassword != "" {
+		password = config.Comm.WinRMPassword
 	}
-
-	instanceId := createInstanceResponse.(*ecs.CreateInstanceResponse).InstanceId
-
-	_, err = client.WaitForInstanceStatus(s.RegionId, instanceId, InstanceStatusStopped)
-	if err != nil {
-		return halt(state, err, "Error waiting create instance")
+	ui.Say("Creating instance.")
+	if network_type == VpcNet {
+		userData, err := s.getUserData(state)
+		if err != nil {
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		vswitchId := state.Get("vswitchid").(string)
+		instanceId, err = client.CreateInstance(&ecs.CreateInstanceArgs{
+			RegionId:                common.Region(s.RegionId),
+			ImageId:                 source_image.ImageId,
+			InstanceType:            s.InstanceType,
+			InternetChargeType:      common.InternetChargeType(s.InternetChargeType), //"PayByTraffic",
+			InternetMaxBandwidthOut: s.InternetMaxBandwidthOut,
+			UserData:                userData,
+			IoOptimized:             ioOptimized,
+			VSwitchId:               vswitchId,
+			SecurityGroupId:         securityGroupId,
+			InstanceName:            s.InstanceName,
+			Password:                password,
+			ZoneId:                  s.ZoneId,
+			DataDisk:                diskDeviceToDiskType(config.AlicloudImageConfig.ECSImagesDiskMappings),
+		})
+		if err != nil {
+			err := fmt.Errorf("Error creating instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+	} else {
+		if s.InstanceType == "" {
+			s.InstanceType = "PayByTraffic"
+		}
+		if s.InternetMaxBandwidthOut == 0 {
+			s.InternetMaxBandwidthOut = 5
+		}
+		instanceId, err = client.CreateInstance(&ecs.CreateInstanceArgs{
+			RegionId:                common.Region(s.RegionId),
+			ImageId:                 source_image.ImageId,
+			InstanceType:            s.InstanceType,
+			InternetChargeType:      common.InternetChargeType(s.InternetChargeType), //"PayByTraffic",
+			InternetMaxBandwidthOut: s.InternetMaxBandwidthOut,
+			IoOptimized:             ioOptimized,
+			SecurityGroupId:         securityGroupId,
+			InstanceName:            s.InstanceName,
+			Password:                password,
+			ZoneId:                  s.ZoneId,
+			DataDisk:                diskDeviceToDiskType(config.AlicloudImageConfig.ECSImagesDiskMappings),
+		})
+		if err != nil {
+			err := fmt.Errorf("Error creating instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
 	}
-
-	describeInstancesRequest := ecs.CreateDescribeInstancesRequest()
-	describeInstancesRequest.InstanceIds = fmt.Sprintf("[\"%s\"]", instanceId)
-	instances, err := client.DescribeInstances(describeInstancesRequest)
+	err = client.WaitForInstance(instanceId, ecs.Stopped, ALICLOUD_DEFAULT_TIMEOUT)
 	if err != nil {
-		return halt(state, err, "")
+		err := fmt.Errorf("Error creating instance: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
-
-	ui.Message(fmt.Sprintf("Created instance: %s", instanceId))
-	s.instance = &instances.Instances.Instance[0]
-	state.Put("instance", s.instance)
+	instance, err := client.DescribeInstanceAttribute(instanceId)
+	if err != nil {
+		ui.Say(err.Error())
+		return multistep.ActionHalt
+	}
+	s.instance = instance
+	state.Put("instance", instance)
 
 	return multistep.ActionContinue
 }
@@ -85,121 +123,42 @@ func (s *stepCreateAlicloudInstance) Cleanup(state multistep.StateBag) {
 	if s.instance == nil {
 		return
 	}
-	cleanUpMessage(state, "instance")
-
-	client := state.Get("client").(*ClientWrapper)
+	message(state, "instance")
+	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
-
-	_, err := client.WaitForExpected(&WaitForExpectArgs{
-		RequestFunc: func() (responses.AcsResponse, error) {
-			request := ecs.CreateDeleteInstanceRequest()
-			request.InstanceId = s.instance.InstanceId
-			request.Force = requests.NewBoolean(true)
-			return client.DeleteInstance(request)
-		},
-		EvalFunc:   client.EvalCouldRetryResponse(deleteInstanceRetryErrors, EvalRetryErrorType),
-		RetryTimes: shortRetryTimes,
-	})
-
+	err := client.DeleteInstance(s.instance.InstanceId)
 	if err != nil {
-		ui.Say(fmt.Sprintf("Failed to clean up instance %s: %s", s.instance.InstanceId, err))
-	}
-}
-
-func (s *stepCreateAlicloudInstance) buildCreateInstanceRequest(state multistep.StateBag) (*ecs.CreateInstanceRequest, error) {
-	request := ecs.CreateCreateInstanceRequest()
-	request.ClientToken = uuid.TimeOrderedUUID()
-	request.RegionId = s.RegionId
-	request.InstanceType = s.InstanceType
-	request.InstanceName = s.InstanceName
-	request.ZoneId = s.ZoneId
-
-	sourceImage := state.Get("source_image").(*ecs.Image)
-	request.ImageId = sourceImage.ImageId
-
-	securityGroupId := state.Get("securitygroupid").(string)
-	request.SecurityGroupId = securityGroupId
-
-	networkType := state.Get("networktype").(InstanceNetWork)
-	if networkType == InstanceNetworkVpc {
-		vswitchId := state.Get("vswitchid").(string)
-		request.VSwitchId = vswitchId
-
-		userData, err := s.getUserData(state)
-		if err != nil {
-			return nil, err
-		}
-
-		request.UserData = userData
-	} else {
-		if s.InternetChargeType == "" {
-			s.InternetChargeType = "PayByTraffic"
-		}
-
-		if s.InternetMaxBandwidthOut == 0 {
-			s.InternetMaxBandwidthOut = 5
-		}
-	}
-	request.InternetChargeType = s.InternetChargeType
-	request.InternetMaxBandwidthOut = requests.Integer(convertNumber(s.InternetMaxBandwidthOut))
-
-	if s.IOOptimized.True() {
-		request.IoOptimized = IOOptimizedOptimized
-	} else if s.IOOptimized.False() {
-		request.IoOptimized = IOOptimizedNone
+		ui.Say(fmt.Sprintf("Failed to clean up instance %s: %v", s.instance.InstanceId, err.Error()))
 	}
 
-	config := state.Get("config").(*Config)
-	password := config.Comm.SSHPassword
-	if password == "" && config.Comm.WinRMPassword != "" {
-		password = config.Comm.WinRMPassword
-	}
-	request.Password = password
-
-	systemDisk := config.AlicloudImageConfig.ECSSystemDiskMapping
-	request.SystemDiskDiskName = systemDisk.DiskName
-	request.SystemDiskCategory = systemDisk.DiskCategory
-	request.SystemDiskSize = requests.Integer(convertNumber(systemDisk.DiskSize))
-	request.SystemDiskDescription = systemDisk.Description
-
-	imageDisks := config.AlicloudImageConfig.ECSImagesDiskMappings
-	var dataDisks []ecs.CreateInstanceDataDisk
-	for _, imageDisk := range imageDisks {
-		var dataDisk ecs.CreateInstanceDataDisk
-		dataDisk.DiskName = imageDisk.DiskName
-		dataDisk.Category = imageDisk.DiskCategory
-		dataDisk.Size = string(convertNumber(imageDisk.DiskSize))
-		dataDisk.SnapshotId = imageDisk.SnapshotId
-		dataDisk.Description = imageDisk.Description
-		dataDisk.DeleteWithInstance = strconv.FormatBool(imageDisk.DeleteWithInstance)
-		dataDisk.Device = imageDisk.Device
-		if imageDisk.Encrypted != confighelper.TriUnset {
-			dataDisk.Encrypted = strconv.FormatBool(imageDisk.Encrypted.True())
-		}
-
-		dataDisks = append(dataDisks, dataDisk)
-	}
-	request.DataDisk = &dataDisks
-
-	return request, nil
 }
 
 func (s *stepCreateAlicloudInstance) getUserData(state multistep.StateBag) (string, error) {
 	userData := s.UserData
-
 	if s.UserDataFile != "" {
 		data, err := ioutil.ReadFile(s.UserDataFile)
 		if err != nil {
 			return "", err
 		}
-
 		userData = string(data)
 	}
-
-	if userData != "" {
-		userData = base64.StdEncoding.EncodeToString([]byte(userData))
-	}
-
+	log.Printf(userData)
 	return userData, nil
 
 }
+
+func diskDeviceToDiskType(diskDevices []AlicloudDiskDevice) []ecs.DataDiskType {
+	result := make([]ecs.DataDiskType, len(diskDevices))
+	for _, diskDevice := range diskDevices {
+		result = append(result, ecs.DataDiskType{
+			DiskName:           diskDevice.DiskName,
+			Category:           ecs.DiskCategory(diskDevice.DiskCategory),
+			Size:               diskDevice.DiskSize,
+			SnapshotId:         diskDevice.SnapshotId,
+			Description:        diskDevice.Description,
+			DeleteWithInstance: diskDevice.DeleteWithInstance,
+			Device:             diskDevice.Device,
+		})
+	}
+	return result
+}

builder/alicloud/ecs/step_create_snapshot.go

@@ -1,90 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
-	"time"
-
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepCreateAlicloudSnapshot struct {
-	snapshot                 *ecs.Snapshot
-	WaitSnapshotReadyTimeout int
-}
-
-func (s *stepCreateAlicloudSnapshot) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	client := state.Get("client").(*ClientWrapper)
-	ui := state.Get("ui").(packer.Ui)
-	instance := state.Get("instance").(*ecs.Instance)
-
-	describeDisksRequest := ecs.CreateDescribeDisksRequest()
-	describeDisksRequest.RegionId = config.AlicloudRegion
-	describeDisksRequest.InstanceId = instance.InstanceId
-	describeDisksRequest.DiskType = DiskTypeSystem
-	disksResponse, err := client.DescribeDisks(describeDisksRequest)
-	if err != nil {
-		return halt(state, err, "Error describe disks")
-	}
-
-	disks := disksResponse.Disks.Disk
-	if len(disks) == 0 {
-		return halt(state, err, "Unable to find system disk of instance")
-	}
-
-	createSnapshotRequest := ecs.CreateCreateSnapshotRequest()
-	createSnapshotRequest.DiskId = disks[0].DiskId
-	snapshot, err := client.CreateSnapshot(createSnapshotRequest)
-	if err != nil {
-		return halt(state, err, "Error creating snapshot")
-	}
-
-	// Create the alicloud snapshot
-	ui.Say(fmt.Sprintf("Creating snapshot from system disk %s: %s", disks[0].DiskId, snapshot.SnapshotId))
-
-	snapshotsResponse, err := client.WaitForSnapshotStatus(config.AlicloudRegion, snapshot.SnapshotId, SnapshotStatusAccomplished, time.Duration(s.WaitSnapshotReadyTimeout)*time.Second)
-	if err != nil {
-		_, ok := err.(errors.Error)
-		if ok {
-			return halt(state, err, "Error querying created snapshot")
-		}
-
-		return halt(state, err, "Timeout waiting for snapshot to be created")
-	}
-
-	snapshots := snapshotsResponse.(*ecs.DescribeSnapshotsResponse).Snapshots.Snapshot
-	if len(snapshots) == 0 {
-		return halt(state, err, "Unable to find created snapshot")
-	}
-
-	s.snapshot = &snapshots[0]
-	state.Put("alicloudsnapshot", snapshot.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").(*ClientWrapper)
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Deleting the snapshot because of cancellation or error...")
-
-	deleteSnapshotRequest := ecs.CreateDeleteSnapshotRequest()
-	deleteSnapshotRequest.SnapshotId = s.snapshot.SnapshotId
-	if _, err := client.DeleteSnapshot(deleteSnapshotRequest); 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,65 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/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").(*ClientWrapper)
-	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))
-
-	var tags []ecs.AddTagsTag
-	for key, value := range s.Tags {
-		var tag ecs.AddTagsTag
-		tag.Key = key
-		tag.Value = value
-		tags = append(tags, tag)
-	}
-
-	addTagsRequest := ecs.CreateAddTagsRequest()
-	addTagsRequest.RegionId = config.AlicloudRegion
-	addTagsRequest.ResourceId = imageId
-	addTagsRequest.ResourceType = TagResourceImage
-	addTagsRequest.Tag = &tags
-
-	if _, err := client.AddTags(addTagsRequest); 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))
-		addTagsRequest := ecs.CreateAddTagsRequest()
-
-		addTagsRequest.RegionId = config.AlicloudRegion
-		addTagsRequest.ResourceId = snapshotId
-		addTagsRequest.ResourceType = TagResourceSnapshot
-		addTagsRequest.Tag = &tags
-
-		if _, err := client.AddTags(addTagsRequest); 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

@@ -5,7 +5,8 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -14,88 +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").(*ClientWrapper)
-	ui := state.Get("ui").(packer.Ui)
-
-	describeImagesRequest := ecs.CreateDescribeImagesRequest()
-	describeImagesRequest.RegionId = region
-	describeImagesRequest.ImageName = imageName
-	describeImagesRequest.Status = ImageStatusQueried
-	imageResponse, _ := client.DescribeImages(describeImagesRequest)
-	images := imageResponse.Images.Image
-	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 != ImageOwnerSelf {
-			log.Printf("You can not delete non-customized images: %s ", image.ImageId)
-			continue
-		}
-
-		deleteImageRequest := ecs.CreateDeleteImageRequest()
-		deleteImageRequest.RegionId = region
-		deleteImageRequest.ImageId = image.ImageId
-		if _, err := client.DeleteImage(deleteImageRequest); err != nil {
-			err := fmt.Errorf("Failed to delete image: %s", err)
-			return err
-		}
-
-		if s.AlicloudImageForceDeleteSnapshots {
-			for _, diskDevice := range image.DiskDeviceMappings.DiskDeviceMapping {
-				deleteSnapshotRequest := ecs.CreateDeleteSnapshotRequest()
-				deleteSnapshotRequest.SnapshotId = diskDevice.SnapshotId
-				if _, err := client.DeleteSnapshot(deleteSnapshotRequest); 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

@@ -0,0 +1,72 @@
+package ecs
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/denverdino/aliyungo/ecs"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+)
+
+type stepMountAlicloudDisk struct {
+}
+
+func (s *stepMountAlicloudDisk) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*ecs.Client)
+	config := state.Get("config").(Config)
+	ui := state.Get("ui").(packer.Ui)
+	instance := state.Get("instance").(*ecs.InstanceAttributesType)
+	alicloudDiskDevices := config.ECSImagesDiskMappings
+	if len(config.ECSImagesDiskMappings) == 0 {
+		return multistep.ActionContinue
+	}
+	ui.Say("Mounting disks.")
+	disks, _, err := client.DescribeDisks(&ecs.DescribeDisksArgs{InstanceId: instance.InstanceId,
+		RegionId: instance.RegionId})
+	if err != nil {
+		err := fmt.Errorf("Error querying disks: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+	for _, disk := range disks {
+		if disk.Status == ecs.DiskStatusAvailable {
+			if err := client.AttachDisk(&ecs.AttachDiskArgs{DiskId: disk.DiskId,
+				InstanceId: instance.InstanceId,
+				Device:     getDevice(&disk, alicloudDiskDevices),
+			}); err != nil {
+				err := fmt.Errorf("Error mounting disks: %s", err)
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
+		}
+	}
+	for _, disk := range disks {
+		if err := client.WaitForDisk(instance.RegionId, disk.DiskId, ecs.DiskStatusInUse, ALICLOUD_DEFAULT_SHORT_TIMEOUT); err != nil {
+			err := fmt.Errorf("Timeout waiting for mount: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+	}
+	ui.Say("Finished mounting disks.")
+	return multistep.ActionContinue
+}
+
+func (s *stepMountAlicloudDisk) Cleanup(state multistep.StateBag) {
+
+}
+
+func getDevice(disk *ecs.DiskItemType, diskDevices []AlicloudDiskDevice) string {
+	if disk.Device != "" {
+		return disk.Device
+	}
+	for _, alicloudDiskDevice := range diskDevices {
+		if alicloudDiskDevice.DiskName == disk.DiskName || alicloudDiskDevice.SnapshotId == disk.SourceSnapshotId {
+			return alicloudDiskDevice.Device
+		}
+	}
+	return ""
+}

builder/alicloud/ecs/step_pre_validate.go

@@ -4,7 +4,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -14,74 +15,35 @@ type stepPreValidate struct {
 	ForceDelete           bool
 }
 
-func (s *stepPreValidate) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	if err := s.validateRegions(state); err != nil {
-		return halt(state, err, "")
+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.")
+		return multistep.ActionContinue
 	}
 
-	if err := s.validateDestImageName(state); err != nil {
-		return halt(state, err, "")
+	client := state.Get("client").(*ecs.Client)
+	config := state.Get("config").(Config)
+	ui.Say("Prevalidating image name...")
+	images, _, err := client.DescribeImages(&ecs.DescribeImagesArgs{
+		ImageName: s.AlicloudDestImageName,
+		RegionId:  common.Region(config.AlicloudRegion)})
+
+	if err != nil {
+		err := fmt.Errorf("Error querying alicloud image: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	if len(images) > 0 {
+		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
 	}
 
 	return multistep.ActionContinue
 }
 
-func (s *stepPreValidate) validateRegions(state multistep.StateBag) error {
-	ui := state.Get("ui").(packer.Ui)
-	config := state.Get("config").(*Config)
-
-	if config.AlicloudSkipValidation {
-		ui.Say("Skip region validation flag found, skipping prevalidating source region and copied regions.")
-		return nil
-	}
-
-	ui.Say("Prevalidating source region and copied regions...")
-
-	var errs *packer.MultiError
-	if err := config.ValidateRegion(config.AlicloudRegion); err != nil {
-		errs = packer.MultiErrorAppend(errs, err)
-	}
-	for _, region := range config.AlicloudImageDestinationRegions {
-		if err := config.ValidateRegion(region); err != nil {
-			errs = packer.MultiErrorAppend(errs, err)
-		}
-	}
-
-	if errs != nil && len(errs.Errors) > 0 {
-		return errs
-	}
-
-	return nil
-}
-
-func (s *stepPreValidate) validateDestImageName(state multistep.StateBag) error {
-	ui := state.Get("ui").(packer.Ui)
-	client := state.Get("client").(*ClientWrapper)
-	config := state.Get("config").(*Config)
-
-	if s.ForceDelete {
-		ui.Say("Force delete flag found, skipping prevalidating image name.")
-		return nil
-	}
-
-	ui.Say("Prevalidating image name...")
-
-	describeImagesRequest := ecs.CreateDescribeImagesRequest()
-	describeImagesRequest.RegionId = config.AlicloudRegion
-	describeImagesRequest.ImageName = s.AlicloudDestImageName
-	describeImagesRequest.Status = ImageStatusQueried
-
-	imagesResponse, err := client.DescribeImages(describeImagesRequest)
-	if err != nil {
-		return fmt.Errorf("Error querying alicloud image: %s", err)
-	}
-
-	images := imagesResponse.Images.Image
-	if len(images) > 0 {
-		return fmt.Errorf("Error: Image Name: '%s' is used by an existing alicloud image: %s", images[0].ImageName, images[0].ImageId)
-	}
-
-	return nil
-}
-
 func (s *stepPreValidate) Cleanup(multistep.StateBag) {}

builder/alicloud/ecs/step_region_copy_image.go

@@ -3,11 +3,9 @@ package ecs
 import (
 	"context"
 	"fmt"
-	"time"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
-	confighelper "github.com/hashicorp/packer/helper/config"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -18,89 +16,57 @@ type stepRegionCopyAlicloudImage struct {
 	RegionId                        string
 }
 
-func (s *stepRegionCopyAlicloudImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-
-	if config.ImageEncrypted != confighelper.TriUnset {
-		s.AlicloudImageDestinationRegions = append(s.AlicloudImageDestinationRegions, s.RegionId)
-		s.AlicloudImageDestinationNames = append(s.AlicloudImageDestinationNames, config.AlicloudImageName)
-	}
-
+func (s *stepRegionCopyAlicloudImage) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
 	if len(s.AlicloudImageDestinationRegions) == 0 {
 		return multistep.ActionContinue
 	}
-
-	client := state.Get("client").(*ClientWrapper)
+	client := state.Get("client").(*ecs.Client)
 	ui := state.Get("ui").(packer.Ui)
-
-	srcImageId := state.Get("alicloudimage").(string)
+	imageId := state.Get("alicloudimage").(string)
 	alicloudImages := state.Get("alicloudimages").(map[string]string)
-	numberOfName := len(s.AlicloudImageDestinationNames)
+	region := common.Region(s.RegionId)
 
-	ui.Say(fmt.Sprintf("Coping image %s from %s...", srcImageId, s.RegionId))
+	numberOfName := len(s.AlicloudImageDestinationNames)
 	for index, destinationRegion := range s.AlicloudImageDestinationRegions {
-		if destinationRegion == s.RegionId && config.ImageEncrypted == confighelper.TriUnset {
+		if destinationRegion == s.RegionId {
 			continue
 		}
-
 		ecsImageName := ""
 		if numberOfName > 0 && index < numberOfName {
 			ecsImageName = s.AlicloudImageDestinationNames[index]
 		}
-
-		copyImageRequest := ecs.CreateCopyImageRequest()
-		copyImageRequest.RegionId = s.RegionId
-		copyImageRequest.ImageId = srcImageId
-		copyImageRequest.DestinationRegionId = destinationRegion
-		copyImageRequest.DestinationImageName = ecsImageName
-		if config.ImageEncrypted != confighelper.TriUnset {
-			copyImageRequest.Encrypted = requests.NewBoolean(config.ImageEncrypted.True())
-		}
-
-		imageResponse, err := client.CopyImage(copyImageRequest)
+		imageId, err := client.CopyImage(
+			&ecs.CopyImageArgs{
+				RegionId:             region,
+				ImageId:              imageId,
+				DestinationRegionId:  common.Region(destinationRegion),
+				DestinationImageName: ecsImageName,
+			})
 		if err != nil {
-			return halt(state, err, "Error copying images")
+			state.Put("error", err)
+			ui.Say(fmt.Sprintf("Error copying images: %s", err))
+			return multistep.ActionHalt
 		}
-
-		alicloudImages[destinationRegion] = imageResponse.ImageId
-		ui.Message(fmt.Sprintf("Copy image from %s(%s) to %s(%s)", s.RegionId, srcImageId, destinationRegion, imageResponse.ImageId))
+		alicloudImages[destinationRegion] = imageId
 	}
-
-	if config.ImageEncrypted != confighelper.TriUnset {
-		if _, err := client.WaitForImageStatus(s.RegionId, alicloudImages[s.RegionId], ImageStatusAvailable, time.Duration(ALICLOUD_DEFAULT_LONG_TIMEOUT)*time.Second); err != nil {
-			return halt(state, err, fmt.Sprintf("Timeout waiting image %s finish copying", alicloudImages[s.RegionId]))
-		}
-	}
-
 	return multistep.ActionContinue
 }
 
 func (s *stepRegionCopyAlicloudImage) Cleanup(state multistep.StateBag) {
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
-
-	if !cancelled && !halted {
-		return
-	}
-
-	ui := state.Get("ui").(packer.Ui)
-	ui.Say(fmt.Sprintf("Stopping copy image because cancellation or error..."))
-
-	client := state.Get("client").(*ClientWrapper)
-	alicloudImages := state.Get("alicloudimages").(map[string]string)
-	srcImageId := state.Get("alicloudimage").(string)
-
-	for copiedRegionId, copiedImageId := range alicloudImages {
-		if copiedImageId == srcImageId {
-			continue
-		}
-
-		cancelCopyImageRequest := ecs.CreateCancelCopyImageRequest()
-		cancelCopyImageRequest.RegionId = copiedRegionId
-		cancelCopyImageRequest.ImageId = copiedImageId
-		if _, err := client.CancelCopyImage(cancelCopyImageRequest); err != nil {
-
-			ui.Error(fmt.Sprintf("Error cancelling copy image: %v", err))
+	if cancelled || halted {
+		ui := state.Get("ui").(packer.Ui)
+		client := state.Get("client").(*ecs.Client)
+		alicloudImages := state.Get("alicloudimages").(map[string]string)
+		ui.Say(fmt.Sprintf("Stopping copy image because cancellation or error..."))
+		for copiedRegionId, copiedImageId := range alicloudImages {
+			if copiedRegionId == s.RegionId {
+				continue
+			}
+			if err := client.CancelCopyImage(common.Region(copiedRegionId), copiedImageId); err != nil {
+				ui.Say(fmt.Sprintf("Error cancelling copy image: %v", err))
+			}
 		}
 	}
 }

builder/alicloud/ecs/step_run_instance.go

@@ -4,8 +4,7 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -13,22 +12,25 @@ import (
 type stepRunAlicloudInstance struct {
 }
 
-func (s *stepRunAlicloudInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
+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.Instance)
+	instance := state.Get("instance").(*ecs.InstanceAttributesType)
 
-	startInstanceRequest := ecs.CreateStartInstanceRequest()
-	startInstanceRequest.InstanceId = instance.InstanceId
-	if _, err := client.StartInstance(startInstanceRequest); err != nil {
-		return halt(state, err, "Error starting instance")
-	}
-
-	ui.Say(fmt.Sprintf("Starting instance: %s", instance.InstanceId))
-
-	_, err := client.WaitForInstanceStatus(instance.RegionId, instance.InstanceId, InstanceStatusRunning)
+	err := client.StartInstance(instance.InstanceId)
 	if err != nil {
-		return halt(state, err, "Timeout waiting for instance to start")
+		err := fmt.Errorf("Error starting instance: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+	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)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
 
 	return multistep.ActionContinue
@@ -37,36 +39,19 @@ func (s *stepRunAlicloudInstance) Run(ctx context.Context, state multistep.State
 func (s *stepRunAlicloudInstance) Cleanup(state multistep.StateBag) {
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
-
-	if !cancelled && !halted {
-		return
-	}
-
-	ui := state.Get("ui").(packer.Ui)
-	client := state.Get("client").(*ClientWrapper)
-	instance := state.Get("instance").(*ecs.Instance)
-
-	describeInstancesRequest := ecs.CreateDescribeInstancesRequest()
-	describeInstancesRequest.InstanceIds = fmt.Sprintf("[\"%s\"]", instance.InstanceId)
-	instancesResponse, _ := client.DescribeInstances(describeInstancesRequest)
-
-	if len(instancesResponse.Instances.Instance) == 0 {
-		return
-	}
-
-	instanceAttribute := instancesResponse.Instances.Instance[0]
-	if instanceAttribute.Status == InstanceStatusStarting || instanceAttribute.Status == InstanceStatusRunning {
-		stopInstanceRequest := ecs.CreateStopInstanceRequest()
-		stopInstanceRequest.InstanceId = instance.InstanceId
-		stopInstanceRequest.ForceStop = requests.NewBoolean(true)
-		if _, err := client.StopInstance(stopInstanceRequest); err != nil {
-			ui.Say(fmt.Sprintf("Error stopping instance %s, it may still be around %s", instance.InstanceId, err))
-			return
-		}
-
-		_, err := client.WaitForInstanceStatus(instance.RegionId, instance.InstanceId, InstanceStatusStopped)
-		if err != nil {
-			ui.Say(fmt.Sprintf("Error stopping instance %s, it may still be around %s", instance.InstanceId, err))
+	if cancelled || halted {
+		ui := state.Get("ui").(packer.Ui)
+		client := state.Get("client").(*ecs.Client)
+		instance := state.Get("instance").(*ecs.InstanceAttributesType)
+		instanceAttribute, _ := client.DescribeInstanceAttribute(instance.InstanceId)
+		if instanceAttribute.Status == ecs.Starting || instanceAttribute.Status == ecs.Running {
+			if err := client.StopInstance(instance.InstanceId, true); err != nil {
+				ui.Say(fmt.Sprintf("Error stopping instance %s, it may still be around %s", instance.InstanceId, err))
+				return
+			}
+			if err := client.WaitForInstance(instance.InstanceId, ecs.Stopped, ALICLOUD_DEFAULT_TIMEOUT); err != nil {
+				ui.Say(fmt.Sprintf("Error stopping instance %s, it may still be around %s", instance.InstanceId, err))
+			}
 		}
 	}
 }

builder/alicloud/ecs/step_share_image.go

@@ -4,7 +4,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/common"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -15,19 +16,22 @@ type stepShareAlicloudImage struct {
 	RegionId                     string
 }
 
-func (s *stepShareAlicloudImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
+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)
-
-	for regionId, imageId := range alicloudImages {
-		modifyImageShareRequest := ecs.CreateModifyImageSharePermissionRequest()
-		modifyImageShareRequest.RegionId = regionId
-		modifyImageShareRequest.ImageId = imageId
-		modifyImageShareRequest.AddAccount = &s.AlicloudImageShareAccounts
-		modifyImageShareRequest.RemoveAccount = &s.AlicloudImageUNShareAccounts
-
-		if _, err := client.ModifyImageSharePermission(modifyImageShareRequest); err != nil {
-			return halt(state, err, "Failed modifying image share permissions")
+	for copiedRegion, copiedImageId := range alicloudImages {
+		err := client.ModifyImageSharePermission(
+			&ecs.ModifyImageSharePermissionArgs{
+				RegionId:      common.Region(copiedRegion),
+				ImageId:       copiedImageId,
+				AddAccount:    s.AlicloudImageShareAccounts,
+				RemoveAccount: s.AlicloudImageUNShareAccounts,
+			})
+		if err != nil {
+			state.Put("error", err)
+			ui.Say(fmt.Sprintf("Failed modifying image share permissions: %s", err))
+			return multistep.ActionHalt
 		}
 	}
 	return multistep.ActionContinue
@@ -36,25 +40,22 @@ func (s *stepShareAlicloudImage) Run(ctx context.Context, state multistep.StateB
 func (s *stepShareAlicloudImage) Cleanup(state multistep.StateBag) {
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
-
-	if !cancelled && !halted {
-		return
-	}
-
-	ui := state.Get("ui").(packer.Ui)
-	client := state.Get("client").(*ClientWrapper)
-	alicloudImages := state.Get("alicloudimages").(map[string]string)
-
-	ui.Say("Restoring image share permission because cancellations or error...")
-
-	for regionId, imageId := range alicloudImages {
-		modifyImageShareRequest := ecs.CreateModifyImageSharePermissionRequest()
-		modifyImageShareRequest.RegionId = regionId
-		modifyImageShareRequest.ImageId = imageId
-		modifyImageShareRequest.AddAccount = &s.AlicloudImageUNShareAccounts
-		modifyImageShareRequest.RemoveAccount = &s.AlicloudImageShareAccounts
-		if _, err := client.ModifyImageSharePermission(modifyImageShareRequest); err != nil {
-			ui.Say(fmt.Sprintf("Restoring image share permission failed: %s", err))
+	if cancelled || halted {
+		ui := state.Get("ui").(packer.Ui)
+		client := state.Get("client").(*ecs.Client)
+		alicloudImages := state.Get("alicloudimages").(map[string]string)
+		ui.Say("Restoring image share permission because cancellations or error...")
+		for copiedRegion, copiedImageId := range alicloudImages {
+			err := client.ModifyImageSharePermission(
+				&ecs.ModifyImageSharePermissionArgs{
+					RegionId:      common.Region(copiedRegion),
+					ImageId:       copiedImageId,
+					AddAccount:    s.AlicloudImageUNShareAccounts,
+					RemoveAccount: s.AlicloudImageShareAccounts,
+				})
+			if err != nil {
+				ui.Say(fmt.Sprintf("Restoring image share permission failed: %s", err))
+			}
 		}
 	}
 }

builder/alicloud/ecs/step_stop_instance.go

@@ -3,41 +3,37 @@ package ecs
 import (
 	"context"
 	"fmt"
-	"strconv"
 
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-
-	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/denverdino/aliyungo/ecs"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
 
 type stepStopAlicloudInstance struct {
-	ForceStop   bool
-	DisableStop bool
+	ForceStop bool
 }
 
-func (s *stepStopAlicloudInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ClientWrapper)
-	instance := state.Get("instance").(*ecs.Instance)
+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))
-
-		stopInstanceRequest := ecs.CreateStopInstanceRequest()
-		stopInstanceRequest.InstanceId = instance.InstanceId
-		stopInstanceRequest.ForceStop = requests.Boolean(strconv.FormatBool(s.ForceStop))
-		if _, err := client.StopInstance(stopInstanceRequest); err != nil {
-			return halt(state, err, "Error stopping alicloud instance")
+	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)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
 		}
 	}
 
-	ui.Say(fmt.Sprintf("Waiting instance stopped: %s", instance.InstanceId))
-
-	_, err := client.WaitForInstanceStatus(instance.RegionId, instance.InstanceId, InstanceStatusStopped)
+	err = client.WaitForInstance(instance.InstanceId, ecs.Stopped, ALICLOUD_DEFAULT_TIMEOUT)
 	if err != nil {
-		return halt(state, err, "Error waiting for alicloud instance to stop")
+		err := fmt.Errorf("Error waiting for alicloud instance to stop: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
 	}
 
 	return multistep.ActionContinue

builder/amazon/chroot/block_device.go

@@ -1,69 +0,0 @@
-//go:generate struct-markdown
-
-package chroot
-
-import (
-	"fmt"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/template/interpolate"
-)
-
-type BlockDevice struct {
-	awscommon.BlockDevice `mapstructure:",squash"`
-	// ID, alias or ARN of the KMS key to use for boot volume encryption. This
-	// only applies to the main region, other regions where the AMI will be
-	// copied will be encrypted by the default EBS KMS key. For valid formats
-	// see KmsKeyId in the [AWS API docs -
-	// CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopyImage.html)
-	// This field is validated by Packer, when using an alias, you will have to
-	// prefix kms_key_id with alias/.
-	KmsKeyId string `mapstructure:"kms_key_id" required:"false"`
-}
-
-type BlockDevices []BlockDevice
-
-func (bds BlockDevices) BuildEC2BlockDeviceMappings() []*ec2.BlockDeviceMapping {
-	var blockDevices []*ec2.BlockDeviceMapping
-
-	for _, blockDevice := range bds {
-		blockDevices = append(blockDevices, blockDevice.BuildEC2BlockDeviceMapping())
-	}
-	return blockDevices
-}
-
-func (blockDevice BlockDevice) BuildEC2BlockDeviceMapping() *ec2.BlockDeviceMapping {
-	mapping := blockDevice.BlockDevice.BuildEC2BlockDeviceMapping()
-
-	if blockDevice.KmsKeyId != "" {
-		mapping.Ebs.KmsKeyId = aws.String(blockDevice.KmsKeyId)
-	}
-	return mapping
-}
-
-func (b *BlockDevice) Prepare(ctx *interpolate.Context) error {
-	err := b.BlockDevice.Prepare(ctx)
-	if err != nil {
-		return err
-	}
-
-	// Warn that encrypted must be true when setting kms_key_id
-	if b.KmsKeyId != "" && b.Encrypted.True() {
-		return fmt.Errorf("The device %v, must also have `encrypted: "+
-			"true` when setting a kms_key_id.", b.DeviceName)
-	}
-
-	_, err = interpolate.RenderInterface(&b, ctx)
-	return err
-}
-
-func (bds BlockDevices) Prepare(ctx *interpolate.Context) (errs []error) {
-	for _, block := range bds {
-		if err := block.Prepare(ctx); err != nil {
-			errs = append(errs, err)
-		}
-	}
-	return errs
-}

builder/amazon/chroot/builder.go

@@ -1,14 +1,12 @@
-//go:generate struct-markdown
-
-// The chroot package is able to create an Amazon AMI without requiring the
-// launch of a new instance for every build. It does this by attaching and
-// mounting the root volume of another AMI and chrooting into that directory.
-// It then creates an AMI from that attached drive.
+// The chroot package is able to create an Amazon AMI without requiring
+// the launch of a new instance for every build. It does this by attaching
+// and mounting the root volume of another AMI and chrooting into that
+// directory. It then creates an AMI from that attached drive.
 package chroot
 
 import (
-	"context"
 	"errors"
+	"log"
 	"runtime"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
@@ -23,147 +21,30 @@ import (
 // The unique ID for this builder
 const BuilderId = "mitchellh.amazon.chroot"
 
-// Config is the configuration that is chained through the steps and settable
-// from the template.
+// Config is the configuration that is chained through the steps and
+// settable from the template.
 type Config struct {
-	common.PackerConfig    `mapstructure:",squash"`
-	awscommon.AMIConfig    `mapstructure:",squash"`
-	awscommon.AccessConfig `mapstructure:",squash"`
-	// Add one or more [block device
-	// mappings](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html)
-	// to the AMI. If this field is populated, and you are building from an
-	// existing source image, the block device mappings in the source image
-	// will be overwritten. This means you must have a block device mapping
-	// entry for your root volume, `root_volume_size` and `root_device_name`.
-	// See the [BlockDevices](#block-devices-configuration) documentation for
-	// fields.
-	AMIMappings BlockDevices `mapstructure:"ami_block_device_mappings" required:"false"`
-	// This is a list of devices to mount into the chroot environment. This
-	// configuration parameter requires some additional documentation which is
-	// in the Chroot Mounts section. Please read that section for more
-	// information on how to use this.
-	ChrootMounts [][]string `mapstructure:"chroot_mounts" required:"false"`
-	// How to run shell commands. This defaults to {{.Command}}. This may be
-	// useful to set if you want to set environmental variables or perhaps run
-	// it with sudo or so on. This is a configuration template where the
-	// .Command variable is replaced with the command to be run. Defaults to
-	// {{.Command}}.
-	CommandWrapper string `mapstructure:"command_wrapper" required:"false"`
-	// Paths to files on the running EC2 instance that will be copied into the
-	// chroot environment prior to provisioning. Defaults to /etc/resolv.conf
-	// so that DNS lookups work. Pass an empty list to skip copying
-	// /etc/resolv.conf. You may need to do this if you're building an image
-	// that uses systemd.
-	CopyFiles []string `mapstructure:"copy_files" required:"false"`
-	// The path to the device where the root volume of the source AMI will be
-	// attached. This defaults to "" (empty string), which forces Packer to
-	// find an open device automatically.
-	DevicePath string `mapstructure:"device_path" required:"false"`
-	// When we call the mount command (by default mount -o device dir), the
-	// string provided in nvme_mount_path will replace device in that command.
-	// When this option is not set, device in that command will be something
-	// like /dev/sdf1, mirroring the attached device name. This assumption
-	// works for most instances but will fail with c5 and m5 instances. In
-	// order to use the chroot builder with c5 and m5 instances, you must
-	// manually set nvme_device_path and device_path.
-	NVMEDevicePath string `mapstructure:"nvme_device_path" required:"false"`
-	// Build a new volume instead of starting from an existing AMI root volume
-	// snapshot. Default false. If true, source_ami is no longer used and the
-	// following options become required: ami_virtualization_type,
-	// pre_mount_commands and root_volume_size. The below options are also
-	// required in this mode only:
-	FromScratch bool `mapstructure:"from_scratch" required:"false"`
-	// Options to supply the mount command when mounting devices. Each option
-	// will be prefixed with -o and supplied to the mount command ran by
-	// Packer. Because this command is ran in a shell, user discretion is
-	// advised. See this manual page for the mount command for valid file
-	// system specific options.
-	MountOptions []string `mapstructure:"mount_options" required:"false"`
-	// The partition number containing the / partition. By default this is the
-	// first partition of the volume, (for example, xvda1) but you can
-	// designate the entire block device by setting "mount_partition": "0" in
-	// your config, which will mount xvda instead.
-	MountPartition string `mapstructure:"mount_partition" required:"false"`
-	// The path where the volume will be mounted. This is where the chroot
-	// environment will be. This defaults to
-	// /mnt/packer-amazon-chroot-volumes/{{.Device}}. This is a configuration
-	// template where the .Device variable is replaced with the name of the
-	// device where the volume is attached.
-	MountPath string `mapstructure:"mount_path" required:"false"`
-	// As pre_mount_commands, but the commands are executed after mounting the
-	// root device and before the extra mount and copy steps. The device and
-	// mount path are provided by {{.Device}} and {{.MountPath}}.
-	PostMountCommands []string `mapstructure:"post_mount_commands" required:"false"`
-	// A series of commands to execute after attaching the root volume and
-	// before mounting the chroot. This is not required unless using
-	// from_scratch. If so, this should include any partitioning and filesystem
-	// creation commands. The path to the device is provided by {{.Device}}.
-	PreMountCommands []string `mapstructure:"pre_mount_commands" required:"false"`
-	// The root device name. For example, xvda.
-	RootDeviceName string `mapstructure:"root_device_name" required:"false"`
-	// The size of the root volume in GB for the chroot environment and the
-	// resulting AMI. Default size is the snapshot size of the source_ami
-	// unless from_scratch is true, in which case this field must be defined.
-	RootVolumeSize int64 `mapstructure:"root_volume_size" required:"false"`
-	// The type of EBS volume for the chroot environment and resulting AMI. The
-	// default value is the type of the source_ami, unless from_scratch is
-	// true, in which case the default value is gp2. You can only specify io1
-	// if building based on top of a source_ami which is also io1.
-	RootVolumeType string `mapstructure:"root_volume_type" required:"false"`
-	// The source AMI whose root volume will be copied and provisioned on the
-	// currently running instance. This must be an EBS-backed AMI with a root
-	// volume snapshot that you have access to. Note: this is not used when
-	// from_scratch is set to true.
-	SourceAmi string `mapstructure:"source_ami" required:"true"`
-	// Filters used to populate the source_ami field. Example:
-	//
-	//
-	//     ``` json
-	//     {
-	//       "source_ami_filter": {
-	//       "filters": {
-	//        "virtualization-type": "hvm",
-	//        "name": "ubuntu/images/*ubuntu-xenial-16.04-amd64-server-*",
-	//        "root-device-type": "ebs"
-	//      },
-	//      "owners": ["099720109477"],
-	//      "most_recent": true
-	//       }
-	//     }
-	//     ```
-	//
-	//     This selects the most recent Ubuntu 16.04 HVM EBS AMI from Canonical. NOTE:
-	//     This will fail unless *exactly* one AMI is returned. In the above example,
-	//     `most_recent` will cause this to succeed by selecting the newest image.
-	//
-	//     -   `filters` (map of strings) - filters used to select a `source_ami`.
-	//         NOTE: This will fail unless *exactly* one AMI is returned. Any filter
-	//         described in the docs for
-	//         [DescribeImages](http://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html)
-	//         is valid.
-	//
-	//     -   `owners` (array of strings) - Filters the images by their owner. You
-	//         may specify one or more AWS account IDs, "self" (which will use the
-	//         account whose credentials you are using to run Packer), or an AWS owner
-	//         alias: for example, "amazon", "aws-marketplace", or "microsoft". This
-	//         option is required for security reasons.
-	//
-	//     -   `most_recent` (boolean) - Selects the newest created image when true.
-	//         This is most useful for selecting a daily distro build.
-	//
-	//     You may set this in place of `source_ami` or in conjunction with it. If you
-	//     set this in conjunction with `source_ami`, the `source_ami` will be added
-	//     to the filter. The provided `source_ami` must meet all of the filtering
-	//     criteria provided in `source_ami_filter`; this pins the AMI returned by the
-	//     filter, but will cause Packer to fail if the `source_ami` does not exist.
-	SourceAmiFilter awscommon.AmiFilterOptions `mapstructure:"source_ami_filter" required:"false"`
-	// Tags to apply to the volumes that are *launched*. This is a [template
-	// engine](/docs/templates/engine.html), see [Build template
-	// data](#build-template-data) for more information.
-	RootVolumeTags awscommon.TagMap `mapstructure:"root_volume_tags" required:"false"`
-	// what architecture to use when registering the final AMI; valid options
-	// are "x86_64" or "arm64". Defaults to "x86_64".
-	Architecture string `mapstructure:"ami_architecture" required:"false"`
+	common.PackerConfig       `mapstructure:",squash"`
+	awscommon.AMIBlockDevices `mapstructure:",squash"`
+	awscommon.AMIConfig       `mapstructure:",squash"`
+	awscommon.AccessConfig    `mapstructure:",squash"`
+
+	ChrootMounts      [][]string                 `mapstructure:"chroot_mounts"`
+	CommandWrapper    string                     `mapstructure:"command_wrapper"`
+	CopyFiles         []string                   `mapstructure:"copy_files"`
+	DevicePath        string                     `mapstructure:"device_path"`
+	NVMEDevicePath    string                     `mapstructure:"nvme_device_path"`
+	FromScratch       bool                       `mapstructure:"from_scratch"`
+	MountOptions      []string                   `mapstructure:"mount_options"`
+	MountPartition    string                     `mapstructure:"mount_partition"`
+	MountPath         string                     `mapstructure:"mount_path"`
+	PostMountCommands []string                   `mapstructure:"post_mount_commands"`
+	PreMountCommands  []string                   `mapstructure:"pre_mount_commands"`
+	RootDeviceName    string                     `mapstructure:"root_device_name"`
+	RootVolumeSize    int64                      `mapstructure:"root_volume_size"`
+	SourceAmi         string                     `mapstructure:"source_ami"`
+	SourceAmiFilter   awscommon.AmiFilterOptions `mapstructure:"source_ami_filter"`
+	RootVolumeTags    awscommon.TagMap           `mapstructure:"root_volume_tags"`
 
 	ctx interpolate.Context
 }
@@ -199,10 +80,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		return nil, err
 	}
 
-	if b.config.Architecture == "" {
-		b.config.Architecture = "x86_64"
-	}
-
 	if b.config.PackerConfig.PackerForce {
 		b.config.AMIForceDeregister = true
 	}
@@ -224,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"}
 		}
@@ -286,42 +164,24 @@ 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")
 		}
-	}
-	valid := false
-	for _, validArch := range []string{"x86_64", "arm64"} {
-		if validArch == b.config.Architecture {
-			valid = true
-			break
+		if b.config.RootDeviceName != "" {
+			warns = append(warns, "root_device_name is unused when from_scratch is false")
 		}
 	}
-	if !valid {
-		errs = packer.MultiErrorAppend(errs, errors.New(`The only valid ami_architecture values are "x86_64" and "arm64"`))
-	}
 
 	if errs != nil && len(errs.Errors) > 0 {
 		return warns, errs
 	}
 
 	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.")
 	}
@@ -333,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)
@@ -365,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{},
 		)
@@ -375,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,
@@ -409,14 +265,18 @@ 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,
-			AMIKmsKeyId:       b.config.AMIKmsKeyId,
 			RegionKeyIds:      b.config.AMIRegionKMSKeyIDs,
 			EncryptBootVolume: b.config.AMIEncryptBootVolume,
 			Name:              b.config.AMIName,
-			OriginalRegion:    *ec2conn.Config.Region,
 		},
 		&awscommon.StepModifyAMIAttributes{
 			Description:    b.config.AMIDescription,
@@ -436,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 {
@@ -457,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

@@ -7,7 +7,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	confighelper "github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -15,26 +14,68 @@ import (
 // StepRegisterAMI creates the AMI.
 type StepRegisterAMI struct {
 	RootVolumeSize           int64
-	EnableAMIENASupport      confighelper.Trilean
+	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 {
@@ -42,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.True() {
+	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)
@@ -74,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.AMIMappings.BuildEC2BlockDeviceMappings()
-		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(config.Architecture),
-			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,138 +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{},
-		AMIMappings: []BlockDevice{
-			{BlockDevice: 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{},
-		AMIMappings: []BlockDevice{
-			{BlockDevice: 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,129 +1,32 @@
-//go:generate struct-markdown
-
 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"`
-	// Specifies the TTL for the use of the STS token. This
-	// is specified as a string with a duration suffix. Valid only when
-	// credential_type is assumed_role or federation_token. When not
-	// specified, the default_sts_ttl set for the role will be used. If that
-	// is also not set, then the default value of 3600s will be used. AWS
-	// places limits on the maximum TTL allowed. See the AWS documentation on
-	// the DurationSeconds parameter for AssumeRole (for assumed_role
-	// credential types) and GetFederationToken (for federation_token
-	// credential types) for more details.
-	TTL        string `mapstructure:"ttl" required:"false"`
-	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 {
-	// The access key used to communicate with AWS. [Learn how  to set this]
-	// (/docs/builders/amazon.html#specifying-amazon-credentials). On EBS, this
-	// is not required if you are using `use_vault_aws_engine` for
-	// authentication instead.
-	AccessKey string `mapstructure:"access_key" required:"true"`
-	// This option is useful if you use a cloud
-	// provider whose API is compatible with aws EC2. Specify another endpoint
-	// like this https://ec2.custom.endpoint.com.
-	CustomEndpointEc2 string `mapstructure:"custom_endpoint_ec2" required:"false"`
-	// Enable automatic decoding of any encoded authorization (error) messages
-	// using the `sts:DecodeAuthorizationMessage` API. Note: requires that the
-	// effective user/role have permissions to `sts:DecodeAuthorizationMessage`
-	// on resource `*`. Default `false`.
-	DecodeAuthZMessages bool `mapstructure:"decode_authorization_messages" required:"false"`
-	// This allows skipping TLS
-	// verification of the AWS EC2 endpoint. The default is false.
-	InsecureSkipTLSVerify bool `mapstructure:"insecure_skip_tls_verify" required:"false"`
-	// The MFA
-	// [TOTP](https://en.wikipedia.org/wiki/Time-based_One-time_Password_Algorithm)
-	// code. This should probably be a user variable since it changes all the
-	// time.
-	MFACode string `mapstructure:"mfa_code" required:"false"`
-	// The profile to use in the shared credentials file for
-	// AWS. See Amazon's documentation on [specifying
-	// profiles](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-profiles)
-	// for more details.
-	ProfileName string `mapstructure:"profile" required:"false"`
-	// The name of the region, such as `us-east-1`, in which
-	// to launch the EC2 instance to create the AMI.
-	// When chroot building, this value is guessed from environment.
-	RawRegion string `mapstructure:"region" required:"true"`
-	// The secret key used to communicate with AWS. [Learn how to set
-	// this](amazon.html#specifying-amazon-credentials). This is not required
-	// if you are using `use_vault_aws_engine` for authentication instead.
-	SecretKey string `mapstructure:"secret_key" required:"true"`
-	// Set to true if you want to skip
-	// validation of the ami_regions configuration option. Default false.
-	SkipValidation       bool `mapstructure:"skip_region_validation" required:"false"`
-	SkipMetadataApiCheck bool `mapstructure:"skip_metadata_api_check"`
-	// The access token to use. This is different from the
-	// access key and secret key. If you're not sure what this is, then you
-	// probably don't need it. This will also be read from the AWS_SESSION_TOKEN
-	// environmental variable.
-	Token   string `mapstructure:"token" required:"false"`
-	session *session.Session
-	// Get credentials from Hashicorp Vault's aws secrets engine. You must
-	// already have created a role to use. For more information about
-	// generating credentials via the Vault engine, see the [Vault
-	// docs.](https://www.vaultproject.io/api/secret/aws/index.html#generate-credentials)
-	// If you set this flag, you must also set the below options:
-	// -   `name` (string) - Required. Specifies the name of the role to generate
-	//     credentials against. This is part of the request URL.
-	// -   `engine_name` (string) - The name of the aws secrets engine. In the
-	//     Vault docs, this is normally referred to as "aws", and Packer will
-	//     default to "aws" if `engine_name` is not set.
-	// -   `role_arn` (string)- The ARN of the role to assume if credential\_type
-	//     on the Vault role is assumed\_role. Must match one of the allowed role
-	//     ARNs in the Vault role. Optional if the Vault role only allows a single
-	//     AWS role ARN; required otherwise.
-	// -   `ttl` (string) - Specifies the TTL for the use of the STS token. This
-	//     is specified as a string with a duration suffix. Valid only when
-	//     credential\_type is assumed\_role or federation\_token. When not
-	//     specified, the default\_sts\_ttl set for the role will be used. If that
-	//     is also not set, then the default value of 3600s will be used. AWS
-	//     places limits on the maximum TTL allowed. See the AWS documentation on
-	//     the DurationSeconds parameter for AssumeRole (for assumed\_role
-	//     credential types) and GetFederationToken (for federation\_token
-	//     credential types) for more details.
-	//
-	// ``` json
-	// {
-	//     "vault_aws_engine": {
-	//         "name": "myrole",
-	//         "role_arn": "myarn",
-	//         "ttl": "3600s"
-	//     }
-	// }
-	// ```
-	VaultAWSEngine VaultAWSEngineOptions `mapstructure:"vault_aws_engine" required:"false"`
-
-	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
@@ -142,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,
@@ -172,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
 }
 
@@ -214,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 {
@@ -253,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 environment.
-	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

@@ -1,132 +1,33 @@
-//go:generate struct-markdown
-
 package common
 
 import (
 	"fmt"
 	"log"
-	"regexp"
 
-	"github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/template/interpolate"
 )
 
 // AMIConfig is for common configuration related to creating AMIs.
 type AMIConfig struct {
-	// The name of the resulting AMI that will appear when managing AMIs in the
-	// AWS console or via APIs. This must be unique. To help make this unique,
-	// use a function like timestamp (see [template
-	// engine](../templates/engine.html) for more info).
-	AMIName string `mapstructure:"ami_name" required:"true"`
-	// The description to set for the resulting
-	// AMI(s). By default this description is empty. This is a template
-	// engine, see Build template
-	// data for more information.
-	AMIDescription string `mapstructure:"ami_description" required:"false"`
-	// The description to set for the resulting AMI(s). By default this
-	// description is empty. This is a [template
-	// engine](../templates/engine.html), see [Build template
-	// data](#build-template-data) for more information.
-	AMIVirtType string `mapstructure:"ami_virtualization_type" required:"false"`
-	// A list of account IDs that have access to
-	// launch the resulting AMI(s). By default no additional users other than the
-	// user creating the AMI has permissions to launch it.
-	AMIUsers []string `mapstructure:"ami_users" required:"false"`
-	// A list of groups that have access to
-	// launch the resulting AMI(s). By default no groups have permission to launch
-	// the AMI. all will make the AMI publicly accessible.
-	AMIGroups []string `mapstructure:"ami_groups" required:"false"`
-	// A list of product codes to
-	// associate with the AMI. By default no product codes are associated with the
-	// AMI.
-	AMIProductCodes []string `mapstructure:"ami_product_codes" required:"false"`
-	// A list of regions to copy the AMI to.
-	// Tags and attributes are copied along with the AMI. AMI copying takes time
-	// depending on the size of the AMI, but will generally take many minutes.
-	AMIRegions []string `mapstructure:"ami_regions" required:"false"`
-	// Set to true if you want to skip
-	// validation of the ami_regions configuration option. Default false.
-	AMISkipRegionValidation bool `mapstructure:"skip_region_validation" required:"false"`
-	// Tags applied to the AMI. This is a
-	// [template engine](/docs/templates/engine.html), see [Build template
-	// data](#build-template-data) for more information.
-	AMITags TagMap `mapstructure:"tags" required:"false"`
-	// Enable enhanced networking (ENA but not SriovNetSupport) on
-	// HVM-compatible AMIs. If set, add `ec2:ModifyInstanceAttribute` to your
-	// AWS IAM policy.
-	//
-	// Note: you must make sure enhanced networking is enabled on your
-	// instance. See [Amazon's documentation on enabling enhanced
-	// networking](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enhanced-networking.html#enabling_enhanced_networking).
-	AMIENASupport config.Trilean `mapstructure:"ena_support" required:"false"`
-	// Enable enhanced networking (SriovNetSupport but not ENA) on
-	// HVM-compatible AMIs. If true, add `ec2:ModifyInstanceAttribute` to your
-	// AWS IAM policy. Note: you must make sure enhanced networking is enabled
-	// on your instance. See [Amazon's documentation on enabling enhanced
-	// networking](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enhanced-networking.html#enabling_enhanced_networking).
-	// Default `false`.
-	AMISriovNetSupport bool `mapstructure:"sriov_support" required:"false"`
-	// Force Packer to first deregister an existing
-	// AMI if one with the same name already exists. Default false.
-	AMIForceDeregister bool `mapstructure:"force_deregister" required:"false"`
-	// Force Packer to delete snapshots
-	// associated with AMIs, which have been deregistered by force_deregister.
-	// Default false.
-	AMIForceDeleteSnapshot bool `mapstructure:"force_delete_snapshot" required:"false"`
-	// Whether or not to encrypt the resulting AMI when
-	// copying a provisioned instance to an AMI. By default, Packer will keep the
-	// encryption setting to what it was in the source image. Setting false will
-	// result in an unencrypted image, and true will result in an encrypted one.
-	// If you have used the `launch_block_device_mappings` to set an encryption
-	// key and that key is the same as the one you want the image encrypted with
-	// at the end, then you don't need to set this field; leaving it empty will
-	// prevent an unnecessary extra copy step and save you some time.
-	AMIEncryptBootVolume config.Trilean `mapstructure:"encrypt_boot" required:"false"`
-	// ID, alias or ARN of the KMS key to use for boot volume encryption. This
-	// only applies to the main `region`, other regions where the AMI will be
-	// copied will be encrypted by the default EBS KMS key. For valid formats
-	// see *KmsKeyId* in the [AWS API docs -
-	// CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopyImage.html).
-	// This field is validated by Packer, when using an alias, you will have to
-	// prefix `kms_key_id` with `alias/`.
-	AMIKmsKeyId string `mapstructure:"kms_key_id" required:"false"`
-	// regions to copy the ami to, along with the custom kms key id (alias or
-	// arn) to use for encryption for that region. Keys must match the regions
-	// provided in `ami_regions`. If you just want to encrypt using a default
-	// ID, you can stick with `kms_key_id` and `ami_regions`. If you want a
-	// region to be encrypted with that region's default key ID, you can use an
-	// empty string `""` instead of a key id in this map. (e.g. `"us-east-1":
-	// ""`) However, you cannot use default key IDs if you are using this in
-	// conjunction with `snapshot_users` -- in that situation you must use
-	// custom keys. For valid formats see *KmsKeyId* in the [AWS API docs -
-	// CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopyImage.html).
-	//
-	// This option supercedes the `kms_key_id` option -- if you set both, and
-	// they are different, Packer will respect the value in
-	// `region_kms_key_ids` for your build region and silently disregard the
-	// value provided in `kms_key_id`.
-	AMIRegionKMSKeyIDs map[string]string `mapstructure:"region_kms_key_ids" required:"false"`
-	// If true, Packer will not check whether an AMI with the `ami_name` exists
-	// in the region it is building in. It will use an intermediary AMI name,
-	// which it will not convert to an AMI in the build region. It will copy
-	// the intermediary AMI into any regions provided in `ami_regions`, then
-	// delete the intermediary AMI. Default `false`.
-	AMISkipBuildRegion bool `mapstructure:"skip_save_build_region"`
-	// Tags to apply to snapshot.
-	// They will override AMI tags if already applied to snapshot. This is a
-	// [template engine](../templates/engine.html), see [Build template
-	// data](#build-template-data) for more information.
-	SnapshotTags TagMap `mapstructure:"snapshot_tags" required:"false"`
-	// A list of account IDs that have
-	// access to create volumes from the snapshot(s). By default no additional
-	// users other than the user creating the AMI has permissions to create
-	// volumes from the backing snapshot(s).
-	SnapshotUsers []string `mapstructure:"snapshot_users" required:"false"`
-	// A list of groups that have access to
-	// create volumes from the snapshot(s). By default no groups have permission
-	// to create volumes from the snapshot(s). all will make the snapshot
-	// publicly accessible.
-	SnapshotGroups []string `mapstructure:"snapshot_groups" required:"false"`
+	AMIName                 string            `mapstructure:"ami_name"`
+	AMIDescription          string            `mapstructure:"ami_description"`
+	AMIVirtType             string            `mapstructure:"ami_virtualization_type"`
+	AMIUsers                []string          `mapstructure:"ami_users"`
+	AMIGroups               []string          `mapstructure:"ami_groups"`
+	AMIProductCodes         []string          `mapstructure:"ami_product_codes"`
+	AMIRegions              []string          `mapstructure:"ami_regions"`
+	AMISkipRegionValidation bool              `mapstructure:"skip_region_validation"`
+	AMITags                 TagMap            `mapstructure:"tags"`
+	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"`
+	AMIKmsKeyId             string            `mapstructure:"kms_key_id"`
+	AMIRegionKMSKeyIDs      map[string]string `mapstructure:"region_kms_key_ids"`
+	SnapshotTags            TagMap            `mapstructure:"snapshot_tags"`
+	SnapshotUsers           []string          `mapstructure:"snapshot_users"`
+	SnapshotGroups          []string          `mapstructure:"snapshot_groups"`
 }
 
 func stringInSlice(s []string, searchstr string) bool {
@@ -155,72 +56,6 @@ func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context
 		}
 	}
 
-	errs = append(errs, c.prepareRegions(accessConfig)...)
-
-	// Prevent sharing of default KMS key encrypted volumes with other aws users
-	if len(c.AMIUsers) > 0 {
-		if len(c.AMIKmsKeyId) == 0 && c.AMIEncryptBootVolume.True() {
-			errs = append(errs, fmt.Errorf("Cannot share AMI 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 AMI encrypted with default KMS key for other regions"))
-				}
-			}
-		}
-	}
-
-	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.True() {
-			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))
@@ -234,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 {
@@ -252,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,14 +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"
-	"github.com/hashicorp/packer/helper/config"
 )
 
 func testAMIConfig() *AMIConfig {
@@ -18,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"}
@@ -82,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{
@@ -92,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"}
@@ -102,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")
 	}
 
@@ -113,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")
 	}
 
@@ -123,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")
 	}
 
@@ -132,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 = config.TriTrue
+	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")
 	}
 
@@ -162,64 +138,24 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 func TestAMIConfigPrepare_Share_EncryptedBoot(t *testing.T) {
 	c := testAMIConfig()
 	c.AMIUsers = []string{"testAccountID"}
-	c.AMIEncryptBootVolume = config.TriTrue
-
-	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 {
-		t.Fatal("should be able to share ami with encrypted boot volume")
+	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 = config.TriTrue
-
-	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

@@ -1,5 +1,3 @@
-//go:generate struct-markdown
-
 package common
 
 import (
@@ -8,156 +6,114 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/template/interpolate"
 )
 
-// These will be attached when booting a new instance from your AMI. Your
-// options here may vary depending on the type of VM you use.
-//
-// Example use case:
-//
-// The following mapping will tell Packer to encrypt the root volume of the
-// build instance at launch using a specific non-default kms key:
-//
-// ``` json
-// "launch_block_device_mappings": [{
-//		"device_name": "/dev/sda1",
-//		"encrypted": true,
-//		"kms_key_id": "1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
-// }]
-// ```
-//
-// Documentation for Block Devices Mappings can be found here:
-// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html
-//
-// These mappings give you control over either the volumes generated for the
-// Packer build via `launch_block_device_mappings`, or the volumes that Packer will
-// save with the artifact AMI via `ami_block_device_mappings`.
+// BlockDevice
 type BlockDevice struct {
-	// Indicates whether the EBS volume is deleted on instance termination.
-	// Default false. NOTE: If this value is not explicitly set to true and
-	// volumes are not cleaned up by an alternative method, additional volumes
-	// will accumulate after every build.
-	DeleteOnTermination bool `mapstructure:"delete_on_termination" required:"false"`
-	// The device name exposed to the instance (for example, /dev/sdh or xvdh).
-	// Required for every device in the block device mapping.
-	DeviceName string `mapstructure:"device_name" required:"false"`
-	// Indicates whether or not to encrypt the volume. By default, Packer will
-	// keep the encryption setting to what it was in the source image. Setting
-	// false will result in an unencrypted device, and true will result in an
-	// encrypted one.
-	Encrypted config.Trilean `mapstructure:"encrypted" required:"false"`
-	// The number of I/O operations per second (IOPS) that the volume supports.
-	// See the documentation on
-	// [IOPs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EbsBlockDevice.html)
-	// for more information
-	IOPS int64 `mapstructure:"iops" required:"false"`
-	// Suppresses the specified device included in the block device mapping of
-	// the AMI.
-	NoDevice bool `mapstructure:"no_device" required:"false"`
-	// The ID of the snapshot.
-	SnapshotId string `mapstructure:"snapshot_id" required:"false"`
-	// The virtual device name. See the documentation on Block Device Mapping
-	// for more information.
-	VirtualName string `mapstructure:"virtual_name" required:"false"`
-	// The volume type. gp2 for General Purpose (SSD) volumes, io1 for
-	// Provisioned IOPS (SSD) volumes, st1 for Throughput Optimized HDD, sc1
-	// for Cold HDD, and standard for Magnetic volumes.
-	VolumeType string `mapstructure:"volume_type" required:"false"`
-	// The size of the volume, in GiB. Required if not specifying a
-	// snapshot_id.
-	VolumeSize int64 `mapstructure:"volume_size" required:"false"`
-	// ID, alias or ARN of the KMS key to use for boot volume encryption. This
-	// only applies to the main region, other regions where the AMI will be
-	// copied will be encrypted by the default EBS KMS key. For valid formats
-	// see KmsKeyId in the [AWS API docs -
-	// CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopyImage.html)
-	// This field is validated by Packer, when using an alias, you will have to
-	// prefix kms_key_id with alias/.
-	KmsKeyId string `mapstructure:"kms_key_id" required:"false"`
+	DeleteOnTermination bool   `mapstructure:"delete_on_termination"`
+	DeviceName          string `mapstructure:"device_name"`
+	Encrypted           bool   `mapstructure:"encrypted"`
+	IOPS                int64  `mapstructure:"iops"`
+	NoDevice            bool   `mapstructure:"no_device"`
+	SnapshotId          string `mapstructure:"snapshot_id"`
+	VirtualName         string `mapstructure:"virtual_name"`
+	VolumeType          string `mapstructure:"volume_type"`
+	VolumeSize          int64  `mapstructure:"volume_size"`
+	KmsKeyId            string `mapstructure:"kms_key_id"`
 }
 
-type BlockDevices []BlockDevice
+type BlockDevices struct {
+	AMIBlockDevices    `mapstructure:",squash"`
+	LaunchBlockDevices `mapstructure:",squash"`
+}
 
-func (bds BlockDevices) BuildEC2BlockDeviceMappings() []*ec2.BlockDeviceMapping {
+type AMIBlockDevices struct {
+	AMIMappings []BlockDevice `mapstructure:"ami_block_device_mappings"`
+}
+
+type LaunchBlockDevices struct {
+	LaunchMappings []BlockDevice `mapstructure:"launch_block_device_mappings"`
+}
+
+func buildBlockDevices(b []BlockDevice) []*ec2.BlockDeviceMapping {
 	var blockDevices []*ec2.BlockDeviceMapping
 
-	for _, blockDevice := range bds {
-		blockDevices = append(blockDevices, blockDevice.BuildEC2BlockDeviceMapping())
+	for _, blockDevice := range b {
+		mapping := &ec2.BlockDeviceMapping{
+			DeviceName: aws.String(blockDevice.DeviceName),
+		}
+
+		if blockDevice.NoDevice {
+			mapping.NoDevice = aws.String("")
+		} else if blockDevice.VirtualName != "" {
+			if strings.HasPrefix(blockDevice.VirtualName, "ephemeral") {
+				mapping.VirtualName = aws.String(blockDevice.VirtualName)
+			}
+		} else {
+			ebsBlockDevice := &ec2.EbsBlockDevice{
+				DeleteOnTermination: aws.Bool(blockDevice.DeleteOnTermination),
+			}
+
+			if blockDevice.VolumeType != "" {
+				ebsBlockDevice.VolumeType = aws.String(blockDevice.VolumeType)
+			}
+
+			if blockDevice.VolumeSize > 0 {
+				ebsBlockDevice.VolumeSize = aws.Int64(blockDevice.VolumeSize)
+			}
+
+			// IOPS is only valid for io1 type
+			if blockDevice.VolumeType == "io1" {
+				ebsBlockDevice.Iops = aws.Int64(blockDevice.IOPS)
+			}
+
+			// 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)
+			}
+
+			if blockDevice.KmsKeyId != "" {
+				ebsBlockDevice.KmsKeyId = aws.String(blockDevice.KmsKeyId)
+			}
+
+			mapping.Ebs = ebsBlockDevice
+		}
+
+		blockDevices = append(blockDevices, mapping)
 	}
 	return blockDevices
 }
 
-func (blockDevice BlockDevice) BuildEC2BlockDeviceMapping() *ec2.BlockDeviceMapping {
-
-	mapping := &ec2.BlockDeviceMapping{
-		DeviceName: aws.String(blockDevice.DeviceName),
-	}
-
-	if blockDevice.NoDevice {
-		mapping.NoDevice = aws.String("")
-		return mapping
-	} else if blockDevice.VirtualName != "" {
-		if strings.HasPrefix(blockDevice.VirtualName, "ephemeral") {
-			mapping.VirtualName = aws.String(blockDevice.VirtualName)
-		}
-		return mapping
-	}
-
-	ebsBlockDevice := &ec2.EbsBlockDevice{
-		DeleteOnTermination: aws.Bool(blockDevice.DeleteOnTermination),
-	}
-
-	if blockDevice.VolumeType != "" {
-		ebsBlockDevice.VolumeType = aws.String(blockDevice.VolumeType)
-	}
-
-	if blockDevice.VolumeSize > 0 {
-		ebsBlockDevice.VolumeSize = aws.Int64(blockDevice.VolumeSize)
-	}
-
-	// IOPS is only valid for io1 type
-	if blockDevice.VolumeType == "io1" {
-		ebsBlockDevice.Iops = aws.Int64(blockDevice.IOPS)
-	}
-
-	// You cannot specify Encrypted if you specify a Snapshot ID
-	if blockDevice.SnapshotId != "" {
-		ebsBlockDevice.SnapshotId = aws.String(blockDevice.SnapshotId)
-	}
-	ebsBlockDevice.Encrypted = blockDevice.Encrypted.ToBoolPointer()
-
-	if blockDevice.KmsKeyId != "" {
-		ebsBlockDevice.KmsKeyId = aws.String(blockDevice.KmsKeyId)
-	}
-
-	mapping.Ebs = ebsBlockDevice
-
-	return mapping
-}
-
 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 or nil when setting kms_key_id
-	if b.KmsKeyId != "" && b.Encrypted.False() {
+	// Warn that encrypted must be true when setting kms_key_id
+	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)
 	}
-
-	_, err := interpolate.RenderInterface(&b, ctx)
-	return err
+	return nil
 }
 
-func (bds BlockDevices) Prepare(ctx *interpolate.Context) (errs []error) {
-	for _, block := range bds {
-		if err := block.Prepare(ctx); err != nil {
-			errs = append(errs, err)
+func (b *BlockDevices) Prepare(ctx *interpolate.Context) (errs []error) {
+	for _, d := range b.AMIMappings {
+		if err := d.Prepare(ctx); err != nil {
+			errs = append(errs, fmt.Errorf("AMIMapping: %s", err.Error()))
+		}
+	}
+	for _, d := range b.LaunchMappings {
+		if err := d.Prepare(ctx); err != nil {
+			errs = append(errs, fmt.Errorf("LaunchMapping: %s", err.Error()))
 		}
 	}
 	return errs
 }
+
+func (b *AMIBlockDevices) BuildAMIDevices() []*ec2.BlockDeviceMapping {
+	return buildBlockDevices(b.AMIMappings)
+}
+
+func (b *LaunchBlockDevices) BuildLaunchDevices() []*ec2.BlockDeviceMapping {
+	return buildBlockDevices(b.LaunchMappings)
+}

builder/amazon/common/block_device_test.go

@@ -1,12 +1,11 @@
 package common
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/google/go-cmp/cmp"
-	"github.com/hashicorp/packer/helper/config"
 )
 
 func TestBlockDevice(t *testing.T) {
@@ -72,7 +71,7 @@ func TestBlockDevice(t *testing.T) {
 				VolumeType:          "gp2",
 				VolumeSize:          8,
 				DeleteOnTermination: true,
-				Encrypted:           config.TriTrue,
+				Encrypted:           true,
 			},
 
 			Result: &ec2.BlockDeviceMapping{
@@ -91,7 +90,7 @@ func TestBlockDevice(t *testing.T) {
 				VolumeType:          "gp2",
 				VolumeSize:          8,
 				DeleteOnTermination: true,
-				Encrypted:           config.TriTrue,
+				Encrypted:           true,
 				KmsKeyId:            "2Fa48a521f-3aff-4b34-a159-376ac5d37812",
 			},
 
@@ -146,20 +145,26 @@ func TestBlockDevice(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-		var amiBlockDevices BlockDevices = []BlockDevice{*tc.Config}
+		amiBlockDevices := AMIBlockDevices{
+			AMIMappings: []BlockDevice{*tc.Config},
+		}
 
-		var launchBlockDevices BlockDevices = []BlockDevice{*tc.Config}
+		launchBlockDevices := LaunchBlockDevices{
+			LaunchMappings: []BlockDevice{*tc.Config},
+		}
 
 		expected := []*ec2.BlockDeviceMapping{tc.Result}
 
-		amiResults := amiBlockDevices.BuildEC2BlockDeviceMappings()
-		if diff := cmp.Diff(expected, amiResults); diff != "" {
-			t.Fatalf("Bad block device: %s", diff)
+		amiResults := amiBlockDevices.BuildAMIDevices()
+		if !reflect.DeepEqual(expected, amiResults) {
+			t.Fatalf("Bad block device, \nexpected: %#v\n\ngot: %#v",
+				expected, amiResults)
 		}
 
-		launchResults := launchBlockDevices.BuildEC2BlockDeviceMappings()
-		if diff := cmp.Diff(expected, launchResults); diff != "" {
-			t.Fatalf("Bad block device: %s", diff)
+		launchResults := launchBlockDevices.BuildLaunchDevices()
+		if !reflect.DeepEqual(expected, launchResults) {
+			t.Fatalf("Bad block device, \nexpected: %#v\n\ngot: %#v",
+				expected, launchResults)
 		}
 	}
 }

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

@@ -1,5 +1,3 @@
-//go:generate struct-markdown
-
 package common
 
 import (
@@ -31,312 +29,35 @@ 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 {
-	// If using a non-default VPC,
-	// public IP addresses are not provided by default. If this is true, your
-	// new instance will get a Public IP. default: false
-	AssociatePublicIpAddress bool `mapstructure:"associate_public_ip_address" required:"false"`
-	// Destination availability zone to launch
-	// instance in. Leave this empty to allow Amazon to auto-assign.
-	AvailabilityZone string `mapstructure:"availability_zone" required:"false"`
-	// Requires spot_price to be set. The
-	// required duration for the Spot Instances (also known as Spot blocks). This
-	// value must be a multiple of 60 (60, 120, 180, 240, 300, or 360). You can't
-	// specify an Availability Zone group or a launch group if you specify a
-	// duration.
-	BlockDurationMinutes int64 `mapstructure:"block_duration_minutes" required:"false"`
-	// Packer normally stops the build instance after all provisioners have
-	// run. For Windows instances, it is sometimes desirable to [run
-	// Sysprep](http://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ami-create-standard.html)
-	// which will stop the instance for you. If this is set to `true`, Packer
-	// *will not* stop the instance but will assume that you will send the stop
-	// signal yourself through your final provisioner. You can do this with a
-	// [windows-shell
-	// provisioner](https://www.packer.io/docs/provisioners/windows-shell.html).
-	// Note that Packer will still wait for the instance to be stopped, and
-	// failing to send the stop signal yourself, when you have set this flag to
-	// `true`, will cause a timeout.
-	// Example of a valid shutdown command:
-	//
-	// ``` json
-	// {
-	//   "type": "windows-shell",
-	//   "inline": ["\"c:\\Program Files\\Amazon\\Ec2ConfigService\\ec2config.exe\" -sysprep"]
-	// }
-	// ```
-	DisableStopInstance bool `mapstructure:"disable_stop_instance" required:"false"`
-	// Mark instance as [EBS
-	// Optimized](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSOptimized.html).
-	// Default `false`.
-	EbsOptimized bool `mapstructure:"ebs_optimized" required:"false"`
-	// Enabling T2 Unlimited allows the source instance to burst additional CPU
-	// beyond its available [CPU
-	// Credits](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/t2-credits-baseline-concepts.html)
-	// for as long as the demand exists. This is in contrast to the standard
-	// configuration that only allows an instance to consume up to its
-	// available CPU Credits. See the AWS documentation for [T2
-	// Unlimited](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/t2-unlimited.html)
-	// and the **T2 Unlimited Pricing** section of the [Amazon EC2 On-Demand
-	// Pricing](https://aws.amazon.com/ec2/pricing/on-demand/) document for
-	// more information. By default this option is disabled and Packer will set
-	// up a [T2
-	// Standard](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/t2-std.html)
-	// instance instead.
-	//
-	// To use T2 Unlimited you must use a T2 instance type, e.g. `t2.micro`.
-	// Additionally, T2 Unlimited cannot be used in conjunction with Spot
-	// Instances, e.g. when the `spot_price` option has been configured.
-	// Attempting to do so will cause an error.
-	//
-	// !> **Warning!** Additional costs may be incurred by enabling T2
-	// Unlimited - even for instances that would usually qualify for the
-	// [AWS Free Tier](https://aws.amazon.com/free/).
-	EnableT2Unlimited bool `mapstructure:"enable_t2_unlimited" required:"false"`
-	// The name of an [IAM instance
-	// profile](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html)
-	// to launch the EC2 instance with.
-	IamInstanceProfile string `mapstructure:"iam_instance_profile" required:"false"`
-	// Automatically terminate instances on
-	// shutdown in case Packer exits ungracefully. Possible values are stop and
-	// terminate. Defaults to stop.
-	InstanceInitiatedShutdownBehavior string `mapstructure:"shutdown_behavior" required:"false"`
-	// The EC2 instance type to use while building the
-	// AMI, such as t2.small.
-	InstanceType string `mapstructure:"instance_type" required:"true"`
-	// Filters used to populate the `security_group_ids` field. Example:
-	//
-	// ``` json
-	// {
-	//   "security_group_filter": {
-	//     "filters": {
-	//       "tag:Class": "packer"
-	//     }
-	//   }
-	// }
-	// ```
-	//
-	// This selects the SG's with tag `Class` with the value `packer`.
-	//
-	// -   `filters` (map of strings) - filters used to select a
-	//     `security_group_ids`. Any filter described in the docs for
-	//     [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)
-	//     is valid.
-	//
-	// `security_group_ids` take precedence over this.
-	SecurityGroupFilter SecurityGroupFilterOptions `mapstructure:"security_group_filter" required:"false"`
-	// Tags to apply to the instance that is that is *launched* to create the
-	// EBS volumes. This is a [template engine](/docs/templates/engine.html),
-	// see [Build template data](#build-template-data) for more information.
-	RunTags map[string]string `mapstructure:"run_tags" required:"false"`
-	// The ID (not the name) of the security
-	// group to assign to the instance. By default this is not set and Packer will
-	// automatically create a new temporary security group to allow SSH access.
-	// Note that if this is specified, you must be sure the security group allows
-	// access to the ssh_port given below.
-	SecurityGroupId string `mapstructure:"security_group_id" required:"false"`
-	// A list of security groups as
-	// described above. Note that if this is specified, you must omit the
-	// security_group_id.
-	SecurityGroupIds []string `mapstructure:"security_group_ids" required:"false"`
-	// The source AMI whose root volume will be copied and
-	// provisioned on the currently running instance. This must be an EBS-backed
-	// AMI with a root volume snapshot that you have access to. Note: this is not
-	// used when from_scratch is set to true.
-	SourceAmi string `mapstructure:"source_ami" required:"true"`
-	// Filters used to populate the `source_ami`
-	// field. Example:
-	//
-	//   ``` json
-	//   {
-	//     "source_ami_filter": {
-	//       "filters": {
-	//         "virtualization-type": "hvm",
-	//         "name": "ubuntu/images/\*ubuntu-xenial-16.04-amd64-server-\*",
-	//         "root-device-type": "ebs"
-	//       },
-	//       "owners": ["099720109477"],
-	//       "most_recent": true
-	//     }
-	//   }
-	//   ```
-	//
-	//   This selects the most recent Ubuntu 16.04 HVM EBS AMI from Canonical. NOTE:
-	//   This will fail unless *exactly* one AMI is returned. In the above example,
-	//   `most_recent` will cause this to succeed by selecting the newest image.
-	//
-	//   -   `filters` (map of strings) - filters used to select a `source_ami`.
-	//       NOTE: This will fail unless *exactly* one AMI is returned. Any filter
-	//       described in the docs for
-	//       [DescribeImages](http://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html)
-	//       is valid.
-	//
-	//   -   `owners` (array of strings) - Filters the images by their owner. You
-	//       may specify one or more AWS account IDs, "self" (which will use the
-	//       account whose credentials you are using to run Packer), or an AWS owner
-	//       alias: for example, `amazon`, `aws-marketplace`, or `microsoft`. This
-	//       option is required for security reasons.
-	//
-	//   -   `most_recent` (boolean) - Selects the newest created image when true.
-	//       This is most useful for selecting a daily distro build.
-	//
-	//   You may set this in place of `source_ami` or in conjunction with it. If you
-	//   set this in conjunction with `source_ami`, the `source_ami` will be added
-	//   to the filter. The provided `source_ami` must meet all of the filtering
-	//   criteria provided in `source_ami_filter`; this pins the AMI returned by the
-	//   filter, but will cause Packer to fail if the `source_ami` does not exist.
-	SourceAmiFilter AmiFilterOptions `mapstructure:"source_ami_filter" required:"false"`
-	// a list of acceptable instance
-	// types to run your build on. We will request a spot instance using the max
-	// price of spot_price and the allocation strategy of "lowest price".
-	// Your instance will be launched on an instance type of the lowest available
-	// price that you have in your list.  This is used in place of instance_type.
-	// You may only set either spot_instance_types or instance_type, not both.
-	// This feature exists to help prevent situations where a Packer build fails
-	// because a particular availability zone does not have capacity for the
-	// specific instance_type requested in instance_type.
-	SpotInstanceTypes []string `mapstructure:"spot_instance_types" required:"false"`
-	// The maximum hourly price to pay for a spot instance
-	// to create the AMI. Spot instances are a type of instance that EC2 starts
-	// when the current spot price is less than the maximum price you specify.
-	// Spot price will be updated based on available spot instance capacity and
-	// current spot instance requests. It may save you some costs. You can set
-	// this to auto for Packer to automatically discover the best spot price or
-	// to "0" to use an on demand instance (default).
-	SpotPrice string `mapstructure:"spot_price" required:"false"`
-	// Required if spot_price is set to
-	// auto. This tells Packer what sort of AMI you're launching to find the
-	// best spot price. This must be one of: Linux/UNIX, SUSE Linux,
-	// Windows, Linux/UNIX (Amazon VPC), SUSE Linux (Amazon VPC),
-	// Windows (Amazon VPC)
-	SpotPriceAutoProduct string `mapstructure:"spot_price_auto_product" required:"false"`
-	// Requires spot_price to be
-	// set. This tells Packer to apply tags to the spot request that is issued.
-	SpotTags map[string]string `mapstructure:"spot_tags" required:"false"`
-	// Filters used to populate the `subnet_id` field.
-	// Example:
-	//
-	//   ``` json
-	//   {
-	//     "subnet_filter": {
-	//       "filters": {
-	//         "tag:Class": "build"
-	//       },
-	//       "most_free": true,
-	//       "random": false
-	//     }
-	//   }
-	//   ```
-	//
-	//   This selects the Subnet with tag `Class` with the value `build`, which has
-	//   the most free IP addresses. NOTE: This will fail unless *exactly* one
-	//   Subnet is returned. By using `most_free` or `random` one will be selected
-	//   from those matching the filter.
-	//
-	//   -   `filters` (map of strings) - filters used to select a `subnet_id`.
-	//       NOTE: This will fail unless *exactly* one Subnet is returned. Any
-	//       filter described in the docs for
-	//       [DescribeSubnets](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSubnets.html)
-	//       is valid.
-	//
-	//   -   `most_free` (boolean) - The Subnet with the most free IPv4 addresses
-	//       will be used if multiple Subnets matches the filter.
-	//
-	//   -   `random` (boolean) - A random Subnet will be used if multiple Subnets
-	//       matches the filter. `most_free` have precendence over this.
-	//
-	//   `subnet_id` take precedence over this.
-	SubnetFilter SubnetFilterOptions `mapstructure:"subnet_filter" required:"false"`
-	// If using VPC, the ID of the subnet, such as
-	// subnet-12345def, where Packer will launch the EC2 instance. This field is
-	// required if you are using an non-default VPC.
-	SubnetId string `mapstructure:"subnet_id" required:"false"`
-	// The name of the temporary key pair to
-	// generate. By default, Packer generates a name that looks like
-	// `packer_<UUID>`, where &lt;UUID&gt; is a 36 character unique identifier.
-	TemporaryKeyPairName string `mapstructure:"temporary_key_pair_name" required:"false"`
-	// A list of IPv4 CIDR blocks to be authorized access to the instance, when
-	// packer is creating a temporary security group.
-	//
-	// The default is [`0.0.0.0/0`] (i.e., allow any IPv4 source). This is only
-	// used when `security_group_id` or `security_group_ids` is not specified.
-	TemporarySGSourceCidrs []string `mapstructure:"temporary_security_group_source_cidrs" required:"false"`
-	// User data to apply when launching the instance. Note
-	// that you need to be careful about escaping characters due to the templates
-	// being JSON. It is often more convenient to use user_data_file, instead.
-	// Packer will not automatically wait for a user script to finish before
-	// shutting down the instance this must be handled in a provisioner.
-	UserData string `mapstructure:"user_data" required:"false"`
-	// Path to a file that will be used for the user
-	// data when launching the instance.
-	UserDataFile string `mapstructure:"user_data_file" required:"false"`
-	// Filters used to populate the `vpc_id` field.
-	// Example:
-	//
-	// ``` json
-	// {
-	//   "vpc_filter": {
-	//     "filters": {
-	//       "tag:Class": "build",
-	//       "isDefault": "false",
-	//       "cidr": "/24"
-	//     }
-	//   }
-	// }
-	// ```
-	//
-	// This selects the VPC with tag `Class` with the value `build`, which is not
-	// the default VPC, and have a IPv4 CIDR block of `/24`. NOTE: This will fail
-	// unless *exactly* one VPC is returned.
-	//
-	// -   `filters` (map of strings) - filters used to select a `vpc_id`. NOTE:
-	//     This will fail unless *exactly* one VPC is returned. Any filter
-	//     described in the docs for
-	//     [DescribeVpcs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html)
-	//     is valid.
-	//
-	// `vpc_id` take precedence over this.
-	VpcFilter VpcFilterOptions `mapstructure:"vpc_filter" required:"false"`
-	// If launching into a VPC subnet, Packer needs the VPC ID
-	// in order to create a temporary security group within the VPC. Requires
-	// subnet_id to be set. If this field is left blank, Packer will try to get
-	// the VPC ID from the subnet_id.
-	VpcId string `mapstructure:"vpc_id" required:"false"`
-	// The timeout for waiting for a Windows
-	// password for Windows instances. Defaults to 20 minutes. Example value:
-	// 10m
-	WindowsPasswordTimeout time.Duration `mapstructure:"windows_password_timeout" required:"false"`
+	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"`
-	SSHInterface string              `mapstructure:"ssh_interface"`
+	Comm communicator.Config `mapstructure:",squash"`
 }
 
 func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
@@ -362,12 +83,12 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 	errs := c.Comm.Prepare(ctx)
 
 	// Validating ssh_interface
-	if c.SSHInterface != "public_ip" &&
-		c.SSHInterface != "private_ip" &&
-		c.SSHInterface != "public_dns" &&
-		c.SSHInterface != "private_dns" &&
-		c.SSHInterface != "" {
-		errs = append(errs, fmt.Errorf("Unknown interface type: %s", c.SSHInterface))
+	if c.Comm.SSHInterface != "public_ip" &&
+		c.Comm.SSHInterface != "private_ip" &&
+		c.Comm.SSHInterface != "public_dns" &&
+		c.Comm.SSHInterface != "private_dns" &&
+		c.Comm.SSHInterface != "" {
+		errs = append(errs, fmt.Errorf("Unknown interface type: %s", c.Comm.SSHInterface))
 	}
 
 	if c.Comm.SSHKeyPairName != "" {
@@ -386,19 +107,22 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 		errs = append(errs, fmt.Errorf("For security reasons, your source AMI filter must declare an owner."))
 	}
 
-	if c.InstanceType == "" && len(c.SpotInstanceTypes) == 0 {
-		errs = append(errs, fmt.Errorf("either instance_type or "+
-			"spot_instance_types must be specified"))
+	if c.InstanceType == "" {
+		errs = append(errs, fmt.Errorf("An instance_type must be specified"))
 	}
 
-	if c.InstanceType != "" && len(c.SpotInstanceTypes) > 0 {
-		errs = append(errs, fmt.Errorf("either instance_type or "+
-			"spot_instance_types must be specified, not both"))
+	if c.SpotPrice == "auto" {
+		if c.SpotPriceAutoProduct == "" {
+			errs = append(errs, fmt.Errorf(
+				"spot_price_auto_product must be specified when spot_price is auto"))
+		}
 	}
 
-	if c.BlockDurationMinutes%60 != 0 {
-		errs = append(errs, fmt.Errorf(
-			"block_duration_minutes must be multiple of 60"))
+	if c.SpotPriceAutoProduct != "" {
+		if c.SpotPrice != "auto" {
+			errs = append(errs, fmt.Errorf(
+				"spot_price should be set to auto when spot_price_auto_product is specified"))
+		}
 	}
 
 	if c.SpotTags != nil {
@@ -425,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/run_config_test.go

@@ -24,9 +24,7 @@ func testConfig() *RunConfig {
 		InstanceType: "m1.small",
 
 		Comm: communicator.Config{
-			SSH: communicator.SSH{
-				SSHUsername: "foo",
-			},
+			SSHUsername: "foo",
 		},
 	}
 }
@@ -119,6 +117,7 @@ func TestRunConfigPrepare_EnableT2UnlimitedBadWithSpotInstanceRequest(t *testing
 	c.InstanceType = "t2.micro"
 	c.EnableT2Unlimited = true
 	c.SpotPrice = "auto"
+	c.SpotPriceAutoProduct = "Linux/UNIX"
 	err := c.Prepare(nil)
 	if len(err) != 1 {
 		t.Fatalf("Should error if T2 Unlimited has been used in conjuntion with a Spot Price request")
@@ -128,14 +127,19 @@ func TestRunConfigPrepare_EnableT2UnlimitedBadWithSpotInstanceRequest(t *testing
 func TestRunConfigPrepare_SpotAuto(t *testing.T) {
 	c := testConfig()
 	c.SpotPrice = "auto"
+	if err := c.Prepare(nil); len(err) != 1 {
+		t.Fatalf("Should error if spot_price_auto_product is not set and spot_price is set to auto")
+	}
+
+	// Good - SpotPrice and SpotPriceAutoProduct are correctly set
+	c.SpotPriceAutoProduct = "foo"
 	if err := c.Prepare(nil); len(err) != 0 {
 		t.Fatalf("err: %s", err)
 	}
 
-	// Shouldn't error (YET) even though SpotPriceAutoProduct is deprecated
-	c.SpotPriceAutoProduct = "Linux/Unix"
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
+	c.SpotPrice = ""
+	if err := c.Prepare(nil); len(err) != 1 {
+		t.Fatalf("Should error if spot_price is not set to auto and spot_price_auto_product is set")
 	}
 }
 

builder/amazon/common/ssh.go

@@ -3,7 +3,6 @@ package common
 import (
 	"errors"
 	"fmt"
-	"log"
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
@@ -21,16 +20,12 @@ var (
 
 // SSHHost returns a function that can be given to the SSH communicator
 // for determining the SSH address based on the instance DNS name.
-func SSHHost(e ec2Describer, sshInterface string, host string) func(multistep.StateBag) (string, error) {
+func SSHHost(e ec2Describer, sshInterface string) func(multistep.StateBag) (string, error) {
 	return func(state multistep.StateBag) (string, error) {
-		if host != "" {
-			log.Printf("Using ssh_host value: %s", host)
-			return host, nil
-		}
-
 		const tries = 2
 		// <= with current structure to check result of describing `tries` times
 		for j := 0; j <= tries; j++ {
+			var host string
 			i := state.Get("instance").(*ec2.Instance)
 			if sshInterface != "" {
 				switch sshInterface {

builder/amazon/common/ssh_test.go

@@ -9,11 +9,10 @@ import (
 )
 
 const (
-	privateIP       = "10.0.0.1"
-	publicIP        = "192.168.1.1"
-	privateDNS      = "private.dns.test"
-	publicDNS       = "public.dns.test"
-	sshHostTemplate = "custom.host.value"
+	privateIP  = "10.0.0.1"
+	publicIP   = "192.168.1.1"
+	privateDNS = "private.dns.test"
+	publicDNS  = "public.dns.test"
 )
 
 func TestSSHHost(t *testing.T) {
@@ -26,46 +25,39 @@ func TestSSHHost(t *testing.T) {
 		vpcId        string
 		sshInterface string
 
-		ok              bool
-		wantHost        string
-		sshHostOverride string
+		ok       bool
+		wantHost string
 	}{
-		{1, "", "", true, publicDNS, ""},
-		{1, "", "private_ip", true, privateIP, ""},
-		{1, "vpc-id", "", true, publicIP, ""},
-		{1, "vpc-id", "private_ip", true, privateIP, ""},
-		{1, "vpc-id", "private_dns", true, privateDNS, ""},
-		{1, "vpc-id", "public_dns", true, publicDNS, ""},
-		{1, "vpc-id", "public_ip", true, publicIP, ""},
-		{2, "", "", true, publicDNS, ""},
-		{2, "", "private_ip", true, privateIP, ""},
-		{2, "vpc-id", "", true, publicIP, ""},
-		{2, "vpc-id", "private_ip", true, privateIP, ""},
-		{2, "vpc-id", "private_dns", true, privateDNS, ""},
-		{2, "vpc-id", "public_dns", true, publicDNS, ""},
-		{2, "vpc-id", "public_ip", true, publicIP, ""},
-		{3, "", "", false, "", ""},
-		{3, "", "private_ip", false, "", ""},
-		{3, "vpc-id", "", false, "", ""},
-		{3, "vpc-id", "private_ip", false, "", ""},
-		{3, "vpc-id", "private_dns", false, "", ""},
-		{3, "vpc-id", "public_dns", false, "", ""},
-		{3, "vpc-id", "public_ip", false, "", ""},
-		{1, "", "", true, sshHostTemplate, sshHostTemplate},
-		{1, "vpc-id", "", true, sshHostTemplate, sshHostTemplate},
-		{2, "vpc-id", "private_dns", true, sshHostTemplate, sshHostTemplate},
+		{1, "", "", true, publicDNS},
+		{1, "", "private_ip", true, privateIP},
+		{1, "vpc-id", "", true, publicIP},
+		{1, "vpc-id", "private_ip", true, privateIP},
+		{1, "vpc-id", "private_dns", true, privateDNS},
+		{1, "vpc-id", "public_dns", true, publicDNS},
+		{1, "vpc-id", "public_ip", true, publicIP},
+		{2, "", "", true, publicDNS},
+		{2, "", "private_ip", true, privateIP},
+		{2, "vpc-id", "", true, publicIP},
+		{2, "vpc-id", "private_ip", true, privateIP},
+		{2, "vpc-id", "private_dns", true, privateDNS},
+		{2, "vpc-id", "public_dns", true, publicDNS},
+		{2, "vpc-id", "public_ip", true, publicIP},
+		{3, "", "", false, ""},
+		{3, "", "private_ip", false, ""},
+		{3, "vpc-id", "", false, ""},
+		{3, "vpc-id", "private_ip", false, ""},
+		{3, "vpc-id", "private_dns", false, ""},
+		{3, "vpc-id", "public_dns", false, ""},
+		{3, "vpc-id", "public_ip", false, ""},
 	}
 
 	for _, c := range cases {
-		testSSHHost(t, c.allowTries, c.vpcId, c.sshInterface, c.ok, c.wantHost,
-			c.sshHostOverride)
+		testSSHHost(t, c.allowTries, c.vpcId, c.sshInterface, c.ok, c.wantHost)
 	}
 }
 
-func testSSHHost(t *testing.T, allowTries int, vpcId string, sshInterface string,
-	ok bool, wantHost string, sshHostOverride string) {
-	t.Logf("allowTries=%d vpcId=%s sshInterface=%s ok=%t wantHost=%q sshHostOverride=%s",
-		allowTries, vpcId, sshInterface, ok, wantHost, sshHostOverride)
+func testSSHHost(t *testing.T, allowTries int, vpcId string, sshInterface string, ok bool, wantHost string) {
+	t.Logf("allowTries=%d vpcId=%s sshInterface=%s ok=%t wantHost=%q", allowTries, vpcId, sshInterface, ok, wantHost)
 
 	e := &fakeEC2Describer{
 		allowTries: allowTries,
@@ -76,7 +68,7 @@ func testSSHHost(t *testing.T, allowTries int, vpcId string, sshInterface string
 		publicDNS:  publicDNS,
 	}
 
-	f := SSHHost(e, sshInterface, sshHostOverride)
+	f := SSHHost(e, sshInterface)
 	st := &multistep.BasicStateBag{}
 	st.Put("instance", &ec2.Instance{
 		InstanceId: aws.String("instance-id"),

builder/amazon/common/state.go

@@ -1,7 +1,6 @@
 package common
 
 import (
-	"fmt"
 	"log"
 	"os"
 	"strconv"
@@ -10,7 +9,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/hashicorp/packer/helper/multistep"
 )
 
@@ -35,9 +33,9 @@ type StateChangeConf struct {
 }
 
 // Following are wrapper functions that use Packer's environment-variables to
-// determine retry logic, then call the AWS SDK's built-in waiters.
+// determing retry logic, then call the AWS SDK's built-in waiters.
 
-func WaitUntilAMIAvailable(ctx aws.Context, conn ec2iface.EC2API, imageId string) error {
+func WaitUntilAMIAvailable(ctx aws.Context, conn *ec2.EC2, imageId string) error {
 	imageInput := ec2.DescribeImagesInput{
 		ImageIds: []*string{&imageId},
 	}
@@ -171,8 +169,6 @@ func WaitForVolumeToBeAttached(c *ec2.EC2, ctx aws.Context, input *ec2.DescribeV
 			return req, nil
 		},
 	}
-	w.ApplyOptions(opts...)
-
 	return w.WaitWithContext(ctx)
 }
 
@@ -202,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{
 			{
@@ -219,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) {
@@ -239,8 +227,6 @@ func WaitForImageToBeImported(c *ec2.EC2, ctx aws.Context, input *ec2.DescribeIm
 			return req, nil
 		},
 	}
-	w.ApplyOptions(opts...)
-
 	return w.WaitWithContext(ctx)
 }
 
@@ -295,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)
@@ -309,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,
@@ -352,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 {
@@ -361,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,8 +7,7 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/hashicorp/packer/helper/config"
+
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -16,106 +15,45 @@ import (
 type StepAMIRegionCopy struct {
 	AccessConfig      *AccessConfig
 	Regions           []string
-	AMIKmsKeyId       string
 	RegionKeyIds      map[string]string
-	EncryptBootVolume config.Trilean // nil means preserve
+	EncryptBootVolume bool
 	Name              string
-	OriginalRegion    string
-
-	toDelete           string
-	getRegionConn      func(*AccessConfig, string) (ec2iface.EC2API, error)
-	AMISkipBuildRegion bool
-}
-
-func (s *StepAMIRegionCopy) DeduplicateRegions(intermediary bool) {
-	// Deduplicates regions by looping over the list of regions and storing
-	// the regions as keys in a map. This saves users from accidentally copying
-	// regions twice if they've added a region to a map twice.
-
-	RegionMap := map[string]bool{}
-	RegionSlice := []string{}
-
-	// Original build region may or may not be present in the Regions list, so
-	// let's make absolutely sure it's in our map.
-	RegionMap[s.OriginalRegion] = true
-	for _, r := range s.Regions {
-		RegionMap[r] = true
-	}
-
-	if !intermediary || s.AMISkipBuildRegion {
-		// We don't want to copy back into the original region if we aren't
-		// using an intermediary image, so remove the original region from our
-		// map.
-
-		// We also don't want to copy back into the original region if the
-		// intermediary image is because we're skipping the build region.
-		delete(RegionMap, s.OriginalRegion)
-
-	}
-
-	// Now print all those keys into the region slice again
-	for k, _ := range RegionMap {
-		RegionSlice = append(RegionSlice, k)
-	}
-
-	s.Regions = RegionSlice
 }
 
 func (s *StepAMIRegionCopy) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 	amis := state.Get("amis").(map[string]string)
 	snapshots := state.Get("snapshots").(map[string][]string)
-	intermediary, _ := state.Get("intermediary_image").(bool)
-
-	s.DeduplicateRegions(intermediary)
-	ami := amis[s.OriginalRegion]
-
-	// Make a note to delete the intermediary AMI if necessary.
-	if intermediary {
-		s.toDelete = ami
-	}
-
-	if s.EncryptBootVolume.True() {
-		// encrypt_boot is true, so we have to copy the temporary
-		// AMI with required encryption setting.
-		// temp image was created by stepCreateAMI.
-		if s.RegionKeyIds == nil {
-			s.RegionKeyIds = make(map[string]string)
-		}
-
-		// Make sure the kms_key_id for the original region is in the map
-		if _, ok := s.RegionKeyIds[s.OriginalRegion]; !ok {
-			s.RegionKeyIds[s.OriginalRegion] = s.AMIKmsKeyId
-		}
-	}
+	ami := amis[*ec2conn.Config.Region]
 
 	if len(s.Regions) == 0 {
 		return multistep.ActionContinue
 	}
 
-	ui.Say(fmt.Sprintf("Copying/Encrypting AMI (%s) to other regions...", ami))
+	ui.Say(fmt.Sprintf("Copying AMI (%s) to other regions...", ami))
 
 	var lock sync.Mutex
 	var wg sync.WaitGroup
+	var regKeyID string
 	errs := new(packer.MultiError)
-	wg.Add(len(s.Regions))
 	for _, region := range s.Regions {
-		var regKeyID string
+		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.True() {
-			// Encrypt is true, explicitly
+		if s.EncryptBootVolume {
 			regKeyID = s.RegionKeyIds[region]
-		} else {
-			// Encrypt is nil or false; Make sure region key is empty
-			regKeyID = ""
 		}
 
 		go func(region string) {
 			defer wg.Done()
-			id, snapshotIds, err := s.amiRegionCopy(ctx, state, s.AccessConfig,
-				s.Name, ami, region, s.OriginalRegion, regKeyID,
-				s.EncryptBootVolume.ToBoolPointer())
+			id, snapshotIds, err := amiRegionCopy(ctx, state, s.AccessConfig, s.Name, ami, region, *ec2conn.Config.Region, regKeyID)
 			lock.Lock()
 			defer lock.Unlock()
 			amis[region] = id
@@ -142,95 +80,35 @@ func (s *StepAMIRegionCopy) Run(ctx context.Context, state multistep.StateBag) m
 }
 
 func (s *StepAMIRegionCopy) Cleanup(state multistep.StateBag) {
-	ec2conn := state.Get("ec2").(*ec2.EC2)
-	ui := state.Get("ui").(packer.Ui)
-
-	if len(s.toDelete) == 0 {
-		return
-	}
-
-	// Delete the unencrypted amis and snapshots
-	ui.Say("Deregistering the AMI and deleting unencrypted temporary " +
-		"AMIs and snapshots")
-
-	resp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{
-		ImageIds: []*string{&s.toDelete},
-	})
-
-	if err != nil {
-		err := fmt.Errorf("Error describing AMI: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return
-	}
-
-	// Deregister image by name.
-	for _, i := range resp.Images {
-		_, err := ec2conn.DeregisterImage(&ec2.DeregisterImageInput{
-			ImageId: i.ImageId,
-		})
-
-		if err != nil {
-			err := fmt.Errorf("Error deregistering existing AMI: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return
-		}
-		ui.Say(fmt.Sprintf("Deregistered AMI id: %s", *i.ImageId))
-
-		// Delete snapshot(s) by image
-		for _, b := range i.BlockDeviceMappings {
-			if b.Ebs != nil && aws.StringValue(b.Ebs.SnapshotId) != "" {
-				_, err := ec2conn.DeleteSnapshot(&ec2.DeleteSnapshotInput{
-					SnapshotId: b.Ebs.SnapshotId,
-				})
-
-				if err != nil {
-					err := fmt.Errorf("Error deleting existing snapshot: %s", err)
-					state.Put("error", err)
-					ui.Error(err.Error())
-					return
-				}
-				ui.Say(fmt.Sprintf("Deleted snapshot: %s", *b.Ebs.SnapshotId))
-			}
-		}
-	}
-}
-
-func getRegionConn(config *AccessConfig, target string) (ec2iface.EC2API, error) {
-	// Connect to the region where the AMI will be copied to
-	session, err := config.Session()
-	if err != nil {
-		return nil, fmt.Errorf("Error getting region connection for copy: %s", err)
-	}
-
-	regionconn := ec2.New(session.Copy(&aws.Config{
-		Region: aws.String(target),
-	}))
-
-	return regionconn, nil
+	// No cleanup...
 }
 
 // amiRegionCopy does a copy for the given AMI to the target region and
 // returns the resulting ID and snapshot IDs, or error.
-func (s *StepAMIRegionCopy) 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
 
-	if s.getRegionConn == nil {
-		s.getRegionConn = getRegionConn
-	}
-
-	regionconn, err := s.getRegionConn(config, target)
+	// 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)},
+	))
+
 	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_ami_region_copy_test.go

@@ -1,404 +0,0 @@
-package common
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"sync"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/hashicorp/packer/helper/config"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-// Define a mock struct to be used in unit tests for common aws steps.
-type mockEC2Conn struct {
-	ec2iface.EC2API
-	Config *aws.Config
-
-	// Counters to figure out what code path was taken
-	copyImageCount       int
-	describeImagesCount  int
-	deregisterImageCount int
-	deleteSnapshotCount  int
-	waitCount            int
-
-	lock sync.Mutex
-}
-
-func (m *mockEC2Conn) CopyImage(copyInput *ec2.CopyImageInput) (*ec2.CopyImageOutput, error) {
-	m.lock.Lock()
-	m.copyImageCount++
-	m.lock.Unlock()
-	copiedImage := fmt.Sprintf("%s-copied-%d", *copyInput.SourceImageId, m.copyImageCount)
-	output := &ec2.CopyImageOutput{
-		ImageId: &copiedImage,
-	}
-	return output, nil
-}
-
-// functions we have to create mock responses for in order for test to run
-func (m *mockEC2Conn) DescribeImages(*ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error) {
-	m.lock.Lock()
-	m.describeImagesCount++
-	m.lock.Unlock()
-	output := &ec2.DescribeImagesOutput{
-		Images: []*ec2.Image{{}},
-	}
-	return output, nil
-}
-
-func (m *mockEC2Conn) DeregisterImage(*ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error) {
-	m.lock.Lock()
-	m.deregisterImageCount++
-	m.lock.Unlock()
-	output := &ec2.DeregisterImageOutput{}
-	return output, nil
-}
-
-func (m *mockEC2Conn) DeleteSnapshot(*ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error) {
-	m.lock.Lock()
-	m.deleteSnapshotCount++
-	m.lock.Unlock()
-	output := &ec2.DeleteSnapshotOutput{}
-	return output, nil
-}
-
-func (m *mockEC2Conn) WaitUntilImageAvailableWithContext(aws.Context, *ec2.DescribeImagesInput, ...request.WaiterOption) error {
-	m.lock.Lock()
-	m.waitCount++
-	m.lock.Unlock()
-	return nil
-}
-
-func getMockConn(config *AccessConfig, target string) (ec2iface.EC2API, error) {
-	mockConn := &mockEC2Conn{
-		Config: aws.NewConfig(),
-	}
-
-	return mockConn, nil
-}
-
-// Create statebag for running test
-func tState() multistep.StateBag {
-	state := new(multistep.BasicStateBag)
-	state.Put("ui", &packer.BasicUi{
-		Reader: new(bytes.Buffer),
-		Writer: new(bytes.Buffer),
-	})
-	state.Put("amis", map[string]string{"us-east-1": "ami-12345"})
-	state.Put("snapshots", map[string][]string{"us-east-1": {"snap-0012345"}})
-	conn, _ := getMockConn(&AccessConfig{}, "us-east-2")
-	state.Put("ec2", conn)
-	return state
-}
-
-func TestStepAMIRegionCopy_duplicates(t *testing.T) {
-	// ------------------------------------------------------------------------
-	// Test that if the original region is added to both Regions and Region,
-	// the ami is only copied once (with encryption).
-	// ------------------------------------------------------------------------
-
-	stepAMIRegionCopy := StepAMIRegionCopy{
-		AccessConfig: testAccessConfig(),
-		Regions:      []string{"us-east-1"},
-		AMIKmsKeyId:  "12345",
-		// Original region key in regionkeyids is different than in amikmskeyid
-		RegionKeyIds:      map[string]string{"us-east-1": "12345"},
-		EncryptBootVolume: config.TriTrue,
-		Name:              "fake-ami-name",
-		OriginalRegion:    "us-east-1",
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-
-	state := tState()
-	state.Put("intermediary_image", true)
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if len(stepAMIRegionCopy.Regions) != 1 {
-		t.Fatalf("Should have added original ami to Regions one time only")
-	}
-
-	// ------------------------------------------------------------------------
-	// Both Region and Regions set, but no encryption - shouldn't copy anything
-	// ------------------------------------------------------------------------
-
-	// the ami is only copied once.
-	stepAMIRegionCopy = StepAMIRegionCopy{
-		AccessConfig:   testAccessConfig(),
-		Regions:        []string{"us-east-1"},
-		Name:           "fake-ami-name",
-		OriginalRegion: "us-east-1",
-	}
-	// mock out the region connection code
-	state.Put("intermediary_image", false)
-	stepAMIRegionCopy.getRegionConn = getMockConn
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if len(stepAMIRegionCopy.Regions) != 0 {
-		t.Fatalf("Should not have added original ami to Regions; not encrypting")
-	}
-
-	// ------------------------------------------------------------------------
-	// Both Region and Regions set, but no encryption - shouldn't copy anything,
-	// this tests false as opposed to nil value above.
-	// ------------------------------------------------------------------------
-
-	// the ami is only copied once.
-	stepAMIRegionCopy = StepAMIRegionCopy{
-		AccessConfig:      testAccessConfig(),
-		Regions:           []string{"us-east-1"},
-		EncryptBootVolume: config.TriFalse,
-		Name:              "fake-ami-name",
-		OriginalRegion:    "us-east-1",
-	}
-	// mock out the region connection code
-	state.Put("intermediary_image", false)
-	stepAMIRegionCopy.getRegionConn = getMockConn
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if len(stepAMIRegionCopy.Regions) != 0 {
-		t.Fatalf("Should not have added original ami to Regions once; not" +
-			"encrypting")
-	}
-
-	// ------------------------------------------------------------------------
-	// Multiple regions, many duplicates, and encryption (this shouldn't ever
-	// happen because of our template validation, but good to test it.)
-	// ------------------------------------------------------------------------
-
-	stepAMIRegionCopy = StepAMIRegionCopy{
-		AccessConfig: testAccessConfig(),
-		// Many duplicates for only 3 actual values
-		Regions:     []string{"us-east-1", "us-west-2", "us-west-2", "ap-east-1", "ap-east-1", "ap-east-1"},
-		AMIKmsKeyId: "IlikePancakes",
-		// Original region key in regionkeyids is different than in amikmskeyid
-		RegionKeyIds:      map[string]string{"us-east-1": "12345", "us-west-2": "abcde", "ap-east-1": "xyz"},
-		EncryptBootVolume: config.TriTrue,
-		Name:              "fake-ami-name",
-		OriginalRegion:    "us-east-1",
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-	state.Put("intermediary_image", true)
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if len(stepAMIRegionCopy.Regions) != 3 {
-		t.Fatalf("Each AMI should have been added to Regions one time only.")
-	}
-
-	// Also verify that we respect RegionKeyIds over AMIKmsKeyIds:
-	if stepAMIRegionCopy.RegionKeyIds["us-east-1"] != "12345" {
-		t.Fatalf("RegionKeyIds should take precedence over AmiKmsKeyIds")
-	}
-
-	// ------------------------------------------------------------------------
-	// Multiple regions, many duplicates, NO encryption
-	// ------------------------------------------------------------------------
-
-	stepAMIRegionCopy = StepAMIRegionCopy{
-		AccessConfig: testAccessConfig(),
-		// Many duplicates for only 3 actual values
-		Regions:        []string{"us-east-1", "us-west-2", "us-west-2", "ap-east-1", "ap-east-1", "ap-east-1"},
-		Name:           "fake-ami-name",
-		OriginalRegion: "us-east-1",
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-	state.Put("intermediary_image", false)
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if len(stepAMIRegionCopy.Regions) != 2 {
-		t.Fatalf("Each AMI should have been added to Regions one time only, " +
-			"and original region shouldn't be added at all")
-	}
-}
-
-func TestStepAmiRegionCopy_nil_encryption(t *testing.T) {
-	// create step
-	stepAMIRegionCopy := StepAMIRegionCopy{
-		AccessConfig:      testAccessConfig(),
-		Regions:           make([]string, 0),
-		AMIKmsKeyId:       "",
-		RegionKeyIds:      make(map[string]string),
-		EncryptBootVolume: config.TriUnset,
-		Name:              "fake-ami-name",
-		OriginalRegion:    "us-east-1",
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-
-	state := tState()
-	state.Put("intermediary_image", false)
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if stepAMIRegionCopy.toDelete != "" {
-		t.Fatalf("Shouldn't have an intermediary ami if encrypt is nil")
-	}
-	if len(stepAMIRegionCopy.Regions) != 0 {
-		t.Fatalf("Should not have added original ami to original region")
-	}
-}
-
-func TestStepAmiRegionCopy_true_encryption(t *testing.T) {
-	// create step
-	stepAMIRegionCopy := StepAMIRegionCopy{
-		AccessConfig:      testAccessConfig(),
-		Regions:           make([]string, 0),
-		AMIKmsKeyId:       "",
-		RegionKeyIds:      make(map[string]string),
-		EncryptBootVolume: config.TriTrue,
-		Name:              "fake-ami-name",
-		OriginalRegion:    "us-east-1",
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-
-	state := tState()
-	state.Put("intermediary_image", true)
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if stepAMIRegionCopy.toDelete == "" {
-		t.Fatalf("Should delete original AMI if encrypted=true")
-	}
-	if len(stepAMIRegionCopy.Regions) == 0 {
-		t.Fatalf("Should have added original ami to Regions")
-	}
-}
-
-func TestStepAmiRegionCopy_nil_intermediary(t *testing.T) {
-	// create step
-	stepAMIRegionCopy := StepAMIRegionCopy{
-		AccessConfig:      testAccessConfig(),
-		Regions:           make([]string, 0),
-		AMIKmsKeyId:       "",
-		RegionKeyIds:      make(map[string]string),
-		EncryptBootVolume: config.TriFalse,
-		Name:              "fake-ami-name",
-		OriginalRegion:    "us-east-1",
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-
-	state := tState()
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if stepAMIRegionCopy.toDelete != "" {
-		t.Fatalf("Should not delete original AMI if no intermediary")
-	}
-	if len(stepAMIRegionCopy.Regions) != 0 {
-		t.Fatalf("Should not have added original ami to Regions")
-	}
-}
-
-func TestStepAmiRegionCopy_AMISkipBuildRegion(t *testing.T) {
-	// ------------------------------------------------------------------------
-	// skip build region is true
-	// ------------------------------------------------------------------------
-
-	stepAMIRegionCopy := StepAMIRegionCopy{
-		AccessConfig:       testAccessConfig(),
-		Regions:            []string{"us-west-1"},
-		AMIKmsKeyId:        "",
-		RegionKeyIds:       map[string]string{"us-west-1": "abcde"},
-		Name:               "fake-ami-name",
-		OriginalRegion:     "us-east-1",
-		AMISkipBuildRegion: true,
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-
-	state := tState()
-	state.Put("intermediary_image", true)
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if stepAMIRegionCopy.toDelete == "" {
-		t.Fatalf("Should delete original AMI if skip_save_build_region=true")
-	}
-	if len(stepAMIRegionCopy.Regions) != 1 {
-		t.Fatalf("Should not have added original ami to Regions; Regions: %#v", stepAMIRegionCopy.Regions)
-	}
-
-	// ------------------------------------------------------------------------
-	// skip build region is false.
-	// ------------------------------------------------------------------------
-	stepAMIRegionCopy = StepAMIRegionCopy{
-		AccessConfig:       testAccessConfig(),
-		Regions:            []string{"us-west-1"},
-		AMIKmsKeyId:        "",
-		RegionKeyIds:       make(map[string]string),
-		Name:               "fake-ami-name",
-		OriginalRegion:     "us-east-1",
-		AMISkipBuildRegion: false,
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-
-	state.Put("intermediary_image", false) // not encrypted
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if stepAMIRegionCopy.toDelete != "" {
-		t.Fatalf("Shouldn't have an intermediary AMI, so dont delete original ami")
-	}
-	if len(stepAMIRegionCopy.Regions) != 1 {
-		t.Fatalf("Should not have added original ami to Regions; Regions: %#v", stepAMIRegionCopy.Regions)
-	}
-
-	// ------------------------------------------------------------------------
-	// skip build region is false, but encrypt is true
-	// ------------------------------------------------------------------------
-	stepAMIRegionCopy = StepAMIRegionCopy{
-		AccessConfig:       testAccessConfig(),
-		Regions:            []string{"us-west-1"},
-		AMIKmsKeyId:        "",
-		RegionKeyIds:       map[string]string{"us-west-1": "abcde"},
-		Name:               "fake-ami-name",
-		OriginalRegion:     "us-east-1",
-		AMISkipBuildRegion: false,
-		EncryptBootVolume:  config.TriTrue,
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-
-	state.Put("intermediary_image", true) //encrypted
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if stepAMIRegionCopy.toDelete == "" {
-		t.Fatalf("Have to delete intermediary AMI")
-	}
-	if len(stepAMIRegionCopy.Regions) != 2 {
-		t.Fatalf("Should have added original ami to Regions; Regions: %#v", stepAMIRegionCopy.Regions)
-	}
-
-	// ------------------------------------------------------------------------
-	// skip build region is true, and encrypt is true
-	// ------------------------------------------------------------------------
-	stepAMIRegionCopy = StepAMIRegionCopy{
-		AccessConfig:       testAccessConfig(),
-		Regions:            []string{"us-west-1"},
-		AMIKmsKeyId:        "",
-		RegionKeyIds:       map[string]string{"us-west-1": "abcde"},
-		Name:               "fake-ami-name",
-		OriginalRegion:     "us-east-1",
-		AMISkipBuildRegion: true,
-		EncryptBootVolume:  config.TriTrue,
-	}
-	// mock out the region connection code
-	stepAMIRegionCopy.getRegionConn = getMockConn
-
-	state.Put("intermediary_image", true) //encrypted
-	stepAMIRegionCopy.Run(context.Background(), state)
-
-	if stepAMIRegionCopy.toDelete == "" {
-		t.Fatalf("Have to delete intermediary AMI")
-	}
-	if len(stepAMIRegionCopy.Regions) != 1 {
-		t.Fatalf("Should not have added original ami to Regions; Regions: %#v", stepAMIRegionCopy.Regions)
-	}
-}

builder/amazon/common/step_cleanup_volumes.go

@@ -14,10 +14,10 @@ import (
 // remain after termination of the instance. These volumes are typically ones
 // that are marked as "delete on terminate:false" in the source_ami of a build.
 type StepCleanupVolumes struct {
-	LaunchMappings BlockDevices
+	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
 }
@@ -79,7 +79,7 @@ func (s *StepCleanupVolumes) Cleanup(state multistep.StateBag) {
 
 	// Filter out any devices created as part of the launch mappings, since
 	// we'll let amazon follow the `delete_on_termination` setting.
-	for _, b := range s.LaunchMappings {
+	for _, b := range s.BlockDevices.LaunchMappings {
 		for volKey, volName := range volList {
 			if volName == b.DeviceName {
 				delete(volList, volKey)

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,29 +90,16 @@ 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 * time.Second, 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
-
-			var err error
-			if len(amiTags) > 0 {
-				_, err = regionConn.CreateTags(&ec2.CreateTagsInput{
-					Resources: resourceIds,
-					Tags:      amiTags,
-				})
-				if err != nil {
-					return err
+			_, err := regionConn.CreateTags(&ec2.CreateTagsInput{
+				Resources: resourceIds,
+				Tags:      amiTags,
+			})
+			if awsErr, ok := err.(awserr.Error); ok {
+				if awsErr.Code() == "InvalidAMIID.NotFound" ||
+					awsErr.Code() == "InvalidSnapshot.NotFound" {
+					return false, nil
 				}
 			}
 
@@ -124,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,8 +12,6 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common/retry"
-	commonhelper "github.com/hashicorp/packer/helper/common"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -28,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
@@ -46,13 +44,14 @@ func (s *StepGetPassword) Run(ctx context.Context, state multistep.StateBag) mul
 	// Get the password
 	var password string
 	var err error
+	cancel := make(chan struct{})
 	waitDone := make(chan bool, 1)
 	go func() {
 		ui.Say("Waiting for auto-generated password for instance...")
 		ui.Message(
 			"It is normal for this process to take up to 15 minutes,\n" +
 				"but it usually takes around 5. Please wait.")
-		password, err = s.waitForPassword(ctx, state)
+		password, err = s.waitForPassword(state, cancel)
 		waitDone <- true
 	}()
 
@@ -76,12 +75,16 @@ WaitLoop:
 			err := fmt.Errorf("Timeout waiting for password.")
 			state.Put("error", err)
 			ui.Error(err.Error())
+			close(cancel)
 			return multistep.ActionHalt
-		case <-ctx.Done():
-			// The step sequence was cancelled, so cancel waiting for password
-			// and just start the halting process.
-			log.Println("[WARN] Interrupt detected, quitting waiting for password.")
-			return multistep.ActionHalt
+		case <-time.After(1 * time.Second):
+			if _, ok := state.GetOk(multistep.StateCancelled); ok {
+				// The step sequence was cancelled, so cancel waiting for password
+				// and just start the halting process.
+				close(cancel)
+				log.Println("[WARN] Interrupt detected, quitting waiting for password.")
+				return multistep.ActionHalt
+			}
 		}
 	}
 
@@ -91,49 +94,33 @@ 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(ctx context.Context, state multistep.StateBag) (string, error) {
+func (s *StepGetPassword) waitForPassword(state multistep.StateBag, cancel <-chan struct{}) (string, error) {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	instance := state.Get("instance").(*ec2.Instance)
 	privateKey := s.Comm.SSHPrivateKey
 
 	for {
 		select {
-		case <-ctx.Done():
+		case <-cancel:
 			log.Println("[INFO] Retrieve password wait cancelled. Exiting loop.")
 			return "", errors.New("Retrieve password wait cancelled")
 		case <-time.After(5 * time.Second):
 		}
 
-		// Wrap in a retry so that we don't fail on rate-limiting.
-		log.Printf("Retrieving auto-generated instance password...")
-		var resp *ec2.GetPasswordDataOutput
-		err := retry.Config{
-			Tries:      11,
-			RetryDelay: (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30 * time.Second, Multiplier: 2}).Linear,
-		}.Run(ctx, func(ctx context.Context) error {
-			var err error
-			resp, err = ec2conn.GetPasswordData(&ec2.GetPasswordDataInput{
-				InstanceId: instance.InstanceId,
-			})
-			if err != nil {
-				err := fmt.Errorf("Error retrieving auto-generated instance password: %s", err)
-				return err
-			}
-			return nil
+		resp, err := ec2conn.GetPasswordData(&ec2.GetPasswordDataInput{
+			InstanceId: instance.InstanceId,
 		})
-
 		if err != nil {
+			err := fmt.Errorf("Error retrieving auto-generated instance password: %s", err)
 			return "", err
 		}
 

builder/amazon/common/step_key_pair.go

@@ -3,12 +3,11 @@ package common
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"runtime"
-	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -22,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
 		}
 
@@ -55,19 +55,10 @@ func (s *StepKeyPair) Run(ctx context.Context, state multistep.StateBag) multist
 	}
 
 	ec2conn := state.Get("ec2").(*ec2.EC2)
-	var keyResp *ec2.CreateKeyPairOutput
 
 	ui.Say(fmt.Sprintf("Creating temporary keypair: %s", s.Comm.SSHTemporaryKeyPairName))
-	err := retry.Config{
-		Tries:      11,
-		RetryDelay: (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30 * time.Second, Multiplier: 2}).Linear,
-	}.Run(ctx, func(ctx context.Context) error {
-		var err error
-		keyResp, err = ec2conn.CreateKeyPair(&ec2.CreateKeyPairInput{
-			KeyName: &s.Comm.SSHTemporaryKeyPairName})
-		return err
-	})
-
+	keyResp, err := ec2conn.CreateKeyPair(&ec2.CreateKeyPairInput{
+		KeyName: &s.Comm.SSHTemporaryKeyPairName})
 	if err != nil {
 		state.Put("error", fmt.Errorf("Error creating temporary keypair: %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,22 +3,20 @@ package common
 import (
 	"context"
 	"fmt"
-	"strings"
 
+	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	confighelper "github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
 
 type StepModifyEBSBackedInstance struct {
-	EnableAMIENASupport      confighelper.Trilean
+	EnableAMIENASupport      bool
 	EnableAMISriovNetSupport bool
 }
 
-func (s *StepModifyEBSBackedInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ec2conn := state.Get("ec2").(ec2iface.EC2API)
+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)
 
@@ -39,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 != confighelper.TriUnset {
-		var prefix string
-		if s.EnableAMIENASupport.True() {
-			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: s.EnableAMIENASupport.ToBoolPointer()},
+			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_modify_ebs_instance_test.go

@@ -1,105 +0,0 @@
-package common
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"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"
-	helperconfig "github.com/hashicorp/packer/helper/config"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-// Define a mock struct to be used in unit tests for common aws steps.
-type mockEC2Conn_ModifyEBS struct {
-	ec2iface.EC2API
-	Config *aws.Config
-
-	// Counters to figure out what code path was taken
-	shouldError          bool
-	modifyImageAttrCount int
-}
-
-func (m *mockEC2Conn_ModifyEBS) ModifyInstanceAttribute(modifyInput *ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error) {
-	m.modifyImageAttrCount++
-	// don't need to define output since we always discard it anyway.
-	output := &ec2.ModifyInstanceAttributeOutput{}
-	if m.shouldError {
-		return output, fmt.Errorf("fake ModifyInstanceAttribute error")
-	}
-	return output, nil
-}
-
-// Create statebag for running test
-func fakeModifyEBSBackedInstanceState() multistep.StateBag {
-	state := new(multistep.BasicStateBag)
-	state.Put("ui", &packer.BasicUi{
-		Reader: new(bytes.Buffer),
-		Writer: new(bytes.Buffer),
-	})
-	state.Put("instance", "i-12345")
-	return state
-}
-
-func StepModifyEBSBackedInstance_EnableAMIENASupport(t *testing.T) {
-	// Value is unset, so we shouldn't modify
-	stepModifyEBSBackedInstance := StepModifyEBSBackedInstance{
-		EnableAMIENASupport:      helperconfig.TriUnset,
-		EnableAMISriovNetSupport: false,
-	}
-
-	// mock out the region connection code
-	mockConn := &mockEC2Conn_ModifyEBS{
-		Config: aws.NewConfig(),
-	}
-
-	state := fakeModifyEBSBackedInstanceState()
-	state.Put("ec2", mockConn)
-	stepModifyEBSBackedInstance.Run(context.Background(), state)
-
-	if mockConn.modifyImageAttrCount > 0 {
-		t.Fatalf("Should not have modified image since EnableAMIENASupport is unset")
-	}
-
-	// Value is true, so we should modify
-	stepModifyEBSBackedInstance = StepModifyEBSBackedInstance{
-		EnableAMIENASupport:      helperconfig.TriTrue,
-		EnableAMISriovNetSupport: false,
-	}
-
-	// mock out the region connection code
-	mockConn = &mockEC2Conn_ModifyEBS{
-		Config: aws.NewConfig(),
-	}
-
-	state = fakeModifyEBSBackedInstanceState()
-	state.Put("ec2", mockConn)
-	stepModifyEBSBackedInstance.Run(context.Background(), state)
-
-	if mockConn.modifyImageAttrCount != 1 {
-		t.Fatalf("Should have modified image, since EnableAMIENASupport is true")
-	}
-
-	// Value is false, so we should modify
-	stepModifyEBSBackedInstance = StepModifyEBSBackedInstance{
-		EnableAMIENASupport:      helperconfig.TriFalse,
-		EnableAMISriovNetSupport: false,
-	}
-
-	// mock out the region connection code
-	mockConn = &mockEC2Conn_ModifyEBS{
-		Config: aws.NewConfig(),
-	}
-
-	state = fakeModifyEBSBackedInstanceState()
-	state.Put("ec2", mockConn)
-	stepModifyEBSBackedInstance.Run(context.Background(), state)
-
-	if mockConn.modifyImageAttrCount != 1 {
-		t.Fatalf("Should have modified image, since EnableAMIENASupport is true")
-	}
-}

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"
 )
@@ -18,89 +14,35 @@ import (
 // the build before actually doing any time consuming work
 //
 type StepPreValidate struct {
-	DestAmiName        string
-	ForceDeregister    bool
-	AMISkipBuildRegion bool
+	DestAmiName     string
+	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
 	}
-	if s.AMISkipBuildRegion {
-		ui.Say("skip_build_region was set; not prevalidating AMI name")
-		return multistep.ActionContinue
-	}
 
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 
 	ui.Say(fmt.Sprintf("Prevalidating AMI Name: %s", s.DestAmiName))
-	req, resp := ec2conn.DescribeImagesRequest(&ec2.DescribeImagesInput{
+	resp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{
 		Filters: []*ec2.Filter{{
 			Name:   aws.String("name"),
 			Values: []*string{aws.String(s.DestAmiName)},
 		}}})
-	req.RetryCount = 11
 
-	err := req.Send()
 	if err != nil {
 		err := fmt.Errorf("Error querying AMI: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
+
 	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