117 lines
3.2 KiB
Go
117 lines
3.2 KiB
Go
package chroot
|
|
|
|
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"
|
|
)
|
|
|
|
// 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)
|
|
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
|
|
rootDeviceName string
|
|
)
|
|
|
|
if config.FromScratch {
|
|
mappings = config.OMIBlockDevices.BuildOscOMIDevices()
|
|
rootDeviceName = config.RootDeviceName
|
|
} else {
|
|
image = state.Get("source_image").(osc.Image)
|
|
mappings = image.BlockDeviceMappings
|
|
rootDeviceName = image.RootDeviceName
|
|
}
|
|
|
|
newMappings := make([]osc.BlockDeviceMappingImage, len(mappings))
|
|
for i, device := range mappings {
|
|
newDevice := device
|
|
|
|
//FIX: Temporary fix
|
|
gibSize := newDevice.Bsu.VolumeSize / (1024 * 1024 * 1024)
|
|
newDevice.Bsu.VolumeSize = gibSize
|
|
|
|
if newDevice.DeviceName == rootDeviceName {
|
|
if newDevice.Bsu != (osc.BsuToCreate{}) {
|
|
newDevice.Bsu.SnapshotId = snapshotId
|
|
} else {
|
|
newDevice.Bsu = osc.BsuToCreate{SnapshotId: snapshotId}
|
|
}
|
|
|
|
if config.FromScratch || int32(s.RootVolumeSize) > newDevice.Bsu.VolumeSize {
|
|
newDevice.Bsu.VolumeSize = int32(s.RootVolumeSize)
|
|
}
|
|
}
|
|
|
|
newMappings[i] = newDevice
|
|
}
|
|
|
|
if config.FromScratch {
|
|
registerOpts = osc.CreateImageRequest{
|
|
ImageName: config.OMIName,
|
|
Architecture: "x86_64",
|
|
RootDeviceName: rootDeviceName,
|
|
BlockDeviceMappings: newMappings,
|
|
}
|
|
} else {
|
|
registerOpts = buildRegisterOpts(config, image, newMappings)
|
|
}
|
|
|
|
registerResp, _, err := osconn.ImageApi.CreateImage(context.Background(), &osc.CreateImageOpts{
|
|
CreateImageRequest: optional.NewInterface(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
|
|
|
|
// Set the OMI ID in the state
|
|
ui.Say(fmt.Sprintf("OMI: %s", imageID))
|
|
omis := make(map[string]string)
|
|
omis[s.RawRegion] = imageID
|
|
state.Put("omis", omis)
|
|
|
|
ui.Say("Waiting for OMI to become ready...")
|
|
if err := osccommon.WaitUntilOscImageAvailable(osconn, imageID); err != nil {
|
|
err := fmt.Errorf("Error waiting for OMI: %s", err)
|
|
state.Put("error", err)
|
|
ui.Error(err.Error())
|
|
return multistep.ActionHalt
|
|
}
|
|
|
|
return multistep.ActionContinue
|
|
}
|
|
|
|
func (s *StepCreateOMI) Cleanup(state multistep.StateBag) {}
|
|
|
|
func buildRegisterOpts(config *Config, image osc.Image, mappings []osc.BlockDeviceMappingImage) osc.CreateImageRequest {
|
|
registerOpts := osc.CreateImageRequest{
|
|
ImageName: config.OMIName,
|
|
Architecture: image.Architecture,
|
|
RootDeviceName: image.RootDeviceName,
|
|
BlockDeviceMappings: mappings,
|
|
}
|
|
return registerOpts
|
|
}
|