Cut version 1.0.0-rc1

When using ssh_key_name, ssh_private_key file must be given,
or ssh_agent_auth enabled.

When automatically retrieving the winrm password, if ssh_key_name is
given, ssh_private_key_file must also be given.

.gitattributes

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

.github/CONTRIBUTING.md

@@ -1,217 +0,0 @@
-# Contributing to Packer
-
-**First:** if you're unsure or afraid of _anything_, just ask or submit the
-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.
-
-However, for those individuals who want a bit more guidance on the best way to
-contribute to the project, read on. This document will cover what we're looking
-for. By addressing all the points we're looking for, it raises the chances we
-can quickly merge or address your contributions.
-
-## Issues
-
-### Reporting an Issue
-
-* Make sure you test against the latest released version. It is possible we
-  already fixed the bug you're experiencing.
-
-* Run the command with debug output with the environment variable `PACKER_LOG`.
-  For example: `PACKER_LOG=1 packer build template.json`. Take the _entire_
-  output and create a [gist](https://gist.github.com) for linking to in your
-  issue. Packer should strip sensitive keys from the output, but take a look
-  through just in case.
-
-* Provide a reproducible test case. If a contributor can't reproduce an issue,
-  then it dramatically lowers the chances it'll get fixed. And in some cases,
-  the issue will eventually be closed.
-
-* Respond promptly to any questions made by the Packer team to your issue. Stale
-  issues will be closed.
-
-### Issue Lifecycle
-
-1. The issue is reported.
-
-2. The issue is verified and categorized by a Packer collaborator.
-   Categorization is done via tags. For example, bugs are marked as "bugs" and
-   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.
-
-4. The issue is addressed in a pull request or commit. The issue will be
-   referenced in the commit message so that the code that fixes it is clearly
-   linked.
-
-5. The issue is closed.
-
-## Setting up Go to work on Packer
-
-If you have never worked with Go before, you will have to complete the following
-steps in order to be able to compile and test Packer. These instructions target
-POSIX-like environments (Mac OS X, Linux, Cygwin, etc.) so you may need to
-adjust them for Windows or other shells.
-
-1. [Download](https://golang.org/dl) and install Go. The instructions below are
-   for go 1.7. Earlier versions of Go are no longer supported.
-
-2. Set and export the `GOPATH` environment variable and update your `PATH`. For
-   example, you can add the following to your `.bash_profile` (or comparable
-   shell startup scripts):
-
-```
-export GOPATH=$HOME/go
-export PATH=$PATH:$GOPATH/bin
-```
-
-3. 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`.
-
-4. When working on Packer, first `cd $GOPATH/src/github.com/hashicorp/packer`
-   so you can run `make` and easily access other files. Run `make help` to get
-   information about make targets.
-
-5. Make your changes to the Packer source. You can run `make` in
-   `$GOPATH/src/github.com/hashicorp/packer` to run tests and build the Packer
-   binary. Any compilation errors will be shown when the binaries are
-   rebuilding. If you don't have `make` you can simply run
-   `go build -o bin/packer .` from the project root.
-
-6. After running building Packer successfully, use
-   `$GOPATH/src/github.com/hashicorp/packer/bin/packer` to build a machine and
-   verify your changes work. For instance:
-   `$GOPATH/src/github.com/hashicorp/packer/bin/packer build template.json`.
-
-7. If everything works well and the tests pass, run `go fmt` on your code before
-   submitting a pull-request.
-
-### Opening an Pull Request
-
-Thank you for contributing! When you are ready to open a pull-request, you will
-need to [fork
-Packer](https://github.com/hashicorp/packer#fork-destination-box), push your
-changes to your fork, and then open a pull-request.
-
-For example, my github username is `cbednarski`, so I would do the following:
-
-```
-git checkout -b f-my-feature
-# Develop a patch.
-git push https://github.com/cbednarski/Packer f-my-feature
-```
-
-From there, open your fork in your browser to open a new pull-request.
-
-**Note:** Go infers package names from their file paths. This means `go build`
-will break if you `git clone` your fork instead of using `go get` on the main
-Packer project.
-
-### Pull Request Lifecycle
-
-1. You are welcome to submit your pull request for commentary or review before
-  it is fully completed. Please prefix the title of your pull request with
-  "[WIP]" to indicate this. It's also a good idea to include specific questions
-  or items you'd like feedback on.
-
-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. 
-
-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.
-
-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 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
-
-#### 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 `$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.
-
-#### Govendor
-
-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 [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 `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.
-
-#### Running Unit Tests
-
-You can run tests for individual packages using commands like this:
-
-```
-make test TEST=./builder/amazon/...
-```
-
-#### Running Acceptance Tests
-
-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 verify it is
-functioning (and also hasn't broken anything else), we recommend running the
-acceptance tests.
-
-**Warning:** The acceptance tests create/destroy/modify _real resources_, which
-may incur costs for real money. In the presence of a bug, it is possible that
-resources may be left behind, which can cost money even though you were not
-using them. We recommend running tests in an account used only for that purpose
-so it is easy to see if there are any dangling resources, and so production
-resources are not accidentally destroyed or overwritten during testing.
-
-To run the acceptance tests, invoke `make testacc`:
-
-```
-make testacc TEST=./builder/amazon/ebs
-...
-```
-
-The `TEST` variable lets you narrow the scope of the acceptance tests to a
-specific package / folder. The `TESTARGS` variable is recommended to filter down
-to a specific resource to test, since testing all of them at once can sometimes
-take a very long time.
-
-To run only a specific test, use the `-run` argument:
-
-```
-make testacc TEST=./builder/amazon/ebs TESTARGS="-run TestBuilderAcc_forceDeleteSnapshot"
-```
-
-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.

.github/ISSUE_TEMPLATE.md

@@ -1,11 +1,6 @@
-_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.
+_Only use Github issues to report bugs or feature requests, see https://www.packer.io/community/_
 
 If you are planning to open a pull-request just open the pull-request instead of making an issue first.
 
@@ -23,4 +18,3 @@ Describe the problem and include the following information:
   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/PULL_REQUEST_TEMPLATE.md

@@ -4,8 +4,8 @@ Describe the change you are making here!
 
 Please include tests. Check out these examples:
 
-- https://github.com/hashicorp/packer/blob/master/builder/virtualbox/common/ssh_config_test.go#L19-L37
-- https://github.com/hashicorp/packer/blob/master/post-processor/compress/post-processor_test.go#L153-L182
+- https://github.com/mitchellh/packer/blob/master/builder/virtualbox/common/ssh_config_test.go#L19-L37
+- https://github.com/mitchellh/packer/blob/master/post-processor/compress/post-processor_test.go#L153-L182
 
 If your PR resolves any open issue(s), please indicate them like this so they will be closed when your PR is merged:
 

.gitignore

@@ -10,7 +10,6 @@
 test/.env
 *~
 *.received.*
-*.swp
 
 website/.bundle
 website/vendor
@@ -22,6 +21,3 @@ packer-test*.log
 
 .idea/
 *.iml
-Thumbs.db
-/packer.exe
-.project

.travis.yml

@@ -6,10 +6,8 @@ sudo: false
 language: go
 
 go:
-  - 1.8.x
-  - 1.9.x
-  - 1.x
-
+  - 1.7.4
+  - 1.8
 
 install:
   - make deps
@@ -23,3 +21,5 @@ branches:
 
 matrix:
   fast_finish: true
+  allow_failures:
+    - go: 1.4.3

CHANGELOG.md

@@ -1,779 +1,62 @@
-## 1.2.4 (May 29, 2018)
+## 1.0rc1 (March 16, 2017)
 
 ### BUG FIXES:
 
-* builder/amazon: Can now force the chroot builder to mount an entire block
-    device instead of a partition [GH-6194]
-* builder/azure: windows-sql-cloud is now in the default list of projects to
-    check for provided images. [GH-6210]
-* builder/chroot: A new template option, `nvme_device_path` has been added to
-    provide a workaround for users who need the amazon-chroot builder to mount
-    a NVMe volume on their instances. [GH-6295]
-* builder/hyper-v: Fix command for mounting multiple disks [GH-6267]
-* builder/hyperv: Enable IP retrieval for Server 2008 R2 hosts. [GH-6219]
-* builder/hyperv: Fix bug in MAC address specification on Hyper-V. [GH-6187]
-* builder/parallels-pvm: Add missing disk compaction step. [GH-6202]
-* builder/vmware-esxi: Remove floppy files from the remote server on cleanup.
-    [GH-6206]
-* communicator/winrm: Updated dependencies to fix a race condition [GH-6261]
-* core: When using `-on-error=[abort|ask]`, output the error to the user.
-    [GH-6252]
-* provisioner/puppet: Extra-Arguments are no longer prematurely
-    interpolated.[GH-6215]
-* provisioner/shell: Remove file stat that was causing problems uploading files
-    [GH-6239]
-
-### IMPROVEMENTS:
-
-* builder/amazon: Amazon builders other than `chroot` now support T2 unlimited
-    instances [GH-6265]
-* builder/azure: Allow device login for US government cloud. [GH-6105]
-* builder/azure: Devicelogin Support for Windows [GH-6285]
-* builder/azure: Enable simultaneous builds within one resource group.
-    [GH-6231]
-* builder/azure: Faster deletion of Azure Resource Groups. [GH-6269]
-* builder/azure: Updated Azure SDK to v15.0.0 [GH-6224]
-* builder/hyper-v: Hyper-V builds now connect to vnc display by default when
-    building [GH-6243]
-* builder/hyper-v: New `use_fixed_vhd_format` allows vm export in an Azure-
-    compatible format [GH-6101]
-* builder/hyperv: New config option for specifying what secure boot template to
-    use, allowing secure boot of linux vms. [GH-5883]
-* builder/qemu: Add support for hvf accelerator. [GH-6193]
-* builder/scaleway: Fix SSH communicator connection issue. [GH-6238]
-* core: Add opt-in Packer top-level command autocomplete [GH-5454]
-* post-processor/shell-local: New options have been added to create feature
-    parity with the shell-local provisioner. This feature now works on Windows
-    hosts. [GH-5956]
-* provisioner/chef: New config option allows user to skip cleanup of chef
-    client staging directory. [GH-4300]
-* provisioner/shell-local: Can now access automatically-generated WinRM
-    password as variable [GH-6251]
-* provisoner/shell-local: New options have been added to create feature parity
-    with the shell-local post-processor. This feature now works on Windows
-    hosts. [GH-5956]
-
-## 1.2.3 (April 25, 2018)
-
-### BUG FIXES:
-
-* builder/azure: Azure CLI may now be logged into several accounts. [GH-6087]
-* builder/ebssurrogate: Snapshot all launch devices. [GH-6056]
-* builder/hyper-v: Fix CopyExportedVirtualMachine script so it works with
-    links. [GH-6082]
-* builder/oracle-classic: Fix panics when cleaning up resources that haven't
-    been created. [GH-6095]
-* builder/parallels: Allow user to cancel build while the OS is starting up.
-    [GH-6166]
-* builder/qemu: Avoid warning when using raw format. [GH-6080]
-* builder/scaleway: Fix compilation issues on solaris/amd64. [GH-6069]
-* builder/virtualbox: Fix broken scancodes in boot_command. [GH-6067]
-* builder/vmware-iso: Fail in validation if user gives wrong remote_type value.
-    [GH-4563]
-* builder/vmware: Fixed a case-sensitivity issue when determing the network
-    type during the cloning step in the vmware-vmx builder. [GH-6057]
-* builder/vmware: Fixes the DHCP lease and configuration pathfinders for VMware
-    Player. [GH-6096]
-* builder/vmware: Multi-disk VM's can be properly handled by the compacting
-    stage. [GH-6074]
-* common/bootcommand: Fix numerous bugs in the boot command code, and make
-    supported features consistent across builders. [GH-6129]
-* communicator/ssh: Stop trying to discover whether destination is a directory
-    from uploader. [GH-6124]
-* post-processor/vagrant: Large VMDKs should no longer show a 0-byte size on OS
-    X. [GH-6084]
-* post-processor/vsphere: Fix encoding of spaces in passwords for upload.
-    [GH-6110]
-* provisioner/ansible: Pass the inventory_directory configuration option to
-    ansible -i when it is set. [GH-6065]
-* provisioner/powershell: fix bug with SSH communicator + cygwin. [GH-6160]
-* provisioner/powershell: The {{.WinRMPassword}} template variable now works
-    with parallel builders. [GH-6144]
-
-### IMPROVEMENTS:
-
-* builder/alicloud: Update aliyungo common package. [GH-6157]
-* builder/amazon: Expose more source ami data as template variables. [GH-6088]
-* builder/amazon: Setting `force_delete` will only delete AMIs owned by the
-    user. This should prevent failures where we try to delete an AMI with a
-    matching name, but owned by someone else. [GH-6111]
-* builder/azure: Users of Powershell provisioner may access the randomly-
-    generated winrm password using the template variable {{.WinRMPassword}}.
-    [GH-6113]
-* builder/google: Users of Powershell provisioner may access the randomly-
-    generated winrm password using the template variable {{.WinRMPassword}}.
-    [GH-6141]
-* builder/hyper-v: User can now configure hyper-v disk block size. [GH-5941]
-* builder/openstack: Add configuration option for `instance_name`. [GH-6041]
-* builder/oracle-classic: Better validation of destination image name.
-    [GH-6089]
-* builder/oracle-oci: New config options for user data and user data file.
-    [GH-6079]
-* builder/oracle-oci: use the official OCI sdk instead of handcrafted client.
-    [GH-6142]
-* builder/triton: Add support to Skip TLS Verification of Triton Certificate.
-    [GH-6039]
-* provisioner/ansible: Ansible users may provide a custom inventory file.
-    [GH-6107]
-* provisioner/file: New `generated` tag allows users to upload files created
-    during Packer run. [GH-3891]
-
-## 1.2.2 (March 26, 2018)
-
-### BUG FIXES:
-
-* builder/amazon: Fix AWS credential defaulting [GH-6019]
-* builder/LXC: make sleep timeout easily configurable [GH-6038]
-* builder/virtualbox: Correctly send multi-byte scancodes when typing boot
-    command. [GH-5987]
-* builder/virtualbox: Special boot-commands no longer overwrite previous
-    commands [GH-6002]
-* builder/vmware: Default to disabling XHCI bus for USB on the vmware-iso
-    builder. [GH-5975]
-* builder/vmware: Handle multiple devices per VMware network type [GH-5985]
-* communicator/ssh: Handle errors uploading files more gracefully [GH-6033]
-* provisioner/powershell: Fix environment variable file escaping. [GH-5973]
-
-
-### IMPROVEMENTS:
-
-* builder/amazon: Added new region `cn-northwest-1`. [GH-5960]
-* builder/amazon: Users may now access the amazon-generated administrator
-    password [GH-5998]
-* builder/azure: Add support concurrent deployments in the same resource group.
-    [GH-6005]
-* builder/azure: Add support for building with additional disks. [GH-5944]
-* builder/azure: Add support for marketplace plan information. [GH-5970]
-* builder/azure: Make all command output human readable. [GH-5967]
-* builder/azure: Respect `-force` for managed image deletion. [GH-6003]
-* builder/google: Add option to specify a service account, or to run without
-    one. [GH-5991] [GH-5928]
-* builder/oracle-oci: Add new "use_private_ip" option. [GH-5893]
-* post-processor/vagrant: Add LXC support. [GH-5980]
-* provisioner/salt-masterless: Added Windows support. [GH-5702]
-* provisioner/salt: Add windows support to salt provisioner [GH-6012] [GH-6012]
-
-
-## 1.2.1 (February 23, 2018)
-
-### BUG FIXES:
-
-* builder/amazon: Fix authorization using assume role. [GH-5914]
-* builder/hyper-v: Fix command collisions with VMWare PowerCLI. [GH-5861]
-* builder/vmware-iso: Fix panic when building on esx5 remotes. [GH-5931]
-* builder/vmware: Fix issue detecting host IP. [GH-5898] [GH-5900]
-* provisioner/ansible-local: Fix conflicting escaping schemes for vars provided
-    via `--extra-vars`. [GH-5888]
-
-### IMPROVEMENTS:
-
-* builder/oracle-classic: Add `snapshot_timeout` option to control how long we
-    wait for the snapshot to be created. [GH-5932]
-* builder/oracle-classic: Add support for WinRM connections. [GH-5929]
-
-
-## 1.2.0 (February 9, 2018)
-
-### BACKWARDS INCOMPATIBILITIES:
-
-* 3rd party plugins: We have moved internal dependencies, meaning your 3rd
-    party plugins will no longer compile (however existing builds will still
-    work fine); the work to fix them is minimal and documented in GH-5810.
-    [GH-5810]
-* builder/amazon: The `ssh_private_ip` option has been removed. Instead, please
-    use `"ssh_interface": "private"`. A fixer has been written for this, which
-    can be invoked with `packer fix`. [GH-5876]
-* builder/openstack: Extension support has been removed. To use OpenStack
-    builder with the OpenStack Newton (Oct 2016) or earlier, we recommend you
-    use Packer v1.1.2 or earlier version.
-* core: Affects Windows guests: User variables containing Powershell special
-    characters no longer need to be escaped.[GH-5376]
-* provisioner/file: We've made destination semantics more consistent across the
-    various communicators. In general, if the destination is a directory, files
-    will be uploaded into the directory instead of failing. This mirrors the
-    behavior of `rsync`. There's a chance some users might be depending on the
-    previous buggy behavior, so it's worth ensuring your configuration is
-    correct. [GH-5426]
-* provisioner/powershell: Regression from v1.1.1 forcing extra escaping of
-    environment variables in the non-elevated provisioner has been fixed.
-    [GH-5515] [GH-5872]
-
-### IMPROVEMENTS:
-
-* **New builder:** `ncloud` for building server images using the NAVER Cloud
-    Platform. [GH-5791]
-* **New builder:** `oci-classic` for building new custom images for use with
-    Oracle Cloud Infrastructure Classic Compute. [GH-5819]
-* **New builder:** `scaleway` - The Scaleway Packer builder is able to create
-    new images for use with Scaleway BareMetal and Virtual cloud server.
-    [GH-4770]
-* builder/amazon: Add `kms_key_id` option to block device mappings. [GH-5774]
-* builder/amazon: Add `skip_metadata_api_check` option to skip consulting the
-    amazon metadata service. [GH-5764]
-* builder/amazon: Add Paris region (eu-west-3) [GH-5718]
-* builder/amazon: Give better error messages if we have trouble during
-    authentication. [GH-5764]
-* builder/amazon: Remove Session Token (STS) from being shown in the log.
-    [GH-5665]
-* builder/amazon: Replace `InstanceStatusOK` check with `InstanceReady`. This
-    reduces build times universally while still working for all instance types.
-    [GH-5678]
-* builder/amazon: Report which authentication provider we're using. [GH-5764]
-* builder/amazon: Timeout early if metadata service can't be reached. [GH-5764]
-* builder/amazon: Warn during prepare if we didn't get both an access key and a
-    secret key when we were expecting one. [GH-5762]
-* builder/azure: Add validation for incorrect VHD URLs [GH-5695]
-* builder/docker: Remove credentials from being shown in the log. [GH-5666]
-* builder/google: Support specifying licenses for images. [GH-5842]
-* builder/hyper-v: Allow MAC address specification. [GH-5709]
-* builder/hyper-v: New option to use differential disks and Inline disk
-    creation to improve build time and reduce disk usage [GH-5631]
-* builder/qemu: Add Intel HAXM support to QEMU builder [GH-5738]
-* builder/triton: Triton RBAC is now supported. [GH-5741]
-* builder/triton: Updated triton-go dependencies, allowing better error
-    handling. [GH-5795]
-* builder/vmware-iso: Add support for cdrom and disk adapter types. [GH-3417]
-* builder/vmware-iso: Add support for setting network type and network adapter
-    type. [GH-3417]
-* builder/vmware-iso: Add support for usb/serial/parallel ports. [GH-3417]
-* builder/vmware-iso: Add support for virtual soundcards. [GH-3417]
-* builder/vmware-iso: More reliably retrieve the guest networking
-    configuration. [GH-3417]
-* builder/vmware: Add support for "super" key in `boot_command`. [GH-5681]
-* communicator/ssh: Add session-level keep-alives [GH-5830]
-* communicator/ssh: Detect dead connections. [GH-4709]
-* core: Gracefully clean up resources on SIGTERM. [GH-5318]
-* core: Improved error logging in floppy file handling. [GH-5802]
-* core: Improved support for downloading and validating a uri containing a
-    Windows UNC path or a relative file:// scheme. [GH-2906]
-* post-processor/amazon-import: Allow user to specify role name in amazon-
-    import [GH-5817]
-* post-processor/docker: Remove credentials from being shown in the log.
-    [GH-5666]
-* post-processor/google-export: Synchronize credential semantics with the
-    Google builder. [GH-4148]
-* post-processor/vagrant: Add vagrant post-processor support for Google
-    [GH-5732]
-* post-processor/vsphere-template: Now accepts artifacts from the vSphere post-
-    processor. [GH-5380]
-* provisioner/amazon: Use Amazon SDK's InstanceRunning waiter instead of
-    InstanceStatusOK waiter [GH-5773]
-* provisioner/ansible: Improve user retrieval. [GH-5758]
-* provisioner/chef: Add support for 'trusted_certs_dir' chef-client
-    configuration option [GH-5790]
-* provisioner/chef: Added Policyfile support to chef-client provisioner.
-    [GH-5831]
-
-### BUG FIXES:
-
-* builder/alicloud-ecs: Attach keypair before starting instance in alicloud
-    builder [GH-5739]
-* builder/amazon: Fix tagging support when building in us-gov/china. [GH-5841]
-* builder/amazon: NewSession now inherits MaxRetries and other settings.
-    [GH-5719]
-* builder/virtualbox: Fix interpolation ordering so that edge cases around
-    guest_additions_url are handled correctly [GH-5757]
-* builder/virtualbox: Fix regression affecting users running Packer on a
-    Windows host that kept Packer from finding Virtualbox guest additions if
-    Packer ran on a different drive from the one where the guest additions were
-    stored. [GH-5761]
-* builder/vmware: Fix case where artifacts might not be cleaned up correctly.
-    [GH-5835]
-* builder/vmware: Fixed file handle leak that may have caused race conditions
-    in vmware builder [GH-5767]
-* communicator/ssh: Add deadline to SSH connection to prevent Packer hangs
-    after script provisioner reboots vm [GH-4684]
-* communicator/winrm: Fix issue copying empty directories. [GH-5763]
-* provisioner/ansible-local: Fix support for `--extra-vars` in
-    `extra_arguments`. [GH-5703]
-* provisioner/ansible-remote: Fixes an error where Packer's private key can be
-    overridden by inherited `ansible_ssh_private_key` options. [GH-5869]
-* provisioner/ansible: The "default extra variables" feature added in Packer
-    v1.0.1 caused the ansible-local provisioner to fail when an --extra-vars
-    argument was specified in the extra_arguments configuration option; this
-    has been fixed. [GH-5335]
-* provisioner/powershell: Regression from v1.1.1 forcing extra escaping of
-    environment variables in the non-elevated provisioner has been fixed.
-    [GH-5515] [GH-5872]
-
-
-## 1.1.3 (December 8, 2017)
-
-### IMPROVEMENTS:
-
-* builder/alicloud-ecs: Add security token support and set TLS handshake
-    timeout through environment variable. [GH-5641]
-* builder/amazon: Add a new parameter `ssh_interface`. Valid values include
-    `public_ip`, `private_ip`, `public_dns` or `private_dns`. [GH-5630]
-* builder/azure: Add sanity checks for resource group names [GH-5599]
-* builder/azure: Allow users to specify an existing resource group to use,
-    instead of creating a new one for every run. [GH-5548]
-* builder/hyper-v: Add support for differencing disk. [GH-5458]
-* builder/vmware-iso: Improve logging of network errors. [GH-5456]
-* core: Add new `packer_version` template engine. [GH-5619]
-* core: Improve logic checking for downloaded ISOs in case where user has
-    provided more than one URL in `iso_urls` [GH-5632]
-* provisioner/ansible-local: Add ability to clean staging directory. [GH-5618]
-
-### BUG FIXES:
-
-* builder/amazon: Allow `region` to appear in `ami_regions`. [GH-5660]
-* builder/amazon: `C5` instance types now build more reliably. [GH-5678]
-* builder/amazon: Correctly set AWS region if given in template along with a
-    profile. [GH-5676]
-* builder/amazon: Prevent `sriov_support` and `ena_support` from being used
-    with spot instances, which would cause a build failure. [GH-5679]
-* builder/hyper-v: Fix interpolation context for user variables in
-    `boot_command` [GH-5547]
-* builder/qemu: Set default disk size to 40960 MB to prevent boot failures.
-    [GH-5588]
-* builder/vmware: Correctly detect Windows boot on vmware workstation.
-    [GH-5672]
-* core: Fix windows path regression when downloading ISOs. [GH-5591]
-* provisioner/chef: Fix chef installs on Windows. [GH-5649]
-
-## 1.1.2 (November 15, 2017)
-
-### IMPROVEMENTS:
-
-* builder/amazon: Correctly deregister AMIs when `force_deregister` is set.
-    [GH-5525]
-* builder/digitalocean: Add `ipv6` option to enable on droplet. [GH-5534]
-* builder/docker: Add `aws_profile` option to control the aws profile for ECR.
-    [GH-5470]
-* builder/google: Add `clean_image_name` template engine. [GH-5463]
-* builder/google: Allow selecting container optimized images. [GH-5576]
-* builder/google: Interpolate network and subnetwork values, rather than
-    relying on an API call that packer may not have permission for. [GH-5343]
-* builder/hyper-v: Add `disk_additional_size` option to allow for up to 64
-    additional disks. [GH-5491]
-* builder/hyper-v: Also disable automatic checkpoints for gen 2 VMs. [GH-5517]
-* builder/lxc: Add new `publish_properties` field to set image properties.
-    [GH-5475]
-* builder/lxc: Add three new configuration option categories to LXC builder:
-    `create_options`, `start_options`, and `attach_options`. [GH-5530]
-* builder/triton: Add `source_machine_image_filter` option to select an image
-    ID based on a variety of parameters. [GH-5538]
-* builder/virtualbox-ovf: Error during prepare if source path doesn't exist.
-    [GH-5573]
-* builder/virtualbox-ovf: Retry while removing VM to solve for transient
-    errors. [GH-5512]
-* communicator/ssh: Add socks 5 proxy support. [GH-5439]
-* core/iso_config: Support relative paths in checksum file. [GH-5578]
-* core: Rewrite vagrantfile code to make cross-platform development easier.
-    [GH-5539]
-* post-processor/docker-push: Add `aws_profile` option to control the aws
-    profile for ECR. [GH-5470]
-* post-processor/vsphere: Properly capture `ovftool` output. [GH-5499]
-
-### BUG FIXES:
-
-* builder/amazon: Add a delay option to security group waiter. [GH-5536]
-* builder/amazon: Fix regressions relating to spot instances and EBS volumes.
-    [GH-5495]
-* builder/amazon: Set region from profile, if profile is set, rather than being
-    overridden by metadata. [GH-5562]
-* builder/docker: Remove `login_email`, which no longer exists in the docker
-    client. [GH-5511]
-* builder/hyperv: Fix admin check that was causing powershell failures.
-    [GH-5510]
-* builder/oracle: Defaulting of OCI builder region will first check the packer
-    template and the OCI config file. [GH-5407]
-* builder/triton: Fix a bug where partially created images can be reported as
-    complete. [GH-5566]
-* post-processor/vsphere: Use the vm disk path information to re-create the vmx
-    datastore path. [GH-5567]
-* provisioner/windows-restart: Wait for restart no longer endlessly loops if
-    user specifies a custom restart check command. [GH-5563]
-
-## 1.1.1 (October 13, 2017)
-
-### IMPROVEMENTS:
-
-* **New builder:** `hyperv-vmcx` for building images from existing VMs.
-    [GH-4944] [GH-5444]
-* builder/amazon-instance: Add `.Token` as a variable in the
-    `BundleUploadCommand` template. [GH-5288]
-* builder/amazon: Add `temporary_security_group_source_cidr` option to control
-    ingress to source instances. [GH-5384]
-* builder/amazon: Output AMI Name during prevalidation. [GH-5389]
-* builder/amazon: Support template functions in tag keys. [GH-5381]
-* builder/amazon: Tag volumes on creation instead of as a separate step.
-    [GH-5417]
-* builder/docker: Add option to set `--user` flag when running `exec`.
-    [GH-5406]
-* builder/docker: Set file owner to container user when uploading. Can be
-    disabled by setting `fix_upload_owner` to `false`. [GH-5422]
-* builder/googlecompute: Support setting labels on the resulting image.
-    [GH-5356]
-* builder/hyper-v: Add `vhd_temp_path` option to control where the VHD resides
-    while it's being provisioned. [GH-5206]
-* builder/hyper-v: Allow vhd or vhdx source images instead of just ISO.
-    [GH-4944] [GH-5444]
-* builder/hyper-v: Disable automatic checkpoints. [GH-5374]
-* builder/virtualbox-ovf: Add `keep_registered` option. [GH-5336]
-* builder/vmware: Add `disable_vnc` option to prevent VNC connections from
-    being made. [GH-5436]
-* core: Releases will now be built for ppc64le.
-* post-processor/vagrant: When building from a builder/hyper-v artifact, link
-    instead of copy when available. [GH-5207]
-
-
-### BUG FIXES:
-
-* builder/cloudstack: Fix panic if build is aborted. [GH-5388]
-* builder/hyper-v: Respect `enable_dynamic_memory` flag. [GH-5363]
-* builder/puppet-masterless: Make sure directories created with sudo are
-    writable by the packer user. [GH-5351]
-* provisioner/chef-solo: Fix issue installing chef-solo on Windows. [GH-5357]
-* provisioner/powershell: Fix issue setting environment variables by writing
-    them to a file, instead of the command line. [GH-5345]
-* provisioner/powershell: Fix issue where powershell scripts could hang.
-    [GH-5082]
-* provisioner/powershell: Fix Powershell progress stream leak to stderr for
-    normal and elevated commands. [GH-5365]
-* provisioner/puppet-masterless: Fix bug where `puppet_bin_dir` wasn't being
-    respected. [GH-5340]
-* provisioner/puppet: Fix setting facter vars on Windows. [GH-5341]
-
-
-## 1.1.0 (September 12, 2017)
-
-### IMPROVEMENTS:
-
-* builder/alicloud: Update alicloud go sdk and enable multi sites support for
-    alicloud [GH-5219]
-* builder/amazon: Upgrade aws-sdk-go to 1.10.14, add tags at instance run time.
-    [GH-5196]
-* builder/azure: Add object_id to windows_custom_image.json. [GH-5285]
-* builder/azure: Add support for storage account for managed images. [GH-5244]
-* builder/azure: Update pkcs12 package. [GH-5301]
-* builder/cloudstack: Add support for Security Groups. [GH-5175]
-* builder/docker: Uploading files and directories now use docker cp. [GH-5273]
-    [GH-5333]
-* builder/googlecompute: Add `labels` option for labeling launched instances.
-    [GH-5308]
-* builder/googlecompute: Add support for accelerator api. [GH-5137]
-* builder/profitbricks: added support for Cloud API v4. [GH-5233]
-* builder/vmware-esxi: Remote builds now respect `output_directory` [GH-4592]
-* builder/vmware: Set artifact ID to `VMName`. [GH-5187]
-* core: Build solaris binary by default. [GH-5268] [GH-5248]
-* core: Remove LGPL dependencies. [GH-5262]
-* provisioner/puppet: Add `guest_os_type` option to add support for Windows.
-    [GH-5252]
-* provisioner/salt-masterless: Also use sudo to clean up if we used sudo to
-    install. [GH-5240]
-
-### BACKWARDS INCOMPATIBILITIES:
-
-* builder/amazon: Changes way that AMI artifacts are printed out after build,
-    aligning them to builder. Could affect output parsing. [GH-5281]
-* builder/amazon: Split `enhanced_networking` into `sriov_support` and
-    `ena_support` to support finer grained control. Use `packer fix
-    <template.json>` to automatically update your template to use `ena_support`
-    where previously there was only `enhanced_networking`. Make sure to also
-    add `sriov_support` if you need that feature, and to ensure `ena_support`
-    is what you intended to be in your template. [GH-5284]
-* builder/cloudstack: Setup temporary SSH keypair; backwards incompatible in
-    the uncommon case that the source image allowed SSH auth with password but
-    not with keypair. [GH-5174]
-* communicator/ssh: Renamed `ssh_disable_agent` to
-    `ssh_disable_agent_forwarding`. Need to run fixer on packer configs that
-    use `ssh_disable_agent`. [GH-5024]
-* communicator: Preserve left-sided white-space in remote command output. Make
-    sure any scripts that parse this output can handle the new whitespace
-    before upgrading. [GH-5167]
-* provisioner/shell: Set default for `ExpectDisconnect` to `false`. If your
-    script causes the connection to be reset, you should set this to `true` to
-    prevent errors. [GH-5283]
-
-### BUG FIXES:
-
-* builder/amazon: `force_deregister` works in all regions, not just original
-    region. [GH-5250]
-* builder/docker: Directory uploads now use the same semantics as the rest of
-    the communicators. [GH-5333]
-* builder/vmware: Fix timestamp in default VMName. [GH-5274]
-* builder/winrm: WinRM now waits to make sure commands can run successfully
-    before considering itself connected. [GH-5300]
-* core: Fix issue where some builders wouldn't respect `-on-error` behavior.
-    [GH-5297]
-* provisioner/windows-restart: The first powershell provisioner after a restart
-    now works. [GH-5272]
-
-### FEATURES:
-
-* **New builder**: Oracle Cloud Infrastructure (OCI) builder for creating
-    custom images. [GH-4554]
-* **New builder:** `lxc` for building lxc images. [GH-3523]
-* **New builder:** `lxd` for building lxd images. [GH-3625]
-* **New post-processor**: vSphere Template post-processor to be used with
-    vmware-iso builder enabling user to mark a VM as a template. [GH-5114]
-
-## 1.0.4 (August 11, 2017)
-
-### IMPROVEMENTS:
-
-* builder/alicloud: Increase polling timeout. [GH-5148]
-* builder/azure: Add `private_virtual_network_with_public_ip` option to
-    optionally obtain a public IP. [GH-5222]
-* builder/googlecompute: use a more portable method of obtaining zone.
-    [GH-5192]
-* builder/hyperv: Properly interpolate user variables in template. [GH-5184]
-* builder/parallels: Remove soon to be removed --vmtype flag in createvm.
-    [GH-5172]
-* contrib: add json files to zsh completion. [GH-5195]
-
-### BUG FIXES:
-
-* builder/amazon: Don't delete snapshots we didn't create. [GH-5211]
-* builder/amazon: fix builds when using the null communicator. [GH-5217]
-* builder/docker: Correctly handle case when uploading an empty directory.
-    [GH-5234]
-* command/push: Don't push variables if they are unspecified. Reverts to
-    behavior in 1.0.1. [GH-5235]
-* command/push: fix handling of symlinks. [GH-5226]
-* core: Strip query parameters from ISO URLs when checking against a checksum
-    file. [GH-5181]
-* provisioner/ansible-remote: Fix issue where packer could hang communicating
-    with ansible-remote. [GH-5146]
-
-## 1.0.3 (July 17, 2017)
-
-### IMPROVEMENTS:
-* builder/azure: Update to latest Azure SDK, enabling support for managed
-    disks. [GH-4511]
-* builder/cloudstack: Add default cidr_list [ 0.0.0.0/0 ]. [GH-5125]
-* builder/cloudstack: Add support for ssh_agent_auth. [GH-5130]
-* builder/cloudstack: Add support for using a HTTP server. [GH-5017]
-* builder/cloudstack: Allow reading api_url, api_key, and secret_key from env
-    vars. [GH-5124]
-* builder/cloudstack: Make expunge optional and improve logging output.
-    [GH-5099]
-* builder/googlecompute: Allow using URL's for network and subnetwork.
-    [GH-5035]
-* builder/hyperv: Add support for floppy_dirs with hyperv-iso builder.
-* builder/hyperv: Add support for override of system %temp% path.
-* core: Experimental Android ARM support. [GH-5111]
-* post-processor/atlas: Disallow packer push of vagrant.box artifacts to atlas.
-    [GH-4780]
-* postprocessor/atlas: Disallow pushing vagrant.box artifacts now that Vagrant
-    cloud is live. [GH-4780]
-
-### BUG FIXES:
-* builder/amazon: Fix panic that happens if ami_block_device_mappings is empty.
-    [GH-5059]
-* builder/azure: Write private SSH to file in debug mode. [GH-5070] [GH-5074]
-* builder/cloudstack: Properly report back errors. [GH-5103] [GH-5123]
-* builder/docker: Fix windows filepath in docker-toolbox call [GH-4887]
-* builder/docker: Fix windows filepath in docker-toolbox call. [GH-4887]
-* builder/hyperv: Use SID to verify membership in Admin group, fixing for non-
-    english users. [GH-5022]
-* builder/hyperv: Verify membership in the group Hyper-V Administrators by SID
-    not name. [GH-5022]
-* builder/openstack: Update gophercloud version, fixing builds  > 1 hr long.
-    [GH-5046]
-* builder/parallels: Skip missing paths when looking for unnecessary files.
-    [GH-5058]
-* builder/vmware-esxi: Fix VNC port discovery default timeout. [GH-5051]
-* communicator/ssh: Add ProvisionerTypes to communicator tests, resolving panic
-    [GH-5116]
-* communicator/ssh: Resolve race condition that sometimes truncates ssh
-    provisioner stdout [GH-4719]
-* post-processor/checksum: Fix interpolation of "output". [GH-5112]
-* push: Push vars in packer config, not just those set from command line and in
-    var-file. [GH-5101]
-
-## 1.0.2 (June 21, 2017)
-
-### BUG FIXES:
-* communicator/ssh: Fix truncated stdout from remote ssh provisioner. [GH-5050]
-* builder/amazon: Fix bugs related to stop instance command. [GH-4719]
-* communicator/ssh: Fix ssh connection errors. [GH-5038]
-* core: Remove logging that shouldn't be there when running commands. [GH-5042]
-* provisioner/shell: Fix bug where scripts were being run under `sh`. [GH-5043]
-
-### IMPROVEMENTS:
-
-* provisioner/windows-restart: make it clear that timeouts come from the
-    provisioner, not winrm. [GH-5040]
-
-## 1.0.1 (June 19, 2017)
-
-### IMPROVEMENTS:
-
-* builder/amazon: Allow amis to be copied to other regions, encrypted with
-    custom KMS keys. [GH-4948]
-* builder/amazon: Allow configuration of api endpoint to support api-compatible
-    cloud providers. [GH-4896]
-* builder/amazon: Fix regex used for ami name validation [GH-4902]
-* builder/amazon: Look up vpc from subnet id if no vpc was specified. [GH-4879]
-* builder/amazon: Print temporary security group name to the UI. [GH-4997]
-* builder/amazon: Support Assume Role with MFA and ECS Task Roles. Also updates
-    to a newer version of aws-sdk-go. [GH-4996]
-* builder/amazon: Use retry logic when creating instance tags. [GH-4876]
-* builder/amazon: Validate ami name. [GH-4762]
-* builder/azure: Add build output to artifact. [GH-4953]
-* builder/azure: Use disk URI as artifact ID. [GH-4981]
-* builder/digitalocean: Added support for monitoring. [GH-4782]
-* builder/digitalocean: Support for copying snapshot to other regions.
-    [GH-4893]
-* builder/hyper-v: Remove the check for administrator rights when sending key
-    strokes to Hyper-V. [GH-4687] # builder/openstack: Fix private key error
-    message to match documentation [GH-4898]
-* builder/null: Support SSH agent auth [GH-4956]
-* builder/openstack: Add ssh agent support. [GH-4655]
-* builder/openstack: Support client x509 certificates. [GH-4921]
-* builder/parallels-iso: Configuration of disk type, plain or expanding.
-    [GH-4621]
-* builder/triton: An SSH agent can be used to authenticate requests, making
-    `triton_key_material` optional. [GH-4838]
-* builder/triton: If no source machine networks are specified, instances are
-    started on the default public and internal networks. [GH-4838]
-* builder/virtualbox: Add sata port count configuration option. [GH-4699]
-* builder/virtualbox: Don't add port forwarding when using "none" communicator.
-    [GH-4960]
-* builder/vmware: Add option to remove interfaces from the vmx. [GH-4927]
-* builder/vmware: Properly remove mounted CDs on OS X. [GH-4810]
-* builder/vmware: VNC probe timeout is configurable. [GH-4919]
-* command/push: add `-sensitive` flag to mark pushed vars are sensitive.
-    [GH-4970]
-* command/push: Vagrant support in Terraform Enterprise is deprecated.
-    [GH-4950]
-* communicator/ssh: Add ssh agent support for bastion connections. [GH-4940]
-* communicator/winrm: Add NTLM authentication support. [GH-4979]
-* communicator/winrm: Add support for file downloads. [GH-4748]
-* core: add telemetry for better product support. [GH-5015]
-* core: Build binaries for arm64 [GH-4892]
-* post-processor/amazon-import: Add support for `license_type`. [GH-4634]
-* post-processor/vagrant-cloud: Get vagrant cloud token from environment.
-    [GH-4982]
-* provisioner/ansible-local: Add extra-vars `packer_build_name`,
-    `packer_builder_type`, and `packer_http_addr`. [GH-4821]
-* provisioner/ansible: Add `inventory_directory` option to control where to
-    place the generated inventory file. [GH-4760]
-* provisioner/ansible: Add `skip_version_check` flag for when ansible will be
-    installed from a prior provisioner. [GH-4983]
-* provisioner/ansible: Add extra-vars `packer_build_name` and
-    `packer_builder_type`. [GH-4821]
-* provisioner/chef-solo: Add option to select Chef version. [GH-4791]
-* provisioner/salt: Add salt bin directory configuration. [GH-5009]
-* provisioner/salt: Add support for grains. [GH-4961]
-* provisioner/shell: Use `env` to set environment variables to support freebsd
-    out of the box. [GH-4909]
-* website/docs: Clarify language, improve formatting. [GH-4866]
-* website/docs: Update docker metadata fields that can be changed. [GH-4867]
-
-
-### BUG FIXES:
-
-* builder/amazon-ebssurrogate: Use ami device settings when creating the AMI.
-    [GH-4972]
-* builder/amazon: don't try to delete extra volumes during clean up. [GH-4930]
-* builder/amazon: fix `force_delete_snapshot` when the launch instance has
-    extra volumes. [GH-4931]
-* builder/amazon: Only delete temporary key if we created one. [GH-4850]
-* builder/azure: Replace calls to panic with error returns. [GH-4846]
-* communicator/winrm: Use KeepAlive to keep long-running connections open.
-    [GH-4952]
-* core: Correctly reject config files which have junk after valid json.
-    [GH-4906]
-* post-processor/checksum: fix crash when invalid checksum is used. [GH-4812]
-* post-processor/vagrant-cloud: don't read files to upload in to memory first.
-    [GH-5005]
-* post-processor/vagrant-cloud: only upload once under normal conditions.
-    [GH-5008]
-* provisioner/ansible-local: Correctly set the default staging directory under
-    Windows. [GH-4792]
-
-### FEATURES:
-
-* **New builder:** `alicloud-ecs` for building Alicloud ECS images. [GH-4619]
-
-
-## 1.0.0 (April 4, 2017)
-
-### BUG FIXES:
-
-* builder/amazon: Fix b/c issue by reporting again the tags we create.
-    [GH-4704]
-* builder/amazon: Fix crash in `step_region_copy`. [GH-4642]
 * builder/googlecompute: Correct values for `on_host_maintenance`. [GH-4643]
-* builder/googlecompute: Use "default" service account. [GH-4749]
-* builder/hyper-v: Don't wait for shutdown_command to return. [GH-4691]
-* builder/virtualbox: fix `none` communicator by allowing skipping upload of
-    version file. [GH-4678]
-* builder/virtualbox: retry removing floppy controller. [GH-4705]
-* communicator/ssh: don't return error if we can't close connection. [GH-4741]
-* communicator/ssh: fix nil pointer error. [GH-4690]
-* core: fix version number
-* core: Invoking packer `--help` or `--version` now exits with status 0.
-    [GH-4723]
-* core: show correct step name when debugging. [GH-4672]
-* communicator/winrm: Directory uploads behave more like scp. [GH-4438]
+* builder/amazon: Fix crash in `step_region_copy`. [GH-4642]
 
-### IMPROVEMENTS:
+### IMRPOVEMENTS:
 
-* builder/amazon-chroot: Ability to give an empty list in `copy_files` to
-    prevent the default `/etc/resolv.conf` file from being copied. If
-    `copy_files` isn't given at all, the default behavior remains. [GH-4708]
-* builder/amazon: set force_deregister to true on -force. [GH-4649]
 * builder/amazon: validate ssh key name/file. [GH-4665]
-* builder/ansible: Clearer error message when we have problems getting the
-    ansible version. [GH-4694]
+* builder/amazon: set force_deregister to true on -force. [GH-4649]
 * builder/hyper-v: validate output dir in step, not in config. [GH-4645]
-* More diligently try to complete azure-setup.sh. [GH-4752]
 * website: fix display on ios devices. [GH-4618]
 
 ## 0.12.3 (March 1, 2017)
 
-### BACKWARDS INCOMPATIBILITIES:
-
-* provisioner/ansible: by default, the staging dir will be randomized. [GH-4472]
-
 ### FEATURES:
 
 * **New builder:** `ebs-surrogate` for building AMIs from EBS volumes. [GH-4351]
 
 ### IMPROVEMENTS:
 
-* builder/amazon-chroot: support encrypted boot volume. [GH-4584]
 * builder/amazon: Add BuildRegion and SourceAMI template variables. [GH-4399]
 * builder/amazon: Change EC2 Windows password timeout to 20 minutes. [GH-4590]
-* builder/amazon: enable ena when `enhanced_networking` is set. [GH-4578]
-* builder/azure:: add two new config variables for temp_compute_name and
-    temp_resource_group_name. [GH-4468]
+* builder/amazon-chroot: support encrypted boot volume. [GH-4584]
 * builder/docker: create export dir if needed. [GH-4439]
 * builder/googlecompute: Add `on_host_maintenance` option. [GH-4544]
-* builder/openstack: add reuse_ips option to try to re-use existing IPs.
-    [GH-4564]
+* builder/openstack: add reuse_ips option to try to re-use existing IPs. [GH-4564]
+* communicator/docker: preserve file mode. [GH-4443]
+* communicator/winrm: support ProxyFromEnvironment. [GH-4463]
+* core: make VNC links clickable in terminal. [GH-4497] [GH-4498]
+* post-processor/amazon-import: support AMI attributes on import [GH-4216]
+* provisioner/ansible: use randomized staging dir [GH-4472]
+* communicator/ssh: Use SSH agent when enabled for bastion step. [GH-4598]
+* builder/amazon: enable ena when `enhanced_networking` is set. [GH-4578]
 * builder/vmware-esxi: try for longer to connect to vnc port. [GH-4480]
     [GH-4610]
-* builder/vmware: allow extra options for ovftool. [GH-4536]
-* builder/vmware: don't cache ip address so we know if it changes. [GH-4532]
-* communicator/docker: preserve file mode. [GH-4443]
-* communicator/ssh: Use SSH agent when enabled for bastion step. [GH-4598]
-* communicator/winrm: support ProxyFromEnvironment. [GH-4463]
 * core: don't show ui color if we're not colorized. [GH-4525]
-* core: make VNC links clickable in terminal. [GH-4497] [GH-4498]
+* builder/vmware: don't cache ip address so we know if it changes. [GH-4532]
+* builder/vmware: allow extra options for ovftool. [GH-4536]
 * docs: add community page. [GH-4550]
-* post-processor/amazon-import: support AMI attributes on import [GH-4216]
 * post-processor/docker-import: print stderr on docker import failure.
     [GH-4529]
+* builder/azure:: add two new config variables for temp_compute_name and
+    temp_resource_group_name. [GH-4468]
 
 ### BUG FIXES:
 
-* builder/amazon-ebsvolume: Fix interpolation of block_device. [GH-4464]
 * builder/amazon: Fix ssh agent authentication. [GH-4597]
-* builder/docker: Don't force tag if using a docker version that doesn't
-    support it. [GH-4560]
+* builder/amazon-ebsvolume: Fix interpolation of block_device. [GH-4464]
 * builder/googlecompute: fix bug when creating image from custom image_family.
     [GH-4518]
 * builder/virtualbox: remove guest additions before saving image. [GH-4496]
 * core: always check for an error first when walking a path. [GH-4467]
-* core: update crypto/ssh lib to fix large file uploads. [GH-4546]
+* builder/docker: Don't force tag if using a docker version that doesn't
+    support it. [GH-4560]
 * provisioner/chef-client: only upload knife config if we're cleaning.
     [GH-4534]
+* core: update crypto/ssh lib to fix large file uploads. [GH-4546]
 
 ## 0.12.2 (January 20, 2017)
 
@@ -786,13 +69,12 @@
 
 * builder/hyperv-iso: add `iso_target_extension` option. [GH-4294]
 * builder/openstack: Add support for instance metadata. [GH-4361]
-* builder/openstack: Attempt to use existing floating IPs before allocating a
-    new one. [GH-4357]
+* builder/openstack: Attempt to use existing floating IPs before allocating
+    a new one. [GH-4357]
 * builder/parallels-iso: add `iso_target_extension` option. [GH-4294]
 * builder/qemu: add `iso_target_extension` option. [GH-4294]
 * builder/qemu: add `use_default_display` option for osx compatibility.
     [GH-4293]
-* builder/qemu: Detect input disk image format during copy/convert. [GH-4343]
 * builder/virtualbox-iso: add `iso_target_extension` option. [GH-4294]
 * builder/virtualbox: add `skip_export` option to skip exporting the VM after
     build completes. [GH-4339]
@@ -804,22 +86,23 @@
 * builder/vmware: Try to use `ip address` to find host IP. [GH-4411]
 * common/step_http\_server: set `PACKER_HTTP_ADDR` env var for accessing http
     server from inside builder. [GH-4409]
-* provisioner/powershell: Allow equals sign in value of environment variables.
-    [GH-4328]
+* provisioner/powershell: Allow equals sign in value of environment
+    variables. [GH-4328]
 * provisioner/puppet-server: Add default facts.  [GH-4286]
+* builder/qemu: Detect input disk image format during copy/convert. [GH-4343]
 
 ### BUG FIXES:
 
 * builder/amazon-chroot: Panic in AMI region copy step. [GH-4341]
 * builder/amazon: Crashes when new EBS vols are used. [GH-4308]
 * builder/amazon: Fix crash in amazon-instance. [GH-4372]
-* builder/amazon: fix run volume tagging [GH-4420]
-* builder/amazon: fix when using non-existent security\_group\_id. [GH-4425]
 * builder/amazon: Properly error if we don't have the
     ec2:DescribeSecurityGroups permission. [GH-4304]
 * builder/amazon: Properly wait for security group to exist. [GH-4369]
-* builder/docker: Fix crash when performing log in to ECR with an invalid URL.
-    [GH-4385]
+* builder/amazon: fix run volume tagging [GH-4420]
+* builder/amazon: fix when using non-existant security\_group\_id. [GH-4425]
+* builder/docker: Fix crash when performing log in to ECR with an invalid
+    URL. [GH-4385]
 * builder/openstack: fix for finding resource by ID. [GH-4301]
 * builder/qemu: Explicitly set WinRMPort for StepConnect. [GH-4321]
 * builder/virtualbox: Explicitly set WinRMPort for StepConnect. [GH-4321]
@@ -830,7 +113,8 @@
 * command/push: Don't interpolate variables when pushing. [GH-4389]
 * common/step_http_server: make port range inclusive. [GH-4398]
 * communicator/winrm: update winrm client, resolving `MaxMemoryPerShellMB`
-    errors and properly error logging instead of panicking. [GH-4412] [GH-4424]
+    errors and properly error logging instead of panicking. [GH-4412]
+    [GH-4424]
 * provider/windows-shell: Allows equals sign in env var value. [GH-4423]
 
 ## 0.12.1 (December 15, 2016)
@@ -842,9 +126,9 @@
     "packer fix template.json" to migrate a template. [GH-4285]
 * builder/openstack: No long supports the `api_key` option for rackspace.
     [GH-4283]
-* post-processor/manifest: Changed `filename` field to be `output`, to be more
-    consistent with other post-processors. `packer fix` will fix this for you.
-    [GH-4192]
+* post-processor/manifest: Changed `filename` field to be `output`, to be
+    more consistent with other post-processors. `packer fix` will fix this
+    for you. [GH-4192]
 * post-processor/shell-local: Now runs per-builder instead of per-file. The
     filename is no longer passed in as an argument to the script, but instead
     needs to be gleaned from the manifest post-processor. [GH-4189]
@@ -1477,7 +761,7 @@
 * builder/parallels: Support Parallels Desktop 11. [GH-2199]
 * builder/openstack: Add `rackconnect_wait` for Rackspace customers to wait for
     RackConnect data to appear
-* builder/openstack: Add `ssh_interface` option for rackconnect for users that
+* buidler/openstack: Add `ssh_interface` option for rackconnect for users that
     have prohibitive firewalls
 * builder/openstack: Flavor names can be used as well as refs
 * builder/openstack: Add `availability_zone` [GH-2016]
@@ -1508,7 +792,7 @@
 * core: Fix potential panic for post-processor plugin exits. [GH-2098]
 * core: `PACKER_CONFIG` may point to a non-existent file. [GH-2226]
 * builder/amazon: Allow spaces in AMI names when using `clean_ami_name` [GH-2182]
-* builder/amazon: Remove deprecated ec2-upload-bundle parameter. [GH-1931]
+* builder/amazon: Remove deprecated ec2-upload-bundle paramger. [GH-1931]
 * builder/amazon: Use IAM Profile to upload bundle if provided. [GH-1985]
 * builder/amazon: Use correct exit code after SSH authentication failed. [GH-2004]
 * builder/amazon: Retry finding created instance for eventual
@@ -1591,7 +875,7 @@
 
 * builder/googlecompute: Support for ubuntu-os-cloud project
 * builder/googlecompute: Support for OAuth2 to avoid client secrets file
-* builder/googlecompute: GCE image from persistent disk instead of tarball
+* builder/googlecompute: GCE image from persistant disk instead of tarball
 * builder/qemu: Checksum type "none" can be used
 * provisioner/chef: Generate a node name if none available
 * provisioner/chef: Added ssl_verify_mode configuration
@@ -1725,7 +1009,7 @@
 * builder/docker: Can now specify login credentials to pull images.
 * builder/docker: Support mounting additional volumes. [GH-1430]
 * builder/parallels/all: Path to tools ISO is calculated automatically. [GH-1455]
-* builder/parallels-pvm: `reassign_mac` option to choose whether or not
+* builder/parallels-pvm: `reassign_mac` option to choose wehther or not
     to generate a new MAC address. [GH-1461]
 * builder/qemu: Can specify "none" acceleration type. [GH-1395]
 * builder/qemu: Can specify "tcg" acceleration type. [GH-1395]
@@ -1754,7 +1038,7 @@
     manager certs. [GH-1137]
 * builder/amazon/all: `delete_on_termination` set to false will work.
 * builder/amazon/all: Fix race condition on setting tags. [GH-1367]
-* builder/amazon/all: More descriptive error messages if Amazon only
+* builder/amazon/all: More desctriptive error messages if Amazon only
     sends an error code. [GH-1189]
 * builder/docker: Error if `DOCKER_HOST` is set.
 * builder/docker: Remove the container during cleanup. [GH-1206]
@@ -2168,7 +1452,7 @@
 * builder/digitalocean: scrub API keys from config debug output. [GH-516]
 * builder/virtualbox: error if VirtualBox version cant be detected. [GH-488]
 * builder/virtualbox: detect if vboxdrv isn't properly setup. [GH-488]
-* builder/virtualbox: sleep a bit before export to ensure the session
+* builder/virtualbox: sleep a bit before export to ensure the sesssion
     is unlocked. [GH-512]
 * builder/virtualbox: create SATA drives properly on VirtualBox 4.3. [GH-547]
 * builder/virtualbox: support user templates in SSH key path. [GH-539]
@@ -2325,7 +1609,7 @@
 * builder/virtualbox,vmware: Support SHA512 as a checksum type. [GH-356]
 * builder/vmware: The root hard drive type can now be specified with
     "disk_type_id" for advanced users. [GH-328]
-* provisioner/salt-masterless: Ability to specify a minion config. [GH-264]
+* provisioner/salt-masterless: Ability to specfy a minion config. [GH-264]
 * provisioner/salt-masterless: Ability to upload pillars. [GH-353]
 
 ### IMPROVEMENTS:
@@ -2384,7 +1668,7 @@
 * core: All HTTP downloads across Packer now support the standard
     proxy environmental variables (`HTTP_PROXY`, `NO_PROXY`, etc.) [GH-252]
 * builder/amazon: API requests will use HTTP proxy if specified by
-    environmental variables.
+    enviromental variables.
 * builder/digitalocean: API requests will use HTTP proxy if specified
     by environmental variables.
 
@@ -2430,11 +1714,11 @@
 * builder/amazon-instance: send IAM instance profile data. [GH-294]
 * builder/digitalocean: API request parameters are properly URL
     encoded. [GH-281]
-* builder/virtualbox: download progress won't be shown until download
+* builder/virtualbox: dowload progress won't be shown until download
     actually starts. [GH-288]
 * builder/virtualbox: floppy files names of 13 characters are now properly
     written to the FAT12 filesystem. [GH-285]
-* builder/vmware: download progress won't be shown until download
+* builder/vmware: dowload progress won't be shown until download
     actually starts. [GH-288]
 * builder/vmware: interrupt works while typing commands over VNC.
 * builder/virtualbox: floppy files names of 13 characters are now properly
@@ -2556,7 +1840,7 @@
 ### BUG FIXES:
 
 * builder/amazon/all: Gracefully handle when AMI appears to not exist
-    while AWS state is propagating. [GH-207]
+    while AWS state is propogating. [GH-207]
 * builder/virtualbox: Trim carriage returns for Windows to properly
     detect VM state on Windows. [GH-218]
 * core: build names no longer cause invalid config errors. [GH-197]
@@ -2581,7 +1865,7 @@
 * Amazon EBS builder can now optionally use a pre-made security group
     instead of randomly generating one.
 * DigitalOcean API key and client IDs can now be passed in as
-    environmental variables. See the documentation for more details.
+    environmental variables. See the documentatin for more details.
 * VirtualBox and VMware can now have `floppy_files` specified to attach
     floppy disks when booting. This allows for unattended Windows installs.
 * `packer build` has a new `-force` flag that forces the removal of
@@ -2638,7 +1922,7 @@
 * core: Non-200 response codes on downloads now show proper errors.
     [GH-141]
 * amazon-ebs: SSH handshake is retried. [GH-130]
-* vagrant: The `BuildName` template property works properly in
+* vagrant: The `BuildName` template propery works properly in
     the output path.
 * vagrant: Properly configure the provider-specific post-processors so
     things like `vagrantfile_template` work. [GH-129]

CODEOWNERS

@@ -1,28 +0,0 @@
-* @hashicorp/packer
-
-# builders
-
-/builder/alicloud/                      dongxiao.zzh@alibaba-inc.com
-/builder/amazon/ebssurrogate/           @jen20
-/builder/amazon/ebsvolume/              @jen20
-/builder/azure/                         @boumenot
-/builder/hyperv/                        @taliesins
-/builder/lxc/                           @ChrisLundquist
-/builder/lxd/                           @ChrisLundquist
-/builder/oneandone/                     @jasmingacic
-/builder/oracle/                        @prydie @owainlewis
-/builder/profitbricks/                  @jasmingacic
-/builder/triton/                        @jen20 @sean-
-/builder/ncloud/                        @YuSungDuk
-/builder/scaleway/                      @dimtion @edouardb
-
-# provisioners
-
-/provisioner/ansible/                   @bhcleek
-/provisioner/converge/                  @stevendborrelli
-
-# post-processors
-/post-processor/alicloud-import/        dongxiao.zzh@alibaba-inc.com
-/post-processor/checksum/               v.tolstov@selfip.ru
-/post-processor/googlecompute-export/   crunkleton@google.com
-/post-processor/vsphere-template/       nelson@bennu.cl

CONTRIBUTING.md

@@ -0,0 +1,158 @@
+# Contributing to Packer
+
+**First:** if you're unsure or afraid of _anything_, just ask
+or submit the 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.
+
+However, for those individuals who want a bit more guidance on the
+best way to contribute to the project, read on. This document will cover
+what we're looking for. By addressing all the points we're looking for,
+it raises the chances we can quickly merge or address your contributions.
+
+## Issues
+
+### Reporting an Issue
+
+* Make sure you test against the latest released version. It is possible
+  we already fixed the bug you're experiencing.
+
+* Run the command with debug ouput with the environment variable
+  `PACKER_LOG`. For example: `PACKER_LOG=1 packer build template.json`. Take
+  the *entire* output and create a [gist](https://gist.github.com) for linking
+  to in your issue. Packer should strip sensitive keys from the output,
+  but take a look through just in case.
+
+* Provide a reproducible test case. If a contributor can't reproduce an
+  issue, then it dramatically lowers the chances it'll get fixed. And in
+  some cases, the issue will eventually be closed.
+
+* Respond promptly to any questions made by the Packer team to your issue.
+  Stale issues will be closed.
+
+### Issue Lifecycle
+
+1. The issue is reported.
+
+2. The issue is verified and categorized by a Packer collaborator.
+   Categorization is done via tags. For example, bugs are marked as "bugs"
+   and 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.
+
+4. The issue is addressed in a pull request or commit. The issue will be
+   referenced in the commit message so that the code that fixes it is clearly
+   linked.
+
+5. The issue is closed.
+
+## Setting up Go to work on Packer
+
+If you have never worked with Go before, you will have to complete the
+following steps in order to be able to compile and test Packer. These instructions target POSIX-like environments (Mac OS X, Linux, Cygwin, etc.) so you may need to adjust them for Windows or other shells.
+
+1. [Download](https://golang.org/dl) and install Go. The instructions below
+   are for go 1.6. Earlier versions of Go are no longer supported.
+
+2. Set and export the `GOPATH` environment variable and update your `PATH`. For
+   example, you can add to your `.bash_profile`.
+
+    ```
+    export GOPATH=$HOME/go
+    export PATH=$PATH:$GOPATH/bin
+    ```
+
+3. Download the Packer source (and its dependencies) by running `go get
+   github.com/mitchellh/packer`. This will download the Packer source to
+   `$GOPATH/src/github.com/mitchellh/packer`.
+
+4. When working on packer `cd $GOPATH/src/github.com/mitchellh/packer` so you
+   can run `make` and easily access other files. Run `make help` to get
+   information about make targets.
+
+5. Make your changes to the Packer source. You can run `make` in
+   `$GOPATH/src/github.com/mitchellh/packer` to run tests and build the packer
+   binary. Any compilation errors will be shown when the binaries are
+   rebuilding. If you don't have `make` you can simply run `go build -o bin/packer .` from the project root.
+
+6. After running building packer successfully, use
+   `$GOPATH/src/github.com/mitchellh/packer/bin/packer` to build a machine and
+   verify your changes work. For instance: `$GOPATH/src/github.com/mitchellh/packer/bin/packer build template.json`.
+
+7. If everything works well and the tests pass, run `go fmt` on your code
+   before submitting a pull-request.
+
+### Opening an Pull Request
+
+When you are ready to open a pull-request, you will need to [fork packer](https://github.com/mitchellh/packer#fork-destination-box), push your changes to your fork, and then open a pull-request.
+
+For example, my github username is `cbednarski` so I would do the following:
+
+    git checkout -b f-my-feature
+    // develop a patch
+    git push https://github.com/cbednarski/packer f-my-feature
+
+From there, open your fork in your browser to open a new pull-request.
+
+**Note** Go infers package names from their filepaths. This means `go build` will break if you `git clone` your fork instead of using `go get` on the main packer project.
+
+### Tips for Working on Packer
+
+#### 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 $GOPATH/src/github.com/mitchellh/packer
+2. Add the remote `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.
+
+#### Govendor
+
+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 [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 `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.
+
+#### Running Unit Tests
+
+You can run tests for individual packages using commands like this:
+
+    $ make test TEST=./builder/amazon/...
+
+#### Running Acceptance Tests
+
+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 verify it is functioning (and also hasn't broken anything else), we recommend running the
+acceptance tests.
+
+**Warning:** The acceptance tests create/destroy/modify *real resources*, which
+may incur costs for real money. In the presence of a bug, it is possible that resources may be left behind, which can cost money even though you were not using them. We recommend running tests in an account used only for that purpose so it is easy to see if there are any dangling resources, and so production resources are not accidentally destroyed or overwritten during testing.
+
+To run the acceptance tests, invoke `make testacc`:
+
+    $ make testacc TEST=./builder/amazon/ebs
+    ...
+
+The `TEST` variable lets you narrow the scope of the acceptance tests to a
+specific package / folder. The `TESTARGS` variable is recommended to filter
+down to a specific resource to test, since testing all of them at once can
+sometimes take a very long time.
+
+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.

Makefile

@@ -5,17 +5,6 @@ GITSHA:=$(shell git rev-parse HEAD)
 # Get the current local branch name from git (if we can, this may be blank)
 GITBRANCH:=$(shell git symbolic-ref --short HEAD 2>/dev/null)
 GOFMT_FILES?=$$(find . -not -path "./vendor/*" -name "*.go")
-GOOS=$(shell go env GOOS)
-GOARCH=$(shell go env GOARCH)
-GOPATH=$(shell go env GOPATH)
-
-# Get the git commit
-GIT_DIRTY=$(shell test -n "`git status --porcelain`" && echo "+CHANGES" || true)
-GIT_COMMIT=$(shell git rev-parse --short HEAD)
-GIT_IMPORT=github.com/hashicorp/packer/version
-GOLDFLAGS=-X $(GIT_IMPORT).GitCommit=$(GIT_COMMIT)$(GIT_DIRTY)
-
-export GOLDFLAGS
 
 default: deps generate test dev
 
@@ -24,38 +13,32 @@ ci: deps test
 release: deps test releasebin package ## Build a release build
 
 bin: deps ## Build debug/test build
-	@go get github.com/mitchellh/gox
 	@echo "WARN: 'make bin' is for debug / test builds only. Use 'make release' for release builds."
-	@sh -c "$(CURDIR)/scripts/build.sh"
+	@GO15VENDOREXPERIMENT=1 sh -c "$(CURDIR)/scripts/build.sh"
 
 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
-	@sh -c "$(CURDIR)/scripts/build.sh"
+	@GO15VENDOREXPERIMENT=1 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)"
 
 deps:
-	@go get golang.org/x/tools/cmd/stringer
-	@go get -u github.com/mna/pigeon
-	@go get github.com/kardianos/govendor
-	@govendor sync
+	go get github.com/mitchellh/gox
+	go get golang.org/x/tools/cmd/stringer
+	go get github.com/kardianos/govendor
+	govendor sync
 
 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; \
 	fi
-	@mkdir -p pkg/$(GOOS)_$(GOARCH)
-	@mkdir -p bin
-	@go install -ldflags '$(GOLDFLAGS)'
-	@cp $(GOPATH)/bin/packer bin/packer
-	@cp $(GOPATH)/bin/packer pkg/$(GOOS)_$(GOARCH)
+	@PACKER_DEV=1 GO15VENDOREXPERIMENT=1 sh -c "$(CURDIR)/scripts/build.sh"
 
 fmt: ## Format Go code
 	@gofmt -w -s $(GOFMT_FILES)
@@ -63,9 +46,6 @@ fmt: ## Format Go code
 fmt-check: ## Check go code formatting
 	$(CURDIR)/scripts/gofmtcheck.sh $(GOFMT_FILES)
 
-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 {} \;
-
 # Install js-beautify with npm install -g js-beautify
 fmt-examples:
 	find examples -name *.json | xargs js-beautify -r -s 2 -n -eol "\n"
@@ -74,8 +54,6 @@ fmt-examples:
 # source files.
 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
 
 test: deps fmt-check ## Run unit tests
@@ -94,9 +72,11 @@ 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"
+	go get -u github.com/mitchellh/gox
+	go get -u golang.org/x/tools/cmd/stringer
+	@echo "INFO: Packer deps are managed by govendor. See 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
+.PHONY: bin checkversion ci default deps fmt fmt-examples generate releasebin test testacc testrace updatedeps

README.md

@@ -5,26 +5,36 @@
 [![GoDoc][godoc-badge]][godoc]
 [![GoReportCard][report-badge]][report]
 
-[travis-badge]: https://travis-ci.org/hashicorp/packer.svg?branch=master
-[travis]: https://travis-ci.org/hashicorp/packer
-[appveyor-badge]: https://ci.appveyor.com/api/projects/status/miavlgnp989e5obc/branch/master?svg=true
+[travis-badge]: https://travis-ci.org/mitchellh/packer.svg?branch=master
+[travis]: https://travis-ci.org/mitchellh/packer
+[appveyor-badge]: https://ci.appveyor.com/api/projects/status/github/mitchellh/packer?branch=master&svg=true
 [appveyor]: https://ci.appveyor.com/project/hashicorp/packer
-[godoc-badge]: https://godoc.org/github.com/hashicorp/packer?status.svg
-[godoc]: https://godoc.org/github.com/hashicorp/packer
-[report-badge]: https://goreportcard.com/badge/github.com/hashicorp/packer
-[report]: https://goreportcard.com/report/github.com/hashicorp/packer
+[godoc-badge]: https://godoc.org/github.com/mitchellh/packer?status.svg
+[godoc]: https://godoc.org/github.com/mitchellh/packer
+[report-badge]: https://goreportcard.com/badge/github.com/mitchellh/packer
+[report]: https://goreportcard.com/report/github.com/mitchellh/packer
 
 * Website: https://www.packer.io
 * IRC: `#packer-tool` on Freenode
-* Mailing list: [Google Groups](https://groups.google.com/forum/#!forum/packer-tool)
+* Mailing list: [Google Groups](http://groups.google.com/group/packer-tool)
 
 Packer is a tool for building identical machine images for multiple platforms
 from a single source configuration.
 
 Packer is lightweight, runs on every major operating system, and is highly
 performant, creating machine images for multiple platforms in parallel. Packer
-comes out of the box with support for many platforms, the full list of which can
-be found at https://www.packer.io/docs/builders/index.html. 
+comes out of the box with support for the following platforms:
+
+* Amazon EC2 (AMI). Both EBS-backed and instance-store AMIs
+* Azure
+* DigitalOcean
+* Docker
+* Google Compute Engine
+* OpenStack
+* Parallels
+* QEMU. Both KVM and Xen images.
+* VirtualBox
+* VMware
 
 Support for other platforms can be added via plugins.
 
@@ -34,19 +44,17 @@ The images that Packer creates can easily be turned into
 ## Quick Start
 Download and install packages and dependencies
 ```
-go get github.com/hashicorp/packer
+go get github.com/mitchellh/packer
 ```
 
 **Note:** There is a great
-[introduction and getting started guide](https://www.packer.io/intro)
+[introduction and getting started guide](http://www.packer.io/intro)
 for those with a bit more patience. Otherwise, the quick start below
 will get you up and running quickly, at the sacrifice of not explaining some
 key points.
 
-First, [download a pre-built Packer
-binary](https://www.packer.io/downloads.html) for your operating system or
-[compile Packer
-yourself](https://github.com/hashicorp/packer/blob/master/.github/CONTRIBUTING.md#setting-up-go-to-work-on-packer).
+First, [download a pre-built Packer binary](http://www.packer.io/downloads.html)
+for your operating system or [compile Packer yourself](CONTRIBUTING.md#setting-up-go-to-work-on-packer).
 
 After Packer is installed, create your first template, which tells Packer
 what platforms to build images for and how you want to build them. In our
@@ -90,11 +98,8 @@ they're run, etc. is up to you.
 
 Comprehensive documentation is viewable on the Packer website:
 
-https://www.packer.io/docs
+http://www.packer.io/docs
 
 ## Developing Packer
 
-See
-[CONTRIBUTING.md](https://github.com/hashicorp/packer/blob/master/.github/CONTRIBUTING.md)
-for best practices and instructions on setting up your development environment
-to work on Packer.
+See [CONTRIBUTING.md](https://github.com/mitchellh/packer/blob/master/CONTRIBUTING.md) for best practices and instructions on setting up your development environment to work on Packer.

Vagrantfile

@@ -1,84 +1,50 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-LINUX_BASE_BOX = "bento/ubuntu-16.04"
-FREEBSD_BASE_BOX = "jen20/FreeBSD-12.0-CURRENT"
+$script = <<SCRIPT
+# Fetch from https://golang.org/dl
+TARBALL="https://storage.googleapis.com/golang/go1.6.linux-amd64.tar.gz"
+
+UNTARPATH="/opt"
+GOROOT="${UNTARPATH}/go"
+GOPATH="${UNTARPATH}/gopath"
+
+# Install Go
+if [ ! -d ${GOROOT} ]; then
+  sudo wget --progress=bar:force --output-document - ${TARBALL} |\
+    tar xfz - -C ${UNTARPATH}
+fi
+
+# Setup the GOPATH
+sudo mkdir -p ${GOPATH}
+cat <<EOF >/tmp/gopath.sh
+export GOROOT="${GOROOT}"
+export GOPATH="${GOPATH}"
+export PATH="${GOROOT}/bin:${GOPATH}/bin:\$PATH"
+EOF
+sudo mv /tmp/gopath.sh /etc/profile.d/gopath.sh
+
+# Make sure the GOPATH is usable by vagrant
+sudo chown -R vagrant:vagrant ${GOROOT}
+sudo chown -R vagrant:vagrant ${GOPATH}
+
+# Install some other stuff we need
+sudo apt-get update
+sudo apt-get install -y curl make git mercurial bzr zip
+SCRIPT
 
 Vagrant.configure(2) do |config|
-	# Compilation and development boxes
-	config.vm.define "linux", autostart: true, primary: true do |vmCfg|
-		vmCfg.vm.box = LINUX_BASE_BOX
-		vmCfg.vm.hostname = "linux"
-		vmCfg = configureProviders vmCfg,
-			cpus: suggestedCPUCores()
+  config.vm.box = "bento/ubuntu-14.04"
 
-		vmCfg.vm.synced_folder ".", "/vagrant", disabled: true
-		vmCfg.vm.synced_folder '.',
-			'/opt/gopath/src/github.com/hashicorp/packer'
+  config.vm.provision "shell", inline: $script
 
-		vmCfg.vm.provision "shell",
-			privileged: true,
-			inline: 'rm -f /home/vagrant/linux.iso'
+  config.vm.synced_folder ".", "/vagrant", disabled: true
 
-		vmCfg.vm.provision "shell",
-			privileged: true,
-			path: './scripts/vagrant-linux-priv-go.sh'
-
-		vmCfg.vm.provision "shell",
-			privileged: true,
-			path: './scripts/vagrant-linux-priv-config.sh'
-
-		vmCfg.vm.provision "shell",
-			privileged: false,
-			path: './scripts/vagrant-linux-unpriv-bootstrap.sh'
-	end
-
-	config.vm.define "freebsd", autostart: false, primary: false do |vmCfg|
-		vmCfg.vm.box = FREEBSD_BASE_BOX
-		vmCfg.vm.hostname = "freebsd"
-		vmCfg = configureProviders vmCfg,
-			cpus: suggestedCPUCores()
-
-		vmCfg.vm.synced_folder ".", "/vagrant", disabled: true
-		vmCfg.vm.synced_folder '.',
-			'/opt/gopath/src/github.com/hashicorp/packer',
-			type: "nfs",
-			bsd__nfs_options: ['noatime']
-
-		vmCfg.vm.provision "shell",
-			privileged: true,
-			path: './scripts/vagrant-freebsd-priv-config.sh'
-
-		vmCfg.vm.provision "shell",
-			privileged: false,
-			path: './scripts/vagrant-freebsd-unpriv-bootstrap.sh'
-	end
-end
-
-def configureProviders(vmCfg, cpus: "2", memory: "2048")
-	vmCfg.vm.provider "virtualbox" do |v|
-		v.memory = memory
-		v.cpus = cpus
-	end
-
-	["vmware_fusion", "vmware_workstation"].each do |p|
-		vmCfg.vm.provider p do |v|
-			v.enable_vmrun_ip_lookup = false
-			v.vmx["memsize"] = memory
-			v.vmx["numvcpus"] = cpus
-		end
-	end
-
-	return vmCfg
-end
-
-def suggestedCPUCores()
-	case RbConfig::CONFIG['host_os']
-	when /darwin/
-		Integer(`sysctl -n hw.ncpu`) / 2
-	when /linux/
-		Integer(`cat /proc/cpuinfo | grep processor | wc -l`) / 2
-	else
-		2
-	end
+  ["vmware_fusion", "vmware_workstation"].each do |p|
+    config.vm.provider "p" do |v|
+      v.vmx["memsize"] = "2048"
+      v.vmx["numvcpus"] = "2"
+      v.vmx["cpuid.coresPerSocket"] = "1"
+    end
+  end
 end

appveyor.yml

@@ -13,7 +13,7 @@ os: Windows Server 2012 R2
 environment:
   GOPATH: c:\gopath
 
-clone_folder: c:\gopath\src\github.com\hashicorp\packer
+clone_folder: c:\gopath\src\github.com\mitchellh\packer
 
 install:
   - set GO15VENDOREXPERIMENT=1
@@ -29,9 +29,9 @@ build_script:
   - ps: |
       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' })
+      |? { $_ -ne 'github.com/mitchellh/packer/builder/parallels/common' } `
+      |? { $_ -ne 'github.com/mitchellh/packer/common' }`
+      |? { $_ -ne 'github.com/mitchellh/packer/provisioner/ansible' })
 
 test: off
 

azure-merge.sh

@@ -0,0 +1,18 @@
+PACKER=$GOPATH/src/github.com/mitchellh/packer
+AZURE=/tmp/packer-azure
+
+ls $AZURE >/dev/null || git clone https://github.com/Azure/packer-azure /tmp/packer-azure
+PWD=`pwd`
+cd $AZURE && git pull
+cd $PWD
+
+# copy things
+cp -r $AZURE/packer/builder/azure $PACKER/builder/
+cp -r $AZURE/packer/communicator/* $PACKER/communicator/
+cp -r $AZURE/packer/provisioner/azureVmCustomScriptExtension $PACKER/provisioner/
+
+# remove legacy API client
+rm -rf $PACKER/builder/azure/smapi
+
+# fix imports
+find $PACKER/builder/azure/ -type f | grep ".go" | xargs sed -e 's/Azure\/packer-azure\/packer\/builder\/azure/mitchellh\/packer\/builder\/azure/g' -i ''

builder/alicloud/ecs/access_config.go

@@ -1,89 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/template/interpolate"
-)
-
-// Config of alicloud
-type AlicloudAccessConfig struct {
-	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"`
-}
-
-// Client for AlicloudClient
-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.SetBusinessInfo("Packer")
-	if _, err := client.DescribeRegions(); err != nil {
-		return nil, err
-	}
-	return client, nil
-}
-
-func (c *AlicloudAccessConfig) Prepare(ctx *interpolate.Context) []error {
-	var errs []error
-	if err := c.Config(); err != nil {
-		errs = append(errs, err)
-	}
-
-	if c.AlicloudRegion != "" && !c.AlicloudSkipValidation {
-		if c.validateRegion() != nil {
-			errs = append(errs, fmt.Errorf("Unknown alicloud region: %s", c.AlicloudRegion))
-		}
-	}
-
-	if len(errs) > 0 {
-		return errs
-	}
-
-	return nil
-}
-
-func (c *AlicloudAccessConfig) Config() error {
-	if c.AlicloudAccessKey == "" {
-		c.AlicloudAccessKey = os.Getenv("ALICLOUD_ACCESS_KEY")
-	}
-	if c.AlicloudSecretKey == "" {
-		c.AlicloudSecretKey = os.Getenv("ALICLOUD_SECRET_KEY")
-	}
-	if c.AlicloudAccessKey == "" || c.AlicloudSecretKey == "" {
-		return fmt.Errorf("ALICLOUD_ACCESS_KEY and ALICLOUD_SECRET_KEY must be set in template file or environment variables.")
-	}
-	return nil
-
-}
-
-func (c *AlicloudAccessConfig) loadAndValidate() error {
-	if err := c.validateRegion(); err != nil {
-		return err
-	}
-
-	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", c.AlicloudRegion)
-}

builder/alicloud/ecs/access_config_test.go

@@ -1,44 +0,0 @@
-package ecs
-
-import (
-	"testing"
-)
-
-func testAlicloudAccessConfig() *AlicloudAccessConfig {
-	return &AlicloudAccessConfig{
-		AlicloudAccessKey: "ak",
-		AlicloudSecretKey: "acs",
-	}
-
-}
-
-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.Fatal("should have error")
-	}
-
-	c.AlicloudRegion = "cn-beijing"
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-
-	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

@@ -1,135 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"log"
-	"sort"
-	"strings"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-)
-
-type Artifact struct {
-	// A map of regions to alicloud image IDs.
-	AlicloudImages map[string]string
-
-	// BuilderId is the unique ID for the builder that created this alicloud image
-	BuilderIdValue string
-
-	// Alcloud connection for performing API stuff.
-	Client *ecs.Client
-}
-
-func (a *Artifact) BuilderId() string {
-	return a.BuilderIdValue
-}
-
-func (*Artifact) Files() []string {
-	// We have no files
-	return nil
-}
-
-func (a *Artifact) Id() string {
-	parts := make([]string, 0, len(a.AlicloudImages))
-	for region, ecsImageId := range a.AlicloudImages {
-		parts = append(parts, fmt.Sprintf("%s:%s", region, ecsImageId))
-	}
-
-	sort.Strings(parts)
-	return strings.Join(parts, ",")
-}
-
-func (a *Artifact) String() string {
-	alicloudImageStrings := make([]string, 0, len(a.AlicloudImages))
-	for region, id := range a.AlicloudImages {
-		single := fmt.Sprintf("%s: %s", region, id)
-		alicloudImageStrings = append(alicloudImageStrings, single)
-	}
-
-	sort.Strings(alicloudImageStrings)
-	return fmt.Sprintf("Alicloud images were created:\n\n%s", strings.Join(alicloudImageStrings, "\n"))
-}
-
-func (a *Artifact) State(name string) interface{} {
-	switch name {
-	case "atlas.artifact.metadata":
-		return a.stateAtlasMetadata()
-	default:
-		return nil
-	}
-}
-
-func (a *Artifact) Destroy() error {
-	errors := make([]error, 0)
-
-	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)
-		}
-		if len(images) == 0 {
-			err := fmt.Errorf("Error retrieving details for alicloud image(%s), no alicloud images found", imageId)
-			errors = append(errors, err)
-			continue
-		}
-		//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{
-
-				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 {
-		if len(errors) == 1 {
-			return errors[0]
-		} else {
-			return &packer.MultiError{Errors: errors}
-		}
-	}
-
-	return nil
-}
-
-func (a *Artifact) stateAtlasMetadata() interface{} {
-	metadata := make(map[string]string)
-	for region, imageId := range a.AlicloudImages {
-		k := fmt.Sprintf("region.%s", region)
-		metadata[k] = imageId
-	}
-
-	return metadata
-}

builder/alicloud/ecs/artifact_test.go

@@ -1,47 +0,0 @@
-package ecs
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/hashicorp/packer/packer"
-)
-
-func TestArtifact_Impl(t *testing.T) {
-	var _ packer.Artifact = new(Artifact)
-}
-
-func TestArtifactId(t *testing.T) {
-	expected := `east:foo,west:bar`
-
-	ecsImages := make(map[string]string)
-	ecsImages["east"] = "foo"
-	ecsImages["west"] = "bar"
-
-	a := &Artifact{
-		AlicloudImages: ecsImages,
-	}
-
-	result := a.Id()
-	if result != expected {
-		t.Fatalf("bad: %s", result)
-	}
-}
-
-func TestArtifactState_atlasMetadata(t *testing.T) {
-	a := &Artifact{
-		AlicloudImages: map[string]string{
-			"east": "foo",
-			"west": "bar",
-		},
-	}
-
-	actual := a.State("atlas.artifact.metadata")
-	expected := map[string]string{
-		"region.east": "foo",
-		"region.west": "bar",
-	}
-	if !reflect.DeepEqual(actual, expected) {
-		t.Fatalf("bad: %#v", actual)
-	}
-}

builder/alicloud/ecs/builder.go

@@ -1,243 +0,0 @@
-// The alicloud  contains a packer.Builder implementation that
-// builds ecs images for alicloud.
-package ecs
-
-import (
-	"log"
-
-	"fmt"
-
-	"github.com/hashicorp/packer/common"
-	"github.com/hashicorp/packer/helper/communicator"
-	"github.com/hashicorp/packer/helper/config"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
-)
-
-// The unique ID for this builder
-const BuilderId = "alibaba.alicloud"
-
-type Config struct {
-	common.PackerConfig  `mapstructure:",squash"`
-	AlicloudAccessConfig `mapstructure:",squash"`
-	AlicloudImageConfig  `mapstructure:",squash"`
-	RunConfig            `mapstructure:",squash"`
-
-	ctx interpolate.Context
-}
-
-type Builder struct {
-	config Config
-	runner multistep.Runner
-}
-
-type InstanceNetWork string
-
-const (
-	ClassicNet                     = InstanceNetWork("classic")
-	VpcNet                         = InstanceNetWork("vpc")
-	ALICLOUD_DEFAULT_SHORT_TIMEOUT = 180
-	ALICLOUD_DEFAULT_TIMEOUT       = 1800
-	ALICLOUD_DEFAULT_LONG_TIMEOUT  = 3600
-)
-
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
-	err := config.Decode(&b.config, &config.DecodeOpts{
-		Interpolate:        true,
-		InterpolateContext: &b.config.ctx,
-		InterpolateFilter: &interpolate.RenderFilter{
-			Exclude: []string{
-				"run_command",
-			},
-		},
-	}, raws...)
-	b.config.ctx.EnableEnv = true
-	if err != nil {
-		return nil, err
-	}
-
-	// Accumulate any errors
-	var errs *packer.MultiError
-	errs = packer.MultiErrorAppend(errs, b.config.AlicloudAccessConfig.Prepare(&b.config.ctx)...)
-	errs = packer.MultiErrorAppend(errs, b.config.AlicloudImageConfig.Prepare(&b.config.ctx)...)
-	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(&b.config.ctx)...)
-
-	if errs != nil && len(errs.Errors) > 0 {
-		return nil, errs
-	}
-
-	log.Println(common.ScrubConfig(b.config, b.config.AlicloudAccessKey, b.config.AlicloudSecretKey))
-	return nil, nil
-}
-
-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("client", client)
-	state.Put("hook", hook)
-	state.Put("ui", ui)
-	state.Put("networktype", b.chooseNetworkType())
-	var steps []multistep.Step
-
-	// Build the steps
-	steps = []multistep.Step{
-		&stepPreValidate{
-			AlicloudDestImageName: b.config.AlicloudImageName,
-			ForceDelete:           b.config.AlicloudImageForceDelete,
-		},
-		&stepCheckAlicloudSourceImage{
-			SourceECSImageId: b.config.AlicloudSourceImage,
-		},
-		&StepConfigAlicloudKeyPair{
-			Debug:                b.config.PackerDebug,
-			KeyPairName:          b.config.SSHKeyPairName,
-			PrivateKeyFile:       b.config.Comm.SSHPrivateKey,
-			TemporaryKeyPairName: b.config.TemporaryKeyPairName,
-			SSHAgentAuth:         b.config.Comm.SSHAgentAuth,
-			DebugKeyPath:         fmt.Sprintf("ecs_%s.pem", b.config.PackerBuildName),
-			RegionId:             b.config.AlicloudRegion,
-		},
-	}
-	if b.chooseNetworkType() == VpcNet {
-		steps = append(steps,
-			&stepConfigAlicloudVPC{
-				VpcId:     b.config.VpcId,
-				CidrBlock: b.config.CidrBlock,
-				VpcName:   b.config.VpcName,
-			},
-			&stepConfigAlicloudVSwitch{
-				VSwitchId:   b.config.VSwitchId,
-				ZoneId:      b.config.ZoneId,
-				CidrBlock:   b.config.CidrBlock,
-				VSwitchName: b.config.VSwitchName,
-			})
-	}
-	steps = append(steps,
-		&stepConfigAlicloudSecurityGroup{
-			SecurityGroupId:   b.config.SecurityGroupId,
-			SecurityGroupName: b.config.SecurityGroupId,
-			RegionId:          b.config.AlicloudRegion,
-		},
-		&stepCreateAlicloudInstance{
-			IOOptimized:             b.config.IOOptimized,
-			InstanceType:            b.config.InstanceType,
-			UserData:                b.config.UserData,
-			UserDataFile:            b.config.UserDataFile,
-			RegionId:                b.config.AlicloudRegion,
-			InternetChargeType:      b.config.InternetChargeType,
-			InternetMaxBandwidthOut: b.config.InternetMaxBandwidthOut,
-			InstanceName:            b.config.InstanceName,
-			ZoneId:                  b.config.ZoneId,
-		})
-	if b.chooseNetworkType() == VpcNet {
-		steps = append(steps, &setpConfigAlicloudEIP{
-			AssociatePublicIpAddress: b.config.AssociatePublicIpAddress,
-			RegionId:                 b.config.AlicloudRegion,
-			InternetChargeType:       b.config.InternetChargeType,
-		})
-	} else {
-		steps = append(steps, &stepConfigAlicloudPublicIP{
-			RegionId: b.config.AlicloudRegion,
-		})
-	}
-	steps = append(steps,
-		&stepAttachKeyPar{},
-		&stepRunAlicloudInstance{},
-		&stepMountAlicloudDisk{},
-		&communicator.StepConnect{
-			Config: &b.config.RunConfig.Comm,
-			Host: SSHHost(
-				client,
-				b.config.SSHPrivateIp),
-			SSHConfig: SSHConfig(
-				b.config.RunConfig.Comm.SSHAgentAuth,
-				b.config.RunConfig.Comm.SSHUsername,
-				b.config.RunConfig.Comm.SSHPassword),
-		},
-		&common.StepProvision{},
-		&stepStopAlicloudInstance{
-			ForceStop: b.config.ForceStopInstance,
-		},
-		&stepDeleteAlicloudImageSnapshots{
-			AlicloudImageForceDeleteSnapshots: b.config.AlicloudImageForceDeleteSnapshots,
-			AlicloudImageForceDelete:          b.config.AlicloudImageForceDelete,
-			AlicloudImageName:                 b.config.AlicloudImageName,
-		},
-		&stepCreateAlicloudImage{},
-		&setpRegionCopyAlicloudImage{
-			AlicloudImageDestinationRegions: b.config.AlicloudImageDestinationRegions,
-			AlicloudImageDestinationNames:   b.config.AlicloudImageDestinationNames,
-			RegionId:                        b.config.AlicloudRegion,
-		},
-		&setpShareAlicloudImage{
-			AlicloudImageShareAccounts:   b.config.AlicloudImageShareAccounts,
-			AlicloudImageUNShareAccounts: b.config.AlicloudImageUNShareAccounts,
-			RegionId:                     b.config.AlicloudRegion,
-		})
-
-	// Run!
-	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
-	b.runner.Run(state)
-
-	// If there was an error, return that
-	if rawErr, ok := state.GetOk("error"); ok {
-		return nil, rawErr.(error)
-	}
-
-	// If there are no ECS images, then just return
-	if _, ok := state.GetOk("alicloudimages"); !ok {
-		return nil, nil
-	}
-
-	// Build the artifact and return it
-	artifact := &Artifact{
-		AlicloudImages: state.Get("alicloudimages").(map[string]string),
-		BuilderIdValue: BuilderId,
-		Client:         client,
-	}
-
-	return artifact, nil
-}
-
-func (b *Builder) Cancel() {
-	if b.runner != nil {
-		log.Println("Cancelling the step runner...")
-		b.runner.Cancel()
-	}
-}
-
-func (b *Builder) chooseNetworkType() InstanceNetWork {
-	if b.isVpcNetRequired() {
-		return VpcNet
-	} else {
-		return ClassicNet
-	}
-}
-
-func (b *Builder) isVpcNetRequired() bool {
-	// UserData and KeyPair only works in VPC
-	return b.isVpcSpecified() || b.isUserDataNeeded() || b.isKeyPairNeeded()
-}
-
-func (b *Builder) isVpcSpecified() bool {
-	return b.config.VpcId != "" || b.config.VSwitchId != ""
-}
-
-func (b *Builder) isUserDataNeeded() bool {
-	// Public key setup requires userdata
-	if b.config.RunConfig.Comm.SSHPrivateKey != "" {
-		return true
-	}
-
-	return b.config.UserData != "" || b.config.UserDataFile != ""
-}
-
-func (b *Builder) isKeyPairNeeded() bool {
-	return b.config.SSHKeyPairName != "" || b.config.TemporaryKeyPairName != ""
-}

builder/alicloud/ecs/builder_acc_test.go

@@ -1,331 +0,0 @@
-package ecs
-
-import (
-	"os"
-	"testing"
-
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	builderT "github.com/hashicorp/packer/helper/builder/testing"
-	"github.com/hashicorp/packer/packer"
-)
-
-func TestBuilderAcc_basic(t *testing.T) {
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccBasic,
-	})
-}
-
-//func TestBuilderAcc_windows(t *testing.T) {
-//	builderT.Test(t, builderT.TestCase{
-//		PreCheck: func() {
-//			testAccPreCheck(t)
-//		},
-//		Builder:  &Builder{},
-//		Template: testBuilderAccWindows,
-//	})
-//}
-
-//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) {
-	// Build the same alicloud image twice, with ecs_image_force_delete on the second run
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:              &Builder{},
-		Template:             buildForceDeregisterConfig("false", "delete"),
-		SkipArtifactTeardown: true,
-	})
-
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: buildForceDeregisterConfig("true", "delete"),
-	})
-}
-
-func TestBuilderAcc_ECSImageSharing(t *testing.T) {
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: testBuilderAccSharing,
-		Check:    checkECSImageSharing("1309208528360047"),
-	})
-}
-
-func TestBuilderAcc_forceDeleteSnapshot(t *testing.T) {
-	destImageName := "delete"
-
-	// Build the same alicloud image name twice, with force_delete_snapshot on the second run
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:              &Builder{},
-		Template:             buildForceDeleteSnapshotConfig("false", destImageName),
-		SkipArtifactTeardown: true,
-	})
-
-	// Get image data by image image name
-	client, _ := testAliyunClient()
-	images, _, _ := client.DescribeImages(&ecs.DescribeImagesArgs{
-		ImageName: "packer-test-" + destImageName,
-		RegionId:  common.Region("cn-beijing")})
-
-	image := images[0]
-
-	// Get snapshot ids for image
-	snapshotIds := []string{}
-	for _, device := range image.DiskDeviceMappings.DiskDeviceMapping {
-		if device.Device != "" && device.SnapshotId != "" {
-			snapshotIds = append(snapshotIds, device.SnapshotId)
-		}
-	}
-
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() {
-			testAccPreCheck(t)
-		},
-		Builder:  &Builder{},
-		Template: buildForceDeleteSnapshotConfig("true", destImageName),
-		Check:    checkSnapshotsDeleted(snapshotIds),
-	})
-}
-
-func checkSnapshotsDeleted(snapshotIds []string) builderT.TestCheckFunc {
-	return func(artifacts []packer.Artifact) error {
-		// Verify the snapshots are gone
-		client, _ := testAliyunClient()
-		snapshotResp, _, err := client.DescribeSnapshots(
-			&ecs.DescribeSnapshotsArgs{RegionId: common.Region("cn-beijing"), SnapshotIds: snapshotIds},
-		)
-		if err != nil {
-			return fmt.Errorf("Query snapshot failed %v", err)
-		}
-		if len(snapshotResp) > 0 {
-			return fmt.Errorf("Snapshots weren't successfully deleted by " +
-				"`ecs_image_force_delete_snapshots`")
-		}
-		return nil
-	}
-}
-
-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()
-		imageSharePermissionResponse, err := client.DescribeImageSharePermission(
-			&ecs.ModifyImageSharePermissionArgs{
-				RegionId: "cn-beijing",
-				ImageId:  artifact.AlicloudImages["cn-beijing"],
-			})
-
-		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(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 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("unknown region: %s", r)
-			}
-
-			delete(regionSet, r)
-		}
-		if len(regionSet) > 0 {
-			return fmt.Errorf("didn't copy to: %#v", regionSet)
-		}
-		client, _ := testAliyunClient()
-		for key, value := range artifact.AlicloudImages {
-			client.WaitForImageReady(common.Region(key), value, 1800)
-		}
-		return nil
-	}
-}
-
-func testAccPreCheck(t *testing.T) {
-	if v := os.Getenv("ALICLOUD_ACCESS_KEY"); v == "" {
-		t.Fatal("ALICLOUD_ACCESS_KEY must be set for acceptance tests")
-	}
-
-	if v := os.Getenv("ALICLOUD_SECRET_KEY"); v == "" {
-		t.Fatal("ALICLOUD_SECRET_KEY must be set for acceptance tests")
-	}
-}
-
-func testAliyunClient() (*ecs.Client, error) {
-	access := &AlicloudAccessConfig{AlicloudRegion: "cn-beijing"}
-	err := access.Config()
-	if err != nil {
-		return nil, err
-	}
-	client, err := access.Client()
-	if err != nil {
-		return nil, err
-	}
-
-	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,95 +0,0 @@
-package ecs
-
-import (
-	"testing"
-
-	"github.com/hashicorp/packer/packer"
-)
-
-func testBuilderConfig() map[string]interface{} {
-	return map[string]interface{}{
-		"access_key":    "foo",
-		"secret_key":    "bar",
-		"source_image":  "foo",
-		"instance_type": "ecs.n1.tiny",
-		"region":        "cn-beijing",
-		"ssh_username":  "root",
-		"image_name":    "foo",
-		"io_optimized":  true,
-	}
-}
-
-func TestBuilder_ImplementsBuilder(t *testing.T) {
-	var raw interface{}
-	raw = &Builder{}
-	if _, ok := raw.(packer.Builder); !ok {
-		t.Fatalf("Builder should be a builder")
-	}
-}
-
-func TestBuilder_Prepare_BadType(t *testing.T) {
-	b := &Builder{}
-	c := map[string]interface{}{
-		"access_key": []string{},
-	}
-
-	warnings, err := b.Prepare(c)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatalf("prepare should fail")
-	}
-}
-
-func TestBuilderPrepare_ECSImageName(t *testing.T) {
-	var b Builder
-	config := testBuilderConfig()
-
-	// Test good
-	config["image_name"] = "ecs.n1.tiny"
-	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)
-	}
-
-	// Test bad
-	config["ecs_image_name"] = "foo {{"
-	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test bad
-	delete(config, "image_name")
-	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_InvalidKey(t *testing.T) {
-	var b Builder
-	config := testBuilderConfig()
-
-	// Add a random key
-	config["i_should_not_be_valid"] = true
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}

builder/alicloud/ecs/image_config.go

@@ -1,100 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"regexp"
-	"strings"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/hashicorp/packer/template/interpolate"
-)
-
-type AlicloudDiskDevice struct {
-	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 {
-	ECSImagesDiskMappings []AlicloudDiskDevice `mapstructure:"image_disk_mappings"`
-}
-
-type AlicloudImageConfig struct {
-	AlicloudImageName                 string   `mapstructure:"image_name"`
-	AlicloudImageVersion              string   `mapstructure:"image_version"`
-	AlicloudImageDescription          string   `mapstructure:"image_description"`
-	AlicloudImageShareAccounts        []string `mapstructure:"image_share_account"`
-	AlicloudImageUNShareAccounts      []string `mapstructure:"image_unshare_account"`
-	AlicloudImageDestinationRegions   []string `mapstructure:"image_copy_regions"`
-	AlicloudImageDestinationNames     []string `mapstructure:"image_copy_names"`
-	AlicloudImageForceDelete          bool     `mapstructure:"image_force_delete"`
-	AlicloudImageForceDeleteSnapshots bool     `mapstructure:"image_force_delete_snapshots"`
-	AlicloudImageForceDeleteInstances bool     `mapstructure:"image_force_delete_instances"`
-	AlicloudImageSkipRegionValidation bool     `mapstructure:"skip_region_validation"`
-	AlicloudDiskDevices               `mapstructure:",squash"`
-}
-
-func (c *AlicloudImageConfig) Prepare(ctx *interpolate.Context) []error {
-	var errs []error
-	if c.AlicloudImageName == "" {
-		errs = append(errs, fmt.Errorf("image_name must be specified"))
-	} else if len(c.AlicloudImageName) < 2 || len(c.AlicloudImageName) > 128 {
-		errs = append(errs, fmt.Errorf("image_name must less than 128 letters and more than 1 letters"))
-	} else if strings.HasPrefix(c.AlicloudImageName, "http://") ||
-		strings.HasPrefix(c.AlicloudImageName, "https://") {
-		errs = append(errs, fmt.Errorf("image_name can't start with 'http://' or 'https://'"))
-	}
-	reg := regexp.MustCompile("\\s+")
-	if reg.FindString(c.AlicloudImageName) != "" {
-		errs = append(errs, fmt.Errorf("image_name can't include spaces"))
-	}
-
-	if len(c.AlicloudImageDestinationRegions) > 0 {
-		regionSet := make(map[string]struct{})
-		regions := make([]string, 0, len(c.AlicloudImageDestinationRegions))
-
-		for _, region := range c.AlicloudImageDestinationRegions {
-			// If we already saw the region, then don't look again
-			if _, ok := regionSet[region]; ok {
-				continue
-			}
-
-			// 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)
-		}
-
-		c.AlicloudImageDestinationRegions = regions
-	}
-
-	if len(errs) > 0 {
-		return errs
-	}
-
-	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

@@ -1,64 +0,0 @@
-package ecs
-
-import (
-	"testing"
-
-	"github.com/denverdino/aliyungo/common"
-)
-
-func testAlicloudImageConfig() *AlicloudImageConfig {
-	return &AlicloudImageConfig{
-		AlicloudImageName: "foo",
-	}
-}
-
-func TestECSImageConfigPrepare_name(t *testing.T) {
-	c := testAlicloudImageConfig()
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-
-	c.AlicloudImageName = ""
-	if err := c.Prepare(nil); err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestAMIConfigPrepare_regions(t *testing.T) {
-	c := testAlicloudImageConfig()
-	c.AlicloudImageDestinationRegions = nil
-	if err := c.Prepare(nil); err != nil {
-		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 = []string{"unknow"}
-	c.AlicloudImageSkipRegionValidation = true
-	if err := c.Prepare(nil); err != nil {
-		t.Fatal("shouldn't have error")
-	}
-	c.AlicloudImageSkipRegionValidation = false
-
-}
-
-func regionsToString() []string {
-	var regions []string
-	for _, region := range common.ValidRegions {
-		regions = append(regions, string(region))
-	}
-	return regions
-}

builder/alicloud/ecs/packer_helper.go

@@ -1,22 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-func message(state multistep.StateBag, module string) {
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-
-	ui := state.Get("ui").(packer.Ui)
-
-	if cancelled || halted {
-		ui.Say(fmt.Sprintf("Deleting %s because of cancellation or error...", module))
-	} else {
-		ui.Say(fmt.Sprintf("Cleaning up '%s'", module))
-	}
-
-}

builder/alicloud/ecs/run_config.go

@@ -1,72 +0,0 @@
-package ecs
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/hashicorp/packer/common/uuid"
-	"github.com/hashicorp/packer/helper/communicator"
-	"github.com/hashicorp/packer/template/interpolate"
-)
-
-type RunConfig struct {
-	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"`
-	TemporaryKeyPairName     string `mapstructure:"temporary_key_pair_name"`
-
-	// Communicator settings
-	Comm           communicator.Config `mapstructure:",squash"`
-	SSHKeyPairName string              `mapstructure:"ssh_keypair_name"`
-	SSHPrivateIp   bool                `mapstructure:"ssh_private_ip"`
-}
-
-func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
-	if c.SSHKeyPairName == "" && c.TemporaryKeyPairName == "" &&
-		c.Comm.SSHPrivateKey == "" && c.Comm.SSHPassword == "" && c.Comm.WinRMPassword == "" {
-
-		c.TemporaryKeyPairName = fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID())
-	}
-
-	// Validation
-	errs := c.Comm.Prepare(ctx)
-	if c.AlicloudSourceImage == "" {
-		errs = append(errs, errors.New("A source_image must be specified"))
-	}
-
-	if strings.TrimSpace(c.AlicloudSourceImage) != c.AlicloudSourceImage {
-		errs = append(errs, errors.New("The source_image can't include spaces"))
-	}
-
-	if c.InstanceType == "" {
-		errs = append(errs, errors.New("An alicloud_instance_type must be specified"))
-	}
-
-	if c.UserData != "" && c.UserDataFile != "" {
-		errs = append(errs, fmt.Errorf("Only one of user_data or user_data_file can be specified."))
-	} else if c.UserDataFile != "" {
-		if _, err := os.Stat(c.UserDataFile); err != nil {
-			errs = append(errs, fmt.Errorf("user_data_file not found: %s", c.UserDataFile))
-		}
-	}
-
-	return errs
-}

builder/alicloud/ecs/run_config_test.go

@@ -1,125 +0,0 @@
-package ecs
-
-import (
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"github.com/hashicorp/packer/helper/communicator"
-)
-
-func testConfig() *RunConfig {
-	return &RunConfig{
-		AlicloudSourceImage: "alicloud_images",
-		InstanceType:        "ecs.n1.tiny",
-		Comm: communicator.Config{
-			SSHUsername: "alicloud",
-		},
-	}
-}
-
-func TestRunConfigPrepare(t *testing.T) {
-	c := testConfig()
-	err := c.Prepare(nil)
-	if len(err) > 0 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_InstanceType(t *testing.T) {
-	c := testConfig()
-	c.InstanceType = ""
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_SourceECSImage(t *testing.T) {
-	c := testConfig()
-	c.AlicloudSourceImage = ""
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_SSHPort(t *testing.T) {
-	c := testConfig()
-	c.Comm.SSHPort = 0
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	if c.Comm.SSHPort != 22 {
-		t.Fatalf("invalid value: %d", c.Comm.SSHPort)
-	}
-
-	c.Comm.SSHPort = 44
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	if c.Comm.SSHPort != 44 {
-		t.Fatalf("invalid value: %d", c.Comm.SSHPort)
-	}
-}
-
-func TestRunConfigPrepare_UserData(t *testing.T) {
-	c := testConfig()
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	defer os.Remove(tf.Name())
-	defer tf.Close()
-
-	c.UserData = "foo"
-	c.UserDataFile = tf.Name()
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_UserDataFile(t *testing.T) {
-	c := testConfig()
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	c.UserDataFile = "idontexistidontthink"
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	defer os.Remove(tf.Name())
-	defer tf.Close()
-
-	c.UserDataFile = tf.Name()
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_TemporaryKeyPairName(t *testing.T) {
-	c := testConfig()
-	c.TemporaryKeyPairName = ""
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	if c.TemporaryKeyPairName == "" {
-		t.Fatal("keypair name is empty")
-	}
-
-	c.TemporaryKeyPairName = "ssh-key-123"
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	if c.TemporaryKeyPairName != "ssh-key-123" {
-		t.Fatal("keypair name does not match")
-	}
-}

builder/alicloud/ecs/ssh_helper.go

@@ -1,83 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"net"
-	"os"
-	"time"
-
-	packerssh "github.com/hashicorp/packer/communicator/ssh"
-	"github.com/hashicorp/packer/helper/multistep"
-	"golang.org/x/crypto/ssh"
-	"golang.org/x/crypto/ssh/agent"
-)
-
-var (
-	// modified in tests
-	sshHostSleepDuration = time.Second
-)
-
-type alicloudSSHHelper interface {
-}
-
-// SSHHost returns a function that can be given to the SSH communicator
-func SSHHost(e alicloudSSHHelper, private bool) func(multistep.StateBag) (string, error) {
-	return func(state multistep.StateBag) (string, error) {
-		ipAddress := state.Get("ipaddress").(string)
-		return ipAddress, nil
-	}
-}
-
-// SSHConfig returns a function that can be used for the SSH communicator
-// config for connecting to the instance created over SSH using the private key
-// or password.
-func SSHConfig(useAgent bool, username, password string) func(multistep.StateBag) (*ssh.ClientConfig, error) {
-	return func(state multistep.StateBag) (*ssh.ClientConfig, error) {
-		if useAgent {
-			authSock := os.Getenv("SSH_AUTH_SOCK")
-			if authSock == "" {
-				return nil, fmt.Errorf("SSH_AUTH_SOCK is not set")
-			}
-
-			sshAgent, err := net.Dial("unix", authSock)
-			if err != nil {
-				return nil, fmt.Errorf("Cannot connect to SSH Agent socket %q: %s", authSock, err)
-			}
-
-			return &ssh.ClientConfig{
-				User: username,
-				Auth: []ssh.AuthMethod{
-					ssh.PublicKeysCallback(agent.NewClient(sshAgent).Signers),
-				},
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
-			}, nil
-		}
-
-		privateKey, hasKey := state.GetOk("privateKey")
-		if hasKey {
-
-			signer, err := ssh.ParsePrivateKey([]byte(privateKey.(string)))
-			if err != nil {
-				return nil, fmt.Errorf("Error setting up SSH config: %s", err)
-			}
-			return &ssh.ClientConfig{
-				User: username,
-				Auth: []ssh.AuthMethod{
-					ssh.PublicKeys(signer),
-				},
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
-			}, nil
-
-		} else {
-			return &ssh.ClientConfig{
-				User: username,
-				Auth: []ssh.AuthMethod{
-					ssh.Password(password),
-					ssh.KeyboardInteractive(
-						packerssh.PasswordKeyboardInteractive(password)),
-				},
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
-			}, nil
-		}
-	}
-}

builder/alicloud/ecs/step_attach_keypair.go

@@ -1,75 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"time"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepAttachKeyPar struct {
-}
-
-func (s *stepAttachKeyPar) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	keyPairName := state.Get("keyPair").(string)
-	if keyPairName == "" {
-		return multistep.ActionContinue
-	}
-	ui := state.Get("ui").(packer.Ui)
-	client := state.Get("client").(*ecs.Client)
-	config := state.Get("config").(Config)
-	instance := state.Get("instance").(*ecs.InstanceAttributesType)
-	timeoutPoint := time.Now().Add(120 * time.Second)
-	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 *stepAttachKeyPar) Cleanup(state multistep.StateBag) {
-	keyPairName := state.Get("keyPair").(string)
-	if keyPairName == "" {
-		return
-	}
-	client := state.Get("client").(*ecs.Client)
-	config := state.Get("config").(Config)
-	ui := state.Get("ui").(packer.Ui)
-	instance := state.Get("instance").(*ecs.InstanceAttributesType)
-
-	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)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return
-	}
-
-	ui.Message(fmt.Sprintf("Detach keypair %s from instance: %s", keyPairName, instance.InstanceId))
-
-}

builder/alicloud/ecs/step_check_source_image.go

@@ -1,43 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepCheckAlicloudSourceImage struct {
-	SourceECSImageId string
-}
-
-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)
-	images, _, err := client.DescribeImages(&ecs.DescribeImagesArgs{RegionId: common.Region(config.AlicloudRegion),
-		ImageId: config.AlicloudSourceImage})
-	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("No alicloud image was found matching filters: %v", config.AlicloudSourceImage)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Message(fmt.Sprintf("Found image ID: %s", images[0].ImageId))
-
-	state.Put("source_image", &images[0])
-	return multistep.ActionContinue
-}
-
-func (s *stepCheckAlicloudSourceImage) Cleanup(multistep.StateBag) {}

builder/alicloud/ecs/step_config_eip.go

@@ -1,80 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type setpConfigAlicloudEIP struct {
-	AssociatePublicIpAddress bool
-	RegionId                 string
-	InternetChargeType       string
-	allocatedId              string
-}
-
-func (s *setpConfigAlicloudEIP) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-	instance := state.Get("instance").(*ecs.InstanceAttributesType)
-	ui.Say("Allocating eip")
-	ipaddress, allocateId, err := client.AllocateEipAddress(&ecs.AllocateEipAddressArgs{
-		RegionId: common.Region(s.RegionId), InternetChargeType: common.InternetChargeType(s.InternetChargeType),
-	})
-	if err != nil {
-		state.Put("error", err)
-		ui.Say(fmt.Sprintf("Error allocating eip: %s", err))
-		return multistep.ActionHalt
-	}
-	s.allocatedId = allocateId
-	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
-	}
-
-	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
-	}
-
-	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
-}
-
-func (s *setpConfigAlicloudEIP) Cleanup(state multistep.StateBag) {
-	if len(s.allocatedId) == 0 {
-		return
-	}
-
-	client := state.Get("client").(*ecs.Client)
-	instance := state.Get("instance").(*ecs.InstanceAttributesType)
-	ui := state.Get("ui").(packer.Ui)
-
-	message(state, "EIP")
-
-	if err := client.UnassociateEipAddress(s.allocatedId, instance.InstanceId); err != nil {
-		ui.Say(fmt.Sprintf("Failed to unassociate eip."))
-	}
-
-	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."))
-	}
-
-}

builder/alicloud/ecs/step_config_key_pair.go

@@ -1,140 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"runtime"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type StepConfigAlicloudKeyPair struct {
-	Debug                bool
-	SSHAgentAuth         bool
-	DebugKeyPath         string
-	TemporaryKeyPairName string
-	KeyPairName          string
-	PrivateKeyFile       string
-	RegionId             string
-
-	keyName string
-}
-
-func (s *StepConfigAlicloudKeyPair) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-
-	if s.PrivateKeyFile != "" {
-		ui.Say("Using existing SSH private key")
-		privateKeyBytes, err := ioutil.ReadFile(s.PrivateKeyFile)
-		if err != nil {
-			state.Put("error", fmt.Errorf(
-				"Error loading configured private key file: %s", err))
-			return multistep.ActionHalt
-		}
-
-		state.Put("keyPair", s.KeyPairName)
-		state.Put("privateKey", string(privateKeyBytes))
-
-		return multistep.ActionContinue
-	}
-
-	if s.SSHAgentAuth && s.KeyPairName == "" {
-		ui.Say("Using SSH Agent with key pair in source image")
-		return multistep.ActionContinue
-	}
-
-	if s.SSHAgentAuth && s.KeyPairName != "" {
-		ui.Say(fmt.Sprintf("Using SSH Agent for existing key pair %s", s.KeyPairName))
-		state.Put("keyPair", s.KeyPairName)
-		return multistep.ActionContinue
-	}
-
-	if s.TemporaryKeyPairName == "" {
-		ui.Say("Not using temporary keypair")
-		state.Put("keyPair", "")
-		return multistep.ActionContinue
-	}
-
-	client := state.Get("client").(*ecs.Client)
-
-	ui.Say(fmt.Sprintf("Creating temporary keypair: %s", s.TemporaryKeyPairName))
-	keyResp, err := client.CreateKeyPair(&ecs.CreateKeyPairArgs{
-		KeyPairName: s.TemporaryKeyPairName,
-		RegionId:    common.Region(s.RegionId),
-	})
-	if err != nil {
-		state.Put("error", fmt.Errorf("Error creating temporary keypair: %s", err))
-		return multistep.ActionHalt
-	}
-
-	// Set the keyname so we know to delete it later
-	s.keyName = s.TemporaryKeyPairName
-
-	// Set some state data for use in future steps
-	state.Put("keyPair", s.keyName)
-	state.Put("privateKey", keyResp.PrivateKeyBody)
-
-	// If we're in debug mode, output the private key to the working
-	// directory.
-	if s.Debug {
-		ui.Message(fmt.Sprintf("Saving key for debug purposes: %s", s.DebugKeyPath))
-		f, err := os.Create(s.DebugKeyPath)
-		if err != nil {
-			state.Put("error", fmt.Errorf("Error saving debug key: %s", err))
-			return multistep.ActionHalt
-		}
-		defer f.Close()
-
-		// Write the key out
-		if _, err := f.Write([]byte(keyResp.PrivateKeyBody)); err != nil {
-			state.Put("error", fmt.Errorf("Error saving debug key: %s", err))
-			return multistep.ActionHalt
-		}
-
-		// Chmod it so that it is SSH ready
-		if runtime.GOOS != "windows" {
-			if err := f.Chmod(0600); err != nil {
-				state.Put("error", fmt.Errorf("Error setting permissions of debug key: %s", err))
-				return multistep.ActionHalt
-			}
-		}
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepConfigAlicloudKeyPair) Cleanup(state multistep.StateBag) {
-	// If no key name is set, then we never created it, so just return
-	// If we used an SSH private key file, do not go about deleting
-	// keypairs
-	if s.PrivateKeyFile != "" || (s.KeyPairName == "" && s.keyName == "") {
-		return
-	}
-
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-
-	// Remove the keypair
-	ui.Say("Deleting temporary keypair...")
-	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))
-	}
-
-	// Also remove the physical key if we're debugging.
-	if s.Debug {
-		if err := os.Remove(s.DebugKeyPath); err != nil {
-			ui.Error(fmt.Sprintf(
-				"Error removing debug key '%s': %s", s.DebugKeyPath, err))
-		}
-	}
-}

builder/alicloud/ecs/step_config_public_ip.go

@@ -1,36 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepConfigAlicloudPublicIP struct {
-	publicIPAddress string
-	RegionId        string
-}
-
-func (s *stepConfigAlicloudPublicIP) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-	instance := state.Get("instance").(*ecs.InstanceAttributesType)
-
-	ipaddress, err := client.AllocatePublicIpAddress(instance.InstanceId)
-	if err != nil {
-		state.Put("error", err)
-		ui.Say(fmt.Sprintf("Error allocating public ip: %s", err))
-		return multistep.ActionHalt
-	}
-	s.publicIPAddress = ipaddress
-	ui.Say(fmt.Sprintf("Allocated public ip address %s.", ipaddress))
-	state.Put("ipaddress", ipaddress)
-	return multistep.ActionContinue
-}
-
-func (s *stepConfigAlicloudPublicIP) Cleanup(state multistep.StateBag) {
-
-}

builder/alicloud/ecs/step_config_security_group.go

@@ -1,138 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepConfigAlicloudSecurityGroup struct {
-	SecurityGroupId   string
-	SecurityGroupName string
-	Description       string
-	VpcId             string
-	RegionId          string
-	isCreate          bool
-}
-
-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 {
-		if networkType == VpcNet {
-			vpcId := state.Get("vpcid").(string)
-			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),
-			})
-		}
-
-		if err != nil {
-			ui.Say(fmt.Sprintf("Failed querying security group: %s", err))
-			state.Put("error", err)
-			return multistep.ActionHalt
-		}
-		for _, securityGroupItem := range securityGroupItems {
-			if securityGroupItem.SecurityGroupId == s.SecurityGroupId {
-				state.Put("securitygroupid", s.SecurityGroupId)
-				s.isCreate = false
-				return multistep.ActionContinue
-			}
-		}
-		s.isCreate = false
-		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,
-		})
-	}
-	if err != nil {
-		state.Put("error", err)
-		ui.Say(fmt.Sprintf("Failed creating security group %s.", err))
-		return multistep.ActionHalt
-	}
-	state.Put("securitygroupid", securityGroupId)
-	s.isCreate = true
-	s.SecurityGroupId = securityGroupId
-	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
-	}
-	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
-}
-
-func (s *stepConfigAlicloudSecurityGroup) Cleanup(state multistep.StateBag) {
-	if !s.isCreate {
-		return
-	}
-
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-
-	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
-	}
-}

builder/alicloud/ecs/step_config_vpc.go

@@ -1,97 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepConfigAlicloudVPC struct {
-	VpcId     string
-	CidrBlock string //192.168.0.0/16 or 172.16.0.0/16 (default)
-	VpcName   string
-	isCreate  bool
-}
-
-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 {
-		vpcs, _, err := client.DescribeVpcs(&ecs.DescribeVpcsArgs{
-			VpcId:    s.VpcId,
-			RegionId: common.Region(config.AlicloudRegion),
-		})
-		if err != nil {
-			ui.Say(fmt.Sprintf("Failed querying vpcs: %s", err))
-			state.Put("error", err)
-			return multistep.ActionHalt
-		}
-		if len(vpcs) > 0 {
-			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)
-		state.Put("error", errors.New(message))
-		ui.Say(message)
-		return multistep.ActionHalt
-
-	}
-	ui.Say("Creating vpc")
-	vpc, err := client.CreateVpc(&ecs.CreateVpcArgs{
-		RegionId:  common.Region(config.AlicloudRegion),
-		CidrBlock: s.CidrBlock,
-		VpcName:   s.VpcName,
-	})
-	if err != nil {
-		state.Put("error", err)
-		ui.Say(fmt.Sprintf("Failed creating vpc: %s", err))
-		return multistep.ActionHalt
-	}
-	err = client.WaitForVpcAvailable(common.Region(config.AlicloudRegion), vpc.VpcId, ALICLOUD_DEFAULT_SHORT_TIMEOUT)
-	if err != nil {
-		state.Put("error", err)
-		ui.Say(fmt.Sprintf("Failed waiting for vpc to become available: %s", err))
-		return multistep.ActionHalt
-	}
-
-	state.Put("vpcid", vpc.VpcId)
-	s.isCreate = true
-	s.VpcId = vpc.VpcId
-	return multistep.ActionContinue
-}
-
-func (s *stepConfigAlicloudVPC) Cleanup(state multistep.StateBag) {
-	if !s.isCreate {
-		return
-	}
-
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-
-	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") && 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
-	}
-}

builder/alicloud/ecs/step_config_vswitch.go

@@ -1,149 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepConfigAlicloudVSwitch struct {
-	VSwitchId   string
-	ZoneId      string
-	isCreate    bool
-	CidrBlock   string
-	VSwitchName string
-}
-
-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)
-
-	if len(s.VSwitchId) != 0 {
-		vswitchs, _, err := client.DescribeVSwitches(&ecs.DescribeVSwitchesArgs{
-			VpcId:     vpcId,
-			VSwitchId: s.VSwitchId,
-			ZoneId:    s.ZoneId,
-		})
-		if err != nil {
-			ui.Say(fmt.Sprintf("Failed querying vswitch: %s", err))
-			state.Put("error", err)
-			return multistep.ActionHalt
-		}
-		if len(vswitchs) > 0 {
-			vswitch := vswitchs[0]
-			state.Put("vswitchid", vswitch.VSwitchId)
-			s.isCreate = false
-			return multistep.ActionContinue
-		}
-		s.isCreate = false
-		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 == "" {
-
-		zones, err := client.DescribeZones(common.Region(config.AlicloudRegion))
-		if err != nil {
-			ui.Say(fmt.Sprintf("Query for available zones failed: %s", err))
-			state.Put("error", err)
-			return multistep.ActionHalt
-		}
-		var instanceTypes []string
-		for _, zone := range zones {
-			isVSwitchSupported := false
-			for _, resourceType := range zone.AvailableResourceCreation.ResourceTypes {
-				if resourceType == ecs.ResourceTypeVSwitch {
-					isVSwitchSupported = true
-				}
-			}
-			if isVSwitchSupported {
-				for _, instanceType := range zone.AvailableInstanceTypes.InstanceTypes {
-					if instanceType == config.InstanceType {
-						s.ZoneId = zone.ZoneId
-						break
-					}
-					instanceTypes = append(instanceTypes, instanceType)
-				}
-			}
-		}
-
-		if s.ZoneId == "" {
-			if len(instanceTypes) > 0 {
-				ui.Say(fmt.Sprintf("The instance type %s isn't available in this region."+
-					"\n You can either change the instance to one of following: %v \n"+
-					"or choose another region.", config.InstanceType, instanceTypes))
-
-				state.Put("error", fmt.Errorf("The instance type %s isn't available in this region."+
-					"\n You can either change the instance to one of following: %v \n"+
-					"or choose another region.", config.InstanceType, instanceTypes))
-				return multistep.ActionHalt
-			} else {
-				ui.Say(fmt.Sprintf("The instance type %s isn't available in this region."+
-					"\n You can change to other regions.", config.InstanceType))
-
-				state.Put("error", fmt.Errorf("The instance type %s isn't available in this region."+
-					"\n You can change to other regions.", config.InstanceType))
-				return multistep.ActionHalt
-			}
-		}
-	}
-	if config.CidrBlock == "" {
-		s.CidrBlock = "172.16.0.0/24" //use the default CirdBlock
-	}
-	ui.Say("Creating vswitch...")
-	vswitchId, err := client.CreateVSwitch(&ecs.CreateVSwitchArgs{
-		CidrBlock:   s.CidrBlock,
-		ZoneId:      s.ZoneId,
-		VpcId:       vpcId,
-		VSwitchName: s.VSwitchName,
-	})
-	if err != nil {
-		state.Put("error", err)
-		ui.Say(fmt.Sprintf("Create vswitch failed %v", err))
-		return multistep.ActionHalt
-	}
-	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
-	}
-	state.Put("vswitchid", vswitchId)
-	s.isCreate = true
-	s.VSwitchId = vswitchId
-	return multistep.ActionContinue
-}
-
-func (s *stepConfigAlicloudVSwitch) Cleanup(state multistep.StateBag) {
-	if !s.isCreate {
-		return
-	}
-
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-	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
-	}
-}

builder/alicloud/ecs/step_create_image.go

@@ -1,95 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepCreateAlicloudImage struct {
-	image *ecs.ImageType
-}
-
-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)
-
-	// Create the alicloud image
-	ui.Say(fmt.Sprintf("Creating image: %s", config.AlicloudImageName))
-	var imageId string
-	var err error
-
-	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 {
-		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
-	}
-
-	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
-	}
-
-	if len(images) == 0 {
-		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]
-
-	state.Put("alicloudimage", imageId)
-	alicloudImages := make(map[string]string)
-	alicloudImages[config.AlicloudRegion] = images[0].ImageId
-	state.Put("alicloudimages", alicloudImages)
-
-	return multistep.ActionContinue
-}
-
-func (s *stepCreateAlicloudImage) Cleanup(state multistep.StateBag) {
-	if s.image == nil {
-		return
-	}
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-	if !cancelled && !halted {
-		return
-	}
-
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-	config := state.Get("config").(Config)
-
-	ui.Say("Deleting the image because of cancellation or error...")
-	if err := client.DeleteImage(common.Region(config.AlicloudRegion), s.image.ImageId); err != nil {
-		ui.Error(fmt.Sprintf("Error deleting image, it may still be around: %s", err))
-		return
-	}
-}

builder/alicloud/ecs/step_create_instance.go

@@ -1,164 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-	"io/ioutil"
-	"log"
-
-	"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             bool
-	InstanceType            string
-	UserData                string
-	UserDataFile            string
-	instanceId              string
-	RegionId                string
-	InternetChargeType      string
-	InternetMaxBandwidthOut int
-	InstanceName            string
-	ZoneId                  string
-	instance                *ecs.InstanceAttributesType
-}
-
-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
-
-	ioOptimized := ecs.IoOptimizedNone
-	if s.IOOptimized {
-		ioOptimized = ecs.IoOptimizedOptimized
-	}
-	password := config.Comm.SSHPassword
-	if password == "" && config.Comm.WinRMPassword != "" {
-		password = config.Comm.WinRMPassword
-	}
-	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
-		}
-	}
-	err = client.WaitForInstance(instanceId, ecs.Stopped, ALICLOUD_DEFAULT_TIMEOUT)
-	if err != nil {
-		err := fmt.Errorf("Error creating instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	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
-}
-
-func (s *stepCreateAlicloudInstance) Cleanup(state multistep.StateBag) {
-	if s.instance == nil {
-		return
-	}
-	message(state, "instance")
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-	err := client.DeleteInstance(s.instance.InstanceId)
-	if err != nil {
-		ui.Say(fmt.Sprintf("Failed to clean up instance %s: %v", s.instance.InstanceId, err.Error()))
-	}
-
-}
-
-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)
-	}
-	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_delete_images_snapshots.go

@@ -1,64 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepDeleteAlicloudImageSnapshots struct {
-	AlicloudImageForceDelete          bool
-	AlicloudImageForceDeleteSnapshots bool
-	AlicloudImageName                 string
-}
-
-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 {
-		images, _, err := client.DescribeImages(&ecs.DescribeImagesArgs{
-			RegionId:  common.Region(config.AlicloudRegion),
-			ImageName: s.AlicloudImageName,
-		})
-		if len(images) < 1 {
-			return multistep.ActionContinue
-		}
-		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
-			}
-			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
-					}
-				}
-			}
-		}
-
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *stepDeleteAlicloudImageSnapshots) Cleanup(state multistep.StateBag) {
-}

builder/alicloud/ecs/step_mount_disk.go

@@ -1,72 +0,0 @@
-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

@@ -1,49 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepPreValidate struct {
-	AlicloudDestImageName string
-	ForceDelete           bool
-}
-
-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
-	}
-
-	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) Cleanup(multistep.StateBag) {}

builder/alicloud/ecs/step_region_copy_image.go

@@ -1,72 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type setpRegionCopyAlicloudImage struct {
-	AlicloudImageDestinationRegions []string
-	AlicloudImageDestinationNames   []string
-	RegionId                        string
-}
-
-func (s *setpRegionCopyAlicloudImage) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	if len(s.AlicloudImageDestinationRegions) == 0 {
-		return multistep.ActionContinue
-	}
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-	imageId := state.Get("alicloudimage").(string)
-	alicloudImages := state.Get("alicloudimages").(map[string]string)
-	region := common.Region(s.RegionId)
-
-	numberOfName := len(s.AlicloudImageDestinationNames)
-	for index, destinationRegion := range s.AlicloudImageDestinationRegions {
-		if destinationRegion == s.RegionId {
-			continue
-		}
-		ecsImageName := ""
-		if numberOfName > 0 && index < numberOfName {
-			ecsImageName = s.AlicloudImageDestinationNames[index]
-		}
-		imageId, err := client.CopyImage(
-			&ecs.CopyImageArgs{
-				RegionId:             region,
-				ImageId:              imageId,
-				DestinationRegionId:  common.Region(destinationRegion),
-				DestinationImageName: ecsImageName,
-			})
-		if err != nil {
-			state.Put("error", err)
-			ui.Say(fmt.Sprintf("Error copying images: %s", err))
-			return multistep.ActionHalt
-		}
-		alicloudImages[destinationRegion] = imageId
-	}
-	return multistep.ActionContinue
-}
-
-func (s *setpRegionCopyAlicloudImage) Cleanup(state multistep.StateBag) {
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-	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

@@ -1,57 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepRunAlicloudInstance struct {
-}
-
-func (s *stepRunAlicloudInstance) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*ecs.Client)
-	ui := state.Get("ui").(packer.Ui)
-	instance := state.Get("instance").(*ecs.InstanceAttributesType)
-
-	err := client.StartInstance(instance.InstanceId)
-	if err != nil {
-		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
-}
-
-func (s *stepRunAlicloudInstance) Cleanup(state multistep.StateBag) {
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-	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

@@ -1,61 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type setpShareAlicloudImage struct {
-	AlicloudImageShareAccounts   []string
-	AlicloudImageUNShareAccounts []string
-	RegionId                     string
-}
-
-func (s *setpShareAlicloudImage) 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 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
-}
-
-func (s *setpShareAlicloudImage) Cleanup(state multistep.StateBag) {
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-	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

@@ -1,44 +0,0 @@
-package ecs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-)
-
-type stepStopAlicloudInstance struct {
-	ForceStop bool
-}
-
-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)
-
-	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
-		}
-	}
-
-	err = client.WaitForInstance(instance.InstanceId, ecs.Stopped, ALICLOUD_DEFAULT_TIMEOUT)
-	if err != nil {
-		err := fmt.Errorf("Error waiting for alicloud instance to stop: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *stepStopAlicloudInstance) Cleanup(multistep.StateBag) {
-	// No cleanup...
-}

builder/amazon/chroot/builder.go

@@ -9,13 +9,14 @@ import (
 	"log"
 	"runtime"
 
+	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/common"
-	"github.com/hashicorp/packer/helper/config"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/multistep"
+	awscommon "github.com/mitchellh/packer/builder/amazon/common"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/helper/config"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 // The unique ID for this builder
@@ -33,10 +34,9 @@ type Config struct {
 	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"`
+	MountPartition    int                        `mapstructure:"mount_partition"`
 	MountPath         string                     `mapstructure:"mount_path"`
 	PostMountCommands []string                   `mapstructure:"post_mount_commands"`
 	PreMountCommands  []string                   `mapstructure:"pre_mount_commands"`
@@ -87,6 +87,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.ChrootMounts = make([][]string, 0)
 	}
 
+	if b.config.CopyFiles == nil {
+		b.config.CopyFiles = make([]string, 0)
+	}
+
 	if len(b.config.ChrootMounts) == 0 {
 		b.config.ChrootMounts = [][]string{
 			{"proc", "proc", "/proc"},
@@ -97,12 +101,8 @@ 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"}
-		}
+	if len(b.config.CopyFiles) == 0 && !b.config.FromScratch {
+		b.config.CopyFiles = []string{"/etc/resolv.conf"}
 	}
 
 	if b.config.CommandWrapper == "" {
@@ -113,8 +113,8 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.MountPath = "/mnt/packer-amazon-chroot-volumes/{{.Device}}"
 	}
 
-	if b.config.MountPartition == "" {
-		b.config.MountPartition = "1"
+	if b.config.MountPartition == 0 {
+		b.config.MountPartition = 1
 	}
 
 	// Accumulate any errors or warnings
@@ -122,8 +122,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	var warns []string
 
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(&b.config.ctx)...)
-	errs = packer.MultiErrorAppend(errs,
-		b.config.AMIConfig.Prepare(&b.config.AccessConfig, &b.config.ctx)...)
+	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(&b.config.ctx)...)
 
 	for _, mounts := range b.config.ChrootMounts {
 		if len(mounts) != 3 {
@@ -174,7 +173,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		return warns, errs
 	}
 
-	log.Println(common.ScrubConfig(b.config, b.config.AccessKey, b.config.SecretKey, b.config.Token))
+	log.Println(common.ScrubConfig(b.config, b.config.AccessKey, b.config.SecretKey))
 	return warns, nil
 }
 
@@ -183,7 +182,12 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		return nil, errors.New("The amazon-chroot builder only works on Linux environments.")
 	}
 
-	session, err := b.config.Session()
+	config, err := b.config.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	session, err := session.NewSession(config)
 	if err != nil {
 		return nil, err
 	}
@@ -199,7 +203,6 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
 	state.Put("ec2", ec2conn)
-	state.Put("awsSession", session)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 	state.Put("wrappedCommand", CommandWrapper(wrappedCommand))
@@ -216,10 +219,9 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	if !b.config.FromScratch {
 		steps = append(steps,
 			&awscommon.StepSourceAMIInfo{
-				SourceAmi:                b.config.SourceAmi,
-				EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-				EnableAMIENASupport:      b.config.AMIENASupport,
-				AmiFilters:               b.config.SourceAmiFilter,
+				SourceAmi:          b.config.SourceAmi,
+				EnhancedNetworking: b.config.AMIEnhancedNetworking,
+				AmiFilters:         b.config.SourceAmiFilter,
 			},
 			&StepCheckRootDevice{},
 		)
@@ -249,29 +251,22 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&StepEarlyCleanup{},
 		&StepSnapshot{},
 		&awscommon.StepDeregisterAMI{
-			AccessConfig:        &b.config.AccessConfig,
 			ForceDeregister:     b.config.AMIForceDeregister,
 			ForceDeleteSnapshot: b.config.AMIForceDeleteSnapshot,
 			AMIName:             b.config.AMIName,
-			Regions:             b.config.AMIRegions,
 		},
 		&StepRegisterAMI{
-			RootVolumeSize:           b.config.RootVolumeSize,
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
+			RootVolumeSize: b.config.RootVolumeSize,
 		},
 		&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,
-			RegionKeyIds:      b.config.AMIRegionKMSKeyIDs,
-			EncryptBootVolume: b.config.AMIEncryptBootVolume,
-			Name:              b.config.AMIName,
+			AccessConfig: &b.config.AccessConfig,
+			Regions:      b.config.AMIRegions,
+			Name:         b.config.AMIName,
 		},
 		&awscommon.StepModifyAMIAttributes{
 			Description:    b.config.AMIDescription,
@@ -307,7 +302,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	artifact := &awscommon.Artifact{
 		Amis:           state.Get("amis").(map[string]string),
 		BuilderIdValue: BuilderId,
-		Session:        session,
+		Conn:           ec2conn,
 	}
 
 	return artifact, nil

builder/amazon/chroot/builder_test.go

@@ -1,16 +1,14 @@
 package chroot
 
 import (
+	"github.com/mitchellh/packer/packer"
 	"testing"
-
-	"github.com/hashicorp/packer/packer"
 )
 
 func testConfig() map[string]interface{} {
 	return map[string]interface{}{
 		"ami_name":   "foo",
 		"source_ami": "foo",
-		"region":     "us-east-1",
 	}
 }
 
@@ -71,16 +69,11 @@ func TestBuilderPrepare_ChrootMounts(t *testing.T) {
 	if err != nil {
 		t.Errorf("err: %s", err)
 	}
-}
-
-func TestBuilderPrepare_ChrootMountsBadDefaults(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
 
 	config["chroot_mounts"] = [][]string{
 		{"bad"},
 	}
-	warnings, err := b.Prepare(config)
+	warnings, err = b.Prepare(config)
 	if len(warnings) > 0 {
 		t.Fatalf("bad: %#v", warnings)
 	}
@@ -124,38 +117,3 @@ func TestBuilderPrepare_CommandWrapper(t *testing.T) {
 		t.Errorf("err: %s", err)
 	}
 }
-
-func TestBuilderPrepare_CopyFiles(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-
-	if len(b.config.CopyFiles) != 1 && b.config.CopyFiles[0] != "/etc/resolv.conf" {
-		t.Errorf("Was expecting default value for copy_files.")
-	}
-}
-
-func TestBuilderPrepare_CopyFilesNoDefault(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["copy_files"] = []string{}
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-
-	if len(b.config.CopyFiles) > 0 {
-		t.Errorf("Was expecting no default value for copy_files.")
-	}
-}

builder/amazon/chroot/cleanup.go

@@ -1,7 +1,7 @@
 package chroot
 
 import (
-	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/mitchellh/multistep"
 )
 
 // Cleanup is an interface that some steps implement for early cleanup.

builder/amazon/chroot/communicator.go

@@ -12,7 +12,7 @@ import (
 	"strings"
 	"syscall"
 
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/packer"
 )
 
 // Communicator is a special communicator that works by executing
@@ -69,10 +69,7 @@ func (c *Communicator) Upload(dst string, r io.Reader, fi *os.FileInfo) error {
 		return fmt.Errorf("Error preparing shell script: %s", err)
 	}
 	defer os.Remove(tf.Name())
-
-	if _, err := io.Copy(tf, r); err != nil {
-		return err
-	}
+	io.Copy(tf, r)
 
 	cpCmd, err := c.CmdWrapper(fmt.Sprintf("cp %s %s", tf.Name(), dst))
 	if err != nil {

builder/amazon/chroot/communicator_test.go

@@ -1,9 +1,8 @@
 package chroot
 
 import (
+	"github.com/mitchellh/packer/packer"
 	"testing"
-
-	"github.com/hashicorp/packer/packer"
 )
 
 func TestCommunicator_ImplementsCommunicator(t *testing.T) {

builder/amazon/chroot/device_test.go

@@ -1,10 +0,0 @@
-package chroot
-
-import "testing"
-
-func TestDevicePrefixMatch(t *testing.T) {
-	/*
-		if devicePrefixMatch("nvme0n1") != "" {
-		}
-	*/
-}

builder/amazon/chroot/lockfile_unix.go

@@ -4,8 +4,7 @@ package chroot
 
 import (
 	"os"
-
-	"golang.org/x/sys/unix"
+	"syscall"
 )
 
 // See: http://linux.die.net/include/sys/file.h
@@ -14,7 +13,7 @@ const LOCK_NB = 4
 const LOCK_UN = 8
 
 func lockFile(f *os.File) error {
-	err := unix.Flock(int(f.Fd()), LOCK_EX)
+	err := syscall.Flock(int(f.Fd()), LOCK_EX)
 	if err != nil {
 		return err
 	}
@@ -23,5 +22,5 @@ func lockFile(f *os.File) error {
 }
 
 func unlockFile(f *os.File) error {
-	return unix.Flock(int(f.Fd()), LOCK_UN)
+	return syscall.Flock(int(f.Fd()), LOCK_UN)
 }

builder/amazon/chroot/run_local_commands.go

@@ -3,9 +3,9 @@ package chroot
 import (
 	"fmt"
 
-	sl "github.com/hashicorp/packer/common/shell-local"
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/post-processor/shell-local"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 func RunLocalCommands(commands []string, wrappedCommand CommandWrapper, ctx interpolate.Context, ui packer.Ui) error {
@@ -21,9 +21,7 @@ func RunLocalCommands(commands []string, wrappedCommand CommandWrapper, ctx inte
 		}
 
 		ui.Say(fmt.Sprintf("Executing command: %s", command))
-		comm := &sl.Communicator{
-			ExecuteCommand: []string{command},
-		}
+		comm := &shell_local.Communicator{}
 		cmd := &packer.RemoteCmd{Command: command}
 		if err := cmd.StartWithUi(comm, ui); err != nil {
 			return fmt.Errorf("Error executing command: %s", err)

builder/amazon/chroot/step_attach_volume.go

@@ -1,16 +1,15 @@
 package chroot
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"strings"
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	awscommon "github.com/mitchellh/packer/builder/amazon/common"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepAttachVolume attaches the previously created volume to an
@@ -24,7 +23,7 @@ type StepAttachVolume struct {
 	volumeId string
 }
 
-func (s *StepAttachVolume) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepAttachVolume) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	device := state.Get("device").(string)
 	instance := state.Get("instance").(*ec2.Instance)

builder/amazon/chroot/step_check_root_device.go

@@ -1,18 +1,17 @@
 package chroot
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepCheckRootDevice makes sure the root device on the AMI is EBS-backed.
 type StepCheckRootDevice struct{}
 
-func (s *StepCheckRootDevice) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCheckRootDevice) Run(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

@@ -1,18 +1,17 @@
 package chroot
 
 import (
-	"context"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 )
 
 // StepChrootProvision provisions the instance within a chroot.
 type StepChrootProvision struct {
+	mounts []string
 }
 
-func (s *StepChrootProvision) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepChrootProvision) Run(state multistep.StateBag) multistep.StepAction {
 	hook := state.Get("hook").(packer.Hook)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)

builder/amazon/chroot/step_copy_files.go

@@ -2,13 +2,11 @@ package chroot
 
 import (
 	"bytes"
-	"context"
 	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 	"path/filepath"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 )
 
 // StepCopyFiles copies some files from the host into the chroot environment.
@@ -20,7 +18,7 @@ type StepCopyFiles struct {
 	files []string
 }
 
-func (s *StepCopyFiles) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCopyFiles) Run(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

@@ -1,15 +1,14 @@
 package chroot
 
 import (
-	"context"
 	"fmt"
 	"log"
 
 	"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/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	awscommon "github.com/mitchellh/packer/builder/amazon/common"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepCreateVolume creates a new volume from the snapshot of the root
@@ -22,7 +21,7 @@ type StepCreateVolume struct {
 	RootVolumeSize int64
 }
 
-func (s *StepCreateVolume) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCreateVolume) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	instance := state.Get("instance").(*ec2.Instance)

builder/amazon/chroot/step_early_cleanup.go

@@ -1,19 +1,17 @@
 package chroot
 
 import (
-	"context"
 	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 )
 
 // StepEarlyCleanup performs some of the cleanup steps early in order to
 // prepare for snapshotting and creating an AMI.
 type StepEarlyCleanup struct{}
 
-func (s *StepEarlyCleanup) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepEarlyCleanup) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 	cleanupKeys := []string{
 		"copy_files_cleanup",

builder/amazon/chroot/step_early_unflock.go

@@ -1,18 +1,16 @@
 package chroot
 
 import (
-	"context"
 	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 )
 
 // StepEarlyUnflock unlocks the flock.
 type StepEarlyUnflock struct{}
 
-func (s *StepEarlyUnflock) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepEarlyUnflock) Run(state multistep.StateBag) multistep.StepAction {
 	cleanup := state.Get("flock_cleanup").(Cleanup)
 	ui := state.Get("ui").(packer.Ui)
 

builder/amazon/chroot/step_flock.go

@@ -1,14 +1,12 @@
 package chroot
 
 import (
-	"context"
 	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
 	"path/filepath"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 )
 
 // StepFlock provisions the instance within a chroot.
@@ -19,7 +17,7 @@ type StepFlock struct {
 	fh *os.File
 }
 
-func (s *StepFlock) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepFlock) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	lockfile := "/var/lock/packer-chroot/lock"

builder/amazon/chroot/step_instance_info.go

@@ -1,31 +1,27 @@
 package chroot
 
 import (
-	"context"
 	"fmt"
 	"log"
 
-	"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/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/builder/amazon/common"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepInstanceInfo verifies that this builder is running on an EC2 instance.
 type StepInstanceInfo struct{}
 
-func (s *StepInstanceInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepInstanceInfo) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
-	session := state.Get("awsSession").(*session.Session)
 	ui := state.Get("ui").(packer.Ui)
 
 	// Get our own instance ID
 	ui.Say("Gathering information about this EC2 instance...")
-
-	ec2meta := ec2metadata.New(session)
-	identity, err := ec2meta.GetInstanceIdentityDocument()
+	instanceIdBytes, err := common.GetInstanceMetaData("instance-id")
 	if err != nil {
+		log.Printf("Error: %s", err)
 		err := fmt.Errorf(
 			"Error retrieving the ID of the instance Packer is running on.\n" +
 				"Please verify Packer is running on a proper AWS EC2 instance.")
@@ -33,10 +29,12 @@ func (s *StepInstanceInfo) Run(_ context.Context, state multistep.StateBag) mult
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
-	log.Printf("Instance ID: %s", identity.InstanceID)
+
+	instanceId := string(instanceIdBytes)
+	log.Printf("Instance ID: %s", instanceId)
 
 	// Query the entire instance metadata
-	instancesResp, err := ec2conn.DescribeInstances(&ec2.DescribeInstancesInput{InstanceIds: []*string{&identity.InstanceID}})
+	instancesResp, err := ec2conn.DescribeInstances(&ec2.DescribeInstancesInput{InstanceIds: []*string{&instanceId}})
 	if err != nil {
 		err := fmt.Errorf("Error getting instance data: %s", err)
 		state.Put("error", err)

builder/amazon/chroot/step_mount_device.go

@@ -2,7 +2,6 @@ package chroot
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"log"
 	"os"
@@ -10,9 +9,9 @@ import (
 	"strings"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 type mountPathData struct {
@@ -26,19 +25,15 @@ type mountPathData struct {
 //   mount_device_cleanup CleanupFunc - To perform early cleanup
 type StepMountDevice struct {
 	MountOptions   []string
-	MountPartition string
+	MountPartition int
 
 	mountPath string
 }
 
-func (s *StepMountDevice) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepMountDevice) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
 	device := state.Get("device").(string)
-	if config.NVMEDevicePath != "" {
-		// customizable device path for mounting NVME block devices on c5 and m5 HVM
-		device = config.NVMEDevicePath
-	}
 	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 
 	var virtualizationType string
@@ -51,7 +46,6 @@ func (s *StepMountDevice) Run(_ context.Context, state multistep.StateBag) multi
 	}
 
 	ctx := config.ctx
-
 	ctx.Data = &mountPathData{Device: filepath.Base(device)}
 	mountPath, err := interpolate.Render(config.MountPath, &ctx)
 
@@ -80,16 +74,15 @@ func (s *StepMountDevice) Run(_ context.Context, state multistep.StateBag) multi
 	}
 
 	deviceMount := device
-
-	if virtualizationType == "hvm" && s.MountPartition != "0" {
-		deviceMount = fmt.Sprintf("%s%s", device, s.MountPartition)
+	if virtualizationType == "hvm" {
+		deviceMount = fmt.Sprintf("%s%d", device, s.MountPartition)
 	}
 	state.Put("deviceMount", deviceMount)
 
 	ui.Say("Mounting the root device...")
 	stderr := new(bytes.Buffer)
 
-	// build mount options from mount_options config, useful for nouuid options
+	// build mount options from mount_options config, usefull for nouuid options
 	// or other specific device type settings for mount
 	opts := ""
 	if len(s.MountOptions) > 0 {
@@ -103,7 +96,7 @@ func (s *StepMountDevice) Run(_ context.Context, state multistep.StateBag) multi
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
-	log.Printf("[DEBUG] (step mount) mount command is %s", mountCommand)
+
 	cmd := ShellCommand(mountCommand)
 	cmd.Stderr = stderr
 	if err := cmd.Run(); err != nil {

builder/amazon/chroot/step_mount_extra.go

@@ -2,14 +2,12 @@ package chroot
 
 import (
 	"bytes"
-	"context"
 	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"os"
 	"os/exec"
 	"syscall"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 )
 
 // StepMountExtra mounts the attached device.
@@ -20,7 +18,7 @@ type StepMountExtra struct {
 	mounts []string
 }
 
-func (s *StepMountExtra) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepMountExtra) Run(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

@@ -1,10 +1,8 @@
 package chroot
 
 import (
-	"context"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type postMountCommandsData struct {
@@ -18,7 +16,7 @@ type StepPostMountCommands struct {
 	Commands []string
 }
 
-func (s *StepPostMountCommands) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepPostMountCommands) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	device := state.Get("device").(string)
 	mountPath := state.Get("mount_path").(string)

builder/amazon/chroot/step_pre_mount_commands.go

@@ -1,10 +1,8 @@
 package chroot
 
 import (
-	"context"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type preMountCommandsData struct {
@@ -16,7 +14,7 @@ type StepPreMountCommands struct {
 	Commands []string
 }
 
-func (s *StepPreMountCommands) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepPreMountCommands) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	device := state.Get("device").(string)
 	ui := state.Get("ui").(packer.Ui)

builder/amazon/chroot/step_prepare_device.go

@@ -1,20 +1,19 @@
 package chroot
 
 import (
-	"context"
 	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
-
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 )
 
 // StepPrepareDevice finds an available device and sets it.
 type StepPrepareDevice struct {
+	mounts []string
 }
 
-func (s *StepPrepareDevice) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepPrepareDevice) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
 

builder/amazon/chroot/step_register_ami.go

@@ -1,24 +1,21 @@
 package chroot
 
 import (
-	"context"
 	"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/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	awscommon "github.com/mitchellh/packer/builder/amazon/common"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepRegisterAMI creates the AMI.
 type StepRegisterAMI struct {
-	RootVolumeSize           int64
-	EnableAMIENASupport      bool
-	EnableAMISriovNetSupport bool
+	RootVolumeSize int64
 }
 
-func (s *StepRegisterAMI) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	snapshotId := state.Get("snapshot_id").(string)
@@ -78,12 +75,11 @@ func (s *StepRegisterAMI) Run(_ context.Context, state multistep.StateBag) multi
 		registerOpts = buildRegisterOpts(config, image, newMappings)
 	}
 
-	if s.EnableAMISriovNetSupport {
+	if config.AMIEnhancedNetworking {
 		// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
 		// 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 {
+
 		// Set EnaSupport to true
 		// As of February 2017, this applies to C5, I3, P2, R4, X1, and m4.16xlarge
 		registerOpts.EnaSupport = aws.Bool(true)

builder/amazon/chroot/step_snapshot.go

@@ -1,15 +1,14 @@
 package chroot
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	awscommon "github.com/mitchellh/packer/builder/amazon/common"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepSnapshot creates a snapshot of the created volume.
@@ -20,7 +19,7 @@ type StepSnapshot struct {
 	snapshotId string
 }
 
-func (s *StepSnapshot) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 	volumeId := state.Get("volume_id").(string)

builder/amazon/common/access_config.go

@@ -2,147 +2,118 @@ package common
 
 import (
 	"fmt"
-	"log"
+	"io/ioutil"
+	"net/http"
 	"strings"
-	"time"
+	"unicode"
 
 	"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/credentials/ec2rolecreds"
 	"github.com/aws/aws-sdk-go/aws/ec2metadata"
 	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/hashicorp/go-cleanhttp"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 // AccessConfig is for common configuration related to AWS access
 type AccessConfig struct {
-	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
+	AccessKey      string `mapstructure:"access_key"`
+	SecretKey      string `mapstructure:"secret_key"`
+	RawRegion      string `mapstructure:"region"`
+	SkipValidation bool   `mapstructure:"skip_region_validation"`
+	Token          string `mapstructure:"token"`
+	ProfileName    string `mapstructure:"profile"`
 }
 
 // Config returns a valid aws.Config object for access to AWS services, or
 // an error if the authentication and region couldn't be resolved
-func (c *AccessConfig) Session() (*session.Session, error) {
-	if c.session != nil {
-		return c.session, nil
-	}
+func (c *AccessConfig) Config() (*aws.Config, error) {
+	var creds *credentials.Credentials
 
-	config := aws.NewConfig().WithCredentialsChainVerboseErrors(true)
-
-	staticCreds := credentials.NewStaticCredentials(c.AccessKey, c.SecretKey, c.Token)
-	if _, err := staticCreds.Get(); err != credentials.ErrStaticCredentialsEmpty {
-		config.WithCredentials(staticCreds)
-	}
-
-	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)
-	}
-
-	opts := session.Options{
-		SharedConfigState: session.SharedConfigEnable,
-		Config:            *config,
-	}
-
-	if c.ProfileName != "" {
-		opts.Profile = c.ProfileName
-	}
-
-	if c.MFACode != "" {
-		opts.AssumeRoleTokenProvider = func() (string, error) {
-			return c.MFACode, nil
-		}
-	}
-
-	if sess, err := session.NewSessionWithOptions(opts); err != nil {
+	region, err := c.Region()
+	if err != nil {
 		return nil, err
-	} 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()
+	}
+	config := aws.NewConfig().WithRegion(region).WithMaxRetries(11)
+	if c.ProfileName != "" {
+		profile, err := NewFromProfile(c.ProfileName)
 		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)
+			return nil, err
+		}
+		creds, err = profile.CredentialsFromProfile(config)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		creds = credentials.NewChainCredentials([]credentials.Provider{
+			&credentials.StaticProvider{Value: credentials.Value{
+				AccessKeyID:     c.AccessKey,
+				SecretAccessKey: c.SecretKey,
+				SessionToken:    c.Token,
+			}},
+			&credentials.EnvProvider{},
+			&credentials.SharedCredentialsProvider{Filename: "", Profile: ""},
+			&ec2rolecreds.EC2RoleProvider{
+				Client: ec2metadata.New(session.New(config)),
+			},
+		})
+	}
+	return config.WithCredentials(creds), nil
+}
+
+// Region returns the aws.Region object for access to AWS services, requesting
+// the region from the instance metadata if possible.
+func (c *AccessConfig) Region() (string, error) {
+	if c.RawRegion != "" {
+		if !c.SkipValidation {
+			if valid := ValidateRegion(c.RawRegion); valid == false {
+				return "", fmt.Errorf("Not a valid region: %s", c.RawRegion)
 			}
 		}
-		log.Printf("[INFO] AWS Auth provider used: %q", cp.ProviderName)
+		return c.RawRegion, nil
 	}
-	return c.session, nil
-}
 
-func (c *AccessConfig) SessionRegion() string {
-	if c.session == nil {
-		panic("access config session should be set.")
-	}
-	return aws.StringValue(c.session.Config.Region)
-}
-
-func (c *AccessConfig) IsGovCloud() bool {
-	return strings.HasPrefix(c.SessionRegion(), "us-gov-")
-}
-
-func (c *AccessConfig) IsChinaCloud() bool {
-	return strings.HasPrefix(c.SessionRegion(), "cn-")
-}
-
-// metadataRegion returns the region from the metadata service
-func (c *AccessConfig) metadataRegion() string {
-
-	client := cleanhttp.DefaultClient()
-
-	// 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()
+	md, err := GetInstanceMetaData("placement/availability-zone")
 	if err != nil {
-		log.Println("Error getting region from metadata service, "+
-			"probably because we're not running on AWS.", err)
-		return ""
+		return "", err
 	}
-	return region
+
+	region := strings.TrimRightFunc(string(md), unicode.IsLetter)
+	return region, nil
 }
 
 func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error {
 	var errs []error
-
-	if c.SkipMetadataApiCheck {
-		log.Println("(WARN) skip_metadata_api_check ignored.")
-	}
-	// 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 {
+		if valid := ValidateRegion(c.RawRegion); valid == false {
 			errs = append(errs, fmt.Errorf("Unknown region: %s", c.RawRegion))
 		}
 	}
 
-	return errs
+	if len(errs) > 0 {
+		return errs
+	}
+
+	return nil
+}
+
+func GetInstanceMetaData(path string) (contents []byte, err error) {
+	url := "http://169.254.169.254/latest/meta-data/" + path
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		err = fmt.Errorf("Code %d returned for url %s", resp.StatusCode, url)
+		return
+	}
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	return []byte(body), err
 }

builder/amazon/common/access_config_test.go

@@ -2,9 +2,6 @@ package common
 
 import (
 	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
 )
 
 func testAccessConfig() *AccessConfig {
@@ -41,20 +38,3 @@ func TestAccessConfigPrepare_Region(t *testing.T) {
 	c.SkipValidation = false
 
 }
-
-func TestAccessConfigPrepare_RegionRestricted(t *testing.T) {
-	c := testAccessConfig()
-
-	// Create a Session with a custom region
-	c.session = session.Must(session.NewSession(&aws.Config{
-		Region: aws.String("us-gov-west-1"),
-	}))
-
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-
-	if !c.IsGovCloud() {
-		t.Fatal("We should be in gov region.")
-	}
-}

builder/amazon/common/ami_config.go

@@ -2,9 +2,8 @@ package common
 
 import (
 	"fmt"
-	"log"
 
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 // AMIConfig is for common configuration related to creating AMIs.
@@ -17,45 +16,23 @@ type AMIConfig struct {
 	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"`
+	AMITags                 map[string]string `mapstructure:"tags"`
+	AMIEnhancedNetworking   bool              `mapstructure:"enhanced_networking"`
 	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"`
+	SnapshotTags            map[string]string `mapstructure:"snapshot_tags"`
 	SnapshotUsers           []string          `mapstructure:"snapshot_users"`
 	SnapshotGroups          []string          `mapstructure:"snapshot_groups"`
 }
 
-func stringInSlice(s []string, searchstr string) bool {
-	for _, item := range s {
-		if item == searchstr {
-			return true
-		}
-	}
-	return false
-}
-
-func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context) []error {
+func (c *AMIConfig) Prepare(ctx *interpolate.Context) []error {
 	var errs []error
-
 	if c.AMIName == "" {
 		errs = append(errs, fmt.Errorf("ami_name must be specified"))
 	}
 
-	// Make sure that if we have region_kms_key_ids defined,
-	//  the regions in region_kms_key_ids are also in ami_regions
-	if len(c.AMIRegionKMSKeyIDs) > 0 {
-		for kmsKeyRegion := range c.AMIRegionKMSKeyIDs {
-			if !stringInSlice(c.AMIRegions, kmsKeyRegion) {
-				errs = append(errs, fmt.Errorf("Region %s is in region_kms_key_ids but not in ami_regions", kmsKeyRegion))
-			}
-		}
-	}
-
 	if len(c.AMIRegions) > 0 {
 		regionSet := make(map[string]struct{})
 		regions := make([]string, 0, len(c.AMIRegions))
@@ -71,24 +48,12 @@ func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context
 
 			if !c.AMISkipRegionValidation {
 				// Verify the region is real
-				if valid := ValidateRegion(region); !valid {
+				if valid := ValidateRegion(region); valid == false {
 					errs = append(errs, fmt.Errorf("Unknown region: %s", region))
+					continue
 				}
 			}
 
-			// 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 {
-				if _, ok := c.AMIRegionKMSKeyIDs[region]; !ok {
-					errs = append(errs, fmt.Errorf("Region %s is in ami_regions but not in region_kms_key_ids", region))
-				}
-			}
-			if (accessConfig != nil) && (region == accessConfig.RawRegion) {
-				// make sure we don't try to copy to the region we originally
-				// create the AMI in.
-				log.Printf("Cannot copy AMI to AWS session region '%s', deleting it from `ami_regions`.", region)
-				continue
-			}
 			regions = append(regions, region)
 		}
 
@@ -99,29 +64,8 @@ func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context
 		errs = append(errs, fmt.Errorf("Cannot share AMI with encrypted boot volume"))
 	}
 
-	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 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_ami_name` template "+
-			"filter to automatically clean your ami name."))
+	if len(c.SnapshotUsers) > 0 && len(c.AMIKmsKeyId) == 0 && c.AMIEncryptBootVolume {
+		errs = append(errs, fmt.Errorf("Cannot share snapshot encrypted with default KMS key"))
 	}
 
 	if len(errs) > 0 {

builder/amazon/common/ami_config_test.go

@@ -11,20 +11,14 @@ func testAMIConfig() *AMIConfig {
 	}
 }
 
-func getFakeAccessConfig(region string) *AccessConfig {
-	return &AccessConfig{
-		RawRegion: region,
-	}
-}
-
 func TestAMIConfigPrepare_name(t *testing.T) {
 	c := testAMIConfig()
-	if err := c.Prepare(nil, nil); err != nil {
+	if err := c.Prepare(nil); err != nil {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
 
 	c.AMIName = ""
-	if err := c.Prepare(nil, nil); err == nil {
+	if err := c.Prepare(nil); err == nil {
 		t.Fatal("should have error")
 	}
 }
@@ -32,22 +26,22 @@ func TestAMIConfigPrepare_name(t *testing.T) {
 func TestAMIConfigPrepare_regions(t *testing.T) {
 	c := testAMIConfig()
 	c.AMIRegions = nil
-	if err := c.Prepare(nil, nil); err != nil {
+	if err := c.Prepare(nil); err != nil {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
 
 	c.AMIRegions = listEC2Regions()
-	if err := c.Prepare(nil, nil); err != nil {
+	if err := c.Prepare(nil); err != nil {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
 
 	c.AMIRegions = []string{"foo"}
-	if err := c.Prepare(nil, nil); err == nil {
+	if err := c.Prepare(nil); err == nil {
 		t.Fatal("should have error")
 	}
 
 	c.AMIRegions = []string{"us-east-1", "us-west-1", "us-east-1"}
-	if err := c.Prepare(nil, nil); err != nil {
+	if err := c.Prepare(nil); err != nil {
 		t.Fatalf("bad: %s", err)
 	}
 
@@ -58,81 +52,11 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 
 	c.AMIRegions = []string{"custom"}
 	c.AMISkipRegionValidation = true
-	if err := c.Prepare(nil, nil); err != nil {
+	if err := c.Prepare(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{
-		"us-east-1": "123-456-7890",
-		"us-west-1": "789-012-3456",
-		"us-east-2": "456-789-0123",
-	}
-	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"}
-	c.AMIRegionKMSKeyIDs = map[string]string{
-		"us-east-1": "123-456-7890",
-		"us-west-1": "789-012-3456",
-		"us-east-2": "",
-	}
-	if err := c.Prepare(nil, nil); err != nil {
-		t.Fatal("should have passed; we are able to use default KMS key if not sharing")
-	}
-
-	c.SnapshotUsers = []string{"user-foo", "user-bar"}
-	c.AMIRegions = []string{"us-east-1", "us-east-2", "us-west-1"}
-	c.AMIRegionKMSKeyIDs = map[string]string{
-		"us-east-1": "123-456-7890",
-		"us-west-1": "789-012-3456",
-		"us-east-2": "",
-	}
-	if err := c.Prepare(nil, nil); err == nil {
-		t.Fatal("should have an error b/c can't use default KMS key if sharing")
-	}
-
-	c.AMIRegions = []string{"us-east-1", "us-west-1"}
-	c.AMIRegionKMSKeyIDs = map[string]string{
-		"us-east-1": "123-456-7890",
-		"us-west-1": "789-012-3456",
-		"us-east-2": "456-789-0123",
-	}
-	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")
-	}
-
-	c.AMIRegions = []string{"us-east-1", "us-west-1", "us-east-2"}
-	c.AMIRegionKMSKeyIDs = map[string]string{
-		"us-east-1": "123-456-7890",
-		"us-west-1": "789-012-3456",
-	}
-	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 = 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 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")
-	c.AMIRegions = []string{"us-east-1", "us-west-1", "us-east-2"}
-	c.AMIRegionKMSKeyIDs = nil
-	if err := c.Prepare(accessConf, nil); err != nil {
-		t.Fatal("should allow user to have the raw region in ami_regions")
-	}
-
 }
 
 func TestAMIConfigPrepare_Share_EncryptedBoot(t *testing.T) {
@@ -141,46 +65,12 @@ func TestAMIConfigPrepare_Share_EncryptedBoot(t *testing.T) {
 	c.AMIEncryptBootVolume = true
 
 	c.AMIKmsKeyId = ""
-	if err := c.Prepare(nil, nil); err == nil {
+	if err := c.Prepare(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(nil, nil); err == nil {
+	if err := c.Prepare(nil); err == nil {
 		t.Fatal("shouldn't be able to share ami with encrypted boot volume")
 	}
 }
-
-func TestAMINameValidation(t *testing.T) {
-	c := testAMIConfig()
-
-	c.AMIName = "aa"
-	if err := c.Prepare(nil, nil); err == nil {
-		t.Fatal("shouldn't be able to have an ami name with less than 3 characters")
-	}
-
-	var longAmiName string
-	for i := 0; i < 129; i++ {
-		longAmiName += "a"
-	}
-	c.AMIName = longAmiName
-	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(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(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(nil, nil); err != nil {
-		t.Fatalf("expected `xyz-base-2017-04-05-1934` to pass validation.")
-	}
-
-}

builder/amazon/common/artifact.go

@@ -9,7 +9,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/packer"
 )
 
 // Artifact is an artifact implementation that contains built AMIs.
@@ -21,7 +21,7 @@ type Artifact struct {
 	BuilderIdValue string
 
 	// EC2 connection for performing API stuff.
-	Session *session.Session
+	Conn *ec2.EC2
 }
 
 func (a *Artifact) BuilderId() string {
@@ -51,7 +51,7 @@ func (a *Artifact) String() string {
 	}
 
 	sort.Strings(amiStrings)
-	return fmt.Sprintf("AMIs were created:\n%s\n", strings.Join(amiStrings, "\n"))
+	return fmt.Sprintf("AMIs were created:\n\n%s", strings.Join(amiStrings, "\n"))
 }
 
 func (a *Artifact) State(name string) interface{} {
@@ -69,9 +69,15 @@ func (a *Artifact) Destroy() error {
 	for region, imageId := range a.Amis {
 		log.Printf("Deregistering image ID (%s) from region (%s)", imageId, region)
 
-		regionConn := ec2.New(a.Session, &aws.Config{
-			Region: aws.String(region),
-		})
+		regionConfig := &aws.Config{
+			Credentials: a.Conn.Config.Credentials,
+			Region:      aws.String(region),
+		}
+		session, err := session.NewSession(regionConfig)
+		if err != nil {
+			return err
+		}
+		regionConn := ec2.New(session)
 
 		// Get image metadata
 		imageResp, err := regionConn.DescribeImages(&ec2.DescribeImagesInput{

builder/amazon/common/artifact_test.go

@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/packer"
 )
 
 func TestArtifact_Impl(t *testing.T) {
@@ -48,9 +48,9 @@ func TestArtifactState_atlasMetadata(t *testing.T) {
 
 func TestArtifactString(t *testing.T) {
 	expected := `AMIs were created:
+
 east: foo
-west: bar
-`
+west: bar`
 
 	amis := make(map[string]string)
 	amis["east"] = "foo"

builder/amazon/common/block_device.go

@@ -1,12 +1,11 @@
 package common
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 // BlockDevice
@@ -20,7 +19,6 @@ type BlockDevice struct {
 	VirtualName         string `mapstructure:"virtual_name"`
 	VolumeType          string `mapstructure:"volume_type"`
 	VolumeSize          int64  `mapstructure:"volume_size"`
-	KmsKeyId            string `mapstructure:"kms_key_id"`
 }
 
 type BlockDevices struct {
@@ -75,10 +73,6 @@ func buildBlockDevices(b []BlockDevice) []*ec2.BlockDeviceMapping {
 				ebsBlockDevice.Encrypted = aws.Bool(blockDevice.Encrypted)
 			}
 
-			if blockDevice.KmsKeyId != "" {
-				ebsBlockDevice.KmsKeyId = aws.String(blockDevice.KmsKeyId)
-			}
-
 			mapping.Ebs = ebsBlockDevice
 		}
 
@@ -87,29 +81,10 @@ func buildBlockDevices(b []BlockDevice) []*ec2.BlockDeviceMapping {
 	return blockDevices
 }
 
-func (b *BlockDevice) Prepare(ctx *interpolate.Context) error {
-	// 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)
-	}
+func (b *BlockDevices) Prepare(ctx *interpolate.Context) []error {
 	return nil
 }
 
-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)
 }

builder/amazon/common/block_device_test.go

@@ -84,27 +84,6 @@ func TestBlockDevice(t *testing.T) {
 				},
 			},
 		},
-		{
-			Config: &BlockDevice{
-				DeviceName:          "/dev/sdb",
-				VolumeType:          "gp2",
-				VolumeSize:          8,
-				DeleteOnTermination: true,
-				Encrypted:           true,
-				KmsKeyId:            "2Fa48a521f-3aff-4b34-a159-376ac5d37812",
-			},
-
-			Result: &ec2.BlockDeviceMapping{
-				DeviceName: aws.String("/dev/sdb"),
-				Ebs: &ec2.EbsBlockDevice{
-					VolumeType:          aws.String("gp2"),
-					VolumeSize:          aws.Int64(8),
-					DeleteOnTermination: aws.Bool(true),
-					Encrypted:           aws.Bool(true),
-					KmsKeyId:            aws.String("2Fa48a521f-3aff-4b34-a159-376ac5d37812"),
-				},
-			},
-		},
 		{
 			Config: &BlockDevice{
 				DeviceName:          "/dev/sdb",

builder/amazon/common/cli_config.go

@@ -0,0 +1,159 @@
+package common
+
+import (
+	"fmt"
+	"os"
+	"path"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/sts"
+	"github.com/go-ini/ini"
+	"github.com/mitchellh/go-homedir"
+)
+
+type CLIConfig struct {
+	ProfileName   string
+	SourceProfile string
+
+	AssumeRoleInput   *sts.AssumeRoleInput
+	SourceCredentials *credentials.Credentials
+
+	profileCfg  *ini.Section
+	profileCred *ini.Section
+}
+
+// Return a new CLIConfig with stored profile settings
+func NewFromProfile(name string) (*CLIConfig, error) {
+	c := &CLIConfig{}
+	c.AssumeRoleInput = new(sts.AssumeRoleInput)
+	err := c.Prepare(name)
+	if err != nil {
+		return nil, err
+	}
+	sessName, err := c.getSessionName(c.profileCfg.Key("role_session_name").Value())
+	if err != nil {
+		return nil, err
+	}
+	c.AssumeRoleInput.RoleSessionName = aws.String(sessName)
+	arn := c.profileCfg.Key("role_arn").Value()
+	if arn != "" {
+		c.AssumeRoleInput.RoleArn = aws.String(arn)
+	}
+	id := c.profileCfg.Key("external_id").Value()
+	if id != "" {
+		c.AssumeRoleInput.ExternalId = aws.String(id)
+	}
+	c.SourceCredentials = credentials.NewStaticCredentials(
+		c.profileCred.Key("aws_access_key_id").Value(),
+		c.profileCred.Key("aws_secret_access_key").Value(),
+		c.profileCred.Key("aws_session_token").Value(),
+	)
+	return c, nil
+}
+
+// Return AWS Credentials using current profile. Must supply source config.
+func (c *CLIConfig) CredentialsFromProfile(conf *aws.Config) (*credentials.Credentials, error) {
+	// If the profile name is equal to the source profile, there is no role to assume so return
+	// the source credentials as they were captured.
+	if c.ProfileName == c.SourceProfile {
+		return c.SourceCredentials, nil
+	}
+	srcCfg := aws.NewConfig().Copy(conf).WithCredentials(c.SourceCredentials)
+	session, err := session.NewSession(srcCfg)
+	if err != nil {
+		return nil, err
+	}
+	svc := sts.New(session)
+	res, err := svc.AssumeRole(c.AssumeRoleInput)
+	if err != nil {
+		return nil, err
+	}
+	return credentials.NewStaticCredentials(
+		*res.Credentials.AccessKeyId,
+		*res.Credentials.SecretAccessKey,
+		*res.Credentials.SessionToken,
+	), nil
+}
+
+// Sets params in the struct based on the file section
+func (c *CLIConfig) Prepare(name string) error {
+	var err error
+	c.ProfileName = name
+	c.profileCfg, err = configFromName(c.ProfileName)
+	if err != nil {
+		return err
+	}
+	c.SourceProfile = c.profileCfg.Key("source_profile").Value()
+	if c.SourceProfile == "" {
+		c.SourceProfile = c.ProfileName
+	}
+	c.profileCred, err = credsFromName(c.SourceProfile)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *CLIConfig) getSessionName(rawName string) (string, error) {
+	if rawName == "" {
+		name := "packer-"
+		host, err := os.Hostname()
+		if err != nil {
+			return name, err
+		}
+		return fmt.Sprintf("%s%s", name, host), nil
+	} else {
+		return rawName, nil
+	}
+}
+
+func configFromName(name string) (*ini.Section, error) {
+	filePath := os.Getenv("AWS_CONFIG_FILE")
+	if filePath == "" {
+		home, err := homedir.Dir()
+		if err != nil {
+			return nil, err
+		}
+		filePath = path.Join(home, ".aws", "config")
+	}
+	file, err := readFile(filePath)
+	if err != nil {
+		return nil, err
+	}
+	profileName := fmt.Sprintf("profile %s", name)
+	cfg, err := file.GetSection(profileName)
+	if err != nil {
+		return nil, err
+	}
+	return cfg, nil
+}
+
+func credsFromName(name string) (*ini.Section, error) {
+	filePath := os.Getenv("AWS_SHARED_CREDENTIALS_FILE")
+	if filePath == "" {
+		home, err := homedir.Dir()
+		if err != nil {
+			return nil, err
+		}
+		filePath = path.Join(home, ".aws", "credentials")
+	}
+	file, err := readFile(filePath)
+	if err != nil {
+		return nil, err
+	}
+	cfg, err := file.GetSection(name)
+	if err != nil {
+		return nil, err
+	}
+	return cfg, nil
+}
+
+func readFile(path string) (*ini.File, error) {
+	cfg, err := ini.Load(path)
+	if err != nil {
+		return nil, err
+	}
+	return cfg, nil
+}

builder/amazon/common/cli_config_test.go

@@ -0,0 +1,118 @@
+package common
+
+import (
+	"io/ioutil"
+	"os"
+	"path"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+)
+
+func init() {
+	os.Setenv("AWS_ACCESS_KEY_ID", "")
+	os.Setenv("AWS_ACCESS_KEY", "")
+	os.Setenv("AWS_SECRET_ACCESS_KEY", "")
+	os.Setenv("AWS_SECRET_KEY", "")
+	os.Setenv("AWS_CONFIG_FILE", "")
+	os.Setenv("AWS_SHARED_CREDENTIALS_FILE", "")
+}
+
+func testCLIConfig() *CLIConfig {
+	return &CLIConfig{}
+}
+
+func TestCLIConfigNewFromProfile(t *testing.T) {
+	tmpDir := mockConfig(t)
+
+	c, err := NewFromProfile("testing2")
+	if err != nil {
+		t.Error(err)
+	}
+	if c.AssumeRoleInput.RoleArn != nil {
+		t.Errorf("RoleArn should be nil. Instead %p", c.AssumeRoleInput.RoleArn)
+	}
+	if c.AssumeRoleInput.ExternalId != nil {
+		t.Errorf("ExternalId should be nil. Instead %p", c.AssumeRoleInput.ExternalId)
+	}
+
+	mockConfigClose(t, tmpDir)
+}
+
+func TestAssumeRole(t *testing.T) {
+	tmpDir := mockConfig(t)
+
+	c, err := NewFromProfile("testing1")
+	if err != nil {
+		t.Error(err)
+	}
+	// Role
+	e := "arn:aws:iam::123456789011:role/rolename"
+	a := *c.AssumeRoleInput.RoleArn
+	if e != a {
+		t.Errorf("RoleArn value should be %s. Instead %s", e, a)
+	}
+	// Session
+	a = *c.AssumeRoleInput.RoleSessionName
+	e = "testsession"
+	if e != a {
+		t.Errorf("RoleSessionName value should be %s. Instead %s", e, a)
+	}
+
+	config := aws.NewConfig()
+	_, err = c.CredentialsFromProfile(config)
+	if err == nil {
+		t.Error("Should have errored")
+	}
+	mockConfigClose(t, tmpDir)
+}
+
+func mockConfig(t *testing.T) string {
+	time := time.Now().UnixNano()
+	dir, err := ioutil.TempDir("", strconv.FormatInt(time, 10))
+	if err != nil {
+		t.Error(err)
+	}
+
+	cfg := []byte(`[profile testing1]
+region=us-west-2
+source_profile=testingcredentials
+role_arn = arn:aws:iam::123456789011:role/rolename
+role_session_name = testsession
+
+[profile testing2]
+region=us-west-2
+	`)
+	cfgFile := path.Join(dir, "config")
+	err = ioutil.WriteFile(cfgFile, cfg, 0644)
+	if err != nil {
+		t.Error(err)
+	}
+	os.Setenv("AWS_CONFIG_FILE", cfgFile)
+
+	crd := []byte(`[testingcredentials]
+aws_access_key_id = foo
+aws_secret_access_key = bar
+
+[testing2]
+aws_access_key_id = baz
+aws_secret_access_key = qux
+	`)
+	crdFile := path.Join(dir, "credentials")
+	err = ioutil.WriteFile(crdFile, crd, 0644)
+	if err != nil {
+		t.Error(err)
+	}
+	os.Setenv("AWS_SHARED_CREDENTIALS_FILE", crdFile)
+
+	return dir
+}
+
+func mockConfigClose(t *testing.T, dir string) {
+	err := os.RemoveAll(dir)
+	if err != nil {
+		t.Error(err)
+	}
+}

builder/amazon/common/interpolate_build_info.go

@@ -1,36 +1,6 @@
 package common
 
-import (
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
-)
-
 type BuildInfoTemplate struct {
-	BuildRegion   string
-	SourceAMI     string
-	SourceAMIName string
-	SourceAMITags map[string]string
-}
-
-func extractBuildInfo(region string, state multistep.StateBag) *BuildInfoTemplate {
-	rawSourceAMI, hasSourceAMI := state.GetOk("source_image")
-	if !hasSourceAMI {
-		return &BuildInfoTemplate{
-			BuildRegion: region,
-		}
-	}
-
-	sourceAMI := rawSourceAMI.(*ec2.Image)
-	sourceAMITags := make(map[string]string, len(sourceAMI.Tags))
-	for _, tag := range sourceAMI.Tags {
-		sourceAMITags[aws.StringValue(tag.Key)] = aws.StringValue(tag.Value)
-	}
-
-	return &BuildInfoTemplate{
-		BuildRegion:   region,
-		SourceAMI:     aws.StringValue(sourceAMI.ImageId),
-		SourceAMIName: aws.StringValue(sourceAMI.Name),
-		SourceAMITags: sourceAMITags,
-	}
+	SourceAMI   string
+	BuildRegion string
 }

builder/amazon/common/interpolate_build_info_test.go

@@ -1,63 +0,0 @@
-package common
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
-)
-
-func testImage() *ec2.Image {
-	return &ec2.Image{
-		ImageId: aws.String("ami-abcd1234"),
-		Name:    aws.String("ami_test_name"),
-		Tags: []*ec2.Tag{
-			{
-				Key:   aws.String("key-1"),
-				Value: aws.String("value-1"),
-			},
-			{
-				Key:   aws.String("key-2"),
-				Value: aws.String("value-2"),
-			},
-		},
-	}
-}
-
-func testState() multistep.StateBag {
-	state := new(multistep.BasicStateBag)
-	return state
-}
-
-func TestInterpolateBuildInfo_extractBuildInfo_noSourceImage(t *testing.T) {
-	state := testState()
-	buildInfo := extractBuildInfo("foo", state)
-
-	expected := BuildInfoTemplate{
-		BuildRegion: "foo",
-	}
-	if !reflect.DeepEqual(*buildInfo, expected) {
-		t.Fatalf("Unexpected BuildInfoTemplate: expected %#v got %#v\n", expected, *buildInfo)
-	}
-}
-
-func TestInterpolateBuildInfo_extractBuildInfo_withSourceImage(t *testing.T) {
-	state := testState()
-	state.Put("source_image", testImage())
-	buildInfo := extractBuildInfo("foo", state)
-
-	expected := BuildInfoTemplate{
-		BuildRegion:   "foo",
-		SourceAMI:     "ami-abcd1234",
-		SourceAMIName: "ami_test_name",
-		SourceAMITags: map[string]string{
-			"key-1": "value-1",
-			"key-2": "value-2",
-		},
-	}
-	if !reflect.DeepEqual(*buildInfo, expected) {
-		t.Fatalf("Unexpected BuildInfoTemplate: expected %#v got %#v\n", expected, *buildInfo)
-	}
-}

builder/amazon/common/regions.go

@@ -12,7 +12,6 @@ func listEC2Regions() []string {
 		"eu-central-1",
 		"eu-west-1",
 		"eu-west-2",
-		"eu-west-3",
 		"sa-east-1",
 		"us-east-1",
 		"us-east-2",
@@ -21,7 +20,6 @@ func listEC2Regions() []string {
 		// not part of autogenerated list
 		"us-gov-west-1",
 		"cn-north-1",
-		"cn-northwest-1",
 	}
 }
 

builder/amazon/common/run_config.go

@@ -1,16 +1,15 @@
 package common
 
 import (
+	"errors"
 	"fmt"
-	"net"
 	"os"
 	"regexp"
-	"strings"
 	"time"
 
-	"github.com/hashicorp/packer/common/uuid"
-	"github.com/hashicorp/packer/helper/communicator"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/common/uuid"
+	"github.com/mitchellh/packer/helper/communicator"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 var reShutdownBehavior = regexp.MustCompile("^(stop|terminate)$")
@@ -30,31 +29,29 @@ func (d *AmiFilterOptions) Empty() bool {
 type RunConfig struct {
 	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"`
+	DisableStopInstance               bool              `mapstructure:"disable_stop_instance"`
+	SecurityGroupId                   string            `mapstructure:"security_group_id"`
+	SecurityGroupIds                  []string          `mapstructure:"security_group_ids"`
 	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"`
+	VpcId                             string            `mapstructure:"vpc_id"`
+	InstanceInitiatedShutdownBehavior string            `mapstructure:"shutdown_behavior"`
 
 	// Communicator settings
 	Comm           communicator.Config `mapstructure:",squash"`
 	SSHKeyPairName string              `mapstructure:"ssh_keypair_name"`
-	SSHInterface   string              `mapstructure:"ssh_interface"`
+	SSHPrivateIp   bool                `mapstructure:"ssh_private_ip"`
 }
 
 func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
@@ -78,46 +75,29 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 
 	// Validation
 	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.SSHKeyPairName != "" {
 		if c.Comm.Type == "winrm" && c.Comm.WinRMPassword == "" && c.Comm.SSHPrivateKey == "" {
-			errs = append(errs, fmt.Errorf("ssh_private_key_file must be provided to retrieve the winrm password when using ssh_keypair_name."))
+			errs = append(errs, errors.New("A private_key_file must be provided to retrieve the winrm password when using ssh_keypair_name."))
 		} else if c.Comm.SSHPrivateKey == "" && !c.Comm.SSHAgentAuth {
-			errs = append(errs, fmt.Errorf("ssh_private_key_file must be provided or ssh_agent_auth enabled when ssh_keypair_name is specified."))
+			errs = append(errs, errors.New("A private_key_file must be provided or ssh_agent_auth enabled when ssh_keypair_name is specified."))
 		}
 	}
 
 	if c.SourceAmi == "" && c.SourceAmiFilter.Empty() {
-		errs = append(errs, fmt.Errorf("A source_ami or source_ami_filter must be specified"))
+		errs = append(errs, errors.New("A source_ami or source_ami_filter must be specified"))
 	}
 
 	if c.InstanceType == "" {
-		errs = append(errs, fmt.Errorf("An instance_type must be specified"))
+		errs = append(errs, errors.New("An instance_type must be specified"))
 	}
 
 	if c.SpotPrice == "auto" {
 		if c.SpotPriceAutoProduct == "" {
-			errs = append(errs, fmt.Errorf(
+			errs = append(errs, errors.New(
 				"spot_price_auto_product must be specified when spot_price is auto"))
 		}
 	}
 
-	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.UserData != "" && c.UserDataFile != "" {
 		errs = append(errs, fmt.Errorf("Only one of user_data or user_data_file can be specified."))
 	} else if c.UserDataFile != "" {
@@ -135,35 +115,11 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 		}
 	}
 
-	if c.TemporarySGSourceCidr == "" {
-		c.TemporarySGSourceCidr = "0.0.0.0/0"
-	} else {
-		if _, _, err := net.ParseCIDR(c.TemporarySGSourceCidr); err != nil {
-			errs = append(errs, fmt.Errorf("Error parsing temporary_security_group_source_cidr: %s", err.Error()))
-		}
-	}
-
 	if c.InstanceInitiatedShutdownBehavior == "" {
 		c.InstanceInitiatedShutdownBehavior = "stop"
 	} else if !reShutdownBehavior.MatchString(c.InstanceInitiatedShutdownBehavior) {
 		errs = append(errs, fmt.Errorf("shutdown_behavior only accepts 'stop' or 'terminate' values."))
 	}
 
-	if c.EnableT2Unlimited {
-		if c.SpotPrice != "" {
-			errs = append(errs, fmt.Errorf("Error: T2 Unlimited cannot be used in conjuction with Spot Instances"))
-		}
-		firstDotIndex := strings.Index(c.InstanceType, ".")
-		if firstDotIndex == -1 {
-			errs = append(errs, fmt.Errorf("Error determining main Instance Type from: %s", c.InstanceType))
-		} else if c.InstanceType[0:firstDotIndex] != "t2" {
-			errs = append(errs, fmt.Errorf("Error: T2 Unlimited enabled with a non-T2 Instance Type: %s", c.InstanceType))
-		}
-	}
-
 	return errs
 }
-
-func (c *RunConfig) IsSpotInstance() bool {
-	return c.SpotPrice != "" && c.SpotPrice != "0"
-}

builder/amazon/common/run_config_test.go

@@ -6,7 +6,7 @@ import (
 	"regexp"
 	"testing"
 
-	"github.com/hashicorp/packer/helper/communicator"
+	"github.com/mitchellh/packer/helper/communicator"
 )
 
 func init() {
@@ -48,7 +48,7 @@ func TestRunConfigPrepare_InstanceType(t *testing.T) {
 	c := testConfig()
 	c.InstanceType = ""
 	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("Should error if an instance_type is not specified")
+		t.Fatalf("err: %s", err)
 	}
 }
 
@@ -56,14 +56,14 @@ func TestRunConfigPrepare_SourceAmi(t *testing.T) {
 	c := testConfig()
 	c.SourceAmi = ""
 	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("Should error if a source_ami (or source_ami_filter) is not specified")
+		t.Fatalf("err: %s", err)
 	}
 }
 
 func TestRunConfigPrepare_SourceAmiFilterBlank(t *testing.T) {
 	c := testConfigFilter()
 	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("Should error if source_ami_filter is empty or not specified (and source_ami is not specified)")
+		t.Fatalf("err: %s", err)
 	}
 }
 
@@ -79,57 +79,16 @@ func TestRunConfigPrepare_SourceAmiFilterGood(t *testing.T) {
 	}
 }
 
-func TestRunConfigPrepare_EnableT2UnlimitedGood(t *testing.T) {
-	c := testConfig()
-	// Must have a T2 instance type if T2 Unlimited is enabled
-	c.InstanceType = "t2.micro"
-	c.EnableT2Unlimited = true
-	err := c.Prepare(nil)
-	if len(err) > 0 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_EnableT2UnlimitedBadInstanceType(t *testing.T) {
-	c := testConfig()
-	// T2 Unlimited cannot be used with instance types other than T2
-	c.InstanceType = "m5.large"
-	c.EnableT2Unlimited = true
-	err := c.Prepare(nil)
-	if len(err) != 1 {
-		t.Fatalf("Should error if T2 Unlimited is enabled with non-T2 instance_type")
-	}
-}
-
-func TestRunConfigPrepare_EnableT2UnlimitedBadWithSpotInstanceRequest(t *testing.T) {
-	c := testConfig()
-	// T2 Unlimited cannot be used with Spot Instances
-	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")
-	}
-}
-
 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)
 	}
 
-	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")
+	c.SpotPriceAutoProduct = "foo"
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
 	}
 }
 
@@ -160,13 +119,12 @@ func TestRunConfigPrepare_UserData(t *testing.T) {
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
-	defer os.Remove(tf.Name())
 	defer tf.Close()
 
 	c.UserData = "foo"
 	c.UserDataFile = tf.Name()
 	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("Should error if user_data string and user_data_file have both been specified")
+		t.Fatalf("err: %s", err)
 	}
 }
 
@@ -178,14 +136,13 @@ func TestRunConfigPrepare_UserDataFile(t *testing.T) {
 
 	c.UserDataFile = "idontexistidontthink"
 	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("Should error if the file specified by user_data_file does not exist")
+		t.Fatalf("err: %s", err)
 	}
 
 	tf, err := ioutil.TempFile("", "packer")
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
-	defer os.Remove(tf.Name())
 	defer tf.Close()
 
 	c.UserDataFile = tf.Name()

builder/amazon/common/ssh.go

@@ -8,8 +8,8 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	packerssh "github.com/hashicorp/packer/communicator/ssh"
-	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/mitchellh/multistep"
+	packerssh "github.com/mitchellh/packer/communicator/ssh"
 	"golang.org/x/crypto/ssh"
 	"golang.org/x/crypto/ssh/agent"
 )
@@ -25,40 +25,21 @@ 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) func(multistep.StateBag) (string, error) {
+func SSHHost(e ec2Describer, private bool) func(multistep.StateBag) (string, error) {
 	return func(state multistep.StateBag) (string, error) {
 		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 {
-				case "public_ip":
-					if i.PublicIpAddress != nil {
-						host = *i.PublicIpAddress
-					}
-				case "private_ip":
-					if i.PrivateIpAddress != nil {
-						host = *i.PrivateIpAddress
-					}
-				case "public_dns":
-					if i.PublicDnsName != nil {
-						host = *i.PublicDnsName
-					}
-				case "private_dns":
-					if i.PrivateDnsName != nil {
-						host = *i.PrivateDnsName
-					}
-				default:
-					panic(fmt.Sprintf("Unknown interface type: %s", sshInterface))
-				}
-			} else if i.VpcId != nil && *i.VpcId != "" {
-				if i.PublicIpAddress != nil && *i.PublicIpAddress != "" {
+			if i.VpcId != nil && *i.VpcId != "" {
+				if i.PublicIpAddress != nil && *i.PublicIpAddress != "" && !private {
 					host = *i.PublicIpAddress
 				} else if i.PrivateIpAddress != nil && *i.PrivateIpAddress != "" {
 					host = *i.PrivateIpAddress
 				}
+			} else if private && i.PrivateIpAddress != nil && *i.PrivateIpAddress != "" {
+				host = *i.PrivateIpAddress
 			} else if i.PublicDnsName != nil && *i.PublicDnsName != "" {
 				host = *i.PublicDnsName
 			}
@@ -82,7 +63,7 @@ func SSHHost(e ec2Describer, sshInterface string) func(multistep.StateBag) (stri
 			time.Sleep(sshHostSleepDuration)
 		}
 
-		return "", errors.New("couldn't determine address for instance")
+		return "", errors.New("couldn't determine IP address for instance")
 	}
 }
 
@@ -107,7 +88,6 @@ func SSHConfig(useAgent bool, username, password string) func(multistep.StateBag
 				Auth: []ssh.AuthMethod{
 					ssh.PublicKeysCallback(agent.NewClient(sshAgent).Signers),
 				},
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
 			}, nil
 		}
 
@@ -123,13 +103,11 @@ func SSHConfig(useAgent bool, username, password string) func(multistep.StateBag
 				Auth: []ssh.AuthMethod{
 					ssh.PublicKeys(signer),
 				},
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
 			}, nil
 
 		} else {
 			return &ssh.ClientConfig{
-				User:            username,
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+				User: username,
 				Auth: []ssh.AuthMethod{
 					ssh.Password(password),
 					ssh.KeyboardInteractive(

builder/amazon/common/ssh_test.go

@@ -5,14 +5,13 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/mitchellh/multistep"
 )
 
 const (
-	privateIP  = "10.0.0.1"
-	publicIP   = "192.168.1.1"
-	privateDNS = "private.dns.test"
-	publicDNS  = "public.dns.test"
+	privateIP = "10.0.0.1"
+	publicIP  = "192.168.1.1"
+	publicDNS = "public.dns.test"
 )
 
 func TestSSHHost(t *testing.T) {
@@ -21,54 +20,44 @@ func TestSSHHost(t *testing.T) {
 	sshHostSleepDuration = 0
 
 	var cases = []struct {
-		allowTries   int
-		vpcId        string
-		sshInterface string
+		allowTries int
+		vpcId      string
+		private    bool
 
 		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, "", false, true, publicDNS},
+		{1, "", true, true, privateIP},
+		{1, "vpc-id", false, true, publicIP},
+		{1, "vpc-id", true, true, privateIP},
+		{2, "", false, true, publicDNS},
+		{2, "", true, true, privateIP},
+		{2, "vpc-id", false, true, publicIP},
+		{2, "vpc-id", true, true, privateIP},
+		{3, "", false, false, ""},
+		{3, "", true, false, ""},
+		{3, "vpc-id", false, false, ""},
+		{3, "vpc-id", true, false, ""},
 	}
 
 	for _, c := range cases {
-		testSSHHost(t, c.allowTries, c.vpcId, c.sshInterface, c.ok, c.wantHost)
+		testSSHHost(t, c.allowTries, c.vpcId, c.private, c.ok, c.wantHost)
 	}
 }
 
-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)
+func testSSHHost(t *testing.T, allowTries int, vpcId string, private, ok bool, wantHost string) {
+	t.Logf("allowTries=%d vpcId=%s private=%t ok=%t wantHost=%q", allowTries, vpcId, private, ok, wantHost)
 
 	e := &fakeEC2Describer{
 		allowTries: allowTries,
 		vpcId:      vpcId,
 		privateIP:  privateIP,
 		publicIP:   publicIP,
-		privateDNS: privateDNS,
 		publicDNS:  publicDNS,
 	}
 
-	f := SSHHost(e, sshInterface)
+	f := SSHHost(e, private)
 	st := &multistep.BasicStateBag{}
 	st.Put("instance", &ec2.Instance{
 		InstanceId: aws.String("instance-id"),
@@ -96,8 +85,8 @@ type fakeEC2Describer struct {
 	allowTries int
 	tries      int
 
-	vpcId                                      string
-	privateIP, publicIP, privateDNS, publicDNS string
+	vpcId                          string
+	privateIP, publicIP, publicDNS string
 }
 
 func (d *fakeEC2Describer) DescribeInstances(in *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) {
@@ -115,7 +104,6 @@ func (d *fakeEC2Describer) DescribeInstances(in *ec2.DescribeInstancesInput) (*e
 		instance.PublicIpAddress = aws.String(d.publicIP)
 		instance.PrivateIpAddress = aws.String(d.privateIP)
 		instance.PublicDnsName = aws.String(d.publicDNS)
-		instance.PrivateDnsName = aws.String(d.privateDNS)
 	}
 
 	out := &ec2.DescribeInstancesOutput{

builder/amazon/common/state.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/mitchellh/multistep"
 )
 
 // StateRefreshFunc is a function type used for StateChangeConf that is
@@ -163,7 +163,7 @@ func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
 	log.Printf("Waiting for state to become: %s", conf.Target)
 
 	sleepSeconds := SleepSeconds()
-	maxTicks := TimeoutSeconds()/sleepSeconds + 1
+	maxTicks := int(TimeoutSeconds()/sleepSeconds) + 1
 	notfoundTick := 0
 
 	for {

builder/amazon/common/step_ami_region_copy.go

@@ -1,26 +1,24 @@
 package common
 
 import (
-	"context"
 	"fmt"
 	"sync"
 
 	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
 
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepAMIRegionCopy struct {
-	AccessConfig      *AccessConfig
-	Regions           []string
-	RegionKeyIds      map[string]string
-	EncryptBootVolume bool
-	Name              string
+	AccessConfig *AccessConfig
+	Regions      []string
+	Name         string
 }
 
-func (s *StepAMIRegionCopy) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepAMIRegionCopy) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 	amis := state.Get("amis").(map[string]string)
@@ -35,7 +33,6 @@ func (s *StepAMIRegionCopy) Run(_ context.Context, state multistep.StateBag) mul
 
 	var lock sync.Mutex
 	var wg sync.WaitGroup
-	var regKeyID string
 	errs := new(packer.MultiError)
 	for _, region := range s.Regions {
 		if region == *ec2conn.Config.Region {
@@ -47,13 +44,10 @@ func (s *StepAMIRegionCopy) Run(_ context.Context, state multistep.StateBag) mul
 		wg.Add(1)
 		ui.Message(fmt.Sprintf("Copying to: %s", region))
 
-		if s.EncryptBootVolume {
-			regKeyID = s.RegionKeyIds[region]
-		}
-
 		go func(region string) {
 			defer wg.Done()
-			id, snapshotIds, err := amiRegionCopy(state, s.AccessConfig, s.Name, ami, region, *ec2conn.Config.Region, regKeyID)
+			id, snapshotIds, err := amiRegionCopy(state, s.AccessConfig, s.Name, ami, region, *ec2conn.Config.Region)
+
 			lock.Lock()
 			defer lock.Unlock()
 			amis[region] = id
@@ -86,29 +80,26 @@ func (s *StepAMIRegionCopy) Cleanup(state multistep.StateBag) {
 // amiRegionCopy does a copy for the given AMI to the target region and
 // returns the resulting ID and snapshot IDs, or error.
 func amiRegionCopy(state multistep.StateBag, config *AccessConfig, name string, imageId string,
-	target string, source string, keyID string) (string, []string, error) {
+	target string, source string) (string, []string, error) {
 	snapshotIds := []string{}
-	isEncrypted := false
 
 	// Connect to the region where the AMI will be copied to
-	session, err := config.Session()
+	awsConfig, err := config.Config()
 	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
+	awsConfig.Region = aws.String(target)
+
+	session, err := session.NewSession(awsConfig)
+	if err != nil {
+		return "", snapshotIds, err
 	}
-	regionconn := ec2.New(session.Copy(&aws.Config{
-		Region: aws.String(target)},
-	))
+	regionconn := ec2.New(session)
 
 	resp, err := regionconn.CopyImage(&ec2.CopyImageInput{
 		SourceRegion:  &source,
 		SourceImageId: &imageId,
 		Name:          &name,
-		Encrypted:     aws.Bool(isEncrypted),
-		KmsKeyId:      aws.String(keyID),
 	})
 
 	if err != nil {

builder/amazon/common/step_create_tags.go

@@ -1,32 +1,38 @@
 package common
 
 import (
-	"context"
 	"fmt"
+	"log"
 
 	"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"
-	retry "github.com/hashicorp/packer/common"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/multistep"
+	retry "github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 type StepCreateTags struct {
-	Tags         TagMap
-	SnapshotTags TagMap
+	Tags         map[string]string
+	SnapshotTags map[string]string
 	Ctx          interpolate.Context
 }
 
-func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCreateTags) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
-	session := state.Get("awsSession").(*session.Session)
 	ui := state.Get("ui").(packer.Ui)
 	amis := state.Get("amis").(map[string]string)
 
-	if !s.Tags.IsSet() && !s.SnapshotTags.IsSet() {
+	var sourceAMI string
+	if rawSourceAMI, hasSourceAMI := state.GetOk("source_image"); hasSourceAMI {
+		sourceAMI = *rawSourceAMI.(*ec2.Image).ImageId
+	} else {
+		sourceAMI = ""
+	}
+
+	if len(s.Tags) == 0 && len(s.SnapshotTags) == 0 {
 		return multistep.ActionContinue
 	}
 
@@ -34,13 +40,23 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
 	for region, ami := range amis {
 		ui.Say(fmt.Sprintf("Adding tags to AMI (%s)...", ami))
 
-		regionConn := ec2.New(session, &aws.Config{
-			Region: aws.String(region),
-		})
+		// Declare list of resources to tag
+		awsConfig := aws.Config{
+			Credentials: ec2conn.Config.Credentials,
+			Region:      aws.String(region),
+		}
+		session, err := session.NewSession(&awsConfig)
+		if err != nil {
+			err := fmt.Errorf("Error creating AWS session: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		regionconn := ec2.New(session)
 
 		// Retrieve image list for given AMI
 		resourceIds := []*string{&ami}
-		imageResp, err := regionConn.DescribeImages(&ec2.DescribeImagesInput{
+		imageResp, err := regionconn.DescribeImages(&ec2.DescribeImagesInput{
 			ImageIds: resourceIds,
 		})
 
@@ -72,27 +88,25 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
 
 		// Convert tags to ec2.Tag format
 		ui.Say("Creating AMI tags")
-		amiTags, err := s.Tags.EC2Tags(s.Ctx, *ec2conn.Config.Region, state)
+		amiTags, err := ConvertToEC2Tags(s.Tags, *ec2conn.Config.Region, sourceAMI, s.Ctx)
 		if err != nil {
 			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
-		amiTags.Report(ui)
 
 		ui.Say("Creating snapshot tags")
-		snapshotTags, err := s.SnapshotTags.EC2Tags(s.Ctx, *ec2conn.Config.Region, state)
+		snapshotTags, err := ConvertToEC2Tags(s.SnapshotTags, *ec2conn.Config.Region, sourceAMI, s.Ctx)
 		if err != nil {
 			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
-		snapshotTags.Report(ui)
 
 		// Retry creating tags for about 2.5 minutes
-		err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
+		err = retry.Retry(0.2, 30, 11, func() (bool, error) {
 			// Tag images and snapshots
-			_, err := regionConn.CreateTags(&ec2.CreateTagsInput{
+			_, err := regionconn.CreateTags(&ec2.CreateTagsInput{
 				Resources: resourceIds,
 				Tags:      amiTags,
 			})
@@ -105,7 +119,7 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
 
 			// Override tags on snapshots
 			if len(snapshotTags) > 0 {
-				_, err = regionConn.CreateTags(&ec2.CreateTagsInput{
+				_, err = regionconn.CreateTags(&ec2.CreateTagsInput{
 					Resources: snapshotIds,
 					Tags:      snapshotTags,
 				})
@@ -135,3 +149,26 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
 func (s *StepCreateTags) Cleanup(state multistep.StateBag) {
 	// No cleanup...
 }
+
+func ConvertToEC2Tags(tags map[string]string, region, sourceAmiId string, ctx interpolate.Context) ([]*ec2.Tag, error) {
+	var ec2Tags []*ec2.Tag
+	for key, value := range tags {
+
+		ctx.Data = &BuildInfoTemplate{
+			SourceAMI:   sourceAmiId,
+			BuildRegion: region,
+		}
+		interpolatedValue, err := interpolate.Render(value, &ctx)
+		if err != nil {
+			return ec2Tags, fmt.Errorf("Error processing tag: %s:%s - %s", key, value, err)
+		}
+
+		log.Printf("Adding tag: \"%s\": \"%s\"", key, interpolatedValue)
+		ec2Tags = append(ec2Tags, &ec2.Tag{
+			Key:   aws.String(key),
+			Value: aws.String(interpolatedValue),
+		})
+	}
+
+	return ec2Tags, nil
+}

builder/amazon/common/step_deregister_ami.go

@@ -1,50 +1,30 @@
 package common
 
 import (
-	"context"
 	"fmt"
 
 	"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"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepDeregisterAMI struct {
-	AccessConfig        *AccessConfig
 	ForceDeregister     bool
 	ForceDeleteSnapshot bool
 	AMIName             string
-	Regions             []string
 }
 
-func (s *StepDeregisterAMI) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	// Check for force deregister
-	if !s.ForceDeregister {
-		return multistep.ActionContinue
-	}
-
-	ui := state.Get("ui").(packer.Ui)
+func (s *StepDeregisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
-	// Add the session region to list of regions will will deregister AMIs in
-	regions := append(s.Regions, *ec2conn.Config.Region)
+	ui := state.Get("ui").(packer.Ui)
 
-	for _, region := range regions {
-		// get new connection for each region in which we need to deregister vms
-		session, err := s.AccessConfig.Session()
-		if err != nil {
-			return multistep.ActionHalt
-		}
-
-		regionconn := ec2.New(session.Copy(&aws.Config{
-			Region: aws.String(region)},
-		))
-
-		resp, err := regionconn.DescribeImages(&ec2.DescribeImagesInput{
-			Owners: aws.StringSlice([]string{"self"}),
+	// Check for force deregister
+	if s.ForceDeregister {
+		resp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{
 			Filters: []*ec2.Filter{{
 				Name:   aws.String("name"),
-				Values: aws.StringSlice([]string{s.AMIName}),
+				Values: []*string{aws.String(s.AMIName)},
 			}}})
 
 		if err != nil {
@@ -56,7 +36,7 @@ func (s *StepDeregisterAMI) Run(_ context.Context, state multistep.StateBag) mul
 
 		// Deregister image(s) by name
 		for _, i := range resp.Images {
-			_, err := regionconn.DeregisterImage(&ec2.DeregisterImageInput{
+			_, err := ec2conn.DeregisterImage(&ec2.DeregisterImageInput{
 				ImageId: i.ImageId,
 			})
 
@@ -71,8 +51,8 @@ func (s *StepDeregisterAMI) Run(_ context.Context, state multistep.StateBag) mul
 			// Delete snapshot(s) by image
 			if s.ForceDeleteSnapshot {
 				for _, b := range i.BlockDeviceMappings {
-					if b.Ebs != nil && aws.StringValue(b.Ebs.SnapshotId) != "" {
-						_, err := regionconn.DeleteSnapshot(&ec2.DeleteSnapshotInput{
+					if b.Ebs != nil {
+						_, err := ec2conn.DeleteSnapshot(&ec2.DeleteSnapshotInput{
 							SnapshotId: b.Ebs.SnapshotId,
 						})
 

builder/amazon/common/step_encrypted_ami.go

@@ -1,14 +1,13 @@
 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"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepCreateEncryptedAMICopy struct {
@@ -16,10 +15,9 @@ type StepCreateEncryptedAMICopy struct {
 	KeyID             string
 	EncryptBootVolume bool
 	Name              string
-	AMIMappings       []BlockDevice
 }
 
-func (s *StepCreateEncryptedAMICopy) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepCreateEncryptedAMICopy) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 	kmsKeyId := s.KeyID
@@ -27,7 +25,7 @@ func (s *StepCreateEncryptedAMICopy) Run(_ context.Context, state multistep.Stat
 	// Encrypt boot not set, so skip step
 	if !s.EncryptBootVolume {
 		if kmsKeyId != "" {
-			log.Printf("Ignoring KMS Key ID: %s, encrypted=false", kmsKeyId)
+			log.Printf(fmt.Sprintf("Ignoring KMS Key ID: %s, encrypted=false", kmsKeyId))
 		}
 		return multistep.ActionContinue
 	}
@@ -38,14 +36,14 @@ func (s *StepCreateEncryptedAMICopy) Run(_ context.Context, state multistep.Stat
 	var region, id string
 	if amis != nil {
 		for region, id = range amis {
-			break // There is only ever one region:ami pair in this map
+			break // Only get the first
 		}
 	}
 
 	ui.Say(fmt.Sprintf("Copying AMI: %s(%s)", region, id))
 
 	if kmsKeyId != "" {
-		ui.Say(fmt.Sprintf("Encrypting with KMS Key ID: %s", kmsKeyId))
+		ui.Say(fmt.Sprintf("Encypting with KMS Key ID: %s", kmsKeyId))
 	}
 
 	copyOpts := &ec2.CopyImageInput{
@@ -118,18 +116,9 @@ func (s *StepCreateEncryptedAMICopy) Run(_ context.Context, state multistep.Stat
 	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))
+			ui.Message(fmt.Sprintf("Snapshot ID: %s", *blockDevice.Ebs.SnapshotId))
 			deleteSnapOpts := &ec2.DeleteSnapshotInput{
 				SnapshotId: aws.String(*blockDevice.Ebs.SnapshotId),
 			}
@@ -172,7 +161,7 @@ func (s *StepCreateEncryptedAMICopy) Cleanup(state multistep.StateBag) {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
-	ui.Say("Deregistering the AMI because cancellation or error...")
+	ui.Say("Deregistering the AMI because cancelation or error...")
 	deregisterOpts := &ec2.DeregisterImageInput{ImageId: s.image.ImageId}
 	if _, err := ec2conn.DeregisterImage(deregisterOpts); err != nil {
 		ui.Error(fmt.Sprintf("Error deregistering AMI, may still be around: %s", err))

builder/amazon/common/step_get_password.go

@@ -1,7 +1,6 @@
 package common
 
 import (
-	"context"
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/base64"
@@ -12,22 +11,20 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	commonhelper "github.com/hashicorp/packer/helper/common"
-	"github.com/hashicorp/packer/helper/communicator"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/helper/communicator"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepGetPassword reads the password from a Windows server and sets it
 // on the WinRM config.
 type StepGetPassword struct {
-	Debug     bool
-	Comm      *communicator.Config
-	Timeout   time.Duration
-	BuildName string
+	Debug   bool
+	Comm    *communicator.Config
+	Timeout time.Duration
 }
 
-func (s *StepGetPassword) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepGetPassword) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	// Skip if we're not using winrm
@@ -94,15 +91,11 @@ WaitLoop:
 		ui.Message(fmt.Sprintf(
 			"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)
 
 	return multistep.ActionContinue
 }
 
-func (s *StepGetPassword) Cleanup(multistep.StateBag) {
-	commonhelper.RemoveSharedStateFile("winrm_password", s.BuildName)
-}
+func (s *StepGetPassword) Cleanup(multistep.StateBag) {}
 
 func (s *StepGetPassword) waitForPassword(state multistep.StateBag, cancel <-chan struct{}) (string, error) {
 	ec2conn := state.Get("ec2").(*ec2.EC2)

builder/amazon/common/step_key_pair.go

@@ -1,15 +1,14 @@
 package common
 
 import (
-	"context"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"runtime"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepKeyPair struct {
@@ -20,10 +19,10 @@ type StepKeyPair struct {
 	KeyPairName          string
 	PrivateKeyFile       string
 
-	doCleanup bool
+	keyName string
 }
 
-func (s *StepKeyPair) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	if s.PrivateKeyFile != "" {
@@ -68,10 +67,11 @@ func (s *StepKeyPair) Run(_ context.Context, state multistep.StateBag) multistep
 		return multistep.ActionHalt
 	}
 
-	s.doCleanup = true
+	// Set the keyname so we know to delete it later
+	s.keyName = s.TemporaryKeyPairName
 
 	// Set some state data for use in future steps
-	state.Put("keyPair", s.TemporaryKeyPairName)
+	state.Put("keyPair", s.keyName)
 	state.Put("privateKey", *keyResp.KeyMaterial)
 
 	// If we're in debug mode, output the private key to the working
@@ -104,7 +104,10 @@ func (s *StepKeyPair) Run(_ context.Context, state multistep.StateBag) multistep
 }
 
 func (s *StepKeyPair) Cleanup(state multistep.StateBag) {
-	if !s.doCleanup {
+	// If no key name is set, then we never created it, so just return
+	// If we used an SSH private key file, do not go about deleting
+	// keypairs
+	if s.PrivateKeyFile != "" || (s.KeyPairName == "" && s.keyName == "") {
 		return
 	}
 
@@ -113,10 +116,10 @@ func (s *StepKeyPair) Cleanup(state multistep.StateBag) {
 
 	// Remove the keypair
 	ui.Say("Deleting temporary keypair...")
-	_, err := ec2conn.DeleteKeyPair(&ec2.DeleteKeyPairInput{KeyName: &s.TemporaryKeyPairName})
+	_, err := ec2conn.DeleteKeyPair(&ec2.DeleteKeyPairInput{KeyName: &s.keyName})
 	if err != nil {
 		ui.Error(fmt.Sprintf(
-			"Error cleaning up keypair. Please delete the key manually: %s", s.TemporaryKeyPairName))
+			"Error cleaning up keypair. Please delete the key manually: %s", s.keyName))
 	}
 
 	// Also remove the physical key if we're debugging.

builder/amazon/common/step_modify_ami_attributes.go

@@ -1,15 +1,14 @@
 package common
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 type StepModifyAMIAttributes struct {
@@ -22,11 +21,17 @@ type StepModifyAMIAttributes struct {
 	Ctx            interpolate.Context
 }
 
-func (s *StepModifyAMIAttributes) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepModifyAMIAttributes) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
-	session := state.Get("awsSession").(*session.Session)
 	ui := state.Get("ui").(packer.Ui)
 	amis := state.Get("amis").(map[string]string)
+
+	var sourceAMI string
+	if rawSourceAMI, hasSourceAMI := state.GetOk("source_image"); hasSourceAMI {
+		sourceAMI = *rawSourceAMI.(*ec2.Image).ImageId
+	} else {
+		sourceAMI = ""
+	}
 	snapshots := state.Get("snapshots").(map[string][]string)
 
 	// Determine if there is any work to do.
@@ -43,7 +48,10 @@ func (s *StepModifyAMIAttributes) Run(_ context.Context, state multistep.StateBa
 	}
 
 	var err error
-	s.Ctx.Data = extractBuildInfo(*ec2conn.Config.Region, state)
+	s.Ctx.Data = &BuildInfoTemplate{
+		SourceAMI:   sourceAMI,
+		BuildRegion: *ec2conn.Config.Region,
+	}
 	s.Description, err = interpolate.Render(s.Description, &s.Ctx)
 	if err != nil {
 		err = fmt.Errorf("Error interpolating AMI description: %s", err)
@@ -144,13 +152,22 @@ func (s *StepModifyAMIAttributes) Run(_ context.Context, state multistep.StateBa
 	// Modifying image attributes
 	for region, ami := range amis {
 		ui.Say(fmt.Sprintf("Modifying attributes on AMI (%s)...", ami))
-		regionConn := ec2.New(session, &aws.Config{
-			Region: aws.String(region),
-		})
+		awsConfig := aws.Config{
+			Credentials: ec2conn.Config.Credentials,
+			Region:      aws.String(region),
+		}
+		session, err := session.NewSession(&awsConfig)
+		if err != nil {
+			err := fmt.Errorf("Error creating AWS session: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		regionconn := ec2.New(session)
 		for name, input := range options {
 			ui.Message(fmt.Sprintf("Modifying: %s", name))
 			input.ImageId = &ami
-			_, err := regionConn.ModifyImageAttribute(input)
+			_, err := regionconn.ModifyImageAttribute(input)
 			if err != nil {
 				err := fmt.Errorf("Error modify AMI attributes: %s", err)
 				state.Put("error", err)
@@ -164,13 +181,16 @@ func (s *StepModifyAMIAttributes) Run(_ context.Context, state multistep.StateBa
 	for region, region_snapshots := range snapshots {
 		for _, snapshot := range region_snapshots {
 			ui.Say(fmt.Sprintf("Modifying attributes on snapshot (%s)...", snapshot))
-			regionConn := ec2.New(session, &aws.Config{
-				Region: aws.String(region),
-			})
+			awsConfig := aws.Config{
+				Credentials: ec2conn.Config.Credentials,
+				Region:      aws.String(region),
+			}
+			session := session.New(&awsConfig)
+			regionconn := ec2.New(session)
 			for name, input := range snapshotOptions {
 				ui.Message(fmt.Sprintf("Modifying: %s", name))
 				input.SnapshotId = &snapshot
-				_, err := regionConn.ModifySnapshotAttribute(input)
+				_, err := regionconn.ModifySnapshotAttribute(input)
 				if err != nil {
 					err := fmt.Errorf("Error modify snapshot attributes: %s", err)
 					state.Put("error", err)

builder/amazon/common/step_modify_ebs_instance.go

@@ -1,28 +1,26 @@
 package common
 
 import (
-	"context"
 	"fmt"
 
 	"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"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepModifyEBSBackedInstance struct {
-	EnableAMIENASupport      bool
-	EnableAMISriovNetSupport bool
+	EnableEnhancedNetworking bool
 }
 
-func (s *StepModifyEBSBackedInstance) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepModifyEBSBackedInstance) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	instance := state.Get("instance").(*ec2.Instance)
 	ui := state.Get("ui").(packer.Ui)
 
-	// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
-	// As of February 2017, this applies to C3, C4, D2, I2, R3, and M4 (excluding m4.16xlarge)
-	if s.EnableAMISriovNetSupport {
+	if s.EnableEnhancedNetworking {
+		// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
+		// As of February 2017, this applies to C3, C4, D2, I2, R3, and M4 (excluding m4.16xlarge)
 		ui.Say("Enabling Enhanced Networking (SR-IOV)...")
 		simple := "simple"
 		_, err := ec2conn.ModifyInstanceAttribute(&ec2.ModifyInstanceAttributeInput{
@@ -35,13 +33,11 @@ func (s *StepModifyEBSBackedInstance) Run(_ context.Context, state multistep.Sta
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
-	}
 
-	// Set EnaSupport to true.
-	// As of February 2017, this applies to C5, I3, P2, R4, X1, and m4.16xlarge
-	if s.EnableAMIENASupport {
+		// Set EnaSupport to true.
+		// As of February 2017, this applies to C5, I3, P2, R4, X1, and m4.16xlarge
 		ui.Say("Enabling Enhanced Networking (ENA)...")
-		_, err := ec2conn.ModifyInstanceAttribute(&ec2.ModifyInstanceAttributeInput{
+		_, err = ec2conn.ModifyInstanceAttribute(&ec2.ModifyInstanceAttributeInput{
 			InstanceId: instance.InstanceId,
 			EnaSupport: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
 		})

builder/amazon/common/step_pre_validate.go

@@ -1,13 +1,12 @@
 package common
 
 import (
-	"context"
 	"fmt"
 
 	"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"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepPreValidate provides an opportunity to pre-validate any configuration for
@@ -18,7 +17,7 @@ type StepPreValidate struct {
 	ForceDeregister bool
 }
 
-func (s *StepPreValidate) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepPreValidate) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 	if s.ForceDeregister {
 		ui.Say("Force Deregister flag found, skipping prevalidating AMI Name")
@@ -27,7 +26,7 @@ func (s *StepPreValidate) Run(_ context.Context, state multistep.StateBag) multi
 
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 
-	ui.Say(fmt.Sprintf("Prevalidating AMI Name: %s", s.DestAmiName))
+	ui.Say("Prevalidating AMI Name...")
 	resp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{
 		Filters: []*ec2.Filter{{
 			Name:   aws.String("name"),

builder/amazon/common/step_run_source_instance.go

@@ -1,46 +1,45 @@
 package common
 
 import (
-	"context"
 	"encoding/base64"
 	"fmt"
 	"io/ioutil"
 	"log"
+	"strconv"
+	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
 
-	retry "github.com/hashicorp/packer/common"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 type StepRunSourceInstance struct {
 	AssociatePublicIpAddress          bool
 	AvailabilityZone                  string
 	BlockDevices                      BlockDevices
-	Ctx                               interpolate.Context
 	Debug                             bool
 	EbsOptimized                      bool
-	EnableT2Unlimited                 bool
 	ExpectedRootDevice                string
 	IamInstanceProfile                string
 	InstanceInitiatedShutdownBehavior string
 	InstanceType                      string
-	IsRestricted                      bool
 	SourceAMI                         string
+	SpotPrice                         string
+	SpotPriceProduct                  string
 	SubnetId                          string
-	Tags                              TagMap
+	Tags                              map[string]string
 	UserData                          string
 	UserDataFile                      string
-	VolumeTags                        TagMap
+	Ctx                               interpolate.Context
 
-	instanceId string
+	instanceId  string
+	spotRequest *ec2.SpotInstanceRequest
 }
 
-func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	var keyName string
 	if name, ok := state.GetOk("keyPair"); ok {
@@ -82,14 +81,207 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		return multistep.ActionHalt
 	}
 
+	spotPrice := s.SpotPrice
+	availabilityZone := s.AvailabilityZone
+	if spotPrice == "auto" {
+		ui.Message(fmt.Sprintf(
+			"Finding spot price for %s %s...",
+			s.SpotPriceProduct, s.InstanceType))
+
+		// Detect the spot price
+		startTime := time.Now().Add(-1 * time.Hour)
+		resp, err := ec2conn.DescribeSpotPriceHistory(&ec2.DescribeSpotPriceHistoryInput{
+			InstanceTypes:       []*string{&s.InstanceType},
+			ProductDescriptions: []*string{&s.SpotPriceProduct},
+			AvailabilityZone:    &s.AvailabilityZone,
+			StartTime:           &startTime,
+		})
+		if err != nil {
+			err := fmt.Errorf("Error finding spot price: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		var price float64
+		for _, history := range resp.SpotPriceHistory {
+			log.Printf("[INFO] Candidate spot price: %s", *history.SpotPrice)
+			current, err := strconv.ParseFloat(*history.SpotPrice, 64)
+			if err != nil {
+				log.Printf("[ERR] Error parsing spot price: %s", err)
+				continue
+			}
+			if price == 0 || current < price {
+				price = current
+				if s.AvailabilityZone == "" {
+					availabilityZone = *history.AvailabilityZone
+				}
+			}
+		}
+		if price == 0 {
+			err := fmt.Errorf("No candidate spot prices found!")
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		} else {
+			// Add 0.5 cents to minimum spot bid to ensure capacity will be available
+			// Avoids price-too-low error in active markets which can fluctuate
+			price = price + 0.005
+		}
+
+		spotPrice = strconv.FormatFloat(price, 'f', -1, 64)
+	}
+
 	var instanceId string
 
+	if spotPrice == "" || spotPrice == "0" {
+		runOpts := &ec2.RunInstancesInput{
+			ImageId:             &s.SourceAMI,
+			InstanceType:        &s.InstanceType,
+			UserData:            &userData,
+			MaxCount:            aws.Int64(1),
+			MinCount:            aws.Int64(1),
+			IamInstanceProfile:  &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
+			BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
+			Placement:           &ec2.Placement{AvailabilityZone: &s.AvailabilityZone},
+			EbsOptimized:        &s.EbsOptimized,
+		}
+
+		if keyName != "" {
+			runOpts.KeyName = &keyName
+		}
+
+		if s.SubnetId != "" && s.AssociatePublicIpAddress {
+			runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
+				{
+					DeviceIndex:              aws.Int64(0),
+					AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
+					SubnetId:                 &s.SubnetId,
+					Groups:                   securityGroupIds,
+					DeleteOnTermination:      aws.Bool(true),
+				},
+			}
+		} else {
+			runOpts.SubnetId = &s.SubnetId
+			runOpts.SecurityGroupIds = securityGroupIds
+		}
+
+		if s.ExpectedRootDevice == "ebs" {
+			runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior
+		}
+
+		runResp, err := ec2conn.RunInstances(runOpts)
+		if err != nil {
+			err := fmt.Errorf("Error launching source instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		instanceId = *runResp.Instances[0].InstanceId
+	} else {
+		ui.Message(fmt.Sprintf(
+			"Requesting spot instance '%s' for: %s",
+			s.InstanceType, spotPrice))
+
+		runOpts := &ec2.RequestSpotLaunchSpecification{
+			ImageId:            &s.SourceAMI,
+			InstanceType:       &s.InstanceType,
+			UserData:           &userData,
+			IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
+			Placement: &ec2.SpotPlacement{
+				AvailabilityZone: &availabilityZone,
+			},
+			BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
+			EbsOptimized:        &s.EbsOptimized,
+		}
+
+		if s.SubnetId != "" && s.AssociatePublicIpAddress {
+			runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
+				{
+					DeviceIndex:              aws.Int64(0),
+					AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
+					SubnetId:                 &s.SubnetId,
+					Groups:                   securityGroupIds,
+					DeleteOnTermination:      aws.Bool(true),
+				},
+			}
+		} else {
+			runOpts.SubnetId = &s.SubnetId
+			runOpts.SecurityGroupIds = securityGroupIds
+		}
+
+		if keyName != "" {
+			runOpts.KeyName = &keyName
+		}
+
+		runSpotResp, err := ec2conn.RequestSpotInstances(&ec2.RequestSpotInstancesInput{
+			SpotPrice:           &spotPrice,
+			LaunchSpecification: runOpts,
+		})
+		if err != nil {
+			err := fmt.Errorf("Error launching source spot instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		s.spotRequest = runSpotResp.SpotInstanceRequests[0]
+
+		spotRequestId := s.spotRequest.SpotInstanceRequestId
+		ui.Message(fmt.Sprintf("Waiting for spot request (%s) to become active...", *spotRequestId))
+		stateChange := StateChangeConf{
+			Pending:   []string{"open"},
+			Target:    "active",
+			Refresh:   SpotRequestStateRefreshFunc(ec2conn, *spotRequestId),
+			StepState: state,
+		}
+		_, err = WaitForState(&stateChange)
+		if err != nil {
+			err := fmt.Errorf("Error waiting for spot request (%s) to become ready: %s", *spotRequestId, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		spotResp, err := ec2conn.DescribeSpotInstanceRequests(&ec2.DescribeSpotInstanceRequestsInput{
+			SpotInstanceRequestIds: []*string{spotRequestId},
+		})
+		if err != nil {
+			err := fmt.Errorf("Error finding spot request (%s): %s", *spotRequestId, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		instanceId = *spotResp.SpotInstanceRequests[0].InstanceId
+	}
+
+	// Set the instance ID so that the cleanup works properly
+	s.instanceId = instanceId
+
+	ui.Message(fmt.Sprintf("Instance ID: %s", instanceId))
+	ui.Say(fmt.Sprintf("Waiting for instance (%v) to become ready...", instanceId))
+	stateChange := StateChangeConf{
+		Pending:   []string{"pending"},
+		Target:    "running",
+		Refresh:   InstanceStateRefreshFunc(ec2conn, instanceId),
+		StepState: state,
+	}
+	latestInstance, err := WaitForState(&stateChange)
+	if err != nil {
+		err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", instanceId, err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	instance := latestInstance.(*ec2.Instance)
+
 	ui.Say("Adding tags to source instance")
 	if _, exists := s.Tags["Name"]; !exists {
 		s.Tags["Name"] = "Packer Builder"
 	}
 
-	ec2Tags, err := s.Tags.EC2Tags(s.Ctx, *ec2conn.Config.Region, state)
+	ec2Tags, err := ConvertToEC2Tags(s.Tags, *ec2conn.Config.Region, s.SourceAMI, s.Ctx)
 	if err != nil {
 		err := fmt.Errorf("Error tagging source instance: %s", err)
 		state.Put("error", err)
@@ -97,117 +289,17 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		return multistep.ActionHalt
 	}
 
-	volTags, err := s.VolumeTags.EC2Tags(s.Ctx, *ec2conn.Config.Region, state)
+	_, err = ec2conn.CreateTags(&ec2.CreateTagsInput{
+		Tags:      ec2Tags,
+		Resources: []*string{instance.InstanceId},
+	})
 	if err != nil {
-		err := fmt.Errorf("Error tagging volumes: %s", err)
+		err := fmt.Errorf("Error tagging source instance: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
-	runOpts := &ec2.RunInstancesInput{
-		ImageId:             &s.SourceAMI,
-		InstanceType:        &s.InstanceType,
-		UserData:            &userData,
-		MaxCount:            aws.Int64(1),
-		MinCount:            aws.Int64(1),
-		IamInstanceProfile:  &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
-		BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
-		Placement:           &ec2.Placement{AvailabilityZone: &s.AvailabilityZone},
-		EbsOptimized:        &s.EbsOptimized,
-	}
-
-	if s.EnableT2Unlimited {
-		creditOption := "unlimited"
-		runOpts.CreditSpecification = &ec2.CreditSpecificationRequest{CpuCredits: &creditOption}
-	}
-
-	// Collect tags for tagging on resource creation
-	var tagSpecs []*ec2.TagSpecification
-
-	if len(ec2Tags) > 0 {
-		runTags := &ec2.TagSpecification{
-			ResourceType: aws.String("instance"),
-			Tags:         ec2Tags,
-		}
-
-		tagSpecs = append(tagSpecs, runTags)
-	}
-
-	if len(volTags) > 0 {
-		runVolTags := &ec2.TagSpecification{
-			ResourceType: aws.String("volume"),
-			Tags:         volTags,
-		}
-
-		tagSpecs = append(tagSpecs, runVolTags)
-	}
-
-	// If our region supports it, set tag specifications
-	if len(tagSpecs) > 0 && !s.IsRestricted {
-		runOpts.SetTagSpecifications(tagSpecs)
-		ec2Tags.Report(ui)
-		volTags.Report(ui)
-	}
-
-	if keyName != "" {
-		runOpts.KeyName = &keyName
-	}
-
-	if s.SubnetId != "" && s.AssociatePublicIpAddress {
-		runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
-			{
-				DeviceIndex:              aws.Int64(0),
-				AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
-				SubnetId:                 &s.SubnetId,
-				Groups:                   securityGroupIds,
-				DeleteOnTermination:      aws.Bool(true),
-			},
-		}
-	} else {
-		runOpts.SubnetId = &s.SubnetId
-		runOpts.SecurityGroupIds = securityGroupIds
-	}
-
-	if s.ExpectedRootDevice == "ebs" {
-		runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior
-	}
-
-	runResp, err := ec2conn.RunInstances(runOpts)
-	if err != nil {
-		err := fmt.Errorf("Error launching source instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	instanceId = *runResp.Instances[0].InstanceId
-
-	// Set the instance ID so that the cleanup works properly
-	s.instanceId = instanceId
-
-	ui.Message(fmt.Sprintf("Instance ID: %s", instanceId))
-	ui.Say(fmt.Sprintf("Waiting for instance (%v) to become ready...", instanceId))
-
-	describeInstance := &ec2.DescribeInstancesInput{
-		InstanceIds: []*string{aws.String(instanceId)},
-	}
-	if err := ec2conn.WaitUntilInstanceRunningWithContext(ctx, describeInstance); err != nil {
-		err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", instanceId, err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	r, err := ec2conn.DescribeInstances(describeInstance)
-
-	if err != nil || len(r.Reservations) == 0 || len(r.Reservations[0].Instances) == 0 {
-		err := fmt.Errorf("Error finding source instance.")
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	instance := r.Reservations[0].Instances[0]
-
 	if s.Debug {
 		if instance.PublicDnsName != nil && *instance.PublicDnsName != "" {
 			ui.Message(fmt.Sprintf("Public DNS: %s", *instance.PublicDnsName))
@@ -224,70 +316,6 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 
 	state.Put("instance", instance)
 
-	// If we're in a region that doesn't support tagging on instance creation,
-	// do that now.
-
-	if s.IsRestricted {
-		ec2Tags.Report(ui)
-		// Retry creating tags for about 2.5 minutes
-		err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
-			_, err := ec2conn.CreateTags(&ec2.CreateTagsInput{
-				Tags:      ec2Tags,
-				Resources: []*string{instance.InstanceId},
-			})
-			if err == nil {
-				return true, nil
-			}
-			if awsErr, ok := err.(awserr.Error); ok {
-				if awsErr.Code() == "InvalidInstanceID.NotFound" {
-					return false, nil
-				}
-			}
-			return true, err
-		})
-
-		if err != nil {
-			err := fmt.Errorf("Error tagging source instance: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		// Now tag volumes
-
-		volumeIds := make([]*string, 0)
-		for _, v := range instance.BlockDeviceMappings {
-			if ebs := v.Ebs; ebs != nil {
-				volumeIds = append(volumeIds, ebs.VolumeId)
-			}
-		}
-
-		if len(volumeIds) > 0 && s.VolumeTags.IsSet() {
-			ui.Say("Adding tags to source EBS Volumes")
-
-			volumeTags, err := s.VolumeTags.EC2Tags(s.Ctx, *ec2conn.Config.Region, state)
-			if err != nil {
-				err := fmt.Errorf("Error tagging source EBS Volumes on %s: %s", *instance.InstanceId, err)
-				state.Put("error", err)
-				ui.Error(err.Error())
-				return multistep.ActionHalt
-			}
-			volumeTags.Report(ui)
-
-			_, err = ec2conn.CreateTags(&ec2.CreateTagsInput{
-				Resources: volumeIds,
-				Tags:      volumeTags,
-			})
-
-			if err != nil {
-				err := fmt.Errorf("Error tagging source EBS Volumes on %s: %s", *instance.InstanceId, err)
-				state.Put("error", err)
-				ui.Error(err.Error())
-				return multistep.ActionHalt
-			}
-		}
-	}
-
 	return multistep.ActionContinue
 }
 
@@ -296,6 +324,26 @@ func (s *StepRunSourceInstance) Cleanup(state multistep.StateBag) {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
+	// Cancel the spot request if it exists
+	if s.spotRequest != nil {
+		ui.Say("Cancelling the spot request...")
+		input := &ec2.CancelSpotInstanceRequestsInput{
+			SpotInstanceRequestIds: []*string{s.spotRequest.SpotInstanceRequestId},
+		}
+		if _, err := ec2conn.CancelSpotInstanceRequests(input); err != nil {
+			ui.Error(fmt.Sprintf("Error cancelling the spot request, may still be around: %s", err))
+			return
+		}
+		stateChange := StateChangeConf{
+			Pending: []string{"active", "open"},
+			Refresh: SpotRequestStateRefreshFunc(ec2conn, *s.spotRequest.SpotInstanceRequestId),
+			Target:  "cancelled",
+		}
+
+		WaitForState(&stateChange)
+
+	}
+
 	// Terminate the source instance if it exists
 	if s.instanceId != "" {
 		ui.Say("Terminating the source AWS instance...")
@@ -309,9 +357,6 @@ func (s *StepRunSourceInstance) Cleanup(state multistep.StateBag) {
 			Target:  "terminated",
 		}
 
-		_, err := WaitForState(&stateChange)
-		if err != nil {
-			ui.Error(err.Error())
-		}
+		WaitForState(&stateChange)
 	}
 }

builder/amazon/common/step_run_spot_instance.go

@@ -1,378 +0,0 @@
-package common
-
-import (
-	"context"
-	"encoding/base64"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"strconv"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/ec2"
-
-	retry "github.com/hashicorp/packer/common"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
-)
-
-type StepRunSpotInstance struct {
-	AssociatePublicIpAddress          bool
-	AvailabilityZone                  string
-	BlockDevices                      BlockDevices
-	Debug                             bool
-	EbsOptimized                      bool
-	ExpectedRootDevice                string
-	IamInstanceProfile                string
-	InstanceInitiatedShutdownBehavior string
-	InstanceType                      string
-	SourceAMI                         string
-	SpotPrice                         string
-	SpotPriceProduct                  string
-	SubnetId                          string
-	Tags                              TagMap
-	VolumeTags                        TagMap
-	UserData                          string
-	UserDataFile                      string
-	Ctx                               interpolate.Context
-
-	instanceId  string
-	spotRequest *ec2.SpotInstanceRequest
-}
-
-func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ec2conn := state.Get("ec2").(*ec2.EC2)
-	var keyName string
-	if name, ok := state.GetOk("keyPair"); ok {
-		keyName = name.(string)
-	}
-	securityGroupIds := aws.StringSlice(state.Get("securityGroupIds").([]string))
-	ui := state.Get("ui").(packer.Ui)
-
-	userData := s.UserData
-	if s.UserDataFile != "" {
-		contents, err := ioutil.ReadFile(s.UserDataFile)
-		if err != nil {
-			state.Put("error", fmt.Errorf("Problem reading user data file: %s", err))
-			return multistep.ActionHalt
-		}
-
-		userData = string(contents)
-	}
-
-	// Test if it is encoded already, and if not, encode it
-	if _, err := base64.StdEncoding.DecodeString(userData); err != nil {
-		log.Printf("[DEBUG] base64 encoding user data...")
-		userData = base64.StdEncoding.EncodeToString([]byte(userData))
-	}
-
-	ui.Say("Launching a source AWS instance...")
-	image, ok := state.Get("source_image").(*ec2.Image)
-	if !ok {
-		state.Put("error", fmt.Errorf("source_image type assertion failed"))
-		return multistep.ActionHalt
-	}
-	s.SourceAMI = *image.ImageId
-
-	if s.ExpectedRootDevice != "" && *image.RootDeviceType != s.ExpectedRootDevice {
-		state.Put("error", fmt.Errorf(
-			"The provided source AMI has an invalid root device type.\n"+
-				"Expected '%s', got '%s'.",
-			s.ExpectedRootDevice, *image.RootDeviceType))
-		return multistep.ActionHalt
-	}
-
-	spotPrice := s.SpotPrice
-	availabilityZone := s.AvailabilityZone
-	if spotPrice == "auto" {
-		ui.Message(fmt.Sprintf(
-			"Finding spot price for %s %s...",
-			s.SpotPriceProduct, s.InstanceType))
-
-		// Detect the spot price
-		startTime := time.Now().Add(-1 * time.Hour)
-		resp, err := ec2conn.DescribeSpotPriceHistory(&ec2.DescribeSpotPriceHistoryInput{
-			InstanceTypes:       []*string{&s.InstanceType},
-			ProductDescriptions: []*string{&s.SpotPriceProduct},
-			AvailabilityZone:    &s.AvailabilityZone,
-			StartTime:           &startTime,
-		})
-		if err != nil {
-			err := fmt.Errorf("Error finding spot price: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		var price float64
-		for _, history := range resp.SpotPriceHistory {
-			log.Printf("[INFO] Candidate spot price: %s", *history.SpotPrice)
-			current, err := strconv.ParseFloat(*history.SpotPrice, 64)
-			if err != nil {
-				log.Printf("[ERR] Error parsing spot price: %s", err)
-				continue
-			}
-			if price == 0 || current < price {
-				price = current
-				if s.AvailabilityZone == "" {
-					availabilityZone = *history.AvailabilityZone
-				}
-			}
-		}
-		if price == 0 {
-			err := fmt.Errorf("No candidate spot prices found!")
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		} else {
-			// Add 0.5 cents to minimum spot bid to ensure capacity will be available
-			// Avoids price-too-low error in active markets which can fluctuate
-			price = price + 0.005
-		}
-
-		spotPrice = strconv.FormatFloat(price, 'f', -1, 64)
-	}
-
-	var instanceId string
-
-	ui.Say("Adding tags to source instance")
-	if _, exists := s.Tags["Name"]; !exists {
-		s.Tags["Name"] = "Packer Builder"
-	}
-
-	ec2Tags, err := s.Tags.EC2Tags(s.Ctx, *ec2conn.Config.Region, state)
-	if err != nil {
-		err := fmt.Errorf("Error tagging source instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	ec2Tags.Report(ui)
-
-	ui.Message(fmt.Sprintf(
-		"Requesting spot instance '%s' for: %s",
-		s.InstanceType, spotPrice))
-
-	runOpts := &ec2.RequestSpotLaunchSpecification{
-		ImageId:            &s.SourceAMI,
-		InstanceType:       &s.InstanceType,
-		UserData:           &userData,
-		IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
-		Placement: &ec2.SpotPlacement{
-			AvailabilityZone: &availabilityZone,
-		},
-		BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
-		EbsOptimized:        &s.EbsOptimized,
-	}
-
-	if s.SubnetId != "" && s.AssociatePublicIpAddress {
-		runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
-			{
-				DeviceIndex:              aws.Int64(0),
-				AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
-				SubnetId:                 &s.SubnetId,
-				Groups:                   securityGroupIds,
-				DeleteOnTermination:      aws.Bool(true),
-			},
-		}
-	} else {
-		runOpts.SubnetId = &s.SubnetId
-		runOpts.SecurityGroupIds = securityGroupIds
-	}
-
-	if keyName != "" {
-		runOpts.KeyName = &keyName
-	}
-
-	runSpotResp, err := ec2conn.RequestSpotInstances(&ec2.RequestSpotInstancesInput{
-		SpotPrice:           &spotPrice,
-		LaunchSpecification: runOpts,
-	})
-	if err != nil {
-		err := fmt.Errorf("Error launching source spot instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	s.spotRequest = runSpotResp.SpotInstanceRequests[0]
-
-	spotRequestId := s.spotRequest.SpotInstanceRequestId
-	ui.Message(fmt.Sprintf("Waiting for spot request (%s) to become active...", *spotRequestId))
-	stateChange := StateChangeConf{
-		Pending:   []string{"open"},
-		Target:    "active",
-		Refresh:   SpotRequestStateRefreshFunc(ec2conn, *spotRequestId),
-		StepState: state,
-	}
-	_, err = WaitForState(&stateChange)
-	if err != nil {
-		err := fmt.Errorf("Error waiting for spot request (%s) to become ready: %s", *spotRequestId, err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	spotResp, err := ec2conn.DescribeSpotInstanceRequests(&ec2.DescribeSpotInstanceRequestsInput{
-		SpotInstanceRequestIds: []*string{spotRequestId},
-	})
-	if err != nil {
-		err := fmt.Errorf("Error finding spot request (%s): %s", *spotRequestId, err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	instanceId = *spotResp.SpotInstanceRequests[0].InstanceId
-
-	// Set the instance ID so that the cleanup works properly
-	s.instanceId = instanceId
-
-	ui.Message(fmt.Sprintf("Instance ID: %s", instanceId))
-	ui.Say(fmt.Sprintf("Waiting for instance (%v) to become ready...", instanceId))
-	describeInstance := &ec2.DescribeInstancesInput{
-		InstanceIds: []*string{aws.String(instanceId)},
-	}
-	if err := ec2conn.WaitUntilInstanceRunningWithContext(ctx, describeInstance); err != nil {
-		err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", instanceId, err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	r, err := ec2conn.DescribeInstances(&ec2.DescribeInstancesInput{
-		InstanceIds: []*string{aws.String(instanceId)},
-	})
-	if err != nil || len(r.Reservations) == 0 || len(r.Reservations[0].Instances) == 0 {
-		err := fmt.Errorf("Error finding source instance.")
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	instance := r.Reservations[0].Instances[0]
-
-	// Retry creating tags for about 2.5 minutes
-	err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
-		_, err := ec2conn.CreateTags(&ec2.CreateTagsInput{
-			Tags:      ec2Tags,
-			Resources: []*string{instance.InstanceId},
-		})
-		if err == nil {
-			return true, nil
-		}
-		if awsErr, ok := err.(awserr.Error); ok {
-			if awsErr.Code() == "InvalidInstanceID.NotFound" {
-				return false, nil
-			}
-		}
-		return true, err
-	})
-
-	if err != nil {
-		err := fmt.Errorf("Error tagging source instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	volumeIds := make([]*string, 0)
-	for _, v := range instance.BlockDeviceMappings {
-		if ebs := v.Ebs; ebs != nil {
-			volumeIds = append(volumeIds, ebs.VolumeId)
-		}
-	}
-
-	if len(volumeIds) > 0 && s.VolumeTags.IsSet() {
-		ui.Say("Adding tags to source EBS Volumes")
-
-		volumeTags, err := s.VolumeTags.EC2Tags(s.Ctx, *ec2conn.Config.Region, state)
-		if err != nil {
-			err := fmt.Errorf("Error tagging source EBS Volumes on %s: %s", *instance.InstanceId, err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-		volumeTags.Report(ui)
-
-		_, err = ec2conn.CreateTags(&ec2.CreateTagsInput{
-			Resources: volumeIds,
-			Tags:      volumeTags,
-		})
-
-		if err != nil {
-			err := fmt.Errorf("Error tagging source EBS Volumes on %s: %s", *instance.InstanceId, err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-	}
-
-	if s.Debug {
-		if instance.PublicDnsName != nil && *instance.PublicDnsName != "" {
-			ui.Message(fmt.Sprintf("Public DNS: %s", *instance.PublicDnsName))
-		}
-
-		if instance.PublicIpAddress != nil && *instance.PublicIpAddress != "" {
-			ui.Message(fmt.Sprintf("Public IP: %s", *instance.PublicIpAddress))
-		}
-
-		if instance.PrivateIpAddress != nil && *instance.PrivateIpAddress != "" {
-			ui.Message(fmt.Sprintf("Private IP: %s", *instance.PrivateIpAddress))
-		}
-	}
-
-	state.Put("instance", instance)
-
-	return multistep.ActionContinue
-}
-
-func (s *StepRunSpotInstance) Cleanup(state multistep.StateBag) {
-
-	ec2conn := state.Get("ec2").(*ec2.EC2)
-	ui := state.Get("ui").(packer.Ui)
-
-	// Cancel the spot request if it exists
-	if s.spotRequest != nil {
-		ui.Say("Cancelling the spot request...")
-		input := &ec2.CancelSpotInstanceRequestsInput{
-			SpotInstanceRequestIds: []*string{s.spotRequest.SpotInstanceRequestId},
-		}
-		if _, err := ec2conn.CancelSpotInstanceRequests(input); err != nil {
-			ui.Error(fmt.Sprintf("Error cancelling the spot request, may still be around: %s", err))
-			return
-		}
-		stateChange := StateChangeConf{
-			Pending: []string{"active", "open"},
-			Refresh: SpotRequestStateRefreshFunc(ec2conn, *s.spotRequest.SpotInstanceRequestId),
-			Target:  "cancelled",
-		}
-
-		_, err := WaitForState(&stateChange)
-		if err != nil {
-			ui.Error(err.Error())
-		}
-
-	}
-
-	// Terminate the source instance if it exists
-	if s.instanceId != "" {
-		ui.Say("Terminating the source AWS instance...")
-		if _, err := ec2conn.TerminateInstances(&ec2.TerminateInstancesInput{InstanceIds: []*string{&s.instanceId}}); err != nil {
-			ui.Error(fmt.Sprintf("Error terminating instance, may still be around: %s", err))
-			return
-		}
-		stateChange := StateChangeConf{
-			Pending: []string{"pending", "running", "shutting-down", "stopped", "stopping"},
-			Refresh: InstanceStateRefreshFunc(ec2conn, s.instanceId),
-			Target:  "terminated",
-		}
-
-		_, err := WaitForState(&stateChange)
-		if err != nil {
-			ui.Error(err.Error())
-		}
-	}
-}

builder/amazon/common/step_security_group.go

@@ -1,30 +1,28 @@
 package common
 
 import (
-	"context"
 	"fmt"
 	"log"
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/waiter"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common/uuid"
-	"github.com/hashicorp/packer/helper/communicator"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/common/uuid"
+	"github.com/mitchellh/packer/helper/communicator"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepSecurityGroup struct {
-	CommConfig            *communicator.Config
-	SecurityGroupIds      []string
-	VpcId                 string
-	TemporarySGSourceCidr string
+	CommConfig       *communicator.Config
+	SecurityGroupIds []string
+	VpcId            string
 
 	createdGroupId string
 }
 
-func (s *StepSecurityGroup) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
@@ -47,23 +45,18 @@ func (s *StepSecurityGroup) Run(_ context.Context, state multistep.StateBag) mul
 
 	port := s.CommConfig.Port()
 	if port == 0 {
-		if s.CommConfig.Type != "none" {
-			panic("port must be set to a non-zero value.")
-		}
+		panic("port must be set to a non-zero value.")
 	}
 
 	// Create the group
-	groupName := fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID())
-	ui.Say(fmt.Sprintf("Creating temporary security group for this instance: %s", groupName))
+	ui.Say("Creating temporary security group for this instance...")
+	groupName := fmt.Sprintf("packer %s", uuid.TimeOrderedUUID())
+	log.Printf("Temporary group name: %s", groupName)
 	group := &ec2.CreateSecurityGroupInput{
 		GroupName:   &groupName,
 		Description: aws.String("Temporary group for Packer"),
+		VpcId:       &s.VpcId,
 	}
-
-	if s.VpcId != "" {
-		group.VpcId = &s.VpcId
-	}
-
 	groupResp, err := ec2conn.CreateSecurityGroup(group)
 	if err != nil {
 		ui.Error(err.Error())
@@ -80,15 +73,15 @@ func (s *StepSecurityGroup) Run(_ context.Context, state multistep.StateBag) mul
 		IpProtocol: aws.String("tcp"),
 		FromPort:   aws.Int64(int64(port)),
 		ToPort:     aws.Int64(int64(port)),
-		CidrIp:     aws.String(s.TemporarySGSourceCidr),
+		CidrIp:     aws.String("0.0.0.0/0"),
 	}
 
 	// We loop and retry this a few times because sometimes the security
-	// group isn't available immediately because AWS resources are eventually
+	// group isn't available immediately because AWS resources are eventaully
 	// consistent.
 	ui.Say(fmt.Sprintf(
-		"Authorizing access to port %d from %s in the temporary security group...",
-		port, s.TemporarySGSourceCidr))
+		"Authorizing access to port %d the temporary security group...",
+		port))
 	for i := 0; i < 5; i++ {
 		_, err = ec2conn.AuthorizeSecurityGroupIngress(req)
 		if err == nil {
@@ -155,43 +148,36 @@ func (s *StepSecurityGroup) Cleanup(state multistep.StateBag) {
 }
 
 func waitUntilSecurityGroupExists(c *ec2.EC2, input *ec2.DescribeSecurityGroupsInput) error {
-	ctx := aws.BackgroundContext()
-	w := request.Waiter{
-		Name:        "DescribeSecurityGroups",
+	waiterCfg := waiter.Config{
+		Operation:   "DescribeSecurityGroups",
+		Delay:       15,
 		MaxAttempts: 40,
-		Delay:       request.ConstantWaiterDelay(5 * time.Second),
-		Acceptors: []request.WaiterAcceptor{
+		Acceptors: []waiter.WaitAcceptor{
 			{
-				State:    request.SuccessWaiterState,
-				Matcher:  request.PathWaiterMatch,
+				State:    "success",
+				Matcher:  "path",
 				Argument: "length(SecurityGroups[]) > `0`",
 				Expected: true,
 			},
 			{
-				State:    request.RetryWaiterState,
-				Matcher:  request.ErrorWaiterMatch,
+				State:    "retry",
+				Matcher:  "error",
 				Argument: "",
 				Expected: "InvalidGroup.NotFound",
 			},
 			{
-				State:    request.RetryWaiterState,
-				Matcher:  request.ErrorWaiterMatch,
+				State:    "retry",
+				Matcher:  "error",
 				Argument: "",
 				Expected: "InvalidSecurityGroupID.NotFound",
 			},
 		},
-		Logger: c.Config.Logger,
-		NewRequest: func(opts []request.Option) (*request.Request, error) {
-			var inCpy *ec2.DescribeSecurityGroupsInput
-			if input != nil {
-				tmp := *input
-				inCpy = &tmp
-			}
-			req, _ := c.DescribeSecurityGroupsRequest(inCpy)
-			req.SetContext(ctx)
-			req.ApplyOptions(opts...)
-			return req, nil
-		},
 	}
-	return w.WaitWithContext(ctx)
+
+	w := waiter.Waiter{
+		Client: c,
+		Input:  input,
+		Config: waiterCfg,
+	}
+	return w.Wait()
 }

builder/amazon/common/step_source_ami_info.go

@@ -1,15 +1,14 @@
 package common
 
 import (
-	"context"
 	"fmt"
 	"log"
 	"sort"
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepSourceAMIInfo extracts critical information from the source AMI
@@ -18,10 +17,9 @@ import (
 // Produces:
 //   source_image *ec2.Image - the source AMI info
 type StepSourceAMIInfo struct {
-	SourceAmi                string
-	EnableAMISriovNetSupport bool
-	EnableAMIENASupport      bool
-	AmiFilters               AmiFilterOptions
+	SourceAmi          string
+	EnhancedNetworking bool
+	AmiFilters         AmiFilterOptions
 }
 
 // Build a slice of AMI filter options from the filters provided.
@@ -53,7 +51,7 @@ func mostRecentAmi(images []*ec2.Image) *ec2.Image {
 	return sortedImages[len(sortedImages)-1]
 }
 
-func (s *StepSourceAMIInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepSourceAMIInfo) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
@@ -87,7 +85,7 @@ func (s *StepSourceAMIInfo) Run(_ context.Context, state multistep.StateBag) mul
 		return multistep.ActionHalt
 	}
 
-	if len(imageResp.Images) > 1 && !s.AmiFilters.MostRecent {
+	if len(imageResp.Images) > 1 && s.AmiFilters.MostRecent == false {
 		err := fmt.Errorf("Your query returned more than one result. Please try a more specific search, or set most_recent to true.")
 		state.Put("error", err)
 		ui.Error(err.Error())
@@ -105,7 +103,7 @@ func (s *StepSourceAMIInfo) Run(_ context.Context, state multistep.StateBag) mul
 
 	// Enhanced Networking can only be enabled on HVM AMIs.
 	// See http://goo.gl/icuXh5
-	if (s.EnableAMIENASupport || s.EnableAMISriovNetSupport) && *image.VirtualizationType != "hvm" {
+	if s.EnhancedNetworking && *image.VirtualizationType != "hvm" {
 		err := fmt.Errorf("Cannot enable enhanced networking, source AMI '%s' is not HVM", s.SourceAmi)
 		state.Put("error", err)
 		ui.Error(err.Error())

builder/amazon/common/step_stop_ebs_instance.go

@@ -1,28 +1,25 @@
 package common
 
 import (
-	"context"
 	"fmt"
 
-	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common"
-	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepStopEBSBackedInstance struct {
-	Skip                bool
+	SpotPrice           string
 	DisableStopInstance bool
 }
 
-func (s *StepStopEBSBackedInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepStopEBSBackedInstance) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	instance := state.Get("instance").(*ec2.Instance)
 	ui := state.Get("ui").(packer.Ui)
 
 	// Skip when it is a spot instance
-	if s.Skip {
+	if s.SpotPrice != "" && s.SpotPrice != "0" {
 		return multistep.ActionContinue
 	}
 
@@ -31,57 +28,28 @@ func (s *StepStopEBSBackedInstance) Run(ctx context.Context, state multistep.Sta
 	if !s.DisableStopInstance {
 		// Stop the instance so we can create an AMI from it
 		ui.Say("Stopping the source instance...")
-
-		// Amazon EC2 API follows an eventual consistency model.
-
-		// This means that if you run a command to modify or describe a resource
-		// that you just created, its ID might not have propagated throughout
-		// the system, and you will get an error responding that the resource
-		// does not exist.
-
-		// Work around this by retrying a few times, up to about 5 minutes.
-		err := common.Retry(10, 60, 6, func(i uint) (bool, error) {
-			ui.Message(fmt.Sprintf("Stopping instance, attempt %d", i+1))
-
-			_, err = ec2conn.StopInstances(&ec2.StopInstancesInput{
-				InstanceIds: []*string{instance.InstanceId},
-			})
-
-			if err == nil {
-				// success
-				return true, nil
-			}
-
-			if awsErr, ok := err.(awserr.Error); ok {
-				if awsErr.Code() == "InvalidInstanceID.NotFound" {
-					ui.Message(fmt.Sprintf(
-						"Error stopping instance; will retry ..."+
-							"Error: %s", err))
-					// retry
-					return false, nil
-				}
-			}
-			// errored, but not in expected way. Don't want to retry
-			return true, err
+		_, err = ec2conn.StopInstances(&ec2.StopInstancesInput{
+			InstanceIds: []*string{instance.InstanceId},
 		})
-
 		if err != nil {
 			err := fmt.Errorf("Error stopping instance: %s", err)
 			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
-
 	} else {
 		ui.Say("Automatic instance stop disabled. Please stop instance manually.")
 	}
 
-	// Wait for the instance to actually stop
+	// Wait for the instance to actual stop
 	ui.Say("Waiting for the instance to stop...")
-	err = ec2conn.WaitUntilInstanceStoppedWithContext(ctx, &ec2.DescribeInstancesInput{
-		InstanceIds: []*string{instance.InstanceId},
-	})
-
+	stateChange := StateChangeConf{
+		Pending:   []string{"running", "stopping"},
+		Target:    "stopped",
+		Refresh:   InstanceStateRefreshFunc(ec2conn, *instance.InstanceId),
+		StepState: state,
+	}
+	_, err = WaitForState(&stateChange)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for instance to stop: %s", err)
 		state.Put("error", err)