packer-cn/builder/oracle/classic/builder.go

202 lines
6.0 KiB
Go
Raw Normal View History

2018-01-12 17:12:15 -05:00
package classic
import (
"context"
2018-01-12 17:12:15 -05:00
"fmt"
"os"
2018-01-12 17:12:15 -05:00
2018-01-12 18:44:40 -05:00
"github.com/hashicorp/go-cleanhttp"
"github.com/hashicorp/go-oracle-terraform/compute"
"github.com/hashicorp/go-oracle-terraform/opc"
2018-01-17 16:07:41 -05:00
ocommon "github.com/hashicorp/packer/builder/oracle/common"
2018-01-12 17:12:15 -05:00
"github.com/hashicorp/packer/common"
"github.com/hashicorp/packer/helper/communicator"
2018-01-25 17:45:09 -05:00
"github.com/hashicorp/packer/helper/multistep"
2018-01-12 17:12:15 -05:00
"github.com/hashicorp/packer/packer"
)
// BuilderId uniquely identifies the builder
const BuilderId = "packer.oracle.classic"
// Builder is a builder implementation that creates Oracle OCI custom images.
type Builder struct {
config *Config
runner multistep.Runner
}
func (b *Builder) Prepare(rawConfig ...interface{}) ([]string, error) {
config, err := NewConfig(rawConfig...)
if err != nil {
return nil, err
}
b.config = config
2018-09-06 01:44:31 -04:00
var errs *packer.MultiError
2018-09-12 20:12:35 -04:00
errs = packer.MultiErrorAppend(errs, b.config.PVConfig.Prepare(&b.config.ctx))
2018-09-06 01:44:31 -04:00
if errs != nil && len(errs.Errors) > 0 {
return nil, errs
}
2018-01-12 17:12:15 -05:00
return nil, nil
}
func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
2018-01-26 11:43:51 -05:00
loggingEnabled := os.Getenv("PACKER_OCI_CLASSIC_LOGGING") != ""
2018-01-12 18:44:40 -05:00
httpClient := cleanhttp.DefaultClient()
config := &opc.Config{
Username: opc.String(b.config.Username),
Password: opc.String(b.config.Password),
IdentityDomain: opc.String(b.config.IdentityDomain),
APIEndpoint: b.config.apiEndpointURL,
LogLevel: opc.LogDebug,
Logger: &Logger{loggingEnabled},
2018-01-12 18:44:40 -05:00
// Logger: # Leave blank to use the default logger, or provide your own
HTTPClient: httpClient,
}
// Create the Compute Client
client, err := compute.NewComputeClient(config)
if err != nil {
return nil, fmt.Errorf("Error creating OPC Compute Client: %s", err)
}
runID := fmt.Sprintf("%s_%s", b.config.ImageName, os.Getenv("PACKER_RUN_UUID"))
2018-01-12 17:12:15 -05:00
// Populate the state bag
state := new(multistep.BasicStateBag)
state.Put("config", b.config)
state.Put("hook", hook)
state.Put("ui", ui)
2018-01-12 18:44:40 -05:00
state.Put("client", client)
2018-10-19 18:51:17 -04:00
state.Put("run_id", runID)
2018-01-12 17:12:15 -05:00
var steps []multistep.Step
2018-09-12 20:12:35 -04:00
if b.config.IsPV() {
steps = []multistep.Step{
2018-09-06 01:44:31 -04:00
&ocommon.StepKeyPair{
Debug: b.config.PackerDebug,
Comm: &b.config.Comm,
DebugKeyPath: fmt.Sprintf("oci_classic_%s.pem", b.config.PackerBuildName),
},
&stepCreateIPReservation{},
2018-10-26 18:47:49 -04:00
&stepAddKeysToAPI{
KeyName: fmt.Sprintf("packer-generated-key_%s", runID),
},
&stepSecurity{
CommType: b.config.Comm.Type,
SecurityListKey: "security_list_master",
},
&stepCreatePersistentVolume{
VolumeSize: fmt.Sprintf("%d", b.config.PersistentVolumeSize),
VolumeName: fmt.Sprintf("master-storage_%s", runID),
ImageList: b.config.SourceImageList,
ImageListEntry: b.config.SourceImageListEntry,
Bootable: true,
},
2018-09-06 01:44:31 -04:00
&stepCreatePVMaster{
Name: fmt.Sprintf("master-instance_%s", runID),
VolumeName: fmt.Sprintf("master-storage_%s", runID),
SecurityListKey: "security_list_master",
2018-09-06 01:44:31 -04:00
},
&communicator.StepConnect{
Config: &b.config.Comm,
2019-07-03 16:34:23 -04:00
Host: communicator.CommHost(b.config.Comm.SSHHost, "instance_ip"),
2018-09-06 01:44:31 -04:00
SSHConfig: b.config.Comm.SSHConfigFunc(),
},
&common.StepProvision{},
&stepTerminatePVMaster{},
&stepSecurity{
SecurityListKey: "security_list_builder",
CommType: "ssh",
},
&stepCreatePersistentVolume{
// We double the master volume size because we need room to
// tarball the disk image. We also need to chunk the tar ball,
// but we can remove the original disk image first.
VolumeSize: fmt.Sprintf("%d", b.config.PersistentVolumeSize*2),
VolumeName: fmt.Sprintf("builder-storage_%s", runID),
},
2018-09-06 01:44:31 -04:00
&stepCreatePVBuilder{
Name: fmt.Sprintf("builder-instance_%s", runID),
BuilderVolumeName: fmt.Sprintf("builder-storage_%s", runID),
SecurityListKey: "security_list_builder",
2018-09-06 01:44:31 -04:00
},
&stepAttachVolume{
VolumeName: fmt.Sprintf("master-storage_%s", runID),
Index: 2,
InstanceInfoKey: "builder_instance_info",
},
2018-10-26 18:47:49 -04:00
&stepConnectBuilder{
KeyName: fmt.Sprintf("packer-generated-key_%s", runID),
StepConnectSSH: &communicator.StepConnectSSH{
Config: &b.config.BuilderComm,
Host: communicator.CommHost(b.config.Comm.SSHHost, "instance_ip"),
2018-10-26 18:47:49 -04:00
SSHConfig: b.config.BuilderComm.SSHConfigFunc(),
},
},
2018-10-20 17:11:11 -04:00
&stepUploadImage{
UploadImageCommand: b.config.BuilderUploadImageCommand,
2018-09-12 20:12:35 -04:00
},
2018-10-20 17:11:11 -04:00
&stepCreateImage{},
2018-10-20 01:51:58 -04:00
&stepListImages{},
2018-09-27 02:12:13 -04:00
&common.StepCleanupTempKeys{
Comm: &b.config.Comm,
},
}
} else {
// Build the steps
steps = []multistep.Step{
&ocommon.StepKeyPair{
Debug: b.config.PackerDebug,
Comm: &b.config.Comm,
DebugKeyPath: fmt.Sprintf("oci_classic_%s.pem", b.config.PackerBuildName),
},
&stepCreateIPReservation{},
&stepAddKeysToAPI{
2018-10-26 18:47:49 -04:00
Skip: b.config.Comm.Type != "ssh",
KeyName: fmt.Sprintf("packer-generated-key_%s", runID),
},
&stepSecurity{
SecurityListKey: "security_list",
CommType: b.config.Comm.Type,
},
&stepCreateInstance{},
&communicator.StepConnect{
Config: &b.config.Comm,
2019-07-03 16:34:23 -04:00
Host: communicator.CommHost(b.config.Comm.SSHHost, "instance_ip"),
SSHConfig: b.config.Comm.SSHConfigFunc(),
},
&common.StepProvision{},
&common.StepCleanupTempKeys{
Comm: &b.config.Comm,
},
&stepSnapshot{},
&stepListImages{},
}
2018-01-12 17:12:15 -05:00
}
// Run the steps
b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
b.runner.Run(ctx, state)
2018-01-12 17:12:15 -05:00
// If there was an error, return that
if rawErr, ok := state.GetOk("error"); ok {
return nil, rawErr.(error)
}
// If there is no snapshot, then just return
if _, ok := state.GetOk("machine_image_name"); !ok {
return nil, nil
}
2018-01-23 21:13:51 -05:00
// Build the artifact and return it
artifact := &Artifact{
2018-01-31 13:47:19 -05:00
ImageListVersion: state.Get("image_list_version").(int),
MachineImageName: state.Get("machine_image_name").(string),
MachineImageFile: state.Get("machine_image_file").(string),
2018-01-23 21:13:51 -05:00
}
2018-01-12 17:12:15 -05:00
2018-01-23 21:13:51 -05:00
return artifact, nil
2018-01-12 17:12:15 -05:00
}
// Cancel terminates a running build.