func (*StepCreateVm) Run(state multistep.StateBag) multistep.StepAction {
client := state.Get(constants.RequestManager).(management.Client)
ui := state.Get("ui").(packer.Ui)
config := state.Get(constants.Config).(*Config)
errorMsg := "Error Creating Temporary Azure VM: %s"
ui.Say("Creating Temporary Azure VM...")
role := state.Get("role").(*vm.Role)
options := vm.CreateDeploymentOptions{}
if config.VNet != "" && config.Subnet != "" {
options.VirtualNetworkName = config.VNet
}
if err := retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return vm.NewClient(client).CreateDeployment(*role, config.tmpServiceName, options)
}); err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
state.Put(constants.VmExists, 1)
state.Put(constants.DiskExists, 1)
return multistep.ActionContinue
}
func (s *StepCreateVm) Run(state multistep.StateBag) multistep.StepAction {
client := state.Get(constants.RequestManager).(management.Client)
ui := state.Get("ui").(packer.Ui)
errorMsg := "Error creating temporary Azure VM: %s"
ui.Say("Creating temporary Azure VM...")
osImageName := state.Get(constants.OSImageName).(string)
if len(osImageName) == 0 {
err := fmt.Errorf(errorMsg, fmt.Errorf("osImageName is empty"))
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
isOSImage := state.Get(constants.IsOSImage).(bool)
mediaLoc := fmt.Sprintf("https://%s.blob.core.windows.net/%s/%s.vhd", s.StorageAccount, s.StorageContainer, s.TmpVmName)
role := createRole(isOSImage, s.TmpVmName, s.InstanceSize, s.Username, s.Password, osImageName, mediaLoc)
if err := retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return vm.NewClient(client).CreateDeployment(role, s.TmpServiceName, vm.CreateDeploymentOptions{})
}); err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
state.Put(constants.VmExists, 1)
state.Put(constants.DiskExists, 1)
return multistep.ActionContinue
}
func (c *comm) updateRoleResourceExtension(
nameOfReference, nameOfPublisher, nameOfExtension, versionOfExtension, state string,
params []vm.ResourceExtensionParameter) error {
client := c.config.ManagementClient
serviceName := c.config.ServiceName
vmName := c.config.VmName
log.Println("Updating Role Resource Extension...")
role := vm.Role{}
vmutils.AddAzureVMExtensionConfiguration(&role,
nameOfExtension, nameOfPublisher, versionOfExtension, nameOfReference, state, []byte{}, []byte{})
// HACK-paulmey: clean up later
(*role.ResourceExtensionReferences)[0].ParameterValues = params
if err := retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return vm.NewClient(client).UpdateRole(serviceName, vmName, vmName, role)
}); err != nil {
return err
}
return nil
}
func (s *StepCreateImage) Run(state multistep.StateBag) multistep.StepAction {
client := state.Get(constants.RequestManager).(management.Client)
ui := state.Get(constants.Ui).(packer.Ui)
errorMsg := "Error Creating Azure Image: %s"
ui.Say("Creating Azure Image. If Successful, This Will Remove the Temporary VM...")
description := "packer made image"
imageFamily := "PackerMade"
if err := retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return vmi.NewClient(client).Capture(s.TmpServiceName, s.TmpVmName, s.TmpVmName,
s.UserImageName, s.UserImageLabel, vmi.OSStateGeneralized, vmi.CaptureParameters{
Description: description,
ImageFamily: imageFamily,
RecommendedVMSize: s.RecommendedVMSize,
})
}); err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
// CatpureVMImage removes the VM
state.Put(constants.ImageCreated, 1)
state.Put(constants.VmExists, 0)
return multistep.ActionContinue
}
func (s *StepCreateService) Cleanup(state multistep.StateBag) {
client := state.Get(constants.RequestManager).(management.Client)
hsc := hostedservice.NewClient(client)
ui := state.Get(constants.Ui).(packer.Ui)
if res := state.Get(constants.SrvExists).(int); res == 1 {
ui.Say("Removing temporary Azure service and its deployments, if any...")
errorMsg := "Error removing temporary Azure service: %s"
if err := retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return hsc.DeleteHostedService(s.TmpServiceName, true)
}); err != nil {
ui.Error(fmt.Sprintf(errorMsg, err))
return
}
}
}
func (s *StepStopVm) Run(state multistep.StateBag) multistep.StepAction {
client := state.Get(constants.RequestManager).(management.Client)
ui := state.Get(constants.Ui).(packer.Ui)
errorMsg := "Error Stopping Temporary Azure VM: %s"
ui.Say("Stopping Temporary Azure VM...")
if err := retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return vm.NewClient(client).ShutdownRole(s.TmpServiceName, s.TmpVmName, s.TmpVmName)
}); err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
state.Put(constants.VmRunning, 0)
return multistep.ActionContinue
}
func (s *StepCreateImage) Cleanup(state multistep.StateBag) {
client := state.Get(constants.RequestManager).(management.Client)
ui := state.Get(constants.Ui).(packer.Ui)
var err error
var res int
if res = state.Get(constants.VmExists).(int); res == 1 { //VM was not removed at image creation step
return
}
// Since VM was successfully removed - remove it's media as well
if res = state.Get(constants.DiskExists).(int); res == 1 {
ui.Message("Removing Temporary Azure Disk...")
errorMsg := "Error Removing Temporary Azure Disk: %s"
diskName, ok := state.Get(constants.HardDiskName).(string)
if ok {
if len(diskName) == 0 {
err := fmt.Errorf(errorMsg, err)
ui.Error(err.Error())
return
}
if err := retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return vmdisk.NewClient(client).DeleteDisk(diskName, true)
}, retry.ConstantBackoffRule("busy", func(err management.AzureError) bool {
return strings.Contains(err.Message, "is currently performing an operation on deployment") ||
strings.Contains(err.Message, "is currently in use by virtual machine")
}, 30*time.Second, 10)); err != nil {
err := fmt.Errorf(errorMsg, err)
ui.Error(err.Error())
return
}
state.Put(constants.DiskExists, 0)
}
}
}