Add vault functions to HCL2 side navigation

.circleci/config.yml

@@ -7,7 +7,7 @@ version: 2.1
 executors:
   golang:
     docker:
-      - image: docker.mirror.hashicorp.services/circleci/golang:1.15
+      - image: circleci/golang:1.15
     resource_class: medium+
   darwin:
     macos:
@@ -153,7 +153,7 @@ jobs:
           destination: /
   build-website-docker-image:
     docker:
-      - image: docker.mirror.hashicorp.services/circleci/buildpack-deps
+      - image: circleci/buildpack-deps
     shell: /usr/bin/env bash -euo pipefail -c
     steps:
       - checkout
@@ -167,14 +167,14 @@ jobs:
                 echo "Dependencies have not changed, not building a new website docker image."
             else
                 cd website/
-                docker login -u $WEBSITE_DOCKER_USER -p $WEBSITE_DOCKER_PASS
                 docker build -t hashicorp/packer-website:$IMAGE_TAG .
                 docker tag hashicorp/packer-website:$IMAGE_TAG hashicorp/packer-website:latest
+                docker login -u $WEBSITE_DOCKER_USER -p $WEBSITE_DOCKER_PASS
                 docker push hashicorp/packer-website
             fi
   algolia-index:
     docker:
-      - image: docker.mirror.hashicorp.services/node:12
+      - image: node:12
     steps:
       - checkout
       - run:

.gitignore

@@ -27,4 +27,3 @@ Thumbs.db
 /packer.exe
 .project
 cache
-/.vscode/

CHANGELOG.md

@@ -1,39 +1,14 @@
-## 1.6.5 (October 30, 2020)
-
-### FEATURES:
-* New Builder(s): Proxmox builder has been split into two new builders
-    `proxmox-iso` and `promox-clone`. See [Proxmox
-    Builder](https://packer.io/docs/builders/proxmox) for more information on
-    the builder. For users of the previous `proxmox` builder please use `packer
-    fix` to migrate your templates to the new `promox-iso` builder. [GH-9262]
+## 1.6.5 (Upcoming)
 
 ### BUG FIXES:
 
-* builder/amazon: SSM connection now recovers from reboots. [GH-10003]
-* builder/azure-arm: Fix build failures due to the deletion of additional
-    managed disks defined in "disk_additional_size". [GH-10163]
 * builder/azure-chroot: Fix typo in option `exlude_from_latest` to
     `exclude_from_latest`. Old name will still be respected. [GH-10034]
-* builder/googlecompute: Fix HCL image_encryption_key fields and use the same
-    casing in JSON and HCL2 [GH-10173]
 * builder/openstack: Fix source image validation regression when using filters.
     [GH-10065]
-* builder/proxmox: Fix unhandled buildvar type for HCL2 enabled build
-    templates. [GH-10154]
-* builder/qemu: Fix a regression where Packer would not wait properly in
-    step_shutdown when a null communicator was used. [GH-10178]
-* builder/qemu: Fix crash in step_run of qemu when loading commhostport form
-    the statebag in a situation where the communicator is none. [GH-10145]
-* builder/vsphere-clone: Packer was not respecting the "destroy" flag set in
-    the content library config, and always keeping the source vm. This has been
-    fixed. [GH-10165]
-* builder/vsphere: Ensure builds are able to continue when no communicator has
-    been specified `"communicator": "none"`. [GH-9964]
-* builder/vsphere: Fix CD uploads so that Packer does not try to delete a CD
-    that was not successfully uploaded. [GH-10155]
-* core/hcl: Hide sensitive variables from output. [GH-10031]
-* core/hcl: Packer HCL's "Coalesce" function now behaves same way as
+* core/hcl2: Packer HCL's "Coalesce" function now behaves same way as
     Terraform's. [GH-10016]
+* core/HCL: Hide sensitive variables from output. [GH-10031]
 * core: Fix artifact handling so that input artifacts are properly preserved in
     postprocessors that don't modify artifacts. [GH-9996]
 * core: Fix pathing in cd_files to copy proper directory tree when user
@@ -43,38 +18,12 @@
 
 ### IMPROVEMENTS:
 
-* builder/amazon-ebssurrogate: Apply snapshot tags at snapshot creation time.
-    [GH-10150]
-* builder/amazon: Add `io2` as a supported volume type. [GH-10102]
-* builder/amazon: Add support for source instance tenancy [GH-10085]
 * builder/google: Add service account impersonation. [GH-9968] [GH-10054]
-* builder/googlecompute: Add `skip_create_image` option. [GH-10115]
-* builder/googlecompute: Allow users to select the algorithm to use when
-    generating temporary SSH keypair [GH-10111]
-* builder/linode: Add `state_timeout` attribute to Linode builder. [GH-10128]
 * builder/oracle-oci:  New option to specify image compartment separate from
     build compartment. [GH-10040]
 * builder/oracle-oci: New option to specify boot volume size. [GH-10017]
-* builder/oracle: Add `base_image_filter` option as alternative to
-    `base_image_ocid` [GH-10116]
-* builder/outscale: Migrate to new Outscale SDK. [GH-10056]
-* builder/proxmox: split Proxmox into proxmox-iso and proxmox-clone. [GH-9626]
-    [GH-10166]
 * builder/scaleway: Allow the user to use an image label (eg ubuntu_focal)
     instead of a hardcoded UUID on the Scaleway builder. [GH-10061]
-* builder/vsphere: Skip iso download if hashed file is already present on
-    remote datastore. [GH-10143]
-* builder/yandex: Add support for IAM credentials in the token field and
-    YC_TOKEN environment variable. [GH-10158]
-* core/hcl: Add ability to set version restrictions [GH-10149]
-* core/hcl: Add build.name variable so users can access build name in addition
-    to source name. [GH-10114]
-* core/hcl: Add consul_key function to HCL templates. [GH-10119]
-* core/hcl: Add HCL2 aws_secretsmanager function [GH-10124]
-* core/hcl: Add packer.version variable to hcl configs so users can access the
-    Packer release version. [GH-10117]
-* core: Let user provide type of generated ssh key instead of always doing ssh-
-    rsa [GH-10101]
 
 ## 1.6.4 (September 30, 2020)
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM docker.mirror.hashicorp.services/ubuntu:16.04
+FROM ubuntu:16.04
 
 ENV DEBIAN_FRONTEND noninteractive
 

Makefile

@@ -1,5 +1,4 @@
 TEST?=$(shell go list ./...)
-COUNT?=1
 VET?=$(shell go list ./...)
 ACC_TEST_BUILDERS?=all
 ACC_TEST_PROVISIONERS?=all
@@ -137,7 +136,7 @@ generate-check: generate ## Check go code generation is on par
 	fi
 
 test: mode-check vet ## Run unit tests
-	@go test -count $(COUNT) $(TEST) $(TESTARGS) -timeout=3m
+	@go test $(TEST) $(TESTARGS) -timeout=3m
 
 # acctest runs provisioners acceptance tests
 provisioners-acctest: install-build-deps generate
@@ -146,14 +145,14 @@ provisioners-acctest: install-build-deps generate
 # testacc runs acceptance tests
 testacc: install-build-deps generate ## Run acceptance tests
 	@echo "WARN: Acceptance tests will take a long time to run and may cost money. Ctrl-C if you want to cancel."
-	PACKER_ACC=1 go test -count $(COUNT) -v $(TEST) $(TESTARGS) -timeout=120m
+	PACKER_ACC=1 go test -v $(TEST) $(TESTARGS) -timeout=45m
 
 testrace: mode-check vet ## Test with race detection enabled
-	@GO111MODULE=off go test -count $(COUNT) -race $(TEST) $(TESTARGS) -timeout=3m -p=8
+	@GO111MODULE=off go test -race $(TEST) $(TESTARGS) -timeout=3m -p=8
 
 # Runs code coverage and open a html page with report
 cover:
-	go test -count $(COUNT) $(TEST) $(TESTARGS) -timeout=3m -coverprofile=coverage.out
+	go test $(TEST) $(TESTARGS) -timeout=3m -coverprofile=coverage.out
 	go tool cover -html=coverage.out
 	rm coverage.out
 

builder/alicloud/ecs/builder.go

@@ -46,7 +46,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{

builder/alicloud/ecs/builder.hcl2spec.go

@@ -107,8 +107,6 @@ type FlatConfig struct {
 	SSHPassword                       *string                     `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                    *string                     `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName           *string                     `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType           *string                     `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits           *int                        `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                        []string                    `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys            *bool                       `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                       []string                    `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -223,8 +221,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/amazon/chroot/builder.go

@@ -194,7 +194,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	b.config.ctx.Funcs = awscommon.TemplateFuncs
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{

builder/amazon/common/access_config.go

@@ -17,7 +17,6 @@ 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/builder/amazon/common/awserrors"
 	"github.com/hashicorp/packer/template/interpolate"
 	vaultapi "github.com/hashicorp/vault/api"
 )
@@ -272,7 +271,7 @@ func (c *AccessConfig) Session() (*session.Session, error) {
 
 	cp, err := c.session.Config.Credentials.Get()
 
-	if awserrors.Matches(err, "NoCredentialProviders", "") {
+	if IsAWSErr(err, "NoCredentialProviders", "") {
 		return nil, c.NewNoValidCredentialSourcesError(err)
 	}
 

builder/amazon/common/awserrors/utils.go

@@ -1,18 +0,0 @@
-package awserrors
-
-import (
-	"strings"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-// Returns true if the err matches all these conditions:
-//  * err is of type awserr.Error
-//  * Error.Code() matches code
-//  * Error.Message() contains message
-func Matches(err error, code string, message string) bool {
-	if err, ok := err.(awserr.Error); ok {
-		return err.Code() == code && strings.Contains(err.Message(), message)
-	}
-	return false
-}

builder/amazon/common/block_device.go

@@ -134,8 +134,8 @@ func (blockDevice BlockDevice) BuildEC2BlockDeviceMapping() *ec2.BlockDeviceMapp
 		ebsBlockDevice.VolumeSize = aws.Int64(blockDevice.VolumeSize)
 	}
 
-	// IOPS is only valid for io1 and io2 types
-	if blockDevice.VolumeType == "io1" || blockDevice.VolumeType == "io2" {
+	// IOPS is only valid for io1 type
+	if blockDevice.VolumeType == "io1" {
 		ebsBlockDevice.Iops = aws.Int64(blockDevice.IOPS)
 	}
 

builder/amazon/common/block_device_test.go

@@ -66,25 +66,6 @@ func TestBlockDevice(t *testing.T) {
 				},
 			},
 		},
-		{
-			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",

builder/amazon/common/helper_funcs.go

@@ -4,11 +4,12 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"strings"
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 	"github.com/hashicorp/packer/common/retry"
 )
 
@@ -30,7 +31,7 @@ func DestroyAMIs(imageids []*string, ec2conn *ec2.EC2) error {
 		err = retry.Config{
 			Tries: 11,
 			ShouldRetry: func(err error) bool {
-				return awserrors.Matches(err, "UnauthorizedOperation", "")
+				return IsAWSErr(err, "UnauthorizedOperation", "")
 			},
 			RetryDelay: (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30 * time.Second, Multiplier: 2}).Linear,
 		}.Run(ctx, func(ctx context.Context) error {
@@ -53,7 +54,7 @@ func DestroyAMIs(imageids []*string, ec2conn *ec2.EC2) error {
 				err = retry.Config{
 					Tries: 11,
 					ShouldRetry: func(err error) bool {
-						return awserrors.Matches(err, "UnauthorizedOperation", "")
+						return IsAWSErr(err, "UnauthorizedOperation", "")
 					},
 					RetryDelay: (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 30 * time.Second, Multiplier: 2}).Linear,
 				}.Run(ctx, func(ctx context.Context) error {
@@ -73,3 +74,14 @@ func DestroyAMIs(imageids []*string, ec2conn *ec2.EC2) error {
 	}
 	return nil
 }
+
+// Returns true if the error matches all these conditions:
+//  * err is of type awserr.Error
+//  * Error.Code() matches code
+//  * Error.Message() contains message
+func IsAWSErr(err error, code string, message string) bool {
+	if err, ok := err.(awserr.Error); ok {
+		return err.Code() == code && strings.Contains(err.Message(), message)
+	}
+	return false
+}

builder/amazon/common/run_config.go

@@ -376,12 +376,6 @@ type RunConfig struct {
 	// subnet-12345def, where Packer will launch the EC2 instance. This field is
 	// required if you are using an non-default VPC.
 	SubnetId string `mapstructure:"subnet_id" required:"false"`
-	// [Tenancy](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html) used
-	// when Packer launches the EC2 instance, allowing it to be launched on dedicated hardware.
-	//
-	// The default is "default", meaning shared tenancy. Allowed values are "default",
-	// "dedicated" and "host".
-	Tenancy string `mapstructure:"tenancy" required:"false"`
 	// The name of the temporary key pair to
 	// generate. By default, Packer generates a name that looks like
 	// `packer_<UUID>`, where &lt;UUID&gt; is a 36 character unique identifier.
@@ -548,6 +542,10 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 			msg := fmt.Errorf(`no iam_instance_profile defined; session_manager connectivity requires a valid instance profile with AmazonSSMManagedInstanceCore permissions. Alternatively a temporary_iam_instance_profile_policy_document can be used.`)
 			errs = append(errs, msg)
 		}
+
+		if c.PauseBeforeSSM == 0 {
+			c.PauseBeforeSSM = 10 * time.Second
+		}
 	}
 
 	if c.Comm.SSHKeyPairName != "" {
@@ -633,13 +631,6 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
 		}
 	}
 
-	if c.Tenancy != "" &&
-		c.Tenancy != "default" &&
-		c.Tenancy != "dedicated" &&
-		c.Tenancy != "host" {
-		errs = append(errs, fmt.Errorf("Error: Unknown tenancy type %s", c.Tenancy))
-	}
-
 	return errs
 }
 

builder/amazon/common/run_config_test.go

@@ -232,23 +232,3 @@ func TestRunConfigPrepare_TemporaryKeyPairName(t *testing.T) {
 		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/ssm/session.go

@@ -1,117 +0,0 @@
-package ssm
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"os/exec"
-	"strconv"
-	"time"
-
-	"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/builder/amazon/common/awserrors"
-	"github.com/hashicorp/packer/common/retry"
-	"github.com/hashicorp/packer/helper/builder/localexec"
-	"github.com/hashicorp/packer/packer"
-)
-
-type Session struct {
-	SvcClient             ssmiface.SSMAPI
-	Region                string
-	InstanceID            string
-	LocalPort, RemotePort int
-}
-
-func (s Session) buildTunnelInput() *ssm.StartSessionInput {
-	portNumber, localPortNumber := strconv.Itoa(s.RemotePort), strconv.Itoa(s.LocalPort)
-	params := map[string][]*string{
-		"portNumber":      []*string{aws.String(portNumber)},
-		"localPortNumber": []*string{aws.String(localPortNumber)},
-	}
-
-	return &ssm.StartSessionInput{
-		DocumentName: aws.String("AWS-StartPortForwardingSession"),
-		Parameters:   params,
-		Target:       aws.String(s.InstanceID),
-	}
-}
-
-// getCommand return a valid ordered set of arguments to pass to the driver command.
-func (s Session) getCommand(ctx context.Context) ([]string, string, error) {
-	input := s.buildTunnelInput()
-
-	var session *ssm.StartSessionOutput
-	err := retry.Config{
-		ShouldRetry: func(err error) bool { return awserrors.Matches(err, "TargetNotConnected", "") },
-		RetryDelay:  (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 60 * time.Second, Multiplier: 2}).Linear,
-	}.Run(ctx, func(ctx context.Context) (err error) {
-		session, err = s.SvcClient.StartSessionWithContext(ctx, input)
-		return err
-	})
-
-	if err != nil {
-		return nil, "", err
-	}
-
-	if session == nil {
-		return nil, "", fmt.Errorf("an active Amazon SSM Session is required before trying to open a session tunnel")
-	}
-
-	// AWS session-manager-plugin requires a valid session be passed in JSON.
-	sessionDetails, err := json.Marshal(session)
-	if err != nil {
-		return nil, *session.SessionId, fmt.Errorf("error encountered in reading session details %s", err)
-	}
-
-	// AWS session-manager-plugin requires the parameters used in the session to be passed in JSON as well.
-	sessionParameters, err := json.Marshal(input)
-	if err != nil {
-		return nil, "", fmt.Errorf("error encountered in reading session parameter details %s", err)
-	}
-
-	// Args must be in this order
-	args := []string{
-		string(sessionDetails),
-		s.Region,
-		"StartSession",
-		"", // ProfileName
-		string(sessionParameters),
-		*session.StreamUrl,
-	}
-	return args, *session.SessionId, nil
-}
-
-// Start an interactive Systems Manager session with a remote instance via the
-// AWS session-manager-plugin. To terminate the session you must cancell the
-// context. If you do not wish to terminate the session manually: calling
-// StopSession on a instance of this driver will terminate the active session
-// created from calling StartSession.
-func (s Session) Start(ctx context.Context, ui packer.Ui) error {
-	for ctx.Err() == nil {
-		log.Printf("ssm: Starting PortForwarding session to instance %s", s.InstanceID)
-		args, sessionID, err := s.getCommand(ctx)
-		if sessionID != "" {
-			defer func() {
-				_, err := s.SvcClient.TerminateSession(&ssm.TerminateSessionInput{SessionId: aws.String(sessionID)})
-				if err != nil {
-					ui.Error(fmt.Sprintf("Error terminating SSM Session %q. Please terminate the session manually: %s", sessionID, err))
-				}
-			}()
-		}
-		if err != nil {
-			return err
-		}
-
-		cmd := exec.CommandContext(ctx, "session-manager-plugin", args...)
-
-		ui.Message(fmt.Sprintf("Starting portForwarding session %q.", sessionID))
-		err = localexec.RunAndStream(cmd, ui, nil)
-		if err != nil {
-			ui.Error(err.Error())
-		}
-	}
-	return nil
-}

builder/amazon/common/ssm_driver.go

@@ -0,0 +1,197 @@
+package common
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os/exec"
+	"time"
+
+	"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/common/retry"
+	"github.com/mitchellh/iochan"
+)
+
+const (
+	sessionManagerPluginName string = "session-manager-plugin"
+
+	//sessionCommand is the AWS-SDK equivalent to the command you would specify to `aws ssm ...`
+	sessionCommand string = "StartSession"
+)
+
+type SSMDriverConfig struct {
+	SvcClient   ssmiface.SSMAPI
+	Region      string
+	ProfileName string
+	SvcEndpoint string
+}
+
+type SSMDriver struct {
+	SSMDriverConfig
+	session       *ssm.StartSessionOutput
+	sessionParams ssm.StartSessionInput
+	pluginCmdFunc func(context.Context) error
+}
+
+func NewSSMDriver(config SSMDriverConfig) *SSMDriver {
+	d := SSMDriver{SSMDriverConfig: config}
+	return &d
+}
+
+// StartSession starts an interactive Systems Manager session with a remote instance via the AWS session-manager-plugin
+// This ssm.StartSessionOutput returned by this function can be used for terminating the session manually. If you do
+// not wish to manage the session manually calling StopSession on a instance of this driver will terminate the active session
+// created from calling StartSession.
+func (d *SSMDriver) StartSession(ctx context.Context, input ssm.StartSessionInput) (*ssm.StartSessionOutput, error) {
+	log.Printf("Starting PortForwarding session to instance %q", aws.StringValue(input.Target))
+
+	var output *ssm.StartSessionOutput
+	err := retry.Config{
+		ShouldRetry: func(err error) bool { return IsAWSErr(err, "TargetNotConnected", "") },
+		RetryDelay:  (&retry.Backoff{InitialBackoff: 200 * time.Millisecond, MaxBackoff: 60 * time.Second, Multiplier: 2}).Linear,
+	}.Run(ctx, func(ctx context.Context) (err error) {
+		output, err = d.SvcClient.StartSessionWithContext(ctx, &input)
+		return err
+	})
+	if err != nil {
+		return nil, fmt.Errorf("error encountered in starting session for instance %q: %s", aws.StringValue(input.Target), err)
+	}
+
+	d.session = output
+	d.sessionParams = input
+
+	if d.pluginCmdFunc == nil {
+		d.pluginCmdFunc = d.openTunnelForSession
+	}
+
+	if err := d.pluginCmdFunc(ctx); err != nil {
+		return nil, fmt.Errorf("error encountered in starting session for instance %q: %s", aws.StringValue(input.Target), err)
+	}
+
+	return d.session, nil
+}
+
+func (d *SSMDriver) openTunnelForSession(ctx context.Context) error {
+	args, err := d.Args()
+	if err != nil {
+		return fmt.Errorf("error encountered validating session details: %s", err)
+	}
+
+	cmd := exec.CommandContext(ctx, sessionManagerPluginName, args...)
+
+	// Let's build up our logging
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return err
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return err
+	}
+
+	// Create the channels we'll use for data
+	stdoutCh := iochan.DelimReader(stdout, '\n')
+	stderrCh := iochan.DelimReader(stderr, '\n')
+
+	/* Loop and get all our output
+	This particular logger will continue to run through an entire Packer run.
+	The decision to continue logging is due to the fact that session-manager-plugin
+	doesn't give a good way of knowing if the command failed or was successful other
+	than looking at the logs. Seeing as the plugin is updated frequently and that the
+	log information is a bit sparse this logger will indefinitely relying on other
+	steps to fail if the tunnel is unable to be created. If successful then the user
+	will get more information on the tunnel connection when running in a debug mode.
+	*/
+	go func(ctx context.Context, prefix string) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case output, ok := <-stderrCh:
+				if !ok {
+					stderrCh = nil
+					break
+				}
+
+				if output != "" {
+					log.Printf("[ERROR] %s: %s", prefix, output)
+				}
+			case output, ok := <-stdoutCh:
+				if !ok {
+					stdoutCh = nil
+					break
+				}
+
+				if output != "" {
+					log.Printf("[DEBUG] %s: %s", prefix, output)
+				}
+			}
+
+			if stdoutCh == nil && stderrCh == nil {
+				log.Printf("[DEBUG] %s: %s", prefix, "active session has been terminated; stopping all log polling processes.")
+				return
+			}
+		}
+	}(ctx, sessionManagerPluginName)
+
+	log.Printf("[DEBUG %s] opening session tunnel to instance %q for session %q", sessionManagerPluginName,
+		aws.StringValue(d.sessionParams.Target),
+		aws.StringValue(d.session.SessionId),
+	)
+
+	if err := cmd.Start(); err != nil {
+		err = fmt.Errorf("error encountered when calling %s: %s\n", sessionManagerPluginName, err)
+		return err
+	}
+
+	return nil
+}
+
+// StopSession terminates an active Session Manager session
+func (d *SSMDriver) StopSession() error {
+
+	if d.session == nil || d.session.SessionId == nil {
+		return fmt.Errorf("Unable to find a valid session to instance %q; skipping the termination step",
+			aws.StringValue(d.sessionParams.Target))
+	}
+
+	_, err := d.SvcClient.TerminateSession(&ssm.TerminateSessionInput{SessionId: d.session.SessionId})
+	if err != nil {
+		err = fmt.Errorf("Error terminating SSM Session %q. Please terminate the session manually: %s", aws.StringValue(d.session.SessionId), err)
+	}
+	return err
+}
+
+// Args validates the driver inputs before returning an ordered set of arguments to pass to the driver command.
+func (d *SSMDriver) Args() ([]string, error) {
+	if d.session == nil {
+		return nil, fmt.Errorf("an active Amazon SSM Session is required before trying to open a session tunnel")
+	}
+
+	// AWS session-manager-plugin requires a valid session be passed in JSON.
+	sessionDetails, err := json.Marshal(d.session)
+	if err != nil {
+		return nil, fmt.Errorf("error encountered in reading session details %s", err)
+	}
+
+	// AWS session-manager-plugin requires the parameters used in the session to be passed in JSON as well.
+	sessionParameters, err := json.Marshal(d.sessionParams)
+	if err != nil {
+		return nil, fmt.Errorf("error encountered in reading session parameter details %s", err)
+	}
+
+	// Args must be in this order
+	args := []string{
+		string(sessionDetails),
+		d.Region,
+		sessionCommand,
+		d.ProfileName,
+		string(sessionParameters),
+		d.SvcEndpoint,
+	}
+
+	return args, nil
+}

builder/amazon/common/ssm_driver_test.go

@@ -0,0 +1,188 @@
+package common
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func NewSSMDriverWithMockSvc(svc *MockSSMSvc) *SSMDriver {
+	config := SSMDriverConfig{
+		SvcClient:   svc,
+		Region:      "east",
+		ProfileName: "default",
+		SvcEndpoint: "example.com",
+	}
+
+	driver := SSMDriver{
+		SSMDriverConfig: config,
+		pluginCmdFunc:   func(ctx context.Context) error { return nil },
+	}
+
+	return &driver
+}
+func TestSSMDriver_StartSession(t *testing.T) {
+	mockSvc := MockSSMSvc{}
+	driver := NewSSMDriverWithMockSvc(&mockSvc)
+
+	if driver.SvcClient == nil {
+		t.Fatalf("SvcClient for driver should not be nil")
+	}
+
+	session, err := driver.StartSession(context.TODO(), MockStartSessionInput("fakeinstance"))
+	if err != nil {
+		t.Fatalf("calling StartSession should not error but got %v", err)
+	}
+
+	if !mockSvc.StartSessionCalled {
+		t.Fatalf("expected test to call ssm mocks but didn't")
+	}
+
+	if session == nil {
+		t.Errorf("expected session to be set after a successful call to StartSession")
+	}
+
+	if !reflect.DeepEqual(session, MockStartSessionOutput()) {
+		t.Errorf("expected session to be %v but got %v", MockStartSessionOutput(), session)
+	}
+}
+
+func TestSSMDriver_StartSessionWithError(t *testing.T) {
+	mockSvc := MockSSMSvc{StartSessionError: fmt.Errorf("bogus error")}
+	driver := NewSSMDriverWithMockSvc(&mockSvc)
+
+	if driver.SvcClient == nil {
+		t.Fatalf("SvcClient for driver should not be nil")
+	}
+
+	session, err := driver.StartSession(context.TODO(), MockStartSessionInput("fakeinstance"))
+	if err == nil {
+		t.Fatalf("StartSession should have thrown an error but didn't")
+	}
+
+	if !mockSvc.StartSessionCalled {
+		t.Errorf("expected test to call StartSession mock but didn't")
+	}
+
+	if session != nil {
+		t.Errorf("expected session to be nil after a bad StartSession call, but got %v", session)
+	}
+}
+
+func TestSSMDriver_StopSession(t *testing.T) {
+	mockSvc := MockSSMSvc{}
+	driver := NewSSMDriverWithMockSvc(&mockSvc)
+
+	if driver.SvcClient == nil {
+		t.Fatalf("SvcClient for driver should not be nil")
+	}
+
+	// Calling StopSession before StartSession should fail
+	err := driver.StopSession()
+	if err == nil {
+		t.Fatalf("calling StopSession() on a driver that has no started session should fail")
+	}
+
+	if driver.session != nil {
+		t.Errorf("expected session to be default to nil")
+	}
+
+	if mockSvc.TerminateSessionCalled {
+		t.Fatalf("a call to TerminateSession should not occur when there is no valid SSM session")
+	}
+
+	// Lets try calling start session, then stopping to see what happens.
+	session, err := driver.StartSession(context.TODO(), MockStartSessionInput("fakeinstance"))
+	if err != nil {
+		t.Fatalf("calling StartSession should not error but got %v", err)
+	}
+
+	if !mockSvc.StartSessionCalled {
+		t.Fatalf("expected test to call StartSession mock but didn't")
+	}
+
+	if session == nil || driver.session != session {
+		t.Errorf("expected session to be set after a successful call to StartSession")
+	}
+
+	if !reflect.DeepEqual(session, MockStartSessionOutput()) {
+		t.Errorf("expected session to be %v but got %v", MockStartSessionOutput(), session)
+	}
+
+	err = driver.StopSession()
+	if err != nil {
+		t.Errorf("calling StopSession() on a driver on a started session should not fail")
+	}
+
+	if !mockSvc.TerminateSessionCalled {
+		t.Fatalf("expected test to call StopSession mock but didn't")
+	}
+
+}
+
+func TestSSMDriver_Args(t *testing.T) {
+	tt := []struct {
+		Name             string
+		ProfileName      string
+		SkipStartSession bool
+		ErrorExpected    bool
+	}{
+		{
+			Name:             "NilSession",
+			SkipStartSession: true,
+			ErrorExpected:    true,
+		},
+		{
+			Name:          "NonNilSession",
+			ErrorExpected: false,
+		},
+		{
+			Name:          "SessionWithProfileName",
+			ProfileName:   "default",
+			ErrorExpected: false,
+		},
+	}
+
+	for _, tc := range tt {
+		tc := tc
+		t.Run(tc.Name, func(t *testing.T) {
+			mockSvc := MockSSMSvc{}
+			driver := NewSSMDriverWithMockSvc(&mockSvc)
+			driver.ProfileName = tc.ProfileName
+
+			if driver.SvcClient == nil {
+				t.Fatalf("svcclient for driver should not be nil")
+			}
+
+			if !tc.SkipStartSession {
+				_, err := driver.StartSession(context.TODO(), MockStartSessionInput("fakeinstance"))
+				if err != nil {
+					t.Fatalf("got an error when calling StartSession %v", err)
+				}
+			}
+
+			args, err := driver.Args()
+			if tc.ErrorExpected && err == nil {
+				t.Fatalf("Driver.Args with a %q should have failed but instead no error was returned", tc.Name)
+			}
+
+			if tc.ErrorExpected {
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("got an error when it should've worked %v", err)
+			}
+
+			// validate launch script
+			expectedArgString := fmt.Sprintf(`{"SessionId":"packerid","StreamUrl":"http://packer.io","TokenValue":"packer-token"} east StartSession %s {"DocumentName":"AWS-StartPortForwardingSession","Parameters":{"localPortNumber":["8001"],"portNumber":["22"]},"Target":"fakeinstance"} example.com`, tc.ProfileName)
+			argString := strings.Join(args, " ")
+			if argString != expectedArgString {
+				t.Errorf("Expected launch script to be %q but got %q", expectedArgString, argString)
+			}
+
+		})
+	}
+}

builder/amazon/common/ssm_mock_funcs.go

@@ -0,0 +1,56 @@
+package common
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/service/ssm"
+	"github.com/aws/aws-sdk-go/service/ssm/ssmiface"
+)
+
+type MockSSMSvc struct {
+	ssmiface.SSMAPI
+	StartSessionError      error
+	TerminateSessionError  error
+	StartSessionCalled     bool
+	TerminateSessionCalled bool
+}
+
+func (svc *MockSSMSvc) StartSessionWithContext(ctx aws.Context, input *ssm.StartSessionInput, options ...request.Option) (*ssm.StartSessionOutput, error) {
+	svc.StartSessionCalled = true
+	return MockStartSessionOutput(), svc.StartSessionError
+}
+func (svc *MockSSMSvc) TerminateSession(input *ssm.TerminateSessionInput) (*ssm.TerminateSessionOutput, error) {
+	svc.TerminateSessionCalled = true
+	return new(ssm.TerminateSessionOutput), svc.TerminateSessionError
+}
+
+func MockPluginCmdFunc(ctx context.Context) error {
+	return nil
+}
+
+func MockStartSessionOutput() *ssm.StartSessionOutput {
+	id, url, token := "packerid", "http://packer.io", "packer-token"
+	output := ssm.StartSessionOutput{
+		SessionId:  &id,
+		StreamUrl:  &url,
+		TokenValue: &token,
+	}
+	return &output
+}
+
+func MockStartSessionInput(instance string) ssm.StartSessionInput {
+	params := map[string][]*string{
+		"portNumber":      []*string{aws.String("22")},
+		"localPortNumber": []*string{aws.String("8001")},
+	}
+
+	input := ssm.StartSessionInput{
+		DocumentName: aws.String("AWS-StartPortForwardingSession"),
+		Parameters:   params,
+		Target:       aws.String(instance),
+	}
+
+	return input
+}

builder/amazon/common/step_create_ssm_tunnel.go

@@ -3,13 +3,13 @@ package common
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"time"
 
 	"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/aws/aws-sdk-go/service/ssm"
-	pssm "github.com/hashicorp/packer/builder/amazon/common/ssm"
 	"github.com/hashicorp/packer/common/net"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -21,8 +21,9 @@ type StepCreateSSMTunnel struct {
 	LocalPortNumber  int
 	RemotePortNumber int
 	SSMAgentEnabled  bool
+	instanceId       string
 	PauseBeforeSSM   time.Duration
-	stopSSMCommand   func()
+	driver           *SSMDriver
 }
 
 // Run executes the Packer build step that creates a session tunnel.
@@ -35,7 +36,7 @@ func (s *StepCreateSSMTunnel) Run(ctx context.Context, state multistep.StateBag)
 
 	// Wait for the remote port to become available
 	if s.PauseBeforeSSM > 0 {
-		ui.Say(fmt.Sprintf("Waiting %s before establishing the SSM session...", s.PauseBeforeSSM))
+		ui.Say(fmt.Sprintf("Waiting %s for establishing the SSM session...", s.PauseBeforeSSM))
 		select {
 		case <-time.After(s.PauseBeforeSSM):
 			break
@@ -60,38 +61,42 @@ func (s *StepCreateSSMTunnel) Run(ctx context.Context, state multistep.StateBag)
 		state.Put("error", err)
 		return multistep.ActionHalt
 	}
+	s.instanceId = aws.StringValue(instance.InstanceId)
 
-	state.Put("sessionPort", s.LocalPortNumber)
-
-	ssmCtx, ssmCancel := context.WithCancel(ctx)
-	s.stopSSMCommand = ssmCancel
-
-	go func() {
+	if s.driver == nil {
 		ssmconn := ssm.New(s.AWSSession)
-		err := pssm.Session{
-			SvcClient:  ssmconn,
-			InstanceID: aws.StringValue(instance.InstanceId),
-			RemotePort: s.RemotePortNumber,
-			LocalPort:  s.LocalPortNumber,
-			Region:     s.Region,
-		}.Start(ssmCtx, ui)
-
-		if err != nil {
-			ui.Error(fmt.Sprintf("ssm error: %s", err))
+		cfg := SSMDriverConfig{
+			SvcClient:   ssmconn,
+			Region:      s.Region,
+			SvcEndpoint: ssmconn.Endpoint,
 		}
-	}()
+		driver := SSMDriver{SSMDriverConfig: cfg}
+		s.driver = &driver
+	}
 
+	input := s.BuildTunnelInputForInstance(s.instanceId)
+	_, err := s.driver.StartSession(ctx, input)
+	if err != nil {
+		err = fmt.Errorf("error encountered in establishing a tunnel %s", err)
+		ui.Error(err.Error())
+		state.Put("error", err)
+		return multistep.ActionHalt
+	}
+
+	ui.Message(fmt.Sprintf("PortForwarding session %q has been started", s.instanceId))
+	state.Put("sessionPort", s.LocalPortNumber)
 	return multistep.ActionContinue
 }
 
 // Cleanup terminates an active session on AWS, which in turn terminates the associated tunnel process running on the local machine.
 func (s *StepCreateSSMTunnel) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packer.Ui)
 	if !s.SSMAgentEnabled {
 		return
 	}
 
-	if s.stopSSMCommand != nil {
-		s.stopSSMCommand()
+	if err := s.driver.StopSession(); err != nil {
+		ui.Error(err.Error())
 	}
 }
 
@@ -124,3 +129,19 @@ func (s *StepCreateSSMTunnel) ConfigureLocalHostPort(ctx context.Context) error
 	return nil
 
 }
+
+func (s *StepCreateSSMTunnel) BuildTunnelInputForInstance(instance string) ssm.StartSessionInput {
+	dst, src := strconv.Itoa(s.RemotePortNumber), strconv.Itoa(s.LocalPortNumber)
+	params := map[string][]*string{
+		"portNumber":      []*string{aws.String(dst)},
+		"localPortNumber": []*string{aws.String(src)},
+	}
+
+	input := ssm.StartSessionInput{
+		DocumentName: aws.String("AWS-StartPortForwardingSession"),
+		Parameters:   params,
+		Target:       aws.String(instance),
+	}
+
+	return input
+}

builder/amazon/common/step_create_ssm_tunnel_test.go

@@ -0,0 +1,139 @@
+package common
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/packer/packer"
+)
+
+func TestStepCreateSSMTunnel_Run(t *testing.T) {
+	mockSvc := MockSSMSvc{}
+	config := SSMDriverConfig{
+		SvcClient:   &mockSvc,
+		SvcEndpoint: "example.com",
+	}
+
+	mockDriver := NewSSMDriver(config)
+	mockDriver.pluginCmdFunc = MockPluginCmdFunc
+
+	state := testState()
+	state.Put("ui", &packer.NoopUi{})
+	state.Put("instance", &ec2.Instance{InstanceId: aws.String("i-something")})
+
+	step := StepCreateSSMTunnel{
+		driver: mockDriver,
+	}
+
+	step.Run(context.Background(), state)
+
+	err := state.Get("error")
+	if err != nil {
+		err = err.(error)
+		t.Fatalf("the call to Run failed with an error when it should've executed: %v", err)
+	}
+
+	if mockSvc.StartSessionCalled {
+		t.Errorf("StartSession should not be called when SSMAgentEnabled is false")
+	}
+
+	// Run when SSMAgentEnabled is true
+	step.SSMAgentEnabled = true
+	step.Run(context.Background(), state)
+
+	err = state.Get("error")
+	if err != nil {
+		err = err.(error)
+		t.Fatalf("the call to Run failed with an error when it should've executed: %v", err)
+	}
+
+	if !mockSvc.StartSessionCalled {
+		t.Errorf("calling run with the correct inputs should call StartSession")
+	}
+
+	step.Cleanup(state)
+	if !mockSvc.TerminateSessionCalled {
+		t.Errorf("calling cleanup on a successful run should call TerminateSession")
+	}
+}
+
+func TestStepCreateSSMTunnel_Cleanup(t *testing.T) {
+	mockSvc := MockSSMSvc{}
+	config := SSMDriverConfig{
+		SvcClient:   &mockSvc,
+		SvcEndpoint: "example.com",
+	}
+
+	mockDriver := NewSSMDriver(config)
+	mockDriver.pluginCmdFunc = MockPluginCmdFunc
+
+	step := StepCreateSSMTunnel{
+		SSMAgentEnabled: true,
+		driver:          mockDriver,
+	}
+
+	state := testState()
+	state.Put("ui", &packer.NoopUi{})
+	state.Put("instance", &ec2.Instance{InstanceId: aws.String("i-something")})
+
+	step.Cleanup(state)
+
+	if mockSvc.TerminateSessionCalled {
+		t.Fatalf("calling cleanup on a non started session should not call TerminateSession")
+	}
+
+}
+
+func TestStepCreateSSMTunnel_BuildTunnelInputForInstance(t *testing.T) {
+	step := StepCreateSSMTunnel{
+		Region:           "region",
+		LocalPortNumber:  8001,
+		RemotePortNumber: 22,
+		SSMAgentEnabled:  true,
+	}
+
+	input := step.BuildTunnelInputForInstance("i-something")
+
+	target := aws.StringValue(input.Target)
+	if target != "i-something" {
+		t.Errorf("input should contain instance id as target but it got %q", target)
+	}
+
+	params := map[string][]*string{
+		"portNumber":      []*string{aws.String("22")},
+		"localPortNumber": []*string{aws.String("8001")},
+	}
+	if !reflect.DeepEqual(input.Parameters, params) {
+		t.Errorf("input should contain the expected port parameters but it got %v", input.Parameters)
+	}
+
+}
+
+func TestStepCreateSSMTunnel_ConfigureLocalHostPort(t *testing.T) {
+	tt := []struct {
+		Name      string
+		Step      StepCreateSSMTunnel
+		PortCheck func(int) bool
+	}{
+		{"WithLocalPortNumber", StepCreateSSMTunnel{LocalPortNumber: 9001}, func(port int) bool { return port == 9001 }},
+		{"WithNoLocalPortNumber", StepCreateSSMTunnel{}, func(port int) bool { return port >= 8000 && port <= 9000 }},
+	}
+
+	for _, tc := range tt {
+		tc := tc
+		t.Run(tc.Name, func(t *testing.T) {
+			step := tc.Step
+			if err := step.ConfigureLocalHostPort(context.TODO()); err != nil {
+				t.Errorf("failed to configure a port on localhost")
+			}
+
+			if !tc.PortCheck(step.LocalPortNumber) {
+				t.Errorf("failed to configure a port on localhost")
+			}
+		})
+	}
+
+}

builder/amazon/common/step_create_tags.go

@@ -8,7 +8,6 @@ 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/builder/amazon/common/awserrors"
 	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -92,7 +91,7 @@ func (s *StepCreateTags) Run(ctx context.Context, state multistep.StateBag) mult
 
 		// Retry creating tags for about 2.5 minutes
 		err = retry.Config{Tries: 11, ShouldRetry: func(error) bool {
-			if awserrors.Matches(err, "InvalidAMIID.NotFound", "") || awserrors.Matches(err, "InvalidSnapshot.NotFound", "") {
+			if IsAWSErr(err, "InvalidAMIID.NotFound", "") || IsAWSErr(err, "InvalidSnapshot.NotFound", "") {
 				return true
 			}
 			return false

builder/amazon/common/step_pre_validate.go

@@ -9,7 +9,6 @@ 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/builder/amazon/common/awserrors"
 	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -40,7 +39,7 @@ func (s *StepPreValidate) Run(ctx context.Context, state multistep.StateBag) mul
 			err := retry.Config{
 				Tries: 11,
 				ShouldRetry: func(err error) bool {
-					if awserrors.Matches(err, "AuthFailure", "") {
+					if IsAWSErr(err, "AuthFailure", "") {
 						log.Printf("Waiting for Vault-generated AWS credentials" +
 							" to pass authentication... trying again.")
 						return true
@@ -132,7 +131,7 @@ func (s *StepPreValidate) checkVpc(conn ec2iface.EC2API) error {
 	}
 
 	res, err := conn.DescribeVpcs(&ec2.DescribeVpcsInput{VpcIds: []*string{aws.String(s.VpcId)}})
-	if awserrors.Matches(err, "InvalidVpcID.NotFound", "") || err != nil {
+	if IsAWSErr(err, "InvalidVpcID.NotFound", "") || err != nil {
 		return fmt.Errorf("Error retrieving VPC information for vpc_id %s: %s", s.VpcId, err)
 	}
 

builder/amazon/common/step_run_source_instance.go

@@ -11,7 +11,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 
-	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/multistep"
@@ -34,7 +33,6 @@ type StepRunSourceInstance struct {
 	IsRestricted                      bool
 	SourceAMI                         string
 	Tags                              map[string]string
-	Tenancy                           string
 	UserData                          string
 	UserDataFile                      string
 	VolumeTags                        map[string]string
@@ -197,15 +195,11 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior
 	}
 
-	if s.Tenancy != "" {
-		runOpts.Placement.Tenancy = aws.String(s.Tenancy)
-	}
-
 	var runResp *ec2.Reservation
 	err = retry.Config{
 		Tries: 11,
 		ShouldRetry: func(err error) bool {
-			if awserrors.Matches(err, "InvalidParameterValue", "iamInstanceProfile") {
+			if IsAWSErr(err, "InvalidParameterValue", "iamInstanceProfile") {
 				return true
 			}
 			return false
@@ -216,7 +210,7 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		return err
 	})
 
-	if awserrors.Matches(err, "VPCIdNotSpecified", "No default VPC for this user") && subnetId == "" {
+	if IsAWSErr(err, "VPCIdNotSpecified", "No default VPC for this user") && subnetId == "" {
 		err := fmt.Errorf("Error launching source instance: a valid Subnet Id was not specified")
 		state.Put("error", err)
 		ui.Error(err.Error())
@@ -254,7 +248,7 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 
 	var r *ec2.DescribeInstancesOutput
 	err = retry.Config{Tries: 11, ShouldRetry: func(err error) bool {
-		if awserrors.Matches(err, "InvalidInstanceID.NotFound", "") {
+		if IsAWSErr(err, "InvalidInstanceID.NotFound", "") {
 			return true
 		}
 		return false
@@ -299,7 +293,7 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		ec2Tags.Report(ui)
 		// Retry creating tags for about 2.5 minutes
 		err = retry.Config{Tries: 11, ShouldRetry: func(error) bool {
-			if awserrors.Matches(err, "InvalidInstanceID.NotFound", "") {
+			if IsAWSErr(err, "InvalidInstanceID.NotFound", "") {
 				return true
 			}
 			return false

builder/amazon/common/step_run_spot_instance.go

@@ -11,7 +11,6 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 	"github.com/hashicorp/packer/common/random"
 	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/communicator"
@@ -397,7 +396,7 @@ func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag)
 
 	// Retry creating tags for about 2.5 minutes
 	err = retry.Config{Tries: 11, ShouldRetry: func(error) bool {
-		if awserrors.Matches(err, "InvalidInstanceID.NotFound", "") {
+		if IsAWSErr(err, "InvalidInstanceID.NotFound", "") {
 			return true
 		}
 		return false

builder/amazon/common/step_stop_ebs_instance.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -43,7 +42,7 @@ func (s *StepStopEBSBackedInstance) Run(ctx context.Context, state multistep.Sta
 
 		// Work around this by retrying a few times, up to about 5 minutes.
 		err := retry.Config{Tries: 6, ShouldRetry: func(error) bool {
-			if awserrors.Matches(err, "InvalidInstanceID.NotFound", "") {
+			if IsAWSErr(err, "InvalidInstanceID.NotFound", "") {
 				return true
 			}
 			return false

builder/amazon/ebs/builder.go

@@ -85,7 +85,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	b.config.ctx.Funcs = awscommon.TemplateFuncs
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
@@ -207,7 +206,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                         b.config.SourceAmi,
 			Tags:                              b.config.RunTags,
-			Tenancy:                           b.config.Tenancy,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
 			VolumeTags:                        b.config.VolumeRunTags,

builder/amazon/ebs/builder.hcl2spec.go

@@ -81,7 +81,6 @@ type FlatConfig struct {
 	SpotTag                                   []hcl2template.FlatKeyValue            `mapstructure:"spot_tag" required:"false" cty:"spot_tag" hcl:"spot_tag"`
 	SubnetFilter                              *common.FlatSubnetFilterOptions        `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter" hcl:"subnet_filter"`
 	SubnetId                                  *string                                `mapstructure:"subnet_id" required:"false" cty:"subnet_id" hcl:"subnet_id"`
-	Tenancy                                   *string                                `mapstructure:"tenancy" required:"false" cty:"tenancy" hcl:"tenancy"`
 	TemporaryKeyPairName                      *string                                `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
 	TemporarySGSourceCidrs                    []string                               `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs" hcl:"temporary_security_group_source_cidrs"`
 	UserData                                  *string                                `mapstructure:"user_data" required:"false" cty:"user_data" hcl:"user_data"`
@@ -96,8 +95,6 @@ type FlatConfig struct {
 	SSHUsername                               *string                                `mapstructure:"ssh_username" cty:"ssh_username" hcl:"ssh_username"`
 	SSHPassword                               *string                                `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                            *string                                `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
-	SSHTemporaryKeyPairType                   *string                                `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits                   *int                                   `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                                []string                               `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys                    *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                               []string                               `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -229,7 +226,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"spot_tag":                              &hcldec.BlockListSpec{TypeName: "spot_tag", Nested: hcldec.ObjectSpec((*hcl2template.FlatKeyValue)(nil).HCL2Spec())},
 		"subnet_filter":                         &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
 		"subnet_id":                             &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
-		"tenancy":                               &hcldec.AttrSpec{Name: "tenancy", Type: cty.String, Required: false},
 		"temporary_key_pair_name":               &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
 		"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
 		"user_data":                             &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
@@ -244,8 +240,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_username":                          &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
 		"ssh_password":                          &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                      &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":               &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":               &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                           &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":             &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":           &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/amazon/ebs/builder_acc_test.go

@@ -246,14 +246,6 @@ func checkBootEncrypted() builderT.TestCheckFunc {
 	}
 }
 
-func TestBuilderAcc_SessionManagerInterface(t *testing.T) {
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() { testAccPreCheck(t) },
-		Builder:  &Builder{},
-		Template: testBuilderAccSessionManagerInterface,
-	})
-}
-
 func testAccPreCheck(t *testing.T) {
 }
 
@@ -358,31 +350,6 @@ const testBuilderAccEncrypted = `
 }
 `
 
-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)
 }

builder/amazon/ebs/step_create_ami.go

@@ -9,7 +9,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/builder/amazon/common/awserrors"
 	"github.com/hashicorp/packer/common/random"
 	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
@@ -62,7 +61,7 @@ func (s *stepCreateAMI) Run(ctx context.Context, state multistep.StateBag) multi
 	err = retry.Config{
 		Tries: 0,
 		ShouldRetry: func(err error) bool {
-			if awserrors.Matches(err, "InvalidParameterValue", "Instance is not in state") {
+			if awscommon.IsAWSErr(err, "InvalidParameterValue", "Instance is not in state") {
 				return true
 			}
 			return false

builder/amazon/ebssurrogate/builder.go

@@ -84,7 +84,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	b.config.ctx.Funcs = awscommon.TemplateFuncs
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
@@ -229,7 +228,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                         b.config.SourceAmi,
 			Tags:                              b.config.RunTags,
-			Tenancy:                           b.config.Tenancy,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
 			VolumeTags:                        b.config.VolumeRunTags,
@@ -334,8 +332,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			PollingConfig:   b.config.PollingConfig,
 			LaunchDevices:   launchDevices,
 			SnapshotOmitMap: b.config.LaunchMappings.GetOmissions(),
-			SnapshotTags:    b.config.SnapshotTags,
-			Ctx:             b.config.ctx,
 		},
 		&awscommon.StepDeregisterAMI{
 			AccessConfig:        &b.config.AccessConfig,

builder/amazon/ebssurrogate/builder.hcl2spec.go

@@ -103,7 +103,6 @@ type FlatConfig struct {
 	SpotTag                                   []hcl2template.FlatKeyValue            `mapstructure:"spot_tag" required:"false" cty:"spot_tag" hcl:"spot_tag"`
 	SubnetFilter                              *common.FlatSubnetFilterOptions        `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter" hcl:"subnet_filter"`
 	SubnetId                                  *string                                `mapstructure:"subnet_id" required:"false" cty:"subnet_id" hcl:"subnet_id"`
-	Tenancy                                   *string                                `mapstructure:"tenancy" required:"false" cty:"tenancy" hcl:"tenancy"`
 	TemporaryKeyPairName                      *string                                `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
 	TemporarySGSourceCidrs                    []string                               `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs" hcl:"temporary_security_group_source_cidrs"`
 	UserData                                  *string                                `mapstructure:"user_data" required:"false" cty:"user_data" hcl:"user_data"`
@@ -118,8 +117,6 @@ type FlatConfig struct {
 	SSHUsername                               *string                                `mapstructure:"ssh_username" cty:"ssh_username" hcl:"ssh_username"`
 	SSHPassword                               *string                                `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                            *string                                `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
-	SSHTemporaryKeyPairType                   *string                                `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits                   *int                                   `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                                []string                               `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys                    *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                               []string                               `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -252,7 +249,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"spot_tag":                              &hcldec.BlockListSpec{TypeName: "spot_tag", Nested: hcldec.ObjectSpec((*hcl2template.FlatKeyValue)(nil).HCL2Spec())},
 		"subnet_filter":                         &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
 		"subnet_id":                             &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
-		"tenancy":                               &hcldec.AttrSpec{Name: "tenancy", Type: cty.String, Required: false},
 		"temporary_key_pair_name":               &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
 		"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
 		"user_data":                             &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
@@ -267,8 +263,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_username":                          &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
 		"ssh_password":                          &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                      &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":               &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":               &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                           &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":             &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":           &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/amazon/ebssurrogate/step_snapshot_volumes.go

@@ -6,13 +6,11 @@ import (
 	"sync"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	multierror "github.com/hashicorp/go-multierror"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/hashicorp/packer/template/interpolate"
 )
 
 // StepSnapshotVolumes creates snapshots of the created volumes.
@@ -25,8 +23,6 @@ type StepSnapshotVolumes struct {
 	snapshotIds     map[string]string
 	snapshotMutex   sync.Mutex
 	SnapshotOmitMap map[string]bool
-	SnapshotTags    map[string]string
-	Ctx             interpolate.Context
 }
 
 func (s *StepSnapshotVolumes) snapshotVolume(ctx context.Context, deviceName string, state multistep.StateBag) error {
@@ -44,34 +40,12 @@ func (s *StepSnapshotVolumes) snapshotVolume(ctx context.Context, deviceName str
 		return fmt.Errorf("Volume ID for device %s not found", deviceName)
 	}
 
-	ui.Say("Creating snapshot tags")
-	snapshotTags, err := awscommon.TagMap(s.SnapshotTags).EC2Tags(s.Ctx, *ec2conn.Config.Region, state)
-	if err != nil {
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return err
-	}
-	snapshotTags.Report(ui)
-
 	ui.Say(fmt.Sprintf("Creating snapshot of EBS Volume %s...", volumeId))
 	description := fmt.Sprintf("Packer: %s", time.Now().String())
 
-	// Collect tags for tagging on resource creation
-	var tagSpecs []*ec2.TagSpecification
-
-	if len(snapshotTags) > 0 {
-		snapTags := &ec2.TagSpecification{
-			ResourceType: aws.String("snapshot"),
-			Tags:         snapshotTags,
-		}
-
-		tagSpecs = append(tagSpecs, snapTags)
-	}
-
 	createSnapResp, err := ec2conn.CreateSnapshot(&ec2.CreateSnapshotInput{
-		VolumeId:          &volumeId,
-		Description:       &description,
-		TagSpecifications: tagSpecs,
+		VolumeId:    &volumeId,
+		Description: &description,
 	})
 	if err != nil {
 		return err

builder/amazon/ebsvolume/builder.go

@@ -100,7 +100,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 		SourceAMI:   `{{ .SourceAMI }} `,
 	}
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 	}, raws...)
@@ -210,7 +209,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                         b.config.SourceAmi,
 			Tags:                              b.config.RunTags,
-			Tenancy:                           b.config.Tenancy,
 			UserData:                          b.config.UserData,
 			UserDataFile:                      b.config.UserDataFile,
 			VolumeTags:                        b.config.VolumeRunTags,

builder/amazon/ebsvolume/builder.hcl2spec.go

@@ -105,7 +105,6 @@ type FlatConfig struct {
 	SpotTag                                   []hcl2template.FlatKeyValue            `mapstructure:"spot_tag" required:"false" cty:"spot_tag" hcl:"spot_tag"`
 	SubnetFilter                              *common.FlatSubnetFilterOptions        `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter" hcl:"subnet_filter"`
 	SubnetId                                  *string                                `mapstructure:"subnet_id" required:"false" cty:"subnet_id" hcl:"subnet_id"`
-	Tenancy                                   *string                                `mapstructure:"tenancy" required:"false" cty:"tenancy" hcl:"tenancy"`
 	TemporaryKeyPairName                      *string                                `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
 	TemporarySGSourceCidrs                    []string                               `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs" hcl:"temporary_security_group_source_cidrs"`
 	UserData                                  *string                                `mapstructure:"user_data" required:"false" cty:"user_data" hcl:"user_data"`
@@ -120,8 +119,6 @@ type FlatConfig struct {
 	SSHUsername                               *string                                `mapstructure:"ssh_username" cty:"ssh_username" hcl:"ssh_username"`
 	SSHPassword                               *string                                `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                            *string                                `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
-	SSHTemporaryKeyPairType                   *string                                `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits                   *int                                   `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                                []string                               `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys                    *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                               []string                               `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -232,7 +229,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"spot_tag":                              &hcldec.BlockListSpec{TypeName: "spot_tag", Nested: hcldec.ObjectSpec((*hcl2template.FlatKeyValue)(nil).HCL2Spec())},
 		"subnet_filter":                         &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
 		"subnet_id":                             &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
-		"tenancy":                               &hcldec.AttrSpec{Name: "tenancy", Type: cty.String, Required: false},
 		"temporary_key_pair_name":               &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
 		"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
 		"user_data":                             &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
@@ -247,8 +243,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_username":                          &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
 		"ssh_password":                          &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                      &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":               &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":               &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                           &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":             &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":           &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/amazon/instance/builder.go

@@ -107,7 +107,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 
 	b.config.ctx.Funcs = awscommon.TemplateFuncs
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
@@ -287,7 +286,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			IsRestricted:             b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                b.config.SourceAmi,
 			Tags:                     b.config.RunTags,
-			Tenancy:                  b.config.Tenancy,
 			UserData:                 b.config.UserData,
 			UserDataFile:             b.config.UserDataFile,
 		}

builder/amazon/instance/builder.hcl2spec.go

@@ -81,7 +81,6 @@ type FlatConfig struct {
 	SpotTag                                   []hcl2template.FlatKeyValue            `mapstructure:"spot_tag" required:"false" cty:"spot_tag" hcl:"spot_tag"`
 	SubnetFilter                              *common.FlatSubnetFilterOptions        `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter" hcl:"subnet_filter"`
 	SubnetId                                  *string                                `mapstructure:"subnet_id" required:"false" cty:"subnet_id" hcl:"subnet_id"`
-	Tenancy                                   *string                                `mapstructure:"tenancy" required:"false" cty:"tenancy" hcl:"tenancy"`
 	TemporaryKeyPairName                      *string                                `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
 	TemporarySGSourceCidrs                    []string                               `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs" hcl:"temporary_security_group_source_cidrs"`
 	UserData                                  *string                                `mapstructure:"user_data" required:"false" cty:"user_data" hcl:"user_data"`
@@ -96,8 +95,6 @@ type FlatConfig struct {
 	SSHUsername                               *string                                `mapstructure:"ssh_username" cty:"ssh_username" hcl:"ssh_username"`
 	SSHPassword                               *string                                `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                            *string                                `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
-	SSHTemporaryKeyPairType                   *string                                `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits                   *int                                   `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                                []string                               `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys                    *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                               []string                               `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -235,7 +232,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"spot_tag":                              &hcldec.BlockListSpec{TypeName: "spot_tag", Nested: hcldec.ObjectSpec((*hcl2template.FlatKeyValue)(nil).HCL2Spec())},
 		"subnet_filter":                         &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
 		"subnet_id":                             &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
-		"tenancy":                               &hcldec.AttrSpec{Name: "tenancy", Type: cty.String, Required: false},
 		"temporary_key_pair_name":               &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
 		"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
 		"user_data":                             &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
@@ -250,8 +246,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_username":                          &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
 		"ssh_password":                          &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                      &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":               &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":               &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                           &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":             &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":           &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/azure/arm/builder.go

@@ -222,6 +222,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			NewStepSnapshotDataDisks(azureClient, ui, &b.config),
 			NewStepCaptureImage(azureClient, ui),
 			NewStepPublishToSharedImageGallery(azureClient, ui, &b.config),
+			NewStepDeleteAdditionalDisks(azureClient, ui),
 		}
 	} else if b.config.OSType == constants.Target_Windows {
 		steps = []multistep.Step{
@@ -262,6 +263,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			NewStepSnapshotDataDisks(azureClient, ui, &b.config),
 			NewStepCaptureImage(azureClient, ui),
 			NewStepPublishToSharedImageGallery(azureClient, ui, &b.config),
+			NewStepDeleteAdditionalDisks(azureClient, ui),
 		)
 	} else {
 		return nil, fmt.Errorf("Builder does not support the os_type '%s'", b.config.OSType)

builder/azure/arm/builder_acc_test.go

@@ -6,6 +6,7 @@ package arm
 // * ARM_CLIENT_ID
 // * ARM_CLIENT_SECRET
 // * ARM_SUBSCRIPTION_ID
+// * ARM_OBJECT_ID
 // * ARM_STORAGE_ACCOUNT
 //
 // The subscription in question should have a resource group
@@ -46,14 +47,6 @@ func TestBuilderAcc_ManagedDisk_Windows_Build_Resource_Group(t *testing.T) {
 	})
 }
 
-func TestBuilderAcc_ManagedDisk_Windows_Build_Resource_Group_Additional_Disk(t *testing.T) {
-	builderT.Test(t, builderT.TestCase{
-		PreCheck: func() { testAccPreCheck(t) },
-		Builder:  &Builder{},
-		Template: testBuilderAccManagedDiskWindowsBuildResourceGroupAdditionalDisk,
-	})
-}
-
 func TestBuilderAcc_ManagedDisk_Windows_DeviceLogin(t *testing.T) {
 	if os.Getenv(DeviceLoginAcceptanceTest) == "" {
 		t.Skip(fmt.Sprintf(
@@ -158,7 +151,7 @@ const testBuilderAccManagedDiskWindowsBuildResourceGroup = `
 
 	  "build_resource_group_name" : "packer-acceptance-test",
 	  "managed_image_resource_group_name": "packer-acceptance-test",
-	  "managed_image_name": "testBuilderAccManagedDiskWindowsBuildResourceGroup-{{timestamp}}",
+	  "managed_image_name": "testBuilderAccManagedDiskWindows-{{timestamp}}",
 
 	  "os_type": "Windows",
 	  "image_publisher": "MicrosoftWindowsServer",
@@ -177,42 +170,6 @@ const testBuilderAccManagedDiskWindowsBuildResourceGroup = `
 }
 `
 
-const testBuilderAccManagedDiskWindowsBuildResourceGroupAdditionalDisk = `
-{
-	"variables": {
-	  "client_id": "{{env ` + "`ARM_CLIENT_ID`" + `}}",
-	  "client_secret": "{{env ` + "`ARM_CLIENT_SECRET`" + `}}",
-	  "subscription_id": "{{env ` + "`ARM_SUBSCRIPTION_ID`" + `}}"
-	},
-	"builders": [{
-	  "type": "test",
-
-	  "client_id": "{{user ` + "`client_id`" + `}}",
-	  "client_secret": "{{user ` + "`client_secret`" + `}}",
-	  "subscription_id": "{{user ` + "`subscription_id`" + `}}",
-
-	  "build_resource_group_name" : "packer-acceptance-test",
-	  "managed_image_resource_group_name": "packer-acceptance-test",
-	  "managed_image_name": "testBuilderAccManagedDiskWindowsBuildResourceGroupAdditionDisk-{{timestamp}}",
-
-	  "os_type": "Windows",
-	  "image_publisher": "MicrosoftWindowsServer",
-	  "image_offer": "WindowsServer",
-	  "image_sku": "2012-R2-Datacenter",
-
-	  "communicator": "winrm",
-	  "winrm_use_ssl": "true",
-	  "winrm_insecure": "true",
-	  "winrm_timeout": "3m",
-	  "winrm_username": "packer",
-	  "async_resourcegroup_delete": "true",
-
-	  "vm_size": "Standard_DS2_v2",
-	  "disk_additional_size": [10,15]
-	}]
-}
-`
-
 const testBuilderAccManagedDiskWindowsDeviceLogin = `
 {
 	"variables": {
@@ -305,6 +262,7 @@ const testBuilderAccBlobWindows = `
 	  "client_id": "{{env ` + "`ARM_CLIENT_ID`" + `}}",
 	  "client_secret": "{{env ` + "`ARM_CLIENT_SECRET`" + `}}",
 	  "subscription_id": "{{env ` + "`ARM_SUBSCRIPTION_ID`" + `}}",
+	  "object_id": "{{env ` + "`ARM_OBJECT_ID`" + `}}",
 	  "storage_account": "{{env ` + "`ARM_STORAGE_ACCOUNT`" + `}}"
 	},
 	"builders": [{
@@ -313,6 +271,7 @@ const testBuilderAccBlobWindows = `
 	  "client_id": "{{user ` + "`client_id`" + `}}",
 	  "client_secret": "{{user ` + "`client_secret`" + `}}",
 	  "subscription_id": "{{user ` + "`subscription_id`" + `}}",
+	  "object_id": "{{user ` + "`object_id`" + `}}",
 
 	  "storage_account": "{{user ` + "`storage_account`" + `}}",
 	  "resource_group_name": "packer-acceptance-test",

builder/azure/arm/config.go

@@ -580,7 +580,6 @@ func (c *Config) createCertificate() (string, error) {
 func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
 	c.ctx.Funcs = azcommon.TemplateFuncs
 	err := config.Decode(c, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &c.ctx,
 	}, raws...)

builder/azure/arm/config.hcl2spec.go

@@ -80,8 +80,6 @@ type FlatConfig struct {
 	SSHPassword                                *string                            `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                             *string                            `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName                    *string                            `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType                    *string                            `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits                    *int                               `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                                 []string                           `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys                     *bool                              `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                                []string                           `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -206,8 +204,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                                     &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                                 &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":                          &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":                          &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":                          &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                                      &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":                        &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":                      &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/azure/arm/step_delete_additional_disks.go

@@ -61,11 +61,7 @@ func (s *StepDeleteAdditionalDisk) deleteManagedDisk(ctx context.Context, resour
 func (s *StepDeleteAdditionalDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	s.say("Deleting the temporary Additional disk ...")
 
-	var dataDisks []string
-
-	if disks := state.Get(constants.ArmAdditionalDiskVhds); disks != nil {
-		dataDisks = disks.([]string)
-	}
+	var dataDisks = state.Get(constants.ArmAdditionalDiskVhds).([]string)
 	var isManagedDisk = state.Get(constants.ArmIsManagedImage).(bool)
 	var isExistingResourceGroup = state.Get(constants.ArmIsExistingResourceGroup).(bool)
 	var resourceGroupName = state.Get(constants.ArmResourceGroupName).(string)

builder/azure/arm/step_deploy_template.go

@@ -6,10 +6,8 @@ import (
 	"fmt"
 	"net/url"
 	"strings"
-	"time"
 
 	"github.com/hashicorp/packer/builder/azure/common/constants"
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 )
@@ -17,7 +15,7 @@ import (
 type StepDeployTemplate struct {
 	client     *AzureClient
 	deploy     func(ctx context.Context, resourceGroupName string, deploymentName string) error
-	delete     func(ctx context.Context, deploymentName, resourceGroupName string) error
+	delete     func(ctx context.Context, client *AzureClient, resourceType string, resourceName string, resourceGroupName string) error
 	disk       func(ctx context.Context, resourceGroupName string, computeName string) (string, string, error)
 	deleteDisk func(ctx context.Context, imageType string, imageName string, resourceGroupName string) error
 	say        func(message string)
@@ -38,7 +36,7 @@ func NewStepDeployTemplate(client *AzureClient, ui packer.Ui, config *Config, de
 	}
 
 	step.deploy = step.deployTemplate
-	step.delete = step.deleteDeploymentResources
+	step.delete = deleteResource
 	step.disk = step.getImageDetails
 	step.deleteDisk = step.deleteImage
 	return step
@@ -64,9 +62,8 @@ func (s *StepDeployTemplate) Cleanup(state multistep.StateBag) {
 		}
 	}()
 
-	// Only clean up if this is an existing resource group that has been verified to exist.
-	// ArmIsResourceGroupCreated is set in step_create_resource_group to true, when Packer has verified that the resource group exists.
-	// ArmIsExistingResourceGroup is set to true when build_resource_group is set in the Packer configuration.
+	//Only clean up if this was an existing resource group and the resource group
+	//is marked as created
 	existingResourceGroup := state.Get(constants.ArmIsExistingResourceGroup).(bool)
 	resourceGroupCreated := state.Get(constants.ArmIsResourceGroupCreated).(bool)
 	if !existingResourceGroup || !resourceGroupCreated {
@@ -78,12 +75,74 @@ func (s *StepDeployTemplate) Cleanup(state multistep.StateBag) {
 
 	deploymentName := s.name
 	resourceGroupName := state.Get(constants.ArmResourceGroupName).(string)
-	err := s.deleteDeploymentResources(context.TODO(), deploymentName, resourceGroupName)
-	if err != nil {
-		s.reportIfError(err, resourceGroupName)
+
+	// Get image disk details before deleting the image; otherwise we won't be able to
+	// delete the disk as the image request will return a 404
+	computeName := state.Get(constants.ArmComputeName).(string)
+	imageType, imageName, err := s.disk(context.TODO(), resourceGroupName, computeName)
+
+	if err != nil && !strings.Contains(err.Error(), "ResourceNotFound") {
+		ui.Error(fmt.Sprintf("Could not retrieve OS Image details: %s", err))
 	}
 
-	NewStepDeleteAdditionalDisks(s.client, ui).Run(context.TODO(), state)
+	ui.Say(" -> Deployment Resources within: " + deploymentName)
+	if deploymentName != "" {
+		maxResources := int32(50)
+		deploymentOperations, err := s.client.DeploymentOperationsClient.ListComplete(context.TODO(), resourceGroupName, deploymentName, &maxResources)
+		if err != nil {
+			ui.Error(fmt.Sprintf("Error deleting resources.  Please delete them manually.\n\n"+
+				"Name: %s\n"+
+				"Error: %s", resourceGroupName, err))
+		}
+
+		for deploymentOperations.NotDone() {
+			deploymentOperation := deploymentOperations.Value()
+			// Sometimes an empty operation is added to the list by Azure
+			if deploymentOperation.Properties.TargetResource == nil {
+				if err := deploymentOperations.Next(); err != nil {
+					ui.Error(fmt.Sprintf("Error moving to to next deployment operation ...\n\n"+
+						"Name: %s\n"+
+						"Error: %s", resourceGroupName, err))
+					break
+				}
+				continue
+			}
+
+			ui.Say(fmt.Sprintf(" -> %s : '%s'",
+				*deploymentOperation.Properties.TargetResource.ResourceType,
+				*deploymentOperation.Properties.TargetResource.ResourceName))
+
+			err = s.delete(context.TODO(), s.client,
+				*deploymentOperation.Properties.TargetResource.ResourceType,
+				*deploymentOperation.Properties.TargetResource.ResourceName,
+				resourceGroupName)
+			if err != nil {
+				ui.Error(fmt.Sprintf("Error deleting resource.  Please delete manually.\n\n"+
+					"Name: %s\n"+
+					"Error: %s", *deploymentOperation.Properties.TargetResource.ResourceName, err))
+			}
+
+			if err = deploymentOperations.Next(); err != nil {
+				ui.Error(fmt.Sprintf("Error deleting resources.  Please delete them manually.\n\n"+
+					"Name: %s\n"+
+					"Error: %s", resourceGroupName, err))
+				break
+			}
+		}
+
+		// The disk is not defined as an operation in the template so it has to be deleted separately
+		if imageType == "" && imageName == "" {
+			return
+		}
+
+		ui.Say(fmt.Sprintf(" -> %s : '%s'", imageType, imageName))
+		err = s.deleteDisk(context.TODO(), imageType, imageName, resourceGroupName)
+		if err != nil {
+			ui.Error(fmt.Sprintf("Error deleting resource.  Please delete manually.\n\n"+
+				"Name: %s\n"+
+				"Error: %s", imageName, err))
+		}
+	}
 }
 
 func (s *StepDeployTemplate) deployTemplate(ctx context.Context, resourceGroupName string, deploymentName string) error {
@@ -93,31 +152,27 @@ func (s *StepDeployTemplate) deployTemplate(ctx context.Context, resourceGroupNa
 	}
 
 	f, err := s.client.DeploymentsClient.CreateOrUpdate(ctx, resourceGroupName, deploymentName, *deployment)
+	if err == nil {
+		err = f.WaitForCompletionRef(ctx, s.client.DeploymentsClient.Client)
+	}
 	if err != nil {
 		s.say(s.client.LastError.Error())
-		return err
 	}
-
-	err = f.WaitForCompletionRef(ctx, s.client.DeploymentsClient.Client)
-	if err == nil {
-		s.say(s.client.LastError.Error())
-	}
-
 	return err
 }
 
 func (s *StepDeployTemplate) deleteTemplate(ctx context.Context, state multistep.StateBag) error {
-	deploymentName := s.name
-	resourceGroupName := state.Get(constants.ArmResourceGroupName).(string)
+	var resourceGroupName = state.Get(constants.ArmResourceGroupName).(string)
+	var deploymentName = s.name
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say(fmt.Sprintf("Removing the created Deployment object: '%s'", deploymentName))
 	f, err := s.client.DeploymentsClient.Delete(ctx, resourceGroupName, deploymentName)
-	if err != nil {
-		return err
+	if err == nil {
+		err = f.WaitForCompletionRef(ctx, s.client.DeploymentsClient.Client)
 	}
 
-	return f.WaitForCompletionRef(ctx, s.client.DeploymentsClient.Client)
+	return err
 }
 
 func (s *StepDeployTemplate) getImageDetails(ctx context.Context, resourceGroupName string, computeName string) (string, string, error) {
@@ -131,12 +186,11 @@ func (s *StepDeployTemplate) getImageDetails(ctx context.Context, resourceGroupN
 	if vm.StorageProfile.OsDisk.Vhd != nil {
 		imageType = "image"
 		imageName = *vm.StorageProfile.OsDisk.Vhd.URI
-		return imageType, imageName, nil
+	} else {
+		imageType = "Microsoft.Compute/disks"
+		imageName = *vm.StorageProfile.OsDisk.ManagedDisk.ID
 	}
 
-	imageType = "Microsoft.Compute/disks"
-	imageName = *vm.StorageProfile.OsDisk.ManagedDisk.ID
-
 	return imageType, imageName, nil
 }
 
@@ -213,58 +267,3 @@ func (s *StepDeployTemplate) deleteImage(ctx context.Context, imageType string,
 
 	return blob.Delete(nil)
 }
-
-func (s *StepDeployTemplate) deleteDeploymentResources(ctx context.Context, deploymentName, resourceGroupName string) error {
-	var maxResources int32 = 50
-	deploymentOperations, err := s.client.DeploymentOperationsClient.ListComplete(ctx, resourceGroupName, deploymentName, &maxResources)
-	if err != nil {
-		s.reportIfError(err, resourceGroupName)
-		return err
-	}
-
-	for deploymentOperations.NotDone() {
-		deploymentOperation := deploymentOperations.Value()
-		// Sometimes an empty operation is added to the list by Azure
-		if deploymentOperation.Properties.TargetResource == nil {
-			_ = deploymentOperations.Next()
-			continue
-		}
-
-		resourceName := *deploymentOperation.Properties.TargetResource.ResourceName
-		resourceType := *deploymentOperation.Properties.TargetResource.ResourceType
-
-		s.say(fmt.Sprintf(" -> %s : '%s'", resourceType, resourceName))
-
-		err = retry.Config{
-			Tries:      10,
-			RetryDelay: (&retry.Backoff{InitialBackoff: 10 * time.Second, MaxBackoff: 600 * time.Second, Multiplier: 2}).Linear,
-		}.Run(ctx, func(ctx context.Context) error {
-			err := deleteResource(ctx, s.client,
-				resourceType,
-				resourceName,
-				resourceGroupName)
-			if err != nil {
-				s.reportIfError(err, resourceName)
-			}
-			return nil
-		})
-		if err != nil {
-			s.reportIfError(err, resourceName)
-		}
-
-		if err = deploymentOperations.Next(); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (s *StepDeployTemplate) reportIfError(err error, resourceName string) {
-	if err != nil {
-		s.say(fmt.Sprintf("Error deleting resource. Please delete manually.\n\n"+
-			"Name: %s\n"+
-			"Error: %s", resourceName, err.Error()))
-		s.error(err)
-	}
-}

builder/azure/chroot/builder.go

@@ -153,7 +153,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	b.config.ctx.Funcs["vm"] = CreateVMMetadataTemplateFunc()
 	md := &mapstructure.Metadata{}
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderID,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{

builder/azure/dtl/config.go

@@ -389,7 +389,6 @@ func newConfig(raws ...interface{}) (*Config, []string, error) {
 	var c Config
 	c.ctx.Funcs = TemplateFuncs
 	err := config.Decode(&c, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &c.ctx,
 	}, raws...)

builder/azure/dtl/config.hcl2spec.go

@@ -93,8 +93,6 @@ type FlatConfig struct {
 	SSHPassword                         *string                            `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                      *string                            `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName             *string                            `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType             *string                            `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits             *int                               `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                          []string                           `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys              *bool                              `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                         []string                           `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -205,8 +203,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                             &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                         &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":                  &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":                  &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":                  &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                              &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":                &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":              &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/cloudstack/config.hcl2spec.go

@@ -29,8 +29,6 @@ type FlatConfig struct {
 	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -144,8 +142,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/digitalocean/config.hcl2spec.go

@@ -24,8 +24,6 @@ type FlatConfig struct {
 	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -110,8 +108,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/docker/config.go

@@ -127,7 +127,6 @@ func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
 	var md mapstructure.Metadata
 	err := config.Decode(c, &config.DecodeOpts{
 		Metadata:           &md,
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &c.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{

builder/docker/config.hcl2spec.go

@@ -24,8 +24,6 @@ type FlatConfig struct {
 	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -123,8 +121,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/googlecompute/builder.go

@@ -59,16 +59,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	// Build the steps.
 	steps := []multistep.Step{
 		new(StepCheckExistingImage),
-		&communicator.StepSSHKeyGen{
-			CommConf:            &b.config.Comm,
-			SSHTemporaryKeyPair: b.config.Comm.SSH.SSHTemporaryKeyPair,
+		&StepCreateSSHKey{
+			Debug:        b.config.PackerDebug,
+			DebugKeyPath: fmt.Sprintf("gce_%s.pem", b.config.PackerBuildName),
 		},
-		multistep.If(b.config.PackerDebug && b.config.Comm.SSHPrivateKeyFile == "",
-			&communicator.StepDumpSSHKey{
-				Path: fmt.Sprintf("gce_%s.pem", b.config.PackerBuildName),
-				SSH:  &b.config.Comm.SSH,
-			},
-		),
 		&StepImportOSLoginSSHKey{
 			Debug: b.config.PackerDebug,
 		},

builder/googlecompute/config.go

@@ -76,8 +76,6 @@ type Config struct {
 	EnableIntegrityMonitoring bool `mapstructure:"enable_integrity_monitoring" required:"false"`
 	// Whether to use an IAP proxy.
 	IAPConfig `mapstructure:",squash"`
-	// Skip creating the image. Useful for setting to `true` during a build test stage. Defaults to `false`.
-	SkipCreateImage bool `mapstructure:"skip_create_image" required:"false"`
 	// The unique name of the resulting image. Defaults to
 	// `packer-{{timestamp}}`.
 	ImageName string `mapstructure:"image_name" required:"false"`
@@ -87,19 +85,13 @@ type Config struct {
 	// * kmsKeyName -  The name of the encryption key that is stored in Google Cloud KMS.
 	// * RawKey: - A 256-bit customer-supplied encryption key, encodes in RFC 4648 base64.
 	//
-	// examples:
+	// example:
 	//
 	//  ```json
 	//  {
 	//     "kmsKeyName": "projects/${project}/locations/${region}/keyRings/computeEngine/cryptoKeys/computeEngine/cryptoKeyVersions/4"
 	//  }
 	//  ```
-	//
-	//  ```hcl
-	//   image_encryption_key {
-	//     kmsKeyName = "projects/${var.project}/locations/${var.region}/keyRings/computeEngine/cryptoKeys/computeEngine/cryptoKeyVersions/4"
-	//   }
-	//  ```
 	ImageEncryptionKey *CustomerEncryptionKey `mapstructure:"image_encryption_key" required:"false"`
 	// The name of the image family to which the resulting image belongs. You
 	// can create disks by specifying an image family instead of a specific
@@ -297,7 +289,6 @@ type Config struct {
 func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
 	c.ctx.Funcs = TemplateFuncs
 	err := config.Decode(c, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &c.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
@@ -545,11 +536,11 @@ func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
 type CustomerEncryptionKey struct {
 	// KmsKeyName: The name of the encryption key that is stored in Google
 	// Cloud KMS.
-	KmsKeyName string `mapstructure:"kmsKeyName" json:"kmsKeyName,omitempty"`
+	KmsKeyName string `json:"kmsKeyName,omitempty"`
 
 	// RawKey: Specifies a 256-bit customer-supplied encryption key, encoded
 	// in RFC 4648 base64 to either encrypt or decrypt this resource.
-	RawKey string `mapstructure:"rawKey" json:"rawKey,omitempty"`
+	RawKey string `json:"rawKey,omitempty"`
 }
 
 func (k *CustomerEncryptionKey) ComputeType() *compute.CustomerEncryptionKey {

builder/googlecompute/config.hcl2spec.go

@@ -24,8 +24,6 @@ type FlatConfig struct {
 	SSHPassword                  *string                    `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName               *string                    `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName      *string                    `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType      *string                    `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits      *int                       `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                   []string                   `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys       *bool                      `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                  []string                   `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -83,7 +81,6 @@ type FlatConfig struct {
 	IAPHashBang                  *string                    `mapstructure:"iap_hashbang" required:"false" cty:"iap_hashbang" hcl:"iap_hashbang"`
 	IAPExt                       *string                    `mapstructure:"iap_ext" required:"false" cty:"iap_ext" hcl:"iap_ext"`
 	IAPTunnelLaunchWait          *int                       `mapstructure:"iap_tunnel_launch_wait" required:"false" cty:"iap_tunnel_launch_wait" hcl:"iap_tunnel_launch_wait"`
-	SkipCreateImage              *bool                      `mapstructure:"skip_create_image" required:"false" cty:"skip_create_image" hcl:"skip_create_image"`
 	ImageName                    *string                    `mapstructure:"image_name" required:"false" cty:"image_name" hcl:"image_name"`
 	ImageDescription             *string                    `mapstructure:"image_description" required:"false" cty:"image_description" hcl:"image_description"`
 	ImageEncryptionKey           *FlatCustomerEncryptionKey `mapstructure:"image_encryption_key" required:"false" cty:"image_encryption_key" hcl:"image_encryption_key"`
@@ -146,8 +143,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                    &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":         &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":         &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":         &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                     &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":       &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":     &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},
@@ -205,7 +200,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"iap_hashbang":                    &hcldec.AttrSpec{Name: "iap_hashbang", Type: cty.String, Required: false},
 		"iap_ext":                         &hcldec.AttrSpec{Name: "iap_ext", Type: cty.String, Required: false},
 		"iap_tunnel_launch_wait":          &hcldec.AttrSpec{Name: "iap_tunnel_launch_wait", Type: cty.Number, Required: false},
-		"skip_create_image":               &hcldec.AttrSpec{Name: "skip_create_image", Type: cty.Bool, Required: false},
 		"image_name":                      &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
 		"image_description":               &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
 		"image_encryption_key":            &hcldec.BlockSpec{TypeName: "image_encryption_key", Nested: hcldec.ObjectSpec((*FlatCustomerEncryptionKey)(nil).HCL2Spec())},
@@ -246,8 +240,8 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 // FlatCustomerEncryptionKey is an auto-generated flat version of CustomerEncryptionKey.
 // Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
 type FlatCustomerEncryptionKey struct {
-	KmsKeyName *string `mapstructure:"kmsKeyName" json:"kmsKeyName,omitempty" cty:"kmsKeyName" hcl:"kmsKeyName"`
-	RawKey     *string `mapstructure:"rawKey" json:"rawKey,omitempty" cty:"rawKey" hcl:"rawKey"`
+	KmsKeyName *string `json:"kmsKeyName,omitempty" cty:"kms_key_name" hcl:"kms_key_name"`
+	RawKey     *string `json:"rawKey,omitempty" cty:"raw_key" hcl:"raw_key"`
 }
 
 // FlatMapstructure returns a new FlatCustomerEncryptionKey.
@@ -262,8 +256,8 @@ func (*CustomerEncryptionKey) FlatMapstructure() interface{ HCL2Spec() map[strin
 // The decoded values from this spec will then be applied to a FlatCustomerEncryptionKey.
 func (*FlatCustomerEncryptionKey) HCL2Spec() map[string]hcldec.Spec {
 	s := map[string]hcldec.Spec{
-		"kmsKeyName": &hcldec.AttrSpec{Name: "kmsKeyName", Type: cty.String, Required: false},
-		"rawKey":     &hcldec.AttrSpec{Name: "rawKey", Type: cty.String, Required: false},
+		"kms_key_name": &hcldec.AttrSpec{Name: "kms_key_name", Type: cty.String, Required: false},
+		"raw_key":      &hcldec.AttrSpec{Name: "raw_key", Type: cty.String, Required: false},
 	}
 	return s
 }

builder/googlecompute/step_create_image.go

@@ -23,11 +23,6 @@ func (s *StepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 	driver := state.Get("driver").(Driver)
 	ui := state.Get("ui").(packer.Ui)
 
-	if config.SkipCreateImage {
-		ui.Say("Skipping image creation...")
-		return multistep.ActionContinue
-	}
-
 	if config.PackerForce && config.imageAlreadyExists {
 		ui.Say("Deleting previous image...")
 

builder/googlecompute/step_create_ssh_key.go

@@ -0,0 +1,88 @@
+package googlecompute
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"fmt"
+	"os"
+
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+	"golang.org/x/crypto/ssh"
+)
+
+// StepCreateSSHKey represents a Packer build step that generates SSH key pairs.
+type StepCreateSSHKey struct {
+	Debug        bool
+	DebugKeyPath string
+}
+
+// Run executes the Packer build step that generates SSH key pairs.
+// The key pairs are added to the ssh config
+func (s *StepCreateSSHKey) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	ui := state.Get("ui").(packer.Ui)
+	config := state.Get("config").(*Config)
+
+	if config.Comm.SSHPrivateKeyFile != "" {
+		ui.Say("Using existing SSH private key")
+		privateKeyBytes, err := config.Comm.ReadSSHPrivateKeyFile()
+		if err != nil {
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+
+		config.Comm.SSHPrivateKey = privateKeyBytes
+		config.Comm.SSHPublicKey = nil
+
+		return multistep.ActionContinue
+	}
+
+	ui.Say("Creating temporary SSH key for instance...")
+	priv, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		err := fmt.Errorf("Error creating temporary ssh key: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	priv_blk := pem.Block{
+		Type:    "RSA PRIVATE KEY",
+		Headers: nil,
+		Bytes:   x509.MarshalPKCS1PrivateKey(priv),
+	}
+
+	pub, err := ssh.NewPublicKey(&priv.PublicKey)
+	if err != nil {
+		err := fmt.Errorf("Error creating temporary ssh key: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+	config.Comm.SSHPrivateKey = pem.EncodeToMemory(&priv_blk)
+	config.Comm.SSHPublicKey = ssh.MarshalAuthorizedKey(pub)
+
+	if s.Debug {
+		ui.Message(fmt.Sprintf("Saving key for debug purposes: %s", s.DebugKeyPath))
+		f, err := os.Create(s.DebugKeyPath)
+		if err != nil {
+			state.Put("error", fmt.Errorf("Error saving debug key: %s", err))
+			return multistep.ActionHalt
+		}
+
+		// Write out the key
+		err = pem.Encode(f, &priv_blk)
+		f.Close()
+		if err != nil {
+			state.Put("error", fmt.Errorf("Error saving debug key: %s", err))
+			return multistep.ActionHalt
+		}
+	}
+	return multistep.ActionContinue
+}
+
+// Nothing to clean up. SSH keys are associated with a single GCE instance.
+func (s *StepCreateSSHKey) Cleanup(state multistep.StateBag) {}

builder/googlecompute/step_create_ssh_key_test.go

@@ -0,0 +1,86 @@
+package googlecompute
+
+import (
+	"context"
+
+	"github.com/hashicorp/packer/helper/multistep"
+
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func TestStepCreateSSHKey_impl(t *testing.T) {
+	var _ multistep.Step = new(StepCreateSSHKey)
+}
+
+func TestStepCreateSSHKey_privateKey(t *testing.T) {
+	state := testState(t)
+	step := new(StepCreateSSHKey)
+	cfg := state.Get("config").(*Config)
+	cfg.Comm.SSHPrivateKeyFile = "test-fixtures/fake-key"
+	defer step.Cleanup(state)
+
+	// run the step
+	if action := step.Run(context.Background(), state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+
+	// Verify that we have a public/private key
+	if len(cfg.Comm.SSHPrivateKey) == 0 {
+		t.Fatal("should have key")
+	}
+}
+
+func TestStepCreateSSHKey(t *testing.T) {
+	state := testState(t)
+	step := new(StepCreateSSHKey)
+	cfg := state.Get("config").(*Config)
+	defer step.Cleanup(state)
+
+	// run the step
+	if action := step.Run(context.Background(), state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+
+	// Verify that we have a public/private key
+	if len(cfg.Comm.SSHPrivateKey) == 0 {
+		t.Fatal("should have key")
+	}
+	if len(cfg.Comm.SSHPublicKey) == 0 {
+		t.Fatal("should have key")
+	}
+}
+
+func TestStepCreateSSHKey_debug(t *testing.T) {
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.Remove(tf.Name())
+	tf.Close()
+
+	state := testState(t)
+	step := new(StepCreateSSHKey)
+	cfg := state.Get("config").(*Config)
+	step.Debug = true
+	step.DebugKeyPath = tf.Name()
+
+	defer step.Cleanup(state)
+
+	// run the step
+	if action := step.Run(context.Background(), state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+
+	// Verify that we have a public/private key
+	if len(cfg.Comm.SSHPrivateKey) == 0 {
+		t.Fatal("should have key")
+	}
+	if len(cfg.Comm.SSHPublicKey) == 0 {
+		t.Fatal("should have key")
+	}
+	if _, err := os.Stat(tf.Name()); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+}

builder/hcloud/config.hcl2spec.go

@@ -24,8 +24,6 @@ type FlatConfig struct {
 	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -108,8 +106,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/hyperone/config.hcl2spec.go

@@ -25,8 +25,6 @@ type FlatConfig struct {
 	SSHPassword               *string                      `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string                      `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string                      `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string                      `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int                         `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string                     `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool                        `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string                     `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -131,8 +129,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/hyperv/iso/builder.go

@@ -89,7 +89,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         hypervcommon.BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{

builder/hyperv/iso/builder.hcl2spec.go

@@ -38,8 +38,6 @@ type FlatConfig struct {
 	SSHPassword                    *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                 *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName        *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType        *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits        *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                     []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys         *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                    []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -159,8 +157,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                     &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                 &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":          &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":          &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":          &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                      &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":        &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":      &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/hyperv/vmcx/builder.go

@@ -82,7 +82,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         hypervcommon.BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{

builder/hyperv/vmcx/builder.hcl2spec.go

@@ -38,8 +38,6 @@ type FlatConfig struct {
 	SSHPassword                    *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                 *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName        *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType        *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits        *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                     []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys         *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                    []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -161,8 +159,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                     &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                 &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":          &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":          &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":          &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                      &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":        &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":      &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/jdcloud/builder.go

@@ -17,7 +17,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BUILDER_ID,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{

builder/jdcloud/common.hcl2spec.go

@@ -26,8 +26,6 @@ type FlatConfig struct {
 	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -109,8 +107,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/linode/builder_test.go

@@ -3,7 +3,6 @@ package linode
 import (
 	"strconv"
 	"testing"
-	"time"
 
 	"github.com/hashicorp/packer/packer"
 )
@@ -249,43 +248,3 @@ func TestBuilderPrepare_Label(t *testing.T) {
 	}
 
 }
-
-func TestBuilderPrepare_StateTimeout(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test default
-	_, warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.StateTimeout != 5*time.Minute {
-		t.Errorf("invalid: %s", b.config.StateTimeout)
-	}
-
-	// Test set
-	config["state_timeout"] = "5m"
-	b = Builder{}
-	_, 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["state_timeout"] = "tubes"
-	b = Builder{}
-	_, warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}

builder/linode/config.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"os"
 	"regexp"
-	"time"
 
 	"github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/communicator"
@@ -25,17 +24,16 @@ type Config struct {
 
 	PersonalAccessToken string `mapstructure:"linode_token"`
 
-	Region       string        `mapstructure:"region"`
-	InstanceType string        `mapstructure:"instance_type"`
-	Label        string        `mapstructure:"instance_label"`
-	Tags         []string      `mapstructure:"instance_tags"`
-	Image        string        `mapstructure:"image"`
-	SwapSize     int           `mapstructure:"swap_size"`
-	RootPass     string        `mapstructure:"root_pass"`
-	RootSSHKey   string        `mapstructure:"root_ssh_key"`
-	ImageLabel   string        `mapstructure:"image_label"`
-	Description  string        `mapstructure:"image_description"`
-	StateTimeout time.Duration `mapstructure:"state_timeout" required:"false"`
+	Region       string   `mapstructure:"region"`
+	InstanceType string   `mapstructure:"instance_type"`
+	Label        string   `mapstructure:"instance_label"`
+	Tags         []string `mapstructure:"instance_tags"`
+	Image        string   `mapstructure:"image"`
+	SwapSize     int      `mapstructure:"swap_size"`
+	RootPass     string   `mapstructure:"root_pass"`
+	RootSSHKey   string   `mapstructure:"root_ssh_key"`
+	ImageLabel   string   `mapstructure:"image_label"`
+	Description  string   `mapstructure:"image_description"`
 }
 
 func createRandomRootPassword() (string, error) {
@@ -96,11 +94,6 @@ func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
-	if c.StateTimeout == 0 {
-		// Default to 5 minute timeouts waiting for state change
-		c.StateTimeout = 5 * time.Minute
-	}
-
 	if es := c.Comm.Prepare(&c.ctx); len(es) > 0 {
 		errs = packer.MultiErrorAppend(errs, es...)
 	}

builder/linode/config.hcl2spec.go

@@ -24,8 +24,6 @@ type FlatConfig struct {
 	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -76,7 +74,6 @@ type FlatConfig struct {
 	RootSSHKey                *string           `mapstructure:"root_ssh_key" cty:"root_ssh_key" hcl:"root_ssh_key"`
 	ImageLabel                *string           `mapstructure:"image_label" cty:"image_label" hcl:"image_label"`
 	Description               *string           `mapstructure:"image_description" cty:"image_description" hcl:"image_description"`
-	StateTimeout              *string           `mapstructure:"state_timeout" required:"false" cty:"state_timeout" hcl:"state_timeout"`
 }
 
 // FlatMapstructure returns a new FlatConfig.
@@ -106,8 +103,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},
@@ -158,7 +153,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"root_ssh_key":                 &hcldec.AttrSpec{Name: "root_ssh_key", Type: cty.String, Required: false},
 		"image_label":                  &hcldec.AttrSpec{Name: "image_label", Type: cty.String, Required: false},
 		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
-		"state_timeout":                &hcldec.AttrSpec{Name: "state_timeout", Type: cty.String, Required: false},
 	}
 	return s
 }

builder/linode/step_shutdown_linode.go

@@ -14,7 +14,6 @@ type stepShutdownLinode struct {
 }
 
 func (s *stepShutdownLinode) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	c := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
 	instance := state.Get("instance").(*linodego.Instance)
 
@@ -26,7 +25,7 @@ func (s *stepShutdownLinode) Run(ctx context.Context, state multistep.StateBag)
 		return multistep.ActionHalt
 	}
 
-	_, err := s.client.WaitForInstanceStatus(ctx, instance.ID, linodego.InstanceOffline, int(c.StateTimeout.Seconds()))
+	_, err := s.client.WaitForInstanceStatus(ctx, instance.ID, linodego.InstanceOffline, 120)
 	if err != nil {
 		err = errors.New("Error shutting down Linode: " + err.Error())
 		state.Put("error", err)

builder/ncloud/config.hcl2spec.go

@@ -36,8 +36,6 @@ type FlatConfig struct {
 	SSHPassword                       *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName                    *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName           *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType           *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits           *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                        []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys            *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                       []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -118,8 +116,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                          &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                      &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":               &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":               &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":               &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                           &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":             &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":           &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/null/config.go

@@ -21,7 +21,6 @@ type Config struct {
 func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
 
 	err := config.Decode(c, &config.DecodeOpts{
-		PluginType:        BuilderId,
 		Interpolate:       true,
 		InterpolateFilter: &interpolate.RenderFilter{},
 	}, raws...)

builder/null/config.hcl2spec.go

@@ -24,8 +24,6 @@ type FlatConfig struct {
 	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -94,8 +92,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/oneandone/config.hcl2spec.go

@@ -24,8 +24,6 @@ type FlatConfig struct {
 	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -102,8 +100,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/openstack/builder.go

@@ -40,7 +40,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 	}, raws...)

builder/openstack/builder.hcl2spec.go

@@ -52,8 +52,6 @@ type FlatConfig struct {
 	SSHPassword                 *string                 `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName              *string                 `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName     *string                 `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType     *string                 `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits     *int                    `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                  []string                `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys      *bool                   `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                 []string                `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -181,8 +179,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                  &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":              &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":       &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":       &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":       &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                   &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":     &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":   &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/oracle/classic/builder.hcl2spec.go

@@ -31,8 +31,6 @@ type FlatConfig struct {
 	SSHPassword               *string                  `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string                  `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string                  `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string                  `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int                     `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string                 `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool                    `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string                 `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -121,8 +119,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/oracle/oci/config.go

@@ -1,4 +1,4 @@
-//go:generate mapstructure-to-hcl2 -type Config,CreateVNICDetails,ListImagesRequest
+//go:generate mapstructure-to-hcl2 -type Config,CreateVNICDetails
 
 package oci
 
@@ -35,16 +35,6 @@ type CreateVNICDetails struct {
 	SubnetId            *string                           `mapstructure:"subnet_id" required:"false"`
 }
 
-type ListImagesRequest struct {
-	// fields that can be specified under "base_image_filter"
-	CompartmentId          *string `mapstructure:"compartment_id"`
-	DisplayName            *string `mapstructure:"display_name"`
-	DisplayNameSearch      *string `mapstructure:"display_name_search"`
-	OperatingSystem        *string `mapstructure:"operating_system"`
-	OperatingSystemVersion *string `mapstructure:"operating_system_version"`
-	Shape                  *string `mapstructure:"shape"`
-}
-
 type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 	Comm                communicator.Config `mapstructure:",squash"`
@@ -79,13 +69,12 @@ type Config struct {
 	CompartmentID      string `mapstructure:"compartment_ocid"`
 
 	// Image
-	BaseImageID        string            `mapstructure:"base_image_ocid"`
-	BaseImageFilter    ListImagesRequest `mapstructure:"base_image_filter"`
-	ImageName          string            `mapstructure:"image_name"`
-	ImageCompartmentID string            `mapstructure:"image_compartment_ocid"`
+	BaseImageID        string `mapstructure:"base_image_ocid"`
+	ImageName          string `mapstructure:"image_name"`
+	ImageCompartmentID string `mapstructure:"image_compartment_ocid"`
 
 	// Instance
-	InstanceName        *string                           `mapstructure:"instance_name"`
+	InstanceName        string                            `mapstructure:"instance_name"`
 	InstanceTags        map[string]string                 `mapstructure:"instance_tags"`
 	InstanceDefinedTags map[string]map[string]interface{} `mapstructure:"instance_defined_tags"`
 	Shape               string                            `mapstructure:"shape"`
@@ -280,17 +269,9 @@ func (c *Config) Prepare(raws ...interface{}) error {
 			errs, errors.New("'subnet_ocid' must be specified"))
 	}
 
-	if (c.BaseImageID == "") && (c.BaseImageFilter == ListImagesRequest{}) {
+	if c.BaseImageID == "" {
 		errs = packer.MultiErrorAppend(
-			errs, errors.New("'base_image_ocid' or 'base_image_filter' must be specified"))
-	}
-
-	if c.BaseImageFilter.CompartmentId == nil {
-		c.BaseImageFilter.CompartmentId = &c.CompartmentID
-	}
-
-	if c.BaseImageFilter.Shape == nil {
-		c.BaseImageFilter.Shape = &c.Shape
+			errs, errors.New("'base_image_ocid' must be specified"))
 	}
 
 	// Validate tag lengths. TODO (hlowndes) maximum number of tags allowed.

builder/oracle/oci/config.hcl2spec.go

@@ -1,4 +1,4 @@
-// Code generated by "mapstructure-to-hcl2 -type Config,CreateVNICDetails,ListImagesRequest"; DO NOT EDIT.
+// Code generated by "mapstructure-to-hcl2 -type Config,CreateVNICDetails"; DO NOT EDIT.
 package oci
 
 import (
@@ -24,8 +24,6 @@ type FlatConfig struct {
 	SSHPassword               *string                           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName            *string                           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
 	SSHTemporaryKeyPairName   *string                           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string                           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int                              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                []string                          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys    *bool                             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos               []string                          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -78,7 +76,6 @@ type FlatConfig struct {
 	AvailabilityDomain        *string                           `mapstructure:"availability_domain" cty:"availability_domain" hcl:"availability_domain"`
 	CompartmentID             *string                           `mapstructure:"compartment_ocid" cty:"compartment_ocid" hcl:"compartment_ocid"`
 	BaseImageID               *string                           `mapstructure:"base_image_ocid" cty:"base_image_ocid" hcl:"base_image_ocid"`
-	BaseImageFilter           *FlatListImagesRequest            `mapstructure:"base_image_filter" cty:"base_image_filter" hcl:"base_image_filter"`
 	ImageName                 *string                           `mapstructure:"image_name" cty:"image_name" hcl:"image_name"`
 	ImageCompartmentID        *string                           `mapstructure:"image_compartment_ocid" cty:"image_compartment_ocid" hcl:"image_compartment_ocid"`
 	InstanceName              *string                           `mapstructure:"instance_name" cty:"instance_name" hcl:"instance_name"`
@@ -122,8 +119,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
 		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},
@@ -176,7 +171,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"availability_domain":          &hcldec.AttrSpec{Name: "availability_domain", Type: cty.String, Required: false},
 		"compartment_ocid":             &hcldec.AttrSpec{Name: "compartment_ocid", Type: cty.String, Required: false},
 		"base_image_ocid":              &hcldec.AttrSpec{Name: "base_image_ocid", Type: cty.String, Required: false},
-		"base_image_filter":            &hcldec.BlockSpec{TypeName: "base_image_filter", Nested: hcldec.ObjectSpec((*FlatListImagesRequest)(nil).HCL2Spec())},
 		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
 		"image_compartment_ocid":       &hcldec.AttrSpec{Name: "image_compartment_ocid", Type: cty.String, Required: false},
 		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
@@ -233,36 +227,3 @@ func (*FlatCreateVNICDetails) HCL2Spec() map[string]hcldec.Spec {
 	}
 	return s
 }
-
-// FlatListImagesRequest is an auto-generated flat version of ListImagesRequest.
-// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
-type FlatListImagesRequest struct {
-	CompartmentId          *string `mapstructure:"compartment_id" cty:"compartment_id" hcl:"compartment_id"`
-	DisplayName            *string `mapstructure:"display_name" cty:"display_name" hcl:"display_name"`
-	DisplayNameSearch      *string `mapstructure:"display_name_search" cty:"display_name_search" hcl:"display_name_search"`
-	OperatingSystem        *string `mapstructure:"operating_system" cty:"operating_system" hcl:"operating_system"`
-	OperatingSystemVersion *string `mapstructure:"operating_system_version" cty:"operating_system_version" hcl:"operating_system_version"`
-	Shape                  *string `mapstructure:"shape" cty:"shape" hcl:"shape"`
-}
-
-// FlatMapstructure returns a new FlatListImagesRequest.
-// FlatListImagesRequest is an auto-generated flat version of ListImagesRequest.
-// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
-func (*ListImagesRequest) FlatMapstructure() interface{ HCL2Spec() map[string]hcldec.Spec } {
-	return new(FlatListImagesRequest)
-}
-
-// HCL2Spec returns the hcl spec of a ListImagesRequest.
-// This spec is used by HCL to read the fields of ListImagesRequest.
-// The decoded values from this spec will then be applied to a FlatListImagesRequest.
-func (*FlatListImagesRequest) HCL2Spec() map[string]hcldec.Spec {
-	s := map[string]hcldec.Spec{
-		"compartment_id":           &hcldec.AttrSpec{Name: "compartment_id", Type: cty.String, Required: false},
-		"display_name":             &hcldec.AttrSpec{Name: "display_name", Type: cty.String, Required: false},
-		"display_name_search":      &hcldec.AttrSpec{Name: "display_name_search", Type: cty.String, Required: false},
-		"operating_system":         &hcldec.AttrSpec{Name: "operating_system", Type: cty.String, Required: false},
-		"operating_system_version": &hcldec.AttrSpec{Name: "operating_system_version", Type: cty.String, Required: false},
-		"shape":                    &hcldec.AttrSpec{Name: "shape", Type: cty.String, Required: false},
-	}
-	return s
-}

builder/oracle/oci/config_test.go

@@ -88,36 +88,6 @@ func TestConfig(t *testing.T) {
 		}
 	})
 
-	t.Run("BaseImageFilterWithoutOCID", func(t *testing.T) {
-		raw := testConfig(cfgFile)
-		raw["base_image_ocid"] = ""
-		raw["base_image_filter"] = map[string]interface{}{
-			"display_name": "hello_world",
-		}
-
-		var c Config
-		errs := c.Prepare(raw)
-
-		if errs != nil {
-			t.Fatalf("Unexpected error in configuration %+v", errs)
-		}
-	})
-
-	t.Run("BaseImageFilterDefault", func(t *testing.T) {
-		raw := testConfig(cfgFile)
-
-		var c Config
-		errs := c.Prepare(raw)
-		if errs != nil {
-			t.Fatalf("Unexpected error in configuration %+v", errs)
-		}
-
-		if *c.BaseImageFilter.Shape != raw["shape"] {
-			t.Fatalf("Default base_image_filter shape %v does not equal config shape %v",
-				*c.BaseImageFilter.Shape, raw["shape"])
-		}
-	})
-
 	t.Run("NoAccessConfig", func(t *testing.T) {
 		raw := testConfig(cfgFile)
 		delete(raw, "access_cfg_file")

builder/oracle/oci/driver_oci.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"regexp"
 	"time"
 
 	core "github.com/oracle/oci-go-sdk/core"
@@ -52,7 +51,22 @@ func (d *driverOCI) CreateInstance(ctx context.Context, publicKey string) (strin
 		metadata["user_data"] = d.cfg.UserData
 	}
 
-	// Create VNIC details for instance
+	instanceDetails := core.LaunchInstanceDetails{
+		AvailabilityDomain: &d.cfg.AvailabilityDomain,
+		CompartmentId:      &d.cfg.CompartmentID,
+		DefinedTags:        d.cfg.InstanceDefinedTags,
+		FreeformTags:       d.cfg.InstanceTags,
+		Shape:              &d.cfg.Shape,
+		SubnetId:           &d.cfg.SubnetID,
+		Metadata:           metadata,
+	}
+
+	// When empty, the default display name is used.
+	if d.cfg.InstanceName != "" {
+		instanceDetails.DisplayName = &d.cfg.InstanceName
+	}
+
+	// Pass VNIC details, if specified, to the instance
 	CreateVnicDetails := core.CreateVnicDetails{
 		AssignPublicIp:      d.cfg.CreateVnicDetails.AssignPublicIp,
 		DisplayName:         d.cfg.CreateVnicDetails.DisplayName,
@@ -65,69 +79,14 @@ func (d *driverOCI) CreateInstance(ctx context.Context, publicKey string) (strin
 		FreeformTags:        d.cfg.CreateVnicDetails.FreeformTags,
 	}
 
-	// Determine base image ID
-	var imageId *string
-	if d.cfg.BaseImageID != "" {
-		imageId = &d.cfg.BaseImageID
-	} else {
-		// Pull images and determine which image ID to use, if BaseImageId not specified
-		response, err := d.computeClient.ListImages(ctx, core.ListImagesRequest{
-			CompartmentId:          d.cfg.BaseImageFilter.CompartmentId,
-			DisplayName:            d.cfg.BaseImageFilter.DisplayName,
-			OperatingSystem:        d.cfg.BaseImageFilter.OperatingSystem,
-			OperatingSystemVersion: d.cfg.BaseImageFilter.OperatingSystemVersion,
-			Shape:                  d.cfg.BaseImageFilter.Shape,
-			LifecycleState:         "AVAILABLE",
-			SortBy:                 "TIMECREATED",
-			SortOrder:              "DESC",
-		})
-		if err != nil {
-			return "", err
-		}
-		if len(response.Items) == 0 {
-			return "", errors.New("base_image_filter returned no images")
-		}
-		if d.cfg.BaseImageFilter.DisplayNameSearch != nil {
-			// Return most recent image that matches regex
-			imageNameRegex, err := regexp.Compile(*d.cfg.BaseImageFilter.DisplayNameSearch)
-			if err != nil {
-				return "", err
-			}
-			for _, image := range response.Items {
-				if imageNameRegex.MatchString(*image.DisplayName) {
-					imageId = image.Id
-					break
-				}
-			}
-			if imageId == nil {
-				return "", errors.New("No image matched display_name_search criteria")
-			}
-		} else {
-			// If no regex provided, simply return most recent image pulled
-			imageId = response.Items[0].Id
-		}
-	}
+	instanceDetails.CreateVnicDetails = &CreateVnicDetails
 
 	// Create Source details which will be used to Launch Instance
-	InstanceSourceDetails := core.InstanceSourceViaImageDetails{
-		ImageId:             imageId,
+	instanceDetails.SourceDetails = core.InstanceSourceViaImageDetails{
+		ImageId:             &d.cfg.BaseImageID,
 		BootVolumeSizeInGBs: &d.cfg.BootVolumeSizeInGBs,
 	}
 
-	// Build instance details
-	instanceDetails := core.LaunchInstanceDetails{
-		AvailabilityDomain: &d.cfg.AvailabilityDomain,
-		CompartmentId:      &d.cfg.CompartmentID,
-		CreateVnicDetails:  &CreateVnicDetails,
-		DefinedTags:        d.cfg.InstanceDefinedTags,
-		DisplayName:        d.cfg.InstanceName,
-		FreeformTags:       d.cfg.InstanceTags,
-		Shape:              &d.cfg.Shape,
-		SourceDetails:      InstanceSourceDetails,
-		SubnetId:           &d.cfg.SubnetID,
-		Metadata:           metadata,
-	}
-
 	instance, err := d.computeClient.LaunchInstance(context.TODO(), core.LaunchInstanceRequest{LaunchInstanceDetails: instanceDetails})
 
 	if err != nil {

builder/osc/bsu/builder.go

@@ -9,7 +9,9 @@ package bsu
 
 import (
 	"context"
+	"crypto/tls"
 	"fmt"
+	"net/http"
 
 	"github.com/hashicorp/hcl/v2/hcldec"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
@@ -19,6 +21,7 @@ import (
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // The unique ID for this builder
@@ -45,7 +48,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	b.config.ctx.Funcs = osccommon.TemplateFuncs
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
@@ -84,13 +86,24 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 }
 
 func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
-	oscConn := b.config.NewOSCClient()
+	clientConfig, err := b.config.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	skipClient := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
+
+	oapiconn := oapi.NewClient(clientConfig, skipClient)
 
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
-	state.Put("osc", oscConn)
-	state.Put("accessConfig", &b.config.AccessConfig)
+	state.Put("oapi", oapiconn)
+	state.Put("clientConfig", clientConfig)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 
@@ -116,7 +129,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&osccommon.StepKeyPair{
 			Debug:        b.config.PackerDebug,
 			Comm:         &b.config.RunConfig.Comm,
-			DebugKeyPath: fmt.Sprintf("osc_%s", b.config.PackerBuildName),
+			DebugKeyPath: fmt.Sprintf("oapi_%s", b.config.PackerBuildName),
 		},
 		&osccommon.StepPublicIp{
 			AssociatePublicIpAddress: b.config.AssociatePublicIpAddress,
@@ -148,7 +161,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			UserData:                    b.config.UserData,
 			UserDataFile:                b.config.UserDataFile,
 			VolumeTags:                  b.config.VolumeRunTags,
-			RawRegion:                   b.config.RawRegion,
 		},
 		&osccommon.StepGetPassword{
 			Debug:     b.config.PackerDebug,
@@ -158,8 +170,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		},
 		&communicator.StepConnect{
 			Config: &b.config.RunConfig.Comm,
-			Host: osccommon.OscSSHHost(
-				oscConn.VmApi,
+			Host: osccommon.SSHHost(
+				oapiconn,
 				b.config.SSHInterface),
 			SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
 		},
@@ -178,13 +190,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			OMIName:             b.config.OMIName,
 			Regions:             b.config.OMIRegions,
 		},
-		&stepCreateOMI{
-			RawRegion: b.config.RawRegion,
-		},
+		&stepCreateOMI{},
 		&osccommon.StepUpdateOMIAttributes{
 			AccountIds:         b.config.OMIAccountIDs,
 			SnapshotAccountIds: b.config.SnapshotAccountIDs,
-			RawRegion:          b.config.RawRegion,
 			Ctx:                b.config.ctx,
 		},
 		&osccommon.StepCreateTags{
@@ -208,6 +217,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		artifact := &osccommon.Artifact{
 			Omis:           omis.(map[string]string),
 			BuilderIdValue: BuilderId,
+			Config:         clientConfig,
 			StateData:      map[string]interface{}{"generated_data": state.Get("generated_data")},
 		}
 

builder/osc/bsu/builder.hcl2spec.go

@@ -76,8 +76,6 @@ type FlatConfig struct {
 	SSHUsername                 *string                                `mapstructure:"ssh_username" cty:"ssh_username" hcl:"ssh_username"`
 	SSHPassword                 *string                                `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName              *string                                `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
-	SSHTemporaryKeyPairType     *string                                `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits     *int                                   `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                  []string                               `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys      *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                 []string                               `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -199,8 +197,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_username":                         &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
 		"ssh_password":                         &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                     &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":              &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":              &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                          &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":            &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":          &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/osc/bsu/builder_acc_test.go

@@ -2,9 +2,13 @@
 package bsu
 
 import (
+	"crypto/tls"
+	"net/http"
 	"testing"
 
+	"github.com/hashicorp/packer/builder/osc/common"
 	builderT "github.com/hashicorp/packer/helper/builder/testing"
+	"github.com/outscale/osc-go/oapi"
 )
 
 func TestBuilderAcc_basic(t *testing.T) {
@@ -19,17 +23,31 @@ func TestBuilderAcc_basic(t *testing.T) {
 func testAccPreCheck(t *testing.T) {
 }
 
+func testOAPIConn() (*oapi.Client, error) {
+	access := &common.AccessConfig{RawRegion: "us-east-1"}
+	clientConfig, err := access.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	skipClient := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
+
+	return oapi.NewClient(clientConfig, skipClient), nil
+}
+
 const testBuilderAccBasic = `
 {
 	"builders": [{
 		"type": "test",
 		"region": "eu-west-2",
 		"vm_type": "t2.micro",
-		"source_omi": "ami-abe953fa",
+		"source_omi": "ami-65efcc11",
 		"ssh_username": "outscale",
-		"omi_name": "packer-test",
-		"associate_public_ip_address": true,
-		"force_deregister": true
+		"omi_name": "packer-test {{timestamp}}"
 	}]
 }
 `

builder/osc/bsu/step_create_omi.go

@@ -5,68 +5,62 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/antihax/optional"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 type stepCreateOMI struct {
-	image     *osc.Image
-	RawRegion string
+	image *oapi.Image
 }
 
 func (s *stepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
-	oscconn := state.Get("osc").(*osc.APIClient)
-	vm := state.Get("vm").(osc.Vm)
+	oapiconn := state.Get("oapi").(*oapi.Client)
+	vm := state.Get("vm").(oapi.Vm)
 	ui := state.Get("ui").(packer.Ui)
 
 	// Create the image
 	omiName := config.OMIName
 
 	ui.Say(fmt.Sprintf("Creating OMI %s from vm %s", omiName, vm.VmId))
-	createOpts := osc.CreateImageRequest{
+	createOpts := oapi.CreateImageRequest{
 		VmId:                vm.VmId,
 		ImageName:           omiName,
-		BlockDeviceMappings: config.BlockDevices.BuildOscOMIDevices(),
+		BlockDeviceMappings: config.BlockDevices.BuildOMIDevices(),
 	}
 
-	resp, _, err := oscconn.ImageApi.CreateImage(context.Background(), &osc.CreateImageOpts{
-		CreateImageRequest: optional.NewInterface(createOpts),
-	})
-	if err != nil || resp.Image.ImageId == "" {
+	resp, err := oapiconn.POST_CreateImage(createOpts)
+	if err != nil || resp.OK == nil {
 		err := fmt.Errorf("Error creating OMI: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
-	image := resp.Image
+	image := resp.OK.Image
 
 	// Set the OMI ID in the state
 	ui.Message(fmt.Sprintf("OMI: %s", image.ImageId))
 	omis := make(map[string]string)
-	omis[s.RawRegion] = image.ImageId
+	omis[oapiconn.GetConfig().Region] = image.ImageId
 	state.Put("omis", omis)
 
 	// Wait for the image to become ready
 	ui.Say("Waiting for OMI to become ready...")
-	if err := osccommon.WaitUntilOscImageAvailable(oscconn, image.ImageId); err != nil {
+	if err := osccommon.WaitUntilImageAvailable(oapiconn, image.ImageId); err != nil {
 		log.Printf("Error waiting for OMI: %s", err)
-		imagesResp, _, err := oscconn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
-			ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
-				Filters: osc.FiltersImage{
-					ImageIds: []string{image.ImageId},
-				},
-			}),
+		imagesResp, err := oapiconn.POST_ReadImages(oapi.ReadImagesRequest{
+			Filters: oapi.FiltersImage{
+				ImageIds: []string{image.ImageId},
+			},
 		})
 		if err != nil {
 			log.Printf("Unable to determine reason waiting for OMI failed: %s", err)
-			err = fmt.Errorf("Unknown error waiting for OMI")
+			err = fmt.Errorf("Unknown error waiting for OMI.")
 		} else {
-			stateReason := imagesResp.Images[0].StateComment
+			stateReason := imagesResp.OK.Images[0].StateComment
 			err = fmt.Errorf("Error waiting for OMI. Reason: %s", stateReason)
 		}
 
@@ -75,12 +69,10 @@ func (s *stepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
 		return multistep.ActionHalt
 	}
 
-	imagesResp, _, err := oscconn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
-		ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
-			Filters: osc.FiltersImage{
-				ImageIds: []string{image.ImageId},
-			},
-		}),
+	imagesResp, err := oapiconn.POST_ReadImages(oapi.ReadImagesRequest{
+		Filters: oapi.FiltersImage{
+			ImageIds: []string{image.ImageId},
+		},
 	})
 	if err != nil {
 		err := fmt.Errorf("Error searching for OMI: %s", err)
@@ -88,12 +80,12 @@ func (s *stepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
-	s.image = &imagesResp.Images[0]
+	s.image = &imagesResp.OK.Images[0]
 
 	snapshots := make(map[string][]string)
-	for _, blockDeviceMapping := range imagesResp.Images[0].BlockDeviceMappings {
+	for _, blockDeviceMapping := range imagesResp.OK.Images[0].BlockDeviceMappings {
 		if blockDeviceMapping.Bsu.SnapshotId != "" {
-			snapshots[s.RawRegion] = append(snapshots[s.RawRegion], blockDeviceMapping.Bsu.SnapshotId)
+			snapshots[oapiconn.GetConfig().Region] = append(snapshots[oapiconn.GetConfig().Region], blockDeviceMapping.Bsu.SnapshotId)
 		}
 	}
 	state.Put("snapshots", snapshots)
@@ -112,14 +104,12 @@ func (s *stepCreateOMI) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Deregistering the OMI because cancellation or error...")
-	DeleteOpts := osc.DeleteImageRequest{ImageId: s.image.ImageId}
-	if _, _, err := oscconn.ImageApi.DeleteImage(context.Background(), &osc.DeleteImageOpts{
-		DeleteImageRequest: optional.NewInterface(DeleteOpts),
-	}); err != nil {
+	DeleteOpts := oapi.DeleteImageRequest{ImageId: s.image.ImageId}
+	if _, err := oapiconn.POST_DeleteImage(DeleteOpts); err != nil {
 		ui.Error(fmt.Sprintf("Error Deleting OMI, may still be around: %s", err))
 		return
 	}

builder/osc/bsusurrogate/builder.go

@@ -6,8 +6,10 @@ package bsusurrogate
 
 import (
 	"context"
+	"crypto/tls"
 	"errors"
 	"fmt"
+	"net/http"
 
 	"github.com/hashicorp/hcl/v2/hcldec"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
@@ -17,6 +19,7 @@ import (
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/outscale/osc-go/oapi"
 )
 
 const BuilderId = "oapi.outscale.bsusurrogate"
@@ -46,7 +49,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	b.config.ctx.Funcs = osccommon.TemplateFuncs
 
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
@@ -102,20 +104,31 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 }
 
 func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
-	oscConn := b.config.NewOSCClient()
+	clientConfig, err := b.config.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	skipClient := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
+
+	oapiconn := oapi.NewClient(clientConfig, skipClient)
 
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
-	state.Put("osc", oscConn)
-	state.Put("accessConfig", &b.config.AccessConfig)
+	state.Put("oapi", oapiconn)
+	state.Put("clientConfig", clientConfig)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 
 	//VMStep
 
-	omiDevices := b.config.BuildOscOMIDevices()
-	launchOSCDevices := b.config.BuildOSCLaunchDevices()
+	omiDevices := b.config.BuildOMIDevices()
+	launchDevices := b.config.BuildLaunchDevices()
 
 	steps := []multistep.Step{
 		&osccommon.StepPreValidate{
@@ -180,8 +193,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		},
 		&communicator.StepConnect{
 			Config: &b.config.RunConfig.Comm,
-			Host: osccommon.OscSSHHost(
-				oscConn.VmApi,
+			Host: osccommon.SSHHost(
+				oapiconn,
 				b.config.SSHInterface),
 			SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
 		},
@@ -194,7 +207,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			DisableStopVm: b.config.DisableStopVm,
 		},
 		&StepSnapshotVolumes{
-			LaunchDevices: launchOSCDevices,
+			LaunchDevices: launchDevices,
 		},
 		&osccommon.StepDeregisterOMI{
 			AccessConfig:        &b.config.AccessConfig,
@@ -206,8 +219,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&StepRegisterOMI{
 			RootDevice:    b.config.RootDevice,
 			OMIDevices:    omiDevices,
-			LaunchDevices: launchOSCDevices,
-			RawRegion:     b.config.RawRegion,
+			LaunchDevices: launchDevices,
 		},
 		&osccommon.StepUpdateOMIAttributes{
 			AccountIds:         b.config.OMIAccountIDs,
@@ -235,6 +247,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		artifact := &osccommon.Artifact{
 			Omis:           omis.(map[string]string),
 			BuilderIdValue: BuilderId,
+			Config:         clientConfig,
 			StateData:      map[string]interface{}{"generated_data": state.Get("generated_data")},
 		}
 

builder/osc/bsusurrogate/builder.hcl2spec.go

@@ -61,8 +61,6 @@ type FlatConfig struct {
 	SSHUsername                 *string                                `mapstructure:"ssh_username" cty:"ssh_username" hcl:"ssh_username"`
 	SSHPassword                 *string                                `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName              *string                                `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
-	SSHTemporaryKeyPairType     *string                                `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits     *int                                   `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                  []string                               `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys      *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                 []string                               `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -185,8 +183,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_username":                         &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
 		"ssh_password":                         &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                     &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":              &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":              &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                          &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":            &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":          &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/osc/bsusurrogate/builder_acc_test.go

@@ -24,7 +24,7 @@ const testBuilderAccBasic = `
 		"type": "test",
 		"region": "eu-west-2",
 		"vm_type": "t2.micro",
-		"source_omi": "ami-abe953fa",
+		"source_omi": "ami-65efcc11",
 		"ssh_username": "outscale",
 		"omi_name": "packer-test {{timestamp}}",
 		"omi_virtualization_type": "hvm",

builder/osc/bsusurrogate/step_register_omi.go

@@ -4,25 +4,23 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/antihax/optional"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // StepRegisterOMI creates the OMI.
 type StepRegisterOMI struct {
 	RootDevice    RootBlockDevice
-	OMIDevices    []osc.BlockDeviceMappingImage
-	LaunchDevices []osc.BlockDeviceMappingVmCreation
-	image         *osc.Image
-	RawRegion     string
+	OMIDevices    []oapi.BlockDeviceMappingImage
+	LaunchDevices []oapi.BlockDeviceMappingVmCreation
+	image         *oapi.Image
 }
 
 func (s *StepRegisterOMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	snapshotIds := state.Get("snapshot_ids").(map[string]string)
 	ui := state.Get("ui").(packer.Ui)
 
@@ -30,16 +28,14 @@ func (s *StepRegisterOMI) Run(ctx context.Context, state multistep.StateBag) mul
 
 	blockDevices := s.combineDevices(snapshotIds)
 
-	registerOpts := osc.CreateImageRequest{
+	registerOpts := oapi.CreateImageRequest{
 		ImageName:           config.OMIName,
 		Architecture:        "x86_64",
 		RootDeviceName:      s.RootDevice.DeviceName,
 		BlockDeviceMappings: blockDevices,
 	}
 
-	registerResp, _, err := oscconn.ImageApi.CreateImage(context.Background(), &osc.CreateImageOpts{
-		CreateImageRequest: optional.NewInterface(registerOpts),
-	})
+	registerResp, err := oapiconn.POST_CreateImage(registerOpts)
 	if err != nil {
 		state.Put("error", fmt.Errorf("Error registering OMI: %s", err))
 		ui.Error(state.Get("error").(error).Error())
@@ -47,26 +43,24 @@ func (s *StepRegisterOMI) Run(ctx context.Context, state multistep.StateBag) mul
 	}
 
 	// Set the OMI ID in the state
-	ui.Say(fmt.Sprintf("OMI: %s", registerResp.Image.ImageId))
+	ui.Say(fmt.Sprintf("OMI: %s", registerResp.OK.Image.ImageId))
 	omis := make(map[string]string)
-	omis[s.RawRegion] = registerResp.Image.ImageId
+	omis[oapiconn.GetConfig().Region] = registerResp.OK.Image.ImageId
 	state.Put("omis", omis)
 
 	// Wait for the image to become ready
 	ui.Say("Waiting for OMI to become ready...")
-	if err := osccommon.WaitUntilOscImageAvailable(oscconn, registerResp.Image.ImageId); err != nil {
+	if err := osccommon.WaitUntilImageAvailable(oapiconn, registerResp.OK.Image.ImageId); err != nil {
 		err := fmt.Errorf("Error waiting for OMI: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
-	imagesResp, _, err := oscconn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
-		ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
-			Filters: osc.FiltersImage{
-				ImageIds: []string{registerResp.Image.ImageId},
-			},
-		}),
+	imagesResp, err := oapiconn.POST_ReadImages(oapi.ReadImagesRequest{
+		Filters: oapi.FiltersImage{
+			ImageIds: []string{registerResp.OK.Image.ImageId},
+		},
 	})
 
 	if err != nil {
@@ -75,12 +69,12 @@ func (s *StepRegisterOMI) Run(ctx context.Context, state multistep.StateBag) mul
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
-	s.image = &imagesResp.Images[0]
+	s.image = &imagesResp.OK.Images[0]
 
 	snapshots := make(map[string][]string)
-	for _, blockDeviceMapping := range imagesResp.Images[0].BlockDeviceMappings {
+	for _, blockDeviceMapping := range imagesResp.OK.Images[0].BlockDeviceMappings {
 		if blockDeviceMapping.Bsu.SnapshotId != "" {
-			snapshots[s.RawRegion] = append(snapshots[s.RawRegion], blockDeviceMapping.Bsu.SnapshotId)
+			snapshots[oapiconn.GetConfig().Region] = append(snapshots[oapiconn.GetConfig().Region], blockDeviceMapping.Bsu.SnapshotId)
 		}
 	}
 	state.Put("snapshots", snapshots)
@@ -99,23 +93,19 @@ func (s *StepRegisterOMI) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Deregistering the OMI because cancellation or error...")
-	deregisterOpts := osc.DeleteImageRequest{ImageId: s.image.ImageId}
-	_, _, err := oscconn.ImageApi.DeleteImage(context.Background(), &osc.DeleteImageOpts{
-		DeleteImageRequest: optional.NewInterface(deregisterOpts),
-	})
-
-	if err != nil {
+	deregisterOpts := oapi.DeleteImageRequest{ImageId: s.image.ImageId}
+	if _, err := oapiconn.POST_DeleteImage(deregisterOpts); err != nil {
 		ui.Error(fmt.Sprintf("Error deregistering OMI, may still be around: %s", err))
 		return
 	}
 }
 
-func (s *StepRegisterOMI) combineDevices(snapshotIds map[string]string) []osc.BlockDeviceMappingImage {
-	devices := map[string]osc.BlockDeviceMappingImage{}
+func (s *StepRegisterOMI) combineDevices(snapshotIds map[string]string) []oapi.BlockDeviceMappingImage {
+	devices := map[string]oapi.BlockDeviceMappingImage{}
 
 	for _, device := range s.OMIDevices {
 		devices[device.DeviceName] = device
@@ -135,18 +125,18 @@ func (s *StepRegisterOMI) combineDevices(snapshotIds map[string]string) []osc.Bl
 		devices[device.DeviceName] = copyToDeviceMappingImage(device)
 	}
 
-	blockDevices := []osc.BlockDeviceMappingImage{}
+	blockDevices := []oapi.BlockDeviceMappingImage{}
 	for _, device := range devices {
 		blockDevices = append(blockDevices, device)
 	}
 	return blockDevices
 }
 
-func copyToDeviceMappingImage(device osc.BlockDeviceMappingVmCreation) osc.BlockDeviceMappingImage {
-	deviceImage := osc.BlockDeviceMappingImage{
+func copyToDeviceMappingImage(device oapi.BlockDeviceMappingVmCreation) oapi.BlockDeviceMappingImage {
+	deviceImage := oapi.BlockDeviceMappingImage{
 		DeviceName:        device.DeviceName,
 		VirtualDeviceName: device.VirtualDeviceName,
-		Bsu: osc.BsuToCreate{
+		Bsu: oapi.BsuToCreate{
 			DeleteOnVmDeletion: device.Bsu.DeleteOnVmDeletion,
 			Iops:               device.Bsu.Iops,
 			SnapshotId:         device.Bsu.SnapshotId,

builder/osc/bsusurrogate/step_snapshop_volumes.go

@@ -6,12 +6,11 @@ import (
 	"sync"
 	"time"
 
-	"github.com/antihax/optional"
 	multierror "github.com/hashicorp/go-multierror"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // StepSnapshotVolumes creates snapshots of the created volumes.
@@ -19,14 +18,14 @@ import (
 // Produces:
 //   snapshot_ids map[string]string - IDs of the created snapshots
 type StepSnapshotVolumes struct {
-	LaunchDevices []osc.BlockDeviceMappingVmCreation
+	LaunchDevices []oapi.BlockDeviceMappingVmCreation
 	snapshotIds   map[string]string
 }
 
 func (s *StepSnapshotVolumes) snapshotVolume(ctx context.Context, deviceName string, state multistep.StateBag) error {
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	ui := state.Get("ui").(packer.Ui)
-	vm := state.Get("vm").(osc.Vm)
+	vm := state.Get("vm").(oapi.Vm)
 
 	var volumeId string
 	for _, volume := range vm.BlockDeviceMappings {
@@ -41,21 +40,19 @@ func (s *StepSnapshotVolumes) snapshotVolume(ctx context.Context, deviceName str
 	ui.Say(fmt.Sprintf("Creating snapshot of EBS Volume %s...", volumeId))
 	description := fmt.Sprintf("Packer: %s", time.Now().String())
 
-	createSnapResp, _, err := oscconn.SnapshotApi.CreateSnapshot(context.Background(), &osc.CreateSnapshotOpts{
-		CreateSnapshotRequest: optional.NewInterface(osc.CreateSnapshotRequest{
-			VolumeId:    volumeId,
-			Description: description,
-		}),
+	createSnapResp, err := oapiconn.POST_CreateSnapshot(oapi.CreateSnapshotRequest{
+		VolumeId:    volumeId,
+		Description: description,
 	})
 	if err != nil {
 		return err
 	}
 
 	// Set the snapshot ID so we can delete it later
-	s.snapshotIds[deviceName] = createSnapResp.Snapshot.SnapshotId
+	s.snapshotIds[deviceName] = createSnapResp.OK.Snapshot.SnapshotId
 
 	// Wait for snapshot to be created
-	err = osccommon.WaitUntilOscSnapshotCompleted(oscconn, createSnapResp.Snapshot.SnapshotId)
+	err = osccommon.WaitUntilSnapshotCompleted(oapiconn, createSnapResp.OK.Snapshot.SnapshotId)
 	return err
 }
 
@@ -68,7 +65,7 @@ func (s *StepSnapshotVolumes) Run(ctx context.Context, state multistep.StateBag)
 	var errs *multierror.Error
 	for _, device := range s.LaunchDevices {
 		wg.Add(1)
-		go func(device osc.BlockDeviceMappingVmCreation) {
+		go func(device oapi.BlockDeviceMappingVmCreation) {
 			defer wg.Done()
 			if err := s.snapshotVolume(ctx, device.DeviceName, state); err != nil {
 				errs = multierror.Append(errs, err)
@@ -97,13 +94,11 @@ func (s *StepSnapshotVolumes) Cleanup(state multistep.StateBag) {
 	_, halted := state.GetOk(multistep.StateHalted)
 
 	if cancelled || halted {
-		oscconn := state.Get("osc").(*osc.APIClient)
+		oapiconn := state.Get("oapi").(*oapi.Client)
 		ui := state.Get("ui").(packer.Ui)
 		ui.Say("Removing snapshots since we cancelled or halted...")
-		for _, snapshotID := range s.snapshotIds {
-			_, _, err := oscconn.SnapshotApi.DeleteSnapshot(context.Background(), &osc.DeleteSnapshotOpts{
-				DeleteSnapshotRequest: optional.NewInterface(osc.DeleteSnapshotRequest{SnapshotId: snapshotID}),
-			})
+		for _, snapshotId := range s.snapshotIds {
+			_, err := oapiconn.POST_DeleteSnapshot(oapi.DeleteSnapshotRequest{SnapshotId: snapshotId})
 			if err != nil {
 				ui.Error(fmt.Sprintf("Error: %s", err))
 			}

builder/osc/bsuvolume/artifact.go

@@ -1,15 +1,13 @@
 package bsuvolume
 
 import (
-	"context"
 	"fmt"
 	"log"
 	"sort"
 	"strings"
 
-	"github.com/antihax/optional"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // map of region to list of volume IDs
@@ -24,7 +22,7 @@ type Artifact struct {
 	BuilderIdValue string
 
 	// Client connection for performing API stuff.
-	Conn *osc.APIClient
+	Conn *oapi.Client
 
 	// StateData should store data such as GeneratedData
 	// to be shared with post-processors
@@ -72,12 +70,10 @@ func (a *Artifact) Destroy() error {
 		for _, volumeID := range volumeIDs {
 			log.Printf("Deregistering Volume ID (%s) from region (%s)", volumeID, region)
 
-			input := osc.DeleteVolumeRequest{
+			input := oapi.DeleteVolumeRequest{
 				VolumeId: volumeID,
 			}
-			if _, _, err := a.Conn.VolumeApi.DeleteVolume(context.Background(), &osc.DeleteVolumeOpts{
-				DeleteVolumeRequest: optional.NewInterface(optional.NewInterface(input)),
-			}); err != nil {
+			if _, err := a.Conn.POST_DeleteVolume(input); err != nil {
 				errors = append(errors, err)
 			}
 		}

builder/osc/bsuvolume/builder.go

@@ -6,8 +6,10 @@ package bsuvolume
 
 import (
 	"context"
+	"crypto/tls"
 	"fmt"
 	"log"
+	"net/http"
 
 	"github.com/hashicorp/hcl/v2/hcldec"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
@@ -17,6 +19,7 @@ import (
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/outscale/osc-go/oapi"
 )
 
 const BuilderId = "oapi.outscale.bsuvolume"
@@ -53,7 +56,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 		SourceOMI:   `{{ .SourceOMI }} `,
 	}
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 	}, raws...)
@@ -87,22 +89,22 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 }
 
 func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
-	// clientConfig, err := b.config.Config()
-	// if err != nil {
-	// 	return nil, err
-	// }
+	clientConfig, err := b.config.Config()
+	if err != nil {
+		return nil, err
+	}
 
-	// skipClient := &http.Client{
-	// 	Transport: &http.Transport{
-	// 		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	// 	},
-	// }
+	skipClient := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
 
-	oscConn := b.config.NewOSCClient()
+	oapiconn := oapi.NewClient(clientConfig, skipClient)
 
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
-	state.Put("osc", oscConn)
+	state.Put("oapi", oapiconn)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 
@@ -115,7 +117,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		Debug:                       b.config.PackerDebug,
 		BsuOptimized:                b.config.BsuOptimized,
 		EnableT2Unlimited:           b.config.EnableT2Unlimited,
-		ExpectedRootDevice:          "bsu",
+		ExpectedRootDevice:          "ebs",
 		IamVmProfile:                b.config.IamVmProfile,
 		VmInitiatedShutdownBehavior: b.config.VmInitiatedShutdownBehavior,
 		VmType:                      b.config.VmType,
@@ -168,8 +170,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		},
 		&communicator.StepConnect{
 			Config: &b.config.RunConfig.Comm,
-			Host: osccommon.OscSSHHost(
-				oscConn.VmApi,
+			Host: osccommon.SSHHost(
+				oapiconn,
 				b.config.SSHInterface),
 			SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
 		},
@@ -196,7 +198,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	artifact := &Artifact{
 		Volumes:        state.Get("bsuvolumes").(BsuVolumes),
 		BuilderIdValue: BuilderId,
-		Conn:           oscConn,
+		Conn:           oapiconn,
 		StateData:      map[string]interface{}{"generated_data": state.Get("generated_data")},
 	}
 	ui.Say(fmt.Sprintf("Created Volumes: %s", artifact))

builder/osc/bsuvolume/builder.hcl2spec.go

@@ -100,8 +100,6 @@ type FlatConfig struct {
 	SSHUsername                 *string                                `mapstructure:"ssh_username" cty:"ssh_username" hcl:"ssh_username"`
 	SSHPassword                 *string                                `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
 	SSHKeyPairName              *string                                `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
-	SSHTemporaryKeyPairType     *string                                `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits     *int                                   `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
 	SSHCiphers                  []string                               `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
 	SSHClearAuthorizedKeys      *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
 	SSHKEXAlgos                 []string                               `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
@@ -208,8 +206,6 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"ssh_username":                         &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
 		"ssh_password":                         &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
 		"ssh_keypair_name":                     &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":              &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":              &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
 		"ssh_ciphers":                          &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
 		"ssh_clear_authorized_keys":            &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
 		"ssh_key_exchange_algorithms":          &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},

builder/osc/bsuvolume/builder_acc_test.go

@@ -2,9 +2,13 @@
 package bsuvolume
 
 import (
+	"crypto/tls"
+	"net/http"
 	"testing"
 
+	"github.com/hashicorp/packer/builder/osc/common"
 	builderT "github.com/hashicorp/packer/helper/builder/testing"
+	"github.com/outscale/osc-go/oapi"
 )
 
 func TestBuilderAcc_basic(t *testing.T) {
@@ -19,6 +23,22 @@ func TestBuilderAcc_basic(t *testing.T) {
 func testAccPreCheck(t *testing.T) {
 }
 
+func testOAPIConn() (*oapi.Client, error) {
+	access := &common.AccessConfig{RawRegion: "us-east-1"}
+	clientConfig, err := access.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	skipClient := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
+
+	return oapi.NewClient(clientConfig, skipClient), nil
+}
+
 const testBuilderAccBasic = `
 {
     "builders": [
@@ -26,7 +46,7 @@ const testBuilderAccBasic = `
             "type": "test",
             "region": "eu-west-2",
             "vm_type": "t2.micro",
-            "source_omi": "ami-abe953fa",
+            "source_omi": "ami-65efcc11",
             "ssh_username": "outscale",
             "bsu_volumes": [
                 {

builder/osc/bsuvolume/step_tag_bsu_volumes.go

@@ -4,30 +4,28 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/antihax/optional"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 type stepTagBSUVolumes struct {
 	VolumeMapping []BlockDevice
-	RawRegion     string
 	Ctx           interpolate.Context
 }
 
 func (s *stepTagBSUVolumes) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	oscconn := state.Get("osc").(*osc.APIClient)
-	vm := state.Get("vm").(osc.Vm)
+	oapiconn := state.Get("oapi").(*oapi.Client)
+	vm := state.Get("vm").(oapi.Vm)
 	ui := state.Get("ui").(packer.Ui)
 
 	volumes := make(BsuVolumes)
 	for _, instanceBlockDevices := range vm.BlockDeviceMappings {
 		for _, configVolumeMapping := range s.VolumeMapping {
 			if configVolumeMapping.DeviceName == instanceBlockDevices.DeviceName {
-				volumes[s.RawRegion] = append(
-					volumes[s.RawRegion],
+				volumes[oapiconn.GetConfig().Region] = append(
+					volumes[oapiconn.GetConfig().Region],
 					instanceBlockDevices.Bsu.VolumeId)
 			}
 		}
@@ -37,14 +35,14 @@ func (s *stepTagBSUVolumes) Run(_ context.Context, state multistep.StateBag) mul
 	if len(s.VolumeMapping) > 0 {
 		ui.Say("Tagging BSU volumes...")
 
-		toTag := map[string][]osc.ResourceTag{}
+		toTag := map[string][]oapi.ResourceTag{}
 		for _, mapping := range s.VolumeMapping {
 			if len(mapping.Tags) == 0 {
 				ui.Say(fmt.Sprintf("No tags specified for volume on %s...", mapping.DeviceName))
 				continue
 			}
 
-			tags, err := mapping.Tags.OSCTags(s.Ctx, s.RawRegion, state)
+			tags, err := mapping.Tags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
 			if err != nil {
 				err := fmt.Errorf("Error tagging device %s with %s", mapping.DeviceName, err)
 				state.Put("error", err)
@@ -61,11 +59,9 @@ func (s *stepTagBSUVolumes) Run(_ context.Context, state multistep.StateBag) mul
 		}
 
 		for volumeId, tags := range toTag {
-			_, _, err := oscconn.TagApi.CreateTags(context.Background(), &osc.CreateTagsOpts{
-				CreateTagsRequest: optional.NewInterface(osc.CreateTagsRequest{
-					ResourceIds: []string{volumeId},
-					Tags:        tags,
-				}),
+			_, err := oapiconn.POST_CreateTags(oapi.CreateTagsRequest{
+				ResourceIds: []string{volumeId},
+				Tags:        tags,
 			})
 			if err != nil {
 				err := fmt.Errorf("Error tagging BSU Volume %s on %s: %s", volumeId, vm.VmId, err)

builder/osc/chroot/builder.go

@@ -8,7 +8,9 @@ package chroot
 
 import (
 	"context"
+	"crypto/tls"
 	"errors"
+	"net/http"
 	"runtime"
 
 	"github.com/hashicorp/hcl/v2/hcldec"
@@ -18,6 +20,7 @@ import (
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // The unique ID for this builder
@@ -66,7 +69,6 @@ func (b *Builder) ConfigSpec() hcldec.ObjectSpec { return b.config.FlatMapstruct
 func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
 	b.config.ctx.Funcs = osccommon.TemplateFuncs
 	err := config.Decode(&b.config, &config.DecodeOpts{
-		PluginType:         BuilderId,
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
@@ -191,7 +193,19 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, errors.New("The outscale-chroot builder only works on Linux environments.")
 	}
 
-	oscConn := b.config.NewOSCClient()
+	clientConfig, err := b.config.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	skipClient := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
+
+	oapiconn := oapi.NewClient(clientConfig, skipClient)
+
 	wrappedCommand := func(command string) (string, error) {
 		ctx := b.config.ctx
 		ctx.Data = &wrappedCommandTemplate{Command: command}
@@ -201,7 +215,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
-	state.Put("osc", oscConn)
+	state.Put("oapi", oapiconn)
+	state.Put("clientConfig", clientConfig)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 	state.Put("wrappedCommand", CommandWrapper(wrappedCommand))
@@ -251,9 +266,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&StepCopyFiles{},
 		&StepChrootProvision{},
 		&StepEarlyCleanup{},
-		&StepSnapshot{
-			RawRegion: b.config.RawRegion,
-		},
+		&StepSnapshot{},
 		&osccommon.StepDeregisterOMI{
 			AccessConfig:        &b.config.AccessConfig,
 			ForceDeregister:     b.config.OMIForceDeregister,
@@ -263,7 +276,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		},
 		&StepCreateOMI{
 			RootVolumeSize: b.config.RootVolumeSize,
-			RawRegion:      b.config.RawRegion,
 		},
 		&osccommon.StepUpdateOMIAttributes{
 			AccountIds:         b.config.OMIAccountIDs,
@@ -295,6 +307,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	artifact := &osccommon.Artifact{
 		Omis:           state.Get("omis").(map[string]string),
 		BuilderIdValue: BuilderId,
+		Config:         clientConfig,
 		StateData:      map[string]interface{}{"generated_data": state.Get("generated_data")},
 	}
 

builder/osc/chroot/step_check_root_device.go

@@ -6,14 +6,14 @@ import (
 
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // StepCheckRootDevice makes sure the root device on the OMI is BSU-backed.
 type StepCheckRootDevice struct{}
 
 func (s *StepCheckRootDevice) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	image := state.Get("source_image").(osc.Image)
+	image := state.Get("source_image").(oapi.Image)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Checking the root device on source OMI...")

builder/osc/chroot/step_create_omi.go

@@ -4,44 +4,42 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/antihax/optional"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // StepCreateOMI creates the OMI.
 type StepCreateOMI struct {
 	RootVolumeSize int64
-	RawRegion      string
 }
 
 func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
-	osconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	snapshotId := state.Get("snapshot_id").(string)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Creating the OMI...")
 
 	var (
-		registerOpts   osc.CreateImageRequest
-		mappings       []osc.BlockDeviceMappingImage
-		image          osc.Image
+		registerOpts   oapi.CreateImageRequest
+		mappings       []oapi.BlockDeviceMappingImage
+		image          oapi.Image
 		rootDeviceName string
 	)
 
 	if config.FromScratch {
-		mappings = config.OMIBlockDevices.BuildOscOMIDevices()
+		mappings = config.OMIBlockDevices.BuildOMIDevices()
 		rootDeviceName = config.RootDeviceName
 	} else {
-		image = state.Get("source_image").(osc.Image)
+		image = state.Get("source_image").(oapi.Image)
 		mappings = image.BlockDeviceMappings
 		rootDeviceName = image.RootDeviceName
 	}
 
-	newMappings := make([]osc.BlockDeviceMappingImage, len(mappings))
+	newMappings := make([]oapi.BlockDeviceMappingImage, len(mappings))
 	for i, device := range mappings {
 		newDevice := device
 
@@ -50,14 +48,14 @@ func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
 		newDevice.Bsu.VolumeSize = gibSize
 
 		if newDevice.DeviceName == rootDeviceName {
-			if newDevice.Bsu != (osc.BsuToCreate{}) {
+			if newDevice.Bsu != (oapi.BsuToCreate{}) {
 				newDevice.Bsu.SnapshotId = snapshotId
 			} else {
-				newDevice.Bsu = osc.BsuToCreate{SnapshotId: snapshotId}
+				newDevice.Bsu = oapi.BsuToCreate{SnapshotId: snapshotId}
 			}
 
-			if config.FromScratch || int32(s.RootVolumeSize) > newDevice.Bsu.VolumeSize {
-				newDevice.Bsu.VolumeSize = int32(s.RootVolumeSize)
+			if config.FromScratch || s.RootVolumeSize > newDevice.Bsu.VolumeSize {
+				newDevice.Bsu.VolumeSize = s.RootVolumeSize
 			}
 		}
 
@@ -65,7 +63,7 @@ func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
 	}
 
 	if config.FromScratch {
-		registerOpts = osc.CreateImageRequest{
+		registerOpts = oapi.CreateImageRequest{
 			ImageName:           config.OMIName,
 			Architecture:        "x86_64",
 			RootDeviceName:      rootDeviceName,
@@ -75,25 +73,23 @@ func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
 		registerOpts = buildRegisterOpts(config, image, newMappings)
 	}
 
-	registerResp, _, err := osconn.ImageApi.CreateImage(context.Background(), &osc.CreateImageOpts{
-		CreateImageRequest: optional.NewInterface(registerOpts),
-	})
+	registerResp, err := oapiconn.POST_CreateImage(registerOpts)
 	if err != nil {
 		state.Put("error", fmt.Errorf("Error registering OMI: %s", err))
 		ui.Error(state.Get("error").(error).Error())
 		return multistep.ActionHalt
 	}
 
-	imageID := registerResp.Image.ImageId
+	imageID := registerResp.OK.Image.ImageId
 
 	// Set the OMI ID in the state
 	ui.Say(fmt.Sprintf("OMI: %s", imageID))
 	omis := make(map[string]string)
-	omis[s.RawRegion] = imageID
+	omis[oapiconn.GetConfig().Region] = imageID
 	state.Put("omis", omis)
 
 	ui.Say("Waiting for OMI to become ready...")
-	if err := osccommon.WaitUntilOscImageAvailable(osconn, imageID); err != nil {
+	if err := osccommon.WaitUntilImageAvailable(oapiconn, imageID); err != nil {
 		err := fmt.Errorf("Error waiting for OMI: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
@@ -105,8 +101,8 @@ func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
 
 func (s *StepCreateOMI) Cleanup(state multistep.StateBag) {}
 
-func buildRegisterOpts(config *Config, image osc.Image, mappings []osc.BlockDeviceMappingImage) osc.CreateImageRequest {
-	registerOpts := osc.CreateImageRequest{
+func buildRegisterOpts(config *Config, image oapi.Image, mappings []oapi.BlockDeviceMappingImage) oapi.CreateImageRequest {
+	registerOpts := oapi.CreateImageRequest{
 		ImageName:           config.OMIName,
 		Architecture:        image.Architecture,
 		RootDeviceName:      image.RootDeviceName,

builder/osc/chroot/step_create_volume.go

@@ -6,12 +6,11 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/antihax/optional"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // StepCreateVolume creates a new volume from the snapshot of the root
@@ -24,19 +23,18 @@ type StepCreateVolume struct {
 	RootVolumeSize int64
 	RootVolumeType string
 	RootVolumeTags osccommon.TagMap
-	RawRegion      string
 	Ctx            interpolate.Context
 }
 
 func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
-	oscconn := state.Get("osc").(*osc.APIClient)
-	vm := state.Get("vm").(osc.Vm)
+	oapiconn := state.Get("oapi").(*oapi.Client)
+	vm := state.Get("vm").(oapi.Vm)
 	ui := state.Get("ui").(packer.Ui)
 
 	var err error
 
-	volTags, err := s.RootVolumeTags.OSCTags(s.Ctx, s.RawRegion, state)
+	volTags, err := s.RootVolumeTags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
 
 	if err != nil {
 		state.Put("error", err)
@@ -44,7 +42,7 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
 		return multistep.ActionHalt
 	}
 
-	var createVolume *osc.CreateVolumeRequest
+	var createVolume *oapi.CreateVolumeRequest
 	if config.FromScratch {
 		rootVolumeType := osccommon.VolumeTypeGp2
 		if s.RootVolumeType == "io1" {
@@ -55,17 +53,17 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
 		} else if s.RootVolumeType != "" {
 			rootVolumeType = s.RootVolumeType
 		}
-		createVolume = &osc.CreateVolumeRequest{
+		createVolume = &oapi.CreateVolumeRequest{
 			SubregionName: vm.Placement.SubregionName,
-			Size:          int32(s.RootVolumeSize),
+			Size:          s.RootVolumeSize,
 			VolumeType:    rootVolumeType,
 		}
 
 	} else {
 		// Determine the root device snapshot
-		image := state.Get("source_image").(osc.Image)
+		image := state.Get("source_image").(oapi.Image)
 		log.Printf("Searching for root device of the image (%s)", image.RootDeviceName)
-		var rootDevice *osc.BlockDeviceMappingImage
+		var rootDevice *oapi.BlockDeviceMappingImage
 		for _, device := range image.BlockDeviceMappings {
 			if device.DeviceName == image.RootDeviceName {
 				rootDevice = &device
@@ -84,9 +82,7 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
 
 	log.Printf("Create args: %+v", createVolume)
 
-	createVolumeResp, _, err := oscconn.VolumeApi.CreateVolume(context.Background(), &osc.CreateVolumeOpts{
-		CreateVolumeRequest: optional.NewInterface(*createVolume),
-	})
+	createVolumeResp, err := oapiconn.POST_CreateVolume(*createVolume)
 	if err != nil {
 		err := fmt.Errorf("Error creating root volume: %s", err)
 		state.Put("error", err)
@@ -95,12 +91,12 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
 	}
 
 	// Set the volume ID so we remember to delete it later
-	s.volumeId = createVolumeResp.Volume.VolumeId
+	s.volumeId = createVolumeResp.OK.Volume.VolumeId
 	log.Printf("Volume ID: %s", s.volumeId)
 
 	//Create tags for volume
 	if len(volTags) > 0 {
-		if err := osccommon.CreateOSCTags(oscconn, s.volumeId, ui, volTags); err != nil {
+		if err := osccommon.CreateTags(oapiconn, s.volumeId, ui, volTags); err != nil {
 			err := fmt.Errorf("Error creating tags for volume: %s", err)
 			state.Put("error", err)
 			ui.Error(err.Error())
@@ -109,7 +105,7 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
 	}
 
 	// Wait for the volume to become ready
-	err = osccommon.WaitUntilOscVolumeAvailable(oscconn, s.volumeId)
+	err = osccommon.WaitUntilVolumeAvailable(oapiconn, s.volumeId)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for volume: %s", err)
 		state.Put("error", err)
@@ -126,34 +122,32 @@ func (s *StepCreateVolume) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Deleting the created BSU volume...")
-	_, _, err := oscconn.VolumeApi.DeleteVolume(context.Background(), &osc.DeleteVolumeOpts{
-		DeleteVolumeRequest: optional.NewInterface(osc.DeleteVolumeRequest{VolumeId: s.volumeId}),
-	})
+	_, err := oapiconn.POST_DeleteVolume(oapi.DeleteVolumeRequest{VolumeId: s.volumeId})
 	if err != nil {
 		ui.Error(fmt.Sprintf("Error deleting BSU volume: %s", err))
 	}
 }
 
-func (s *StepCreateVolume) buildCreateVolumeInput(suregionName string, rootDevice *osc.BlockDeviceMappingImage) (*osc.CreateVolumeRequest, error) {
+func (s *StepCreateVolume) buildCreateVolumeInput(suregionName string, rootDevice *oapi.BlockDeviceMappingImage) (*oapi.CreateVolumeRequest, error) {
 	if rootDevice == nil {
-		return nil, fmt.Errorf("Couldn't find root device")
+		return nil, fmt.Errorf("Couldn't find root device!")
 	}
 
 	//FIX: Temporary fix
 	gibSize := rootDevice.Bsu.VolumeSize / (1024 * 1024 * 1024)
-	createVolumeInput := &osc.CreateVolumeRequest{
+	createVolumeInput := &oapi.CreateVolumeRequest{
 		SubregionName: suregionName,
 		Size:          gibSize,
 		SnapshotId:    rootDevice.Bsu.SnapshotId,
 		VolumeType:    rootDevice.Bsu.VolumeType,
 		Iops:          rootDevice.Bsu.Iops,
 	}
-	if int32(s.RootVolumeSize) > rootDevice.Bsu.VolumeSize {
-		createVolumeInput.Size = int32(s.RootVolumeSize)
+	if s.RootVolumeSize > rootDevice.Bsu.VolumeSize {
+		createVolumeInput.Size = s.RootVolumeSize
 	}
 
 	if s.RootVolumeType == "" || s.RootVolumeType == rootDevice.Bsu.VolumeType {

builder/osc/chroot/step_link_volume.go

@@ -4,11 +4,10 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/antihax/optional"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // StepLinkVolume attaches the previously created volume to an
@@ -23,9 +22,9 @@ type StepLinkVolume struct {
 }
 
 func (s *StepLinkVolume) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	device := state.Get("device").(string)
-	vm := state.Get("vm").(osc.Vm)
+	vm := state.Get("vm").(oapi.Vm)
 	ui := state.Get("ui").(packer.Ui)
 	volumeId := state.Get("volume_id").(string)
 
@@ -34,12 +33,10 @@ func (s *StepLinkVolume) Run(ctx context.Context, state multistep.StateBag) mult
 	linkVolume := device
 
 	ui.Say(fmt.Sprintf("Attaching the root volume to %s", linkVolume))
-	_, _, err := oscconn.VolumeApi.LinkVolume(context.Background(), &osc.LinkVolumeOpts{
-		LinkVolumeRequest: optional.NewInterface(osc.LinkVolumeRequest{
-			VmId:       vm.VmId,
-			VolumeId:   volumeId,
-			DeviceName: linkVolume,
-		}),
+	_, err := oapiconn.POST_LinkVolume(oapi.LinkVolumeRequest{
+		VmId:       vm.VmId,
+		VolumeId:   volumeId,
+		DeviceName: linkVolume,
 	})
 
 	if err != nil {
@@ -54,7 +51,7 @@ func (s *StepLinkVolume) Run(ctx context.Context, state multistep.StateBag) mult
 	s.volumeId = volumeId
 
 	// Wait for the volume to become attached
-	err = osccommon.WaitUntilOscVolumeIsLinked(oscconn, s.volumeId)
+	err = osccommon.WaitUntilVolumeIsLinked(oapiconn, s.volumeId)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for volume: %s", err)
 		state.Put("error", err)
@@ -78,14 +75,11 @@ func (s *StepLinkVolume) CleanupFunc(state multistep.StateBag) error {
 		return nil
 	}
 
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Detaching BSU volume...")
-	_, _, err := oscconn.VolumeApi.UnlinkVolume(context.Background(), &osc.UnlinkVolumeOpts{
-		UnlinkVolumeRequest: optional.NewInterface(osc.UnlinkVolumeRequest{VolumeId: s.volumeId}),
-	})
-
+	_, err := oapiconn.POST_UnlinkVolume(oapi.UnlinkVolumeRequest{VolumeId: s.volumeId})
 	if err != nil {
 		return fmt.Errorf("Error detaching BSU volume: %s", err)
 	}
@@ -93,7 +87,7 @@ func (s *StepLinkVolume) CleanupFunc(state multistep.StateBag) error {
 	s.attached = false
 
 	// Wait for the volume to detach
-	err = osccommon.WaitUntilOscVolumeIsUnlinked(oscconn, s.volumeId)
+	err = osccommon.WaitUntilVolumeIsUnlinked(oapiconn, s.volumeId)
 	if err != nil {
 		return fmt.Errorf("Error waiting for volume: %s", err)
 	}

builder/osc/chroot/step_snapshot.go

@@ -5,11 +5,10 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/antihax/optional"
 	osccommon "github.com/hashicorp/packer/builder/osc/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // StepSnapshot creates a snapshot of the created volume.
@@ -18,22 +17,19 @@ import (
 //   snapshot_id string - ID of the created snapshot
 type StepSnapshot struct {
 	snapshotId string
-	RawRegion  string
 }
 
 func (s *StepSnapshot) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	ui := state.Get("ui").(packer.Ui)
 	volumeId := state.Get("volume_id").(string)
 
 	ui.Say("Creating snapshot...")
 	description := fmt.Sprintf("Packer: %s", time.Now().String())
 
-	createSnapResp, _, err := oscconn.SnapshotApi.CreateSnapshot(context.Background(), &osc.CreateSnapshotOpts{
-		CreateSnapshotRequest: optional.NewInterface(osc.CreateSnapshotRequest{
-			VolumeId:    volumeId,
-			Description: description,
-		}),
+	createSnapResp, err := oapiconn.POST_CreateSnapshot(oapi.CreateSnapshotRequest{
+		VolumeId:    volumeId,
+		Description: description,
 	})
 	if err != nil {
 		err := fmt.Errorf("Error creating snapshot: %s", err)
@@ -43,11 +39,11 @@ func (s *StepSnapshot) Run(ctx context.Context, state multistep.StateBag) multis
 	}
 
 	// Set the snapshot ID so we can delete it later
-	s.snapshotId = createSnapResp.Snapshot.SnapshotId
+	s.snapshotId = createSnapResp.OK.Snapshot.SnapshotId
 	ui.Message(fmt.Sprintf("Snapshot ID: %s", s.snapshotId))
 
 	// Wait for the snapshot to be ready
-	err = osccommon.WaitUntilOscSnapshotDone(oscconn, s.snapshotId)
+	err = osccommon.WaitUntilSnapshotDone(oapiconn, s.snapshotId)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for snapshot: %s", err)
 		state.Put("error", err)
@@ -58,7 +54,7 @@ func (s *StepSnapshot) Run(ctx context.Context, state multistep.StateBag) multis
 	state.Put("snapshot_id", s.snapshotId)
 
 	snapshots := map[string][]string{
-		s.RawRegion: {s.snapshotId},
+		oapiconn.GetConfig().Region: {s.snapshotId},
 	}
 	state.Put("snapshots", snapshots)
 
@@ -74,12 +70,10 @@ func (s *StepSnapshot) Cleanup(state multistep.StateBag) {
 	_, halted := state.GetOk(multistep.StateHalted)
 
 	if cancelled || halted {
-		oscconn := state.Get("osc").(*osc.APIClient)
+		oapiconn := state.Get("oapi").(*oapi.Client)
 		ui := state.Get("ui").(packer.Ui)
 		ui.Say("Removing snapshot since we cancelled or halted...")
-		_, _, err := oscconn.SnapshotApi.DeleteSnapshot(context.Background(), &osc.DeleteSnapshotOpts{
-			DeleteSnapshotRequest: optional.NewInterface(osc.DeleteSnapshotRequest{SnapshotId: s.snapshotId}),
-		})
+		_, err := oapiconn.POST_DeleteSnapshot(oapi.DeleteSnapshotRequest{SnapshotId: s.snapshotId})
 		if err != nil {
 			ui.Error(fmt.Sprintf("Error: %s", err))
 		}

builder/osc/chroot/step_vm_info.go

@@ -5,17 +5,16 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/antihax/optional"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/outscale/osc-sdk-go/osc"
+	"github.com/outscale/osc-go/oapi"
 )
 
 // StepVmInfo verifies that this builder is running on an Outscale vm.
 type StepVmInfo struct{}
 
 func (s *StepVmInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
-	oscconn := state.Get("osc").(*osc.APIClient)
+	oapiconn := state.Get("oapi").(*oapi.Client)
 	//session := state.Get("clientConfig").(*session.Session)
 	ui := state.Get("ui").(packer.Ui)
 
@@ -37,11 +36,9 @@ func (s *StepVmInfo) Run(_ context.Context, state multistep.StateBag) multistep.
 	log.Printf("[Debug] VmID got: %s", string(vmID))
 
 	// Query the entire vm metadata
-	resp, _, err := oscconn.VmApi.ReadVms(context.Background(), &osc.ReadVmsOpts{
-		ReadVmsRequest: optional.NewInterface(osc.ReadVmsRequest{Filters: osc.FiltersVm{
-			VmIds: []string{string(vmID)},
-		}}),
-	})
+	resp, err := oapiconn.POST_ReadVms(oapi.ReadVmsRequest{Filters: oapi.FiltersVm{
+		VmIds: []string{string(vmID)},
+	}})
 	if err != nil {
 		err := fmt.Errorf("Error getting vm data: %s", err)
 		state.Put("error", err)
@@ -49,10 +46,10 @@ func (s *StepVmInfo) Run(_ context.Context, state multistep.StateBag) multistep.
 		return multistep.ActionHalt
 	}
 
-	vmsResp := resp
+	vmsResp := resp.OK
 
 	if len(vmsResp.Vms) == 0 {
-		err := fmt.Errorf("Error getting vm data: no vm found")
+		err := fmt.Errorf("Error getting vm data: no vm found.")
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt