make progress bar POC for pause

than 10 seconds

.circleci/config.yml

@@ -7,7 +7,7 @@ version: 2.1
 executors:
   golang:
     docker:
-      - image: docker.mirror.hashicorp.services/circleci/golang:1.16
+      - image: docker.mirror.hashicorp.services/circleci/golang:1.15
     resource_class: medium+
   darwin:
     macos:
@@ -37,19 +37,15 @@ commands:
     parameters:
       GOOS:
         type: string
-      GOARCH:
-        default: "amd64"
-        type: string
     steps:
       - checkout
-      - run: GOOS=<< parameters.GOOS >> GOARCH=<<parameters.GOARCH>> go build -ldflags="-s -w -X github.com/hashicorp/packer/version.GitCommit=${CIRCLE_SHA1}" -o ./pkg/packer_<< parameters.GOOS >>_<< parameters.GOARCH >> .
-      - run: zip ./pkg/packer_<< parameters.GOOS >>_<< parameters.GOARCH >>.zip ./pkg/packer_<< parameters.GOOS >>_<< parameters.GOARCH >>
-      - run: rm ./pkg/packer_<< parameters.GOOS >>_<< parameters.GOARCH >>
+      - run: GOOS=<< parameters.GOOS >> go build -ldflags="-s -w -X github.com/hashicorp/packer/version.GitCommit=${CIRCLE_SHA1}" -o ./pkg/packer_<< parameters.GOOS >>_$(go env GOARCH) .
+      - run: zip ./pkg/packer_<< parameters.GOOS >>_$(go env GOARCH).zip ./pkg/packer_<< parameters.GOOS >>_$(go env GOARCH)
+      - run: rm ./pkg/packer_<< parameters.GOOS >>_$(go env GOARCH)
       - persist_to_workspace:
           root: .
           paths:
             - ./pkg/
-
 # Golang CircleCI 2.0 configuration file
 #
 # Check https://circleci.com/docs/2.0/language-go/ for more details
@@ -65,11 +61,13 @@ jobs:
           file: coverage.txt
   test-darwin:
     executor: darwin
-    working_directory: ~/go/github.com/hashicorp/packer
+    working_directory: ~/go/src/github.com/hashicorp/packer
+    environment:
+      GO111MODULE: "off"
     steps:
       - install-go-run-tests-unix:
           GOOS: darwin
-          GOVERSION: "1.16"
+          GOVERSION: "1.15"
       - codecov/upload:
           file: coverage.txt
   test-windows:
@@ -78,7 +76,7 @@ jobs:
       shell: bash.exe
     steps:
       - install-go-run-tests-windows:
-          GOVERSION: "1.16"
+          GOVERSION: "1.15"
       - codecov/upload:
           file: coverage.txt
   check-lint:
@@ -127,13 +125,6 @@ jobs:
     steps:
       - build-and-persist-packer-binary:
           GOOS: darwin
-  build_darwin_arm64:
-    executor: golang
-    working_directory: /go/src/github.com/hashicorp/packer
-    steps:
-      - build-and-persist-packer-binary:
-          GOOS: darwin
-          GOARCH: arm64
   build_freebsd:
     executor: golang
     working_directory: /go/src/github.com/hashicorp/packer
@@ -214,7 +205,6 @@ workflows:
     jobs:
       - build_linux
       - build_darwin
-      - build_darwin_arm64
       - build_windows
       - build_freebsd
       - build_openbsd
@@ -223,7 +213,6 @@ workflows:
           requires:
             - build_linux
             - build_darwin
-            - build_darwin_arm64
             - build_windows
             - build_freebsd
             - build_openbsd

.gitattributes

@@ -6,7 +6,6 @@
 *.mdx text eol=lf
 *.ps1 text eol=lf
 *.hcl text eol=lf
-*.tmpl text eol=lf
 *.txt text eol=lf
 go.mod text eol=lf
 go.sum text eol=lf

.github/CONTRIBUTING.md

@@ -11,12 +11,6 @@ contribute to the project, read on. This document will cover what we're looking
 for. By addressing all the points we're looking for, it raises the chances we
 can quickly merge or address your contributions.
 
-When contributing in any way to the Packer project (new issue, PR, etc), please 
-be aware that our team identifies with many gender pronouns. Please remember to 
-use nonbinary pronouns (they/them) and gender neutral language ("Hello folks") 
-when addressing our team. For more reading on our code of conduct, please see the 
-[HashiCorp community guidelines](https://www.hashicorp.com/community-guidelines).
-
 ## Issues
 
 ### Reporting an Issue
@@ -25,7 +19,7 @@ when addressing our team. For more reading on our code of conduct, please see th
   already fixed the bug you're experiencing.
 
 - Run the command with debug output with the environment variable `PACKER_LOG`.
-  For example: `PACKER_LOG=1 packer build template.pkr.hcl`. Take the _entire_
+  For example: `PACKER_LOG=1 packer build template.json`. Take the _entire_
   output and create a [gist](https://gist.github.com) for linking to in your
   issue. Packer should strip sensitive keys from the output, but take a look
   through just in case.
@@ -70,9 +64,7 @@ when addressing our team. For more reading on our code of conduct, please see th
 If you have never worked with Go before, you will have to install its
 runtime in order to build packer.
 
-1. This project always releases from the latest version of golang.
-[Install go](https://golang.org/doc/install#install) To properly build from
-source, you need to have golang >= v1.16
+1. This project always releases from the latest version of golang. [Install go](https://golang.org/doc/install#install)
 
 ## Setting up Packer for dev
 
@@ -80,6 +72,7 @@ If/when you have go installed you can already `go get` packer and `make` in
 order to compile and test Packer. These instructions target
 POSIX-like environments (macOS, Linux, Cygwin, etc.) so you may need to
 adjust them for Windows or other shells.
+The instructions below are for go 1.7. or later.
 
 1. Download the Packer source (and its dependencies) by running
    `go get github.com/hashicorp/packer`. This will download the Packer source to
@@ -98,7 +91,7 @@ adjust them for Windows or other shells.
 4. 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.pkr.hcl`.
+   `$GOPATH/src/github.com/hashicorp/packer/bin/packer build template.json`.
 
 5. If everything works well and the tests pass, run `go fmt` on your code before
    submitting a pull-request.

.github/PULL_REQUEST_TEMPLATE.md

@@ -10,7 +10,7 @@ Describe the change you are making here!
 
 Please include tests. Check out these examples:
 
-- https://github.com/hashicorp/packer/blob/master/builder/parallels/common/ssh_config_test.go#L34
+- 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
 
 If your PR resolves any open issue(s), please indicate them like this so they will be closed when your PR is merged:

.github/workflows/check-plugin-docs.js

@@ -1,77 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const fetchPluginDocs = require("../../website/components/remote-plugin-docs/utils/fetch-plugin-docs");
-
-const COLOR_RESET = "\x1b[0m";
-const COLOR_GREEN = "\x1b[32m";
-const COLOR_BLUE = "\x1b[34m";
-const COLOR_RED = "\x1b[31m";
-
-async function checkPluginDocs() {
-  const failureMessages = [];
-  const pluginsPath = "website/data/docs-remote-plugins.json";
-  const pluginsFile = fs.readFileSync(path.join(process.cwd(), pluginsPath));
-  const pluginEntries = JSON.parse(pluginsFile);
-  const entriesCount = pluginEntries.length;
-  console.log(`\nResolving plugin docs from ${entriesCount} repositories …`);
-  for (var i = 0; i < entriesCount; i++) {
-    const pluginEntry = pluginEntries[i];
-    const { title, repo, version } = pluginEntry;
-    console.log(`\n${COLOR_BLUE}${repo}${COLOR_RESET} | ${title}`);
-    console.log(`Fetching docs from release "${version}" …`);
-    try {
-      const undefinedProps = ["title", "repo", "version", "path"].filter(
-        (key) => typeof pluginEntry[key] == "undefined"
-      );
-      if (undefinedProps.length > 0) {
-        throw new Error(
-          `Failed to validate plugin docs config. Undefined configuration properties ${JSON.stringify(
-            undefinedProps
-          )} found for "${
-            title || pluginEntry.path || repo
-          }". In "website/data/docs-remote-plugins.json", please ensure the missing properties ${JSON.stringify(
-            undefinedProps
-          )} are defined. Additional information on this configuration can be found in "website/README.md".`
-        );
-      }
-      const docsMdxFiles = await fetchPluginDocs({ repo, tag: version });
-      const mdxFilesByComponent = docsMdxFiles.reduce((acc, mdxFile) => {
-        const componentType = mdxFile.filePath.split("/")[1];
-        if (!acc[componentType]) acc[componentType] = [];
-        acc[componentType].push(mdxFile);
-        return acc;
-      }, {});
-      console.log(`${COLOR_GREEN}Found valid docs:${COLOR_RESET}`);
-      Object.keys(mdxFilesByComponent).forEach((component) => {
-        const componentFiles = mdxFilesByComponent[component];
-        console.log(`  ${component}`);
-        componentFiles.forEach(({ filePath }) => {
-          const pathFromComponent = filePath.split("/").slice(2).join("/");
-          console.log(`  ├── ${pathFromComponent}`);
-        });
-      });
-    } catch (err) {
-      console.log(`${COLOR_RED}${err}${COLOR_RESET}`);
-      failureMessages.push(`\n${COLOR_RED}× ${repo}: ${COLOR_RESET}${err}`);
-    }
-  }
-
-  if (failureMessages.length === 0) {
-    console.log(
-      `\n---\n\n${COLOR_GREEN}Summary: Successfully resolved all plugin docs.`
-    );
-    pluginEntries.forEach((e) =>
-      console.log(`${COLOR_GREEN}✓ ${e.repo}${COLOR_RESET}`)
-    );
-    console.log("");
-  } else {
-    console.log(
-      `\n---\n\n${COLOR_RED}Summary: Failed to fetch docs for ${failureMessages.length} plugin(s):`
-    );
-    failureMessages.forEach((err) => console.log(err));
-    console.log("");
-    process.exit(1);
-  }
-}
-
-checkPluginDocs();

.github/workflows/check-plugin-docs.yml

@@ -1,29 +0,0 @@
-#
-# This GitHub action checks plugin repositories for valid docs.
-#
-# This provides a quick assessment on PRs of whether
-# there might be issues with docs in plugin repositories.
-#
-# This is intended to help debug Vercel build issues, which
-# may or may not be related to docs in plugin repositories.
-
-name: "website: Check plugin docs"
-on:
-  pull_request:
-    paths:
-      - "website/**"
-  schedule:
-    - cron: "45 0 * * *"
-
-jobs:
-  check-plugin-docs:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Setup Node
-        uses: actions/setup-node@v1
-      - name: Install Dependencies
-        run: npm i isomorphic-unfetch adm-zip gray-matter
-      - name: Fetch and validate plugin docs
-        run: node .github/workflows/check-plugin-docs.js

.github/workflows/linkchecker.yml

@@ -1,37 +1,14 @@
-on:
-  pull_request:
-    paths:
-      - 'website/**'
-
-name: Check markdown links on modified website files
+on: [pull_request]
+name: Check Markdown links for modified files
 jobs:
-  vercel-deployment-poll:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5 #cancel job if no deployment is found within x minutes
-    outputs:
-      url: ${{ steps.waitForVercelPreviewDeployment.outputs.url }}
-    steps:
-    - name: Wait for Vercel preview deployment to be ready
-      uses: nywilken/wait-for-vercel-preview@master
-      id: waitForVercelPreviewDeployment
-      with:
-       token: ${{ secrets.GITHUB_TOKEN }}
-       max_timeout: 600 # in seconds, set really high to leverage job timeout-minutes values
-       allow_inactive: true # needed to ensure we get a URL for a previously released deployment
   markdown-link-check:
-    needs: vercel-deployment-poll
-    if: ${{ needs.vercel-deployment-poll.outputs.url != '' }}
     runs-on: ubuntu-latest
     steps:
-    - name: Get Deployment URL
-      run:
-        echo "DEPLOYMENT_URL=${{ needs.vercel-deployment-poll.outputs.url }}" >> $GITHUB_ENV
-    - name: Checkout source branch
-      uses: actions/checkout@master
-    - name: Check links
-      uses: gaurav-nelson/github-action-markdown-link-check@v1
+    - uses: actions/checkout@master
+    - uses: gaurav-nelson/github-action-markdown-link-check@v1
       with:
         use-quiet-mode: 'yes'
         file-extension: 'mdx'
         check-modified-files-only: 'yes'
         folder-path: 'website/content'
+

.github/workflows/scheduled-link-checker.yml

@@ -6,9 +6,6 @@ jobs:
   markdown-link-check:
     runs-on: ubuntu-latest
     steps:
-    - name: Set deployment URL env
-      run:
-        echo "DEPLOYMENT_URL=https://packer-git-master.hashicorp.vercel.app" >> $GITHUB_ENV
     - uses: actions/checkout@master
     - uses: gaurav-nelson/github-action-markdown-link-check@v1
       with:

.hashibot.hcl

@@ -22,21 +22,3 @@ poll "closed_issue_locker" "locker" {
     If you have found a problem that seems similar to this, please open a new issue and complete the issue template so we can capture all the details necessary to investigate further.
   EOF
 }
-
-poll "label_issue_migrater" "remote_plugin_migrater" {
-  schedule                = "0 20 * * * *"
-  new_owner               = "hashicorp"
-  repo_prefix             = "packer-plugin-"
-  label_prefix            = "remote-plugin/"
-  excluded_label_prefixes  = ["communicator/"]
-  excluded_labels         = ["build", "core", "new-plugin-contribution", "website"]
-
-  issue_header     = <<-EOF
-    _This issue was originally opened by @${var.user} as ${var.repository}#${var.issue_number}. It was migrated here as a result of the [Packer plugin split](https://github.com/hashicorp/packer/issues/8610#issuecomment-770034737). The original body of the issue is below._
-
-    <hr>
-
-    EOF
-  migrated_comment = "This issue has been automatically migrated to ${var.repository}#${var.issue_number} because it looks like an issue with that plugin. If you believe this is _not_ an issue with the plugin, please reply to ${var.repository}#${var.issue_number}."
-}
-

CHANGELOG.md

@@ -1,218 +1,15 @@
-## 1.7.2 (Upcoming)
-
-## 1.7.1 (March 31, 2021)
-
-### NOTES:
-
-* builder/amazon: Has been vendored in this release and will no longer be
-    updated with Packer core. In Packer v1.8.0 the plugin will be removed
-    entirely. The `amazon` components will continue to work as expected until
-    then, but for the latest offerings of the Amazon plugin, users are
-    encourage to use the `packer init` command to install the latest release
-    version. For more details see [Installing Packer
-    Plugins](https://www.packer.io/docs/plugins#installing-plugins)
-* builder/docker: Has been vendored in this release and will no longer be
-    updated with Packer core. In Packer v1.8.0 the plugin will be removed
-    entirely. The `docker` builder will continue to work as expected until
-    then, but for the latest offerings of the Docker plugin, users are
-    encourage to use the `packer init` command to install the latest release
-    version. For more details see [Installing Packer
-    Plugins](https://www.packer.io/docs/plugins#installing-plugins)
-* darwin/arm64: Packer now includes the darwin/arm64 binary to its releases to
-    supports the new OSX M1. [GH-10804]
-* post-processor/docker-\*: Have been vendored in this release and will no
-    longer be updated with Packer core. In Packer v1.8.0 the plugin will be
-    removed entirely. The `docker` builder will continue to work as expected
-    until then, but for the latest offerings of the Docker plugin, users are
-    encourage to use the `packer init` command to install the latest release
-    version. For more details see [Installing Packer
-    Plugins](https://www.packer.io/docs/plugins#installing-plugins)
-* post-processor/exoscale-import: Has been vendored in this release and will no
-    longer be updated with Packer core. In Packer v1.8.0 the plugin will be
-    removed entirely. The `exoscale-import` post-processor will continue to
-    work as expected until then, but for the latest offerings of the Exoscale
-    plugin, users are encourage to use the `packer init` command to install the
-    latest release version. For more details see [Exoscale Plugin
-    Repostiroy](https://github.com/exoscale/packer-plugin-exoscale). [GH-10709]
-
-### IMPROVEMENTS
-* builder/amazon: allow creation of ebs snapshots without volumes. [GH-9591]
-* builder/amazon: Fix issue for multi-region AMI build that fail when
-    encrypting with KMS and sharing across accounts. [GH-10754]
-* builder/azure: Add client_cert_token_timeout option. [GH-10528]
-* builder/google: Make Windows password timeout configurable. [GH-10727]
-* builder/google: Update public GCP image project as gce-uefi-images are
-    deprecated. [GH-10724]
-* builder/oracle-oci: Update Oracle Go SDK to add support for OCI flexible
-    shapes.  [GH-10833]
-* builder/proxmox: Allow using API tokens for Proxmox authentication.
-    [GH-10797]
-* builder/qemu: Added firmware option. [GH-10683]
-* builder/scaleway: add support for timeout in shutdown step. [GH-10503]
-* builder/vagrant: Fix logging to be clearer when Vagrant builder overrides
-    values retrieved from vagrant's ssh_config call. [GH-10743]
-* builder/virtualbox:  Added ISO builder option to create additional disks.
-    [GH-10674]
-* builder/virtualbox: Add options for nested virtualisation and RTC time base.
-    [GH-10736]
-* builder/virtualbox: Add template options for chipset, firmware, nic, graphics
-    controller, and audio controller. [GH-10671]
-* builder/virtualbox: Support for "virtio" storage and ISO drive. [GH-10632]
-* builder/vmware: Added "attach_snapshot" parameter to vmware vmx builder.
-    [GH-10651]
-* command/fmt: Adding recursive flag to formatter to format subdirectories.
-    [GH-10457]
-* core/hcl2: Add legacy_isotime function. [GH-10780]
-* core/hcl2: Add support for generating `dynamic` blocks within a `build`
-    block. [GH-10825]
-* core/hcl2: Add templatefile function. [GH-10776]
-* core/hcl2_upgrade: hcl2_upgrade command can now upgrade json var-files.
-    [GH-10676]
-* core/init: Add implicit required_plugin blocks feature. [GH-10732]
-* core: Add http_content option to serve variables from HTTP at preseed.
-    [GH-10801]
-* core: Change template parsing error to include warning about file extensions.
-    [GH-10652]
-* core: Update to gopsutil v3.21.1 to allow builds to work for darwin arm64.
-    [GH-10697]
-* provisioner/inspec: Allow non-zero exit codes for inspec provisioner.
-    [GH-10723]
-
-### BUG FIXES
-* buider/azure: Update builder to ensure a proper clean up Azure temporary
-    managed Os disks. [GH-10713]
-* builder/amazon: Update amazon SDK to fix an SSO login issue. [GH-10668]
-* builder/azure: Don't overwrite subscription id if unset. [GH-10659]
-* builder/azure: Set default for the parameter client_cert_token_timeout
-    [GH-10783]
-* builder/google: Add new configuration field `windows_password_timeout` to
-    allow user to set configurable timeouts. [GH-10727]
-* builder/hyperv: Make Packer respect winrm_host flag in winrm connect func.
-    [GH-10748]
-* builder/openstack: Make Packer respect winrm_host flag in winrm connect func.
-    [GH-10748]
-* builder/oracle-oci: Update Oracle Go SDK to fix issue with reading key file.
-    [GH-10560] [GH-10774]
-* builder/outscale: Fix omi_description that was ignored in Osc builder
-    [GH-10792]
-* builder/parallels: Make Packer respect winrm_host flag in winrm connect func.
-    [GH-10748]
-* builder/proxmox: Fixes issue when using `additional_iso_files` in HCL enabled
-    templates. [GH-10772]
-* builder/qemu: Make Packer respect winrm_host flag in winrm connect func.
-    [GH-10748]
-* builder/virtualbox: Make Packer respect winrm_host flag in winrm connect
-    func. [GH-10748]
-* builder/vmware: Added a fallback file check when trying to determine the
-    network-mapping configuration. [GH-10543]
-* builder/vsphere: Fix invalid device configuration issue when creating a
-    vm with multiple disk on the same controller. [GH-10844]
-* builder/vsphere: Fix issue where boot command would fail the build do to a
-    key typing error. This change will now retry to type the key on error
-    before giving up. [GH-10541]
-* core/hcl2_upgrade: Check for nil config map when provisioner/post-processor
-    doesn't have config. [GH-10730]
-* core/hcl2_upgrade: Fix escaped quotes in template functions [GH-10794]
-* core/hcl2_upgrade: Make hcl2_upgrade command correctly translate
-    pause_before. [GH-10654]
-* core/hcl2_upgrade: Make json variables using template engines get stored as
-    locals so they can be properly interpolated. [GH-10685]
-* core/init: Fixes issue where `packer init` was failing to install valid
-    plugins containing a 'v' within its name. [GH-10760]
-* core: Packer will now show a proper error message when failing to load the
-    contents of PACKER_CONFIG. [GH-10766]
-* core: Pin Packer to Golang 1.16 to fix code generation issues. [GH-10702]
-* core: Templates previously could not interpolate the environment variable
-    PACKER_LOG_PATH. [GH-10660]
-* post-processor/vagrant-cloud: Override direct upload based on box size
-    [GH-10820]
-* provisioner/chef-solo: HCL2 templates can support the json_string option.
-    [GH-10655]
-* provisioner/inspec: Add new configuration field `valid_exit_codes` to allow
-    for non-zero exit codes. [GH-10723]
-* provisioner/salt-masterless: Update urls for the bootstrap scripts used by
-    salt-masterless provide. [GH-10755]
-
-## 1.7.0 (February 17, 2021)
-
-### FEATURES
-* **New Command** (HCL only) `packer init` command will download plugins defined
-    in a new `required_plugins` block [GH-10304] [GH-10633].
-* **New Plugin Type** Data sources can be implemented (blog post forthcoming).
-    [GH-10440]
-* **New Plugin** Aws Secrets Manager data source [GH-10505] [GH-10467]
-
-### BACKWARDS INCOMPATIBILITIES
-* core: The API that the Packer core uses to communicate with community plugins
-    has changed; maintainers of community plugins will need to upgrade their
-    plugins in order to make them compatible with v1.7.0. An upgrade guide will
-    be available on our guides page https://www.packer.io/guides.
-
-### IMPROVEMENTS
-* builder/amazon: Add `skip_create_ami` option for testing and situations where
-    artifact is not the ami. [GH-10531]
-* builder/amazon: Add IMDSv2 support for AWS EBS builder. [GH-10546]
-* builder/amazon: Add resource tags in the launch template used to request spot
-    instances. [GH-10456]
-* builder/openstack:  Add `skip_create_image` option for testing and situations
-    where artifact is not the image. [GH-10496]
-* builder/oracle-oci: Add retry strategies to oci calls [GH-10591]
-* core/fmt: The `packer fmt` can now read from stdin. [GH-10500]
-* core/hcl: Add regex and regexall hcl2 template functions. [GH-10601]
-* core/hcl: Templates now support "sensitive" locals. [GH-10509]
-* core/hcl: Templates now support error-cleanup-provisioner. [GH-10604]
-* hcl2_upgrade: Command now comes with a flag so you can control whether output
-    templates are annotated with helpful comments. [GH-10619]
-* hcl2_upgrade: Command now gracefully handles options with template engine
-    interpolations. [GH-10625]
-* hcl2_upgrade: Command will convert amazon filters to use the ami data source.
-    [GH-10491]
-
-### BUG FIXES
-* amazon/ebssurrogate: Apply snapshot tags at same time as when taking
-    snapshot. [GH-10150]
-* builder/amazon: Fix bug where validation fails if optional iops value is
-    unset. [GH-10518]
-* builder/amazon: Wrap API call to get filtered image in a retry. [GH-10610]
-* builder/bsusurrogate: override bsu when omi root device is set. [GH-10490]
-* builder/google: Fix bug where Packer would fail when run by users who do not
-    have permission to access the metadata, even though the metadata is not
-    necessary to the run. [GH-10458]
-* builder/profitbricks: Profitbricks builder could not connect using SSH
-    communicator. [GH-10549]
-* builder/proxmox: Ensure ISOs in additional_iso_files are mounted during VM
-    creation. [GH-10586]
-* builder/proxmox: Improve cloud init error logging for proxmox builder.
-    [GH-10499]
-* builder/qemu: Fix bug where vnc_min_port set to value greater then 5900 could
-    prevent Packer from connecting to QEMU. [GH-10450] [GH-10451]
-* builder/qemu: Fix regression with cd indexing when disk_interface is `ide`.
-    [GH-10519]
-* builder/vmware-esx: Skip credential validation, which requires ovftool to be
-    installed, if we are not exporting an image. [GH-10520]
-* builder/yandex: Fix cloud-init config for ubuntu 20.04. [GH-10522]
-* builder/yandex: Fix incorrect access to `instance_id`. [GH-10522]
-* core/hcl: Fix bug where []uint8 types could not be passed to plugins.
-* core/hcl: fix bug where HCL core could not handle passing []uint8 to plugins.
-    [GH-10516]
-* core/hcl: Fix force flag for hcl2 provisioners and post-processors.
-    [GH-10571]
-* post-processor/vsphere: Fix regression where Packer would not check the exit
-    status after streaming UI from the ovftool command. [GH-10468]
-* post-processor/yandex-export: Changed dhclient command and supported
-    configuring disk for exportupdate-dump-method. Also added support for
-    `file` builder. [GH-10488]
+## 1.7.0 (Upcoming)
 
 ## 1.6.6 (December 16, 2020)
 
-### FEATURES
+### FEATURES:
 * **New command** `fmt` allows users to format existing HCL2 configuration
     files into a canonical style. Please see [fmt command
     docs](https://packer.io/docs/commands/fmt) for more details. [GH-10225]
     [GH-10377]
 * **New function** `env` allows users to set the default value of a variable to
     the value of an environment variable. Please see [env function
-    docs](https://www.packer.io/docs/templates/hcl_templates/functions/contextual/env) for
+    docs](https://www.packer.io/docs/templates/hcl_templates/functions/contextual/env") for
     more details. [GH-10240]
 * **Future Scaffolding** This release contains a large number of no-op
     refactoring changes. The Packer team at HashiCorp is preparing to split the

CODEOWNERS

@@ -37,8 +37,8 @@
 /builder/oracle/                      @prydie @owainlewis
 /website/pages/docs/builders/oracle* @prydie @owainlewis
 
-/builder/profitbricks/                      @LiviusP @mflorin
-/website/pages/docs/builders/profitbricks* @LiviusP @mflorin
+/builder/profitbricks/                      @jasmingacic
+/website/pages/docs/builders/profitbricks* @jasmingacic
 
 /builder/triton/                      @sean-
 /website/pages/docs/builders/triton* @sean-
@@ -87,6 +87,7 @@
 
 /post-processor/alicloud-import/        dongxiao.zzh@alibaba-inc.com
 /post-processor/checksum/               v.tolstov@selfip.ru
+/post-processor/exoscale-import/        @falzm @mcorbin
 /post-processor/googlecompute-export/   crunkleton@google.com
 /post-processor/yandex-export/          @GennadySpb
 /post-processor/yandex-import/          @GennadySpb

Makefile

@@ -49,7 +49,7 @@ package:
 	@sh -c "$(CURDIR)/scripts/dist.sh $(VERSION)"
 
 install-build-deps: ## Install dependencies for bin build
-	@go install github.com/mitchellh/gox@v1.0.1
+	@go get github.com/mitchellh/gox
 
 install-gen-deps: ## Install dependencies for code generation
 	# to avoid having to tidy our go deps, we `go get` our binaries from a temp

README.md

@@ -1,7 +1,7 @@
 # Packer
 
 [![Build Status][circleci-badge]][circleci]
-[![Discuss](https://img.shields.io/badge/discuss-packer-3d89ff?style=flat)](https://discuss.hashicorp.com/c/packer)
+[![Windows Build Status][appveyor-badge]][appveyor]
 [![PkgGoDev](https://pkg.go.dev/badge/github.com/hashicorp/packer)](https://pkg.go.dev/github.com/hashicorp/packer)
 [![GoReportCard][report-badge]][report]
 [![codecov](https://codecov.io/gh/hashicorp/packer/branch/master/graph/badge.svg)](https://codecov.io/gh/hashicorp/packer)
@@ -9,16 +9,15 @@
 [circleci-badge]: https://circleci.com/gh/hashicorp/packer.svg?style=svg
 [circleci]: https://app.circleci.com/pipelines/github/hashicorp/packer
 [appveyor-badge]: https://ci.appveyor.com/api/projects/status/miavlgnp989e5obc/branch/master?svg=true
+[appveyor]: https://ci.appveyor.com/project/hashicorp/packer
 [godoc-badge]: https://godoc.org/github.com/hashicorp/packer?status.svg
-[godoc]: https://godoc.org/github.com/hashicorp/packer	
-[report-badge]: https://goreportcard.com/badge/github.com/hashicorp/packer	
+[godoc]: https://godoc.org/github.com/hashicorp/packer
+[report-badge]: https://goreportcard.com/badge/github.com/hashicorp/packer
 [report]: https://goreportcard.com/report/github.com/hashicorp/packer
 
-<p align="center" style="text-align:center;">
-  <a href="https://www.packer.io">
-    <img alt="HashiCorp Packer logo" src="website/public/img/logo-packer-padded.svg" width="500" />
-  </a>
-</p>
+* Website: https://www.packer.io
+* IRC: `#packer-tool` on Freenode
+* Mailing list: [Google Groups](https://groups.google.com/forum/#!forum/packer-tool)
 
 Packer is a tool for building identical machine images for multiple platforms
 from a single source configuration.
@@ -48,43 +47,33 @@ yourself](https://github.com/hashicorp/packer/blob/master/.github/CONTRIBUTING.m
 
 After Packer is installed, create your first template, which tells Packer
 what platforms to build images for and how you want to build them. In our
-case, we'll create a simple AMI that has Redis pre-installed. 
-
-Save this file as `quick-start.pkr.hcl`. Export your AWS credentials as the
+case, we'll create a simple AMI that has Redis pre-installed. Save this
+file as `quick-start.json`. Export your AWS credentials as the
 `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables.
 
-```hcl
-variable "access_key" {
-  type    = string
-  default = "${env("AWS_ACCESS_KEY_ID")}"
-}
-
-variable "secret_key" {
-  type    = string
-  default = "${env("AWS_SECRET_ACCESS_KEY")}"
-}
-
-locals { timestamp = regex_replace(timestamp(), "[- TZ:]", "") }
-
-source "amazon-ebs" "quick-start" {
-  access_key    = "${var.access_key}"
-  ami_name      = "packer-example ${local.timestamp}"
-  instance_type = "t2.micro"
-  region        = "us-east-1"
-  secret_key    = "${var.secret_key}"
-  source_ami    = "ami-af22d9b9"
-  ssh_username  = "ubuntu"
-}
-
-build {
-  sources = ["source.amazon-ebs.quick-start"]
+```json
+{
+  "variables": {
+    "access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
+    "secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}"
+  },
+  "builders": [{
+    "type": "amazon-ebs",
+    "access_key": "{{user `access_key`}}",
+    "secret_key": "{{user `secret_key`}}",
+    "region": "us-east-1",
+    "source_ami": "ami-af22d9b9",
+    "instance_type": "t2.micro",
+    "ssh_username": "ubuntu",
+    "ami_name": "packer-example {{timestamp}}"
+  }]
 }
 ```
 
 Next, tell Packer to build the image:
 
 ```
-$ packer build quick-start.pkr.hcl
+$ packer build quick-start.json
 ...
 ```
 
@@ -96,9 +85,11 @@ they're run, etc., is up to you.
 
 ## Documentation
 
-Comprehensive documentation is viewable on the Packer website at https://www.packer.io/docs.
+Comprehensive documentation is viewable on the Packer website:
 
-## Contributing to Packer
+https://www.packer.io/docs
+
+## Developing Packer
 
 See
 [CONTRIBUTING.md](https://github.com/hashicorp/packer/blob/master/.github/CONTRIBUTING.md)

builder/amazon/chroot/builder.go

@@ -15,7 +15,6 @@ import (
 
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/hashicorp/hcl/v2/hcldec"
-	awscommon "github.com/hashicorp/packer-plugin-amazon/builder/common"
 	"github.com/hashicorp/packer-plugin-sdk/chroot"
 	"github.com/hashicorp/packer-plugin-sdk/common"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
@@ -24,6 +23,7 @@ import (
 	"github.com/hashicorp/packer-plugin-sdk/packerbuilderdata"
 	"github.com/hashicorp/packer-plugin-sdk/template/config"
 	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 )
 
 // The unique ID for this builder
@@ -162,7 +162,7 @@ type Config struct {
 	//filter, but will cause Packer to fail if the `source_ami` does not exist.
 	SourceAmiFilter awscommon.AmiFilterOptions `mapstructure:"source_ami_filter" required:"false"`
 	// Key/value pair tags to apply to the volumes that are *launched*. This is
-	// a [template engine](/docs/templates/legacy_json_templates/engine), see [Build template
+	// a [template engine](/docs/templates/engine), see [Build template
 	// data](#build-template-data) for more information.
 	RootVolumeTags map[string]string `mapstructure:"root_volume_tags" required:"false"`
 	// Same as [`root_volume_tags`](#root_volume_tags) but defined as a

builder/amazon/chroot/builder.hcl2spec.go

@@ -4,8 +4,8 @@ package chroot
 
 import (
 	"github.com/hashicorp/hcl/v2/hcldec"
-	"github.com/hashicorp/packer-plugin-amazon/builder/common"
 	"github.com/hashicorp/packer-plugin-sdk/template/config"
+	"github.com/hashicorp/packer/builder/amazon/common"
 	"github.com/zclconf/go-cty/cty"
 )
 

builder/amazon/chroot/builder_test.go

@@ -0,0 +1,251 @@
+package chroot
+
+import (
+	"testing"
+
+	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+)
+
+func testConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"ami_name":   "foo",
+		"source_ami": "foo",
+		"region":     "us-east-1",
+		// region validation logic is checked in ami_config_test
+		"skip_region_validation": true,
+	}
+}
+
+func TestBuilder_ImplementsBuilder(t *testing.T) {
+	var raw interface{}
+	raw = &Builder{}
+	if _, ok := raw.(packersdk.Builder); !ok {
+		t.Fatalf("Builder should be a builder")
+	}
+}
+
+func TestBuilderPrepare_AMIName(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["ami_name"] = "foo"
+	config["skip_region_validation"] = true
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	// Test bad
+	config["ami_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, "ami_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_ChrootMounts(t *testing.T) {
+	b := &Builder{}
+	config := testConfig()
+
+	config["chroot_mounts"] = nil
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Errorf("err: %s", err)
+	}
+}
+
+func TestBuilderPrepare_ChrootMountsBadDefaults(t *testing.T) {
+	b := &Builder{}
+	config := testConfig()
+
+	config["chroot_mounts"] = [][]string{
+		{"bad"},
+	}
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+func TestBuilderPrepare_SourceAmi(t *testing.T) {
+	b := &Builder{}
+	config := testConfig()
+
+	config["source_ami"] = ""
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	config["source_ami"] = "foo"
+	_, warnings, err = b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Errorf("err: %s", err)
+	}
+}
+
+func TestBuilderPrepare_CommandWrapper(t *testing.T) {
+	b := &Builder{}
+	config := testConfig()
+
+	config["command_wrapper"] = "echo hi; {{.Command}}"
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Errorf("err: %s", err)
+	}
+}
+
+func TestBuilderPrepare_CopyFiles(t *testing.T) {
+	b := &Builder{}
+	config := testConfig()
+
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Errorf("err: %s", err)
+	}
+
+	if len(b.config.CopyFiles) != 1 && b.config.CopyFiles[0] != "/etc/resolv.conf" {
+		t.Errorf("Was expecting default value for copy_files.")
+	}
+}
+
+func TestBuilderPrepare_CopyFilesNoDefault(t *testing.T) {
+	b := &Builder{}
+	config := testConfig()
+
+	config["copy_files"] = []string{}
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Errorf("err: %s", err)
+	}
+
+	if len(b.config.CopyFiles) > 0 {
+		t.Errorf("Was expecting no default value for copy_files. Found %v",
+			b.config.CopyFiles)
+	}
+}
+
+func TestBuilderPrepare_RootDeviceNameAndAMIMappings(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	config["root_device_name"] = "/dev/sda"
+	config["ami_block_device_mappings"] = []interface{}{map[string]string{}}
+	config["root_volume_size"] = 15
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) == 0 {
+		t.Fatal("Missing warning, stating block device mappings will be overwritten")
+	} else if len(warnings) > 1 {
+		t.Fatalf("excessive warnings: %#v", warnings)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+}
+
+func TestBuilderPrepare_AMIMappingsNoRootDeviceName(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	config["ami_block_device_mappings"] = []interface{}{map[string]string{}}
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err == nil {
+		t.Fatalf("should have error")
+	}
+}
+
+func TestBuilderPrepare_RootDeviceNameNoAMIMappings(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	config["root_device_name"] = "/dev/sda"
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err == nil {
+		t.Fatalf("should have error")
+	}
+}
+
+func TestBuilderPrepare_ReturnGeneratedData(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	generatedData, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+	if len(generatedData) == 0 {
+		t.Fatalf("Generated data should not be empty")
+	}
+	if generatedData[0] != "SourceAMIName" {
+		t.Fatalf("Generated data should contain SourceAMIName")
+	}
+	if generatedData[1] != "BuildRegion" {
+		t.Fatalf("Generated data should contain BuildRegion")
+	}
+	if generatedData[2] != "SourceAMI" {
+		t.Fatalf("Generated data should contain SourceAMI")
+	}
+	if generatedData[3] != "SourceAMICreationDate" {
+		t.Fatalf("Generated data should contain SourceAMICreationDate")
+	}
+	if generatedData[4] != "SourceAMIOwner" {
+		t.Fatalf("Generated data should contain SourceAMIOwner")
+	}
+	if generatedData[5] != "SourceAMIOwnerName" {
+		t.Fatalf("Generated data should contain SourceAMIOwnerName")
+	}
+	if generatedData[6] != "Device" {
+		t.Fatalf("Generated data should contain Device")
+	}
+	if generatedData[7] != "MountPath" {
+		t.Fatalf("Generated data should contain MountPath")
+	}
+}

builder/amazon/chroot/copy_files_test.go

@@ -0,0 +1,51 @@
+package chroot
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"runtime"
+	"testing"
+
+	"github.com/hashicorp/packer-plugin-sdk/common"
+)
+
+func TestCopyFile(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		return
+	}
+
+	first, err := ioutil.TempFile("", "copy_files_test")
+	if err != nil {
+		t.Fatalf("couldn't create temp file.")
+	}
+	defer os.Remove(first.Name())
+	newName := first.Name() + "-new"
+
+	payload := "copy_files_test.go payload"
+	if _, err = first.WriteString(payload); err != nil {
+		t.Fatalf("Couldn't write payload to first file.")
+	}
+	first.Sync()
+
+	cmd := common.ShellCommand(fmt.Sprintf("cp %s %s", first.Name(), newName))
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("Couldn't copy file")
+	}
+	defer os.Remove(newName)
+
+	second, err := os.Open(newName)
+	if err != nil {
+		t.Fatalf("Couldn't open copied file.")
+	}
+	defer second.Close()
+
+	var copiedPayload = make([]byte, len(payload))
+	if _, err := second.Read(copiedPayload); err != nil {
+		t.Fatalf("Couldn't open copied file for reading.")
+	}
+
+	if string(copiedPayload) != payload {
+		t.Fatalf("payload not copied.")
+	}
+}

builder/amazon/chroot/device_test.go

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

builder/amazon/chroot/step_attach_volume.go

@@ -7,9 +7,9 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer-plugin-amazon/builder/common"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 )
 
 // StepAttachVolume attaches the previously created volume to an

builder/amazon/chroot/step_attach_volume_test.go

@@ -0,0 +1,15 @@
+package chroot
+
+import (
+	"testing"
+
+	"github.com/hashicorp/packer-plugin-sdk/chroot"
+)
+
+func TestAttachVolumeCleanupFunc_ImplementsCleanupFunc(t *testing.T) {
+	var raw interface{}
+	raw = new(StepAttachVolume)
+	if _, ok := raw.(chroot.Cleanup); !ok {
+		t.Fatalf("cleanup func should be a CleanupFunc")
+	}
+}

builder/amazon/chroot/step_create_volume.go

@@ -8,11 +8,11 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer-plugin-amazon/builder/common"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 	"github.com/hashicorp/packer-plugin-sdk/template/config"
 	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 )
 
 // StepCreateVolume creates a new volume from the snapshot of the root

builder/amazon/chroot/step_create_volume_test.go

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

builder/amazon/chroot/step_flock_test.go

@@ -0,0 +1,15 @@
+package chroot
+
+import (
+	"testing"
+
+	"github.com/hashicorp/packer-plugin-sdk/chroot"
+)
+
+func TestFlockCleanupFunc_ImplementsCleanupFunc(t *testing.T) {
+	var raw interface{}
+	raw = new(StepFlock)
+	if _, ok := raw.(chroot.Cleanup); !ok {
+		t.Fatalf("cleanup func should be a CleanupFunc")
+	}
+}

builder/amazon/chroot/step_mount_device_test.go

@@ -0,0 +1,15 @@
+package chroot
+
+import (
+	"testing"
+
+	"github.com/hashicorp/packer-plugin-sdk/chroot"
+)
+
+func TestMountDeviceCleanupFunc_ImplementsCleanupFunc(t *testing.T) {
+	var raw interface{}
+	raw = new(StepMountDevice)
+	if _, ok := raw.(chroot.Cleanup); !ok {
+		t.Fatalf("cleanup func should be a CleanupFunc")
+	}
+}

builder/amazon/chroot/step_register_ami.go

@@ -6,11 +6,11 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer-plugin-amazon/builder/common"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 	"github.com/hashicorp/packer-plugin-sdk/random"
 	confighelper "github.com/hashicorp/packer-plugin-sdk/template/config"
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 )
 
 // StepRegisterAMI creates the AMI.

builder/amazon/chroot/step_register_ami_test.go

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

builder/amazon/chroot/step_snapshot.go

@@ -6,9 +6,9 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer-plugin-amazon/builder/common"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 )
 
 // StepSnapshot creates a snapshot of the created volume.

builder/amazon/common/access_config.go

@@ -17,7 +17,7 @@ import (
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	awsbase "github.com/hashicorp/aws-sdk-go-base"
 	cleanhttp "github.com/hashicorp/go-cleanhttp"
-	"github.com/hashicorp/packer-plugin-amazon/builder/common/awserrors"
+	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 	vaultapi "github.com/hashicorp/vault/api"
 )
 
@@ -29,7 +29,7 @@ import (
 // HCL config example:
 //
 // ```HCL
-// source "amazon-ebs" "example" {
+// source "example" "amazon-ebs"{
 // 	assume_role {
 // 		role_arn     = "arn:aws:iam::ACCOUNT_ID:role/ROLE_NAME"
 // 		session_name = "SESSION_NAME"
@@ -150,7 +150,7 @@ type AccessConfig struct {
 	// environmental variable.
 	Token   string `mapstructure:"token" required:"false"`
 	session *session.Session
-	// Get credentials from HashiCorp Vault's aws secrets engine. You must
+	// Get credentials from Hashicorp Vault's aws secrets engine. You must
 	// already have created a role to use. For more information about
 	// generating credentials via the Vault engine, see the [Vault
 	// docs.](https://www.vaultproject.io/api/secret/aws#generate-credentials)
@@ -174,16 +174,6 @@ type AccessConfig struct {
 	//     credential types) and GetFederationToken (for federation\_token
 	//     credential types) for more details.
 	//
-	// HCL2 example:
-	//
-	// ```hcl
-	// vault_aws_engine {
-	//     name = "myrole"
-	//     role_arn = "myarn"
-	//     ttl = "3600s"
-	// }
-	// ```
-	//
 	// JSON example:
 	//
 	// ```json
@@ -195,6 +185,16 @@ type AccessConfig struct {
 	//     }
 	// }
 	// ```
+	//
+	// HCL2 example:
+	//
+	// ```hcl
+	//   vault_aws_engine {
+	//       name = "myrole"
+	//       role_arn = "myarn"
+	//       ttl = "3600s"
+	//   }
+	// ```
 	VaultAWSEngine VaultAWSEngineOptions `mapstructure:"vault_aws_engine" required:"false"`
 	// [Polling configuration](#polling-configuration) for the AWS waiter. Configures the waiter that checks
 	// resource state.

builder/amazon/common/access_config_test.go

@@ -0,0 +1,57 @@
+package common
+
+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/ec2iface"
+)
+
+func testAccessConfig() *AccessConfig {
+	return &AccessConfig{
+		getEC2Connection: func() ec2iface.EC2API {
+			return &mockEC2Client{}
+		},
+		PollingConfig: new(AWSPollingConfig),
+	}
+}
+
+func TestAccessConfigPrepare_Region(t *testing.T) {
+	c := testAccessConfig()
+
+	c.RawRegion = "us-east-12"
+	err := c.ValidateRegion(c.RawRegion)
+	if err == nil {
+		t.Fatalf("should have region validation err: %s", c.RawRegion)
+	}
+
+	c.RawRegion = "us-east-1"
+	err = c.ValidateRegion(c.RawRegion)
+	if err != nil {
+		t.Fatalf("shouldn't have region validation err: %s", c.RawRegion)
+	}
+
+	c.RawRegion = "custom"
+	err = c.ValidateRegion(c.RawRegion)
+	if err == nil {
+		t.Fatalf("should have region validation err: %s", c.RawRegion)
+	}
+}
+
+func TestAccessConfigPrepare_RegionRestricted(t *testing.T) {
+	c := testAccessConfig()
+
+	// Create a Session with a custom region
+	c.session = session.Must(session.NewSession(&aws.Config{
+		Region: aws.String("us-gov-west-1"),
+	}))
+
+	if err := c.Prepare(); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
+	}
+
+	if !c.IsGovCloud() {
+		t.Fatal("We should be in gov region.")
+	}
+}

builder/amazon/common/ami_config.go

@@ -16,11 +16,11 @@ type AMIConfig struct {
 	// The name of the resulting AMI that will appear when managing AMIs in the
 	// AWS console or via APIs. This must be unique. To help make this unique,
 	// use a function like timestamp (see [template
-	// engine](/docs/templates/legacy_json_templates/engine) for more info).
+	// engine](/docs/templates/engine) for more info).
 	AMIName string `mapstructure:"ami_name" required:"true"`
 	// The description to set for the resulting
 	// AMI(s). By default this description is empty.  This is a
-	// [template engine](/docs/templates/legacy_json_templates/engine), see [Build template
+	// [template engine](/docs/templates/engine), see [Build template
 	// data](#build-template-data) for more information.
 	AMIDescription string `mapstructure:"ami_description" required:"false"`
 	// The type of virtualization for the AMI
@@ -47,7 +47,7 @@ type AMIConfig struct {
 	// validation of the ami_regions configuration option. Default false.
 	AMISkipRegionValidation bool `mapstructure:"skip_region_validation" required:"false"`
 	// Key/value pair tags applied to the AMI. This is a [template
-	// engine](/docs/templates/legacy_json_templates/engine), see [Build template
+	// engine](/docs/templates/engine), see [Build template
 	// data](#build-template-data) for more information.
 	AMITags map[string]string `mapstructure:"tags" required:"false"`
 	// Same as [`tags`](#tags) but defined as a singular repeatable block
@@ -135,8 +135,26 @@ type AMIConfig struct {
 	// the intermediary AMI into any regions provided in `ami_regions`, then
 	// delete the intermediary AMI. Default `false`.
 	AMISkipBuildRegion bool `mapstructure:"skip_save_build_region"`
-
-	SnapshotConfig `mapstructure:",squash"`
+	// Key/value pair tags to apply to snapshot. They will override AMI tags if
+	// already applied to snapshot. This is a [template
+	// engine](/docs/templates/engine), see [Build template
+	// data](#build-template-data) for more information.
+	SnapshotTags map[string]string `mapstructure:"snapshot_tags" required:"false"`
+	// Same as [`snapshot_tags`](#snapshot_tags) but defined as a singular
+	// repeatable block containing a `key` and a `value` field. In HCL2 mode the
+	// [`dynamic_block`](/docs/templates/hcl_templates/expressions#dynamic-blocks)
+	// will allow you to create those programatically.
+	SnapshotTag config.KeyValues `mapstructure:"snapshot_tag" required:"false"`
+	// A list of account IDs that have
+	// access to create volumes from the snapshot(s). By default no additional
+	// users other than the user creating the AMI has permissions to create
+	// volumes from the backing snapshot(s).
+	SnapshotUsers []string `mapstructure:"snapshot_users" required:"false"`
+	// A list of groups that have access to
+	// create volumes from the snapshot(s). By default no groups have permission
+	// to create volumes from the snapshot(s). all will make the snapshot
+	// publicly accessible.
+	SnapshotGroups []string `mapstructure:"snapshot_groups" required:"false"`
 }
 
 func stringInSlice(s []string, searchstr string) bool {
@@ -172,7 +190,7 @@ func (c *AMIConfig) Prepare(accessConfig *AccessConfig, ctx *interpolate.Context
 
 	// Prevent sharing of default KMS key encrypted volumes with other aws users
 	if len(c.AMIUsers) > 0 {
-		if len(c.AMIKmsKeyId) == 0 && len(c.AMIRegionKMSKeyIDs) == 0 && c.AMIEncryptBootVolume.True() {
+		if len(c.AMIKmsKeyId) == 0 && c.AMIEncryptBootVolume.True() {
 			errs = append(errs, fmt.Errorf("Cannot share AMI encrypted with default KMS key"))
 		}
 		if len(c.AMIRegionKMSKeyIDs) > 0 {

builder/amazon/common/ami_config_test.go

@@ -0,0 +1,249 @@
+package common
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/hashicorp/packer-plugin-sdk/template/config"
+)
+
+func testAMIConfig() *AMIConfig {
+	return &AMIConfig{
+		AMIName: "foo",
+	}
+}
+
+func getFakeAccessConfig(region string) *AccessConfig {
+	c := testAccessConfig()
+	c.RawRegion = region
+	return c
+}
+
+func TestAMIConfigPrepare_name(t *testing.T) {
+	c := testAMIConfig()
+	accessConf := testAccessConfig()
+	if err := c.Prepare(accessConf, nil); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
+	}
+
+	c.AMIName = ""
+	if err := c.Prepare(accessConf, nil); err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+type mockEC2Client struct {
+	ec2iface.EC2API
+}
+
+func (m *mockEC2Client) DescribeRegions(*ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error) {
+	return &ec2.DescribeRegionsOutput{
+		Regions: []*ec2.Region{
+			{RegionName: aws.String("us-east-1")},
+			{RegionName: aws.String("us-east-2")},
+			{RegionName: aws.String("us-west-1")},
+		},
+	}, nil
+}
+
+func TestAMIConfigPrepare_regions(t *testing.T) {
+	c := testAMIConfig()
+	c.AMIRegions = nil
+
+	var errs []error
+	var err error
+	accessConf := testAccessConfig()
+	mockConn := &mockEC2Client{}
+	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		t.Fatalf("shouldn't have err: %#v", errs)
+	}
+
+	c.AMIRegions, err = listEC2Regions(mockConn)
+	if err != nil {
+		t.Fatalf("shouldn't have err: %s", err.Error())
+	}
+	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		t.Fatalf("shouldn't have err: %#v", errs)
+	}
+
+	c.AMIRegions = []string{"us-east-1", "us-west-1", "us-east-1"}
+	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		t.Fatalf("bad: %s", errs[0])
+	}
+
+	expected := []string{"us-east-1", "us-west-1"}
+	if !reflect.DeepEqual(c.AMIRegions, expected) {
+		t.Fatalf("bad: %#v", c.AMIRegions)
+	}
+
+	c.AMIRegions = []string{"custom"}
+	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		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": "456-789-0123",
+	}
+	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		t.Fatal(fmt.Sprintf("shouldn't have error: %s", errs[0]))
+	}
+
+	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 errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		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 errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		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 errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		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(accessConf, nil); err == nil {
+		t.Fatal("should have error b/c theres a region in in ami_regions that isn't in the key map")
+	}
+
+	c.SnapshotUsers = []string{"foo", "bar"}
+	c.AMIKmsKeyId = "123-abc-456"
+	c.AMIEncryptBootVolume = config.TriTrue
+	c.AMIRegions = []string{"us-east-1", "us-west-1"}
+	c.AMIRegionKMSKeyIDs = map[string]string{
+		"us-east-1": "123-456-7890",
+		"us-west-1": "",
+	}
+	if errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		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 errs = c.prepareRegions(accessConf); len(errs) > 0 {
+		t.Fatal("should allow user to have the raw region in ami_regions")
+	}
+
+}
+
+func TestAMIConfigPrepare_Share_EncryptedBoot(t *testing.T) {
+	c := testAMIConfig()
+	c.AMIUsers = []string{"testAccountID"}
+	c.AMIEncryptBootVolume = config.TriTrue
+
+	accessConf := testAccessConfig()
+
+	c.AMIKmsKeyId = ""
+	if err := c.Prepare(accessConf, nil); err == nil {
+		t.Fatal("shouldn't be able to share ami with encrypted boot volume")
+	}
+	c.AMIKmsKeyId = "89c3fb9a-de87-4f2a-aedc-fddc5138193c"
+	if err := c.Prepare(accessConf, nil); err != nil {
+		t.Fatal("should be able to share ami with encrypted boot volume")
+	}
+}
+
+func TestAMIConfigPrepare_ValidateKmsKey(t *testing.T) {
+	c := testAMIConfig()
+	c.AMIEncryptBootVolume = config.TriTrue
+
+	accessConf := testAccessConfig()
+
+	validCases := []string{
+		"abcd1234-e567-890f-a12b-a123b4cd56ef",
+		"alias/foo/bar",
+		"arn:aws:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef",
+		"arn:aws:kms:us-east-1:012345678910:alias/foo/bar",
+		"arn:aws-us-gov:kms:us-gov-east-1:123456789012:key/12345678-1234-abcd-0000-123456789012",
+	}
+	for _, validCase := range validCases {
+		c.AMIKmsKeyId = validCase
+		if err := c.Prepare(accessConf, nil); err != nil {
+			t.Fatalf("%s should not have failed KMS key validation", validCase)
+		}
+	}
+
+	invalidCases := []string{
+		"ABCD1234-e567-890f-a12b-a123b4cd56ef",
+		"ghij1234-e567-890f-a12b-a123b4cd56ef",
+		"ghij1234+e567_890f-a12b-a123b4cd56ef",
+		"foo/bar",
+		"arn:aws:kms:us-east-1:012345678910:foo/bar",
+		"arn:foo:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef",
+	}
+	for _, invalidCase := range invalidCases {
+		c.AMIKmsKeyId = invalidCase
+		if err := c.Prepare(accessConf, nil); err == nil {
+			t.Fatalf("%s should have failed KMS key validation", invalidCase)
+		}
+	}
+
+}
+
+func TestAMINameValidation(t *testing.T) {
+	c := testAMIConfig()
+
+	accessConf := testAccessConfig()
+
+	c.AMIName = "aa"
+	if err := c.Prepare(accessConf, nil); err == nil {
+		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(accessConf, nil); err == nil {
+		t.Fatal("shouldn't be able to have an ami name with great than 128 characters")
+	}
+
+	c.AMIName = "+aaa"
+	if err := c.Prepare(accessConf, nil); err == nil {
+		t.Fatal("shouldn't be able to have an ami name with invalid characters")
+	}
+
+	c.AMIName = "fooBAR1()[] ./-'@_"
+	if err := c.Prepare(accessConf, nil); err != nil {
+		t.Fatal("should be able to use all of the allowed AMI characters")
+	}
+
+	c.AMIName = `xyz-base-2017-04-05-1934`
+	if err := c.Prepare(accessConf, nil); err != nil {
+		t.Fatalf("expected `xyz-base-2017-04-05-1934` to pass validation.")
+	}
+
+}

builder/amazon/common/ami_filter.go

@@ -51,10 +51,7 @@ func (d *AmiFilterOptions) GetFilteredImage(params *ec2.DescribeImagesInput, ec2
 	}
 
 	log.Printf("Using AMI Filters %v", params)
-	req, imageResp := ec2conn.DescribeImagesRequest(params)
-	req.RetryCount = 11
-
-	err := req.Send()
+	imageResp, err := ec2conn.DescribeImages(params)
 	if err != nil {
 		err := fmt.Errorf("Error querying AMI: %s", err)
 		return nil, err

builder/amazon/common/artifact_test.go

@@ -0,0 +1,90 @@
+package common
+
+import (
+	"reflect"
+	"testing"
+
+	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+)
+
+func TestArtifact_Impl(t *testing.T) {
+	var _ packersdk.Artifact = new(Artifact)
+}
+
+func TestArtifactId(t *testing.T) {
+	expected := `east:foo,west:bar`
+
+	amis := make(map[string]string)
+	amis["east"] = "foo"
+	amis["west"] = "bar"
+
+	a := &Artifact{
+		Amis: amis,
+	}
+
+	result := a.Id()
+	if result != expected {
+		t.Fatalf("bad: %s", result)
+	}
+}
+
+func TestArtifactState_atlasMetadata(t *testing.T) {
+	a := &Artifact{
+		Amis: 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)
+	}
+}
+
+func TestArtifactString(t *testing.T) {
+	expected := `AMIs were created:
+east: foo
+west: bar
+`
+
+	amis := make(map[string]string)
+	amis["east"] = "foo"
+	amis["west"] = "bar"
+
+	a := &Artifact{Amis: amis}
+	result := a.String()
+	if result != expected {
+		t.Fatalf("bad: %s", result)
+	}
+}
+
+func TestArtifactState(t *testing.T) {
+	expectedData := "this is the data"
+	artifact := &Artifact{
+		StateData: map[string]interface{}{"state_data": expectedData},
+	}
+
+	// Valid state
+	result := artifact.State("state_data")
+	if result != expectedData {
+		t.Fatalf("Bad: State data was %s instead of %s", result, expectedData)
+	}
+
+	// Invalid state
+	result = artifact.State("invalid_key")
+	if result != nil {
+		t.Fatalf("Bad: State should be nil for invalid state data name")
+	}
+
+	// Nil StateData should not fail and should return nil
+	artifact = &Artifact{}
+	result = artifact.State("key")
+	if result != nil {
+		t.Fatalf("Bad: State should be nil for nil StateData")
+	}
+}

builder/amazon/common/block_device.go

@@ -30,6 +30,18 @@ const (
 // The following mapping will tell Packer to encrypt the root volume of the
 // build instance at launch using a specific non-default kms key:
 //
+// JSON example:
+//
+// ```json
+// launch_block_device_mappings: [
+//   {
+//      "device_name": "/dev/sda1",
+//      "encrypted": true,
+//      "kms_key_id": "1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
+//   }
+// ]
+// ```
+//
 // HCL2 example:
 //
 // ```hcl
@@ -40,17 +52,6 @@ const (
 // }
 // ```
 //
-// JSON example:
-// ```json
-// "launch_block_device_mappings": [
-//   {
-//      "device_name": "/dev/sda1",
-//      "encrypted": true,
-//      "kms_key_id": "1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
-//   }
-// ]
-// ```
-//
 // Please note that the kms_key_id option in this example exists for
 // launch_block_device_mappings but not ami_block_device_mappings.
 //
@@ -75,7 +76,7 @@ type BlockDevice struct {
 	// See the documentation on
 	// [IOPs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EbsBlockDevice.html)
 	// for more information
-	IOPS *int64 `mapstructure:"iops" required:"false"`
+	IOPS int64 `mapstructure:"iops" required:"false"`
 	// Suppresses the specified device included in the block device mapping of
 	// the AMI.
 	NoDevice bool `mapstructure:"no_device" required:"false"`
@@ -85,7 +86,7 @@ type BlockDevice struct {
 	// See the documentation on
 	// [Throughput](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EbsBlockDevice.html)
 	// for more information
-	Throughput *int64 `mapstructure:"throughput" required:"false"`
+	Throughput int64 `mapstructure:"throughput" required:"false"`
 	// The virtual device name. See the documentation on Block Device Mapping
 	// for more information.
 	VirtualName string `mapstructure:"virtual_name" required:"false"`
@@ -149,12 +150,12 @@ func (blockDevice BlockDevice) BuildEC2BlockDeviceMapping() *ec2.BlockDeviceMapp
 
 	switch blockDevice.VolumeType {
 	case "io1", "io2", "gp3":
-		ebsBlockDevice.Iops = blockDevice.IOPS
+		ebsBlockDevice.Iops = aws.Int64(blockDevice.IOPS)
 	}
 
 	// Throughput is only valid for gp3 types
 	if blockDevice.VolumeType == "gp3" {
-		ebsBlockDevice.Throughput = blockDevice.Throughput
+		ebsBlockDevice.Throughput = aws.Int64(blockDevice.Throughput)
 	}
 
 	// You cannot specify Encrypted if you specify a Snapshot ID
@@ -190,28 +191,28 @@ func (b *BlockDevice) Prepare(ctx *interpolate.Context) error {
 	}
 
 	if ratio, ok := iopsRatios[b.VolumeType]; b.VolumeSize != 0 && ok {
-		if b.IOPS != nil && (*b.IOPS/b.VolumeSize > ratio) {
+		if b.IOPS/b.VolumeSize > ratio {
 			return fmt.Errorf("%s: the maximum ratio of provisioned IOPS to requested volume size "+
 				"(in GiB) is %v:1 for %s volumes", b.DeviceName, ratio, b.VolumeType)
 		}
 
-		if b.IOPS != nil && (*b.IOPS < minIops || *b.IOPS > maxIops) {
+		if b.IOPS < minIops || b.IOPS > maxIops {
 			return fmt.Errorf("IOPS must be between %d and %d for device %s",
 				minIops, maxIops, b.DeviceName)
 		}
 	}
 
 	if b.VolumeType == "gp3" {
-		if b.Throughput != nil && (*b.Throughput < minThroughput || *b.Throughput > maxThroughput) {
+		if b.Throughput < minThroughput || b.Throughput > maxThroughput {
 			return fmt.Errorf("Throughput must be between %d and %d for device %s",
 				minThroughput, maxThroughput, b.DeviceName)
 		}
 
-		if b.IOPS != nil && (*b.IOPS < minIopsGp3 || *b.IOPS > maxIopsGp3) {
+		if b.IOPS < minIopsGp3 || b.IOPS > maxIopsGp3 {
 			return fmt.Errorf("IOPS must be between %d and %d for device %s",
 				minIopsGp3, maxIopsGp3, b.DeviceName)
 		}
-	} else if b.Throughput != nil {
+	} else if b.Throughput > 0 {
 		return fmt.Errorf("Throughput is not available for device %s",
 			b.DeviceName)
 	}

builder/amazon/common/block_device_test.go

@@ -0,0 +1,401 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/google/go-cmp/cmp"
+	"github.com/hashicorp/packer-plugin-sdk/template/config"
+	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
+)
+
+func TestBlockDevice(t *testing.T) {
+	cases := []struct {
+		Config *BlockDevice
+		Result *ec2.BlockDeviceMapping
+	}{
+		{
+			Config: &BlockDevice{
+				DeviceName:          "/dev/sdb",
+				SnapshotId:          "snap-1234",
+				VolumeType:          "standard",
+				VolumeSize:          8,
+				DeleteOnTermination: true,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				Ebs: &ec2.EbsBlockDevice{
+					SnapshotId:          aws.String("snap-1234"),
+					VolumeType:          aws.String("standard"),
+					VolumeSize:          aws.Int64(8),
+					DeleteOnTermination: aws.Bool(true),
+				},
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeSize: 8,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				Ebs: &ec2.EbsBlockDevice{
+					VolumeSize:          aws.Int64(8),
+					DeleteOnTermination: aws.Bool(false),
+				},
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName:          "/dev/sdb",
+				VolumeType:          "io1",
+				VolumeSize:          8,
+				DeleteOnTermination: true,
+				IOPS:                1000,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				Ebs: &ec2.EbsBlockDevice{
+					VolumeType:          aws.String("io1"),
+					VolumeSize:          aws.Int64(8),
+					DeleteOnTermination: aws.Bool(true),
+					Iops:                aws.Int64(1000),
+				},
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName:          "/dev/sdb",
+				VolumeType:          "io2",
+				VolumeSize:          8,
+				DeleteOnTermination: true,
+				IOPS:                1000,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				Ebs: &ec2.EbsBlockDevice{
+					VolumeType:          aws.String("io2"),
+					VolumeSize:          aws.Int64(8),
+					DeleteOnTermination: aws.Bool(true),
+					Iops:                aws.Int64(1000),
+				},
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName:          "/dev/sdb",
+				VolumeType:          "gp2",
+				VolumeSize:          8,
+				DeleteOnTermination: true,
+				Encrypted:           config.TriTrue,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				Ebs: &ec2.EbsBlockDevice{
+					VolumeType:          aws.String("gp2"),
+					VolumeSize:          aws.Int64(8),
+					DeleteOnTermination: aws.Bool(true),
+					Encrypted:           aws.Bool(true),
+				},
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName:          "/dev/sdb",
+				VolumeType:          "gp2",
+				VolumeSize:          8,
+				DeleteOnTermination: true,
+				Encrypted:           config.TriTrue,
+				KmsKeyId:            "2Fa48a521f-3aff-4b34-a159-376ac5d37812",
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				Ebs: &ec2.EbsBlockDevice{
+					VolumeType:          aws.String("gp2"),
+					VolumeSize:          aws.Int64(8),
+					DeleteOnTermination: aws.Bool(true),
+					Encrypted:           aws.Bool(true),
+					KmsKeyId:            aws.String("2Fa48a521f-3aff-4b34-a159-376ac5d37812"),
+				},
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName:          "/dev/sdb",
+				VolumeType:          "standard",
+				DeleteOnTermination: true,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				Ebs: &ec2.EbsBlockDevice{
+					VolumeType:          aws.String("standard"),
+					DeleteOnTermination: aws.Bool(true),
+				},
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName:  "/dev/sdb",
+				VirtualName: "ephemeral0",
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName:  aws.String("/dev/sdb"),
+				VirtualName: aws.String("ephemeral0"),
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName: "/dev/sdb",
+				NoDevice:   true,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				NoDevice:   aws.String(""),
+			},
+		},
+		{
+			Config: &BlockDevice{
+				DeviceName:          "/dev/sdb",
+				VolumeType:          "gp3",
+				VolumeSize:          8,
+				Throughput:          125,
+				IOPS:                3000,
+				DeleteOnTermination: true,
+				Encrypted:           config.TriTrue,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName: aws.String("/dev/sdb"),
+				Ebs: &ec2.EbsBlockDevice{
+					VolumeType:          aws.String("gp3"),
+					VolumeSize:          aws.Int64(8),
+					Throughput:          aws.Int64(125),
+					Iops:                aws.Int64(3000),
+					DeleteOnTermination: aws.Bool(true),
+					Encrypted:           aws.Bool(true),
+				},
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		var amiBlockDevices BlockDevices = []BlockDevice{*tc.Config}
+
+		var launchBlockDevices BlockDevices = []BlockDevice{*tc.Config}
+
+		expected := []*ec2.BlockDeviceMapping{tc.Result}
+
+		amiResults := amiBlockDevices.BuildEC2BlockDeviceMappings()
+		if diff := cmp.Diff(expected, amiResults); diff != "" {
+			t.Fatalf("Bad block device: %s", diff)
+		}
+
+		launchResults := launchBlockDevices.BuildEC2BlockDeviceMappings()
+		if diff := cmp.Diff(expected, launchResults); diff != "" {
+			t.Fatalf("Bad block device: %s", diff)
+		}
+	}
+}
+
+func TestIOPSValidation(t *testing.T) {
+
+	cases := []struct {
+		device BlockDevice
+		ok     bool
+		msg    string
+	}{
+		// volume size unknown
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "io1",
+				IOPS:       1000,
+			},
+			ok: true,
+		},
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "io2",
+				IOPS:       1000,
+			},
+			ok: true,
+		},
+		// ratio requirement satisfied
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "io1",
+				VolumeSize: 50,
+				IOPS:       1000,
+			},
+			ok: true,
+		},
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "io2",
+				VolumeSize: 100,
+				IOPS:       1000,
+			},
+			ok: true,
+		},
+		// ratio requirement not satisfied
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "io1",
+				VolumeSize: 10,
+				IOPS:       2000,
+			},
+			ok:  false,
+			msg: "/dev/sdb: the maximum ratio of provisioned IOPS to requested volume size (in GiB) is 50:1 for io1 volumes",
+		},
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "io2",
+				VolumeSize: 50,
+				IOPS:       30000,
+			},
+			ok:  false,
+			msg: "/dev/sdb: the maximum ratio of provisioned IOPS to requested volume size (in GiB) is 500:1 for io2 volumes",
+		},
+		// exceed max iops
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "io2",
+				VolumeSize: 500,
+				IOPS:       99999,
+			},
+			ok:  false,
+			msg: "IOPS must be between 100 and 64000 for device /dev/sdb",
+		},
+		// lower than min iops
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "io2",
+				VolumeSize: 50,
+				IOPS:       10,
+			},
+			ok:  false,
+			msg: "IOPS must be between 100 and 64000 for device /dev/sdb",
+		},
+		// exceed max iops
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "gp3",
+				VolumeSize: 50,
+				Throughput: 125,
+				IOPS:       99999,
+			},
+			ok:  false,
+			msg: "IOPS must be between 3000 and 16000 for device /dev/sdb",
+		},
+		// lower than min iops
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "gp3",
+				VolumeSize: 50,
+				Throughput: 125,
+				IOPS:       10,
+			},
+			ok:  false,
+			msg: "IOPS must be between 3000 and 16000 for device /dev/sdb",
+		},
+	}
+
+	ctx := interpolate.Context{}
+	for _, testCase := range cases {
+		err := testCase.device.Prepare(&ctx)
+		if testCase.ok && err != nil {
+			t.Fatalf("should not error, but: %v", err)
+		}
+		if !testCase.ok {
+			if err == nil {
+				t.Fatalf("should error")
+			} else if err.Error() != testCase.msg {
+				t.Fatalf("wrong error: expected %s, found: %v", testCase.msg, err)
+			}
+		}
+	}
+}
+
+func TestThroughputValidation(t *testing.T) {
+
+	cases := []struct {
+		device BlockDevice
+		ok     bool
+		msg    string
+	}{
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "gp3",
+				Throughput: 125,
+				IOPS:       3000,
+			},
+			ok: true,
+		},
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "gp3",
+				Throughput: 1000,
+				IOPS:       3000,
+			},
+			ok: true,
+		},
+		// exceed max Throughput
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "gp3",
+				Throughput: 1001,
+				IOPS:       3000,
+			},
+			ok:  false,
+			msg: "Throughput must be between 125 and 1000 for device /dev/sdb",
+		},
+		// lower than min Throughput
+		{
+			device: BlockDevice{
+				DeviceName: "/dev/sdb",
+				VolumeType: "gp3",
+				Throughput: 124,
+				IOPS:       3000,
+			},
+			ok:  false,
+			msg: "Throughput must be between 125 and 1000 for device /dev/sdb",
+		},
+	}
+
+	ctx := interpolate.Context{}
+	for _, testCase := range cases {
+		err := testCase.device.Prepare(&ctx)
+		if testCase.ok && err != nil {
+			t.Fatalf("should not error, but: %v", err)
+		}
+		if !testCase.ok {
+			if err == nil {
+				t.Fatalf("should error")
+			} else if err.Error() != testCase.msg {
+				t.Fatalf("wrong error: expected %s, found: %v", testCase.msg, err)
+			}
+		}
+	}
+}

builder/amazon/common/build_filter_test.go

@@ -0,0 +1,31 @@
+package common
+
+import (
+	"testing"
+)
+
+func TestStepSourceAmiInfo_BuildFilter(t *testing.T) {
+	filter_key := "name"
+	filter_value := "foo"
+	filter_key2 := "name2"
+	filter_value2 := "foo2"
+
+	inputFilter := map[string]string{filter_key: filter_value, filter_key2: filter_value2}
+	outputFilter := buildEc2Filters(inputFilter)
+
+	// deconstruct filter back into things we can test
+	foundMap := map[string]bool{filter_key: false, filter_key2: false}
+	for _, filter := range outputFilter {
+		for key, value := range inputFilter {
+			if *filter.Name == key && *filter.Values[0] == value {
+				foundMap[key] = true
+			}
+		}
+	}
+
+	for k, v := range foundMap {
+		if !v {
+			t.Fatalf("Fail: should have found value for key: %s", k)
+		}
+	}
+}

builder/amazon/common/errors_test.go

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

builder/amazon/common/helper_funcs.go

@@ -8,8 +8,8 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer-plugin-amazon/builder/common/awserrors"
 	"github.com/hashicorp/packer-plugin-sdk/retry"
+	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 )
 
 // DestroyAMIs deregisters the AWS machine images in imageids from an active AWS account

builder/amazon/common/interpolate_build_info_test.go

@@ -0,0 +1,91 @@
+package common
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/packer-plugin-sdk/multistep"
+	"github.com/hashicorp/packer-plugin-sdk/packerbuilderdata"
+)
+
+func testImage() *ec2.Image {
+	return &ec2.Image{
+		ImageId:         aws.String("ami-abcd1234"),
+		CreationDate:    aws.String("ami_test_creation_date"),
+		Name:            aws.String("ami_test_name"),
+		OwnerId:         aws.String("ami_test_owner_id"),
+		ImageOwnerAlias: aws.String("ami_test_owner_alias"),
+		RootDeviceType:  aws.String("ebs"),
+		Tags: []*ec2.Tag{
+			{
+				Key:   aws.String("key-1"),
+				Value: aws.String("value-1"),
+			},
+			{
+				Key:   aws.String("key-2"),
+				Value: aws.String("value-2"),
+			},
+		},
+	}
+}
+
+func testState() multistep.StateBag {
+	state := new(multistep.BasicStateBag)
+	return state
+}
+
+func testGeneratedData(state multistep.StateBag) packerbuilderdata.GeneratedData {
+	generatedData := packerbuilderdata.GeneratedData{State: state}
+	return generatedData
+}
+
+func TestInterpolateBuildInfo_extractBuildInfo_noSourceImage(t *testing.T) {
+	state := testState()
+	generatedData := testGeneratedData(state)
+	buildInfo := extractBuildInfo("foo", state, &generatedData)
+
+	expected := BuildInfoTemplate{
+		BuildRegion: "foo",
+	}
+	if !reflect.DeepEqual(*buildInfo, expected) {
+		t.Fatalf("Unexpected BuildInfoTemplate: expected %#v got %#v\n", expected, *buildInfo)
+	}
+}
+
+func TestInterpolateBuildInfo_extractBuildInfo_withSourceImage(t *testing.T) {
+	state := testState()
+	state.Put("source_image", testImage())
+	generatedData := testGeneratedData(state)
+	buildInfo := extractBuildInfo("foo", state, &generatedData)
+
+	expected := BuildInfoTemplate{
+		BuildRegion:           "foo",
+		SourceAMI:             "ami-abcd1234",
+		SourceAMICreationDate: "ami_test_creation_date",
+		SourceAMIName:         "ami_test_name",
+		SourceAMIOwner:        "ami_test_owner_id",
+		SourceAMIOwnerName:    "ami_test_owner_alias",
+		SourceAMITags: map[string]string{
+			"key-1": "value-1",
+			"key-2": "value-2",
+		},
+	}
+	if !reflect.DeepEqual(*buildInfo, expected) {
+		t.Fatalf("Unexpected BuildInfoTemplate: expected %#v got %#v\n", expected, *buildInfo)
+	}
+}
+
+func TestInterpolateBuildInfo_extractBuildInfo_GeneratedDataWithSourceImageName(t *testing.T) {
+	state := testState()
+	state.Put("source_image", testImage())
+	generatedData := testGeneratedData(state)
+	extractBuildInfo("foo", state, &generatedData)
+
+	generatedDataState := state.Get("generated_data").(map[string]interface{})
+
+	if generatedDataState["SourceAMIName"] != "ami_test_name" {
+		t.Fatalf("Unexpected state SourceAMIName: expected %#v got %#v\n", "ami_test_name", generatedDataState["SourceAMIName"])
+	}
+}

builder/amazon/common/run_config.go

@@ -1,5 +1,5 @@
 //go:generate struct-markdown
-//go:generate mapstructure-to-hcl2 -type AmiFilterOptions,SecurityGroupFilterOptions,SubnetFilterOptions,VpcFilterOptions,PolicyDocument,Statement,MetadataOptions
+//go:generate mapstructure-to-hcl2 -type AmiFilterOptions,SecurityGroupFilterOptions,SubnetFilterOptions,VpcFilterOptions,PolicyDocument,Statement
 
 package common
 
@@ -44,20 +44,6 @@ type SecurityGroupFilterOptions struct {
 	config.NameValueFilter `mapstructure:",squash"`
 }
 
-// Configures the metadata options.
-// See [Configure IMDS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) for details.
-type MetadataOptions struct {
-	// A string to enable or disble the IMDS endpoint for an instance. Defaults to enabled.
-	// Accepts either "enabled" or "disabled"
-	HttpEndpoint string `mapstructure:"http_endpoint" required:"false"`
-	// A string to either set the use of IMDSv2 for the instance to optional or required. Defaults to "optional".
-	// Accepts either "optional" or "required"
-	HttpTokens string `mapstructure:"http_tokens" required:"false"`
-	// A numerical value to set an upper limit for the amount of hops allowed when communicating with IMDS endpoints.
-	// Defaults to 1.
-	HttpPutResponseHopLimit int64 `mapstructure:"http_put_response_hop_limit" required:"false"`
-}
-
 // RunConfig contains configuration for running an instance from a source
 // AMI and details on how to access that launched image.
 type RunConfig struct {
@@ -132,21 +118,8 @@ type RunConfig struct {
 	// Whether or not to check if the IAM instance profile exists. Defaults to false
 	SkipProfileValidation bool `mapstructure:"skip_profile_validation" required:"false"`
 	// Temporary IAM instance profile policy document
-	// If IamInstanceProfile is specified it will be used instead.
+	// If IamInstanceProfile is specified it will be used instead. Example:
 	//
-	// HCL2 example:
-	// ```hcl
-	//temporary_iam_instance_profile_policy_document {
-	//	Statement {
-	//		Action   = ["logs:*"]
-	//		Effect   = "Allow"
-	//		Resource = "*"
-	//	}
-	//	Version = "2012-10-17"
-	//}
-	// ```
-	//
-	// JSON example:
 	// ```json
 	//{
 	//	"Version": "2012-10-17",
@@ -170,7 +143,17 @@ type RunConfig struct {
 	// The EC2 instance type to use while building the
 	// AMI, such as t2.small.
 	InstanceType string `mapstructure:"instance_type" required:"true"`
-	// Filters used to populate the `security_group_ids` field.
+	// Filters used to populate the `security_group_ids` field. JSON Example:
+	//
+	// ```json
+	// {
+	//   "security_group_filter": {
+	//     "filters": {
+	//       "tag:Class": "packer"
+	//     }
+	//   }
+	// }
+	// ```
 	//
 	// HCL2 Example:
 	//
@@ -182,17 +165,6 @@ type RunConfig struct {
 	//   }
 	// ```
 	//
-	// JSON Example:
-	// ```json
-	// {
-	//   "security_group_filter": {
-	//     "filters": {
-	//       "tag:Class": "packer"
-	//     }
-	//   }
-	// }
-	// ```
-	//
 	// This selects the SG's with tag `Class` with the value `packer`.
 	//
 	// -   `filters` (map of strings) - filters used to select a
@@ -204,7 +176,7 @@ type RunConfig struct {
 	SecurityGroupFilter SecurityGroupFilterOptions `mapstructure:"security_group_filter" required:"false"`
 	// Key/value pair tags to apply to the instance that is that is *launched*
 	// to create the EBS volumes. This is a [template
-	// engine](/docs/templates/legacy_json_templates/engine), see [Build template
+	// engine](/docs/templates/engine), see [Build template
 	// data](#build-template-data) for more information.
 	RunTags map[string]string `mapstructure:"run_tags" required:"false"`
 	// Same as [`run_tags`](#run_tags) but defined as a singular repeatable
@@ -224,27 +196,12 @@ type RunConfig struct {
 	SecurityGroupIds []string `mapstructure:"security_group_ids" required:"false"`
 	// The source AMI whose root volume will be copied and
 	// provisioned on the currently running instance. This must be an EBS-backed
-	// AMI with a root volume snapshot that you have access to.
+	// AMI with a root volume snapshot that you have access to. Note: this is not
+	// used when from_scratch is set to true.
 	SourceAmi string `mapstructure:"source_ami" required:"true"`
 	// Filters used to populate the `source_ami`
-	// field.
+	// field. JSON Example:
 	//
-	// HCL2 example:
-	// ```hcl
-	// source "amazon-ebs" "basic-example" {
-	//   source_ami_filter {
-	//     filters = {
-	//        virtualization-type = "hvm"
-	//        name = "ubuntu/images/\*ubuntu-xenial-16.04-amd64-server-\*"
-	//        root-device-type = "ebs"
-	//     }
-	//     owners = ["099720109477"]
-	//     most_recent = true
-	//   }
-	// }
-	// ```
-	//
-	// JSON Example:
 	// ```json
 	// "builders" [
 	//   {
@@ -261,6 +218,21 @@ type RunConfig struct {
 	//   }
 	// ]
 	// ```
+	// HCL2 example:
+	//
+	// ```hcl
+	// source "amazon-ebs" "basic-example" {
+	//   source_ami_filter {
+	//     filters = {
+	//        virtualization-type = "hvm"
+	//        name = "ubuntu/images/\*ubuntu-xenial-16.04-amd64-server-\*"
+	//        root-device-type = "ebs"
+	//     }
+	//     owners = ["099720109477"]
+	//     most_recent = true
+	//   }
+	// }
+	// ```
 	//
 	//   This selects the most recent Ubuntu 16.04 HVM EBS AMI from Canonical. NOTE:
 	//   This will fail unless *exactly* one AMI is returned. In the above example,
@@ -328,22 +300,8 @@ type RunConfig struct {
 	// will allow you to create those programatically.
 	SpotTag config.KeyValues `mapstructure:"spot_tag" required:"false"`
 	// Filters used to populate the `subnet_id` field.
-	//
-	// HCL2 example:
-	//
-	// ```hcl
-	// source "amazon-ebs" "basic-example" {
-	//   subnet_filter {
-	//     filters = {
-	//           "tag:Class": "build"
-	//     }
-	//     most_free = true
-	//     random = false
-	//   }
-	// }
-	// ```
-	//
 	// JSON Example:
+	//
 	// ```json
 	// "builders" [
 	//   {
@@ -358,6 +316,19 @@ type RunConfig struct {
 	//   }
 	// ]
 	// ```
+	// HCL2 example:
+	//
+	// ```hcl
+	// source "amazon-ebs" "basic-example" {
+	//   subnet_filter {
+	//     filters = {
+	//           "tag:Class": "build"
+	//     }
+	//     most_free = true
+	//     random = false
+	//   }
+	// }
+	// ```
 	//
 	//   This selects the Subnet with tag `Class` with the value `build`, which has
 	//   the most free IP addresses. NOTE: This will fail unless *exactly* one
@@ -404,21 +375,8 @@ type RunConfig struct {
 	// data when launching the instance.
 	UserDataFile string `mapstructure:"user_data_file" required:"false"`
 	// Filters used to populate the `vpc_id` field.
-	//
-	// HCL2 example:
-	// ```hcl
-	// source "amazon-ebs" "basic-example" {
-	//   vpc_filter {
-	//     filters = {
-	//       "tag:Class": "build",
-	//       "isDefault": "false",
-	//       "cidr": "/24"
-	//     }
-	//   }
-	// }
-	// ```
-	//
 	// JSON Example:
+	//
 	// ```json
 	// "builders" [
 	//   {
@@ -433,6 +391,19 @@ type RunConfig struct {
 	//   }
 	// ]
 	// ```
+	// HCL2 example:
+	//
+	// ```hcl
+	// source "amazon-ebs" "basic-example" {
+	//   vpc_filter {
+	//     filters = {
+	//       "tag:Class": "build",
+	//       "isDefault": "false",
+	//       "cidr": "/24"
+	//     }
+	//   }
+	// }
+	// ```
 	//
 	// This selects the VPC with tag `Class` with the value `build`, which is not
 	// the default VPC, and have a IPv4 CIDR block of `/24`. NOTE: This will fail
@@ -456,9 +427,6 @@ type RunConfig struct {
 	// 10m
 	WindowsPasswordTimeout time.Duration `mapstructure:"windows_password_timeout" required:"false"`
 
-	// [Metadata Settings](#metadata-settings)
-	Metadata MetadataOptions `mapstructure:"metadata_options" required:"false"`
-
 	// Communicator settings
 	Comm communicator.Config `mapstructure:",squash"`
 
@@ -519,33 +487,6 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 	// Validation
 	errs := c.Comm.Prepare(ctx)
 
-	if c.Metadata.HttpEndpoint == "" {
-		c.Metadata.HttpEndpoint = "enabled"
-	}
-
-	if c.Metadata.HttpTokens == "" {
-		c.Metadata.HttpTokens = "optional"
-	}
-
-	if c.Metadata.HttpPutResponseHopLimit == 0 {
-		c.Metadata.HttpPutResponseHopLimit = 1
-	}
-
-	if c.Metadata.HttpEndpoint != "enabled" && c.Metadata.HttpEndpoint != "disabled" {
-		msg := fmt.Errorf("http_endpoint requires either disabled or enabled as its value")
-		errs = append(errs, msg)
-	}
-
-	if c.Metadata.HttpTokens != "optional" && c.Metadata.HttpTokens != "required" {
-		msg := fmt.Errorf("http_tokens requires either optional or required as its value")
-		errs = append(errs, msg)
-	}
-
-	if c.Metadata.HttpPutResponseHopLimit < 1 || c.Metadata.HttpPutResponseHopLimit > 64 {
-		msg := fmt.Errorf("http_put_response_hop_limit requires a number between 1 and 64")
-		errs = append(errs, msg)
-	}
-
 	// Copy singular tag maps
 	errs = append(errs, c.RunTag.CopyOn(&c.RunTags)...)
 	errs = append(errs, c.SpotTag.CopyOn(&c.SpotTags)...)

builder/amazon/common/run_config.hcl2spec.go

@@ -1,4 +1,4 @@
-// Code generated by "mapstructure-to-hcl2 -type AmiFilterOptions,SecurityGroupFilterOptions,SubnetFilterOptions,VpcFilterOptions,PolicyDocument,Statement,MetadataOptions"; DO NOT EDIT.
+// Code generated by "mapstructure-to-hcl2 -type AmiFilterOptions,SecurityGroupFilterOptions,SubnetFilterOptions,VpcFilterOptions,PolicyDocument,Statement"; DO NOT EDIT.
 
 package common
 
@@ -35,33 +35,6 @@ func (*FlatAmiFilterOptions) HCL2Spec() map[string]hcldec.Spec {
 	return s
 }
 
-// FlatMetadataOptions is an auto-generated flat version of MetadataOptions.
-// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
-type FlatMetadataOptions struct {
-	HttpEndpoint            *string `mapstructure:"http_endpoint" required:"false" cty:"http_endpoint" hcl:"http_endpoint"`
-	HttpTokens              *string `mapstructure:"http_tokens" required:"false" cty:"http_tokens" hcl:"http_tokens"`
-	HttpPutResponseHopLimit *int64  `mapstructure:"http_put_response_hop_limit" required:"false" cty:"http_put_response_hop_limit" hcl:"http_put_response_hop_limit"`
-}
-
-// FlatMapstructure returns a new FlatMetadataOptions.
-// FlatMetadataOptions is an auto-generated flat version of MetadataOptions.
-// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
-func (*MetadataOptions) FlatMapstructure() interface{ HCL2Spec() map[string]hcldec.Spec } {
-	return new(FlatMetadataOptions)
-}
-
-// HCL2Spec returns the hcl spec of a MetadataOptions.
-// This spec is used by HCL to read the fields of MetadataOptions.
-// The decoded values from this spec will then be applied to a FlatMetadataOptions.
-func (*FlatMetadataOptions) HCL2Spec() map[string]hcldec.Spec {
-	s := map[string]hcldec.Spec{
-		"http_endpoint":               &hcldec.AttrSpec{Name: "http_endpoint", Type: cty.String, Required: false},
-		"http_tokens":                 &hcldec.AttrSpec{Name: "http_tokens", Type: cty.String, Required: false},
-		"http_put_response_hop_limit": &hcldec.AttrSpec{Name: "http_put_response_hop_limit", Type: cty.Number, Required: false},
-	}
-	return s
-}
-
 // FlatPolicyDocument is an auto-generated flat version of PolicyDocument.
 // Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
 type FlatPolicyDocument struct {

builder/amazon/common/run_config_test.go

@@ -0,0 +1,251 @@
+package common
+
+import (
+	"io/ioutil"
+	"os"
+	"regexp"
+	"testing"
+
+	"github.com/hashicorp/packer-plugin-sdk/communicator"
+)
+
+func init() {
+	// Clear out the AWS access key env vars so they don't
+	// affect our tests.
+	os.Setenv("AWS_ACCESS_KEY_ID", "")
+	os.Setenv("AWS_ACCESS_KEY", "")
+	os.Setenv("AWS_SECRET_ACCESS_KEY", "")
+	os.Setenv("AWS_SECRET_KEY", "")
+}
+
+func testConfig() *RunConfig {
+	return &RunConfig{
+		SourceAmi:    "abcd",
+		InstanceType: "m1.small",
+
+		Comm: communicator.Config{
+			SSH: communicator.SSH{
+				SSHUsername: "foo",
+			},
+		},
+	}
+}
+
+func testConfigFilter() *RunConfig {
+	config := testConfig()
+	config.SourceAmi = ""
+	config.SourceAmiFilter = AmiFilterOptions{}
+	return config
+}
+
+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("Should error if an instance_type is not specified")
+	}
+}
+
+func TestRunConfigPrepare_SourceAmi(t *testing.T) {
+	c := testConfig()
+	c.SourceAmi = ""
+	if err := c.Prepare(nil); len(err) != 2 {
+		t.Fatalf("Should error if a source_ami (or source_ami_filter) is not specified")
+	}
+}
+
+func TestRunConfigPrepare_SourceAmiFilterBlank(t *testing.T) {
+	c := testConfigFilter()
+	if err := c.Prepare(nil); len(err) != 2 {
+		t.Fatalf("Should error if source_ami_filter is empty or not specified (and source_ami is not specified)")
+	}
+}
+
+func TestRunConfigPrepare_SourceAmiFilterOwnersBlank(t *testing.T) {
+	c := testConfigFilter()
+	filter_key := "name"
+	filter_value := "foo"
+	c.SourceAmiFilter.Filters = map[string]string{filter_key: filter_value}
+	if err := c.Prepare(nil); len(err) != 1 {
+		t.Fatalf("Should error if Owners is not specified)")
+	}
+}
+
+func TestRunConfigPrepare_SourceAmiFilterGood(t *testing.T) {
+	c := testConfigFilter()
+	owner := "123"
+	filter_key := "name"
+	filter_value := "foo"
+	goodFilter := AmiFilterOptions{
+		Owners:  []string{owner},
+		Filters: map[string]string{filter_key: filter_value},
+	}
+	c.SourceAmiFilter = goodFilter
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestRunConfigPrepare_EnableT2UnlimitedGood(t *testing.T) {
+	c := testConfig()
+	// Must have a T2 instance type if T2 Unlimited is enabled
+	c.InstanceType = "t2.micro"
+	c.EnableT2Unlimited = true
+	err := c.Prepare(nil)
+	if len(err) > 0 {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestRunConfigPrepare_EnableT2UnlimitedBadInstanceType(t *testing.T) {
+	c := testConfig()
+	// T2 Unlimited cannot be used with instance types other than T2
+	c.InstanceType = "m5.large"
+	c.EnableT2Unlimited = true
+	err := c.Prepare(nil)
+	if len(err) != 1 {
+		t.Fatalf("Should error if T2 Unlimited is enabled with non-T2 instance_type")
+	}
+}
+
+func TestRunConfigPrepare_EnableT2UnlimitedBadWithSpotInstanceRequest(t *testing.T) {
+	c := testConfig()
+	// T2 Unlimited cannot be used with Spot Instances
+	c.InstanceType = "t2.micro"
+	c.EnableT2Unlimited = true
+	c.SpotPrice = "auto"
+	err := c.Prepare(nil)
+	if len(err) != 1 {
+		t.Fatalf("Should error if T2 Unlimited has been used in conjuntion with a Spot Price request")
+	}
+}
+
+func TestRunConfigPrepare_SpotAuto(t *testing.T) {
+	c := testConfig()
+	c.SpotPrice = "auto"
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Shouldn't error (YET) even though SpotPriceAutoProduct is deprecated
+	c.SpotPriceAutoProduct = "Linux/Unix"
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestRunConfigPrepare_SSHPort(t *testing.T) {
+	c := testConfig()
+	c.Comm.SSHPort = 0
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+
+	if c.Comm.SSHPort != 22 {
+		t.Fatalf("invalid value: %d", c.Comm.SSHPort)
+	}
+
+	c.Comm.SSHPort = 44
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+
+	if c.Comm.SSHPort != 44 {
+		t.Fatalf("invalid value: %d", c.Comm.SSHPort)
+	}
+}
+
+func TestRunConfigPrepare_UserData(t *testing.T) {
+	c := testConfig()
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.Remove(tf.Name())
+	defer tf.Close()
+
+	c.UserData = "foo"
+	c.UserDataFile = tf.Name()
+	if err := c.Prepare(nil); len(err) != 1 {
+		t.Fatalf("Should error if user_data string and user_data_file have both been specified")
+	}
+}
+
+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("Should error if the file specified by user_data_file does not exist")
+	}
+
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.Remove(tf.Name())
+	defer tf.Close()
+
+	c.UserDataFile = tf.Name()
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestRunConfigPrepare_TemporaryKeyPairName(t *testing.T) {
+	c := testConfig()
+	c.Comm.SSHTemporaryKeyPairName = ""
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+
+	if c.Comm.SSHTemporaryKeyPairName == "" {
+		t.Fatal("keypair name is empty")
+	}
+
+	// Match prefix and UUID, e.g. "packer_5790d491-a0b8-c84c-c9d2-2aea55086550".
+	r := regexp.MustCompile(`\Apacker_(?:(?i)[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}?)\z`)
+	if !r.MatchString(c.Comm.SSHTemporaryKeyPairName) {
+		t.Fatal("keypair name is not valid")
+	}
+
+	c.Comm.SSHTemporaryKeyPairName = "ssh-key-123"
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+
+	if c.Comm.SSHTemporaryKeyPairName != "ssh-key-123" {
+		t.Fatal("keypair name does not match")
+	}
+}
+
+func TestRunConfigPrepare_TenancyBad(t *testing.T) {
+	c := testConfig()
+	c.Tenancy = "not_real"
+
+	if err := c.Prepare(nil); len(err) != 1 {
+		t.Fatal("Should error if tenancy is set to an invalid type")
+	}
+}
+
+func TestRunConfigPrepare_TenancyGood(t *testing.T) {
+	validTenancy := []string{"", "default", "dedicated", "host"}
+	for _, vt := range validTenancy {
+		c := testConfig()
+		c.Tenancy = vt
+		if err := c.Prepare(nil); len(err) != 0 {
+			t.Fatalf("Should not error if tenancy is set to %s", vt)
+		}
+	}
+}

builder/amazon/common/ssh_test.go

@@ -0,0 +1,141 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/packer-plugin-sdk/multistep"
+)
+
+const (
+	privateIP       = "10.0.0.1"
+	publicIP        = "192.168.1.1"
+	privateDNS      = "private.dns.test"
+	publicDNS       = "public.dns.test"
+	localhost       = "localhost"
+	sshHostTemplate = "custom.host.value"
+)
+
+func TestSSHHost(t *testing.T) {
+	origSshHostSleepDuration := sshHostSleepDuration
+	defer func() { sshHostSleepDuration = origSshHostSleepDuration }()
+	sshHostSleepDuration = 0
+
+	var cases = []struct {
+		allowTries   int
+		vpcId        string
+		sshInterface string
+
+		ok              bool
+		wantHost        string
+		sshHostOverride string
+	}{
+		{1, "", "", true, publicDNS, ""},
+		{1, "", "private_ip", true, privateIP, ""},
+		{1, "", "session_manager", true, localhost, ""},
+		{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, ""},
+		{1, "vpc-id", "session_manager", true, localhost, ""},
+		{2, "", "", true, publicDNS, ""},
+		{2, "", "private_ip", true, privateIP, ""},
+		{2, "vpc-id", "", true, publicIP, ""},
+		{2, "vpc-id", "private_ip", true, privateIP, ""},
+		{2, "vpc-id", "private_dns", true, privateDNS, ""},
+		{2, "vpc-id", "public_dns", true, publicDNS, ""},
+		{2, "vpc-id", "public_ip", true, publicIP, ""},
+		{3, "", "", false, "", ""},
+		{3, "", "private_ip", false, "", ""},
+		{3, "vpc-id", "", false, "", ""},
+		{3, "vpc-id", "private_ip", false, "", ""},
+		{3, "vpc-id", "private_dns", false, "", ""},
+		{3, "vpc-id", "public_dns", false, "", ""},
+		{3, "vpc-id", "public_ip", false, "", ""},
+		{1, "", "", true, sshHostTemplate, sshHostTemplate},
+		{1, "vpc-id", "", true, sshHostTemplate, sshHostTemplate},
+		{2, "vpc-id", "private_dns", true, sshHostTemplate, sshHostTemplate},
+	}
+
+	for _, c := range cases {
+		testSSHHost(t, c.allowTries, c.vpcId, c.sshInterface, c.ok, c.wantHost,
+			c.sshHostOverride)
+	}
+}
+
+func testSSHHost(t *testing.T, allowTries int, vpcId string, sshInterface string,
+	ok bool, wantHost string, sshHostOverride string) {
+	t.Logf("allowTries=%d vpcId=%s sshInterface=%s ok=%t wantHost=%q sshHostOverride=%s",
+		allowTries, vpcId, sshInterface, ok, wantHost, sshHostOverride)
+
+	e := &fakeEC2Describer{
+		allowTries: allowTries,
+		vpcId:      vpcId,
+		privateIP:  privateIP,
+		publicIP:   publicIP,
+		privateDNS: privateDNS,
+		publicDNS:  publicDNS,
+	}
+
+	f := SSHHost(e, sshInterface, sshHostOverride)
+	st := &multistep.BasicStateBag{}
+	st.Put("instance", &ec2.Instance{
+		InstanceId: aws.String("instance-id"),
+	})
+
+	host, err := f(st)
+
+	if e.tries > allowTries {
+		t.Fatalf("got %d ec2 DescribeInstances tries, want %d", e.tries, allowTries)
+	}
+
+	switch {
+	case ok && err != nil:
+		t.Fatalf("expected no error, got %+v", err)
+	case !ok && err == nil:
+		t.Fatalf("expected error, got none and host %s", host)
+	}
+
+	if host != wantHost {
+		t.Fatalf("got host %s, want %s", host, wantHost)
+	}
+}
+
+type fakeEC2Describer struct {
+	allowTries int
+	tries      int
+
+	vpcId                                      string
+	privateIP, publicIP, privateDNS, publicDNS string
+}
+
+func (d *fakeEC2Describer) DescribeInstances(in *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) {
+	d.tries++
+
+	instance := &ec2.Instance{
+		InstanceId: aws.String("instance-id"),
+	}
+
+	if d.vpcId != "" {
+		instance.VpcId = aws.String(d.vpcId)
+	}
+
+	if d.tries >= d.allowTries {
+		instance.PublicIpAddress = aws.String(d.publicIP)
+		instance.PrivateIpAddress = aws.String(d.privateIP)
+		instance.PublicDnsName = aws.String(d.publicDNS)
+		instance.PrivateDnsName = aws.String(d.privateDNS)
+	}
+
+	out := &ec2.DescribeInstancesOutput{
+		Reservations: []*ec2.Reservation{
+			{
+				Instances: []*ec2.Instance{instance},
+			},
+		},
+	}
+
+	return out, nil
+}

builder/amazon/common/ssm/session.go

@@ -12,10 +12,10 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ssm"
 	"github.com/aws/aws-sdk-go/service/ssm/ssmiface"
-	"github.com/hashicorp/packer-plugin-amazon/builder/common/awserrors"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 	"github.com/hashicorp/packer-plugin-sdk/retry"
 	"github.com/hashicorp/packer-plugin-sdk/shell-local/localexec"
+	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 )
 
 type Session struct {

builder/amazon/common/state.go

@@ -42,8 +42,17 @@ type StateChangeConf struct {
 
 // Polling configuration for the AWS waiter. Configures the waiter for resources creation or actions like attaching
 // volumes or importing image.
+// Usage example:
 //
-// HCL2 example:
+// In JSON:
+// ```json
+// "aws_polling" : {
+// 	 "delay_seconds": 30,
+// 	 "max_attempts": 50
+// }
+// ```
+//
+// In HCL2:
 // ```hcl
 // aws_polling {
 //	 delay_seconds = 30
@@ -51,13 +60,6 @@ type StateChangeConf struct {
 // }
 // ```
 //
-// JSON example:
-// ```json
-// "aws_polling" : {
-// 	 "delay_seconds": 30,
-// 	 "max_attempts": 50
-// }
-// ```
 type AWSPollingConfig struct {
 	// Specifies the maximum number of attempts the waiter will check for resource state.
 	// This value can also be set via the AWS_MAX_ATTEMPTS.
@@ -149,22 +151,15 @@ func (w *AWSPollingConfig) WaitUntilVolumeAvailable(ctx aws.Context, conn *ec2.E
 	return err
 }
 
-func (w *AWSPollingConfig) WaitUntilSnapshotDone(ctx aws.Context, conn ec2iface.EC2API, snapshotID string) error {
+func (w *AWSPollingConfig) WaitUntilSnapshotDone(ctx aws.Context, conn *ec2.EC2, snapshotID string) error {
 	snapInput := ec2.DescribeSnapshotsInput{
 		SnapshotIds: []*string{&snapshotID},
 	}
 
-	waitOpts := w.getWaiterOptions()
-	if len(waitOpts) == 0 {
-		// Bump this default to 30 minutes.
-		// Large snapshots can take a long time for the copy to s3
-		waitOpts = append(waitOpts, request.WithWaiterMaxAttempts(120))
-	}
-
 	err := conn.WaitUntilSnapshotCompletedWithContext(
 		ctx,
 		&snapInput,
-		waitOpts...)
+		w.getWaiterOptions()...)
 	return err
 }
 

builder/amazon/common/state_test.go

@@ -0,0 +1,66 @@
+package common
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws/request"
+)
+
+func testGetWaiterOptions(t *testing.T) {
+	// no vars are set
+	envValues := overridableWaitVars{
+		envInfo{"AWS_POLL_DELAY_SECONDS", 2, false},
+		envInfo{"AWS_MAX_ATTEMPTS", 0, false},
+		envInfo{"AWS_TIMEOUT_SECONDS", 300, false},
+	}
+	options := applyEnvOverrides(envValues)
+	if len(options) > 0 {
+		t.Fatalf("Did not expect any waiter options to be generated; actual: %#v", options)
+	}
+
+	// all vars are set
+	envValues = overridableWaitVars{
+		envInfo{"AWS_POLL_DELAY_SECONDS", 1, true},
+		envInfo{"AWS_MAX_ATTEMPTS", 800, true},
+		envInfo{"AWS_TIMEOUT_SECONDS", 20, true},
+	}
+	options = applyEnvOverrides(envValues)
+	expected := []request.WaiterOption{
+		request.WithWaiterDelay(request.ConstantWaiterDelay(time.Duration(1) * time.Second)),
+		request.WithWaiterMaxAttempts(800),
+	}
+	if !reflect.DeepEqual(options, expected) {
+		t.Fatalf("expected != actual!! Expected: %#v; Actual: %#v.", expected, options)
+	}
+
+	// poll delay is not set
+	envValues = overridableWaitVars{
+		envInfo{"AWS_POLL_DELAY_SECONDS", 2, false},
+		envInfo{"AWS_MAX_ATTEMPTS", 800, true},
+		envInfo{"AWS_TIMEOUT_SECONDS", 300, false},
+	}
+	options = applyEnvOverrides(envValues)
+	expected = []request.WaiterOption{
+		request.WithWaiterMaxAttempts(800),
+	}
+	if !reflect.DeepEqual(options, expected) {
+		t.Fatalf("expected != actual!! Expected: %#v; Actual: %#v.", expected, options)
+	}
+
+	// poll delay is not set but timeout seconds is
+	envValues = overridableWaitVars{
+		envInfo{"AWS_POLL_DELAY_SECONDS", 2, false},
+		envInfo{"AWS_MAX_ATTEMPTS", 0, false},
+		envInfo{"AWS_TIMEOUT_SECONDS", 20, true},
+	}
+	options = applyEnvOverrides(envValues)
+	expected = []request.WaiterOption{
+		request.WithWaiterDelay(request.ConstantWaiterDelay(time.Duration(2) * time.Second)),
+		request.WithWaiterMaxAttempts(10),
+	}
+	if !reflect.DeepEqual(options, expected) {
+		t.Fatalf("expected != actual!! Expected: %#v; Actual: %#v.", expected, options)
+	}
+}

builder/amazon/common/step_ami_region_copy.go

@@ -24,7 +24,6 @@ type StepAMIRegionCopy struct {
 
 	toDelete           string
 	getRegionConn      func(*AccessConfig, string) (ec2iface.EC2API, error)
-	AMISkipCreateImage bool
 	AMISkipBuildRegion bool
 }
 
@@ -64,12 +63,6 @@ func (s *StepAMIRegionCopy) DeduplicateRegions(intermediary bool) {
 
 func (s *StepAMIRegionCopy) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packersdk.Ui)
-
-	if s.AMISkipCreateImage {
-		ui.Say("Skipping AMI region copy...")
-		return multistep.ActionContinue
-	}
-
 	amis := state.Get("amis").(map[string]string)
 	snapshots := state.Get("snapshots").(map[string][]string)
 	intermediary, _ := state.Get("intermediary_image").(bool)

builder/amazon/common/step_ami_region_copy_test.go

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

builder/amazon/common/step_create_ssm_tunnel.go

@@ -9,10 +9,10 @@ import (
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/ssm"
-	pssm "github.com/hashicorp/packer-plugin-amazon/builder/common/ssm"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	"github.com/hashicorp/packer-plugin-sdk/net"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+	pssm "github.com/hashicorp/packer/builder/amazon/common/ssm"
 )
 
 type StepCreateSSMTunnel struct {

builder/amazon/common/step_create_tags.go

@@ -8,16 +8,14 @@ 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-plugin-amazon/builder/common/awserrors"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 	"github.com/hashicorp/packer-plugin-sdk/retry"
 	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
+	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 )
 
 type StepCreateTags struct {
-	AMISkipCreateImage bool
-
 	Tags         map[string]string
 	SnapshotTags map[string]string
 	Ctx          interpolate.Context
@@ -27,12 +25,6 @@ func (s *StepCreateTags) Run(ctx context.Context, state multistep.StateBag) mult
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	session := state.Get("awsSession").(*session.Session)
 	ui := state.Get("ui").(packersdk.Ui)
-
-	if s.AMISkipCreateImage {
-		ui.Say("Skipping AMI create tags...")
-		return multistep.ActionContinue
-	}
-
 	amis := state.Get("amis").(map[string]string)
 
 	if len(s.Tags) == 0 && len(s.SnapshotTags) == 0 {

builder/amazon/common/step_modify_ami_attributes.go

@@ -14,8 +14,6 @@ import (
 )
 
 type StepModifyAMIAttributes struct {
-	AMISkipCreateImage bool
-
 	Users          []string
 	Groups         []string
 	SnapshotUsers  []string
@@ -31,12 +29,6 @@ func (s *StepModifyAMIAttributes) Run(ctx context.Context, state multistep.State
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	session := state.Get("awsSession").(*session.Session)
 	ui := state.Get("ui").(packersdk.Ui)
-
-	if s.AMISkipCreateImage {
-		ui.Say("Skipping AMI modify attributes...")
-		return multistep.ActionContinue
-	}
-
 	amis := state.Get("amis").(map[string]string)
 	snapshots := state.Get("snapshots").(map[string][]string)
 

builder/amazon/common/step_pre_validate.go

@@ -9,10 +9,10 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/hashicorp/packer-plugin-amazon/builder/common/awserrors"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 	"github.com/hashicorp/packer-plugin-sdk/retry"
+	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 )
 
 // StepPreValidate provides an opportunity to pre-validate any configuration for

builder/amazon/common/step_pre_validate_test.go

@@ -0,0 +1,70 @@
+package common
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+)
+
+//DescribeVpcs mocks an ec2.DescribeVpcsOutput for a given input
+func (m *mockEC2Conn) DescribeVpcs(input *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) {
+
+	if input == nil || aws.StringValue(input.VpcIds[0]) == "" {
+		return nil, fmt.Errorf("oops looks like we need more input")
+	}
+
+	var isDefault bool
+	vpcID := aws.StringValue(input.VpcIds[0])
+
+	//only one default VPC per region
+	if strings.Contains("vpc-default-id", vpcID) {
+		isDefault = true
+	}
+
+	output := &ec2.DescribeVpcsOutput{
+		Vpcs: []*ec2.Vpc{
+			{IsDefault: aws.Bool(isDefault),
+				VpcId: aws.String(vpcID),
+			},
+		},
+	}
+	return output, nil
+}
+
+func TestStepPreValidate_checkVpc(t *testing.T) {
+	tt := []struct {
+		name          string
+		step          StepPreValidate
+		errorExpected bool
+	}{
+		{"DefaultVpc", StepPreValidate{VpcId: "vpc-default-id"}, false},
+		{"NonDefaultVpcNoSubnet", StepPreValidate{VpcId: "vpc-1234567890"}, true},
+		{"NonDefaultVpcWithSubnet", StepPreValidate{VpcId: "vpc-1234567890", SubnetId: "subnet-1234567890"}, false},
+		{"SubnetWithNoVpc", StepPreValidate{SubnetId: "subnet-1234567890"}, false},
+		{"NoVpcInformation", StepPreValidate{}, false},
+		{"NonDefaultVpcWithSubnetFilter", StepPreValidate{VpcId: "vpc-1234567890", HasSubnetFilter: true}, false},
+	}
+
+	mockConn, err := getMockConn(nil, "")
+	if err != nil {
+		t.Fatal("unable to get a mock connection")
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			err := tc.step.checkVpc(mockConn)
+
+			if tc.errorExpected && err == nil {
+				t.Errorf("expected a validation error for %q but got %q", tc.name, err)
+			}
+
+			if !tc.errorExpected && err != nil {
+				t.Errorf("expected a validation to pass for %q but got %q", tc.name, err)
+			}
+		})
+	}
+
+}

builder/amazon/common/step_run_source_instance.go

@@ -11,12 +11,12 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 
-	"github.com/hashicorp/packer-plugin-amazon/builder/common/awserrors"
 	"github.com/hashicorp/packer-plugin-sdk/communicator"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 	"github.com/hashicorp/packer-plugin-sdk/retry"
 	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
+	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 )
 
 type StepRunSourceInstance struct {
@@ -29,9 +29,6 @@ type StepRunSourceInstance struct {
 	EbsOptimized                      bool
 	EnableT2Unlimited                 bool
 	ExpectedRootDevice                string
-	HttpEndpoint                      string
-	HttpTokens                        string
-	HttpPutResponseHopLimit           int64
 	InstanceInitiatedShutdownBehavior string
 	InstanceType                      string
 	IsRestricted                      bool
@@ -147,10 +144,6 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		runOpts.CreditSpecification = &ec2.CreditSpecificationRequest{CpuCredits: &creditOption}
 	}
 
-	if s.HttpEndpoint == "enabled" {
-		runOpts.MetadataOptions = &ec2.InstanceMetadataOptionsRequest{HttpEndpoint: &s.HttpEndpoint, HttpTokens: &s.HttpTokens, HttpPutResponseHopLimit: &s.HttpPutResponseHopLimit}
-	}
-
 	// Collect tags for tagging on resource creation
 	var tagSpecs []*ec2.TagSpecification
 
@@ -258,7 +251,7 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		if resp, e := ec2conn.DescribeInstances(describeInstance); e == nil {
 			if len(resp.Reservations) > 0 && len(resp.Reservations[0].Instances) > 0 {
 				instance := resp.Reservations[0].Instances[0]
-				if instance.StateTransitionReason != nil && instance.StateReason != nil && instance.StateReason.Message != nil {
+				if instance.StateTransitionReason != nil && instance.StateReason.Message != nil {
 					ui.Error(fmt.Sprintf("Instance state change details: %s: %s",
 						*instance.StateTransitionReason, *instance.StateReason.Message))
 				}

builder/amazon/common/step_run_spot_instance.go

@@ -12,13 +12,13 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/hashicorp/packer-plugin-amazon/builder/common/awserrors"
 	"github.com/hashicorp/packer-plugin-sdk/communicator"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 	"github.com/hashicorp/packer-plugin-sdk/random"
 	"github.com/hashicorp/packer-plugin-sdk/retry"
 	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
+	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 )
 
 type EC2BlockDeviceMappingsBuilder interface {
@@ -34,9 +34,6 @@ type StepRunSpotInstance struct {
 	Comm                              *communicator.Config
 	EbsOptimized                      bool
 	ExpectedRootDevice                string
-	HttpEndpoint                      string
-	HttpTokens                        string
-	HttpPutResponseHopLimit           int64
 	InstanceInitiatedShutdownBehavior string
 	InstanceType                      string
 	Region                            string
@@ -54,24 +51,6 @@ type StepRunSpotInstance struct {
 	instanceId string
 }
 
-// The EbsBlockDevice and LaunchTemplateEbsBlockDeviceRequest structs are
-// nearly identical except for the struct's name and one extra field in
-// EbsBlockDeviceResuest, which unfortunately means you can't just cast one
-// into the other. THANKS AMAZON.
-func castBlockDeviceToRequest(bd *ec2.EbsBlockDevice) *ec2.LaunchTemplateEbsBlockDeviceRequest {
-	out := &ec2.LaunchTemplateEbsBlockDeviceRequest{
-		DeleteOnTermination: bd.DeleteOnTermination,
-		Encrypted:           bd.Encrypted,
-		Iops:                bd.Iops,
-		KmsKeyId:            bd.KmsKeyId,
-		SnapshotId:          bd.SnapshotId,
-		Throughput:          bd.Throughput,
-		VolumeSize:          bd.VolumeSize,
-		VolumeType:          bd.VolumeType,
-	}
-	return out
-}
-
 func (s *StepRunSpotInstance) CreateTemplateData(userData *string, az string,
 	state multistep.StateBag, marketOptions *ec2.LaunchTemplateInstanceMarketOptionsRequest) *ec2.RequestLaunchTemplateData {
 	blockDeviceMappings := s.LaunchMappings.BuildEC2BlockDeviceMappings()
@@ -79,12 +58,15 @@ func (s *StepRunSpotInstance) CreateTemplateData(userData *string, az string,
 	// LaunchTemplateBlockDeviceMappingRequest. These structs are identical,
 	// except for the EBS field -- on one, that field contains a
 	// LaunchTemplateEbsBlockDeviceRequest, and on the other, it contains an
-	// EbsBlockDevice.
+	// EbsBlockDevice. The EbsBlockDevice and
+	// LaunchTemplateEbsBlockDeviceRequest structs are themselves
+	// identical except for the struct's name, so you can cast one directly
+	// into the other.
 	var launchMappingRequests []*ec2.LaunchTemplateBlockDeviceMappingRequest
 	for _, mapping := range blockDeviceMappings {
 		launchRequest := &ec2.LaunchTemplateBlockDeviceMappingRequest{
 			DeviceName:  mapping.DeviceName,
-			Ebs:         castBlockDeviceToRequest(mapping.Ebs),
+			Ebs:         (*ec2.LaunchTemplateEbsBlockDeviceRequest)(mapping.Ebs),
 			VirtualName: mapping.VirtualName,
 		}
 		launchMappingRequests = append(launchMappingRequests, launchRequest)
@@ -145,10 +127,6 @@ func (s *StepRunSpotInstance) CreateTemplateData(userData *string, az string,
 
 	}
 
-	if s.HttpEndpoint == "enabled" {
-		templateData.MetadataOptions = &ec2.LaunchTemplateInstanceMetadataOptionsRequest{HttpEndpoint: &s.HttpEndpoint, HttpTokens: &s.HttpTokens, HttpPutResponseHopLimit: &s.HttpPutResponseHopLimit}
-	}
-
 	// If instance type is not set, we'll just pick the lowest priced instance
 	// available.
 	if s.InstanceType != "" {

builder/amazon/common/step_run_spot_instance_test.go

@@ -0,0 +1,366 @@
+package common
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/hashicorp/packer-plugin-sdk/communicator"
+	"github.com/hashicorp/packer-plugin-sdk/multistep"
+	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+)
+
+// Create statebag for running test
+func tStateSpot() multistep.StateBag {
+	state := new(multistep.BasicStateBag)
+	state.Put("ui", &packersdk.BasicUi{
+		Reader: new(bytes.Buffer),
+		Writer: new(bytes.Buffer),
+	})
+	state.Put("availability_zone", "us-east-1c")
+	state.Put("securityGroupIds", []string{"sg-0b8984db72f213dc3"})
+	state.Put("iamInstanceProfile", "packer-123")
+	state.Put("subnet_id", "subnet-077fde4e")
+	state.Put("source_image", "")
+	return state
+}
+
+func getBasicStep() *StepRunSpotInstance {
+	stepRunSpotInstance := StepRunSpotInstance{
+		PollingConfig:            new(AWSPollingConfig),
+		AssociatePublicIpAddress: false,
+		LaunchMappings:           BlockDevices{},
+		BlockDurationMinutes:     0,
+		Debug:                    false,
+		Comm: &communicator.Config{
+			SSH: communicator.SSH{
+				SSHKeyPairName: "foo",
+			},
+		},
+		EbsOptimized:                      false,
+		ExpectedRootDevice:                "ebs",
+		InstanceInitiatedShutdownBehavior: "stop",
+		InstanceType:                      "t2.micro",
+		Region:                            "us-east-1",
+		SourceAMI:                         "",
+		SpotPrice:                         "auto",
+		SpotTags:                          nil,
+		Tags:                              map[string]string{},
+		VolumeTags:                        nil,
+		UserData:                          "",
+		UserDataFile:                      "",
+	}
+
+	return &stepRunSpotInstance
+}
+
+func TestCreateTemplateData(t *testing.T) {
+	state := tStateSpot()
+	stepRunSpotInstance := getBasicStep()
+	template := stepRunSpotInstance.CreateTemplateData(aws.String("userdata"), "az", state,
+		&ec2.LaunchTemplateInstanceMarketOptionsRequest{})
+
+	// expected := []*ec2.LaunchTemplateInstanceNetworkInterfaceSpecificationRequest{
+	// 	&ec2.LaunchTemplateInstanceNetworkInterfaceSpecificationRequest{
+	// 		DeleteOnTermination: aws.Bool(true),
+	// 		DeviceIndex:         aws.Int64(0),
+	// 		Groups:              aws.StringSlice([]string{"sg-0b8984db72f213dc3"}),
+	// 		SubnetId:            aws.String("subnet-077fde4e"),
+	// 	},
+	// }
+	// if expected != template.NetworkInterfaces {
+	if template.NetworkInterfaces == nil {
+		t.Fatalf("Template should have contained a networkInterface object: recieved %#v", template.NetworkInterfaces)
+	}
+
+	if *template.IamInstanceProfile.Name != state.Get("iamInstanceProfile") {
+		t.Fatalf("Template should have contained a InstanceProfile name: recieved %#v", template.IamInstanceProfile.Name)
+	}
+
+	// Rerun, this time testing that we set security group IDs
+	state.Put("subnet_id", "")
+	template = stepRunSpotInstance.CreateTemplateData(aws.String("userdata"), "az", state,
+		&ec2.LaunchTemplateInstanceMarketOptionsRequest{})
+	if template.NetworkInterfaces != nil {
+		t.Fatalf("Template shouldn't contain network interfaces object if subnet_id is unset.")
+	}
+
+	// Rerun, this time testing that instance doesn't have instance profile is iamInstanceProfile is unset
+	state.Put("iamInstanceProfile", "")
+	template = stepRunSpotInstance.CreateTemplateData(aws.String("userdata"), "az", state,
+		&ec2.LaunchTemplateInstanceMarketOptionsRequest{})
+	fmt.Println(template.IamInstanceProfile)
+	if *template.IamInstanceProfile.Name != "" {
+		t.Fatalf("Template shouldn't contain instance profile if iamInstanceProfile is unset.")
+	}
+}
+
+func TestCreateTemplateData_NoEphemeral(t *testing.T) {
+	state := tStateSpot()
+	stepRunSpotInstance := getBasicStep()
+	stepRunSpotInstance.NoEphemeral = true
+	template := stepRunSpotInstance.CreateTemplateData(aws.String("userdata"), "az", state,
+		&ec2.LaunchTemplateInstanceMarketOptionsRequest{})
+	if len(template.BlockDeviceMappings) != 26 {
+		t.Fatalf("Should have created 26 mappings to keep ephemeral drives from appearing.")
+	}
+
+	// Now check that noEphemeral doesn't mess with the mappings in real life.
+	// state = tStateSpot()
+	// stepRunSpotInstance = getBasicStep()
+	// stepRunSpotInstance.NoEphemeral = true
+	// mappings := []*ec2.InstanceBlockDeviceMapping{
+	// 	&ec2.InstanceBlockDeviceMapping{
+	// 		DeviceName: "xvda",
+	// 		Ebs: {
+	// 			DeleteOnTermination: true,
+	// 			Status:              "attaching",
+	// 			VolumeId:            "vol-044cd49c330f21c05",
+	// 		},
+	// 	},
+	// 	&ec2.InstanceBlockDeviceMapping{
+	// 		DeviceName: "/dev/xvdf",
+	// 		Ebs: {
+	// 			DeleteOnTermination: false,
+	// 			Status:              "attaching",
+	// 			VolumeId:            "vol-0eefaf2d6ae35827e",
+	// 		},
+	// 	},
+	// }
+	// template = stepRunSpotInstance.CreateTemplateData(aws.String("userdata"), "az", state,
+	// 	&ec2.LaunchTemplateInstanceMarketOptionsRequest{})
+	// if len(*template.BlockDeviceMappings) != 26 {
+	// 	t.Fatalf("Should have created 26 mappings to keep ephemeral drives from appearing.")
+	// }
+}
+
+type runSpotEC2ConnMock struct {
+	ec2iface.EC2API
+
+	CreateLaunchTemplateParams []*ec2.CreateLaunchTemplateInput
+	CreateLaunchTemplateFn     func(*ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error)
+
+	CreateFleetParams []*ec2.CreateFleetInput
+	CreateFleetFn     func(*ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error)
+
+	CreateTagsParams []*ec2.CreateTagsInput
+	CreateTagsFn     func(*ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error)
+
+	DescribeInstancesParams []*ec2.DescribeInstancesInput
+	DescribeInstancesFn     func(input *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error)
+}
+
+func (m *runSpotEC2ConnMock) CreateLaunchTemplate(req *ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error) {
+	m.CreateLaunchTemplateParams = append(m.CreateLaunchTemplateParams, req)
+	resp, err := m.CreateLaunchTemplateFn(req)
+	return resp, err
+}
+
+func (m *runSpotEC2ConnMock) CreateFleet(req *ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error) {
+	m.CreateFleetParams = append(m.CreateFleetParams, req)
+	if m.CreateFleetFn != nil {
+		resp, err := m.CreateFleetFn(req)
+		return resp, err
+	} else {
+		return nil, nil
+	}
+}
+
+func (m *runSpotEC2ConnMock) DescribeInstances(req *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) {
+	m.DescribeInstancesParams = append(m.DescribeInstancesParams, req)
+	if m.DescribeInstancesFn != nil {
+		resp, err := m.DescribeInstancesFn(req)
+		return resp, err
+	} else {
+		return nil, nil
+	}
+}
+
+func (m *runSpotEC2ConnMock) CreateTags(req *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) {
+	m.CreateTagsParams = append(m.CreateTagsParams, req)
+	if m.CreateTagsFn != nil {
+		resp, err := m.CreateTagsFn(req)
+		return resp, err
+	} else {
+		return nil, nil
+	}
+}
+
+func defaultEc2Mock(instanceId, spotRequestId, volumeId, launchTemplateId *string) *runSpotEC2ConnMock {
+	instance := &ec2.Instance{
+		InstanceId:            instanceId,
+		SpotInstanceRequestId: spotRequestId,
+		BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+			{
+				Ebs: &ec2.EbsInstanceBlockDevice{
+					VolumeId: volumeId,
+				},
+			},
+		},
+	}
+	return &runSpotEC2ConnMock{
+		CreateLaunchTemplateFn: func(in *ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error) {
+			return &ec2.CreateLaunchTemplateOutput{
+				LaunchTemplate: &ec2.LaunchTemplate{
+					LaunchTemplateId: launchTemplateId,
+				},
+				Warning: nil,
+			}, nil
+		},
+		CreateFleetFn: func(*ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error) {
+			return &ec2.CreateFleetOutput{
+				Errors:  nil,
+				FleetId: nil,
+				Instances: []*ec2.CreateFleetInstance{
+					{
+						InstanceIds: []*string{instanceId},
+					},
+				},
+			}, nil
+		},
+		DescribeInstancesFn: func(input *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) {
+			return &ec2.DescribeInstancesOutput{
+				NextToken: nil,
+				Reservations: []*ec2.Reservation{
+					{
+						Instances: []*ec2.Instance{instance},
+					},
+				},
+			}, nil
+		},
+	}
+}
+
+func TestRun(t *testing.T) {
+	instanceId := aws.String("test-instance-id")
+	spotRequestId := aws.String("spot-id")
+	volumeId := aws.String("volume-id")
+	launchTemplateId := aws.String("launchTemplateId")
+	ec2Mock := defaultEc2Mock(instanceId, spotRequestId, volumeId, launchTemplateId)
+
+	uiMock := packersdk.TestUi(t)
+
+	state := tStateSpot()
+	state.Put("ec2", ec2Mock)
+	state.Put("ui", uiMock)
+	state.Put("source_image", testImage())
+
+	stepRunSpotInstance := getBasicStep()
+	stepRunSpotInstance.Tags["Name"] = "Packer Builder"
+	stepRunSpotInstance.Tags["test-tag"] = "test-value"
+	stepRunSpotInstance.SpotTags = map[string]string{
+		"spot-tag": "spot-tag-value",
+	}
+	stepRunSpotInstance.VolumeTags = map[string]string{
+		"volume-tag": "volume-tag-value",
+	}
+
+	ctx := context.TODO()
+	action := stepRunSpotInstance.Run(ctx, state)
+
+	if err := state.Get("error"); err != nil {
+		t.Fatalf("should not error, but: %v", err)
+	}
+
+	if action != multistep.ActionContinue {
+		t.Fatalf("shoul continue, but: %v", action)
+	}
+
+	if len(ec2Mock.CreateLaunchTemplateParams) != 1 {
+		t.Fatalf("createLaunchTemplate should be invoked once, but invoked %v", len(ec2Mock.CreateLaunchTemplateParams))
+	}
+	launchTemplateName := ec2Mock.CreateLaunchTemplateParams[0].LaunchTemplateName
+
+	if len(ec2Mock.CreateLaunchTemplateParams[0].TagSpecifications) != 1 {
+		t.Fatalf("exactly one launch template tag specification expected")
+	}
+	if *ec2Mock.CreateLaunchTemplateParams[0].TagSpecifications[0].ResourceType != "launch-template" {
+		t.Fatalf("resource type 'launch-template' expected")
+	}
+	if len(ec2Mock.CreateLaunchTemplateParams[0].TagSpecifications[0].Tags) != 1 {
+		t.Fatalf("1 launch template tag expected")
+	}
+
+	nameTag := ec2Mock.CreateLaunchTemplateParams[0].TagSpecifications[0].Tags[0]
+	if *nameTag.Key != "spot-tag" || *nameTag.Value != "spot-tag-value" {
+		t.Fatalf("expected spot-tag: spot-tag-value")
+	}
+
+	if len(ec2Mock.CreateFleetParams) != 1 {
+		t.Fatalf("createFleet should be invoked once, but invoked %v", len(ec2Mock.CreateLaunchTemplateParams))
+	}
+	if *ec2Mock.CreateFleetParams[0].TargetCapacitySpecification.DefaultTargetCapacityType != "spot" {
+		t.Fatalf("capacity type should be spot")
+	}
+	if *ec2Mock.CreateFleetParams[0].TargetCapacitySpecification.TotalTargetCapacity != 1 {
+		t.Fatalf("target capacity should be 1")
+	}
+	if len(ec2Mock.CreateFleetParams[0].LaunchTemplateConfigs) != 1 {
+		t.Fatalf("exactly one launch config template expected")
+	}
+	if *ec2Mock.CreateFleetParams[0].LaunchTemplateConfigs[0].LaunchTemplateSpecification.LaunchTemplateName != *launchTemplateName {
+		t.Fatalf("launchTemplateName should match in createLaunchTemplate and createFleet requests")
+	}
+
+	if len(ec2Mock.DescribeInstancesParams) != 1 {
+		t.Fatalf("describeInstancesParams should be invoked once, but invoked %v", len(ec2Mock.DescribeInstancesParams))
+	}
+	if *ec2Mock.DescribeInstancesParams[0].InstanceIds[0] != *instanceId {
+		t.Fatalf("instanceId should match from createFleet response")
+	}
+
+	uiMock.Say(fmt.Sprintf("%v", ec2Mock.CreateTagsParams))
+	if len(ec2Mock.CreateTagsParams) != 3 {
+		t.Fatalf("createTags should be invoked 3 times")
+	}
+	if len(ec2Mock.CreateTagsParams[0].Resources) != 1 || *ec2Mock.CreateTagsParams[0].Resources[0] != *spotRequestId {
+		t.Fatalf("should create tags for spot request")
+	}
+	if len(ec2Mock.CreateTagsParams[1].Resources) != 1 || *ec2Mock.CreateTagsParams[1].Resources[0] != *instanceId {
+		t.Fatalf("should create tags for instance")
+	}
+	if len(ec2Mock.CreateTagsParams[2].Resources) != 1 || ec2Mock.CreateTagsParams[2].Resources[0] != volumeId {
+		t.Fatalf("should create tags for volume")
+	}
+}
+
+func TestRun_NoSpotTags(t *testing.T) {
+	instanceId := aws.String("test-instance-id")
+	spotRequestId := aws.String("spot-id")
+	volumeId := aws.String("volume-id")
+	launchTemplateId := aws.String("lt-id")
+	ec2Mock := defaultEc2Mock(instanceId, spotRequestId, volumeId, launchTemplateId)
+
+	uiMock := packersdk.TestUi(t)
+
+	state := tStateSpot()
+	state.Put("ec2", ec2Mock)
+	state.Put("ui", uiMock)
+	state.Put("source_image", testImage())
+
+	stepRunSpotInstance := getBasicStep()
+	stepRunSpotInstance.Tags["Name"] = "Packer Builder"
+	stepRunSpotInstance.Tags["test-tag"] = "test-value"
+	stepRunSpotInstance.VolumeTags = map[string]string{
+		"volume-tag": "volume-tag-value",
+	}
+
+	ctx := context.TODO()
+	action := stepRunSpotInstance.Run(ctx, state)
+
+	if err := state.Get("error"); err != nil {
+		t.Fatalf("should not error, but: %v", err)
+	}
+
+	if action != multistep.ActionContinue {
+		t.Fatalf("shoul continue, but: %v", action)
+	}
+
+	if len(ec2Mock.CreateLaunchTemplateParams[0].TagSpecifications) != 0 {
+		t.Fatalf("0 launch template tags expected")
+	}
+}

builder/amazon/common/step_source_ami_info_test.go

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

builder/amazon/common/step_stop_ebs_instance.go

@@ -6,10 +6,10 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer-plugin-amazon/builder/common/awserrors"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 	"github.com/hashicorp/packer-plugin-sdk/retry"
+	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 )
 
 type StepStopEBSBackedInstance struct {

builder/amazon/common/template_funcs_test.go

@@ -0,0 +1,16 @@
+package common
+
+import (
+	"testing"
+)
+
+func TestAMITemplatePrepare_clean(t *testing.T) {
+	origName := "AMZamz09()./-_:&^ $%[]#'@"
+	expected := "AMZamz09()./-_--- --[]-'@"
+
+	name := templateCleanAMIName(origName)
+
+	if name != expected {
+		t.Fatalf("template names do not match: expected %s got %s\n", expected, name)
+	}
+}

builder/amazon/ebs/acceptance/aws.go

@@ -0,0 +1,46 @@
+package amazon_acc
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
+)
+
+type AWSHelper struct {
+	Region  string
+	AMIName string
+}
+
+func (a *AWSHelper) CleanUpAmi() error {
+	accessConfig := &awscommon.AccessConfig{}
+	session, err := accessConfig.Session()
+	if err != nil {
+		return fmt.Errorf("AWSAMICleanUp: Unable to create aws session %s", err.Error())
+	}
+
+	regionconn := ec2.New(session.Copy(&aws.Config{
+		Region: aws.String(a.Region),
+	}))
+
+	resp, err := regionconn.DescribeImages(&ec2.DescribeImagesInput{
+		Owners: aws.StringSlice([]string{"self"}),
+		Filters: []*ec2.Filter{{
+			Name:   aws.String("name"),
+			Values: aws.StringSlice([]string{a.AMIName}),
+		}}})
+	if err != nil {
+		return fmt.Errorf("AWSAMICleanUp: Unable to find Image %s: %s", a.AMIName, err.Error())
+	}
+
+	if resp != nil && len(resp.Images) > 0 {
+		_, err = regionconn.DeregisterImage(&ec2.DeregisterImageInput{
+			ImageId: resp.Images[0].ImageId,
+		})
+		if err != nil {
+			return fmt.Errorf("AWSAMICleanUp: Unable to Deregister Image %s", err.Error())
+		}
+	}
+	return nil
+}

builder/amazon/ebs/acceptance/builder_acceptance.go

@@ -0,0 +1,59 @@
+package amazon_acc
+
+// This is the code necessary for running the provisioner acceptance tests.
+// It provides the builder config and cleans up created resource.
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	amazonebsbuilder "github.com/hashicorp/packer/builder/amazon/ebs"
+
+	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+)
+
+type AmazonEBSAccTest struct{}
+
+func (s *AmazonEBSAccTest) GetConfigs() (map[string]string, error) {
+	fixtures := map[string]string{
+		"linux":   "amazon-ebs.txt",
+		"windows": "amazon-ebs_windows.txt",
+	}
+
+	configs := make(map[string]string)
+
+	for distro, fixture := range fixtures {
+		fileName := fixture
+		filePath := filepath.Join("../../builder/amazon/ebs/acceptance/test-fixtures/", fileName)
+		config, err := os.Open(filePath)
+		if err != nil {
+			return nil, fmt.Errorf("Expected to find %s", filePath)
+		}
+		defer config.Close()
+
+		file, err := ioutil.ReadAll(config)
+		if err != nil {
+			return nil, fmt.Errorf("Unable to read %s", filePath)
+		}
+
+		configs[distro] = string(file)
+
+	}
+	return configs, nil
+}
+
+func (s *AmazonEBSAccTest) CleanUp() error {
+	helper := AWSHelper{
+		Region:  "us-east-1",
+		AMIName: "packer-acc-test",
+	}
+	return helper.CleanUpAmi()
+}
+
+func (s *AmazonEBSAccTest) GetBuilderStore() packersdk.MapOfBuilder {
+	return packersdk.MapOfBuilder{
+		"amazon-ebs": func() (packersdk.Builder, error) { return &amazonebsbuilder.Builder{}, nil },
+	}
+}

builder/amazon/ebs/acceptance/test-fixtures/amazon-ebs.txt

@@ -0,0 +1,12 @@
+{
+  "type": "amazon-ebs",
+  "ami_name": "packer-acc-test",
+  "instance_type": "m1.small",
+  "region": "us-east-1",
+  "ssh_username": "ubuntu",
+  "source_ami": "ami-0568456c",
+  "force_deregister" : true,
+  "tags": {
+    "packer-test": "true"
+  }
+}

builder/amazon/ebs/acceptance/test-fixtures/amazon-ebs_windows.txt

@@ -0,0 +1,23 @@
+{
+ "type": "amazon-ebs",
+ "region": "us-east-1",
+  "instance_type": "t2.micro",
+  "source_ami_filter": {
+    "filters": {
+      "virtualization-type": "hvm",
+      "name": "*Windows_Server-2012-R2*English-64Bit-Base*",
+      "root-device-type": "ebs"
+    },
+    "most_recent": true,
+    "owners": "amazon"
+  },
+  "ami_name": "packer-acc-test",
+  "user_data_file": "../../builder/amazon/ebs/acceptance/test-fixtures/scripts/bootstrap_win.txt",
+  "communicator": "winrm",
+  "winrm_username": "Administrator",
+  "winrm_password": "SuperS3cr3t!!!!",
+  "force_deregister" : true,
+  "tags": {
+    "packer-test": "true"
+  }
+}

builder/amazon/ebs/acceptance/test-fixtures/scripts/bootstrap_win.txt

@@ -0,0 +1,40 @@
+<powershell>
+# Set administrator password
+net user Administrator SuperS3cr3t!!!!
+wmic useraccount where "name='Administrator'" set PasswordExpires=FALSE
+
+# First, make sure WinRM can't be connected to
+netsh advfirewall firewall set rule name="Windows Remote Management (HTTP-In)" new enable=yes action=block
+
+# Delete any existing WinRM listeners
+winrm delete winrm/config/listener?Address=*+Transport=HTTP  2>$Null
+winrm delete winrm/config/listener?Address=*+Transport=HTTPS 2>$Null
+
+# Disable group policies which block basic authentication and unencrypted login
+
+Set-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WinRM\Client -Name AllowBasic -Value 1
+Set-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WinRM\Client -Name AllowUnencryptedTraffic -Value 1
+Set-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WinRM\Service -Name AllowBasic -Value 1
+Set-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WinRM\Service -Name AllowUnencryptedTraffic -Value 1
+
+
+# Create a new WinRM listener and configure
+winrm create winrm/config/listener?Address=*+Transport=HTTP
+winrm set winrm/config/winrs '@{MaxMemoryPerShellMB="0"}'
+winrm set winrm/config '@{MaxTimeoutms="7200000"}'
+winrm set winrm/config/service '@{AllowUnencrypted="true"}'
+winrm set winrm/config/service '@{MaxConcurrentOperationsPerUser="12000"}'
+winrm set winrm/config/service/auth '@{Basic="true"}'
+winrm set winrm/config/client/auth '@{Basic="true"}'
+
+# Configure UAC to allow privilege elevation in remote shells
+$Key = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System'
+$Setting = 'LocalAccountTokenFilterPolicy'
+Set-ItemProperty -Path $Key -Name $Setting -Value 1 -Force
+
+# Configure and restart the WinRM Service; Enable the required firewall exception
+Stop-Service -Name WinRM
+Set-Service -Name WinRM -StartupType Automatic
+netsh advfirewall firewall set rule name="Windows Remote Management (HTTP-In)" new action=allow localip=any remoteip=any
+Start-Service -Name WinRM
+</powershell>

builder/amazon/ebs/builder.go

@@ -15,7 +15,6 @@ import (
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/hashicorp/hcl/v2/hcldec"
-	awscommon "github.com/hashicorp/packer-plugin-amazon/builder/common"
 	"github.com/hashicorp/packer-plugin-sdk/common"
 	"github.com/hashicorp/packer-plugin-sdk/communicator"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
@@ -24,6 +23,7 @@ import (
 	"github.com/hashicorp/packer-plugin-sdk/packerbuilderdata"
 	"github.com/hashicorp/packer-plugin-sdk/template/config"
 	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 )
 
 // The unique ID for this builder
@@ -34,9 +34,6 @@ type Config struct {
 	awscommon.AccessConfig `mapstructure:",squash"`
 	awscommon.AMIConfig    `mapstructure:",squash"`
 	awscommon.RunConfig    `mapstructure:",squash"`
-	// If true, Packer will not create the AMI. Useful for setting to `true`
-	// during a build test stage. Default `false`.
-	AMISkipCreateImage bool `mapstructure:"skip_create_ami" required:"false"`
 	// Add one or more block device mappings to the AMI. These will be attached
 	// when booting a new instance from your AMI. To add a block device during
 	// the Packer build see `launch_block_device_mappings` below. Your options
@@ -56,7 +53,7 @@ type Config struct {
 	// Tags to apply to the volumes that are *launched* to create the AMI.
 	// These tags are *not* applied to the resulting AMI unless they're
 	// duplicated in `tags`. This is a [template
-	// engine](/docs/templates/legacy_json_templates/engine), see [Build template
+	// engine](/docs/templates/engine), see [Build template
 	// data](#build-template-data) for more information.
 	VolumeRunTags map[string]string `mapstructure:"run_volume_tags"`
 	// Same as [`run_volume_tags`](#run_volume_tags) but defined as a singular
@@ -187,9 +184,6 @@ func (b *Builder) Run(ctx context.Context, ui packersdk.Ui, hook packersdk.Hook)
 			Debug:                             b.config.PackerDebug,
 			EbsOptimized:                      b.config.EbsOptimized,
 			ExpectedRootDevice:                "ebs",
-			HttpEndpoint:                      b.config.Metadata.HttpEndpoint,
-			HttpTokens:                        b.config.Metadata.HttpTokens,
-			HttpPutResponseHopLimit:           b.config.Metadata.HttpPutResponseHopLimit,
 			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
 			InstanceType:                      b.config.InstanceType,
 			Region:                            *ec2conn.Config.Region,
@@ -214,9 +208,6 @@ func (b *Builder) Run(ctx context.Context, ui packersdk.Ui, hook packersdk.Hook)
 			EbsOptimized:                      b.config.EbsOptimized,
 			EnableT2Unlimited:                 b.config.EnableT2Unlimited,
 			ExpectedRootDevice:                "ebs",
-			HttpEndpoint:                      b.config.Metadata.HttpEndpoint,
-			HttpTokens:                        b.config.Metadata.HttpTokens,
-			HttpPutResponseHopLimit:           b.config.Metadata.HttpPutResponseHopLimit,
 			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
 			InstanceType:                      b.config.InstanceType,
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
@@ -328,7 +319,6 @@ func (b *Builder) Run(ctx context.Context, ui packersdk.Ui, hook packersdk.Hook)
 			Regions:             b.config.AMIRegions,
 		},
 		&stepCreateAMI{
-			AMISkipCreateImage: b.config.AMISkipCreateImage,
 			AMISkipBuildRegion: b.config.AMISkipBuildRegion,
 			PollingConfig:      b.config.PollingConfig,
 		},
@@ -340,25 +330,22 @@ func (b *Builder) Run(ctx context.Context, ui packersdk.Ui, hook packersdk.Hook)
 			EncryptBootVolume:  b.config.AMIEncryptBootVolume,
 			Name:               b.config.AMIName,
 			OriginalRegion:     *ec2conn.Config.Region,
-			AMISkipCreateImage: b.config.AMISkipCreateImage,
 			AMISkipBuildRegion: b.config.AMISkipBuildRegion,
 		},
 		&awscommon.StepModifyAMIAttributes{
-			AMISkipCreateImage: b.config.AMISkipCreateImage,
-			Description:        b.config.AMIDescription,
-			Users:              b.config.AMIUsers,
-			Groups:             b.config.AMIGroups,
-			ProductCodes:       b.config.AMIProductCodes,
-			SnapshotUsers:      b.config.SnapshotUsers,
-			SnapshotGroups:     b.config.SnapshotGroups,
-			Ctx:                b.config.ctx,
-			GeneratedData:      generatedData,
+			Description:    b.config.AMIDescription,
+			Users:          b.config.AMIUsers,
+			Groups:         b.config.AMIGroups,
+			ProductCodes:   b.config.AMIProductCodes,
+			SnapshotUsers:  b.config.SnapshotUsers,
+			SnapshotGroups: b.config.SnapshotGroups,
+			Ctx:            b.config.ctx,
+			GeneratedData:  generatedData,
 		},
 		&awscommon.StepCreateTags{
-			AMISkipCreateImage: b.config.AMISkipCreateImage,
-			Tags:               b.config.AMITags,
-			SnapshotTags:       b.config.SnapshotTags,
-			Ctx:                b.config.ctx,
+			Tags:         b.config.AMITags,
+			SnapshotTags: b.config.SnapshotTags,
+			Ctx:          b.config.ctx,
 		},
 	}
 

builder/amazon/ebs/builder.hcl2spec.go

@@ -4,8 +4,8 @@ package ebs
 
 import (
 	"github.com/hashicorp/hcl/v2/hcldec"
-	"github.com/hashicorp/packer-plugin-amazon/builder/common"
 	"github.com/hashicorp/packer-plugin-sdk/template/config"
+	"github.com/hashicorp/packer/builder/amazon/common"
 	"github.com/zclconf/go-cty/cty"
 )
 
@@ -90,7 +90,6 @@ type FlatConfig struct {
 	VpcFilter                                 *common.FlatVpcFilterOptions           `mapstructure:"vpc_filter" required:"false" cty:"vpc_filter" hcl:"vpc_filter"`
 	VpcId                                     *string                                `mapstructure:"vpc_id" required:"false" cty:"vpc_id" hcl:"vpc_id"`
 	WindowsPasswordTimeout                    *string                                `mapstructure:"windows_password_timeout" required:"false" cty:"windows_password_timeout" hcl:"windows_password_timeout"`
-	Metadata                                  *common.FlatMetadataOptions            `mapstructure:"metadata_options" required:"false" cty:"metadata_options" hcl:"metadata_options"`
 	Type                                      *string                                `mapstructure:"communicator" cty:"communicator" hcl:"communicator"`
 	PauseBeforeConnect                        *string                                `mapstructure:"pause_before_connecting" cty:"pause_before_connecting" hcl:"pause_before_connecting"`
 	SSHHost                                   *string                                `mapstructure:"ssh_host" cty:"ssh_host" hcl:"ssh_host"`
@@ -143,7 +142,6 @@ type FlatConfig struct {
 	SSHInterface                              *string                                `mapstructure:"ssh_interface" cty:"ssh_interface" hcl:"ssh_interface"`
 	PauseBeforeSSM                            *string                                `mapstructure:"pause_before_ssm" cty:"pause_before_ssm" hcl:"pause_before_ssm"`
 	SessionManagerPort                        *int                                   `mapstructure:"session_manager_port" cty:"session_manager_port" hcl:"session_manager_port"`
-	AMISkipCreateImage                        *bool                                  `mapstructure:"skip_create_ami" required:"false" cty:"skip_create_ami" hcl:"skip_create_ami"`
 	AMIMappings                               []common.FlatBlockDevice               `mapstructure:"ami_block_device_mappings" required:"false" cty:"ami_block_device_mappings" hcl:"ami_block_device_mappings"`
 	LaunchMappings                            []common.FlatBlockDevice               `mapstructure:"launch_block_device_mappings" required:"false" cty:"launch_block_device_mappings" hcl:"launch_block_device_mappings"`
 	VolumeRunTags                             map[string]string                      `mapstructure:"run_volume_tags" cty:"run_volume_tags" hcl:"run_volume_tags"`
@@ -241,7 +239,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"vpc_filter":                            &hcldec.BlockSpec{TypeName: "vpc_filter", Nested: hcldec.ObjectSpec((*common.FlatVpcFilterOptions)(nil).HCL2Spec())},
 		"vpc_id":                                &hcldec.AttrSpec{Name: "vpc_id", Type: cty.String, Required: false},
 		"windows_password_timeout":              &hcldec.AttrSpec{Name: "windows_password_timeout", Type: cty.String, Required: false},
-		"metadata_options":                      &hcldec.BlockSpec{TypeName: "metadata_options", Nested: hcldec.ObjectSpec((*common.FlatMetadataOptions)(nil).HCL2Spec())},
 		"communicator":                          &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
 		"pause_before_connecting":               &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
 		"ssh_host":                              &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
@@ -294,7 +291,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_interface":                         &hcldec.AttrSpec{Name: "ssh_interface", Type: cty.String, Required: false},
 		"pause_before_ssm":                      &hcldec.AttrSpec{Name: "pause_before_ssm", Type: cty.String, Required: false},
 		"session_manager_port":                  &hcldec.AttrSpec{Name: "session_manager_port", Type: cty.Number, Required: false},
-		"skip_create_ami":                       &hcldec.AttrSpec{Name: "skip_create_ami", Type: cty.Bool, Required: false},
 		"ami_block_device_mappings":             &hcldec.BlockListSpec{TypeName: "ami_block_device_mappings", Nested: hcldec.ObjectSpec((*common.FlatBlockDevice)(nil).HCL2Spec())},
 		"launch_block_device_mappings":          &hcldec.BlockListSpec{TypeName: "launch_block_device_mappings", Nested: hcldec.ObjectSpec((*common.FlatBlockDevice)(nil).HCL2Spec())},
 		"run_volume_tags":                       &hcldec.AttrSpec{Name: "run_volume_tags", Type: cty.Map(cty.String), Required: false},

builder/amazon/ebs/builder_acc_test.go

@@ -0,0 +1,396 @@
+/*
+Deregister the test image with
+aws ec2 deregister-image --image-id $(aws ec2 describe-images --output text --filters "Name=name,Values=packer-test-packer-test-dereg" --query 'Images[*].{ID:ImageId}')
+*/
+package ebs
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	builderT "github.com/hashicorp/packer-plugin-sdk/acctest"
+	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+	"github.com/hashicorp/packer/builder/amazon/common"
+)
+
+func TestBuilderAcc_basic(t *testing.T) {
+	builderT.Test(t, builderT.TestCase{
+		PreCheck: func() { testAccPreCheck(t) },
+		Builder:  &Builder{},
+		Template: testBuilderAccBasic,
+	})
+}
+
+func TestBuilderAcc_regionCopy(t *testing.T) {
+	builderT.Test(t, builderT.TestCase{
+		PreCheck: func() { testAccPreCheck(t) },
+		Builder:  &Builder{},
+		Template: testBuilderAccRegionCopy,
+		Check:    checkRegionCopy([]string{"us-east-1", "us-west-2"}),
+	})
+}
+
+func TestBuilderAcc_forceDeregister(t *testing.T) {
+	// Build the same AMI name twice, with force_deregister on the second run
+	builderT.Test(t, builderT.TestCase{
+		PreCheck:             func() { testAccPreCheck(t) },
+		Builder:              &Builder{},
+		Template:             buildForceDeregisterConfig("false", "dereg"),
+		SkipArtifactTeardown: true,
+	})
+
+	builderT.Test(t, builderT.TestCase{
+		PreCheck: func() { testAccPreCheck(t) },
+		Builder:  &Builder{},
+		Template: buildForceDeregisterConfig("true", "dereg"),
+	})
+}
+
+func TestBuilderAcc_forceDeleteSnapshot(t *testing.T) {
+	amiName := "packer-test-dereg"
+
+	// Build the same AMI name twice, with force_delete_snapshot on the second run
+	builderT.Test(t, builderT.TestCase{
+		PreCheck:             func() { testAccPreCheck(t) },
+		Builder:              &Builder{},
+		Template:             buildForceDeleteSnapshotConfig("false", amiName),
+		SkipArtifactTeardown: true,
+	})
+
+	// Get image data by AMI name
+	ec2conn, _ := testEC2Conn()
+	describeInput := &ec2.DescribeImagesInput{Filters: []*ec2.Filter{
+		{
+			Name:   aws.String("name"),
+			Values: []*string{aws.String(amiName)},
+		},
+	}}
+	ec2conn.WaitUntilImageExists(describeInput)
+	imageResp, _ := ec2conn.DescribeImages(describeInput)
+	image := imageResp.Images[0]
+
+	// Get snapshot ids for image
+	snapshotIds := []*string{}
+	for _, device := range image.BlockDeviceMappings {
+		if device.Ebs != nil && device.Ebs.SnapshotId != nil {
+			snapshotIds = append(snapshotIds, device.Ebs.SnapshotId)
+		}
+	}
+
+	builderT.Test(t, builderT.TestCase{
+		PreCheck: func() { testAccPreCheck(t) },
+		Builder:  &Builder{},
+		Template: buildForceDeleteSnapshotConfig("true", amiName),
+		Check:    checkSnapshotsDeleted(snapshotIds),
+	})
+}
+
+func checkSnapshotsDeleted(snapshotIds []*string) builderT.TestCheckFunc {
+	return func(artifacts []packersdk.Artifact) error {
+		// Verify the snapshots are gone
+		ec2conn, _ := testEC2Conn()
+		snapshotResp, _ := ec2conn.DescribeSnapshots(
+			&ec2.DescribeSnapshotsInput{SnapshotIds: snapshotIds},
+		)
+
+		if len(snapshotResp.Snapshots) > 0 {
+			return fmt.Errorf("Snapshots weren't successfully deleted by `force_delete_snapshot`")
+		}
+		return nil
+	}
+}
+
+func TestBuilderAcc_amiSharing(t *testing.T) {
+	builderT.Test(t, builderT.TestCase{
+		PreCheck: func() { testAccSharingPreCheck(t) },
+		Builder:  &Builder{},
+		Template: buildSharingConfig(os.Getenv("TESTACC_AWS_ACCOUNT_ID")),
+		Check:    checkAMISharing(2, os.Getenv("TESTACC_AWS_ACCOUNT_ID"), "all"),
+	})
+}
+
+func TestBuilderAcc_encryptedBoot(t *testing.T) {
+	builderT.Test(t, builderT.TestCase{
+		PreCheck: func() { testAccPreCheck(t) },
+		Builder:  &Builder{},
+		Template: testBuilderAccEncrypted,
+		Check:    checkBootEncrypted(),
+	})
+}
+
+func checkAMISharing(count int, uid, group string) builderT.TestCheckFunc {
+	return func(artifacts []packersdk.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.(*common.Artifact)
+		if !ok {
+			return fmt.Errorf("unknown artifact: %#v", artifactRaw)
+		}
+
+		// describe the image, get block devices with a snapshot
+		ec2conn, _ := testEC2Conn()
+		imageResp, err := ec2conn.DescribeImageAttribute(&ec2.DescribeImageAttributeInput{
+			Attribute: aws.String("launchPermission"),
+			ImageId:   aws.String(artifact.Amis["us-east-1"]),
+		})
+
+		if err != nil {
+			return fmt.Errorf("Error retrieving Image Attributes for AMI Artifact (%#v) in AMI Sharing Test: %s", artifact, err)
+		}
+
+		// Launch Permissions are in addition to the userid that created it, so if
+		// you add 3 additional ami_users, you expect 2 Launch Permissions here
+		if len(imageResp.LaunchPermissions) != count {
+			return fmt.Errorf("Error in Image Attributes, expected (%d) Launch Permissions, got (%d)", count, len(imageResp.LaunchPermissions))
+		}
+
+		userFound := false
+		for _, lp := range imageResp.LaunchPermissions {
+			if lp.UserId != nil && uid == *lp.UserId {
+				userFound = true
+			}
+		}
+
+		if !userFound {
+			return fmt.Errorf("Error in Image Attributes, expected User ID (%s) to have Launch Permissions, but was not found", uid)
+		}
+
+		groupFound := false
+		for _, lp := range imageResp.LaunchPermissions {
+			if lp.Group != nil && group == *lp.Group {
+				groupFound = true
+			}
+		}
+
+		if !groupFound {
+			return fmt.Errorf("Error in Image Attributes, expected Group ID (%s) to have Launch Permissions, but was not found", group)
+		}
+
+		return nil
+	}
+}
+
+func checkRegionCopy(regions []string) builderT.TestCheckFunc {
+	return func(artifacts []packersdk.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.(*common.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.Amis {
+			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)
+		}
+
+		return nil
+	}
+}
+
+func checkBootEncrypted() builderT.TestCheckFunc {
+	return func(artifacts []packersdk.Artifact) error {
+
+		// Get the actual *Artifact pointer so we can access the AMIs directly
+		artifactRaw := artifacts[0]
+		artifact, ok := artifactRaw.(*common.Artifact)
+		if !ok {
+			return fmt.Errorf("unknown artifact: %#v", artifactRaw)
+		}
+
+		// describe the image, get block devices with a snapshot
+		ec2conn, _ := testEC2Conn()
+		imageResp, err := ec2conn.DescribeImages(&ec2.DescribeImagesInput{
+			ImageIds: []*string{aws.String(artifact.Amis["us-east-1"])},
+		})
+
+		if err != nil {
+			return fmt.Errorf("Error retrieving Image Attributes for AMI (%s) in AMI Encrypted Boot Test: %s", artifact, err)
+		}
+
+		image := imageResp.Images[0] // Only requested a single AMI ID
+
+		rootDeviceName := image.RootDeviceName
+
+		for _, bd := range image.BlockDeviceMappings {
+			if *bd.DeviceName == *rootDeviceName {
+				if *bd.Ebs.Encrypted != true {
+					return fmt.Errorf("volume not encrypted: %s", *bd.Ebs.SnapshotId)
+				}
+			}
+		}
+
+		return nil
+	}
+}
+
+func TestBuilderAcc_SessionManagerInterface(t *testing.T) {
+	builderT.Test(t, builderT.TestCase{
+		PreCheck: func() { testAccPreCheck(t) },
+		Builder:  &Builder{},
+		Template: testBuilderAccSessionManagerInterface,
+	})
+}
+
+func testAccPreCheck(t *testing.T) {
+}
+
+func testAccSharingPreCheck(t *testing.T) {
+	if v := os.Getenv("TESTACC_AWS_ACCOUNT_ID"); v == "" {
+		t.Fatal(fmt.Sprintf("TESTACC_AWS_ACCOUNT_ID must be set for acceptance tests"))
+	}
+}
+
+func testEC2Conn() (*ec2.EC2, error) {
+	access := &common.AccessConfig{RawRegion: "us-east-1"}
+	session, err := access.Session()
+	if err != nil {
+		return nil, err
+	}
+
+	return ec2.New(session), nil
+}
+
+const testBuilderAccBasic = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "us-east-1",
+		"instance_type": "m3.medium",
+		"source_ami": "ami-76b2a71e",
+		"ssh_username": "ubuntu",
+		"ami_name": "packer-test {{timestamp}}"
+	}]
+}
+`
+
+const testBuilderAccRegionCopy = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "us-east-1",
+		"instance_type": "m3.medium",
+		"source_ami": "ami-76b2a71e",
+		"ssh_username": "ubuntu",
+		"ami_name": "packer-test {{timestamp}}",
+		"ami_regions": ["us-east-1", "us-west-2"]
+	}]
+}
+`
+
+const testBuilderAccForceDeregister = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "us-east-1",
+		"instance_type": "m3.medium",
+		"source_ami": "ami-76b2a71e",
+		"ssh_username": "ubuntu",
+		"force_deregister": "%s",
+		"ami_name": "%s"
+	}]
+}
+`
+
+const testBuilderAccForceDeleteSnapshot = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "us-east-1",
+		"instance_type": "m3.medium",
+		"source_ami": "ami-76b2a71e",
+		"ssh_username": "ubuntu",
+		"force_deregister": "%s",
+		"force_delete_snapshot": "%s",
+		"ami_name": "%s"
+	}]
+}
+`
+
+const testBuilderAccSharing = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "us-east-1",
+		"instance_type": "m3.medium",
+		"source_ami": "ami-76b2a71e",
+		"ssh_username": "ubuntu",
+		"ami_name": "packer-test {{timestamp}}",
+		"ami_users":["%s"],
+		"ami_groups":["all"]
+	}]
+}
+`
+
+const testBuilderAccEncrypted = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "us-east-1",
+		"instance_type": "m3.medium",
+		"source_ami":"ami-c15bebaa",
+		"ssh_username": "ubuntu",
+		"ami_name": "packer-enc-test {{timestamp}}",
+		"encrypt_boot": true
+	}]
+}
+`
+
+const testBuilderAccSessionManagerInterface = `
+{
+	"builders": [{
+		"type": "test",
+		"region": "us-east-1",
+		"instance_type": "m3.medium",
+		"source_ami_filter": {
+				"filters": {
+						"virtualization-type": "hvm",
+						"name": "ubuntu/images/*ubuntu-xenial-16.04-amd64-server-*",
+						"root-device-type": "ebs"
+				},
+				"owners": [
+						"099720109477"
+				],
+				"most_recent": true
+		},
+		"ssh_username": "ubuntu",
+		"ssh_interface": "session_manager",
+		"iam_instance_profile": "SSMInstanceProfile",
+		"ami_name": "packer-ssm-test-{{timestamp}}"
+	}]
+}
+`
+
+func buildForceDeregisterConfig(val, name string) string {
+	return fmt.Sprintf(testBuilderAccForceDeregister, val, name)
+}
+
+func buildForceDeleteSnapshotConfig(val, name string) string {
+	return fmt.Sprintf(testBuilderAccForceDeleteSnapshot, val, val, name)
+}
+
+func buildSharingConfig(val string) string {
+	return fmt.Sprintf(testBuilderAccSharing, val)
+}

builder/amazon/ebs/builder_test.go

@@ -0,0 +1,166 @@
+package ebs
+
+import (
+	"testing"
+
+	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+)
+
+func testConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"access_key":    "foo",
+		"secret_key":    "bar",
+		"source_ami":    "foo",
+		"instance_type": "foo",
+		"region":        "us-east-1",
+		"ssh_username":  "root",
+		"ami_name":      "foo",
+	}
+}
+
+func TestBuilder_ImplementsBuilder(t *testing.T) {
+	var raw interface{}
+	raw = &Builder{}
+	if _, ok := raw.(packersdk.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_AMIName(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["ami_name"] = "foo"
+	_, 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["ami_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, "ami_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 := testConfig()
+
+	// 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")
+	}
+}
+
+func TestBuilderPrepare_InvalidShutdownBehavior(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["shutdown_behavior"] = "terminate"
+	_, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	// Test good
+	config["shutdown_behavior"] = "stop"
+	_, warnings, err = b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	// Test bad
+	config["shutdown_behavior"] = "foobar"
+	_, warnings, err = b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_ReturnGeneratedData(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	generatedData, warnings, err := b.Prepare(config)
+	if len(warnings) > 0 {
+		t.Fatalf("bad: %#v", warnings)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+	if len(generatedData) == 0 {
+		t.Fatalf("Generated data should not be empty")
+	}
+	if len(generatedData) == 0 {
+		t.Fatalf("Generated data should not be empty")
+	}
+	if generatedData[0] != "SourceAMIName" {
+		t.Fatalf("Generated data should contain SourceAMIName")
+	}
+	if generatedData[1] != "BuildRegion" {
+		t.Fatalf("Generated data should contain BuildRegion")
+	}
+	if generatedData[2] != "SourceAMI" {
+		t.Fatalf("Generated data should contain SourceAMI")
+	}
+	if generatedData[3] != "SourceAMICreationDate" {
+		t.Fatalf("Generated data should contain SourceAMICreationDate")
+	}
+	if generatedData[4] != "SourceAMIOwner" {
+		t.Fatalf("Generated data should contain SourceAMIOwner")
+	}
+	if generatedData[5] != "SourceAMIOwnerName" {
+		t.Fatalf("Generated data should contain SourceAMIOwnerName")
+	}
+}