packer-plugin-amazon/common/step_associate_eip.go at 2a401680123893f6ace840857d21b223ca5b4fbe · hashicorp/packer-plugin-amazon · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
// Copyright IBM Corp. 2013, 2025
// SPDX-License-Identifier: MPL-2.0

package common

import (
	"context"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/ec2"
	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
	"github.com/hashicorp/packer-plugin-amazon/common/clients"
	"github.com/hashicorp/packer-plugin-sdk/multistep"
	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
)

// StepAssociateEIP associates a pre-existing Elastic IP with the build instance
// immediately after launch. Cleanup disassociates (but does not release) the EIP.
type StepAssociateEIP struct {
	AllocationId  string
	associationId string
}

func (s *StepAssociateEIP) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
	if s.AllocationId == "" {
		return multistep.ActionContinue
	}
	ec2Client := state.Get("ec2v2").(clients.Ec2Client)
	ui := state.Get("ui").(packersdk.Ui)
	instance := state.Get("instance").(ec2types.Instance)

	ui.Say(fmt.Sprintf("Associating Elastic IP %s with instance %s...", s.AllocationId, *instance.InstanceId))
	resp, err := ec2Client.AssociateAddress(ctx, &ec2.AssociateAddressInput{
		AllocationId: aws.String(s.AllocationId),
		InstanceId:   instance.InstanceId,
	})
	if err != nil {
		err = fmt.Errorf("error associating EIP %s: %w", s.AllocationId, err)
		state.Put("error", err)
		ui.Error(err.Error())
		return multistep.ActionHalt
	}
	s.associationId = aws.ToString(resp.AssociationId)
	ui.Say(fmt.Sprintf("EIP associated (association ID: %s)", s.associationId))

	// Refresh instance in state so SSHHost reads the EIP as PublicIpAddress.
	descResp, err := ec2Client.DescribeInstances(ctx, &ec2.DescribeInstancesInput{
		InstanceIds: []string{*instance.InstanceId},
	})
	if err != nil || len(descResp.Reservations) == 0 || len(descResp.Reservations[0].Instances) == 0 {
		err = fmt.Errorf("error refreshing instance after EIP association: %w", err)
		state.Put("error", err)
		ui.Error(err.Error())
		return multistep.ActionHalt
	}
	state.Put("instance", descResp.Reservations[0].Instances[0])
	return multistep.ActionContinue
}

func (s *StepAssociateEIP) Cleanup(state multistep.StateBag) {
	if s.associationId == "" {
		return
	}
	ec2Client := state.Get("ec2v2").(clients.Ec2Client)
	ui := state.Get("ui").(packersdk.Ui)

	ui.Say(fmt.Sprintf("Disassociating Elastic IP (association ID: %s)...", s.associationId))
	_, err := ec2Client.DisassociateAddress(context.Background(), &ec2.DisassociateAddressInput{
		AssociationId: aws.String(s.associationId),
	})
	if err != nil {
		ui.Error(fmt.Sprintf("Error disassociating EIP %s: %s", s.associationId, err))
		return
	}
	ui.Say("Elastic IP disassociated.")
}