Cut version 1.0.0-rc3

https://github.com/dominikh/go-tools/tree/master/cmd/unused

.github/ISSUE_TEMPLATE.md

@@ -1,11 +1,6 @@
-_Please read these instructions before submitting_
-
 **DELETE THIS TEMPLATE BEFORE SUBMITTING**
 
-_Only use Github issues to report bugs or feature requests, see
-https://www.packer.io/community.html_
-
-For example, _Timeouts waiting for SSH/WinRM_ are generally not bugs within packer and are better addressed by the mailing list. Ask on the mailing list if you are unsure.
+_Only use Github issues to report bugs or feature requests, see https://www.packer.io/community/_
 
 If you are planning to open a pull-request just open the pull-request instead of making an issue first.
 
@@ -23,4 +18,3 @@ Describe the problem and include the following information:
   Please paste this in a gist https://gist.github.com
 - The _simplest example template and scripts_ needed to reproduce the bug.
   Include these in your gist https://gist.github.com
-  

.github/PULL_REQUEST_TEMPLATE.md

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

.gitignore

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

.travis.yml

@@ -7,8 +7,7 @@ language: go
 
 go:
   - 1.7.4
-  - 1.8.3
-  - 1.x
+  - 1.8
 
 install:
   - make deps
@@ -22,3 +21,5 @@ branches:
 
 matrix:
   fast_finish: true
+  allow_failures:
+    - go: 1.4.3

CHANGELOG.md

@@ -1,433 +1,45 @@
-## 1.1.3 (December 8, 2017)
-
-### IMPROVEMENTS:
-
-* builder/alicloud-ecs: Add security token support and set TLS handshake
-    timeout through environment variable. [GH-5641]
-* builder/amazon: Add a new parameter `ssh_interface`. Valid values include
-    `public_ip`, `private_ip`, `public_dns` or `private_dns`. [GH-5630]
-* builder/azure: Add sanity checks for resource group names [GH-5599]
-* builder/hyper-v: Add support for differencing disk. [GH-5458]
-* builder/vmware-iso: Improve logging of network errors. [GH-5456]
-* core: Add new `packer_version` template engine. [GH-5619]
-* core: Improve logic checking for downloaded ISOs in case where user has
-    provided more than one URL in `iso_urls` [GH-5632]
-* provisioner/ansible-local: Add ability to clean staging directory. [GH-5618]
+## 1.0.0-rc3 (March 30, 2017)
 
 ### BUG FIXES:
-
-* builder/amazon: Allow `region` to appear in `ami_regions`. [GH-5660]
-* builder/amazon: `C5` instance types now build more reliably. [GH-5678]
-* builder/amazon: Correctly set AWS region if given in template along with a
-    profile. [GH-5676]
-* builder/amazon: Prevent `sriov_support` and `ena_support` from being used
-    with spot instances, which would cause a build failure. [GH-5679]
-* builder/azure: `build_resource_group_name` is mutually exclusive with
-    `location` [GH-5661]
-* builder/azure: Clean up KeyVaults when deploying Windows images that used an
-    existing resource group. [GH-5656]
-* builder/azure: Only destroy temporary resource groups if they were created by
-    Packer. [GH-5593]
-* builder/hyper-v: Fix interpolation context for user variables in
-    `boot_command` [GH-5547]
-* builder/qemu: Set default disk size to 40960 MB to prevent boot failures.
-    [GH-5588]
-* builder/vmware: Correctly detect Windows boot on vmware workstation.
-    [GH-5672]
-* core: Fix windows path regression when downloading ISOs. [GH-5591]
-* provisioner/chef: Fix chef installs on Windows. [GH-5649]
-
-## 1.1.2 (November 15, 2017)
-
-### IMPROVEMENTS:
-
-* builder/amazon: Correctly deregister AMIs when `force_deregister` is set.
-    [GH-5525]
-* builder/digitalocean: Add `ipv6` option to enable on droplet. [GH-5534]
-* builder/docker: Add `aws_profile` option to control the aws profile for ECR.
-    [GH-5470]
-* builder/google: Add `clean_image_name` template engine. [GH-5463]
-* builder/google: Allow selecting container optimized images. [GH-5576]
-* builder/google: Interpolate network and subnetwork values, rather than
-    relying on an API call that packer may not have permission for. [GH-5343]
-* builder/hyper-v: Add `disk_additional_size` option to allow for up to 64
-    additional disks. [GH-5491]
-* builder/hyper-v: Also disable automatic checkpoints for gen 2 VMs. [GH-5517]
-* builder/lxc: Add new `publish_properties` field to set image properties.
-    [GH-5475]
-* builder/lxc: Add three new configuration option categories to LXC builder:
-    `create_options`, `start_options`, and `attach_options`. [GH-5530]
-* builder/triton: Add `source_machine_image_filter` option to select an image
-    ID based on a variety of parameters. [GH-5538]
-* builder/virtualbox-ovf: Error during prepare if source path doesn't exist.
-    [GH-5573]
-* builder/virtualbox-ovf: Retry while removing VM to solve for transient
-    errors. [GH-5512]
-* communicator/ssh: Add socks 5 proxy support. [GH-5439]
-* core/iso_config: Support relative paths in checksum file. [GH-5578]
-* core: Rewrite vagrantfile code to make cross-platform development easier.
-    [GH-5539]
-* post-processor/docker-push: Add `aws_profile` option to control the aws
-    profile for ECR. [GH-5470]
-* post-processor/vsphere: Properly capture `ovftool` output. [GH-5499]
-
-### BUG FIXES:
-
-* builder/amazon: Add a delay option to security group waiter. [GH-5536]
-* builder/amazon: Fix regressions relating to spot instances and EBS volumes.
-    [GH-5495]
-* builder/amazon: Set region from profile, if profile is set, rather than being
-    overridden by metadata. [GH-5562]
-* builder/docker: Remove `login_email`, which no longer exists in the docker
-    client. [GH-5511]
-* builder/hyperv: Fix admin check that was causing powershell failures.
-    [GH-5510]
-* builder/oracle: Defaulting of OCI builder region will first check the packer
-    template and the OCI config file. [GH-5407]
-* builder/triton: Fix a bug where partially created images can be reported as
-    complete. [GH-5566]
-* post-processor/vsphere: Use the vm disk path information to re-create the vmx
-    datastore path. [GH-5567]
-* provisioner/windows-restart: Wait for restart no longer endlessly loops if
-    user specifies a custom restart check command. [GH-5563]
-
-## 1.1.1 (October 13, 2017)
-
-### IMPROVEMENTS:
-
-* **New builder:** `hyperv-vmcx` for building images from existing VMs.
-    [GH-4944] [GH-5444]
-* builder/amazon-instance: Add `.Token` as a variable in the
-    `BundleUploadCommand` template. [GH-5288]
-* builder/amazon: Add `temporary_security_group_source_cidr` option to control
-    ingress to source instances. [GH-5384]
-* builder/amazon: Output AMI Name during prevalidation. [GH-5389]
-* builder/amazon: Support template functions in tag keys. [GH-5381]
-* builder/amazon: Tag volumes on creation instead of as a separate step.
-    [GH-5417]
-* builder/docker: Add option to set `--user` flag when running `exec`.
-    [GH-5406]
-* builder/docker: Set file owner to container user when uploading. Can be
-    disabled by setting `fix_upload_owner` to `false`. [GH-5422]
-* builder/googlecompute: Support setting labels on the resulting image.
-    [GH-5356]
-* builder/hyper-v: Add `vhd_temp_path` option to control where the VHD resides
-    while it's being provisioned. [GH-5206]
-* builder/hyper-v: Allow vhd or vhdx source images instead of just ISO.
-    [GH-4944] [GH-5444]
-* builder/hyper-v: Disable automatic checkpoints. [GH-5374]
-* builder/virtualbox-ovf: Add `keep_registered` option. [GH-5336]
-* builder/vmware: Add `disable_vnc` option to prevent VNC connections from
-    being made. [GH-5436]
-* core: Releases will now be built for ppc64le.
-* post-processor/vagrant: When building from a builder/hyper-v artifact, link
-    instead of copy when available. [GH-5207]
-
-
-### BUG FIXES:
-
-* builder/cloudstack: Fix panic if build is aborted. [GH-5388]
-* builder/hyper-v: Respect `enable_dynamic_memory` flag. [GH-5363]
-* builder/puppet-masterless: Make sure directories created with sudo are
-    writable by the packer user. [GH-5351]
-* provisioner/chef-solo: Fix issue installing chef-solo on Windows. [GH-5357]
-* provisioner/powershell: Fix issue setting environment variables by writing
-    them to a file, instead of the command line. [GH-5345]
-* provisioner/powershell: Fix issue where powershell scripts could hang.
-    [GH-5082]
-* provisioner/powershell: Fix Powershell progress stream leak to stderr for
-    normal and elevated commands. [GH-5365]
-* provisioner/puppet-masterless: Fix bug where `puppet_bin_dir` wasn't being
-    respected. [GH-5340]
-* provisioner/puppet: Fix setting facter vars on Windows. [GH-5341]
-
-
-## 1.1.0 (September 12, 2017)
-
-### IMPROVEMENTS:
-
-* builder/alicloud: Update alicloud go sdk and enable multi sites support for
-    alicloud [GH-5219]
-* builder/amazon: Upgrade aws-sdk-go to 1.10.14, add tags at instance run time.
-    [GH-5196]
-* builder/azure: Add object_id to windows_custom_image.json. [GH-5285]
-* builder/azure: Add support for storage account for managed images. [GH-5244]
-* builder/azure: Update pkcs12 package. [GH-5301]
-* builder/cloudstack: Add support for Security Groups. [GH-5175]
-* builder/docker: Uploading files and directories now use docker cp. [GH-5273]
-    [GH-5333]
-* builder/googlecompute: Add `labels` option for labeling launched instances.
-    [GH-5308]
-* builder/googlecompute: Add support for accelerator api. [GH-5137]
-* builder/profitbricks: added support for Cloud API v4. [GH-5233]
-* builder/vmware-esxi: Remote builds now respect `output_directory` [GH-4592]
-* builder/vmware: Set artifact ID to `VMName`. [GH-5187]
-* core: Build solaris binary by default. [GH-5268] [GH-5248]
-* core: Remove LGPL dependencies. [GH-5262]
-* provisioner/puppet: Add `guest_os_type` option to add support for Windows.
-    [GH-5252]
-* provisioner/salt-masterless: Also use sudo to clean up if we used sudo to
-    install. [GH-5240]
-
-### BACKWARDS INCOMPATIBILITIES:
-
-* builder/amazon: Changes way that AMI artifacts are printed out after build,
-    aligning them to builder. Could affect output parsing. [GH-5281]
-* builder/amazon: Split `enhanced_networking` into `sriov_support` and
-    `ena_support` to support finer grained control. Use `packer fix
-    <template.json>` to automatically update your template to use `ena_support`
-    where previously there was only `enhanced_networking`. Make sure to also
-    add `sriov_support` if you need that feature, and to ensure `ena_support`
-    is what you intended to be in your template. [GH-5284]
-* builder/cloudstack: Setup temporary SSH keypair; backwards incompatible in
-    the uncommon case that the source image allowed SSH auth with password but
-    not with keypair. [GH-5174]
-* communicator/ssh: Renamed `ssh_disable_agent` to
-    `ssh_disable_agent_forwarding`. Need to run fixer on packer configs that
-    use `ssh_disable_agent`. [GH-5024]
-* communicator: Preserve left-sided white-space in remote command output. Make
-    sure any scripts that parse this output can handle the new whitespace
-    before upgrading. [GH-5167]
-* provisioner/shell: Set default for `ExpectDisconnect` to `false`. If your
-    script causes the connection to be reset, you should set this to `true` to
-    prevent errors. [GH-5283]
-
-### BUG FIXES:
-
-* builder/amazon: `force_deregister` works in all regions, not just original
-    region. [GH-5250]
-* builder/docker: Directory uploads now use the same semantics as the rest of
-    the communicators. [GH-5333]
-* builder/vmware: Fix timestamp in default VMName. [GH-5274]
-* builder/winrm: WinRM now waits to make sure commands can run successfully
-    before considering itself connected. [GH-5300]
-* core: Fix issue where some builders wouldn't respect `-on-error` behavior.
-    [GH-5297]
-* provisioner/windows-restart: The first powershell provisioner after a restart
-    now works. [GH-5272]
-
-### FEATURES:
-
-* **New builder**: Oracle Cloud Infrastructure (OCI) builder for creating
-    custom images. [GH-4554]
-* **New builder:** `lxc` for building lxc images. [GH-3523]
-* **New builder:** `lxd` for building lxd images. [GH-3625]
-* **New post-processor**: vSphere Template post-processor to be used with
-    vmware-iso builder enabling user to mark a VM as a template. [GH-5114]
-
-## 1.0.4 (August 11, 2017)
-
-### IMPROVEMENTS:
-
-* builder/alicloud: Increase polling timeout. [GH-5148]
-* builder/azure: Add `private_virtual_network_with_public_ip` option to
-    optionally obtain a public IP. [GH-5222]
-* builder/googlecompute: use a more portable method of obtaining zone.
-    [GH-5192]
-* builder/hyperv: Properly interpolate user variables in template. [GH-5184]
-* builder/parallels: Remove soon to be removed --vmtype flag in createvm.
-    [GH-5172]
-* contrib: add json files to zsh completion. [GH-5195]
-
-### BUG FIXES:
-
-* builder/amazon: Don't delete snapshots we didn't create. [GH-5211]
-* builder/amazon: fix builds when using the null communicator. [GH-5217]
-* builder/docker: Correctly handle case when uploading an empty directory.
-    [GH-5234]
-* command/push: Don't push variables if they are unspecified. Reverts to
-    behavior in 1.0.1. [GH-5235]
-* command/push: fix handling of symlinks. [GH-5226]
-* core: Strip query parameters from ISO URLs when checking against a checksum
-    file. [GH-5181]
-* provisioner/ansible-remote: Fix issue where packer could hang communicating
-    with ansible-remote. [GH-5146]
-
-## 1.0.3 (July 17, 2017)
-
-### IMPROVEMENTS:
-* builder/azure: Update to latest Azure SDK, enabling support for managed
-    disks. [GH-4511]
-* builder/cloudstack: Add default cidr_list [ 0.0.0.0/0 ]. [GH-5125]
-* builder/cloudstack: Add support for ssh_agent_auth. [GH-5130]
-* builder/cloudstack: Add support for using a HTTP server. [GH-5017]
-* builder/cloudstack: Allow reading api_url, api_key, and secret_key from env
-    vars. [GH-5124]
-* builder/cloudstack: Make expunge optional and improve logging output.
-    [GH-5099]
-* builder/googlecompute: Allow using URL's for network and subnetwork.
-    [GH-5035]
-* builder/hyperv: Add support for floppy_dirs with hyperv-iso builder.
-* builder/hyperv: Add support for override of system %temp% path.
-* core: Experimental Android ARM support. [GH-5111]
-* post-processor/atlas: Disallow packer push of vagrant.box artifacts to atlas.
-    [GH-4780]
-* postprocessor/atlas: Disallow pushing vagrant.box artifacts now that Vagrant
-    cloud is live. [GH-4780]
-
-### BUG FIXES:
-* builder/amazon: Fix panic that happens if ami_block_device_mappings is empty.
-    [GH-5059]
-* builder/azure: Write private SSH to file in debug mode. [GH-5070] [GH-5074]
-* builder/cloudstack: Properly report back errors. [GH-5103] [GH-5123]
-* builder/docker: Fix windows filepath in docker-toolbox call [GH-4887]
-* builder/docker: Fix windows filepath in docker-toolbox call. [GH-4887]
-* builder/hyperv: Use SID to verify membersip in Admin group, fixing for non-
-    english users. [GH-5022]
-* builder/hyperv: Verify membership in the group Hyper-V Administrators by SID
-    not name. [GH-5022]
-* builder/openstack: Update gophercloud version, fixing builds  > 1 hr long.
-    [GH-5046]
-* builder/parallels: Skip missing paths when looking for unnecessary files.
-    [GH-5058]
-* builder/vmware-esxi: Fix VNC port discovery default timeout. [GH-5051]
-* communicator/ssh: Add ProvisionerTypes to communicator tests, resolving panic
-    [GH-5116]
-* communicator/ssh: Resolve race condition that sometimes truncates ssh
-    provisioner stdout [GH-4719]
-* post-processor/checksum: Fix interpolation of "output". [GH-5112]
-* push: Push vars in packer config, not just those set from command line and in
-    var-file. [GH-5101]
-
-## 1.0.2 (June 21, 2017)
-
-### BUG FIXES:
-* communicator/ssh: Fix truncated stdout from remote ssh provisioner. [GH-5050]
-* builder/amazon: Fix bugs related to stop instance command. [GH-4719]
-* communicator/ssh: Fix ssh connection errors. [GH-5038]
-* core: Remove logging that shouldn't be there when running commands. [GH-5042]
-* provisioner/shell: Fix bug where scripts were being run under `sh`. [GH-5043]
-
-### IMPROVEMENTS:
-
-* provisioner/windows-restart: make it clear that timeouts come from the
-    provisioner, not winrm. [GH-5040]
-
-## 1.0.1 (June 19, 2017)
-
-### IMPROVEMENTS:
-
-* builder/amazon: Allow amis to be copied to other regions, encrypted with
-    custom KMS keys. [GH-4948]
-* builder/amazon: Allow configuration of api endpoint to support api-compatible
-    cloud providers. [GH-4896]
-* builder/amazon: Fix regex used for ami name validation [GH-4902]
-* builder/amazon: Look up vpc from subnet id if no vpc was specified. [GH-4879]
-* builder/amazon: Print temporary security group name to the UI. [GH-4997]
-* builder/amazon: Support Assume Role with MFA and ECS Task Roles. Also updates
-    to a newer version of aws-sdk-go. [GH-4996]
-* builder/amazon: Use retry logic when creating instance tags. [GH-4876]
-* builder/amazon: Validate ami name. [GH-4762]
-* builder/azure: Add build output to artifact. [GH-4953]
-* builder/azure: Use disk URI as artifact ID. [GH-4981]
-* builder/digitalocean: Added support for monitoring. [GH-4782]
-* builder/digitalocean: Support for copying snapshot to other regions.
-    [GH-4893]
-* builder/hyper-v: Remove the check for administrator rights when sending key
-    strokes to Hyper-V. [GH-4687] # builder/openstack: Fix private key error
-    message to match documentation [GH-4898]
-* builder/null: Support SSH agent auth [GH-4956]
-* builder/openstack: Add ssh agent support. [GH-4655]
-* builder/openstack: Support client x509 certificates. [GH-4921]
-* builder/parallels-iso: Configuration of disk type, plain or expanding.
-    [GH-4621]
-* builder/triton: An SSH agent can be used to authenticate requests, making
-    `triton_key_material` optional. [GH-4838]
-* builder/triton: If no source machine networks are specified, instances are
-    started on the default public and internal networks. [GH-4838]
-* builder/virtualbox: Add sata port count configuration option. [GH-4699]
-* builder/virtualbox: Don't add port forwarding when using "none" communicator.
-    [GH-4960]
-* builder/vmware: Add option to remove interfaces from the vmx. [GH-4927]
-* builder/vmware: Properly remove mounted CDs on OS X. [GH-4810]
-* builder/vmware: VNC probe timeout is configurable. [GH-4919]
-* command/push: add `-sensitive` flag to mark pushed vars are sensitive.
-    [GH-4970]
-* command/push: Vagrant support in Terraform Enterprise is deprecated.
-    [GH-4950]
-* communicator/ssh: Add ssh agent support for bastion connections. [GH-4940]
-* communicator/winrm: Add NTLM authentication support. [GH-4979]
-* communicator/winrm: Add support for file downloads. [GH-4748]
-* core: add telemetry for better product support. [GH-5015]
-* core: Build binaries for arm64 [GH-4892]
-* post-processor/amazon-import: Add support for `license_type`. [GH-4634]
-* post-processor/vagrant-cloud: Get vagrant cloud token from environment.
-    [GH-4982]
-* provisioner/ansible-local: Add extra-vars `packer_build_name`,
-    `packer_builder_type`, and `packer_http_addr`. [GH-4821]
-* provisioner/ansible: Add `inventory_directory` option to control where to
-    place the generated inventory file. [GH-4760]
-* provisioner/ansible: Add `skip_version_check` flag for when ansible will be
-    installed from a prior provisioner. [GH-4983]
-* provisioner/ansible: Add extra-vars `packer_build_name` and
-    `packer_builder_type`. [GH-4821]
-* provisioner/chef-solo: Add option to select Chef version. [GH-4791]
-* provisioner/salt: Add salt bin directory configuration. [GH-5009]
-* provisioner/salt: Add support for grains. [GH-4961]
-* provisioner/shell: Use `env` to set environment variables to support freebsd
-    out of the box. [GH-4909]
-* website/docs: Clarify language, improve formatting. [GH-4866]
-* website/docs: Update docker metadata fields that can be changed. [GH-4867]
-
-
-### BUG FIXES:
-
-* builder/amazon-ebssurrogate: Use ami device settings when creating the AMI.
-    [GH-4972]
-* builder/amazon: don't try to delete extra volumes during clean up. [GH-4930]
-* builder/amazon: fix `force_delete_snapshot` when the launch instance has
-    extra volumes. [GH-4931]
-* builder/amazon: Only delete temporary key if we created one. [GH-4850]
-* builder/azure: Replace calls to panic with error returns. [GH-4846]
-* communicator/winrm: Use KeepAlive to keep long-running connections open.
-    [GH-4952]
-* core: Correctly reject config files which have junk after valid json.
-    [GH-4906]
-* post-processor/checksum: fix crash when invalid checksum is used. [GH-4812]
-* post-processor/vagrant-cloud: don't read files to upload in to memory first.
-    [GH-5005]
-* post-processor/vagrant-cloud: only upload once under normal conditions.
-    [GH-5008]
-* provisioner/ansible-local: Correctly set the default staging directory under
-    Windows. [GH-4792]
-
-### FEATURES:
-
-* **New builder:** `alicloud-ecs` for building Alicloud ECS images. [GH-4619]
-
-
-## 1.0.0 (April 4, 2017)
-
-### BUG FIXES:
-
-* builder/amazon: Fix b/c issue by reporting again the tags we create.
-    [GH-4704]
-* builder/amazon: Fix crash in `step_region_copy`. [GH-4642]
-* builder/googlecompute: Correct values for `on_host_maintenance`. [GH-4643]
-* builder/googlecompute: Use "default" service account. [GH-4749]
-* builder/hyper-v: Don't wait for shutdown_command to return. [GH-4691]
-* builder/virtualbox: fix `none` communicator by allowing skipping upload of
-    version file. [GH-4678]
-* builder/virtualbox: retry removing floppy controller. [GH-4705]
-* communicator/ssh: don't return error if we can't close connection. [GH-4741]
-* communicator/ssh: fix nil pointer error. [GH-4690]
 * core: fix version number
+* communicator/ssh: don't return error if we can't close connection. #4741
+
+## 1.0.0-rc2 (March 29, 2017)
+
+### BUG FIXES:
+
 * core: Invoking packer `--help` or `--version` now exits with status 0.
     [GH-4723]
 * core: show correct step name when debugging. [GH-4672]
-* communicator/winrm: Directory uploads behave more like scp. [GH-4438]
+* builder/virtualbox: fix `none` communicator by allowing skipping upload of
+    version file. [GH-4678]
+* communicator/ssh: fix nil pointer error. [GH-4690]
+* builder/hyper-v: Don't wait for shutdown_command to return. [GH-4691]
+* builder/amazon: Fix b/c issue by reporting again the tags we create.
+    [GH-4704]
+* builder/virtualbox: retry removing floppy controller. [GH-4705]
 
-### IMPROVEMENTS:
+### IMRPOVEMENTS:
 
-* builder/amazon-chroot: Ability to give an empty list in `copy_files` to
-    prevent the default `/etc/resolv.conf` file from being copied. If
-    `copy_files` isn't given at all, the default behavior remains. [GH-4708]
-* builder/amazon: set force_deregister to true on -force. [GH-4649]
-* builder/amazon: validate ssh key name/file. [GH-4665]
 * builder/ansible: Clearer error message when we have problems getting the
     ansible version. [GH-4694]
+* builder/amazon-chroot: Ability to give an empty list in `copy_files` to
+    prevent the default `/etc/resolv.conf` file from being copied. If `copy_files`
+    isn't given at all, the default behavior remains. [GH-4708]
+
+
+## 1.0.0-rc1 (March 16, 2017)
+
+### BUG FIXES:
+
+* builder/googlecompute: Correct values for `on_host_maintenance`. [GH-4643]
+* builder/amazon: Fix crash in `step_region_copy`. [GH-4642]
+
+### IMRPOVEMENTS:
+
+* builder/amazon: validate ssh key name/file. [GH-4665]
+* builder/amazon: set force_deregister to true on -force. [GH-4649]
 * builder/hyper-v: validate output dir in step, not in config. [GH-4645]
-* More diligently try to complete azure-setup.sh. [GH-4752]
 * website: fix display on ios devices. [GH-4618]
 
 ## 0.12.3 (March 1, 2017)
@@ -442,43 +54,42 @@
 
 ### IMPROVEMENTS:
 
-* builder/amazon-chroot: support encrypted boot volume. [GH-4584]
 * builder/amazon: Add BuildRegion and SourceAMI template variables. [GH-4399]
 * builder/amazon: Change EC2 Windows password timeout to 20 minutes. [GH-4590]
-* builder/amazon: enable ena when `enhanced_networking` is set. [GH-4578]
-* builder/azure:: add two new config variables for temp_compute_name and
-    temp_resource_group_name. [GH-4468]
+* builder/amazon-chroot: support encrypted boot volume. [GH-4584]
 * builder/docker: create export dir if needed. [GH-4439]
 * builder/googlecompute: Add `on_host_maintenance` option. [GH-4544]
-* builder/openstack: add reuse_ips option to try to re-use existing IPs.
-    [GH-4564]
+* builder/openstack: add reuse_ips option to try to re-use existing IPs. [GH-4564]
+* communicator/docker: preserve file mode. [GH-4443]
+* communicator/winrm: support ProxyFromEnvironment. [GH-4463]
+* core: make VNC links clickable in terminal. [GH-4497] [GH-4498]
+* post-processor/amazon-import: support AMI attributes on import [GH-4216]
+* communicator/ssh: Use SSH agent when enabled for bastion step. [GH-4598]
+* builder/amazon: enable ena when `enhanced_networking` is set. [GH-4578]
 * builder/vmware-esxi: try for longer to connect to vnc port. [GH-4480]
     [GH-4610]
-* builder/vmware: allow extra options for ovftool. [GH-4536]
-* builder/vmware: don't cache ip address so we know if it changes. [GH-4532]
-* communicator/docker: preserve file mode. [GH-4443]
-* communicator/ssh: Use SSH agent when enabled for bastion step. [GH-4598]
-* communicator/winrm: support ProxyFromEnvironment. [GH-4463]
 * core: don't show ui color if we're not colorized. [GH-4525]
-* core: make VNC links clickable in terminal. [GH-4497] [GH-4498]
+* builder/vmware: don't cache ip address so we know if it changes. [GH-4532]
+* builder/vmware: allow extra options for ovftool. [GH-4536]
 * docs: add community page. [GH-4550]
-* post-processor/amazon-import: support AMI attributes on import [GH-4216]
 * post-processor/docker-import: print stderr on docker import failure.
     [GH-4529]
+* builder/azure:: add two new config variables for temp_compute_name and
+    temp_resource_group_name. [GH-4468]
 
 ### BUG FIXES:
 
-* builder/amazon-ebsvolume: Fix interpolation of block_device. [GH-4464]
 * builder/amazon: Fix ssh agent authentication. [GH-4597]
-* builder/docker: Don't force tag if using a docker version that doesn't
-    support it. [GH-4560]
+* builder/amazon-ebsvolume: Fix interpolation of block_device. [GH-4464]
 * builder/googlecompute: fix bug when creating image from custom image_family.
     [GH-4518]
 * builder/virtualbox: remove guest additions before saving image. [GH-4496]
 * core: always check for an error first when walking a path. [GH-4467]
-* core: update crypto/ssh lib to fix large file uploads. [GH-4546]
+* builder/docker: Don't force tag if using a docker version that doesn't
+    support it. [GH-4560]
 * provisioner/chef-client: only upload knife config if we're cleaning.
     [GH-4534]
+* core: update crypto/ssh lib to fix large file uploads. [GH-4546]
 
 ## 0.12.2 (January 20, 2017)
 
@@ -491,13 +102,12 @@
 
 * builder/hyperv-iso: add `iso_target_extension` option. [GH-4294]
 * builder/openstack: Add support for instance metadata. [GH-4361]
-* builder/openstack: Attempt to use existing floating IPs before allocating a
-    new one. [GH-4357]
+* builder/openstack: Attempt to use existing floating IPs before allocating
+    a new one. [GH-4357]
 * builder/parallels-iso: add `iso_target_extension` option. [GH-4294]
 * builder/qemu: add `iso_target_extension` option. [GH-4294]
 * builder/qemu: add `use_default_display` option for osx compatibility.
     [GH-4293]
-* builder/qemu: Detect input disk image format during copy/convert. [GH-4343]
 * builder/virtualbox-iso: add `iso_target_extension` option. [GH-4294]
 * builder/virtualbox: add `skip_export` option to skip exporting the VM after
     build completes. [GH-4339]
@@ -509,22 +119,23 @@
 * builder/vmware: Try to use `ip address` to find host IP. [GH-4411]
 * common/step_http\_server: set `PACKER_HTTP_ADDR` env var for accessing http
     server from inside builder. [GH-4409]
-* provisioner/powershell: Allow equals sign in value of environment variables.
-    [GH-4328]
+* provisioner/powershell: Allow equals sign in value of environment
+    variables. [GH-4328]
 * provisioner/puppet-server: Add default facts.  [GH-4286]
+* builder/qemu: Detect input disk image format during copy/convert. [GH-4343]
 
 ### BUG FIXES:
 
 * builder/amazon-chroot: Panic in AMI region copy step. [GH-4341]
 * builder/amazon: Crashes when new EBS vols are used. [GH-4308]
 * builder/amazon: Fix crash in amazon-instance. [GH-4372]
-* builder/amazon: fix run volume tagging [GH-4420]
-* builder/amazon: fix when using non-existant security\_group\_id. [GH-4425]
 * builder/amazon: Properly error if we don't have the
     ec2:DescribeSecurityGroups permission. [GH-4304]
 * builder/amazon: Properly wait for security group to exist. [GH-4369]
-* builder/docker: Fix crash when performing log in to ECR with an invalid URL.
-    [GH-4385]
+* builder/amazon: fix run volume tagging [GH-4420]
+* builder/amazon: fix when using non-existant security\_group\_id. [GH-4425]
+* builder/docker: Fix crash when performing log in to ECR with an invalid
+    URL. [GH-4385]
 * builder/openstack: fix for finding resource by ID. [GH-4301]
 * builder/qemu: Explicitly set WinRMPort for StepConnect. [GH-4321]
 * builder/virtualbox: Explicitly set WinRMPort for StepConnect. [GH-4321]
@@ -535,7 +146,8 @@
 * command/push: Don't interpolate variables when pushing. [GH-4389]
 * common/step_http_server: make port range inclusive. [GH-4398]
 * communicator/winrm: update winrm client, resolving `MaxMemoryPerShellMB`
-    errors and properly error logging instead of panicking. [GH-4412] [GH-4424]
+    errors and properly error logging instead of panicking. [GH-4412]
+    [GH-4424]
 * provider/windows-shell: Allows equals sign in env var value. [GH-4423]
 
 ## 0.12.1 (December 15, 2016)
@@ -547,9 +159,9 @@
     "packer fix template.json" to migrate a template. [GH-4285]
 * builder/openstack: No long supports the `api_key` option for rackspace.
     [GH-4283]
-* post-processor/manifest: Changed `filename` field to be `output`, to be more
-    consistent with other post-processors. `packer fix` will fix this for you.
-    [GH-4192]
+* post-processor/manifest: Changed `filename` field to be `output`, to be
+    more consistent with other post-processors. `packer fix` will fix this
+    for you. [GH-4192]
 * post-processor/shell-local: Now runs per-builder instead of per-file. The
     filename is no longer passed in as an argument to the script, but instead
     needs to be gleaned from the manifest post-processor. [GH-4189]

CODEOWNERS

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

CONTRIBUTING.md

@@ -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,28 +65,28 @@ 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
+4. When working on packer `cd $GOPATH/src/github.com/mitchellh/packer` so you
    can run `make` and easily access other files. Run `make help` to get
    information about make targets.
 
 5. Make your changes to the Packer source. You can run `make` in
-   `$GOPATH/src/github.com/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.
+When you are ready to open a pull-request, you will need to [fork packer](https://github.com/mitchellh/packer#fork-destination-box), push your changes to your fork, and then open a pull-request.
 
 For example, my github username is `cbednarski` so I would do the following:
 
@@ -104,7 +104,7 @@ From there, open your fork in your browser to open a new pull-request.
 
 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
+1. Navigate to $GOPATH/src/github.com/mitchellh/packer
 2. Add the remote `git remote add <name of remote> <github url of fork>`. For example `git remote add mwhooker https://github.com/mwhooker/packer.git`.
 3. Checkout a feature branch: `git checkout -b new-feature`
 4. Make changes

Makefile

@@ -5,17 +5,6 @@ GITSHA:=$(shell git rev-parse HEAD)
 # Get the current local branch name from git (if we can, this may be blank)
 GITBRANCH:=$(shell git symbolic-ref --short HEAD 2>/dev/null)
 GOFMT_FILES?=$$(find . -not -path "./vendor/*" -name "*.go")
-GOOS=$(shell go env GOOS)
-GOARCH=$(shell go env GOARCH)
-GOPATH=$(shell go env GOPATH)
-
-# Get the git commit
-GIT_DIRTY=$(shell test -n "`git status --porcelain`" && echo "+CHANGES" || true)
-GIT_COMMIT=$(shell git rev-parse --short HEAD)
-GIT_IMPORT=github.com/hashicorp/packer/version
-GOLDFLAGS=-X $(GIT_IMPORT).GitCommit=$(GIT_COMMIT)$(GIT_DIRTY)
-
-export GOLDFLAGS
 
 default: deps generate test dev
 
@@ -24,37 +13,32 @@ ci: deps test
 release: deps test releasebin package ## Build a release build
 
 bin: deps ## Build debug/test build
-	@go get github.com/mitchellh/gox
 	@echo "WARN: 'make bin' is for debug / test builds only. Use 'make release' for release builds."
-	@sh -c "$(CURDIR)/scripts/build.sh"
+	@GO15VENDOREXPERIMENT=1 sh -c "$(CURDIR)/scripts/build.sh"
 
 releasebin: deps
-	@go get github.com/mitchellh/gox
 	@grep 'const VersionPrerelease = "dev"' version/version.go > /dev/null ; if [ $$? -eq 0 ]; then \
 		echo "ERROR: You must remove prerelease tags from version/version.go prior to release."; \
 		exit 1; \
 	fi
-	@sh -c "$(CURDIR)/scripts/build.sh"
+	@GO15VENDOREXPERIMENT=1 sh -c "$(CURDIR)/scripts/build.sh"
 
 package:
 	$(if $(VERSION),,@echo 'VERSION= needed to release; Use make package skip compilation'; exit 1)
 	@sh -c "$(CURDIR)/scripts/dist.sh $(VERSION)"
 
 deps:
-	@go get golang.org/x/tools/cmd/stringer
-	@go get github.com/kardianos/govendor
-	@govendor sync
+	go get github.com/mitchellh/gox
+	go get golang.org/x/tools/cmd/stringer
+	go get github.com/kardianos/govendor
+	govendor sync
 
 dev: deps ## Build and install a development build
 	@grep 'const VersionPrerelease = ""' version/version.go > /dev/null ; if [ $$? -eq 0 ]; then \
 		echo "ERROR: You must add prerelease tags to version/version.go prior to making a dev build."; \
 		exit 1; \
 	fi
-	@mkdir -p pkg/$(GOOS)_$(GOARCH)
-	@mkdir -p bin
-	@go install -ldflags '$(GOLDFLAGS)'
-	@cp $(GOPATH)/bin/packer bin/packer
-	@cp $(GOPATH)/bin/packer pkg/$(GOOS)_$(GOARCH)
+	@PACKER_DEV=1 GO15VENDOREXPERIMENT=1 sh -c "$(CURDIR)/scripts/build.sh"
 
 fmt: ## Format Go code
 	@gofmt -w -s $(GOFMT_FILES)
@@ -62,9 +46,6 @@ fmt: ## Format Go code
 fmt-check: ## Check go code formatting
 	$(CURDIR)/scripts/gofmtcheck.sh $(GOFMT_FILES)
 
-fmt-docs:
-	@find ./website/source/docs -name "*.md" -exec pandoc --wrap auto --columns 79 --atx-headers -s -f "markdown_github+yaml_metadata_block" -t "markdown_github+yaml_metadata_block" {} -o {} \;
-
 # Install js-beautify with npm install -g js-beautify
 fmt-examples:
 	find examples -name *.json | xargs js-beautify -r -s 2 -n -eol "\n"
@@ -91,9 +72,11 @@ testrace: deps ## Test for race conditions
 	@go test -race $(TEST) $(TESTARGS) -timeout=2m
 
 updatedeps:
+	go get -u github.com/mitchellh/gox
+	go get -u golang.org/x/tools/cmd/stringer
 	@echo "INFO: Packer deps are managed by govendor. See CONTRIBUTING.md"
 
 help:
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
 
-.PHONY: bin checkversion ci default deps fmt fmt-docs fmt-examples generate releasebin test testacc testrace updatedeps
+.PHONY: bin checkversion ci default deps fmt fmt-examples generate releasebin test testacc testrace updatedeps

README.md

@@ -5,9 +5,9 @@
 [![GoDoc][godoc-badge]][godoc]
 [![GoReportCard][report-badge]][report]
 
-[travis-badge]: https://travis-ci.org/hashicorp/packer.svg?branch=master
-[travis]: https://travis-ci.org/hashicorp/packer
-[appveyor-badge]: https://ci.appveyor.com/api/projects/status/miavlgnp989e5obc/branch/master?svg=true
+[travis-badge]: https://travis-ci.org/mitchellh/packer.svg?branch=master
+[travis]: https://travis-ci.org/mitchellh/packer
+[appveyor-badge]: https://ci.appveyor.com/api/projects/status/github/mitchellh/packer?branch=master&svg=true
 [appveyor]: https://ci.appveyor.com/project/hashicorp/packer
 [godoc-badge]: https://godoc.org/github.com/mitchellh/packer?status.svg
 [godoc]: https://godoc.org/github.com/mitchellh/packer
@@ -16,7 +16,7 @@
 
 * Website: https://www.packer.io
 * IRC: `#packer-tool` on Freenode
-* Mailing list: [Google Groups](https://groups.google.com/forum/#!forum/packer-tool)
+* Mailing list: [Google Groups](http://groups.google.com/group/packer-tool)
 
 Packer is a tool for building identical machine images for multiple platforms
 from a single source configuration.
@@ -34,7 +34,6 @@ comes out of the box with support for the following platforms:
 * Hyper-V
 * 1&1
 * OpenStack
-* Oracle Cloud Infrastructure
 * Parallels
 * ProfitBricks
 * QEMU. Both KVM and Xen images.
@@ -50,16 +49,16 @@ The images that Packer creates can easily be turned into
 ## Quick Start
 Download and install packages and dependencies
 ```
-go get github.com/hashicorp/packer
+go get github.com/mitchellh/packer
 ```
 
 **Note:** There is a great
-[introduction and getting started guide](https://www.packer.io/intro)
+[introduction and getting started guide](http://www.packer.io/intro)
 for those with a bit more patience. Otherwise, the quick start below
 will get you up and running quickly, at the sacrifice of not explaining some
 key points.
 
-First, [download a pre-built Packer binary](https://www.packer.io/downloads.html)
+First, [download a pre-built Packer binary](http://www.packer.io/downloads.html)
 for your operating system or [compile Packer yourself](CONTRIBUTING.md#setting-up-go-to-work-on-packer).
 
 After Packer is installed, create your first template, which tells Packer
@@ -104,8 +103,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.

Vagrantfile

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

appveyor.yml

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

builder/alicloud/ecs/access_config.go

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

builder/alicloud/ecs/access_config_test.go

@@ -1,44 +0,0 @@
-package ecs
-
-import (
-	"testing"
-)
-
-func testAlicloudAccessConfig() *AlicloudAccessConfig {
-	return &AlicloudAccessConfig{
-		AlicloudAccessKey: "ak",
-		AlicloudSecretKey: "acs",
-	}
-
-}
-
-func TestAlicloudAccessConfigPrepareRegion(t *testing.T) {
-	c := testAlicloudAccessConfig()
-	c.AlicloudRegion = ""
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-
-	c.AlicloudRegion = "cn-beijing-3"
-	if err := c.Prepare(nil); err == nil {
-		t.Fatal("should have error")
-	}
-
-	c.AlicloudRegion = "cn-beijing"
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-
-	c.AlicloudRegion = "unknown"
-	if err := c.Prepare(nil); err == nil {
-		t.Fatalf("should have err")
-	}
-
-	c.AlicloudRegion = "unknown"
-	c.AlicloudSkipValidation = true
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-	c.AlicloudSkipValidation = false
-
-}

builder/alicloud/ecs/artifact.go

@@ -1,135 +0,0 @@
-package ecs
-
-import (
-	"fmt"
-	"log"
-	"sort"
-	"strings"
-
-	"github.com/denverdino/aliyungo/common"
-	"github.com/denverdino/aliyungo/ecs"
-	"github.com/hashicorp/packer/packer"
-)
-
-type Artifact struct {
-	// A map of regions to alicloud image IDs.
-	AlicloudImages map[string]string
-
-	// BuilderId is the unique ID for the builder that created this alicloud image
-	BuilderIdValue string
-
-	// Alcloud connection for performing API stuff.
-	Client *ecs.Client
-}
-
-func (a *Artifact) BuilderId() string {
-	return a.BuilderIdValue
-}
-
-func (*Artifact) Files() []string {
-	// We have no files
-	return nil
-}
-
-func (a *Artifact) Id() string {
-	parts := make([]string, 0, len(a.AlicloudImages))
-	for region, ecsImageId := range a.AlicloudImages {
-		parts = append(parts, fmt.Sprintf("%s:%s", region, ecsImageId))
-	}
-
-	sort.Strings(parts)
-	return strings.Join(parts, ",")
-}
-
-func (a *Artifact) String() string {
-	alicloudImageStrings := make([]string, 0, len(a.AlicloudImages))
-	for region, id := range a.AlicloudImages {
-		single := fmt.Sprintf("%s: %s", region, id)
-		alicloudImageStrings = append(alicloudImageStrings, single)
-	}
-
-	sort.Strings(alicloudImageStrings)
-	return fmt.Sprintf("Alicloud images were created:\n\n%s", strings.Join(alicloudImageStrings, "\n"))
-}
-
-func (a *Artifact) State(name string) interface{} {
-	switch name {
-	case "atlas.artifact.metadata":
-		return a.stateAtlasMetadata()
-	default:
-		return nil
-	}
-}
-
-func (a *Artifact) Destroy() error {
-	errors := make([]error, 0)
-
-	for region, imageId := range a.AlicloudImages {
-		log.Printf("Delete alicloud image ID (%s) from region (%s)", imageId, region)
-
-		// Get alicloud image metadata
-		images, _, err := a.Client.DescribeImages(&ecs.DescribeImagesArgs{
-			RegionId: common.Region(region),
-			ImageId:  imageId})
-		if err != nil {
-			errors = append(errors, err)
-		}
-		if len(images) == 0 {
-			err := fmt.Errorf("Error retrieving details for alicloud image(%s), no alicloud images found", imageId)
-			errors = append(errors, err)
-			continue
-		}
-		//Unshared the shared account before destroy
-		sharePermissions, err := a.Client.DescribeImageSharePermission(&ecs.ModifyImageSharePermissionArgs{RegionId: common.Region(region), ImageId: imageId})
-		if err != nil {
-			errors = append(errors, err)
-		}
-		accountsNumber := len(sharePermissions.Accounts.Account)
-		if accountsNumber > 0 {
-			accounts := make([]string, accountsNumber)
-			for index, account := range sharePermissions.Accounts.Account {
-				accounts[index] = account.AliyunId
-			}
-			err := a.Client.ModifyImageSharePermission(&ecs.ModifyImageSharePermissionArgs{
-
-				RegionId:      common.Region(region),
-				ImageId:       imageId,
-				RemoveAccount: accounts,
-			})
-			if err != nil {
-				errors = append(errors, err)
-			}
-		}
-		// Delete alicloud images
-		if err := a.Client.DeleteImage(common.Region(region), imageId); err != nil {
-			errors = append(errors, err)
-		}
-		//Delete the snapshot of this images
-		for _, diskDevices := range images[0].DiskDeviceMappings.DiskDeviceMapping {
-			if err := a.Client.DeleteSnapshot(diskDevices.SnapshotId); err != nil {
-				errors = append(errors, err)
-			}
-		}
-
-	}
-
-	if len(errors) > 0 {
-		if len(errors) == 1 {
-			return errors[0]
-		} else {
-			return &packer.MultiError{Errors: errors}
-		}
-	}
-
-	return nil
-}
-
-func (a *Artifact) stateAtlasMetadata() interface{} {
-	metadata := make(map[string]string)
-	for region, imageId := range a.AlicloudImages {
-		k := fmt.Sprintf("region.%s", region)
-		metadata[k] = imageId
-	}
-
-	return metadata
-}

builder/alicloud/ecs/artifact_test.go

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

builder/alicloud/ecs/builder.go

@@ -1,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 copiedRegionId, copiedImageId := range alicloudImages {
-			if copiedRegionId == s.RegionId {
-				continue
-			}
-			if err := client.CancelCopyImage(common.Region(copiedRegionId), copiedImageId); err != nil {
-				ui.Say(fmt.Sprintf("Error cancelling copy image: %v", err))
-			}
-		}
-	}
-}

builder/alicloud/ecs/step_run_instance.go

@@ -1,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 copiedRegion, copiedImageId := range alicloudImages {
-		err := client.ModifyImageSharePermission(
-			&ecs.ModifyImageSharePermissionArgs{
-				RegionId:      common.Region(copiedRegion),
-				ImageId:       copiedImageId,
-				AddAccount:    s.AlicloudImageShareAccounts,
-				RemoveAccount: s.AlicloudImageUNShareAccounts,
-			})
-		if err != nil {
-			state.Put("error", err)
-			ui.Say(fmt.Sprintf("Failed modifying image share permissions: %s", err))
-			return multistep.ActionHalt
-		}
-	}
-	return multistep.ActionContinue
-}
-
-func (s *setpShareAlicloudImage) Cleanup(state multistep.StateBag) {
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-	if cancelled || halted {
-		ui := state.Get("ui").(packer.Ui)
-		client := state.Get("client").(*ecs.Client)
-		alicloudImages := state.Get("alicloudimages").(map[string]string)
-		ui.Say("Restoring image share permission because cancellations or error...")
-		for copiedRegion, copiedImageId := range alicloudImages {
-			err := client.ModifyImageSharePermission(
-				&ecs.ModifyImageSharePermissionArgs{
-					RegionId:      common.Region(copiedRegion),
-					ImageId:       copiedImageId,
-					AddAccount:    s.AlicloudImageUNShareAccounts,
-					RemoveAccount: s.AlicloudImageShareAccounts,
-				})
-			if err != nil {
-				ui.Say(fmt.Sprintf("Restoring image share permission failed: %s", err))
-			}
-		}
-	}
-}

builder/alicloud/ecs/step_stop_instance.go

@@ -1,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
@@ -121,8 +122,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	var warns []string
 
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(&b.config.ctx)...)
-	errs = packer.MultiErrorAppend(errs,
-		b.config.AMIConfig.Prepare(&b.config.AccessConfig, &b.config.ctx)...)
+	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(&b.config.ctx)...)
 
 	for _, mounts := range b.config.ChrootMounts {
 		if len(mounts) != 3 {
@@ -182,7 +182,12 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		return nil, errors.New("The amazon-chroot builder only works on Linux environments.")
 	}
 
-	session, err := b.config.Session()
+	config, err := b.config.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	session, err := session.NewSession(config)
 	if err != nil {
 		return nil, err
 	}
@@ -214,10 +219,9 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	if !b.config.FromScratch {
 		steps = append(steps,
 			&awscommon.StepSourceAMIInfo{
-				SourceAmi:                b.config.SourceAmi,
-				EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-				EnableAMIENASupport:      b.config.AMIENASupport,
-				AmiFilters:               b.config.SourceAmiFilter,
+				SourceAmi:          b.config.SourceAmi,
+				EnhancedNetworking: b.config.AMIEnhancedNetworking,
+				AmiFilters:         b.config.SourceAmiFilter,
 			},
 			&StepCheckRootDevice{},
 		)
@@ -247,29 +251,22 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&StepEarlyCleanup{},
 		&StepSnapshot{},
 		&awscommon.StepDeregisterAMI{
-			AccessConfig:        &b.config.AccessConfig,
 			ForceDeregister:     b.config.AMIForceDeregister,
 			ForceDeleteSnapshot: b.config.AMIForceDeleteSnapshot,
 			AMIName:             b.config.AMIName,
-			Regions:             b.config.AMIRegions,
 		},
 		&StepRegisterAMI{
-			RootVolumeSize:           b.config.RootVolumeSize,
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
+			RootVolumeSize: b.config.RootVolumeSize,
 		},
 		&awscommon.StepCreateEncryptedAMICopy{
 			KeyID:             b.config.AMIKmsKeyId,
 			EncryptBootVolume: b.config.AMIEncryptBootVolume,
 			Name:              b.config.AMIName,
-			AMIMappings:       b.config.AMIBlockDevices.AMIMappings,
 		},
 		&awscommon.StepAMIRegionCopy{
-			AccessConfig:      &b.config.AccessConfig,
-			Regions:           b.config.AMIRegions,
-			RegionKeyIds:      b.config.AMIRegionKMSKeyIDs,
-			EncryptBootVolume: b.config.AMIEncryptBootVolume,
-			Name:              b.config.AMIName,
+			AccessConfig: &b.config.AccessConfig,
+			Regions:      b.config.AMIRegions,
+			Name:         b.config.AMIName,
 		},
 		&awscommon.StepModifyAMIAttributes{
 			Description:    b.config.AMIDescription,

builder/amazon/chroot/builder_test.go

@@ -3,14 +3,13 @@ package chroot
 import (
 	"testing"
 
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/packer"
 )
 
 func testConfig() map[string]interface{} {
 	return map[string]interface{}{
 		"ami_name":   "foo",
 		"source_ami": "foo",
-		"region":     "us-east-1",
 	}
 }
 

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

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

@@ -3,9 +3,9 @@ package chroot
 import (
 	"fmt"
 
-	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/post-processor/shell-local"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/post-processor/shell-local"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 func RunLocalCommands(commands []string, wrappedCommand CommandWrapper, ctx interpolate.Context, ui packer.Ui) error {

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

@@ -3,8 +3,8 @@ package chroot
 import (
 	"log"
 
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepChrootProvision provisions the instance within a chroot.

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

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 {

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,8 +1,8 @@
 package chroot
 
 import (
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type postMountCommandsData struct {

builder/amazon/chroot/step_pre_mount_commands.go

@@ -1,8 +1,8 @@
 package chroot
 
 import (
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type preMountCommandsData struct {

builder/amazon/chroot/step_prepare_device.go

@@ -5,8 +5,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/hashicorp/packer/packer"
 	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepPrepareDevice finds an available device and sets it.

builder/amazon/chroot/step_register_ami.go

@@ -5,16 +5,14 @@ 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 {
@@ -77,12 +75,11 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 		registerOpts = buildRegisterOpts(config, image, newMappings)
 	}
 
-	if s.EnableAMISriovNetSupport {
+	if config.AMIEnhancedNetworking {
 		// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
 		// As of February 2017, this applies to C3, C4, D2, I2, R3, and M4 (excluding m4.16xlarge)
 		registerOpts.SriovNetSupport = aws.String("simple")
-	}
-	if s.EnableAMIENASupport {
+
 		// Set EnaSupport to true
 		// As of February 2017, this applies to C5, I3, P2, R4, X1, and m4.16xlarge
 		registerOpts.EnaSupport = aws.Bool(true)

builder/amazon/chroot/step_snapshot.go

@@ -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.

builder/amazon/common/access_config.go

@@ -2,110 +2,84 @@ package common
 
 import (
 	"fmt"
-	"log"
-	"os"
-	"time"
+	"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/go-cleanhttp"
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 // AccessConfig is for common configuration related to AWS access
 type AccessConfig struct {
-	AccessKey         string `mapstructure:"access_key"`
-	CustomEndpointEc2 string `mapstructure:"custom_endpoint_ec2"`
-	MFACode           string `mapstructure:"mfa_code"`
-	ProfileName       string `mapstructure:"profile"`
-	RawRegion         string `mapstructure:"region"`
-	SecretKey         string `mapstructure:"secret_key"`
-	SkipValidation    bool   `mapstructure:"skip_region_validation"`
-	Token             string `mapstructure:"token"`
-	session           *session.Session
+	AccessKey      string `mapstructure:"access_key"`
+	SecretKey      string `mapstructure:"secret_key"`
+	RawRegion      string `mapstructure:"region"`
+	SkipValidation bool   `mapstructure:"skip_region_validation"`
+	Token          string `mapstructure:"token"`
+	ProfileName    string `mapstructure:"profile"`
 }
 
 // Config returns a valid aws.Config object for access to AWS services, or
 // an error if the authentication and region couldn't be resolved
-func (c *AccessConfig) Session() (*session.Session, error) {
-	if c.session != nil {
-		return c.session, nil
-	}
+func (c *AccessConfig) Config() (*aws.Config, error) {
+	var creds *credentials.Credentials
 
-	config := aws.NewConfig().WithMaxRetries(11).WithCredentialsChainVerboseErrors(true)
-
-	if c.ProfileName != "" {
-		if err := os.Setenv("AWS_PROFILE", c.ProfileName); err != nil {
-			return nil, fmt.Errorf("Set env error: %s", err)
-		}
-	}
-
-	if c.RawRegion != "" {
-		config = config.WithRegion(c.RawRegion)
-	} else if region := c.metadataRegion(); region != "" {
-		config = config.WithRegion(region)
-	}
-
-	if c.CustomEndpointEc2 != "" {
-		config = config.WithEndpoint(c.CustomEndpointEc2)
-	}
-
-	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
-		}
-	}
-
-	if sess, err := session.NewSessionWithOptions(opts); err != nil {
+	region, err := c.Region()
+	if err != nil {
 		return nil, err
-	} else if *sess.Config.Region == "" {
-		return nil, fmt.Errorf("Could not find AWS region, make sure it's set.")
-	} else {
-		log.Printf("Found region %s", *sess.Config.Region)
-		c.session = sess
 	}
-
-	return c.session, nil
+	config := aws.NewConfig().WithRegion(region).WithMaxRetries(11)
+	if c.ProfileName != "" {
+		profile, err := NewFromProfile(c.ProfileName)
+		if err != nil {
+			return nil, err
+		}
+		creds, err = profile.CredentialsFromProfile(config)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		creds = credentials.NewChainCredentials([]credentials.Provider{
+			&credentials.StaticProvider{Value: credentials.Value{
+				AccessKeyID:     c.AccessKey,
+				SecretAccessKey: c.SecretKey,
+				SessionToken:    c.Token,
+			}},
+			&credentials.EnvProvider{},
+			&credentials.SharedCredentialsProvider{Filename: "", Profile: ""},
+			&ec2rolecreds.EC2RoleProvider{
+				Client: ec2metadata.New(session.New(config)),
+			},
+		})
+	}
+	return config.WithCredentials(creds), nil
 }
 
-// metadataRegion returns the region from the metadata service
-func (c *AccessConfig) metadataRegion() string {
-
-	client := cleanhttp.DefaultClient()
-
-	// Keep the default timeout (100ms) low as we don't want to wait in non-EC2 environments
-	client.Timeout = 100 * time.Millisecond
-	ec2meta := ec2metadata.New(session.New(), &aws.Config{
-		HTTPClient: client,
-	})
-	region, err := ec2meta.Region()
-	if err != nil {
-		log.Println("Error getting region from metadata service, "+
-			"probably because we're not running on AWS.", err)
-		return ""
+// 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)
+			}
+		}
+		return c.RawRegion, nil
 	}
-	return region
+
+	md, err := GetInstanceMetaData("placement/availability-zone")
+	if err != nil {
+		return "", err
+	}
+
+	region := strings.TrimRightFunc(string(md), unicode.IsLetter)
+	return region, nil
 }
 
 func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error {
@@ -116,5 +90,30 @@ func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error {
 		}
 	}
 
-	return errs
+	if len(errs) > 0 {
+		return errs
+	}
+
+	return nil
+}
+
+func GetInstanceMetaData(path string) (contents []byte, err error) {
+	url := "http://169.254.169.254/latest/meta-data/" + path
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		err = fmt.Errorf("Code %d returned for url %s", resp.StatusCode, url)
+		return
+	}
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	return body, err
 }

builder/amazon/common/ami_config.go

@@ -2,9 +2,8 @@ package common
 
 import (
 	"fmt"
-	"log"
 
-	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 // AMIConfig is for common configuration related to creating AMIs.
@@ -18,44 +17,22 @@ type AMIConfig struct {
 	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"`
+	AMIEnhancedNetworking   bool              `mapstructure:"enhanced_networking"`
 	AMIForceDeregister      bool              `mapstructure:"force_deregister"`
 	AMIForceDeleteSnapshot  bool              `mapstructure:"force_delete_snapshot"`
 	AMIEncryptBootVolume    bool              `mapstructure:"encrypt_boot"`
 	AMIKmsKeyId             string            `mapstructure:"kms_key_id"`
-	AMIRegionKMSKeyIDs      map[string]string `mapstructure:"region_kms_key_ids"`
 	SnapshotTags            map[string]string `mapstructure:"snapshot_tags"`
 	SnapshotUsers           []string          `mapstructure:"snapshot_users"`
 	SnapshotGroups          []string          `mapstructure:"snapshot_groups"`
 }
 
-func stringInSlice(s []string, searchstr string) bool {
-	for _, item := range s {
-		if item == searchstr {
-			return true
-		}
-	}
-	return false
-}
-
-func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context) []error {
+func (c *AMIConfig) Prepare(ctx *interpolate.Context) []error {
 	var errs []error
-
 	if c.AMIName == "" {
 		errs = append(errs, fmt.Errorf("ami_name must be specified"))
 	}
 
-	// Make sure that if we have region_kms_key_ids defined,
-	//  the regions in region_kms_key_ids are also in ami_regions
-	if len(c.AMIRegionKMSKeyIDs) > 0 {
-		for kmsKeyRegion := range c.AMIRegionKMSKeyIDs {
-			if !stringInSlice(c.AMIRegions, kmsKeyRegion) {
-				errs = append(errs, fmt.Errorf("Region %s is in region_kms_key_ids but not in ami_regions", kmsKeyRegion))
-			}
-		}
-	}
-
 	if len(c.AMIRegions) > 0 {
 		regionSet := make(map[string]struct{})
 		regions := make([]string, 0, len(c.AMIRegions))
@@ -73,22 +50,10 @@ func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context
 				// 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))
-				}
-			}
-			if (accessConfig != nil) && (region == accessConfig.RawRegion) {
-				// make sure we don't try to copy to the region we originally
-				// create the AMI in.
-				log.Printf("Cannot copy AMI to AWS session region '%s', deleting it from `ami_regions`.", region)
-				continue
-			}
 			regions = append(regions, region)
 		}
 
@@ -99,29 +64,8 @@ func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context
 		errs = append(errs, fmt.Errorf("Cannot share AMI with encrypted boot volume"))
 	}
 
-	if len(c.SnapshotUsers) > 0 {
-		if len(c.AMIKmsKeyId) == 0 && c.AMIEncryptBootVolume {
-			errs = append(errs, fmt.Errorf("Cannot share snapshot encrypted with default KMS key"))
-		}
-		if len(c.AMIRegionKMSKeyIDs) > 0 {
-			for _, kmsKey := range c.AMIRegionKMSKeyIDs {
-				if len(kmsKey) == 0 {
-					errs = append(errs, fmt.Errorf("Cannot share snapshot encrypted with default KMS key"))
-				}
-			}
-		}
-	}
-
-	if len(c.AMIName) < 3 || len(c.AMIName) > 128 {
-		errs = append(errs, fmt.Errorf("ami_name must be between 3 and 128 characters long"))
-	}
-
-	if c.AMIName != templateCleanAMIName(c.AMIName) {
-		errs = append(errs, fmt.Errorf("AMIName should only contain "+
-			"alphanumeric characters, parentheses (()), square brackets ([]), spaces "+
-			"( ), periods (.), slashes (/), dashes (-), single quotes ('), at-signs "+
-			"(@), or underscores(_). You can use the `clean_ami_name` template "+
-			"filter to automatically clean your ami name."))
+	if len(c.SnapshotUsers) > 0 && len(c.AMIKmsKeyId) == 0 && c.AMIEncryptBootVolume {
+		errs = append(errs, fmt.Errorf("Cannot share snapshot encrypted with default KMS key"))
 	}
 
 	if len(errs) > 0 {

builder/amazon/common/ami_config_test.go

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

builder/amazon/common/artifact.go

@@ -9,7 +9,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/packer"
 )
 
 // Artifact is an artifact implementation that contains built AMIs.
@@ -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{} {

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

builder/amazon/common/cli_config.go

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

@@ -3,14 +3,13 @@ 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)$")
@@ -41,7 +40,6 @@ type RunConfig struct {
 	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"`
@@ -54,7 +52,6 @@ type RunConfig struct {
 	Comm           communicator.Config `mapstructure:",squash"`
 	SSHKeyPairName string              `mapstructure:"ssh_keypair_name"`
 	SSHPrivateIp   bool                `mapstructure:"ssh_private_ip"`
-	SSHInterface   string              `mapstructure:"ssh_interface"`
 }
 
 func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
@@ -78,29 +75,11 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 
 	// Validation
 	errs := c.Comm.Prepare(ctx)
-	if c.SSHPrivateIp && c.SSHInterface != "" {
-		errs = append(errs, errors.New("ssh_interface and ssh_private_ip should not both be specified"))
-	}
-
-	// Legacy configurable
-	if c.SSHPrivateIp {
-		c.SSHInterface = "private_ip"
-	}
-
-	// Valadating ssh_interface
-	if c.SSHInterface != "public_ip" &&
-		c.SSHInterface != "private_ip" &&
-		c.SSHInterface != "public_dns" &&
-		c.SSHInterface != "private_dns" &&
-		c.SSHInterface != "" {
-		errs = append(errs, errors.New(fmt.Sprintf("Unknown interface type: %s", c.SSHInterface)))
-	}
-
 	if c.SSHKeyPairName != "" {
 		if c.Comm.Type == "winrm" && c.Comm.WinRMPassword == "" && c.Comm.SSHPrivateKey == "" {
-			errs = append(errs, errors.New("ssh_private_key_file must be provided to retrieve the winrm password when using ssh_keypair_name."))
+			errs = append(errs, errors.New("A private_key_file must be provided to retrieve the winrm password when using ssh_keypair_name."))
 		} else if c.Comm.SSHPrivateKey == "" && !c.Comm.SSHAgentAuth {
-			errs = append(errs, errors.New("ssh_private_key_file must be provided or ssh_agent_auth enabled when ssh_keypair_name is specified."))
+			errs = append(errs, errors.New("A private_key_file must be provided or ssh_agent_auth enabled when ssh_keypair_name is specified."))
 		}
 	}
 
@@ -136,14 +115,6 @@ 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) {
@@ -152,7 +123,3 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 
 	return errs
 }
-
-func (c *RunConfig) IsSpotInstance() bool {
-	return c.SpotPrice != "" && c.SpotPrice != "0"
-}

builder/amazon/common/run_config_test.go

@@ -6,7 +6,7 @@ import (
 	"regexp"
 	"testing"
 
-	"github.com/hashicorp/packer/helper/communicator"
+	"github.com/mitchellh/packer/helper/communicator"
 )
 
 func init() {

builder/amazon/common/ssh.go

@@ -8,8 +8,8 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	packerssh "github.com/hashicorp/packer/communicator/ssh"
 	"github.com/mitchellh/multistep"
+	packerssh "github.com/mitchellh/packer/communicator/ssh"
 	"golang.org/x/crypto/ssh"
 	"golang.org/x/crypto/ssh/agent"
 )
@@ -25,40 +25,21 @@ var (
 
 // SSHHost returns a function that can be given to the SSH communicator
 // for determining the SSH address based on the instance DNS name.
-func SSHHost(e ec2Describer, sshInterface string) func(multistep.StateBag) (string, error) {
+func SSHHost(e ec2Describer, private bool) func(multistep.StateBag) (string, error) {
 	return func(state multistep.StateBag) (string, error) {
 		const tries = 2
 		// <= with current structure to check result of describing `tries` times
 		for j := 0; j <= tries; j++ {
 			var host string
 			i := state.Get("instance").(*ec2.Instance)
-			if sshInterface != "" {
-				switch sshInterface {
-				case "public_ip":
-					if i.PublicIpAddress != nil {
-						host = *i.PublicIpAddress
-					}
-				case "private_ip":
-					if i.PrivateIpAddress != nil {
-						host = *i.PrivateIpAddress
-					}
-				case "public_dns":
-					if i.PublicDnsName != nil {
-						host = *i.PublicDnsName
-					}
-				case "private_dns":
-					if i.PrivateDnsName != nil {
-						host = *i.PrivateDnsName
-					}
-				default:
-					panic(fmt.Sprintf("Unknown interface type: %s", sshInterface))
-				}
-			} else if i.VpcId != nil && *i.VpcId != "" {
-				if i.PublicIpAddress != nil && *i.PublicIpAddress != "" {
+			if i.VpcId != nil && *i.VpcId != "" {
+				if i.PublicIpAddress != nil && *i.PublicIpAddress != "" && !private {
 					host = *i.PublicIpAddress
 				} else if i.PrivateIpAddress != nil && *i.PrivateIpAddress != "" {
 					host = *i.PrivateIpAddress
 				}
+			} else if private && i.PrivateIpAddress != nil && *i.PrivateIpAddress != "" {
+				host = *i.PrivateIpAddress
 			} else if i.PublicDnsName != nil && *i.PublicDnsName != "" {
 				host = *i.PublicDnsName
 			}
@@ -82,7 +63,7 @@ func SSHHost(e ec2Describer, sshInterface string) func(multistep.StateBag) (stri
 			time.Sleep(sshHostSleepDuration)
 		}
 
-		return "", errors.New("couldn't determine address for instance")
+		return "", errors.New("couldn't determine IP address for instance")
 	}
 }
 
@@ -107,7 +88,6 @@ func SSHConfig(useAgent bool, username, password string) func(multistep.StateBag
 				Auth: []ssh.AuthMethod{
 					ssh.PublicKeysCallback(agent.NewClient(sshAgent).Signers),
 				},
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
 			}, nil
 		}
 
@@ -123,13 +103,11 @@ func SSHConfig(useAgent bool, username, password string) func(multistep.StateBag
 				Auth: []ssh.AuthMethod{
 					ssh.PublicKeys(signer),
 				},
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
 			}, nil
 
 		} else {
 			return &ssh.ClientConfig{
-				User:            username,
-				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+				User: username,
 				Auth: []ssh.AuthMethod{
 					ssh.Password(password),
 					ssh.KeyboardInteractive(

builder/amazon/common/ssh_test.go

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

builder/amazon/common/step_ami_region_copy.go

@@ -5,18 +5,17 @@ import (
 	"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 {
@@ -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,13 +44,10 @@ 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, snapshotIds, err := amiRegionCopy(state, s.AccessConfig, s.Name, ami, region, *ec2conn.Config.Region)
+
 			lock.Lock()
 			defer lock.Unlock()
 			amis[region] = id
@@ -85,29 +80,26 @@ func (s *StepAMIRegionCopy) Cleanup(state multistep.StateBag) {
 // amiRegionCopy does a copy for the given AMI to the target region and
 // returns the resulting ID and snapshot IDs, or error.
 func amiRegionCopy(state multistep.StateBag, config *AccessConfig, name string, imageId string,
-	target string, source string, keyID string) (string, []string, error) {
+	target string, source string) (string, []string, error) {
 	snapshotIds := []string{}
-	isEncrypted := false
 
 	// Connect to the region where the AMI will be copied to
-	session, err := config.Session()
+	awsConfig, err := config.Config()
 	if err != nil {
 		return "", snapshotIds, err
 	}
-	// if we've provided a map of key ids to regions, use those keys.
-	if len(keyID) > 0 {
-		isEncrypted = true
+	awsConfig.Region = aws.String(target)
+
+	session, err := session.NewSession(awsConfig)
+	if err != nil {
+		return "", snapshotIds, err
 	}
-	regionconn := ec2.New(session.Copy(&aws.Config{
-		Region: aws.String(target)},
-	))
+	regionconn := ec2.New(session)
 
 	resp, err := regionconn.CopyImage(&ec2.CopyImageInput{
 		SourceRegion:  &source,
 		SourceImageId: &imageId,
 		Name:          &name,
-		Encrypted:     aws.Bool(isEncrypted),
-		KmsKeyId:      aws.String(keyID),
 	})
 
 	if err != nil {

builder/amazon/common/step_create_tags.go

@@ -7,10 +7,10 @@ import (
 	"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"
+	retry "github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 type StepCreateTags struct {
@@ -105,7 +105,7 @@ func (s *StepCreateTags) Run(state multistep.StateBag) multistep.StepAction {
 		ReportTags(ui, snapshotTags)
 
 		// Retry creating tags for about 2.5 minutes
-		err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
+		err = retry.Retry(0.2, 30, 11, func() (bool, error) {
 			// Tag images and snapshots
 			_, err := regionconn.CreateTags(&ec2.CreateTagsInput{
 				Resources: resourceIds,
@@ -166,17 +166,13 @@ func ConvertToEC2Tags(tags map[string]string, region, sourceAmiId string, ctx in
 			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),
+			Key:   aws.String(key),
 			Value: aws.String(interpolatedValue),
 		})
 	}

builder/amazon/common/step_deregister_ami.go

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

builder/amazon/common/step_encrypted_ami.go

@@ -6,8 +6,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"
 )
 
 type StepCreateEncryptedAMICopy struct {
@@ -15,7 +15,6 @@ type StepCreateEncryptedAMICopy struct {
 	KeyID             string
 	EncryptBootVolume bool
 	Name              string
-	AMIMappings       []BlockDevice
 }
 
 func (s *StepCreateEncryptedAMICopy) Run(state multistep.StateBag) multistep.StepAction {
@@ -37,14 +36,14 @@ func (s *StepCreateEncryptedAMICopy) Run(state multistep.StateBag) multistep.Ste
 	var region, id string
 	if amis != nil {
 		for region, id = range amis {
-			break // There is only ever one region:ami pair in this map
+			break // Only get the first
 		}
 	}
 
 	ui.Say(fmt.Sprintf("Copying AMI: %s(%s)", region, id))
 
 	if kmsKeyId != "" {
-		ui.Say(fmt.Sprintf("Encrypting with KMS Key ID: %s", kmsKeyId))
+		ui.Say(fmt.Sprintf("Encypting with KMS Key ID: %s", kmsKeyId))
 	}
 
 	copyOpts := &ec2.CopyImageInput{
@@ -117,18 +116,9 @@ func (s *StepCreateEncryptedAMICopy) Run(state multistep.StateBag) multistep.Ste
 	ui.Say("Deleting unencrypted snapshots")
 	snapshots := state.Get("snapshots").(map[string][]string)
 
-OuterLoop:
 	for _, blockDevice := range unencImage.BlockDeviceMappings {
 		if blockDevice.Ebs != nil && blockDevice.Ebs.SnapshotId != nil {
-			// If this packer run didn't create it, then don't delete it
-			for _, origDevice := range s.AMIMappings {
-				if origDevice.SnapshotId == *blockDevice.Ebs.SnapshotId {
-					ui.Message(fmt.Sprintf("Keeping Snapshot ID: %s", *blockDevice.Ebs.SnapshotId))
-					continue OuterLoop
-				}
-			}
-
-			ui.Message(fmt.Sprintf("Deleting Snapshot ID: %s", *blockDevice.Ebs.SnapshotId))
+			ui.Message(fmt.Sprintf("Snapshot ID: %s", *blockDevice.Ebs.SnapshotId))
 			deleteSnapOpts := &ec2.DeleteSnapshotInput{
 				SnapshotId: aws.String(*blockDevice.Ebs.SnapshotId),
 			}
@@ -171,7 +161,7 @@ func (s *StepCreateEncryptedAMICopy) Cleanup(state multistep.StateBag) {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
-	ui.Say("Deregistering the AMI because cancellation or error...")
+	ui.Say("Deregistering the AMI because cancelation or error...")
 	deregisterOpts := &ec2.DeregisterImageInput{ImageId: s.image.ImageId}
 	if _, err := ec2conn.DeregisterImage(deregisterOpts); err != nil {
 		ui.Error(fmt.Sprintf("Error deregistering AMI, may still be around: %s", err))

builder/amazon/common/step_get_password.go

@@ -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,8 +7,8 @@ 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 {
@@ -19,7 +19,7 @@ type StepKeyPair struct {
 	KeyPairName          string
 	PrivateKeyFile       string
 
-	doCleanup bool
+	keyName string
 }
 
 func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction {
@@ -67,10 +67,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 +104,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 != "" || (s.KeyPairName == "" && s.keyName == "") {
 		return
 	}
 
@@ -112,10 +116,10 @@ func (s *StepKeyPair) Cleanup(state multistep.StateBag) {
 
 	// Remove the keypair
 	ui.Say("Deleting temporary keypair...")
-	_, err := ec2conn.DeleteKeyPair(&ec2.DeleteKeyPairInput{KeyName: &s.TemporaryKeyPairName})
+	_, err := ec2conn.DeleteKeyPair(&ec2.DeleteKeyPairInput{KeyName: &s.keyName})
 	if err != nil {
 		ui.Error(fmt.Sprintf(
-			"Error cleaning up keypair. Please delete the key manually: %s", s.TemporaryKeyPairName))
+			"Error cleaning up keypair. Please delete the key manually: %s", s.keyName))
 	}
 
 	// Also remove the physical key if we're debugging.

builder/amazon/common/step_modify_ami_attributes.go

@@ -6,9 +6,9 @@ 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"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 type StepModifyAMIAttributes struct {

builder/amazon/common/step_modify_ebs_instance.go

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

builder/amazon/common/step_pre_validate.go

@@ -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,7 +26,7 @@ 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{{
 			Name:   aws.String("name"),

builder/amazon/common/step_run_source_instance.go

@@ -5,13 +5,15 @@ 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"
+	"github.com/mitchellh/packer/template/interpolate"
 )
 
 type StepRunSourceInstance struct {
@@ -25,14 +27,16 @@ type StepRunSourceInstance struct {
 	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
+	instanceId  string
+	spotRequest *ec2.SpotInstanceRequest
 }
 
 func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepAction {
@@ -77,8 +81,201 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 		return multistep.ActionHalt
 	}
 
+	spotPrice := s.SpotPrice
+	availabilityZone := s.AvailabilityZone
+	if spotPrice == "auto" {
+		ui.Message(fmt.Sprintf(
+			"Finding spot price for %s %s...",
+			s.SpotPriceProduct, s.InstanceType))
+
+		// Detect the spot price
+		startTime := time.Now().Add(-1 * time.Hour)
+		resp, err := ec2conn.DescribeSpotPriceHistory(&ec2.DescribeSpotPriceHistoryInput{
+			InstanceTypes:       []*string{&s.InstanceType},
+			ProductDescriptions: []*string{&s.SpotPriceProduct},
+			AvailabilityZone:    &s.AvailabilityZone,
+			StartTime:           &startTime,
+		})
+		if err != nil {
+			err := fmt.Errorf("Error finding spot price: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		var price float64
+		for _, history := range resp.SpotPriceHistory {
+			log.Printf("[INFO] Candidate spot price: %s", *history.SpotPrice)
+			current, err := strconv.ParseFloat(*history.SpotPrice, 64)
+			if err != nil {
+				log.Printf("[ERR] Error parsing spot price: %s", err)
+				continue
+			}
+			if price == 0 || current < price {
+				price = current
+				if s.AvailabilityZone == "" {
+					availabilityZone = *history.AvailabilityZone
+				}
+			}
+		}
+		if price == 0 {
+			err := fmt.Errorf("No candidate spot prices found!")
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		} else {
+			// Add 0.5 cents to minimum spot bid to ensure capacity will be available
+			// Avoids price-too-low error in active markets which can fluctuate
+			price = price + 0.005
+		}
+
+		spotPrice = strconv.FormatFloat(price, 'f', -1, 64)
+	}
+
 	var instanceId string
 
+	if spotPrice == "" || spotPrice == "0" {
+		runOpts := &ec2.RunInstancesInput{
+			ImageId:             &s.SourceAMI,
+			InstanceType:        &s.InstanceType,
+			UserData:            &userData,
+			MaxCount:            aws.Int64(1),
+			MinCount:            aws.Int64(1),
+			IamInstanceProfile:  &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
+			BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
+			Placement:           &ec2.Placement{AvailabilityZone: &s.AvailabilityZone},
+			EbsOptimized:        &s.EbsOptimized,
+		}
+
+		if keyName != "" {
+			runOpts.KeyName = &keyName
+		}
+
+		if s.SubnetId != "" && s.AssociatePublicIpAddress {
+			runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
+				{
+					DeviceIndex:              aws.Int64(0),
+					AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
+					SubnetId:                 &s.SubnetId,
+					Groups:                   securityGroupIds,
+					DeleteOnTermination:      aws.Bool(true),
+				},
+			}
+		} else {
+			runOpts.SubnetId = &s.SubnetId
+			runOpts.SecurityGroupIds = securityGroupIds
+		}
+
+		if s.ExpectedRootDevice == "ebs" {
+			runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior
+		}
+
+		runResp, err := ec2conn.RunInstances(runOpts)
+		if err != nil {
+			err := fmt.Errorf("Error launching source instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		instanceId = *runResp.Instances[0].InstanceId
+	} else {
+		ui.Message(fmt.Sprintf(
+			"Requesting spot instance '%s' for: %s",
+			s.InstanceType, spotPrice))
+
+		runOpts := &ec2.RequestSpotLaunchSpecification{
+			ImageId:            &s.SourceAMI,
+			InstanceType:       &s.InstanceType,
+			UserData:           &userData,
+			IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
+			Placement: &ec2.SpotPlacement{
+				AvailabilityZone: &availabilityZone,
+			},
+			BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
+			EbsOptimized:        &s.EbsOptimized,
+		}
+
+		if s.SubnetId != "" && s.AssociatePublicIpAddress {
+			runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
+				{
+					DeviceIndex:              aws.Int64(0),
+					AssociatePublicIpAddress: &s.AssociatePublicIpAddress,
+					SubnetId:                 &s.SubnetId,
+					Groups:                   securityGroupIds,
+					DeleteOnTermination:      aws.Bool(true),
+				},
+			}
+		} else {
+			runOpts.SubnetId = &s.SubnetId
+			runOpts.SecurityGroupIds = securityGroupIds
+		}
+
+		if keyName != "" {
+			runOpts.KeyName = &keyName
+		}
+
+		runSpotResp, err := ec2conn.RequestSpotInstances(&ec2.RequestSpotInstancesInput{
+			SpotPrice:           &spotPrice,
+			LaunchSpecification: runOpts,
+		})
+		if err != nil {
+			err := fmt.Errorf("Error launching source spot instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		s.spotRequest = runSpotResp.SpotInstanceRequests[0]
+
+		spotRequestId := s.spotRequest.SpotInstanceRequestId
+		ui.Message(fmt.Sprintf("Waiting for spot request (%s) to become active...", *spotRequestId))
+		stateChange := StateChangeConf{
+			Pending:   []string{"open"},
+			Target:    "active",
+			Refresh:   SpotRequestStateRefreshFunc(ec2conn, *spotRequestId),
+			StepState: state,
+		}
+		_, err = WaitForState(&stateChange)
+		if err != nil {
+			err := fmt.Errorf("Error waiting for spot request (%s) to become ready: %s", *spotRequestId, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		spotResp, err := ec2conn.DescribeSpotInstanceRequests(&ec2.DescribeSpotInstanceRequestsInput{
+			SpotInstanceRequestIds: []*string{spotRequestId},
+		})
+		if err != nil {
+			err := fmt.Errorf("Error finding spot request (%s): %s", *spotRequestId, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		instanceId = *spotResp.SpotInstanceRequests[0].InstanceId
+	}
+
+	// Set the instance ID so that the cleanup works properly
+	s.instanceId = instanceId
+
+	ui.Message(fmt.Sprintf("Instance ID: %s", instanceId))
+	ui.Say(fmt.Sprintf("Waiting for instance (%v) to become ready...", instanceId))
+	stateChange := StateChangeConf{
+		Pending:   []string{"pending"},
+		Target:    "running",
+		Refresh:   InstanceStateRefreshFunc(ec2conn, instanceId),
+		StepState: state,
+	}
+	latestInstance, err := WaitForState(&stateChange)
+	if err != nil {
+		err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", instanceId, err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	instance := latestInstance.(*ec2.Instance)
+
 	ui.Say("Adding tags to source instance")
 	if _, exists := s.Tags["Name"]; !exists {
 		s.Tags["Name"] = "Packer Builder"
@@ -91,110 +288,19 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 		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,
-		}
-
-		tagSpecs = append(tagSpecs, runTags)
-	}
-
-	if len(volTags) > 0 {
-		runVolTags := &ec2.TagSpecification{
-			ResourceType: aws.String("volume"),
-			Tags:         volTags,
-		}
-
-		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),
-			},
-		}
-	} else {
-		runOpts.SubnetId = &s.SubnetId
-		runOpts.SecurityGroupIds = securityGroupIds
-	}
-
-	if s.ExpectedRootDevice == "ebs" {
-		runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior
-	}
-
-	runResp, err := ec2conn.RunInstances(runOpts)
-	if err != nil {
-		err := fmt.Errorf("Error launching source instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	instanceId = *runResp.Instances[0].InstanceId
-
-	// Set the instance ID so that the cleanup works properly
-	s.instanceId = instanceId
-
-	ui.Message(fmt.Sprintf("Instance ID: %s", instanceId))
-	ui.Say(fmt.Sprintf("Waiting for instance (%v) to become ready...", instanceId))
-
-	describeInstanceStatus := &ec2.DescribeInstanceStatusInput{
-		InstanceIds: []*string{aws.String(instanceId)},
-	}
-	if err := ec2conn.WaitUntilInstanceStatusOk(describeInstanceStatus); err != nil {
-		err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", instanceId, err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	r, err := ec2conn.DescribeInstances(&ec2.DescribeInstancesInput{
-		InstanceIds: []*string{aws.String(instanceId)},
+	_, err = ec2conn.CreateTags(&ec2.CreateTagsInput{
+		Tags:      ec2Tags,
+		Resources: []*string{instance.InstanceId},
 	})
-	if err != nil || len(r.Reservations) == 0 || len(r.Reservations[0].Instances) == 0 {
-		err := fmt.Errorf("Error finding source instance.")
+	if err != nil {
+		err := fmt.Errorf("Error tagging source instance: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
-	instance := r.Reservations[0].Instances[0]
 
 	if s.Debug {
 		if instance.PublicDnsName != nil && *instance.PublicDnsName != "" {
@@ -220,6 +326,29 @@ 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",
+		}
+
+		_, 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...")

builder/amazon/common/step_run_spot_instance.go

@@ -1,377 +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))
-	describeInstanceStatus := &ec2.DescribeInstanceStatusInput{
-		InstanceIds: []*string{aws.String(instanceId)},
-	}
-	if err := ec2conn.WaitUntilInstanceStatusOk(describeInstanceStatus); err != nil {
-		err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", instanceId, err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	r, err := ec2conn.DescribeInstances(&ec2.DescribeInstancesInput{
-		InstanceIds: []*string{aws.String(instanceId)},
-	})
-	if err != nil || len(r.Reservations) == 0 || len(r.Reservations[0].Instances) == 0 {
-		err := fmt.Errorf("Error finding source instance.")
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	instance := r.Reservations[0].Instances[0]
-
-	// Retry creating tags for about 2.5 minutes
-	err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
-		_, err := ec2conn.CreateTags(&ec2.CreateTagsInput{
-			Tags:      ec2Tags,
-			Resources: []*string{instance.InstanceId},
-		})
-		if err == nil {
-			return true, nil
-		}
-		if awsErr, ok := err.(awserr.Error); ok {
-			if awsErr.Code() == "InvalidInstanceID.NotFound" {
-				return false, nil
-			}
-		}
-		return true, err
-	})
-
-	if err != nil {
-		err := fmt.Errorf("Error tagging source instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	volumeIds := make([]*string, 0)
-	for _, v := range instance.BlockDeviceMappings {
-		if ebs := v.Ebs; ebs != nil {
-			volumeIds = append(volumeIds, ebs.VolumeId)
-		}
-	}
-
-	if len(volumeIds) > 0 && len(s.VolumeTags) > 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,18 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/waiter"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/common/uuid"
-	"github.com/hashicorp/packer/helper/communicator"
-	"github.com/hashicorp/packer/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
 }
@@ -46,23 +45,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 +73,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
 	// 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 {
@@ -154,43 +148,36 @@ func (s *StepSecurityGroup) Cleanup(state multistep.StateBag) {
 }
 
 func waitUntilSecurityGroupExists(c *ec2.EC2, input *ec2.DescribeSecurityGroupsInput) error {
-	ctx := aws.BackgroundContext()
-	w := request.Waiter{
-		Name:        "DescribeSecurityGroups",
+	waiterCfg := waiter.Config{
+		Operation:   "DescribeSecurityGroups",
+		Delay:       15,
 		MaxAttempts: 40,
-		Delay:       request.ConstantWaiterDelay(5 * time.Second),
-		Acceptors: []request.WaiterAcceptor{
+		Acceptors: []waiter.WaitAcceptor{
 			{
-				State:    request.SuccessWaiterState,
-				Matcher:  request.PathWaiterMatch,
+				State:    "success",
+				Matcher:  "path",
 				Argument: "length(SecurityGroups[]) > `0`",
 				Expected: true,
 			},
 			{
-				State:    request.RetryWaiterState,
-				Matcher:  request.ErrorWaiterMatch,
+				State:    "retry",
+				Matcher:  "error",
 				Argument: "",
 				Expected: "InvalidGroup.NotFound",
 			},
 			{
-				State:    request.RetryWaiterState,
-				Matcher:  request.ErrorWaiterMatch,
+				State:    "retry",
+				Matcher:  "error",
 				Argument: "",
 				Expected: "InvalidSecurityGroupID.NotFound",
 			},
 		},
-		Logger: c.Config.Logger,
-		NewRequest: func(opts []request.Option) (*request.Request, error) {
-			var inCpy *ec2.DescribeSecurityGroupsInput
-			if input != nil {
-				tmp := *input
-				inCpy = &tmp
-			}
-			req, _ := c.DescribeSecurityGroupsRequest(inCpy)
-			req.SetContext(ctx)
-			req.ApplyOptions(opts...)
-			return req, nil
-		},
 	}
-	return w.WaitWithContext(ctx)
+
+	w := waiter.Waiter{
+		Client: c,
+		Input:  input,
+		Config: waiterCfg,
+	}
+	return w.Wait()
 }

builder/amazon/common/step_source_ami_info.go

@@ -7,8 +7,8 @@ import (
 	"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,10 +17,9 @@ import (
 // Produces:
 //   source_image *ec2.Image - the source AMI info
 type StepSourceAMIInfo struct {
-	SourceAmi                string
-	EnableAMISriovNetSupport bool
-	EnableAMIENASupport      bool
-	AmiFilters               AmiFilterOptions
+	SourceAmi          string
+	EnhancedNetworking bool
+	AmiFilters         AmiFilterOptions
 }
 
 // Build a slice of AMI filter options from the filters provided.
@@ -104,7 +103,7 @@ func (s *StepSourceAMIInfo) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Enhanced Networking can only be enabled on HVM AMIs.
 	// See http://goo.gl/icuXh5
-	if (s.EnableAMIENASupport || s.EnableAMISriovNetSupport) && *image.VirtualizationType != "hvm" {
+	if s.EnhancedNetworking && *image.VirtualizationType != "hvm" {
 		err := fmt.Errorf("Cannot enable enhanced networking, source AMI '%s' is not HVM", s.SourceAmi)
 		state.Put("error", err)
 		ui.Error(err.Error())

builder/amazon/common/step_stop_ebs_instance.go

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

builder/amazon/common/step_tag_ebs_volumes.go

@@ -0,0 +1,65 @@
+package common
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/template/interpolate"
+)
+
+type StepTagEBSVolumes struct {
+	VolumeRunTags map[string]string
+	Ctx           interpolate.Context
+}
+
+func (s *StepTagEBSVolumes) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	instance := state.Get("instance").(*ec2.Instance)
+	sourceAMI := state.Get("source_image").(*ec2.Image)
+	ui := state.Get("ui").(packer.Ui)
+
+	if len(s.VolumeRunTags) == 0 {
+		return multistep.ActionContinue
+	}
+
+	volumeIds := make([]*string, 0)
+	for _, v := range instance.BlockDeviceMappings {
+		if ebs := v.Ebs; ebs != nil {
+			volumeIds = append(volumeIds, ebs.VolumeId)
+		}
+	}
+
+	if len(volumeIds) == 0 {
+		return multistep.ActionContinue
+	}
+
+	ui.Say("Adding tags to source EBS Volumes")
+	tags, err := ConvertToEC2Tags(s.VolumeRunTags, *ec2conn.Config.Region, *sourceAMI.ImageId, 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
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *StepTagEBSVolumes) Cleanup(state 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
@@ -64,18 +65,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	// Accumulate any errors
 	var errs *packer.MultiError
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(&b.config.ctx)...)
-	errs = packer.MultiErrorAppend(errs,
-		b.config.AMIConfig.Prepare(&b.config.AccessConfig, &b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.BlockDevices.Prepare(&b.config.ctx)...)
+	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(&b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(&b.config.ctx)...)
 
-	if b.config.IsSpotInstance() && (b.config.AMIENASupport || b.config.AMISriovNetSupport) {
-		errs = packer.MultiErrorAppend(errs,
-			fmt.Errorf("Spot instances do not support modification, which is required "+
-				"when either `ena_support` or `sriov_support` are set. Please ensure "+
-				"you use an AMI that already has either SR-IOV or ENA enabled."))
-	}
-
 	if errs != nil && len(errs.Errors) > 0 {
 		return nil, errs
 	}
@@ -85,28 +78,26 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
+	config, err := b.config.Config()
+	if err != nil {
+		return nil, err
+	}
 
-	session, err := b.config.Session()
+	session, err := session.NewSession(config)
 	if err != nil {
 		return nil, err
 	}
 	ec2conn := ec2.New(session)
 
-	// If the subnet is specified but not the VpcId or AZ, try to determine them automatically
-	if b.config.SubnetId != "" && (b.config.AvailabilityZone == "" || b.config.VpcId == "") {
-		log.Printf("[INFO] Finding AZ and VpcId for the given subnet '%s'", b.config.SubnetId)
+	// 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
@@ -116,50 +107,6 @@ 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.IsSpotInstance() {
-		instanceStep = &awscommon.StepRunSpotInstance{
-			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
-			AvailabilityZone:                  b.config.AvailabilityZone,
-			BlockDevices:                      b.config.BlockDevices,
-			Ctx:                               b.config.ctx,
-			Debug:                             b.config.PackerDebug,
-			EbsOptimized:                      b.config.EbsOptimized,
-			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
-			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
-			InstanceType:                      b.config.InstanceType,
-			SourceAMI:                         b.config.SourceAmi,
-			SpotPrice:                         b.config.SpotPrice,
-			SpotPriceProduct:                  b.config.SpotPriceAutoProduct,
-			SubnetId:                          b.config.SubnetId,
-			Tags:                              b.config.RunTags,
-			UserData:                          b.config.UserData,
-			UserDataFile:                      b.config.UserDataFile,
-			VolumeTags:                        b.config.VolumeRunTags,
-		}
-	} else {
-		instanceStep = &awscommon.StepRunSourceInstance{
-			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
-			AvailabilityZone:                  b.config.AvailabilityZone,
-			BlockDevices:                      b.config.BlockDevices,
-			Ctx:                               b.config.ctx,
-			Debug:                             b.config.PackerDebug,
-			EbsOptimized:                      b.config.EbsOptimized,
-			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
-			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
-			InstanceType:                      b.config.InstanceType,
-			SourceAMI:                         b.config.SourceAmi,
-			SubnetId:                          b.config.SubnetId,
-			Tags:                              b.config.RunTags,
-			UserData:                          b.config.UserData,
-			UserDataFile:                      b.config.UserDataFile,
-			VolumeTags:                        b.config.VolumeRunTags,
-		}
-	}
-
 	// Build the steps
 	steps := []multistep.Step{
 		&awscommon.StepPreValidate{
@@ -167,10 +114,9 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			ForceDeregister: b.config.AMIForceDeregister,
 		},
 		&awscommon.StepSourceAMIInfo{
-			SourceAmi:                b.config.SourceAmi,
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
-			AmiFilters:               b.config.SourceAmiFilter,
+			SourceAmi:          b.config.SourceAmi,
+			EnhancedNetworking: b.config.AMIEnhancedNetworking,
+			AmiFilters:         b.config.SourceAmiFilter,
 		},
 		&awscommon.StepKeyPair{
 			Debug:                b.config.PackerDebug,
@@ -184,12 +130,33 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			SecurityGroupIds: b.config.SecurityGroupIds,
 			CommConfig:       &b.config.RunConfig.Comm,
 			VpcId:            b.config.VpcId,
-			TemporarySGSourceCidr: b.config.TemporarySGSourceCidr,
 		},
 		&stepCleanupVolumes{
 			BlockDevices: b.config.BlockDevices,
 		},
-		instanceStep,
+		&awscommon.StepRunSourceInstance{
+			Debug:                    b.config.PackerDebug,
+			ExpectedRootDevice:       "ebs",
+			SpotPrice:                b.config.SpotPrice,
+			SpotPriceProduct:         b.config.SpotPriceAutoProduct,
+			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,
+			Ctx:                      b.config.ctx,
+			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
+		},
+		&awscommon.StepTagEBSVolumes{
+			VolumeRunTags: b.config.VolumeRunTags,
+			Ctx:           b.config.ctx,
+		},
 		&awscommon.StepGetPassword{
 			Debug:   b.config.PackerDebug,
 			Comm:    &b.config.RunConfig.Comm,
@@ -199,7 +166,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			Config: &b.config.RunConfig.Comm,
 			Host: awscommon.SSHHost(
 				ec2conn,
-				b.config.SSHInterface),
+				b.config.SSHPrivateIp),
 			SSHConfig: awscommon.SSHConfig(
 				b.config.RunConfig.Comm.SSHAgentAuth,
 				b.config.RunConfig.Comm.SSHUsername,
@@ -207,33 +174,27 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		},
 		&common.StepProvision{},
 		&awscommon.StepStopEBSBackedInstance{
-			Skip:                b.config.IsSpotInstance(),
+			SpotPrice:           b.config.SpotPrice,
 			DisableStopInstance: b.config.DisableStopInstance,
 		},
 		&awscommon.StepModifyEBSBackedInstance{
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
+			EnableEnhancedNetworking: b.config.AMIEnhancedNetworking,
 		},
 		&awscommon.StepDeregisterAMI{
-			AccessConfig:        &b.config.AccessConfig,
 			ForceDeregister:     b.config.AMIForceDeregister,
 			ForceDeleteSnapshot: b.config.AMIForceDeleteSnapshot,
 			AMIName:             b.config.AMIName,
-			Regions:             b.config.AMIRegions,
 		},
 		&stepCreateAMI{},
 		&awscommon.StepCreateEncryptedAMICopy{
 			KeyID:             b.config.AMIKmsKeyId,
 			EncryptBootVolume: b.config.AMIEncryptBootVolume,
 			Name:              b.config.AMIName,
-			AMIMappings:       b.config.AMIBlockDevices.AMIMappings,
 		},
 		&awscommon.StepAMIRegionCopy{
-			AccessConfig:      &b.config.AccessConfig,
-			Regions:           b.config.AMIRegions,
-			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,

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) {
@@ -254,11 +255,15 @@ 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, err := session.NewSession(config)
+	if err != nil {
+		return nil, err
+	}
 	return ec2.New(session), nil
 }
 

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{} {

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
@@ -37,8 +37,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 {
@@ -77,11 +91,10 @@ 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)
 			}
 		}

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 {
@@ -92,7 +92,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))

builder/amazon/ebs/tags_acc_test.go

@@ -7,9 +7,9 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"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"
 )
 
 type TFBuilder struct {

builder/amazon/ebssurrogate/builder.go

@@ -7,14 +7,16 @@ 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/hashicorp/errwrap"
 	"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"
 )
 
 const BuilderId = "mitchellh.amazon.ebssurrogate"
@@ -64,8 +66,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	var errs *packer.MultiError
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(&b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(&b.config.ctx)...)
-	errs = packer.MultiErrorAppend(errs,
-		b.config.AMIConfig.Prepare(&b.config.AccessConfig, &b.config.ctx)...)
+	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(&b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.BlockDevices.Prepare(&b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.RootDevice.Prepare(&b.config.ctx)...)
 
@@ -84,13 +85,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("no volume with name '%s' is found", b.config.RootDevice.SourceDeviceName))
 	}
 
-	if b.config.IsSpotInstance() && (b.config.AMIENASupport || b.config.AMISriovNetSupport) {
-		errs = packer.MultiErrorAppend(errs,
-			fmt.Errorf("Spot instances do not support modification, which is required "+
-				"when either `ena_support` or `sriov_support` are set. Please ensure "+
-				"you use an AMI that already has either SR-IOV or ENA enabled."))
-	}
-
 	if errs != nil && len(errs.Errors) > 0 {
 		return nil, errs
 	}
@@ -100,27 +94,27 @@ 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()
+	awsConfig, err := b.config.Config()
 	if err != nil {
 		return nil, err
 	}
-	ec2conn := ec2.New(session)
 
-	// If the subnet is specified but not the VpcId or AZ, try to determine them automatically
-	if b.config.SubnetId != "" && (b.config.AvailabilityZone == "" || b.config.VpcId == "") {
-		log.Printf("[INFO] Finding AZ and VpcId for the given subnet '%s'", b.config.SubnetId)
+	awsSession, err := session.NewSession(awsConfig)
+	if err != nil {
+		return nil, errwrap.Wrapf("Error creating AWS Session: {{err}}", err)
+	}
+
+	ec2conn := ec2.New(awsSession)
+
+	// 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
@@ -130,50 +124,6 @@ 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.IsSpotInstance() {
-		instanceStep = &awscommon.StepRunSpotInstance{
-			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
-			AvailabilityZone:                  b.config.AvailabilityZone,
-			BlockDevices:                      b.config.BlockDevices,
-			Ctx:                               b.config.ctx,
-			Debug:                             b.config.PackerDebug,
-			EbsOptimized:                      b.config.EbsOptimized,
-			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
-			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
-			InstanceType:                      b.config.InstanceType,
-			SourceAMI:                         b.config.SourceAmi,
-			SpotPrice:                         b.config.SpotPrice,
-			SpotPriceProduct:                  b.config.SpotPriceAutoProduct,
-			SubnetId:                          b.config.SubnetId,
-			Tags:                              b.config.RunTags,
-			UserData:                          b.config.UserData,
-			UserDataFile:                      b.config.UserDataFile,
-			VolumeTags:                        b.config.VolumeRunTags,
-		}
-	} else {
-		instanceStep = &awscommon.StepRunSourceInstance{
-			AssociatePublicIpAddress:          b.config.AssociatePublicIpAddress,
-			AvailabilityZone:                  b.config.AvailabilityZone,
-			BlockDevices:                      b.config.BlockDevices,
-			Ctx:                               b.config.ctx,
-			Debug:                             b.config.PackerDebug,
-			EbsOptimized:                      b.config.EbsOptimized,
-			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
-			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
-			InstanceType:                      b.config.InstanceType,
-			SourceAMI:                         b.config.SourceAmi,
-			SubnetId:                          b.config.SubnetId,
-			Tags:                              b.config.RunTags,
-			UserData:                          b.config.UserData,
-			UserDataFile:                      b.config.UserDataFile,
-			VolumeTags:                        b.config.VolumeRunTags,
-		}
-	}
-
 	// Build the steps
 	steps := []multistep.Step{
 		&awscommon.StepPreValidate{
@@ -181,10 +131,9 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			ForceDeregister: b.config.AMIForceDeregister,
 		},
 		&awscommon.StepSourceAMIInfo{
-			SourceAmi:                b.config.SourceAmi,
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
-			AmiFilters:               b.config.SourceAmiFilter,
+			SourceAmi:          b.config.SourceAmi,
+			EnhancedNetworking: b.config.AMIEnhancedNetworking,
+			AmiFilters:         b.config.SourceAmiFilter,
 		},
 		&awscommon.StepKeyPair{
 			Debug:                b.config.PackerDebug,
@@ -198,9 +147,29 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			SecurityGroupIds: b.config.SecurityGroupIds,
 			CommConfig:       &b.config.RunConfig.Comm,
 			VpcId:            b.config.VpcId,
-			TemporarySGSourceCidr: b.config.TemporarySGSourceCidr,
 		},
-		instanceStep,
+		&awscommon.StepRunSourceInstance{
+			Debug:                    b.config.PackerDebug,
+			ExpectedRootDevice:       "ebs",
+			SpotPrice:                b.config.SpotPrice,
+			SpotPriceProduct:         b.config.SpotPriceAutoProduct,
+			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,
+			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
+		},
+		&awscommon.StepTagEBSVolumes{
+			VolumeRunTags: b.config.VolumeRunTags,
+			Ctx:           b.config.ctx,
+		},
 		&awscommon.StepGetPassword{
 			Debug:   b.config.PackerDebug,
 			Comm:    &b.config.RunConfig.Comm,
@@ -210,7 +179,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			Config: &b.config.RunConfig.Comm,
 			Host: awscommon.SSHHost(
 				ec2conn,
-				b.config.SSHInterface),
+				b.config.SSHPrivateIp),
 			SSHConfig: awscommon.SSHConfig(
 				b.config.RunConfig.Comm.SSHAgentAuth,
 				b.config.RunConfig.Comm.SSHUsername,
@@ -218,28 +187,23 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		},
 		&common.StepProvision{},
 		&awscommon.StepStopEBSBackedInstance{
-			Skip:                b.config.IsSpotInstance(),
+			SpotPrice:           b.config.SpotPrice,
 			DisableStopInstance: b.config.DisableStopInstance,
 		},
 		&awscommon.StepModifyEBSBackedInstance{
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
+			EnableEnhancedNetworking: b.config.AMIEnhancedNetworking,
 		},
 		&StepSnapshotNewRootVolume{
 			NewRootMountPoint: b.config.RootDevice.SourceDeviceName,
 		},
 		&awscommon.StepDeregisterAMI{
-			AccessConfig:        &b.config.AccessConfig,
 			ForceDeregister:     b.config.AMIForceDeregister,
 			ForceDeleteSnapshot: b.config.AMIForceDeleteSnapshot,
 			AMIName:             b.config.AMIName,
-			Regions:             b.config.AMIRegions,
 		},
 		&StepRegisterAMI{
-			RootDevice:               b.config.RootDevice,
-			BlockDevices:             b.config.BlockDevices.BuildAMIDevices(),
-			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
-			EnableAMIENASupport:      b.config.AMIENASupport,
+			RootDevice:   b.config.RootDevice,
+			BlockDevices: b.config.BlockDevices.BuildLaunchDevices(),
 		},
 		&awscommon.StepCreateEncryptedAMICopy{
 			KeyID:             b.config.AMIKmsKeyId,
@@ -247,11 +211,9 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			Name:              b.config.AMIName,
 		},
 		&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,

builder/amazon/ebssurrogate/builder_test.go

@@ -3,7 +3,7 @@ package ebssurrogate
 import (
 	"testing"
 
-	"github.com/hashicorp/packer/packer"
+	"github.com/mitchellh/packer/packer"
 )
 
 func testConfig() map[string]interface{} {

builder/amazon/ebssurrogate/root_block_device.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"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"
 )
 
 type RootBlockDevice struct {

builder/amazon/ebssurrogate/step_register_ami.go

@@ -5,18 +5,16 @@ 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 {
-	RootDevice               RootBlockDevice
-	BlockDevices             []*ec2.BlockDeviceMapping
-	EnableAMIENASupport      bool
-	EnableAMISriovNetSupport bool
-	image                    *ec2.Image
+	RootDevice   RootBlockDevice
+	BlockDevices []*ec2.BlockDeviceMapping
+	image        *ec2.Image
 }
 
 func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
@@ -27,7 +25,16 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 
 	ui.Say("Registering the AMI...")
 
-	blockDevicesExcludingRoot := DeduplicateRootVolume(s.BlockDevices, s.RootDevice, snapshotId)
+	blockDevicesExcludingRoot := make([]*ec2.BlockDeviceMapping, 0, len(s.BlockDevices)-1)
+	for _, blockDevice := range s.BlockDevices {
+		if *blockDevice.DeviceName == s.RootDevice.SourceDeviceName {
+			continue
+		}
+
+		blockDevicesExcludingRoot = append(blockDevicesExcludingRoot, blockDevice)
+	}
+
+	blockDevicesExcludingRoot = append(blockDevicesExcludingRoot, s.RootDevice.createBlockDeviceMapping(snapshotId))
 
 	registerOpts := &ec2.RegisterImageInput{
 		Name:                &config.AMIName,
@@ -37,16 +44,16 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 		BlockDeviceMappings: blockDevicesExcludingRoot,
 	}
 
-	if s.EnableAMISriovNetSupport {
+	if config.AMIEnhancedNetworking {
 		// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
 		// As of February 2017, this applies to C3, C4, D2, I2, R3, and M4 (excluding m4.16xlarge)
 		registerOpts.SriovNetSupport = aws.String("simple")
-	}
-	if s.EnableAMIENASupport {
+
 		// Set EnaSupport to true
 		// As of February 2017, this applies to C5, I3, P2, R4, X1, and m4.16xlarge
 		registerOpts.EnaSupport = aws.Bool(true)
 	}
+
 	registerResp, err := ec2conn.RegisterImage(registerOpts)
 	if err != nil {
 		state.Put("error", fmt.Errorf("Error registering AMI: %s", err))
@@ -111,25 +118,10 @@ func (s *StepRegisterAMI) 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))
 		return
 	}
 }
-
-func DeduplicateRootVolume(BlockDevices []*ec2.BlockDeviceMapping, RootDevice RootBlockDevice, snapshotId string) []*ec2.BlockDeviceMapping {
-	// Defensive coding to make sure we only add the root volume once
-	blockDevicesExcludingRoot := make([]*ec2.BlockDeviceMapping, 0, len(BlockDevices))
-	for _, blockDevice := range BlockDevices {
-		if *blockDevice.DeviceName == RootDevice.SourceDeviceName {
-			continue
-		}
-
-		blockDevicesExcludingRoot = append(blockDevicesExcludingRoot, blockDevice)
-	}
-
-	blockDevicesExcludingRoot = append(blockDevicesExcludingRoot, RootDevice.createBlockDeviceMapping(snapshotId))
-	return blockDevicesExcludingRoot
-}