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)
}
}
}
func (s *StepUploadCertificate) Run(state multistep.StateBag) multistep.StepAction {
client := state.Get(constants.RequestManager).(management.Client)
ui := state.Get("ui").(packer.Ui)
errorMsg := "Error Uploading Temporary Certificate: %s"
var err error
ui.Say("Uploading Temporary Certificate...")
certData := []byte(state.Get(constants.Certificate).(string))
if err = retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return hostedservice.NewClient(client).AddCertificate(s.TmpServiceName, certData, hostedservice.CertificateFormatPfx, "")
}); err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
state.Put(constants.CertUploaded, 1)
return multistep.ActionContinue
}