func CreateVirtualGuestTemplate(stemcell bslcstem.Stemcell, cloudProps VMCloudProperties) (sldatatypes.SoftLayer_Virtual_Guest_Template, error) {
virtualGuestTemplate := sldatatypes.SoftLayer_Virtual_Guest_Template{
Hostname: cloudProps.VmNamePrefix,
Domain: cloudProps.Domain,
StartCpus: cloudProps.StartCpus,
MaxMemory: cloudProps.MaxMemory,
Datacenter: sldatatypes.Datacenter{
Name: cloudProps.Datacenter.Name,
},
BlockDeviceTemplateGroup: &sldatatypes.BlockDeviceTemplateGroup{
GlobalIdentifier: stemcell.Uuid(),
},
SshKeys: cloudProps.SshKeys,
HourlyBillingFlag: cloudProps.HourlyBillingFlag,
LocalDiskFlag: cloudProps.LocalDiskFlag,
DedicatedAccountHostOnlyFlag: cloudProps.DedicatedAccountHostOnlyFlag,
BlockDevices: cloudProps.BlockDevices,
NetworkComponents: cloudProps.NetworkComponents,
PrivateNetworkOnlyFlag: cloudProps.PrivateNetworkOnlyFlag,
PrimaryNetworkComponent: &cloudProps.PrimaryNetworkComponent,
PrimaryBackendNetworkComponent: &cloudProps.PrimaryBackendNetworkComponent,
}
return virtualGuestTemplate, nil
}
func (vm SoftLayerVM) ReloadOS(stemcell bslcstem.Stemcell) error {
reload_OS_Config := sldatatypes.Image_Template_Config{
ImageTemplateId: strconv.Itoa(stemcell.ID()),
}
virtualGuestService, err := vm.softLayerClient.GetSoftLayer_Virtual_Guest_Service()
if err != nil {
return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client")
}
err = bslcommon.WaitForVirtualGuestToHaveNoRunningTransactions(vm.softLayerClient, vm.ID())
if err != nil {
return bosherr.WrapError(err, fmt.Sprintf("Waiting for VirtualGuest %d to have no pending transactions before os reload", vm.ID()))
}
vm.logger.Info(SOFTLAYER_VM_OS_RELOAD_TAG, fmt.Sprintf("No transaction is running on this VM %d", vm.ID()))
err = virtualGuestService.ReloadOperatingSystem(vm.ID(), reload_OS_Config)
if err != nil {
return bosherr.WrapError(err, "Failed to reload OS on the specified VirtualGuest from SoftLayer client")
}
err = vm.postCheckActiveTransactionsForOSReload(vm.softLayerClient)
if err != nil {
return err
}
return nil
}
func (c SoftLayerCreator) CreateNewVM(agentID string, stemcell bslcstem.Stemcell, cloudProps VMCloudProperties, networks Networks, env Environment) (VM, error) {
virtualGuestTemplate, err := CreateVirtualGuestTemplate(stemcell, cloudProps)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Creating virtual guest template")
}
virtualGuestService, err := c.softLayerClient.GetSoftLayer_Virtual_Guest_Service()
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client")
}
virtualGuest, err := virtualGuestService.CreateObject(virtualGuestTemplate)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Creating VirtualGuest from SoftLayer client")
}
if cloudProps.EphemeralDiskSize == 0 {
err = bslcommon.WaitForVirtualGuestLastCompleteTransaction(c.softLayerClient, virtualGuest.Id, "Service Setup")
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` has Service Setup transaction complete", virtualGuest.Id)
}
} else {
err = bslcommon.AttachEphemeralDiskToVirtualGuest(c.softLayerClient, virtualGuest.Id, cloudProps.EphemeralDiskSize, c.logger)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, fmt.Sprintf("Attaching ephemeral disk to VirtualGuest `%d`", virtualGuest.Id))
}
}
virtualGuest, err = bslcommon.GetObjectDetailsOnVirtualGuest(c.softLayerClient, virtualGuest.Id)
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Cannot get details from virtual guest with id: %d.", virtualGuest.Id)
}
softlayerFileService := NewSoftlayerFileService(util.GetSshClient(), virtualGuest, c.logger, c.uuidGenerator, c.fs)
agentEnvService := c.agentEnvServiceFactory.New(softlayerFileService, strconv.Itoa(virtualGuest.Id))
if len(cloudProps.BoshIp) == 0 {
// update /etc/hosts file of bosh-init vm
c.updateEtcHostsOfBoshInit(fmt.Sprintf("%s %s", virtualGuest.PrimaryBackendIpAddress, virtualGuest.FullyQualifiedDomainName))
// Update mbus url setting for bosh director: construct mbus url with new director ip
mbus, err := c.parseMbusURL(c.agentOptions.Mbus, virtualGuest.PrimaryBackendIpAddress)
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Cannot construct mbus url.")
}
c.agentOptions.Mbus = mbus
} else {
// Update mbus url setting
mbus, err := c.parseMbusURL(c.agentOptions.Mbus, cloudProps.BoshIp)
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Cannot construct mbus url.")
}
c.agentOptions.Mbus = mbus
// Update blobstore setting
switch c.agentOptions.Blobstore.Provider {
case BlobstoreTypeDav:
davConf := DavConfig(c.agentOptions.Blobstore.Options)
c.updateDavConfig(&davConf, cloudProps.BoshIp)
}
}
agentEnv := CreateAgentUserData(agentID, cloudProps, networks, env, c.agentOptions)
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Cannot agent env for virtual guest with id: %d.", virtualGuest.Id)
}
err = agentEnvService.Update(agentEnv)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Updating VM's agent env")
}
vm := NewSoftLayerVM(virtualGuest.Id, c.softLayerClient, util.GetSshClient(), agentEnvService, c.logger)
if strings.ToUpper(common.GetOSEnvVariable("OS_RELOAD_ENABLED", "TRUE")) == "TRUE" && !strings.Contains(cloudProps.VmNamePrefix, "-worker") {
db, err := bslcvmpool.OpenDB(bslcvmpool.SQLITE_DB_FILE_PATH)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Opening DB")
}
vmInfoDB := bslcvmpool.NewVMInfoDB(vm.ID(), virtualGuestTemplate.Hostname+"."+virtualGuestTemplate.Domain, "t", stemcell.Uuid(), agentID, c.logger, db)
err = vmInfoDB.InsertVMInfo(bslcvmpool.DB_RETRY_TIMEOUT, bslcvmpool.DB_RETRY_INTERVAL)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Failed to insert the record into VM pool DB")
}
}
if len(c.agentOptions.VcapPassword) > 0 {
err = c.SetVcapPassword(vm, virtualGuest, c.agentOptions.VcapPassword)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Updating VM's vcap password")
}
}
return vm, nil
}
func (c SoftLayerCreator) Create(agentID string, stemcell bslcstem.Stemcell, cloudProps VMCloudProperties, networks Networks, env Environment) (VM, error) {
if strings.ToUpper(common.GetOSEnvVariable("OS_RELOAD_ENABLED", "TRUE")) == "FALSE" {
return c.CreateNewVM(agentID, stemcell, cloudProps, networks, env)
}
err := bslcvmpool.InitVMPoolDB(bslcvmpool.DB_RETRY_TIMEOUT, bslcvmpool.DB_RETRY_INTERVAL, c.logger)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Failed to initialize VM pool DB")
}
if strings.Contains(cloudProps.VmNamePrefix, "-worker") {
vm, err := c.CreateNewVM(agentID, stemcell, cloudProps, networks, env)
return vm, err
}
db, err := bslcvmpool.OpenDB(bslcvmpool.SQLITE_DB_FILE_PATH)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Opening DB")
}
vmInfoDB := bslcvmpool.NewVMInfoDB(0, "", "f", "", agentID, c.logger, db)
defer vmInfoDB.CloseDB()
err = vmInfoDB.QueryVMInfobyAgentID(bslcvmpool.DB_RETRY_TIMEOUT, bslcvmpool.DB_RETRY_INTERVAL)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Failed to query VM info by given agent ID "+agentID)
}
if vmInfoDB.VmProperties.Id != 0 {
c.logger.Info(SOFTLAYER_VM_CREATOR_LOG_TAG, fmt.Sprintf("OS reload on the server id %d with stemcell %d", vmInfoDB.VmProperties.Id, stemcell.ID()))
vm := NewSoftLayerVM(vmInfoDB.VmProperties.Id, c.softLayerClient, util.GetSshClient(), nil, c.logger)
bslcommon.TIMEOUT = 2 * time.Hour
err = vm.ReloadOS(stemcell)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Failed to reload OS")
}
if cloudProps.EphemeralDiskSize == 0 {
err = bslcommon.WaitForVirtualGuestLastCompleteTransaction(c.softLayerClient, vmInfoDB.VmProperties.Id, "Service Setup")
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` has Service Setup transaction complete", vmInfoDB.VmProperties.Id)
}
} else {
err = bslcommon.AttachEphemeralDiskToVirtualGuest(c.softLayerClient, vmInfoDB.VmProperties.Id, cloudProps.EphemeralDiskSize, c.logger)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, fmt.Sprintf("Attaching ephemeral disk to VirtualGuest `%d`", vmInfoDB.VmProperties.Id))
}
}
virtualGuest, err := bslcommon.GetObjectDetailsOnVirtualGuest(c.softLayerClient, vmInfoDB.VmProperties.Id)
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Cannot get details from virtual guest with id: %d.", virtualGuest.Id)
}
softlayerFileService := NewSoftlayerFileService(util.GetSshClient(), virtualGuest, c.logger, c.uuidGenerator, c.fs)
agentEnvService := c.agentEnvServiceFactory.New(softlayerFileService, strconv.Itoa(virtualGuest.Id))
if len(cloudProps.BoshIp) == 0 {
// update /etc/hosts file of bosh-init vm
c.updateEtcHostsOfBoshInit(fmt.Sprintf("%s %s", virtualGuest.PrimaryBackendIpAddress, virtualGuest.FullyQualifiedDomainName))
// Update mbus url setting for bosh director: construct mbus url with new director ip
mbus, err := c.parseMbusURL(c.agentOptions.Mbus, virtualGuest.PrimaryBackendIpAddress)
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Cannot construct mbus url.")
}
c.agentOptions.Mbus = mbus
} else {
// Update mbus url setting
mbus, err := c.parseMbusURL(c.agentOptions.Mbus, cloudProps.BoshIp)
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Cannot construct mbus url.")
}
c.agentOptions.Mbus = mbus
// Update blobstore setting
switch c.agentOptions.Blobstore.Provider {
case BlobstoreTypeDav:
davConf := DavConfig(c.agentOptions.Blobstore.Options)
c.updateDavConfig(&davConf, cloudProps.BoshIp)
}
}
agentEnv := CreateAgentUserData(agentID, cloudProps, networks, env, c.agentOptions)
if err != nil {
return SoftLayerVM{}, bosherr.WrapErrorf(err, "Cannot agent env for virtual guest with id: %d.", virtualGuest.Id)
}
err = agentEnvService.Update(agentEnv)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Updating VM's agent env")
}
vm = NewSoftLayerVM(virtualGuest.Id, c.softLayerClient, util.GetSshClient(), agentEnvService, c.logger)
c.logger.Info(SOFTLAYER_VM_CREATOR_LOG_TAG, fmt.Sprintf("Updated in_use flag to 't' for the VM %d in VM pool", vmInfoDB.VmProperties.Id))
vmInfoDB.VmProperties.InUse = "t"
err = vmInfoDB.UpdateVMInfoByID(bslcvmpool.DB_RETRY_TIMEOUT, bslcvmpool.DB_RETRY_INTERVAL)
if err != nil {
return vm, bosherr.WrapError(err, fmt.Sprintf("Failed to query VM info by given ID %d", vm.ID()))
} else {
if len(c.agentOptions.VcapPassword) > 0 {
err = c.SetVcapPassword(vm, virtualGuest, c.agentOptions.VcapPassword)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Updating VM's vcap password")
}
}
return vm, nil
}
}
vmInfoDB.VmProperties.InUse = ""
err = vmInfoDB.QueryVMInfobyAgentID(bslcvmpool.DB_RETRY_TIMEOUT, bslcvmpool.DB_RETRY_INTERVAL)
if err != nil {
return SoftLayerVM{}, bosherr.WrapError(err, "Failed to query VM info by given agent ID "+agentID)
}
if vmInfoDB.VmProperties.Id != 0 {
return SoftLayerVM{}, bosherr.WrapError(err, "Wrong in_use status in VM with agent ID "+agentID+", Do not create a new VM")
} else {
return c.CreateNewVM(agentID, stemcell, cloudProps, networks, env)
}
}