github.com/mmcquillan/packer@v1.1.1-0.20171009221028-c85cf0483a5d/builder/alicloud/ecs/step_create_instance.go (about)

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