bump gem deps and www version

This fixes building `packer` with Go >1.6.  From https://golang.org/cmd/link/:

```
-X importpath.name=value
	Set the value of the string variable in importpath named name to value.
	Note that before Go 1.5 this option took two separate arguments.
	Now it takes one argument split on the first = sign.
```

.gitattributes

@@ -1,2 +0,0 @@
-
-common/test-fixtures/root/*	eol=lf

.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.
 
@@ -17,10 +12,9 @@ FOR BUGS:
 
 Describe the problem and include the following information:
 
-- Packer version from `packer version`
+- Packer Version
 - Host platform
 - Debug log output from `PACKER_LOG=1 packer build template.json`.
   Please paste this in a gist https://gist.github.com
 - The _simplest example template and scripts_ needed to reproduce the bug.
   Include these in your gist https://gist.github.com
-  

.github/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

@@ -9,18 +9,8 @@
 .idea
 test/.env
 *~
-*.received.*
-*.swp
 
 website/.bundle
 website/vendor
 
 packer-test*.log
-
-*.received.txt
-*.received.json
-
-.idea/
-*.iml
-Thumbs.db
-/packer.exe

.travis.yml

@@ -1,14 +1,9 @@
-env:
-    - USER=travis
-
 sudo: false
 
 language: go
 
 go:
-  - 1.7.4
-  - 1.8.3
-  - 1.9
+  - 1.6
 
 install:
   - make deps
@@ -22,3 +17,5 @@ branches:
 
 matrix:
   fast_finish: true
+  allow_failures:
+    - go: 1.4.3

CONTRIBUTING.md

@@ -54,7 +54,7 @@ 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.
+   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`.
@@ -65,65 +65,29 @@ following steps in order to be able to compile and test Packer. These instructio
     ```
 
 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`.
+   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/hashicorp/packer` so you
-   can run `make` and easily access other files. Run `make help` to get
-   information about make targets.
+4. When working on packer `cd $GOPATH/src/github.com/mitchellh/packer` so you
+   can run `make` and easily access other files.
 
 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
+   `$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/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`.
+   `$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/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 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
+#### Godeps
 
-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 `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.
+If you are submitting a change that requires a change in dependencies, DO NOT update the `vendor/` folder. This keeps the PR smaller and easier to review. Instead, please indicate which upstream has changed and which version we should be using. You _may_ do this using `Godeps/Godeps.json` but this is not required.
 
 #### Running Unit Tests
 
@@ -137,11 +101,16 @@ 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
+If you're working on a feature of a builder or a new builder 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.
+may incur real costs in some cases. In the presence of a bug, it is technically
+possible that broken backends could leave dangling data behind. Therefore,
+please run the acceptance tests at your own risk. At the very least, we
+recommend running them in their own private account for whatever builder you're
+testing.
 
 To run the acceptance tests, invoke `make testacc`:
 
@@ -154,5 +123,5 @@ 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.
+things such as access keys. The test itself should error early and tell you
+what to set, so it is not documented here.

Godeps/Godeps.json

@@ -0,0 +1,633 @@
+{
+	"ImportPath": "github.com/mitchellh/packer",
+	"GoVersion": "go1.6",
+	"GodepVersion": "v62",
+	"Deps": [
+		{
+			"ImportPath": "github.com/ActiveState/tail",
+			"Comment": "v0-41-g1a0242e",
+			"Rev": "1a0242e795eeefe54261ff308dc685f7d29cc58c"
+		},
+		{
+			"ImportPath": "github.com/Azure/azure-sdk-for-go/arm/compute",
+			"Comment": "v2.1.1-beta",
+			"Rev": "a1883f7b98346e4908a6c25230c95a8a3026a10c"
+		},
+		{
+			"ImportPath": "github.com/Azure/azure-sdk-for-go/arm/network",
+			"Comment": "v2.1.1-beta",
+			"Rev": "a1883f7b98346e4908a6c25230c95a8a3026a10c"
+		},
+		{
+			"ImportPath": "github.com/Azure/azure-sdk-for-go/arm/resources/resources",
+			"Comment": "v2.1.1-beta",
+			"Rev": "a1883f7b98346e4908a6c25230c95a8a3026a10c"
+		},
+		{
+			"ImportPath": "github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions",
+			"Comment": "v2.1.1-beta",
+			"Rev": "a1883f7b98346e4908a6c25230c95a8a3026a10c"
+		},
+		{
+			"ImportPath": "github.com/Azure/azure-sdk-for-go/arm/storage",
+			"Comment": "v2.1.1-beta",
+			"Rev": "a1883f7b98346e4908a6c25230c95a8a3026a10c"
+		},
+		{
+			"ImportPath": "github.com/Azure/azure-sdk-for-go/storage",
+			"Comment": "v2.1.1-beta",
+			"Rev": "a1883f7b98346e4908a6c25230c95a8a3026a10c"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest",
+			"Comment": "v7.0.4",
+			"Rev": "b01ec2b60f95678fa759f796bac3c6b9bceaead4"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/azure",
+			"Comment": "v7.0.4",
+			"Rev": "b01ec2b60f95678fa759f796bac3c6b9bceaead4"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/date",
+			"Comment": "v7.0.4",
+			"Rev": "b01ec2b60f95678fa759f796bac3c6b9bceaead4"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/to",
+			"Comment": "v7.0.4",
+			"Rev": "b01ec2b60f95678fa759f796bac3c6b9bceaead4"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-ntlmssp",
+			"Rev": "e0b63eb299a769ea4b04dadfe530f6074b277afb"
+		},
+		{
+			"ImportPath": "github.com/armon/go-radix",
+			"Rev": "4239b77079c7b5d1243b7b4736304ce8ddb6f0f2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/awserr",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/awsutil",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/client",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/client/metadata",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/corehandlers",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/defaults",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/ec2metadata",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/request",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/aws/session",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/endpoints",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/ec2query",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query/queryutil",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/rest",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/restxml",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/signer/v4",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/private/waiter",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/service/ec2",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/service/s3",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/service/s3/s3iface",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/service/s3/s3manager",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/service/sts",
+			"Comment": "v1.1.2",
+			"Rev": "8041be5461786460d86b4358305fbdf32d37cfb2"
+		},
+		{
+			"ImportPath": "github.com/bgentry/speakeasy",
+			"Rev": "36e9cfdd690967f4f690c6edcc9ffacd006014a0"
+		},
+		{
+			"ImportPath": "github.com/dgrijalva/jwt-go",
+			"Comment": "v2.4.0-11-gf219341",
+			"Rev": "f2193411bd642f7db03249fd79d5292c9b34916a"
+		},
+		{
+			"ImportPath": "github.com/digitalocean/godo",
+			"Comment": "v0.9.0-24-g6ca5b77",
+			"Rev": "6ca5b770f203b82a0fca68d0941736458efa8a4f"
+		},
+		{
+			"ImportPath": "github.com/dylanmei/iso8601",
+			"Rev": "2075bf119b58e5576c6ed9f867b8f3d17f2e54d4"
+		},
+		{
+			"ImportPath": "github.com/dylanmei/winrmtest",
+			"Rev": "025617847eb2cf9bd1d851bc3b22ed28e6245ce5"
+		},
+		{
+			"ImportPath": "github.com/go-ini/ini",
+			"Comment": "v1.8.6",
+			"Rev": "afbd495e5aaea13597b5e14fe514ddeaa4d76fc3"
+		},
+		{
+			"ImportPath": "github.com/golang/protobuf/proto",
+			"Rev": "b982704f8bb716bb608144408cff30e15fbde841"
+		},
+		{
+			"ImportPath": "github.com/google/go-querystring/query",
+			"Rev": "2a60fc2ba6c19de80291203597d752e9ba58e4c0"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/atlas-go/archive",
+			"Comment": "20141209094003-92-g95fa852",
+			"Rev": "95fa852edca41c06c4ce526af4bb7dec4eaad434"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/atlas-go/v1",
+			"Comment": "20141209094003-92-g95fa852",
+			"Rev": "95fa852edca41c06c4ce526af4bb7dec4eaad434"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/errwrap",
+			"Rev": "7554cd9344cec97297fa6649b055a8c98c2a1e55"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/go-checkpoint",
+			"Rev": "e4b2dc34c0f698ee04750bf2035d8b9384233e1b"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/go-cleanhttp",
+			"Rev": "875fb671b3ddc66f8e2f0acc33829c8cb989a38d"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/go-multierror",
+			"Rev": "d30f09973e19c1dfcd120b2d9c4f168e68d6b5d5"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/go-rootcerts",
+			"Rev": "6bb64b370b90e7ef1fa532be9e591a81c3493e00"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/go-version",
+			"Rev": "7e3c02b30806fa5779d3bdfc152ce4c6f40e7b38"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/yamux",
+			"Rev": "df949784da9ed028ee76df44652e42d37a09d7e4"
+		},
+		{
+			"ImportPath": "github.com/hpcloud/tail/ratelimiter",
+			"Comment": "v0-41-g1a0242e",
+			"Rev": "1a0242e795eeefe54261ff308dc685f7d29cc58c"
+		},
+		{
+			"ImportPath": "github.com/hpcloud/tail/util",
+			"Comment": "v0-41-g1a0242e",
+			"Rev": "1a0242e795eeefe54261ff308dc685f7d29cc58c"
+		},
+		{
+			"ImportPath": "github.com/hpcloud/tail/watch",
+			"Comment": "v0-41-g1a0242e",
+			"Rev": "1a0242e795eeefe54261ff308dc685f7d29cc58c"
+		},
+		{
+			"ImportPath": "github.com/hpcloud/tail/winfile",
+			"Comment": "v0-41-g1a0242e",
+			"Rev": "1a0242e795eeefe54261ff308dc685f7d29cc58c"
+		},
+		{
+			"ImportPath": "github.com/jmespath/go-jmespath",
+			"Comment": "0.2.2-2-gc01cf91",
+			"Rev": "c01cf91b011868172fdcd9f41838e80c9d716264"
+		},
+		{
+			"ImportPath": "github.com/kardianos/osext",
+			"Rev": "29ae4ffbc9a6fe9fb2bc5029050ce6996ea1d3bc"
+		},
+		{
+			"ImportPath": "github.com/klauspost/compress/flate",
+			"Rev": "f86d2e6d8a77c6a2c4e42a87ded21c6422f7557e"
+		},
+		{
+			"ImportPath": "github.com/klauspost/cpuid",
+			"Rev": "349c675778172472f5e8f3a3e0fe187e302e5a10"
+		},
+		{
+			"ImportPath": "github.com/klauspost/crc32",
+			"Rev": "999f3125931f6557b991b2f8472172bdfa578d38"
+		},
+		{
+			"ImportPath": "github.com/klauspost/pgzip",
+			"Rev": "47f36e165cecae5382ecf1ec28ebf7d4679e307d"
+		},
+		{
+			"ImportPath": "github.com/kr/fs",
+			"Rev": "2788f0dbd16903de03cb8186e5c7d97b69ad387b"
+		},
+		{
+			"ImportPath": "github.com/masterzen/simplexml/dom",
+			"Rev": "95ba30457eb1121fa27753627c774c7cd4e90083"
+		},
+		{
+			"ImportPath": "github.com/masterzen/winrm/soap",
+			"Rev": "54ea5d01478cfc2afccec1504bd0dfcd8c260cfa"
+		},
+		{
+			"ImportPath": "github.com/masterzen/winrm/winrm",
+			"Rev": "54ea5d01478cfc2afccec1504bd0dfcd8c260cfa"
+		},
+		{
+			"ImportPath": "github.com/masterzen/xmlpath",
+			"Rev": "13f4951698adc0fa9c1dda3e275d489a24201161"
+		},
+		{
+			"ImportPath": "github.com/mattn/go-isatty",
+			"Rev": "56b76bdf51f7708750eac80fa38b952bb9f32639"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/cli",
+			"Rev": "5c87c51cedf76a1737bf5ca3979e8644871598a6"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/go-fs",
+			"Rev": "a34c1b9334e86165685a9449b782f20465eb8c69"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/go-fs/fat",
+			"Rev": "a34c1b9334e86165685a9449b782f20465eb8c69"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/go-homedir",
+			"Rev": "d682a8f0cf139663a984ff12528da460ca963de9"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/go-vnc",
+			"Rev": "723ed9867aed0f3209a81151e52ddc61681f0b01"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/iochan",
+			"Rev": "87b45ffd0e9581375c491fef3d32130bb15c5bd7"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/mapstructure",
+			"Rev": "281073eb9eb092240d33ef253c404f1cca550309"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/multistep",
+			"Rev": "162146fc57112954184d90266f4733e900ed05a5"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/panicwrap",
+			"Rev": "a1e50bc201f387747a45ffff020f1af2d8759e88"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/prefixedio",
+			"Rev": "6e6954073784f7ee67b28f2d22749d6479151ed7"
+		},
+		{
+			"ImportPath": "github.com/mitchellh/reflectwalk",
+			"Rev": "eecf4c70c626c7cfbb95c90195bc34d386c74ac6"
+		},
+		{
+			"ImportPath": "github.com/nu7hatch/gouuid",
+			"Rev": "179d4d0c4d8d407a32af483c2354df1d2c91e6c3"
+		},
+		{
+			"ImportPath": "github.com/packer-community/winrmcp/winrmcp",
+			"Rev": "f1bcf36a69fa2945e65dd099eee11b560fbd3346"
+		},
+		{
+			"ImportPath": "github.com/pierrec/lz4",
+			"Rev": "383c0d87b5dd7c090d3cddefe6ff0c2ffbb88470"
+		},
+		{
+			"ImportPath": "github.com/pierrec/xxHash/xxHash32",
+			"Rev": "5a004441f897722c627870a981d02b29924215fa"
+		},
+		{
+			"ImportPath": "github.com/pkg/sftp",
+			"Rev": "e84cc8c755ca39b7b64f510fe1fffc1b51f210a5"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/common/extensions",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/compute/v2/extensions",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/floatingip",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/keypairs",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/startstop",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/compute/v2/flavors",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/compute/v2/images",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/compute/v2/servers",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/identity/v2/tenants",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/identity/v2/tokens",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/identity/v3/tokens",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/openstack/utils",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/pagination",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/testhelper",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/rackspace/gophercloud/testhelper/client",
+			"Comment": "v1.0.0-810-g53d1dc4",
+			"Rev": "53d1dc4400e1ebcd37a0e01d8c1fe2f4db3b99d2"
+		},
+		{
+			"ImportPath": "github.com/satori/go.uuid",
+			"Rev": "d41af8bb6a7704f00bc3b7cba9355ae6a5a80048"
+		},
+		{
+			"ImportPath": "github.com/tent/http-link-go",
+			"Rev": "ac974c61c2f990f4115b119354b5e0b47550e888"
+		},
+		{
+			"ImportPath": "github.com/ugorji/go/codec",
+			"Rev": "646ae4a518c1c3be0739df898118d9bccf993858"
+		},
+		{
+			"ImportPath": "golang.org/x/crypto/curve25519",
+			"Rev": "1f22c0103821b9390939b6776727195525381532"
+		},
+		{
+			"ImportPath": "golang.org/x/crypto/md4",
+			"Rev": "1f22c0103821b9390939b6776727195525381532"
+		},
+		{
+			"ImportPath": "golang.org/x/crypto/ssh",
+			"Rev": "1f22c0103821b9390939b6776727195525381532"
+		},
+		{
+			"ImportPath": "golang.org/x/crypto/ssh/agent",
+			"Rev": "1f22c0103821b9390939b6776727195525381532"
+		},
+		{
+			"ImportPath": "golang.org/x/net/context",
+			"Rev": "6ccd6698c634f5d835c40c1c31848729e0cecda1"
+		},
+		{
+			"ImportPath": "golang.org/x/net/context/ctxhttp",
+			"Rev": "6ccd6698c634f5d835c40c1c31848729e0cecda1"
+		},
+		{
+			"ImportPath": "golang.org/x/net/html",
+			"Rev": "6ccd6698c634f5d835c40c1c31848729e0cecda1"
+		},
+		{
+			"ImportPath": "golang.org/x/net/html/atom",
+			"Rev": "6ccd6698c634f5d835c40c1c31848729e0cecda1"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2",
+			"Rev": "8a57ed94ffd43444c0879fe75701732a38afc985"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/google",
+			"Rev": "8a57ed94ffd43444c0879fe75701732a38afc985"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/internal",
+			"Rev": "8a57ed94ffd43444c0879fe75701732a38afc985"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/jws",
+			"Rev": "8a57ed94ffd43444c0879fe75701732a38afc985"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/jwt",
+			"Rev": "8a57ed94ffd43444c0879fe75701732a38afc985"
+		},
+		{
+			"ImportPath": "golang.org/x/sys/unix",
+			"Rev": "50c6bc5e4292a1d4e65c6e9be5f53be28bcbe28e"
+		},
+		{
+			"ImportPath": "google.golang.org/api/compute/v1",
+			"Rev": "ddff2aff599105a55549cf173852507dfa094b7f"
+		},
+		{
+			"ImportPath": "google.golang.org/api/gensupport",
+			"Rev": "ddff2aff599105a55549cf173852507dfa094b7f"
+		},
+		{
+			"ImportPath": "google.golang.org/api/googleapi",
+			"Rev": "ddff2aff599105a55549cf173852507dfa094b7f"
+		},
+		{
+			"ImportPath": "google.golang.org/api/googleapi/internal/uritemplates",
+			"Rev": "ddff2aff599105a55549cf173852507dfa094b7f"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine",
+			"Rev": "6bde959377a90acb53366051d7d587bfd7171354"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal",
+			"Rev": "6bde959377a90acb53366051d7d587bfd7171354"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/app_identity",
+			"Rev": "6bde959377a90acb53366051d7d587bfd7171354"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/base",
+			"Rev": "6bde959377a90acb53366051d7d587bfd7171354"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/datastore",
+			"Rev": "6bde959377a90acb53366051d7d587bfd7171354"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/log",
+			"Rev": "6bde959377a90acb53366051d7d587bfd7171354"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/modules",
+			"Rev": "6bde959377a90acb53366051d7d587bfd7171354"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/remote_api",
+			"Rev": "6bde959377a90acb53366051d7d587bfd7171354"
+		},
+		{
+			"ImportPath": "google.golang.org/cloud/compute/metadata",
+			"Rev": "5a3b06f8b5da3b7c3a93da43163b872c86c509ef"
+		},
+		{
+			"ImportPath": "google.golang.org/cloud/internal",
+			"Rev": "5a3b06f8b5da3b7c3a93da43163b872c86c509ef"
+		},
+		{
+			"ImportPath": "gopkg.in/fsnotify.v1",
+			"Comment": "v1.2.9",
+			"Rev": "8611c35ab31c1c28aa903d33cf8b6e44a399b09e"
+		},
+		{
+			"ImportPath": "gopkg.in/tomb.v1",
+			"Rev": "dd632973f1e7218eb1089048e0798ec9ae7dceb8"
+		},
+		{
+			"ImportPath": "gopkg.in/xmlpath.v2",
+			"Rev": "860cbeca3ebcc600db0b213c0e83ad6ce91f5739"
+		}
+	]
+}

Makefile

@@ -4,66 +4,46 @@ VET?=$(shell ls -d */ | grep -v vendor | grep -v website)
 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
 
 ci: deps test
 
-release: deps test releasebin package ## Build a release build
+release: deps test releasebin package
 
-bin: deps ## Build debug/test build
-	@go get github.com/mitchellh/gox
+bin: deps
 	@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 github.com/kardianos/govendor
-	@govendor sync
+	go get github.com/mitchellh/gox
+	go get golang.org/x/tools/cmd/stringer
+	@go version | grep 1.4 ; if [ $$? -eq 0 ]; then \
+		echo "Installing godep and restoring dependencies"; \
+		go get github.com/tools/godep; \
+		godep restore; \
+	fi
 
-dev: deps ## Build and install a development build
+dev: deps
 	@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)
-
-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 {} \;
+fmt:
+	go fmt `go list ./... | grep -v vendor`
 
 # Install js-beautify with npm install -g js-beautify
 fmt-examples:
@@ -71,11 +51,11 @@ fmt-examples:
 
 # generate runs `go generate` to build the dynamically generated
 # source files.
-generate: deps ## Generate dynamically generated code
+generate: deps
 	go generate .
-	gofmt -w command/plugin.go
+	go fmt command/plugin.go
 
-test: deps fmt-check ## Run unit tests
+test: deps
 	@go test $(TEST) $(TESTARGS) -timeout=2m
 	@go tool vet $(VET)  ; if [ $$? -eq 1 ]; then \
 		echo "ERROR: Vet found problems in the code."; \
@@ -83,17 +63,22 @@ test: deps fmt-check ## Run unit tests
 	fi
 
 # testacc runs acceptance tests
-testacc: deps generate ## Run acceptance tests
+testacc: deps generate
 	@echo "WARN: Acceptance tests will take a long time to run and may cost money. Ctrl-C if you want to cancel."
 	PACKER_ACC=1 go test -v $(TEST) $(TESTARGS) -timeout=45m
 
-testrace: deps ## Test for race conditions
+testrace: deps
 	@go test -race $(TEST) $(TESTARGS) -timeout=2m
 
 updatedeps:
-	@echo "INFO: Packer deps are managed by govendor. See 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 godep. 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}'
+# This is used to add new dependencies to packer. If you are submitting a PR
+# that includes new dependencies you will need to run this.
+vendor:
+	godep restore
+	godep save
 
-.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

@@ -1,22 +1,11 @@
 # Packer
 
-[![Build Status][travis-badge]][travis]
-[![Windows Build Status][appveyor-badge]][appveyor]
-[![GoDoc][godoc-badge]][godoc]
-[![GoReportCard][report-badge]][report]
+[![Build Status](https://travis-ci.org/mitchellh/packer.svg?branch=master)](https://travis-ci.org/mitchellh/packer)
+[![Windows Build Status](https://ci.appveyor.com/api/projects/status/github/mitchellh/packer?branch=master&svg=true)](https://ci.appveyor.com/project/hashicorp/packer)
 
-[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
-[appveyor]: https://ci.appveyor.com/project/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
+* Website: http://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.
@@ -26,21 +15,14 @@ performant, creating machine images for multiple platforms in parallel. Packer
 comes out of the box with support for the following platforms:
 
 * Amazon EC2 (AMI). Both EBS-backed and instance-store AMIs
-* Azure
-* CloudStack
 * DigitalOcean
 * Docker
 * Google Compute Engine
-* Hyper-V
-* 1&1
 * OpenStack
-* Oracle Bare Metal Cloud Services
 * Parallels
-* ProfitBricks
 * QEMU. Both KVM and Xen images.
-* Triton (Joyent Public Cloud)
-* VMware
 * VirtualBox
+* VMware
 
 Support for other platforms can be added via plugins.
 
@@ -48,19 +30,15 @@ The images that Packer creates can easily be turned into
 [Vagrant](http://www.vagrantup.com) boxes.
 
 ## Quick Start
-Download and install packages and dependencies
-```
-go get github.com/hashicorp/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](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](#developing-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
@@ -79,8 +57,8 @@ file as `quick-start.json`. Export your AWS credentials as the
     "access_key": "{{user `access_key`}}",
     "secret_key": "{{user `secret_key`}}",
     "region": "us-east-1",
-    "source_ami": "ami-af22d9b9",
-    "instance_type": "t2.micro",
+    "source_ami": "ami-de0d9eb7",
+    "instance_type": "t1.micro",
     "ssh_username": "ubuntu",
     "ami_name": "packer-example {{timestamp}}"
   }]
@@ -104,8 +82,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/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.

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
 

builder/alicloud/ecs/access_config.go

@@ -1,83 +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"`
-}
-
-// Client for AlicloudClient
-func (c *AlicloudAccessConfig) Client() (*ecs.Client, error) {
-	if err := c.loadAndValidate(); err != nil {
-		return nil, err
-	}
-	client := ecs.NewECSClient(c.AlicloudAccessKey, c.AlicloudSecretKey, 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,242 +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/packer"
-	"github.com/hashicorp/packer/template/interpolate"
-	"github.com/mitchellh/multistep"
-)
-
-// 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.AlicloudImageForceDetele,
-		},
-		&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,
-			InstnaceName:            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,
-		&stepRunAlicloudInstance{},
-		&stepMountAlicloudDisk{},
-		&stepAttachKeyPar{},
-		&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{
-			AlicloudImageForceDeteleSnapshots: b.config.AlicloudImageForceDeteleSnapshots,
-			AlicloudImageForceDetele:          b.config.AlicloudImageForceDetele,
-			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,99 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/hashicorp/packer/template/interpolate"
-	"regexp"
-	"strings"
-)
-
-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"`
-	AlicloudImageForceDetele          bool     `mapstructure:"image_force_delete"`
-	AlicloudImageForceDeteleSnapshots 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/packer"
-	"github.com/mitchellh/multistep"
-)
-
-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 aliclod_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,122 +0,0 @@
-package ecs
-
-import (
-	"io/ioutil"
-	"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 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 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/mitchellh/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,73 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-	"time"
-)
-
-type stepAttachKeyPar struct {
-}
-
-func (s *stepAttachKeyPar) Run(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,42 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepCheckAlicloudSourceImage struct {
-	SourceECSImageId string
-}
-
-func (s *stepCheckAlicloudSourceImage) Run(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,79 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type setpConfigAlicloudEIP struct {
-	AssociatePublicIpAddress bool
-	RegionId                 string
-	InternetChargeType       string
-	allocatedId              string
-}
-
-func (s *setpConfigAlicloudEIP) Run(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,139 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"runtime"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type StepConfigAlicloudKeyPair struct {
-	Debug                bool
-	SSHAgentAuth         bool
-	DebugKeyPath         string
-	TemporaryKeyPairName string
-	KeyPairName          string
-	PrivateKeyFile       string
-	RegionId             string
-
-	keyName string
-}
-
-func (s *StepConfigAlicloudKeyPair) Run(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,35 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepConfigAlicloudPublicIP struct {
-	publicIPAdress string
-	RegionId       string
-}
-
-func (s *stepConfigAlicloudPublicIP) Run(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.publicIPAdress = 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,137 +0,0 @@
-package ecs
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepConfigAlicloudSecurityGroup struct {
-	SecurityGroupId   string
-	SecurityGroupName string
-	Description       string
-	VpcId             string
-	RegionId          string
-	isCreate          bool
-}
-
-func (s *stepConfigAlicloudSecurityGroup) Run(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,96 +0,0 @@
-package ecs
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-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(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,148 +0,0 @@
-package ecs
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepConfigAlicloudVSwitch struct {
-	VSwitchId   string
-	ZoneId      string
-	isCreate    bool
-	CidrBlock   string
-	VSwitchName string
-}
-
-func (s *stepConfigAlicloudVSwitch) Run(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 == "IncorretRouteEntryStatus") && 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,94 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepCreateAlicloudImage struct {
-	image *ecs.ImageType
-}
-
-func (s *stepCreateAlicloudImage) Run(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,163 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepCreateAlicloudInstance struct {
-	IOOptimized             bool
-	InstanceType            string
-	UserData                string
-	UserDataFile            string
-	instanceId              string
-	RegionId                string
-	InternetChargeType      string
-	InternetMaxBandwidthOut int
-	InstnaceName            string
-	ZoneId                  string
-	instance                *ecs.InstanceAttributesType
-}
-
-func (s *stepCreateAlicloudInstance) Run(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.InstnaceName,
-			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.InstnaceName,
-			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,63 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"log"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepDeleteAlicloudImageSnapshots struct {
-	AlicloudImageForceDetele          bool
-	AlicloudImageForceDeteleSnapshots bool
-	AlicloudImageName                 string
-}
-
-func (s *stepDeleteAlicloudImageSnapshots) Run(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.AlicloudImageForceDetele {
-		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.AlicloudImageForceDeteleSnapshots {
-				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,71 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepMountAlicloudDisk struct {
-}
-
-func (s *stepMountAlicloudDisk) Run(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,48 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepPreValidate struct {
-	AlicloudDestImageName string
-	ForceDelete           bool
-}
-
-func (s *stepPreValidate) Run(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,71 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type setpRegionCopyAlicloudImage struct {
-	AlicloudImageDestinationRegions []string
-	AlicloudImageDestinationNames   []string
-	RegionId                        string
-}
-
-func (s *setpRegionCopyAlicloudImage) Run(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 copyedRegionId, copyedImageId := range alicloudImages {
-			if copyedRegionId == s.RegionId {
-				continue
-			}
-			if err := client.CancelCopyImage(common.Region(copyedRegionId), copyedImageId); err != nil {
-				ui.Say(fmt.Sprintf("Error cancelling copy image: %v", err))
-			}
-		}
-	}
-}

builder/alicloud/ecs/step_run_instance.go

@@ -1,56 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepRunAlicloudInstance struct {
-}
-
-func (s *stepRunAlicloudInstance) Run(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)
-		instanceAttrubite, _ := client.DescribeInstanceAttribute(instance.InstanceId)
-		if instanceAttrubite.Status == ecs.Starting || instanceAttrubite.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,60 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type setpShareAlicloudImage struct {
-	AlicloudImageShareAccounts   []string
-	AlicloudImageUNShareAccounts []string
-	RegionId                     string
-}
-
-func (s *setpShareAlicloudImage) Run(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 copyedRegion, copyedImageId := range alicloudImages {
-		err := client.ModifyImageSharePermission(
-			&ecs.ModifyImageSharePermissionArgs{
-				RegionId:      common.Region(copyedRegion),
-				ImageId:       copyedImageId,
-				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 copyedRegion, copyedImageId := range alicloudImages {
-			err := client.ModifyImageSharePermission(
-				&ecs.ModifyImageSharePermissionArgs{
-					RegionId:      common.Region(copyedRegion),
-					ImageId:       copyedImageId,
-					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,43 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type stepStopAlicloudInstance struct {
-	ForceStop bool
-}
-
-func (s *stepStopAlicloudInstance) Run(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/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
@@ -24,25 +25,19 @@ const BuilderId = "mitchellh.amazon.chroot"
 // Config is the configuration that is chained through the steps and
 // settable from the template.
 type Config struct {
-	common.PackerConfig       `mapstructure:",squash"`
-	awscommon.AMIBlockDevices `mapstructure:",squash"`
-	awscommon.AMIConfig       `mapstructure:",squash"`
-	awscommon.AccessConfig    `mapstructure:",squash"`
+	common.PackerConfig    `mapstructure:",squash"`
+	awscommon.AccessConfig `mapstructure:",squash"`
+	awscommon.AMIConfig    `mapstructure:",squash"`
 
-	ChrootMounts      [][]string                 `mapstructure:"chroot_mounts"`
-	CommandWrapper    string                     `mapstructure:"command_wrapper"`
-	CopyFiles         []string                   `mapstructure:"copy_files"`
-	DevicePath        string                     `mapstructure:"device_path"`
-	FromScratch       bool                       `mapstructure:"from_scratch"`
-	MountOptions      []string                   `mapstructure:"mount_options"`
-	MountPartition    int                        `mapstructure:"mount_partition"`
-	MountPath         string                     `mapstructure:"mount_path"`
-	PostMountCommands []string                   `mapstructure:"post_mount_commands"`
-	PreMountCommands  []string                   `mapstructure:"pre_mount_commands"`
-	RootDeviceName    string                     `mapstructure:"root_device_name"`
-	RootVolumeSize    int64                      `mapstructure:"root_volume_size"`
-	SourceAmi         string                     `mapstructure:"source_ami"`
-	SourceAmiFilter   awscommon.AmiFilterOptions `mapstructure:"source_ami_filter"`
+	ChrootMounts   [][]string `mapstructure:"chroot_mounts"`
+	CommandWrapper string     `mapstructure:"command_wrapper"`
+	CopyFiles      []string   `mapstructure:"copy_files"`
+	DevicePath     string     `mapstructure:"device_path"`
+	MountPath      string     `mapstructure:"mount_path"`
+	SourceAmi      string     `mapstructure:"source_ami"`
+	RootVolumeSize int64      `mapstructure:"root_volume_size"`
+	MountOptions   []string   `mapstructure:"mount_options"`
+	MountPartition int        `mapstructure:"mount_partition"`
 
 	ctx interpolate.Context
 }
@@ -63,12 +58,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
 			Exclude: []string{
-				"ami_description",
-				"snapshot_tags",
-				"tags",
 				"command_wrapper",
-				"post_mount_commands",
-				"pre_mount_commands",
 				"mount_path",
 			},
 		},
@@ -77,31 +67,27 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		return nil, err
 	}
 
-	if b.config.PackerConfig.PackerForce {
-		b.config.AMIForceDeregister = true
-	}
-
 	// Defaults
 	if b.config.ChrootMounts == nil {
 		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"},
-			{"sysfs", "sysfs", "/sys"},
-			{"bind", "/dev", "/dev"},
-			{"devpts", "devpts", "/dev/pts"},
-			{"binfmt_misc", "binfmt_misc", "/proc/sys/fs/binfmt_misc"},
+			[]string{"proc", "proc", "/proc"},
+			[]string{"sysfs", "sysfs", "/sys"},
+			[]string{"bind", "/dev", "/dev"},
+			[]string{"devpts", "devpts", "/dev/pts"},
+			[]string{"binfmt_misc", "binfmt_misc", "/proc/sys/fs/binfmt_misc"},
 		}
 	}
 
-	// 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.CopyFiles = []string{"/etc/resolv.conf"}
 	}
 
 	if b.config.CommandWrapper == "" {
@@ -116,10 +102,8 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.MountPartition = 1
 	}
 
-	// Accumulate any errors or warnings
+	// Accumulate any errors
 	var errs *packer.MultiError
-	var warns []string
-
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(&b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(&b.config.ctx)...)
 
@@ -131,49 +115,16 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
-	if b.config.FromScratch {
-		if b.config.SourceAmi != "" || !b.config.SourceAmiFilter.Empty() {
-			warns = append(warns, "source_ami and source_ami_filter are unused when from_scratch is true")
-		}
-		if b.config.RootVolumeSize == 0 {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("root_volume_size is required with from_scratch."))
-		}
-		if len(b.config.PreMountCommands) == 0 {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("pre_mount_commands is required with from_scratch."))
-		}
-		if b.config.AMIVirtType == "" {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("ami_virtualization_type is required with from_scratch."))
-		}
-		if b.config.RootDeviceName == "" {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("root_device_name is required with from_scratch."))
-		}
-		if len(b.config.AMIMappings) == 0 {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("ami_block_device_mappings is required with from_scratch."))
-		}
-	} else {
-		if b.config.SourceAmi == "" && b.config.SourceAmiFilter.Empty() {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("source_ami or source_ami_filter is required."))
-		}
-		if len(b.config.AMIMappings) != 0 {
-			warns = append(warns, "ami_block_device_mappings are unused when from_scratch is false")
-		}
-		if b.config.RootDeviceName != "" {
-			warns = append(warns, "root_device_name is unused when from_scratch is false")
-		}
+	if b.config.SourceAmi == "" {
+		errs = packer.MultiErrorAppend(errs, errors.New("source_ami is required."))
 	}
 
 	if errs != nil && len(errs.Errors) > 0 {
-		return warns, errs
+		return nil, errs
 	}
 
 	log.Println(common.ScrubConfig(b.config, b.config.AccessKey, b.config.SecretKey))
-	return warns, nil
+	return nil, nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
@@ -181,10 +132,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 := session.New(config)
 	ec2conn := ec2.New(session)
 
 	wrappedCommand := func(command string) (string, error) {
@@ -208,21 +161,11 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			ForceDeregister: b.config.AMIForceDeregister,
 		},
 		&StepInstanceInfo{},
-	}
-
-	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,
-			},
-			&StepCheckRootDevice{},
-		)
-	}
-
-	steps = append(steps,
+		&awscommon.StepSourceAMIInfo{
+			SourceAmi:          b.config.SourceAmi,
+			EnhancedNetworking: b.config.AMIEnhancedNetworking,
+		},
+		&StepCheckRootDevice{},
 		&StepFlock{},
 		&StepPrepareDevice{},
 		&StepCreateVolume{
@@ -230,64 +173,48 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		},
 		&StepAttachVolume{},
 		&StepEarlyUnflock{},
-		&StepPreMountCommands{
-			Commands: b.config.PreMountCommands,
-		},
 		&StepMountDevice{
 			MountOptions:   b.config.MountOptions,
 			MountPartition: b.config.MountPartition,
 		},
-		&StepPostMountCommands{
-			Commands: b.config.PostMountCommands,
-		},
 		&StepMountExtra{},
 		&StepCopyFiles{},
 		&StepChrootProvision{},
 		&StepEarlyCleanup{},
 		&StepSnapshot{},
 		&awscommon.StepDeregisterAMI{
-			AccessConfig:        &b.config.AccessConfig,
-			ForceDeregister:     b.config.AMIForceDeregister,
-			ForceDeleteSnapshot: b.config.AMIForceDeleteSnapshot,
-			AMIName:             b.config.AMIName,
-			Regions:             b.config.AMIRegions,
+			ForceDeregister: b.config.AMIForceDeregister,
+			AMIName:         b.config.AMIName,
 		},
 		&StepRegisterAMI{
-			RootVolumeSize:           b.config.RootVolumeSize,
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
-		},
-		&awscommon.StepCreateEncryptedAMICopy{
-			KeyID:             b.config.AMIKmsKeyId,
-			EncryptBootVolume: b.config.AMIEncryptBootVolume,
-			Name:              b.config.AMIName,
-			AMIMappings:       b.config.AMIBlockDevices.AMIMappings,
+			RootVolumeSize: b.config.RootVolumeSize,
 		},
 		&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,
-			Users:          b.config.AMIUsers,
-			Groups:         b.config.AMIGroups,
-			ProductCodes:   b.config.AMIProductCodes,
-			SnapshotUsers:  b.config.SnapshotUsers,
-			SnapshotGroups: b.config.SnapshotGroups,
-			Ctx:            b.config.ctx,
+			Description:  b.config.AMIDescription,
+			Users:        b.config.AMIUsers,
+			Groups:       b.config.AMIGroups,
+			ProductCodes: b.config.AMIProductCodes,
 		},
 		&awscommon.StepCreateTags{
-			Tags:         b.config.AMITags,
-			SnapshotTags: b.config.SnapshotTags,
-			Ctx:          b.config.ctx,
+			Tags: b.config.AMITags,
 		},
-	)
+	}
 
 	// Run!
-	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
+	if b.config.PackerDebug {
+		b.runner = &multistep.DebugRunner{
+			Steps:   steps,
+			PauseFn: common.MultistepDebugFn(ui),
+		}
+	} else {
+		b.runner = &multistep.BasicRunner{Steps: steps}
+	}
+
 	b.runner.Run(state)
 
 	// If there was an error, return that

builder/amazon/chroot/builder_test.go

@@ -1,9 +1,8 @@
 package chroot
 
 import (
+	"github.com/mitchellh/packer/packer"
 	"testing"
-
-	"github.com/hashicorp/packer/packer"
 )
 
 func testConfig() map[string]interface{} {
@@ -72,7 +71,7 @@ func TestBuilderPrepare_ChrootMounts(t *testing.T) {
 	}
 
 	config["chroot_mounts"] = [][]string{
-		{"bad"},
+		[]string{"bad"},
 	}
 	warnings, err = b.Prepare(config)
 	if len(warnings) > 0 {
@@ -118,33 +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.")
-	}
-
-	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/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,7 +1,7 @@
 package chroot
 
 import (
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/packer"
 	"testing"
 )
 

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

@@ -1,37 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/post-processor/shell-local"
-	"github.com/hashicorp/packer/template/interpolate"
-)
-
-func RunLocalCommands(commands []string, wrappedCommand CommandWrapper, ctx interpolate.Context, ui packer.Ui) error {
-	for _, rawCmd := range commands {
-		intCmd, err := interpolate.Render(rawCmd, &ctx)
-		if err != nil {
-			return fmt.Errorf("Error interpolating: %s", err)
-		}
-
-		command, err := wrappedCommand(intCmd)
-		if err != nil {
-			return fmt.Errorf("Error wrapping command: %s", err)
-		}
-
-		ui.Say(fmt.Sprintf("Executing command: %s", 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)
-		}
-		if cmd.ExitStatus != 0 {
-			return fmt.Errorf(
-				"Received non-zero exit code %d from command: %s",
-				cmd.ExitStatus,
-				command)
-		}
-	}
-	return nil
-}

builder/amazon/chroot/step_attach_volume.go

@@ -7,9 +7,9 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"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

builder/amazon/chroot/step_check_root_device.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"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.

builder/amazon/chroot/step_chroot_provision.go

@@ -1,14 +1,14 @@
 package chroot
 
 import (
-	"log"
-
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
 )
 
 // StepChrootProvision provisions the instance within a chroot.
 type StepChrootProvision struct {
+	mounts []string
 }
 
 func (s *StepChrootProvision) Run(state multistep.StateBag) multistep.StepAction {

builder/amazon/chroot/step_copy_files.go

@@ -3,8 +3,8 @@ package chroot
 import (
 	"bytes"
 	"fmt"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 	"path/filepath"
 )

builder/amazon/chroot/step_create_volume.go

@@ -6,9 +6,9 @@ import (
 
 	"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/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,52 +22,40 @@ type StepCreateVolume struct {
 }
 
 func (s *StepCreateVolume) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
 	ec2conn := state.Get("ec2").(*ec2.EC2)
+	image := state.Get("source_image").(*ec2.Image)
 	instance := state.Get("instance").(*ec2.Instance)
 	ui := state.Get("ui").(packer.Ui)
 
-	var createVolume *ec2.CreateVolumeInput
-	if config.FromScratch {
-		createVolume = &ec2.CreateVolumeInput{
-			AvailabilityZone: instance.Placement.AvailabilityZone,
-			Size:             aws.Int64(s.RootVolumeSize),
-			VolumeType:       aws.String(ec2.VolumeTypeGp2),
-		}
-	} else {
-		// Determine the root device snapshot
-		image := state.Get("source_image").(*ec2.Image)
-		log.Printf("Searching for root device of the image (%s)", *image.RootDeviceName)
-		var rootDevice *ec2.BlockDeviceMapping
-		for _, device := range image.BlockDeviceMappings {
-			if *device.DeviceName == *image.RootDeviceName {
-				rootDevice = device
-				break
-			}
-		}
-
-		if rootDevice == nil {
-			err := fmt.Errorf("Couldn't find root device!")
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		ui.Say("Creating the root volume...")
-		vs := *rootDevice.Ebs.VolumeSize
-		if s.RootVolumeSize > *rootDevice.Ebs.VolumeSize {
-			vs = s.RootVolumeSize
-		}
-
-		createVolume = &ec2.CreateVolumeInput{
-			AvailabilityZone: instance.Placement.AvailabilityZone,
-			Size:             aws.Int64(vs),
-			SnapshotId:       rootDevice.Ebs.SnapshotId,
-			VolumeType:       rootDevice.Ebs.VolumeType,
-			Iops:             rootDevice.Ebs.Iops,
+	// Determine the root device snapshot
+	log.Printf("Searching for root device of the image (%s)", *image.RootDeviceName)
+	var rootDevice *ec2.BlockDeviceMapping
+	for _, device := range image.BlockDeviceMappings {
+		if *device.DeviceName == *image.RootDeviceName {
+			rootDevice = device
+			break
 		}
 	}
 
+	if rootDevice == nil {
+		err := fmt.Errorf("Couldn't find root device!")
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	ui.Say("Creating the root volume...")
+	vs := *rootDevice.Ebs.VolumeSize
+	if s.RootVolumeSize > *rootDevice.Ebs.VolumeSize {
+		vs = s.RootVolumeSize
+	}
+	createVolume := &ec2.CreateVolumeInput{
+		AvailabilityZone: instance.Placement.AvailabilityZone,
+		Size:             aws.Int64(vs),
+		SnapshotId:       rootDevice.Ebs.SnapshotId,
+		VolumeType:       rootDevice.Ebs.VolumeType,
+		Iops:             rootDevice.Ebs.Iops,
+	}
 	log.Printf("Create args: %+v", createVolume)
 
 	createVolumeResp, err := ec2conn.CreateVolume(createVolume)

builder/amazon/chroot/step_early_cleanup.go

@@ -2,8 +2,8 @@ package chroot
 
 import (
 	"fmt"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 )
 

builder/amazon/chroot/step_early_unflock.go

@@ -2,8 +2,8 @@ package chroot
 
 import (
 	"fmt"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 )
 

builder/amazon/chroot/step_flock.go

@@ -2,8 +2,8 @@ package chroot
 
 import (
 	"fmt"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
 	"path/filepath"

builder/amazon/chroot/step_instance_info.go

@@ -4,11 +4,10 @@ import (
 	"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/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.
@@ -20,11 +19,9 @@ func (s *StepInstanceInfo) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Get our own instance ID
 	ui.Say("Gathering information about this EC2 instance...")
-
-	sess := session.New()
-	ec2meta := ec2metadata.New(sess)
-	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.")
@@ -32,10 +29,12 @@ func (s *StepInstanceInfo) Run(state multistep.StateBag) multistep.StepAction {
 		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

@@ -9,9 +9,9 @@ import (
 	"strings"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"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 {
@@ -33,18 +33,10 @@ type StepMountDevice struct {
 func (s *StepMountDevice) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
+	image := state.Get("source_image").(*ec2.Image)
 	device := state.Get("device").(string)
 	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 
-	var virtualizationType string
-	if config.FromScratch {
-		virtualizationType = config.AMIVirtType
-	} else {
-		image := state.Get("source_image").(*ec2.Image)
-		virtualizationType = *image.VirtualizationType
-		log.Printf("Source image virtualization type is: %s", virtualizationType)
-	}
-
 	ctx := config.ctx
 	ctx.Data = &mountPathData{Device: filepath.Base(device)}
 	mountPath, err := interpolate.Render(config.MountPath, &ctx)
@@ -73,8 +65,9 @@ func (s *StepMountDevice) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionHalt
 	}
 
+	log.Printf("Source image virtualization type is: %s", *image.VirtualizationType)
 	deviceMount := device
-	if virtualizationType == "hvm" {
+	if *image.VirtualizationType == "hvm" {
 		deviceMount = fmt.Sprintf("%s%d", device, s.MountPartition)
 	}
 	state.Put("deviceMount", deviceMount)
@@ -82,7 +75,7 @@ func (s *StepMountDevice) Run(state multistep.StateBag) multistep.StepAction {
 	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 {

builder/amazon/chroot/step_mount_extra.go

@@ -3,8 +3,8 @@ package chroot
 import (
 	"bytes"
 	"fmt"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"os"
 	"os/exec"
 	"syscall"

builder/amazon/chroot/step_post_mount_commands.go

@@ -1,45 +0,0 @@
-package chroot
-
-import (
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type postMountCommandsData struct {
-	Device    string
-	MountPath string
-}
-
-// StepPostMountCommands allows running arbitrary commands after mounting the
-// device, but prior to the bind mount and copy steps.
-type StepPostMountCommands struct {
-	Commands []string
-}
-
-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)
-	ui := state.Get("ui").(packer.Ui)
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
-
-	if len(s.Commands) == 0 {
-		return multistep.ActionContinue
-	}
-
-	ctx := config.ctx
-	ctx.Data = &postMountCommandsData{
-		Device:    device,
-		MountPath: mountPath,
-	}
-
-	ui.Say("Running post-mount commands...")
-	if err := RunLocalCommands(s.Commands, wrappedCommand, ctx, ui); err != nil {
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	return multistep.ActionContinue
-}
-
-func (s *StepPostMountCommands) Cleanup(state multistep.StateBag) {}

builder/amazon/chroot/step_pre_mount_commands.go

@@ -1,39 +0,0 @@
-package chroot
-
-import (
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type preMountCommandsData struct {
-	Device string
-}
-
-// StepPreMountCommands sets up the a new block device when building from scratch
-type StepPreMountCommands struct {
-	Commands []string
-}
-
-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)
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
-
-	if len(s.Commands) == 0 {
-		return multistep.ActionContinue
-	}
-
-	ctx := config.ctx
-	ctx.Data = &preMountCommandsData{Device: device}
-
-	ui.Say("Running device setup commands...")
-	if err := RunLocalCommands(s.Commands, wrappedCommand, ctx, ui); err != nil {
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	return multistep.ActionContinue
-}
-
-func (s *StepPreMountCommands) Cleanup(state multistep.StateBag) {}

builder/amazon/chroot/step_prepare_device.go

@@ -2,15 +2,15 @@ package chroot
 
 import (
 	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
-
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
 )
 
 // StepPrepareDevice finds an available device and sets it.
 type StepPrepareDevice struct {
+	mounts []string
 }
 
 func (s *StepPrepareDevice) Run(state multistep.StateBag) multistep.StepAction {

builder/amazon/chroot/step_register_ami.go

@@ -5,53 +5,35 @@ import (
 
 	"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/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(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ec2conn := state.Get("ec2").(*ec2.EC2)
+	image := state.Get("source_image").(*ec2.Image)
 	snapshotId := state.Get("snapshot_id").(string)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Registering the AMI...")
-
-	var (
-		registerOpts   *ec2.RegisterImageInput
-		mappings       []*ec2.BlockDeviceMapping
-		image          *ec2.Image
-		rootDeviceName string
-	)
-
-	if config.FromScratch {
-		mappings = config.AMIBlockDevices.BuildAMIDevices()
-		rootDeviceName = config.RootDeviceName
-	} else {
-		image = state.Get("source_image").(*ec2.Image)
-		mappings = image.BlockDeviceMappings
-		rootDeviceName = *image.RootDeviceName
-	}
-
-	newMappings := make([]*ec2.BlockDeviceMapping, len(mappings))
-	for i, device := range mappings {
+	blockDevices := make([]*ec2.BlockDeviceMapping, len(image.BlockDeviceMappings))
+	for i, device := range image.BlockDeviceMappings {
 		newDevice := device
-		if *newDevice.DeviceName == rootDeviceName {
+		if *newDevice.DeviceName == *image.RootDeviceName {
 			if newDevice.Ebs != nil {
 				newDevice.Ebs.SnapshotId = aws.String(snapshotId)
 			} else {
 				newDevice.Ebs = &ec2.EbsBlockDevice{SnapshotId: aws.String(snapshotId)}
 			}
 
-			if config.FromScratch || s.RootVolumeSize > *newDevice.Ebs.VolumeSize {
+			if s.RootVolumeSize > *newDevice.Ebs.VolumeSize {
 				newDevice.Ebs.VolumeSize = aws.Int64(s.RootVolumeSize)
 			}
 		}
@@ -62,31 +44,15 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 			newDevice.Ebs.Encrypted = nil
 		}
 
-		newMappings[i] = newDevice
+		blockDevices[i] = newDevice
 	}
 
-	if config.FromScratch {
-		registerOpts = &ec2.RegisterImageInput{
-			Name:                &config.AMIName,
-			Architecture:        aws.String(ec2.ArchitectureValuesX8664),
-			RootDeviceName:      aws.String(rootDeviceName),
-			VirtualizationType:  aws.String(config.AMIVirtType),
-			BlockDeviceMappings: newMappings,
-		}
-	} else {
-		registerOpts = buildRegisterOpts(config, image, newMappings)
-	}
+	registerOpts := buildRegisterOpts(config, image, blockDevices)
 
-	if s.EnableAMISriovNetSupport {
-		// 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)
+	// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
+	if config.AMIEnhancedNetworking {
 		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)
-	}
 
 	registerResp, err := ec2conn.RegisterImage(registerOpts)
 	if err != nil {
@@ -122,12 +88,12 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 
 func (s *StepRegisterAMI) Cleanup(state multistep.StateBag) {}
 
-func buildRegisterOpts(config *Config, image *ec2.Image, mappings []*ec2.BlockDeviceMapping) *ec2.RegisterImageInput {
+func buildRegisterOpts(config *Config, image *ec2.Image, blockDevices []*ec2.BlockDeviceMapping) *ec2.RegisterImageInput {
 	registerOpts := &ec2.RegisterImageInput{
 		Name:                &config.AMIName,
 		Architecture:        image.Architecture,
 		RootDeviceName:      image.RootDeviceName,
-		BlockDeviceMappings: mappings,
+		BlockDeviceMappings: blockDevices,
 		VirtualizationType:  image.VirtualizationType,
 	}
 
@@ -139,5 +105,6 @@ func buildRegisterOpts(config *Config, image *ec2.Image, mappings []*ec2.BlockDe
 		registerOpts.KernelId = image.KernelId
 		registerOpts.RamdiskId = image.RamdiskId
 	}
+
 	return registerOpts
 }

builder/amazon/chroot/step_snapshot.go

@@ -6,9 +6,9 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"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.
@@ -71,12 +71,6 @@ func (s *StepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	state.Put("snapshot_id", s.snapshotId)
-
-	snapshots := map[string][]string{
-		*ec2conn.Config.Region: {s.snapshotId},
-	}
-	state.Put("snapshots", snapshots)
-
 	return multistep.ActionContinue
 }
 

builder/amazon/common/access_config.go

@@ -2,111 +2,88 @@ package common
 
 import (
 	"fmt"
-	"log"
-	"os"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"unicode"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"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/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"`
-	Token             string `mapstructure:"token"`
-	session           *session.Session
+	AccessKey   string `mapstructure:"access_key"`
+	SecretKey   string `mapstructure:"secret_key"`
+	RawRegion   string `mapstructure:"region"`
+	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
 
 	region, err := c.Region()
 	if err != nil {
 		return nil, err
 	}
-
+	config := aws.NewConfig().WithRegion(region).WithMaxRetries(11)
 	if c.ProfileName != "" {
-		if err := os.Setenv("AWS_PROFILE", c.ProfileName); err != nil {
-			log.Printf("Set env error: %s", err)
+		profile, err := NewFromProfile(c.ProfileName)
+		if err != nil {
+			return nil, err
 		}
-	}
-
-	config := aws.NewConfig().WithRegion(region).WithMaxRetries(11).WithCredentialsChainVerboseErrors(true)
-
-	if c.CustomEndpointEc2 != "" {
-		config = config.WithEndpoint(c.CustomEndpointEc2)
-	}
-
-	if c.AccessKey != "" {
-		creds := credentials.NewChainCredentials(
-			[]credentials.Provider{
-				&credentials.StaticProvider{
-					Value: credentials.Value{
-						AccessKeyID:     c.AccessKey,
-						SecretAccessKey: c.SecretKey,
-						SessionToken:    c.Token,
-					},
-				},
-			})
-		config = config.WithCredentials(creds)
-	}
-
-	opts := session.Options{
-		SharedConfigState: session.SharedConfigEnable,
-		Config:            *config,
-	}
-	if c.MFACode != "" {
-		opts.AssumeRoleTokenProvider = func() (string, error) {
-			return c.MFACode, nil
+		creds, err = profile.CredentialsFromProfile(config)
+		if err != nil {
+			return nil, err
 		}
+	} else {
+		sess := session.New(config)
+		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(sess),
+			},
+		})
 	}
-	c.session, err = session.NewSessionWithOptions(opts)
-	if err != nil {
-		return nil, err
-	}
-
-	return c.session, nil
+	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 {
-				return "", fmt.Errorf("Not a valid region: %s", c.RawRegion)
-			}
+		if valid := ValidateRegion(c.RawRegion); valid == false {
+			return "", fmt.Errorf("Not a valid region: %s", c.RawRegion)
 		}
 		return c.RawRegion, nil
 	}
 
-	sess := session.New()
-	ec2meta := ec2metadata.New(sess)
-	identity, err := ec2meta.GetInstanceIdentityDocument()
+	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 "", nil
+		return "", err
 	}
-	return identity.Region, nil
+
+	region := strings.TrimRightFunc(string(md), unicode.IsLetter)
+	return region, nil
 }
 
 func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error {
 	var errs []error
-	if c.RawRegion != "" && !c.SkipValidation {
-		if valid := ValidateRegion(c.RawRegion); !valid {
+	if c.RawRegion != "" {
+		if valid := ValidateRegion(c.RawRegion); valid == false {
 			errs = append(errs, fmt.Errorf("Unknown region: %s", c.RawRegion))
 		}
 	}
@@ -117,3 +94,24 @@ func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error {
 
 	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

@@ -24,17 +24,4 @@ func TestAccessConfigPrepare_Region(t *testing.T) {
 	if err := c.Prepare(nil); err != nil {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
-
-	c.RawRegion = "custom"
-	if err := c.Prepare(nil); err == nil {
-		t.Fatalf("should have err")
-	}
-
-	c.RawRegion = "custom"
-	c.SkipValidation = true
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-	c.SkipValidation = false
-
 }

builder/amazon/common/ami_config.go

@@ -3,39 +3,21 @@ package common
 import (
 	"fmt"
 
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 // AMIConfig is for common configuration related to creating AMIs.
 type AMIConfig struct {
-	AMIName                 string            `mapstructure:"ami_name"`
-	AMIDescription          string            `mapstructure:"ami_description"`
-	AMIVirtType             string            `mapstructure:"ami_virtualization_type"`
-	AMIUsers                []string          `mapstructure:"ami_users"`
-	AMIGroups               []string          `mapstructure:"ami_groups"`
-	AMIProductCodes         []string          `mapstructure:"ami_product_codes"`
-	AMIRegions              []string          `mapstructure:"ami_regions"`
-	AMISkipRegionValidation bool              `mapstructure:"skip_region_validation"`
-	AMITags                 map[string]string `mapstructure:"tags"`
-	AMIENASupport           bool              `mapstructure:"ena_support"`
-	AMISriovNetSupport      bool              `mapstructure:"sriov_support"`
-	AMIForceDeregister      bool              `mapstructure:"force_deregister"`
-	AMIForceDeleteSnapshot  bool              `mapstructure:"force_delete_snapshot"`
-	AMIEncryptBootVolume    bool              `mapstructure:"encrypt_boot"`
-	AMIKmsKeyId             string            `mapstructure:"kms_key_id"`
-	AMIRegionKMSKeyIDs      map[string]string `mapstructure:"region_kms_key_ids"`
-	SnapshotTags            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
+	AMIName               string            `mapstructure:"ami_name"`
+	AMIDescription        string            `mapstructure:"ami_description"`
+	AMIVirtType           string            `mapstructure:"ami_virtualization_type"`
+	AMIUsers              []string          `mapstructure:"ami_users"`
+	AMIGroups             []string          `mapstructure:"ami_groups"`
+	AMIProductCodes       []string          `mapstructure:"ami_product_codes"`
+	AMIRegions            []string          `mapstructure:"ami_regions"`
+	AMITags               map[string]string `mapstructure:"tags"`
+	AMIEnhancedNetworking bool              `mapstructure:"enhanced_networking"`
+	AMIForceDeregister    bool              `mapstructure:"force_deregister"`
 }
 
 func (c *AMIConfig) Prepare(ctx *interpolate.Context) []error {
@@ -57,20 +39,10 @@ func (c *AMIConfig) Prepare(ctx *interpolate.Context) []error {
 			// Mark that we saw the region
 			regionSet[region] = struct{}{}
 
-			if !c.AMISkipRegionValidation {
-				// Verify the region is real
-				if valid := ValidateRegion(region); !valid {
-					errs = append(errs, fmt.Errorf("Unknown region: %s", region))
-					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))
-				}
+			// Verify the region is real
+			if valid := ValidateRegion(region); valid == false {
+				errs = append(errs, fmt.Errorf("Unknown region: %s", region))
+				continue
 			}
 
 			regions = append(regions, region)
@@ -78,44 +50,6 @@ func (c *AMIConfig) Prepare(ctx *interpolate.Context) []error {
 
 		c.AMIRegions = regions
 	}
-	// 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.AMIUsers) > 0 && c.AMIEncryptBootVolume {
-		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(errs) > 0 {
 		return errs

builder/amazon/common/ami_config_test.go

@@ -49,123 +49,4 @@ func TestAMIConfigPrepare_regions(t *testing.T) {
 	if !reflect.DeepEqual(c.AMIRegions, expected) {
 		t.Fatalf("bad: %#v", c.AMIRegions)
 	}
-
-	c.AMIRegions = []string{"custom"}
-	c.AMISkipRegionValidation = true
-	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); 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); 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); 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); 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); 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); err == nil {
-		t.Fatal("should have error b/c theres a region in in ami_regions that isn't in the key map")
-	}
-}
-
-func TestAMIConfigPrepare_Share_EncryptedBoot(t *testing.T) {
-	c := testAMIConfig()
-	c.AMIUsers = []string{"testAccountID"}
-	c.AMIEncryptBootVolume = true
-
-	c.AMIKmsKeyId = ""
-	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); 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); 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); 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); err == nil {
-		t.Fatal("shouldn't be able to have an ami name with invalid characters")
-	}
-
-	c.AMIName = "fooBAR1()[] ./-'@_"
-	if err := c.Prepare(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); 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.
@@ -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{} {
@@ -73,25 +73,9 @@ func (a *Artifact) Destroy() error {
 			Credentials: a.Conn.Config.Credentials,
 			Region:      aws.String(region),
 		}
-		session, err := session.NewSession(regionConfig)
-		if err != nil {
-			return err
-		}
-		regionConn := ec2.New(session)
+		sess := session.New(regionConfig)
+		regionConn := ec2.New(sess)
 
-		// Get image metadata
-		imageResp, err := regionConn.DescribeImages(&ec2.DescribeImagesInput{
-			ImageIds: []*string{&imageId},
-		})
-		if err != nil {
-			errors = append(errors, err)
-		}
-		if len(imageResp.Images) == 0 {
-			err := fmt.Errorf("Error retrieving details for AMI (%s), no images found", imageId)
-			errors = append(errors, err)
-		}
-
-		// Deregister ami
 		input := &ec2.DeregisterImageInput{
 			ImageId: &imageId,
 		}

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

@@ -5,7 +5,7 @@ import (
 
 	"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
@@ -22,15 +22,7 @@ type BlockDevice struct {
 }
 
 type BlockDevices struct {
-	AMIBlockDevices    `mapstructure:",squash"`
-	LaunchBlockDevices `mapstructure:",squash"`
-}
-
-type AMIBlockDevices struct {
-	AMIMappings []BlockDevice `mapstructure:"ami_block_device_mappings"`
-}
-
-type LaunchBlockDevices struct {
+	AMIMappings    []BlockDevice `mapstructure:"ami_block_device_mappings"`
 	LaunchMappings []BlockDevice `mapstructure:"launch_block_device_mappings"`
 }
 
@@ -85,10 +77,10 @@ func (b *BlockDevices) Prepare(ctx *interpolate.Context) []error {
 	return nil
 }
 
-func (b *AMIBlockDevices) BuildAMIDevices() []*ec2.BlockDeviceMapping {
+func (b *BlockDevices) BuildAMIDevices() []*ec2.BlockDeviceMapping {
 	return buildBlockDevices(b.AMIMappings)
 }
 
-func (b *LaunchBlockDevices) BuildLaunchDevices() []*ec2.BlockDeviceMapping {
+func (b *BlockDevices) BuildLaunchDevices() []*ec2.BlockDeviceMapping {
 	return buildBlockDevices(b.LaunchMappings)
 }

builder/amazon/common/block_device_test.go

@@ -124,26 +124,22 @@ func TestBlockDevice(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-		amiBlockDevices := AMIBlockDevices{
-			AMIMappings: []BlockDevice{*tc.Config},
-		}
-
-		launchBlockDevices := LaunchBlockDevices{
+		blockDevices := BlockDevices{
+			AMIMappings:    []BlockDevice{*tc.Config},
 			LaunchMappings: []BlockDevice{*tc.Config},
 		}
 
 		expected := []*ec2.BlockDeviceMapping{tc.Result}
-
-		amiResults := amiBlockDevices.BuildAMIDevices()
-		if !reflect.DeepEqual(expected, amiResults) {
+		got := blockDevices.BuildAMIDevices()
+		if !reflect.DeepEqual(expected, got) {
 			t.Fatalf("Bad block device, \nexpected: %#v\n\ngot: %#v",
-				expected, amiResults)
+				expected, got)
 		}
 
-		launchResults := launchBlockDevices.BuildLaunchDevices()
-		if !reflect.DeepEqual(expected, launchResults) {
+		if !reflect.DeepEqual(expected, blockDevices.BuildLaunchDevices()) {
 			t.Fatalf("Bad block device, \nexpected: %#v\n\ngot: %#v",
-				expected, launchResults)
+				expected,
+				blockDevices.BuildLaunchDevices())
 		}
 	}
 }

builder/amazon/common/cli_config.go

@@ -0,0 +1,155 @@
+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)
+	svc := sts.New(session.New(), srcCfg)
+	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,6 +0,0 @@
-package common
-
-type BuildInfoTemplate struct {
-	SourceAMI   string
-	BuildRegion string
-}

builder/amazon/common/regions.go

@@ -1,25 +1,19 @@
 package common
 
-// aws ec2 describe-regions --query 'Regions[].{Name:RegionName}' --output text | sed 's/\(.*\)/"\1",/' | sort
 func listEC2Regions() []string {
 	return []string{
 		"ap-northeast-1",
 		"ap-northeast-2",
-		"ap-south-1",
 		"ap-southeast-1",
 		"ap-southeast-2",
-		"ca-central-1",
+		"cn-north-1",
 		"eu-central-1",
 		"eu-west-1",
-		"eu-west-2",
 		"sa-east-1",
 		"us-east-1",
-		"us-east-2",
+		"us-gov-west-1",
 		"us-west-1",
 		"us-west-2",
-		// not part of autogenerated list
-		"us-gov-west-1",
-		"cn-north-1",
 	}
 }
 

builder/amazon/common/run_config.go

@@ -3,52 +3,34 @@ package common
 import (
 	"errors"
 	"fmt"
-	"net"
 	"os"
-	"regexp"
 	"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)$")
-
-type AmiFilterOptions struct {
-	Filters    map[*string]*string
-	Owners     []*string
-	MostRecent bool `mapstructure:"most_recent"`
-}
-
-func (d *AmiFilterOptions) Empty() bool {
-	return len(d.Owners) == 0 && len(d.Filters) == 0
-}
-
 // RunConfig contains configuration for running an instance from a source
 // AMI and details on how to access that launched image.
 type RunConfig struct {
-	AssociatePublicIpAddress          bool              `mapstructure:"associate_public_ip_address"`
-	AvailabilityZone                  string            `mapstructure:"availability_zone"`
-	EbsOptimized                      bool              `mapstructure:"ebs_optimized"`
-	IamInstanceProfile                string            `mapstructure:"iam_instance_profile"`
-	InstanceType                      string            `mapstructure:"instance_type"`
-	RunTags                           map[string]string `mapstructure:"run_tags"`
-	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"`
-	TemporarySGSourceCidr             string            `mapstructure:"temporary_security_group_source_cidr"`
-	SubnetId                          string            `mapstructure:"subnet_id"`
-	TemporaryKeyPairName              string            `mapstructure:"temporary_key_pair_name"`
-	UserData                          string            `mapstructure:"user_data"`
-	UserDataFile                      string            `mapstructure:"user_data_file"`
-	WindowsPasswordTimeout            time.Duration     `mapstructure:"windows_password_timeout"`
-	VpcId                             string            `mapstructure:"vpc_id"`
-	InstanceInitiatedShutdownBehavior string            `mapstructure:"shutdown_behavior"`
+	AssociatePublicIpAddress bool              `mapstructure:"associate_public_ip_address"`
+	AvailabilityZone         string            `mapstructure:"availability_zone"`
+	EbsOptimized             bool              `mapstructure:"ebs_optimized"`
+	IamInstanceProfile       string            `mapstructure:"iam_instance_profile"`
+	InstanceType             string            `mapstructure:"instance_type"`
+	RunTags                  map[string]string `mapstructure:"run_tags"`
+	SourceAmi                string            `mapstructure:"source_ami"`
+	SpotPrice                string            `mapstructure:"spot_price"`
+	SpotPriceAutoProduct     string            `mapstructure:"spot_price_auto_product"`
+	SecurityGroupId          string            `mapstructure:"security_group_id"`
+	SecurityGroupIds         []string          `mapstructure:"security_group_ids"`
+	SubnetId                 string            `mapstructure:"subnet_id"`
+	TemporaryKeyPairName     string            `mapstructure:"temporary_key_pair_name"`
+	UserData                 string            `mapstructure:"user_data"`
+	UserDataFile             string            `mapstructure:"user_data_file"`
+	WindowsPasswordTimeout   time.Duration     `mapstructure:"windows_password_timeout"`
+	VpcId                    string            `mapstructure:"vpc_id"`
 
 	// Communicator settings
 	Comm           communicator.Config `mapstructure:",squash"`
@@ -57,36 +39,20 @@ type RunConfig struct {
 }
 
 func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
-	// If we are not given an explicit ssh_keypair_name or
-	// ssh_private_key_file, then create a temporary one, but only if the
-	// temporary_key_pair_name has not been provided and we are not using
-	// ssh_password.
-	if c.SSHKeyPairName == "" && c.TemporaryKeyPairName == "" &&
-		c.Comm.SSHPrivateKey == "" && c.Comm.SSHPassword == "" {
-
-		c.TemporaryKeyPairName = fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID())
+	// if we are not given an explicit keypairname, create a temporary one
+	if c.SSHKeyPairName == "" {
+		c.TemporaryKeyPairName = fmt.Sprintf(
+			"packer %s", uuid.TimeOrderedUUID())
 	}
 
 	if c.WindowsPasswordTimeout == 0 {
-		c.WindowsPasswordTimeout = 20 * time.Minute
-	}
-
-	if c.RunTags == nil {
-		c.RunTags = make(map[string]string)
+		c.WindowsPasswordTimeout = 10 * time.Minute
 	}
 
 	// Validation
 	errs := c.Comm.Prepare(ctx)
-	if c.SSHKeyPairName != "" {
-		if c.Comm.Type == "winrm" && c.Comm.WinRMPassword == "" && c.Comm.SSHPrivateKey == "" {
-			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, 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, errors.New("A source_ami or source_ami_filter must be specified"))
+	if c.SourceAmi == "" {
+		errs = append(errs, errors.New("A source_ami must be specified"))
 	}
 
 	if c.InstanceType == "" {
@@ -117,19 +83,5 @@ 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."))
-	}
-
 	return errs
 }

builder/amazon/common/run_config_test.go

@@ -3,10 +3,9 @@ package common
 import (
 	"io/ioutil"
 	"os"
-	"regexp"
 	"testing"
 
-	"github.com/hashicorp/packer/helper/communicator"
+	"github.com/mitchellh/packer/helper/communicator"
 )
 
 func init() {
@@ -29,13 +28,6 @@ func testConfig() *RunConfig {
 	}
 }
 
-func testConfigFilter() *RunConfig {
-	config := testConfig()
-	config.SourceAmi = ""
-	config.SourceAmiFilter = AmiFilterOptions{}
-	return config
-}
-
 func TestRunConfigPrepare(t *testing.T) {
 	c := testConfig()
 	err := c.Prepare(nil)
@@ -60,25 +52,6 @@ func TestRunConfigPrepare_SourceAmi(t *testing.T) {
 	}
 }
 
-func TestRunConfigPrepare_SourceAmiFilterBlank(t *testing.T) {
-	c := testConfigFilter()
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_SourceAmiFilterGood(t *testing.T) {
-	c := testConfigFilter()
-	owner := "123"
-	filter_key := "name"
-	filter_value := "foo"
-	goodFilter := AmiFilterOptions{Owners: []*string{&owner}, Filters: map[*string]*string{&filter_key: &filter_value}}
-	c.SourceAmiFilter = goodFilter
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
 func TestRunConfigPrepare_SpotAuto(t *testing.T) {
 	c := testConfig()
 	c.SpotPrice = "auto"
@@ -113,6 +86,14 @@ func TestRunConfigPrepare_SSHPort(t *testing.T) {
 	}
 }
 
+func TestRunConfigPrepare_SSHUsername(t *testing.T) {
+	c := testConfig()
+	c.Comm.SSHUsername = ""
+	if err := c.Prepare(nil); len(err) != 1 {
+		t.Fatalf("err: %s", err)
+	}
+}
+
 func TestRunConfigPrepare_UserData(t *testing.T) {
 	c := testConfig()
 	tf, err := ioutil.TempFile("", "packer")
@@ -159,21 +140,6 @@ func TestRunConfigPrepare_TemporaryKeyPairName(t *testing.T) {
 	}
 
 	if c.TemporaryKeyPairName == "" {
-		t.Fatal("keypair name is empty")
-	}
-
-	// Match prefix and UUID, e.g. "packer_5790d491-a0b8-c84c-c9d2-2aea55086550".
-	r := regexp.MustCompile(`\Apacker_(?:(?i)[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}?)\z`)
-	if !r.MatchString(c.TemporaryKeyPairName) {
-		t.Fatal("keypair name is not valid")
-	}
-
-	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")
+		t.Fatal("keypair empty")
 	}
 }

builder/amazon/common/ssh.go

@@ -3,43 +3,26 @@ package common
 import (
 	"errors"
 	"fmt"
-	"net"
-	"os"
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	packerssh "github.com/hashicorp/packer/communicator/ssh"
 	"github.com/mitchellh/multistep"
 	"golang.org/x/crypto/ssh"
-	"golang.org/x/crypto/ssh/agent"
-)
-
-type ec2Describer interface {
-	DescribeInstances(*ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error)
-}
-
-var (
-	// modified in tests
-	sshHostSleepDuration = time.Second
 )
 
 // 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, private bool) func(multistep.StateBag) (string, error) {
+func SSHHost(e *ec2.EC2, 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++ {
+		for j := 0; j < 2; j++ {
 			var host string
 			i := state.Get("instance").(*ec2.Instance)
 			if i.VpcId != nil && *i.VpcId != "" {
 				if i.PublicIpAddress != nil && *i.PublicIpAddress != "" && !private {
 					host = *i.PublicIpAddress
-				} else if i.PrivateIpAddress != nil && *i.PrivateIpAddress != "" {
+				} else {
 					host = *i.PrivateIpAddress
 				}
-			} else if private && i.PrivateIpAddress != nil && *i.PrivateIpAddress != "" {
-				host = *i.PrivateIpAddress
 			} else if i.PublicDnsName != nil && *i.PublicDnsName != "" {
 				host = *i.PublicDnsName
 			}
@@ -59,8 +42,8 @@ func SSHHost(e ec2Describer, private bool) func(multistep.StateBag) (string, err
 				return "", fmt.Errorf("instance not found: %s", *i.InstanceId)
 			}
 
-			state.Put("instance", r.Reservations[0].Instances[0])
-			time.Sleep(sshHostSleepDuration)
+			state.Put("instance", &r.Reservations[0].Instances[0])
+			time.Sleep(1 * time.Second)
 		}
 
 		return "", errors.New("couldn't determine IP address for instance")
@@ -68,54 +51,22 @@ func SSHHost(e ec2Describer, private bool) func(multistep.StateBag) (string, err
 }
 
 // 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) {
+// config for connecting to the instance created over SSH using the generated
+// private key.
+func SSHConfig(username 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")
-			}
+		privateKey := state.Get("privateKey").(string)
 
-			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
+		signer, err := ssh.ParsePrivateKey([]byte(privateKey))
+		if err != nil {
+			return nil, fmt.Errorf("Error setting up SSH config: %s", err)
 		}
 
-		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,
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
-				Auth: []ssh.AuthMethod{
-					ssh.Password(password),
-					ssh.KeyboardInteractive(
-						packerssh.PasswordKeyboardInteractive(password)),
-				}}, nil
-		}
+		return &ssh.ClientConfig{
+			User: username,
+			Auth: []ssh.AuthMethod{
+				ssh.PublicKeys(signer),
+			},
+		}, nil
 	}
 }

builder/amazon/common/ssh_test.go

@@ -1,118 +0,0 @@
-package common
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/mitchellh/multistep"
-)
-
-const (
-	privateIP = "10.0.0.1"
-	publicIP  = "192.168.1.1"
-	publicDNS = "public.dns.test"
-)
-
-func TestSSHHost(t *testing.T) {
-	origSshHostSleepDuration := sshHostSleepDuration
-	defer func() { sshHostSleepDuration = origSshHostSleepDuration }()
-	sshHostSleepDuration = 0
-
-	var cases = []struct {
-		allowTries int
-		vpcId      string
-		private    bool
-
-		ok       bool
-		wantHost string
-	}{
-		{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.private, c.ok, c.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,
-		publicDNS:  publicDNS,
-	}
-
-	f := SSHHost(e, private)
-	st := &multistep.BasicStateBag{}
-	st.Put("instance", &ec2.Instance{
-		InstanceId: aws.String("instance-id"),
-	})
-
-	host, err := f(st)
-
-	if e.tries > allowTries {
-		t.Fatalf("got %d ec2 DescribeInstances tries, want %d", e.tries, allowTries)
-	}
-
-	switch {
-	case ok && err != nil:
-		t.Fatalf("expected no error, got %+v", err)
-	case !ok && err == nil:
-		t.Fatalf("expected error, got none and host %s", host)
-	}
-
-	if host != wantHost {
-		t.Fatalf("got host %s, want %s", host, wantHost)
-	}
-}
-
-type fakeEC2Describer struct {
-	allowTries int
-	tries      int
-
-	vpcId                          string
-	privateIP, publicIP, publicDNS string
-}
-
-func (d *fakeEC2Describer) DescribeInstances(in *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) {
-	d.tries++
-
-	instance := &ec2.Instance{
-		InstanceId: aws.String("instance-id"),
-	}
-
-	if d.vpcId != "" {
-		instance.VpcId = aws.String(d.vpcId)
-	}
-
-	if d.tries >= d.allowTries {
-		instance.PublicIpAddress = aws.String(d.publicIP)
-		instance.PrivateIpAddress = aws.String(d.privateIP)
-		instance.PublicDnsName = aws.String(d.publicDNS)
-	}
-
-	out := &ec2.DescribeInstancesOutput{
-		Reservations: []*ec2.Reservation{
-			{
-				Instances: []*ec2.Instance{instance},
-			},
-		},
-	}
-
-	return out, nil
-}

builder/amazon/common/state.go

@@ -162,8 +162,8 @@ func ImportImageRefreshFunc(conn *ec2.EC2, importTaskId string) StateRefreshFunc
 func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
 	log.Printf("Waiting for state to become: %s", conf.Target)
 
-	sleepSeconds := SleepSeconds()
-	maxTicks := TimeoutSeconds()/sleepSeconds + 1
+	sleepSeconds := 2
+	maxTicks := int(TimeoutSeconds()/sleepSeconds) + 1
 	notfoundTick := 0
 
 	for {
@@ -239,24 +239,3 @@ func TimeoutSeconds() (seconds int) {
 	log.Printf("Allowing %ds to complete (change with AWS_TIMEOUT_SECONDS)", seconds)
 	return seconds
 }
-
-// Returns 2 seconds by default
-// AWS async operations sometimes takes long times, if there are multiple parallel builds,
-// polling at 2 second frequency will exceed the request limit. Allow 2 seconds to be
-// overwritten with AWS_POLL_DELAY_SECONDS
-func SleepSeconds() (seconds int) {
-	seconds = 2
-
-	override := os.Getenv("AWS_POLL_DELAY_SECONDS")
-	if override != "" {
-		n, err := strconv.Atoi(override)
-		if err != nil {
-			log.Printf("Invalid sleep seconds '%s', using default", override)
-		} else {
-			seconds = n
-		}
-	}
-
-	log.Printf("Using %ds as polling delay (change with AWS_POLL_DELAY_SECONDS)", seconds)
-	return seconds
-}

builder/amazon/common/step_ami_region_copy.go

@@ -2,28 +2,27 @@ package common
 
 import (
 	"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/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(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 	amis := state.Get("amis").(map[string]string)
-	snapshots := state.Get("snapshots").(map[string][]string)
 	ami := amis[*ec2conn.Config.Region]
 
 	if len(s.Regions) == 0 {
@@ -34,7 +33,6 @@ func (s *StepAMIRegionCopy) Run(state multistep.StateBag) multistep.StepAction {
 
 	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 {
@@ -46,17 +44,13 @@ func (s *StepAMIRegionCopy) Run(state multistep.StateBag) multistep.StepAction {
 		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, err := amiRegionCopy(state, s.AccessConfig, s.Name, ami, region, *ec2conn.Config.Region)
+
 			lock.Lock()
 			defer lock.Unlock()
 			amis[region] = id
-			snapshots[region] = snapshotIds
 			if err != nil {
 				errs = packer.MultiErrorAppend(errs, err)
 			}
@@ -83,35 +77,28 @@ 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.
+// returns the resulting ID or error.
 func amiRegionCopy(state multistep.StateBag, config *AccessConfig, name string, imageId string,
-	target string, source string, keyID string) (string, []string, error) {
-	snapshotIds := []string{}
-	isEncrypted := false
+	target string, source string) (string, error) {
 
 	// 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
+		return "", err
 	}
-	// if we've provided a map of key ids to regions, use those keys.
-	if len(keyID) > 0 {
-		isEncrypted = true
-	}
-	regionconn := ec2.New(session.Copy(&aws.Config{
-		Region: aws.String(target)},
-	))
+	awsConfig.Region = aws.String(target)
+
+	sess := session.New(awsConfig)
+	regionconn := ec2.New(sess)
 
 	resp, err := regionconn.CopyImage(&ec2.CopyImageInput{
 		SourceRegion:  &source,
 		SourceImageId: &imageId,
 		Name:          &name,
-		Encrypted:     aws.Bool(isEncrypted),
-		KmsKeyId:      aws.String(keyID),
 	})
 
 	if err != nil {
-		return "", snapshotIds, fmt.Errorf("Error Copying AMI (%s) to region (%s): %s",
+		return "", fmt.Errorf("Error Copying AMI (%s) to region (%s): %s",
 			imageId, target, err)
 	}
 
@@ -123,22 +110,9 @@ func amiRegionCopy(state multistep.StateBag, config *AccessConfig, name string,
 	}
 
 	if _, err := WaitForState(&stateChange); err != nil {
-		return "", snapshotIds, fmt.Errorf("Error waiting for AMI (%s) in region (%s): %s",
+		return "", fmt.Errorf("Error waiting for AMI (%s) in region (%s): %s",
 			*resp.ImageId, target, err)
 	}
 
-	// Getting snapshot IDs out of the copied AMI
-	describeImageResp, err := regionconn.DescribeImages(&ec2.DescribeImagesInput{ImageIds: []*string{resp.ImageId}})
-	if err != nil {
-		return "", snapshotIds, fmt.Errorf("Error describing copied AMI (%s) in region (%s): %s",
-			imageId, target, err)
-	}
-
-	for _, blockDeviceMapping := range describeImageResp.Images[0].BlockDeviceMappings {
-		if blockDeviceMapping.Ebs != nil && blockDeviceMapping.Ebs.SnapshotId != nil {
-			snapshotIds = append(snapshotIds, *blockDeviceMapping.Ebs.SnapshotId)
-		}
-	}
-
-	return *resp.ImageId, snapshotIds, nil
+	return *resp.ImageId, nil
 }

builder/amazon/common/step_create_tags.go

@@ -4,19 +4,14 @@ import (
 	"fmt"
 
 	"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/packer"
-	"github.com/hashicorp/packer/template/interpolate"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepCreateTags struct {
-	Tags         map[string]string
-	SnapshotTags map[string]string
-	Ctx          interpolate.Context
+	Tags map[string]string
 }
 
 func (s *StepCreateTags) Run(state multistep.StateBag) multistep.StepAction {
@@ -24,123 +19,69 @@ func (s *StepCreateTags) Run(state multistep.StateBag) multistep.StepAction {
 	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 = ""
-	}
+	if len(s.Tags) > 0 {
+		for region, ami := range amis {
+			ui.Say(fmt.Sprintf("Adding tags to AMI (%s)...", ami))
 
-	if len(s.Tags) == 0 && len(s.SnapshotTags) == 0 {
-		return multistep.ActionContinue
-	}
-
-	// Adds tags to AMIs and snapshots
-	for region, ami := range amis {
-		ui.Say(fmt.Sprintf("Adding tags to AMI (%s)...", ami))
-
-		// 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{
-			ImageIds: resourceIds,
-		})
-
-		if err != nil {
-			err := fmt.Errorf("Error retrieving details for AMI (%s): %s", ami, err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		if len(imageResp.Images) == 0 {
-			err := fmt.Errorf("Error retrieving details for AMI (%s), no images found", ami)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		image := imageResp.Images[0]
-		snapshotIds := []*string{}
-
-		// Add only those with a Snapshot ID, i.e. not Ephemeral
-		for _, device := range image.BlockDeviceMappings {
-			if device.Ebs != nil && device.Ebs.SnapshotId != nil {
-				ui.Say(fmt.Sprintf("Tagging snapshot: %s", *device.Ebs.SnapshotId))
-				resourceIds = append(resourceIds, device.Ebs.SnapshotId)
-				snapshotIds = append(snapshotIds, device.Ebs.SnapshotId)
-			}
-		}
-
-		// Convert tags to ec2.Tag format
-		ui.Say("Creating AMI tags")
-		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
-		}
-		ReportTags(ui, amiTags)
-
-		ui.Say("Creating snapshot tags")
-		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
-		}
-		ReportTags(ui, snapshotTags)
-
-		// Retry creating tags for about 2.5 minutes
-		err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
-			// Tag images and snapshots
-			_, err := regionconn.CreateTags(&ec2.CreateTagsInput{
-				Resources: resourceIds,
-				Tags:      amiTags,
-			})
-			if awsErr, ok := err.(awserr.Error); ok {
-				if awsErr.Code() == "InvalidAMIID.NotFound" ||
-					awsErr.Code() == "InvalidSnapshot.NotFound" {
-					return false, nil
-				}
-			}
-
-			// Override tags on snapshots
-			if len(snapshotTags) > 0 {
-				_, err = regionconn.CreateTags(&ec2.CreateTagsInput{
-					Resources: snapshotIds,
-					Tags:      snapshotTags,
+			var ec2Tags []*ec2.Tag
+			for key, value := range s.Tags {
+				ui.Message(fmt.Sprintf("Adding tag: \"%s\": \"%s\"", key, value))
+				ec2Tags = append(ec2Tags, &ec2.Tag{
+					Key:   aws.String(key),
+					Value: aws.String(value),
 				})
 			}
-			if err == nil {
-				return true, nil
+
+			// Declare list of resources to tag
+			resourceIds := []*string{&ami}
+			awsConfig := aws.Config{
+				Credentials: ec2conn.Config.Credentials,
+				Region:      aws.String(region),
 			}
-			if awsErr, ok := err.(awserr.Error); ok {
-				if awsErr.Code() == "InvalidSnapshot.NotFound" {
-					return false, nil
+			session := session.New(&awsConfig)
+
+			regionconn := ec2.New(session)
+
+			// Retrieve image list for given AMI
+			imageResp, err := regionconn.DescribeImages(&ec2.DescribeImagesInput{
+				ImageIds: resourceIds,
+			})
+
+			if err != nil {
+				err := fmt.Errorf("Error retrieving details for AMI (%s): %s", ami, err)
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
+
+			if len(imageResp.Images) == 0 {
+				err := fmt.Errorf("Error retrieving details for AMI (%s), no images found", ami)
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
+
+			image := imageResp.Images[0]
+
+			// Add only those with a Snapshot ID, i.e. not Ephemeral
+			for _, device := range image.BlockDeviceMappings {
+				if device.Ebs != nil && device.Ebs.SnapshotId != nil {
+					ui.Say(fmt.Sprintf("Tagging snapshot: %s", *device.Ebs.SnapshotId))
+					resourceIds = append(resourceIds, device.Ebs.SnapshotId)
 				}
 			}
-			return true, err
-		})
 
-		if err != nil {
-			err := fmt.Errorf("Error adding tags to Resources (%#v): %s", resourceIds, err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
+			_, err = regionconn.CreateTags(&ec2.CreateTagsInput{
+				Resources: resourceIds,
+				Tags:      ec2Tags,
+			})
+
+			if err != nil {
+				err := fmt.Errorf("Error adding tags to Resources (%#v): %s", resourceIds, err)
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
 		}
 	}
 
@@ -150,36 +91,3 @@ func (s *StepCreateTags) Run(state multistep.StateBag) multistep.StepAction {
 func (s *StepCreateTags) Cleanup(state multistep.StateBag) {
 	// No cleanup...
 }
-
-func ReportTags(ui packer.Ui, tags []*ec2.Tag) {
-	for _, tag := range tags {
-		ui.Message(fmt.Sprintf("Adding tag: \"%s\": \"%s\"",
-			aws.StringValue(tag.Key), aws.StringValue(tag.Value)))
-	}
-}
-
-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,
-		}
-		interpolatedKey, err := interpolate.Render(key, &ctx)
-		if err != nil {
-			return ec2Tags, fmt.Errorf("Error processing tag: %s:%s - %s", key, value, err)
-		}
-		interpolatedValue, err := interpolate.Render(value, &ctx)
-		if err != nil {
-			return ec2Tags, fmt.Errorf("Error processing tag: %s:%s - %s", key, value, err)
-		}
-
-		ec2Tags = append(ec2Tags, &ec2.Tag{
-			Key:   aws.String(interpolatedKey),
-			Value: aws.String(interpolatedValue),
-		})
-	}
-
-	return ec2Tags, nil
-}

builder/amazon/common/step_deregister_ami.go

@@ -5,84 +5,47 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"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
+	ForceDeregister bool
+	AMIName         string
 }
 
 func (s *StepDeregisterAMI) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
-	regions := s.Regions
-	if len(regions) == 0 {
-		regions = append(regions, s.AccessConfig.RawRegion)
-	}
 
-	// Check for force deregister
+	// check for force deregister
 	if s.ForceDeregister {
-		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
-			}
+		resp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{
+			Filters: []*ec2.Filter{&ec2.Filter{
+				Name:   aws.String("name"),
+				Values: []*string{aws.String(s.AMIName)},
+			}}})
 
-			regionconn := ec2.New(session.Copy(&aws.Config{
-				Region: aws.String(region)},
-			))
+		if err != nil {
+			err := fmt.Errorf("Error creating AMI: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
 
-			resp, err := regionconn.DescribeImages(&ec2.DescribeImagesInput{
-				Filters: []*ec2.Filter{{
-					Name:   aws.String("name"),
-					Values: []*string{aws.String(s.AMIName)},
-				}}})
+		// deregister image(s) by that name
+		for _, i := range resp.Images {
+			_, err := ec2conn.DeregisterImage(&ec2.DeregisterImageInput{
+				ImageId: i.ImageId,
+			})
 
 			if err != nil {
-				err := fmt.Errorf("Error describing AMI: %s", err)
+				err := fmt.Errorf("Error deregistering existing AMI: %s", err)
 				state.Put("error", err)
 				ui.Error(err.Error())
 				return multistep.ActionHalt
 			}
-
-			// Deregister image(s) by name
-			for _, i := range resp.Images {
-				_, err := regionconn.DeregisterImage(&ec2.DeregisterImageInput{
-					ImageId: i.ImageId,
-				})
-
-				if err != nil {
-					err := fmt.Errorf("Error deregistering existing AMI: %s", err)
-					state.Put("error", err)
-					ui.Error(err.Error())
-					return multistep.ActionHalt
-				}
-				ui.Say(fmt.Sprintf("Deregistered AMI %s, id: %s", s.AMIName, *i.ImageId))
-
-				// 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{
-								SnapshotId: b.Ebs.SnapshotId,
-							})
-
-							if err != nil {
-								err := fmt.Errorf("Error deleting existing snapshot: %s", err)
-								state.Put("error", err)
-								ui.Error(err.Error())
-								return multistep.ActionHalt
-							}
-							ui.Say(fmt.Sprintf("Deleted snapshot: %s", *b.Ebs.SnapshotId))
-						}
-					}
-				}
-			}
+			ui.Say(fmt.Sprintf("Deregistered AMI %s, id: %s", s.AMIName, *i.ImageId))
 		}
 	}
 

builder/amazon/common/step_encrypted_ami.go

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

builder/amazon/common/step_get_password.go

@@ -11,9 +11,9 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/helper/communicator"
-	"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

builder/amazon/common/step_key_pair.go

@@ -7,26 +7,22 @@ import (
 	"runtime"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepKeyPair struct {
 	Debug                bool
-	SSHAgentAuth         bool
 	DebugKeyPath         string
 	TemporaryKeyPairName string
 	KeyPairName          string
 	PrivateKeyFile       string
 
-	doCleanup bool
+	keyName string
 }
 
 func (s *StepKeyPair) Run(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(
@@ -40,24 +36,8 @@ func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionContinue
 	}
 
-	if s.SSHAgentAuth && s.KeyPairName == "" {
-		ui.Say("Using SSH Agent with key pair in Source AMI")
-		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
-	}
-
 	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say(fmt.Sprintf("Creating temporary keypair: %s", s.TemporaryKeyPairName))
 	keyResp, err := ec2conn.CreateKeyPair(&ec2.CreateKeyPairInput{
@@ -67,10 +47,11 @@ func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction {
 		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
@@ -103,7 +84,10 @@ func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction {
 }
 
 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 != "" {
 		return
 	}
 
@@ -112,10 +96,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

@@ -6,19 +6,15 @@ 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/hashicorp/packer/template/interpolate"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepModifyAMIAttributes struct {
-	Users          []string
-	Groups         []string
-	SnapshotUsers  []string
-	SnapshotGroups []string
-	ProductCodes   []string
-	Description    string
-	Ctx            interpolate.Context
+	Users        []string
+	Groups       []string
+	ProductCodes []string
+	Description  string
 }
 
 func (s *StepModifyAMIAttributes) Run(state multistep.StateBag) multistep.StepAction {
@@ -26,115 +22,57 @@ func (s *StepModifyAMIAttributes) Run(state multistep.StateBag) multistep.StepAc
 	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.
 	valid := false
 	valid = valid || s.Description != ""
 	valid = valid || (s.Users != nil && len(s.Users) > 0)
 	valid = valid || (s.Groups != nil && len(s.Groups) > 0)
 	valid = valid || (s.ProductCodes != nil && len(s.ProductCodes) > 0)
-	valid = valid || (s.SnapshotUsers != nil && len(s.SnapshotUsers) > 0)
-	valid = valid || (s.SnapshotGroups != nil && len(s.SnapshotGroups) > 0)
 
 	if !valid {
 		return multistep.ActionContinue
 	}
 
-	var err error
-	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)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Construct the modify image and snapshot attribute requests we're going
-	// to make. We need to make each separately since the EC2 API only allows
-	// changing one type at a kind currently.
+	// Construct the modify image attribute requests we're going to make.
+	// We need to make each separately since the EC2 API only allows changing
+	// one type at a kind currently.
 	options := make(map[string]*ec2.ModifyImageAttributeInput)
 	if s.Description != "" {
 		options["description"] = &ec2.ModifyImageAttributeInput{
 			Description: &ec2.AttributeValue{Value: &s.Description},
 		}
 	}
-	snapshotOptions := make(map[string]*ec2.ModifySnapshotAttributeInput)
 
 	if len(s.Groups) > 0 {
 		groups := make([]*string, len(s.Groups))
-		addsImage := make([]*ec2.LaunchPermission, len(s.Groups))
+		adds := make([]*ec2.LaunchPermission, len(s.Groups))
 		addGroups := &ec2.ModifyImageAttributeInput{
 			LaunchPermission: &ec2.LaunchPermissionModifications{},
 		}
 
 		for i, g := range s.Groups {
 			groups[i] = aws.String(g)
-			addsImage[i] = &ec2.LaunchPermission{
+			adds[i] = &ec2.LaunchPermission{
 				Group: aws.String(g),
 			}
 		}
-
 		addGroups.UserGroups = groups
-		addGroups.LaunchPermission.Add = addsImage
+		addGroups.LaunchPermission.Add = adds
+
 		options["groups"] = addGroups
 	}
 
-	if len(s.SnapshotGroups) > 0 {
-		groups := make([]*string, len(s.SnapshotGroups))
-		addsSnapshot := make([]*ec2.CreateVolumePermission, len(s.SnapshotGroups))
-		addSnapshotGroups := &ec2.ModifySnapshotAttributeInput{
-			CreateVolumePermission: &ec2.CreateVolumePermissionModifications{},
-		}
-
-		for i, g := range s.SnapshotGroups {
-			groups[i] = aws.String(g)
-			addsSnapshot[i] = &ec2.CreateVolumePermission{
-				Group: aws.String(g),
-			}
-		}
-		addSnapshotGroups.GroupNames = groups
-		addSnapshotGroups.CreateVolumePermission.Add = addsSnapshot
-		snapshotOptions["groups"] = addSnapshotGroups
-	}
-
 	if len(s.Users) > 0 {
 		users := make([]*string, len(s.Users))
-		addsImage := make([]*ec2.LaunchPermission, len(s.Users))
+		adds := make([]*ec2.LaunchPermission, len(s.Users))
 		for i, u := range s.Users {
 			users[i] = aws.String(u)
-			addsImage[i] = &ec2.LaunchPermission{UserId: aws.String(u)}
+			adds[i] = &ec2.LaunchPermission{UserId: aws.String(u)}
 		}
-
 		options["users"] = &ec2.ModifyImageAttributeInput{
 			UserIds: users,
 			LaunchPermission: &ec2.LaunchPermissionModifications{
-				Add: addsImage,
-			},
-		}
-	}
-
-	if len(s.SnapshotUsers) > 0 {
-		users := make([]*string, len(s.SnapshotUsers))
-		addsSnapshot := make([]*ec2.CreateVolumePermission, len(s.SnapshotUsers))
-		for i, u := range s.SnapshotUsers {
-			users[i] = aws.String(u)
-			addsSnapshot[i] = &ec2.CreateVolumePermission{UserId: aws.String(u)}
-		}
-
-		snapshotOptions["users"] = &ec2.ModifySnapshotAttributeInput{
-			UserIds: users,
-			CreateVolumePermission: &ec2.CreateVolumePermissionModifications{
-				Add: addsSnapshot,
+				Add: adds,
 			},
 		}
 	}
@@ -149,20 +87,13 @@ func (s *StepModifyAMIAttributes) Run(state multistep.StateBag) multistep.StepAc
 		}
 	}
 
-	// Modifying image attributes
 	for region, ami := range amis {
 		ui.Say(fmt.Sprintf("Modifying attributes on AMI (%s)...", ami))
 		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
-		}
+		session := session.New(&awsConfig)
 		regionconn := ec2.New(session)
 		for name, input := range options {
 			ui.Message(fmt.Sprintf("Modifying: %s", name))
@@ -177,30 +108,6 @@ func (s *StepModifyAMIAttributes) Run(state multistep.StateBag) multistep.StepAc
 		}
 	}
 
-	// Modifying snapshot attributes
-	for region, region_snapshots := range snapshots {
-		for _, snapshot := range region_snapshots {
-			ui.Say(fmt.Sprintf("Modifying attributes on snapshot (%s)...", snapshot))
-			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)
-				if err != nil {
-					err := fmt.Errorf("Error modify snapshot attributes: %s", err)
-					state.Put("error", err)
-					ui.Error(err.Error())
-					return multistep.ActionHalt
-				}
-			}
-		}
-	}
-
 	return multistep.ActionContinue
 }
 

builder/amazon/common/step_modify_ebs_instance.go

@@ -1,60 +0,0 @@
-package common
-
-import (
-	"fmt"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type StepModifyEBSBackedInstance struct {
-	EnableAMIENASupport      bool
-	EnableAMISriovNetSupport bool
-}
-
-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 {
-		ui.Say("Enabling Enhanced Networking (SR-IOV)...")
-		simple := "simple"
-		_, err := ec2conn.ModifyInstanceAttribute(&ec2.ModifyInstanceAttributeInput{
-			InstanceId:      instance.InstanceId,
-			SriovNetSupport: &ec2.AttributeValue{Value: &simple},
-		})
-		if err != nil {
-			err := fmt.Errorf("Error enabling Enhanced Networking (SR-IOV) on %s: %s", *instance.InstanceId, err)
-			state.Put("error", err)
-			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 {
-		ui.Say("Enabling Enhanced Networking (ENA)...")
-		_, err := ec2conn.ModifyInstanceAttribute(&ec2.ModifyInstanceAttributeInput{
-			InstanceId: instance.InstanceId,
-			EnaSupport: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
-		})
-		if err != nil {
-			err := fmt.Errorf("Error enabling Enhanced Networking (ENA) on %s: %s", *instance.InstanceId, err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepModifyEBSBackedInstance) Cleanup(state multistep.StateBag) {
-	// No cleanup...
-}

builder/amazon/common/step_pre_validate.go

@@ -5,8 +5,8 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepPreValidate provides an opportunity to pre-validate any configuration for
@@ -26,9 +26,9 @@ func (s *StepPreValidate) Run(state multistep.StateBag) multistep.StepAction {
 
 	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{{
+		Filters: []*ec2.Filter{&ec2.Filter{
 			Name:   aws.String("name"),
 			Values: []*string{aws.String(s.DestAmiName)},
 		}}})

builder/amazon/common/step_run_source_instance.go

@@ -5,45 +5,48 @@ import (
 	"fmt"
 	"io/ioutil"
 	"log"
+	"strconv"
+	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type StepRunSourceInstance struct {
-	AssociatePublicIpAddress          bool
-	AvailabilityZone                  string
-	BlockDevices                      BlockDevices
-	Debug                             bool
-	EbsOptimized                      bool
-	ExpectedRootDevice                string
-	IamInstanceProfile                string
-	InstanceInitiatedShutdownBehavior string
-	InstanceType                      string
-	SourceAMI                         string
-	SubnetId                          string
-	Tags                              map[string]string
-	VolumeTags                        map[string]string
-	UserData                          string
-	UserDataFile                      string
-	Ctx                               interpolate.Context
+	AssociatePublicIpAddress bool
+	AvailabilityZone         string
+	BlockDevices             BlockDevices
+	Debug                    bool
+	EbsOptimized             bool
+	ExpectedRootDevice       string
+	InstanceType             string
+	IamInstanceProfile       string
+	SourceAMI                string
+	SpotPrice                string
+	SpotPriceProduct         string
+	SubnetId                 string
+	Tags                     map[string]string
+	UserData                 string
+	UserDataFile             string
 
-	instanceId string
+	instanceId  string
+	spotRequest *ec2.SpotInstanceRequest
 }
 
 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 {
-		keyName = name.(string)
-	}
-	securityGroupIds := aws.StringSlice(state.Get("securityGroupIds").([]string))
+	keyName := state.Get("keyPair").(string)
+	tempSecurityGroupIds := state.Get("securityGroupIds").([]string)
 	ui := state.Get("ui").(packer.Ui)
 
+	securityGroupIds := make([]*string, len(tempSecurityGroupIds))
+	for i, sg := range tempSecurityGroupIds {
+		securityGroupIds[i] = aws.String(sg)
+	}
+
 	userData := s.UserData
 	if s.UserDataFile != "" {
 		contents, err := ioutil.ReadFile(s.UserDataFile)
@@ -62,112 +65,177 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 	}
 
 	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"))
+	imageResp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{
+		ImageIds: []*string{&s.SourceAMI},
+	})
+	if err != nil {
+		state.Put("error", fmt.Errorf("There was a problem with the source AMI: %s", err))
 		return multistep.ActionHalt
 	}
-	s.SourceAMI = *image.ImageId
 
-	if s.ExpectedRootDevice != "" && *image.RootDeviceType != s.ExpectedRootDevice {
+	if len(imageResp.Images) != 1 {
+		state.Put("error", fmt.Errorf("The source AMI '%s' could not be found.", s.SourceAMI))
+		return multistep.ActionHalt
+	}
+
+	if s.ExpectedRootDevice != "" && *imageResp.Images[0].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))
+			s.ExpectedRootDevice, *imageResp.Images[0].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
+		}
+
+		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 := 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)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	ReportTags(ui, ec2Tags)
-
-	volTags, err := ConvertToEC2Tags(s.VolumeTags, *ec2conn.Config.Region, s.SourceAMI, s.Ctx)
-	if err != nil {
-		err := fmt.Errorf("Error tagging volumes: %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,
-	}
-
-	var tagSpecs []*ec2.TagSpecification
-
-	if len(ec2Tags) > 0 {
-		runTags := &ec2.TagSpecification{
-			ResourceType: aws.String("instance"),
-			Tags:         ec2Tags,
+	if spotPrice == "" || spotPrice == "0" {
+		runOpts := &ec2.RunInstancesInput{
+			KeyName:             &keyName,
+			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,
 		}
 
-		tagSpecs = append(tagSpecs, runTags)
-	}
-
-	if len(volTags) > 0 {
-		runVolTags := &ec2.TagSpecification{
-			ResourceType: aws.String("volume"),
-			Tags:         volTags,
+		if s.SubnetId != "" && s.AssociatePublicIpAddress {
+			runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
+				&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
 		}
 
-		tagSpecs = append(tagSpecs, runVolTags)
-	}
-
-	if len(tagSpecs) > 0 {
-		runOpts.SetTagSpecifications(tagSpecs)
-	}
-
-	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),
-			},
+		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 {
-		runOpts.SubnetId = &s.SubnetId
-		runOpts.SecurityGroupIds = securityGroupIds
-	}
+		ui.Message(fmt.Sprintf(
+			"Requesting spot instance '%s' for: %s",
+			s.InstanceType, spotPrice))
+		runSpotResp, err := ec2conn.RequestSpotInstances(&ec2.RequestSpotInstancesInput{
+			SpotPrice: &spotPrice,
+			LaunchSpecification: &ec2.RequestSpotLaunchSpecification{
+				KeyName:            &keyName,
+				ImageId:            &s.SourceAMI,
+				InstanceType:       &s.InstanceType,
+				UserData:           &userData,
+				IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
+				NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+					&ec2.InstanceNetworkInterfaceSpecification{
+						DeviceIndex:              aws.Int64(0),
+						AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
+						SubnetId:                 &s.SubnetId,
+						Groups:                   securityGroupIds,
+						DeleteOnTermination:      aws.Bool(true),
+					},
+				},
+				Placement: &ec2.SpotPlacement{
+					AvailabilityZone: &availabilityZone,
+				},
+				BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
+				EbsOptimized:        &s.EbsOptimized,
+			},
+		})
+		if err != nil {
+			err := fmt.Errorf("Error launching source spot instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
 
-	if s.ExpectedRootDevice == "ebs" {
-		runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior
-	}
+		s.spotRequest = runSpotResp.SpotInstanceRequests[0]
 
-	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
+		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
 	}
-	instanceId = *runResp.Instances[0].InstanceId
 
 	// Set the instance ID so that the cleanup works properly
 	s.instanceId = instanceId
@@ -190,6 +258,21 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 
 	instance := latestInstance.(*ec2.Instance)
 
+	ec2Tags := make([]*ec2.Tag, 1, len(s.Tags)+1)
+	ec2Tags[0] = &ec2.Tag{Key: aws.String("Name"), Value: aws.String("Packer Builder")}
+	for k, v := range s.Tags {
+		ec2Tags = append(ec2Tags, &ec2.Tag{Key: aws.String(k), Value: aws.String(v)})
+	}
+
+	_, err = ec2conn.CreateTags(&ec2.CreateTagsInput{
+		Tags:      ec2Tags,
+		Resources: []*string{instance.InstanceId},
+	})
+	if err != nil {
+		ui.Message(
+			fmt.Sprintf("Failed to tag a Name on the builder instance: %s", err))
+	}
+
 	if s.Debug {
 		if instance.PublicDnsName != nil && *instance.PublicDnsName != "" {
 			ui.Message(fmt.Sprintf("Public DNS: %s", *instance.PublicDnsName))
@@ -214,6 +297,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...")
@@ -227,9 +330,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,372 +0,0 @@
-package common
-
-import (
-	"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/packer"
-	"github.com/hashicorp/packer/template/interpolate"
-	"github.com/mitchellh/multistep"
-)
-
-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                              map[string]string
-	VolumeTags                        map[string]string
-	UserData                          string
-	UserDataFile                      string
-	Ctx                               interpolate.Context
-
-	instanceId  string
-	spotRequest *ec2.SpotInstanceRequest
-}
-
-func (s *StepRunSpotInstance) Run(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 := 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)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	ReportTags(ui, ec2Tags)
-
-	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))
-	stateChangeSpot := StateChangeConf{
-		Pending:   []string{"pending"},
-		Target:    "running",
-		Refresh:   InstanceStateRefreshFunc(ec2conn, instanceId),
-		StepState: state,
-	}
-	latestInstance, err := WaitForState(&stateChangeSpot)
-	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)
-
-	// 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 {
-		ui.Say("Adding tags to source EBS Volumes")
-		tags, err := ConvertToEC2Tags(s.VolumeTags, *ec2conn.Config.Region, s.SourceAMI, s.Ctx)
-		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
-		}
-
-		ReportTags(ui, tags)
-
-		_, err = ec2conn.CreateTags(&ec2.CreateTagsInput{
-			Resources: volumeIds,
-			Tags:      tags,
-		})
-
-		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

@@ -6,19 +6,17 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common/uuid"
-	"github.com/hashicorp/packer/helper/communicator"
-	"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
 }
@@ -28,17 +26,6 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	if len(s.SecurityGroupIds) > 0 {
-		_, err := ec2conn.DescribeSecurityGroups(
-			&ec2.DescribeSecurityGroupsInput{
-				GroupIds: aws.StringSlice(s.SecurityGroupIds),
-			},
-		)
-		if err != nil {
-			err := fmt.Errorf("Couldn't find specified security group: %s", err)
-			log.Printf("[DEBUG] %s", err.Error())
-			state.Put("error", err)
-			return multistep.ActionHalt
-		}
 		log.Printf("Using specified security groups: %v", s.SecurityGroupIds)
 		state.Put("securityGroupIds", s.SecurityGroupIds)
 		return multistep.ActionContinue
@@ -46,23 +33,18 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 
 	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())
@@ -79,15 +61,15 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 		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 {
@@ -105,21 +87,6 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionHalt
 	}
 
-	log.Printf("[DEBUG] Waiting for temporary security group: %s", s.createdGroupId)
-	err = waitUntilSecurityGroupExists(ec2conn,
-		&ec2.DescribeSecurityGroupsInput{
-			GroupIds: []*string{aws.String(s.createdGroupId)},
-		},
-	)
-	if err == nil {
-		log.Printf("[DEBUG] Found security group %s", s.createdGroupId)
-	} else {
-		err := fmt.Errorf("Timed out waiting for security group %s: %s", s.createdGroupId, err)
-		log.Printf("[DEBUG] %s", err.Error())
-		state.Put("error", err)
-		return multistep.ActionHalt
-	}
-
 	// Set some state data for use in future steps
 	state.Put("securityGroupIds", []string{s.createdGroupId})
 
@@ -152,44 +119,3 @@ func (s *StepSecurityGroup) Cleanup(state multistep.StateBag) {
 			"Error cleaning up security group. Please delete the group manually: %s", s.createdGroupId))
 	}
 }
-
-func waitUntilSecurityGroupExists(c *ec2.EC2, input *ec2.DescribeSecurityGroupsInput) error {
-	ctx := aws.BackgroundContext()
-	w := request.Waiter{
-		Name:        "DescribeSecurityGroups",
-		MaxAttempts: 40,
-		Acceptors: []request.WaiterAcceptor{
-			{
-				State:    request.SuccessWaiterState,
-				Matcher:  request.PathWaiterMatch,
-				Argument: "length(SecurityGroups[]) > `0`",
-				Expected: true,
-			},
-			{
-				State:    request.RetryWaiterState,
-				Matcher:  request.ErrorWaiterMatch,
-				Argument: "",
-				Expected: "InvalidGroup.NotFound",
-			},
-			{
-				State:    request.RetryWaiterState,
-				Matcher:  request.ErrorWaiterMatch,
-				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)
-}

builder/amazon/common/step_source_ami_info.go

@@ -2,13 +2,10 @@ package common
 
 import (
 	"fmt"
-	"log"
-	"sort"
-	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepSourceAMIInfo extracts critical information from the source AMI
@@ -17,61 +14,16 @@ import (
 // Produces:
 //   source_image *ec2.Image - the source AMI info
 type StepSourceAMIInfo struct {
-	SourceAmi                string
-	EnableAMISriovNetSupport bool
-	EnableAMIENASupport      bool
-	AmiFilters               AmiFilterOptions
-}
-
-// Build a slice of AMI filter options from the filters provided.
-func buildAmiFilters(input map[*string]*string) []*ec2.Filter {
-	var filters []*ec2.Filter
-	for k, v := range input {
-		filters = append(filters, &ec2.Filter{
-			Name:   k,
-			Values: []*string{v},
-		})
-	}
-	return filters
-}
-
-type imageSort []*ec2.Image
-
-func (a imageSort) Len() int      { return len(a) }
-func (a imageSort) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a imageSort) Less(i, j int) bool {
-	itime, _ := time.Parse(time.RFC3339, *a[i].CreationDate)
-	jtime, _ := time.Parse(time.RFC3339, *a[j].CreationDate)
-	return itime.Unix() < jtime.Unix()
-}
-
-// Returns the most recent AMI out of a slice of images.
-func mostRecentAmi(images []*ec2.Image) *ec2.Image {
-	sortedImages := images
-	sort.Sort(imageSort(sortedImages))
-	return sortedImages[len(sortedImages)-1]
+	SourceAmi          string
+	EnhancedNetworking bool
 }
 
 func (s *StepSourceAMIInfo) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
-	params := &ec2.DescribeImagesInput{}
-
-	if s.SourceAmi != "" {
-		params.ImageIds = []*string{&s.SourceAmi}
-	}
-
-	// We have filters to apply
-	if len(s.AmiFilters.Filters) > 0 {
-		params.Filters = buildAmiFilters(s.AmiFilters.Filters)
-	}
-	if len(s.AmiFilters.Owners) > 0 {
-		params.Owners = s.AmiFilters.Owners
-	}
-
-	log.Printf("Using AMI Filters %v", params)
-	imageResp, err := ec2conn.DescribeImages(params)
+	ui.Say("Inspecting the source AMI...")
+	imageResp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{ImageIds: []*string{&s.SourceAmi}})
 	if err != nil {
 		err := fmt.Errorf("Error querying AMI: %s", err)
 		state.Put("error", err)
@@ -80,31 +32,17 @@ func (s *StepSourceAMIInfo) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	if len(imageResp.Images) == 0 {
-		err := fmt.Errorf("No AMI was found matching filters: %v", params)
+		err := fmt.Errorf("Source AMI '%s' was not found!", s.SourceAmi)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
-	if len(imageResp.Images) > 1 && !s.AmiFilters.MostRecent {
-		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())
-		return multistep.ActionHalt
-	}
+	image := imageResp.Images[0]
 
-	var image *ec2.Image
-	if s.AmiFilters.MostRecent {
-		image = mostRecentAmi(imageResp.Images)
-	} else {
-		image = imageResp.Images[0]
-	}
-
-	ui.Message(fmt.Sprintf("Found Image ID: %s", *image.ImageId))
-
-	// Enhanced Networking can only be enabled on HVM AMIs.
+	// Enhanced Networking (SriovNetSupport) 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,99 +0,0 @@
-package common
-
-import (
-	"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/packer"
-	"github.com/mitchellh/multistep"
-)
-
-type StepStopEBSBackedInstance struct {
-	SpotPrice           string
-	DisableStopInstance bool
-}
-
-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.SpotPrice != "" && s.SpotPrice != "0" {
-		return multistep.ActionContinue
-	}
-
-	var err error
-
-	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
-		})
-
-		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 actual stop
-	ui.Say("Waiting for the instance to stop...")
-	stateChange := StateChangeConf{
-		Pending:   []string{"running", "pending", "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)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepStopEBSBackedInstance) Cleanup(multistep.StateBag) {
-	// No cleanup...
-}

builder/amazon/ebs/builder.go

@@ -9,14 +9,15 @@ import (
 	"fmt"
 	"log"
 
+	"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/communicator"
-	"github.com/hashicorp/packer/helper/config"
-	"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/communicator"
+	"github.com/mitchellh/packer/helper/config"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 // The unique ID for this builder
@@ -43,24 +44,11 @@ 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{
-				"ami_description",
-				"run_tags",
-				"run_volume_tags",
-				"snapshot_tags",
-				"tags",
-			},
-		},
 	}, raws...)
 	if err != nil {
 		return nil, err
 	}
 
-	if b.config.PackerConfig.PackerForce {
-		b.config.AMIForceDeregister = true
-	}
-
 	// Accumulate any errors
 	var errs *packer.MultiError
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(&b.config.ctx)...)
@@ -77,28 +65,23 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
-
-	session, err := b.config.Session()
+	config, err := b.config.Config()
 	if err != nil {
 		return nil, err
 	}
+
+	session := session.New(config)
 	ec2conn := ec2.New(session)
 
-	// If the subnet is specified but not the VpcId or AZ, try to determine them automatically
-	if b.config.SubnetId != "" && (b.config.AvailabilityZone == "" || b.config.VpcId == "") {
-		log.Printf("[INFO] Finding AZ and VpcId for the given subnet '%s'", b.config.SubnetId)
+	// If the subnet is specified but not the AZ, try to determine the AZ automatically
+	if b.config.SubnetId != "" && b.config.AvailabilityZone == "" {
+		log.Printf("[INFO] Finding AZ for the given subnet '%s'", b.config.SubnetId)
 		resp, err := ec2conn.DescribeSubnets(&ec2.DescribeSubnetsInput{SubnetIds: []*string{&b.config.SubnetId}})
 		if err != nil {
 			return nil, err
 		}
-		if b.config.AvailabilityZone == "" {
-			b.config.AvailabilityZone = *resp.Subnets[0].AvailabilityZone
-			log.Printf("[INFO] AvailabilityZone found: '%s'", b.config.AvailabilityZone)
-		}
-		if b.config.VpcId == "" {
-			b.config.VpcId = *resp.Subnets[0].VpcId
-			log.Printf("[INFO] VpcId found: '%s'", b.config.VpcId)
-		}
+		b.config.AvailabilityZone = *resp.Subnets[0].AvailabilityZone
+		log.Printf("[INFO] AZ found: '%s'", b.config.AvailabilityZone)
 	}
 
 	// Setup the state bag and initial state for the steps
@@ -108,29 +91,32 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 
-	var instanceStep multistep.Step
-
-	if b.config.SpotPrice == "" || b.config.SpotPrice == "0" {
-		instanceStep = &awscommon.StepRunSourceInstance{
-			Debug:                    b.config.PackerDebug,
-			ExpectedRootDevice:       "ebs",
-			InstanceType:             b.config.InstanceType,
-			UserData:                 b.config.UserData,
-			UserDataFile:             b.config.UserDataFile,
-			SourceAMI:                b.config.SourceAmi,
-			IamInstanceProfile:       b.config.IamInstanceProfile,
-			SubnetId:                 b.config.SubnetId,
-			AssociatePublicIpAddress: b.config.AssociatePublicIpAddress,
-			EbsOptimized:             b.config.EbsOptimized,
-			AvailabilityZone:         b.config.AvailabilityZone,
-			BlockDevices:             b.config.BlockDevices,
-			Tags:                     b.config.RunTags,
-			VolumeTags:               b.config.VolumeRunTags,
-			Ctx:                      b.config.ctx,
-			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
-		}
-	} else {
-		instanceStep = &awscommon.StepRunSpotInstance{
+	// Build the steps
+	steps := []multistep.Step{
+		&awscommon.StepPreValidate{
+			DestAmiName:     b.config.AMIName,
+			ForceDeregister: b.config.AMIForceDeregister,
+		},
+		&awscommon.StepSourceAMIInfo{
+			SourceAmi:          b.config.SourceAmi,
+			EnhancedNetworking: b.config.AMIEnhancedNetworking,
+		},
+		&awscommon.StepKeyPair{
+			Debug:                b.config.PackerDebug,
+			DebugKeyPath:         fmt.Sprintf("ec2_%s.pem", b.config.PackerBuildName),
+			KeyPairName:          b.config.SSHKeyPairName,
+			TemporaryKeyPairName: b.config.TemporaryKeyPairName,
+			PrivateKeyFile:       b.config.RunConfig.Comm.SSHPrivateKey,
+		},
+		&awscommon.StepSecurityGroup{
+			SecurityGroupIds: b.config.SecurityGroupIds,
+			CommConfig:       &b.config.RunConfig.Comm,
+			VpcId:            b.config.VpcId,
+		},
+		&stepCleanupVolumes{
+			BlockDevices: b.config.BlockDevices,
+		},
+		&awscommon.StepRunSourceInstance{
 			Debug:                    b.config.PackerDebug,
 			ExpectedRootDevice:       "ebs",
 			SpotPrice:                b.config.SpotPrice,
@@ -146,42 +132,10 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			AvailabilityZone:         b.config.AvailabilityZone,
 			BlockDevices:             b.config.BlockDevices,
 			Tags:                     b.config.RunTags,
-			VolumeTags:               b.config.VolumeRunTags,
-			Ctx:                      b.config.ctx,
-			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
-		}
-	}
-
-	// Build the steps
-	steps := []multistep.Step{
-		&awscommon.StepPreValidate{
-			DestAmiName:     b.config.AMIName,
-			ForceDeregister: b.config.AMIForceDeregister,
 		},
-		&awscommon.StepSourceAMIInfo{
-			SourceAmi:                b.config.SourceAmi,
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
-			AmiFilters:               b.config.SourceAmiFilter,
+		&stepTagEBSVolumes{
+			VolumeRunTags: b.config.VolumeRunTags,
 		},
-		&awscommon.StepKeyPair{
-			Debug:                b.config.PackerDebug,
-			SSHAgentAuth:         b.config.Comm.SSHAgentAuth,
-			DebugKeyPath:         fmt.Sprintf("ec2_%s.pem", b.config.PackerBuildName),
-			KeyPairName:          b.config.SSHKeyPairName,
-			TemporaryKeyPairName: b.config.TemporaryKeyPairName,
-			PrivateKeyFile:       b.config.RunConfig.Comm.SSHPrivateKey,
-		},
-		&awscommon.StepSecurityGroup{
-			SecurityGroupIds: b.config.SecurityGroupIds,
-			CommConfig:       &b.config.RunConfig.Comm,
-			VpcId:            b.config.VpcId,
-			TemporarySGSourceCidr: b.config.TemporarySGSourceCidr,
-		},
-		&stepCleanupVolumes{
-			BlockDevices: b.config.BlockDevices,
-		},
-		instanceStep,
 		&awscommon.StepGetPassword{
 			Debug:   b.config.PackerDebug,
 			Comm:    &b.config.RunConfig.Comm,
@@ -193,58 +147,43 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 				ec2conn,
 				b.config.SSHPrivateIp),
 			SSHConfig: awscommon.SSHConfig(
-				b.config.RunConfig.Comm.SSHAgentAuth,
-				b.config.RunConfig.Comm.SSHUsername,
-				b.config.RunConfig.Comm.SSHPassword),
+				b.config.RunConfig.Comm.SSHUsername),
 		},
 		&common.StepProvision{},
-		&awscommon.StepStopEBSBackedInstance{
-			SpotPrice:           b.config.SpotPrice,
-			DisableStopInstance: b.config.DisableStopInstance,
-		},
-		&awscommon.StepModifyEBSBackedInstance{
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
-		},
+		&stepStopInstance{SpotPrice: b.config.SpotPrice},
+		// TODO(mitchellh): verify works with spots
+		&stepModifyInstance{},
 		&awscommon.StepDeregisterAMI{
-			AccessConfig:        &b.config.AccessConfig,
-			ForceDeregister:     b.config.AMIForceDeregister,
-			ForceDeleteSnapshot: b.config.AMIForceDeleteSnapshot,
-			AMIName:             b.config.AMIName,
-			Regions:             b.config.AMIRegions,
+			ForceDeregister: b.config.AMIForceDeregister,
+			AMIName:         b.config.AMIName,
 		},
 		&stepCreateAMI{},
-		&awscommon.StepCreateEncryptedAMICopy{
-			KeyID:             b.config.AMIKmsKeyId,
-			EncryptBootVolume: b.config.AMIEncryptBootVolume,
-			Name:              b.config.AMIName,
-			AMIMappings:       b.config.AMIBlockDevices.AMIMappings,
-		},
 		&awscommon.StepAMIRegionCopy{
-			AccessConfig:      &b.config.AccessConfig,
-			Regions:           b.config.AMIRegions,
-			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,
-			Users:          b.config.AMIUsers,
-			Groups:         b.config.AMIGroups,
-			ProductCodes:   b.config.AMIProductCodes,
-			SnapshotUsers:  b.config.SnapshotUsers,
-			SnapshotGroups: b.config.SnapshotGroups,
-			Ctx:            b.config.ctx,
+			Description:  b.config.AMIDescription,
+			Users:        b.config.AMIUsers,
+			Groups:       b.config.AMIGroups,
+			ProductCodes: b.config.AMIProductCodes,
 		},
 		&awscommon.StepCreateTags{
-			Tags:         b.config.AMITags,
-			SnapshotTags: b.config.SnapshotTags,
-			Ctx:          b.config.ctx,
+			Tags: b.config.AMITags,
 		},
 	}
 
 	// Run!
-	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
+	if b.config.PackerDebug {
+		b.runner = &multistep.DebugRunner{
+			Steps:   steps,
+			PauseFn: common.MultistepDebugFn(ui),
+		}
+	} else {
+		b.runner = &multistep.BasicRunner{Steps: steps}
+	}
+
 	b.runner.Run(state)
 
 	// If there was an error, return that

builder/amazon/ebs/builder_acc_test.go

@@ -6,10 +6,11 @@ import (
 	"testing"
 
 	"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/builder/amazon/common"
-	builderT "github.com/hashicorp/packer/helper/builder/testing"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/builder/amazon/common"
+	builderT "github.com/mitchellh/packer/helper/builder/testing"
+	"github.com/mitchellh/packer/packer"
 )
 
 func TestBuilderAcc_basic(t *testing.T) {
@@ -45,60 +46,6 @@ func TestBuilderAcc_forceDeregister(t *testing.T) {
 	})
 }
 
-func TestBuilderAcc_forceDeleteSnapshot(t *testing.T) {
-	amiName := "packer-test-dereg"
-
-	// Build the same AMI name twice, with force_delete_snapshot on the second run
-	builderT.Test(t, builderT.TestCase{
-		PreCheck:             func() { testAccPreCheck(t) },
-		Builder:              &Builder{},
-		Template:             buildForceDeleteSnapshotConfig("false", amiName),
-		SkipArtifactTeardown: true,
-	})
-
-	// Get image data by AMI name
-	ec2conn, _ := testEC2Conn()
-	imageResp, _ := ec2conn.DescribeImages(
-		&ec2.DescribeImagesInput{Filters: []*ec2.Filter{
-			{
-				Name:   aws.String("name"),
-				Values: []*string{aws.String(amiName)},
-			},
-		}},
-	)
-	image := imageResp.Images[0]
-
-	// Get snapshot ids for image
-	snapshotIds := []*string{}
-	for _, device := range image.BlockDeviceMappings {
-		if device.Ebs != nil && device.Ebs.SnapshotId != nil {
-			snapshotIds = append(snapshotIds, device.Ebs.SnapshotId)
-		}
-	}
-
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() { testAccPreCheck(t) },
-		Builder:  &Builder{},
-		Template: buildForceDeleteSnapshotConfig("true", amiName),
-		Check:    checkSnapshotsDeleted(snapshotIds),
-	})
-}
-
-func checkSnapshotsDeleted(snapshotIds []*string) builderT.TestCheckFunc {
-	return func(artifacts []packer.Artifact) error {
-		// Verify the snapshots are gone
-		ec2conn, _ := testEC2Conn()
-		snapshotResp, _ := ec2conn.DescribeSnapshots(
-			&ec2.DescribeSnapshotsInput{SnapshotIds: snapshotIds},
-		)
-
-		if len(snapshotResp.Snapshots) > 0 {
-			return fmt.Errorf("Snapshots weren't successfully deleted by `force_delete_snapshot`")
-		}
-		return nil
-	}
-}
-
 func TestBuilderAcc_amiSharing(t *testing.T) {
 	builderT.Test(t, builderT.TestCase{
 		PreCheck: func() { testAccPreCheck(t) },
@@ -108,15 +55,6 @@ func TestBuilderAcc_amiSharing(t *testing.T) {
 	})
 }
 
-func TestBuilderAcc_encryptedBoot(t *testing.T) {
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() { testAccPreCheck(t) },
-		Builder:  &Builder{},
-		Template: testBuilderAccEncrypted,
-		Check:    checkBootEncrypted(),
-	})
-}
-
 func checkAMISharing(count int, uid, group string) builderT.TestCheckFunc {
 	return func(artifacts []packer.Artifact) error {
 		if len(artifacts) > 1 {
@@ -191,7 +129,7 @@ func checkRegionCopy(regions []string) builderT.TestCheckFunc {
 		for _, r := range regions {
 			regionSet[r] = struct{}{}
 		}
-		for r := range artifact.Amis {
+		for r, _ := range artifact.Amis {
 			if _, ok := regionSet[r]; !ok {
 				return fmt.Errorf("unknown region: %s", r)
 			}
@@ -206,42 +144,6 @@ func checkRegionCopy(regions []string) builderT.TestCheckFunc {
 	}
 }
 
-func checkBootEncrypted() builderT.TestCheckFunc {
-	return func(artifacts []packer.Artifact) error {
-
-		// Get the actual *Artifact pointer so we can access the AMIs directly
-		artifactRaw := artifacts[0]
-		artifact, ok := artifactRaw.(*common.Artifact)
-		if !ok {
-			return fmt.Errorf("unknown artifact: %#v", artifactRaw)
-		}
-
-		// describe the image, get block devices with a snapshot
-		ec2conn, _ := testEC2Conn()
-		imageResp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{
-			ImageIds: []*string{aws.String(artifact.Amis["us-east-1"])},
-		})
-
-		if err != nil {
-			return fmt.Errorf("Error retrieving Image Attributes for AMI (%s) in AMI Encrypted Boot Test: %s", artifact, err)
-		}
-
-		image := imageResp.Images[0] // Only requested a single AMI ID
-
-		rootDeviceName := image.RootDeviceName
-
-		for _, bd := range image.BlockDeviceMappings {
-			if *bd.DeviceName == *rootDeviceName {
-				if *bd.Ebs.Encrypted != true {
-					return fmt.Errorf("volume not encrypted: %s", *bd.Ebs.SnapshotId)
-				}
-			}
-		}
-
-		return nil
-	}
-}
-
 func testAccPreCheck(t *testing.T) {
 	if v := os.Getenv("AWS_ACCESS_KEY_ID"); v == "" {
 		t.Fatal("AWS_ACCESS_KEY_ID must be set for acceptance tests")
@@ -254,11 +156,12 @@ func testAccPreCheck(t *testing.T) {
 
 func testEC2Conn() (*ec2.EC2, error) {
 	access := &common.AccessConfig{RawRegion: "us-east-1"}
-	session, err := access.Session()
+	config, err := access.Config()
 	if err != nil {
 		return nil, err
 	}
 
+	session := session.New(config)
 	return ec2.New(session), nil
 }
 
@@ -303,21 +206,6 @@ const testBuilderAccForceDeregister = `
 }
 `
 
-const testBuilderAccForceDeleteSnapshot = `
-{
-	"builders": [{
-		"type": "test",
-		"region": "us-east-1",
-		"instance_type": "m3.medium",
-		"source_ami": "ami-76b2a71e",
-		"ssh_username": "ubuntu",
-		"force_deregister": "%s",
-		"force_delete_snapshot": "%s",
-		"ami_name": "packer-test-%s"
-	}]
-}
-`
-
 // share with catsby
 const testBuilderAccSharing = `
 {
@@ -334,24 +222,6 @@ const testBuilderAccSharing = `
 }
 `
 
-const testBuilderAccEncrypted = `
-{
-	"builders": [{
-		"type": "test",
-		"region": "us-east-1",
-		"instance_type": "m3.medium",
-		"source_ami":"ami-c15bebaa",
-		"ssh_username": "ubuntu",
-		"ami_name": "packer-enc-test {{timestamp}}",
-		"encrypt_boot": true
-	}]
-}
-`
-
-func buildForceDeregisterConfig(val, name string) string {
-	return fmt.Sprintf(testBuilderAccForceDeregister, val, name)
-}
-
-func buildForceDeleteSnapshotConfig(val, name string) string {
-	return fmt.Sprintf(testBuilderAccForceDeleteSnapshot, val, val, name)
+func buildForceDeregisterConfig(name, flag string) string {
+	return fmt.Sprintf(testBuilderAccForceDeregister, name, flag)
 }

builder/amazon/ebs/builder_test.go

@@ -3,7 +3,7 @@ package ebs
 import (
 	"testing"
 
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/packer"
 )
 
 func testConfig() map[string]interface{} {
@@ -92,38 +92,3 @@ func TestBuilderPrepare_InvalidKey(t *testing.T) {
 		t.Fatal("should have error")
 	}
 }
-
-func TestBuilderPrepare_InvalidShutdownBehavior(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test good
-	config["shutdown_behavior"] = "terminate"
-	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 good
-	config["shutdown_behavior"] = "stop"
-	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["shutdown_behavior"] = "foobar"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}

builder/amazon/ebs/step_cleanup_volumes.go

@@ -5,9 +5,9 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/builder/amazon/common"
+	"github.com/mitchellh/packer/packer"
 )
 
 // stepCleanupVolumes cleans up any orphaned volumes that were not designated to
@@ -30,6 +30,12 @@ func (s *stepCleanupVolumes) Cleanup(state multistep.StateBag) {
 		instance = instanceRaw.(*ec2.Instance)
 	}
 	ui := state.Get("ui").(packer.Ui)
+	amisRaw := state.Get("amis")
+	if amisRaw == nil {
+		ui.Say("No AMIs to cleanup")
+		return
+	}
+
 	if instance == nil {
 		ui.Say("No volumes to clean up, skipping")
 		return
@@ -37,8 +43,22 @@ func (s *stepCleanupVolumes) Cleanup(state multistep.StateBag) {
 
 	ui.Say("Cleaning up any extra volumes...")
 
+	// We don't actually care about the value here, but we need Set behavior
+	save := make(map[string]struct{})
+	for _, b := range s.BlockDevices.AMIMappings {
+		if !b.DeleteOnTermination {
+			save[b.DeviceName] = struct{}{}
+		}
+	}
+
+	for _, b := range s.BlockDevices.LaunchMappings {
+		if !b.DeleteOnTermination {
+			save[b.DeviceName] = struct{}{}
+		}
+	}
+
 	// Collect Volume information from the cached Instance as a map of volume-id
-	// to device name, to compare with save list below
+	// to device name, to compare with save list above
 	var vl []*string
 	volList := make(map[string]string)
 	for _, bdm := range instance.BlockDeviceMappings {
@@ -52,7 +72,7 @@ func (s *stepCleanupVolumes) Cleanup(state multistep.StateBag) {
 	// date information on them
 	resp, err := ec2conn.DescribeVolumes(&ec2.DescribeVolumesInput{
 		Filters: []*ec2.Filter{
-			{
+			&ec2.Filter{
 				Name:   aws.String("volume-id"),
 				Values: vl,
 			},
@@ -77,22 +97,21 @@ func (s *stepCleanupVolumes) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	// Filter out any devices created as part of the launch mappings, since
-	// we'll let amazon follow the `delete_on_termination` setting.
-	for _, b := range s.BlockDevices.LaunchMappings {
+	// Filter out any devices marked for saving
+	for saveName, _ := range save {
 		for volKey, volName := range volList {
-			if volName == b.DeviceName {
+			if volName == saveName {
 				delete(volList, volKey)
 			}
 		}
 	}
 
 	// Destroy remaining volumes
-	for k := range volList {
+	for k, _ := range volList {
 		ui.Say(fmt.Sprintf("Destroying volume (%s)...", k))
 		_, err := ec2conn.DeleteVolume(&ec2.DeleteVolumeInput{VolumeId: aws.String(k)})
 		if err != nil {
-			ui.Say(fmt.Sprintf("Error deleting volume: %s", err))
+			ui.Say(fmt.Sprintf("Error deleting volume: %s", k))
 		}
 
 	}

builder/amazon/ebs/step_create_ami.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	awscommon "github.com/mitchellh/packer/builder/amazon/common"
+	"github.com/mitchellh/packer/packer"
 )
 
 type stepCreateAMI struct {
@@ -66,15 +66,6 @@ func (s *stepCreateAMI) Run(state multistep.StateBag) multistep.StepAction {
 	}
 	s.image = imagesResp.Images[0]
 
-	snapshots := make(map[string][]string)
-	for _, blockDeviceMapping := range imagesResp.Images[0].BlockDeviceMappings {
-		if blockDeviceMapping.Ebs != nil && blockDeviceMapping.Ebs.SnapshotId != nil {
-
-			snapshots[*ec2conn.Config.Region] = append(snapshots[*ec2conn.Config.Region], *blockDeviceMapping.Ebs.SnapshotId)
-		}
-	}
-	state.Put("snapshots", snapshots)
-
 	return multistep.ActionContinue
 }
 
@@ -92,7 +83,7 @@ func (s *stepCreateAMI) 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))