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 (*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 *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 *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
}
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...")
if err := retry.ExecuteAsyncOperation(client, func() (management.OperationID, error) {
return vm.NewClient(client).CaptureRole(s.TmpServiceName, s.TmpVmName, s.TmpVmName,
s.UserImageName, s.UserImageLabel, nil)
}); 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
}