github.phpd.cn/hashicorp/packer@v1.3.2/builder/alicloud/ecs/step_create_instance.go (about)

     1  package ecs
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"log"
     8  
     9  	"github.com/denverdino/aliyungo/common"
    10  	"github.com/denverdino/aliyungo/ecs"
    11  	"github.com/hashicorp/packer/helper/multistep"
    12  	"github.com/hashicorp/packer/packer"
    13  )
    14  
    15  type stepCreateAlicloudInstance struct {
    16  	IOOptimized             bool
    17  	InstanceType            string
    18  	UserData                string
    19  	UserDataFile            string
    20  	instanceId              string
    21  	RegionId                string
    22  	InternetChargeType      string
    23  	InternetMaxBandwidthOut int
    24  	InstanceName            string
    25  	ZoneId                  string
    26  	instance                *ecs.InstanceAttributesType
    27  }
    28  
    29  func (s *stepCreateAlicloudInstance) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
    30  	client := state.Get("client").(*ecs.Client)
    31  	config := state.Get("config").(*Config)
    32  	ui := state.Get("ui").(packer.Ui)
    33  	source_image := state.Get("source_image").(*ecs.ImageType)
    34  	network_type := state.Get("networktype").(InstanceNetWork)
    35  	securityGroupId := state.Get("securitygroupid").(string)
    36  	var instanceId string
    37  	var err error
    38  
    39  	ioOptimized := ecs.IoOptimizedNone
    40  	if s.IOOptimized {
    41  		ioOptimized = ecs.IoOptimizedOptimized
    42  	}
    43  	password := config.Comm.SSHPassword
    44  	if password == "" && config.Comm.WinRMPassword != "" {
    45  		password = config.Comm.WinRMPassword
    46  	}
    47  	ui.Say("Creating instance.")
    48  	if network_type == VpcNet {
    49  		userData, err := s.getUserData(state)
    50  		if err != nil {
    51  			state.Put("error", err)
    52  			ui.Error(err.Error())
    53  			return multistep.ActionHalt
    54  		}
    55  		vswitchId := state.Get("vswitchid").(string)
    56  		instanceId, err = client.CreateInstance(&ecs.CreateInstanceArgs{
    57  			RegionId:                common.Region(s.RegionId),
    58  			ImageId:                 source_image.ImageId,
    59  			InstanceType:            s.InstanceType,
    60  			InternetChargeType:      common.InternetChargeType(s.InternetChargeType), //"PayByTraffic",
    61  			InternetMaxBandwidthOut: s.InternetMaxBandwidthOut,
    62  			UserData:                userData,
    63  			IoOptimized:             ioOptimized,
    64  			VSwitchId:               vswitchId,
    65  			SecurityGroupId:         securityGroupId,
    66  			InstanceName:            s.InstanceName,
    67  			Password:                password,
    68  			ZoneId:                  s.ZoneId,
    69  			DataDisk:                diskDeviceToDiskType(config.AlicloudImageConfig.ECSImagesDiskMappings),
    70  		})
    71  		if err != nil {
    72  			err := fmt.Errorf("Error creating instance: %s", err)
    73  			state.Put("error", err)
    74  			ui.Error(err.Error())
    75  			return multistep.ActionHalt
    76  		}
    77  	} else {
    78  		if s.InstanceType == "" {
    79  			s.InstanceType = "PayByTraffic"
    80  		}
    81  		if s.InternetMaxBandwidthOut == 0 {
    82  			s.InternetMaxBandwidthOut = 5
    83  		}
    84  		instanceId, err = client.CreateInstance(&ecs.CreateInstanceArgs{
    85  			RegionId:                common.Region(s.RegionId),
    86  			ImageId:                 source_image.ImageId,
    87  			InstanceType:            s.InstanceType,
    88  			InternetChargeType:      common.InternetChargeType(s.InternetChargeType), //"PayByTraffic",
    89  			InternetMaxBandwidthOut: s.InternetMaxBandwidthOut,
    90  			IoOptimized:             ioOptimized,
    91  			SecurityGroupId:         securityGroupId,
    92  			InstanceName:            s.InstanceName,
    93  			Password:                password,
    94  			ZoneId:                  s.ZoneId,
    95  			DataDisk:                diskDeviceToDiskType(config.AlicloudImageConfig.ECSImagesDiskMappings),
    96  		})
    97  		if err != nil {
    98  			err := fmt.Errorf("Error creating instance: %s", err)
    99  			state.Put("error", err)
   100  			ui.Error(err.Error())
   101  			return multistep.ActionHalt
   102  		}
   103  	}
   104  	err = client.WaitForInstance(instanceId, ecs.Stopped, ALICLOUD_DEFAULT_TIMEOUT)
   105  	if err != nil {
   106  		err := fmt.Errorf("Error creating instance: %s", err)
   107  		state.Put("error", err)
   108  		ui.Error(err.Error())
   109  		return multistep.ActionHalt
   110  	}
   111  	instance, err := client.DescribeInstanceAttribute(instanceId)
   112  	if err != nil {
   113  		ui.Say(err.Error())
   114  		return multistep.ActionHalt
   115  	}
   116  	s.instance = instance
   117  	state.Put("instance", instance)
   118  
   119  	return multistep.ActionContinue
   120  }
   121  
   122  func (s *stepCreateAlicloudInstance) Cleanup(state multistep.StateBag) {
   123  	if s.instance == nil {
   124  		return
   125  	}
   126  	message(state, "instance")
   127  	client := state.Get("client").(*ecs.Client)
   128  	ui := state.Get("ui").(packer.Ui)
   129  	err := client.DeleteInstance(s.instance.InstanceId)
   130  	if err != nil {
   131  		ui.Say(fmt.Sprintf("Failed to clean up instance %s: %v", s.instance.InstanceId, err.Error()))
   132  	}
   133  
   134  }
   135  
   136  func (s *stepCreateAlicloudInstance) getUserData(state multistep.StateBag) (string, error) {
   137  	userData := s.UserData
   138  	if s.UserDataFile != "" {
   139  		data, err := ioutil.ReadFile(s.UserDataFile)
   140  		if err != nil {
   141  			return "", err
   142  		}
   143  		userData = string(data)
   144  	}
   145  	log.Printf(userData)
   146  	return userData, nil
   147  
   148  }
   149  
   150  func diskDeviceToDiskType(diskDevices []AlicloudDiskDevice) []ecs.DataDiskType {
   151  	result := make([]ecs.DataDiskType, len(diskDevices))
   152  	for _, diskDevice := range diskDevices {
   153  		result = append(result, ecs.DataDiskType{
   154  			DiskName:           diskDevice.DiskName,
   155  			Category:           ecs.DiskCategory(diskDevice.DiskCategory),
   156  			Size:               diskDevice.DiskSize,
   157  			SnapshotId:         diskDevice.SnapshotId,
   158  			Description:        diskDevice.Description,
   159  			DeleteWithInstance: diskDevice.DeleteWithInstance,
   160  			Device:             diskDevice.Device,
   161  		})
   162  	}
   163  	return result
   164  }