func WaitForVirtualGuestToHaveNoRunningTransaction(softLayerClient sl.Client, virtualGuestId int, logger boshlog.Logger) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } totalTime := time.Duration(0) for totalTime < TIMEOUT { activeTransactions, err := virtualGuestService.GetActiveTransactions(virtualGuestId) if err != nil { return bosherr.WrapErrorf(err, "Getting active transaction against vitrual guest %d", virtualGuestId) } if len(activeTransactions) == 0 { return nil } totalTime += POLLING_INTERVAL time.Sleep(POLLING_INTERVAL) } return bosherr.Errorf("Waiting for virtual guest with ID '%d' to have no active transactions", virtualGuestId) }
func WaitForVirtualGuest(softLayerClient sl.Client, virtualGuestId int, targetState string, timeout, pollingInterval time.Duration) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } retryCount := 0 totalTime := time.Duration(0) for totalTime < timeout { vgPowerState, err := virtualGuestService.GetPowerState(virtualGuestId) if err != nil { if retryCount > MAX_RETRY_COUNT { return bosherr.WrapError(err, "Getting active transactions from SoftLayer client") } else { retryCount += 1 continue } } if vgPowerState.KeyName == targetState { return nil } totalTime += pollingInterval time.Sleep(pollingInterval) } return bosherr.Errorf("Waiting for virtual guest with ID '%d' to have be in state '%s'", virtualGuestId, targetState) }
func WaitForVirtualGuestToTargetState(softLayerClient sl.Client, virtualGuestId int, targetState string, logger boshlog.Logger) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } getTargetStateRetryable := boshretry.NewRetryable( func() (bool, error) { vgPowerState, err := virtualGuestService.GetPowerState(virtualGuestId) if err != nil { return false, bosherr.WrapErrorf(err, "Getting PowerState from vitrual guest %d", virtualGuestId) } else { if strings.Contains(vgPowerState.KeyName, targetState) { return false, nil } return true, nil } }) timeService := clock.NewClock() timeoutRetryStrategy := boshretry.NewTimeoutRetryStrategy(TIMEOUT, POLLING_INTERVAL, getTargetStateRetryable, timeService, logger) err = timeoutRetryStrategy.Try() if err != nil { return bosherr.Errorf("Waiting for virtual guest with ID '%d' to have be in state '%s'", virtualGuestId, targetState) } return nil }
func WaitForVirtualGuestToHaveNoRunningTransactions(softLayerClient sl.Client, virtualGuestId int, timeout, pollingInterval time.Duration) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } retryCount := 0 totalTime := time.Duration(0) for totalTime < timeout { activeTransactions, err := virtualGuestService.GetActiveTransactions(virtualGuestId) if err != nil { if retryCount > MAX_RETRY_COUNT { return bosherr.WrapError(err, "Getting active transactions from SoftLayer client") } else { retryCount += 1 continue } } if len(activeTransactions) == 0 { return nil } totalTime += pollingInterval time.Sleep(pollingInterval) } return bosherr.Errorf("Waiting for virtual guest with ID '%d' to have no active transactions", virtualGuestId) }
func AttachEphemeralDiskToVirtualGuest(softLayerClient sl.Client, virtualGuestId int, diskSize int, logger boshlog.Logger) error { err := WaitForVirtualGuestLastCompleteTransaction(softLayerClient, virtualGuestId, "Service Setup") if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` has Service Setup transaction complete", virtualGuestId) } err = WaitForVirtualGuestToHaveNoRunningTransactions(softLayerClient, virtualGuestId) if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` to have no pending transactions", virtualGuestId) } service, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapErrorf(err, "Attaching ephemeral disk to VirtualGuest `%d`", virtualGuestId) } err = service.AttachEphemeralDisk(virtualGuestId, diskSize) if err != nil { return bosherr.WrapErrorf(err, "Attaching ephemeral disk to VirtualGuest `%d`", virtualGuestId) } err = WaitForVirtualGuestToHaveRunningTransaction(softLayerClient, virtualGuestId, logger) if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` to launch transaction", virtualGuestId) } err = WaitForVirtualGuestLastCompleteTransaction(softLayerClient, virtualGuestId, "Cloud Instance Upgrade") if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` has Cloud Instance Upgrade transaction complete", virtualGuestId) } return nil }
func WaitForVirtualGuestIsNotPingable(softLayerClient sl.Client, virtualGuestId int, logger boshlog.Logger) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } checkPingableRetryable := boshretry.NewRetryable( func() (bool, error) { state, err := virtualGuestService.IsPingable(virtualGuestId) if err != nil { return false, bosherr.WrapErrorf(err, "Checking pingable against vitrual guest %d", virtualGuestId) } else { return state, nil } }) timeService := clock.NewClock() timeoutRetryStrategy := boshretry.NewTimeoutRetryStrategy(TIMEOUT, POLLING_INTERVAL, checkPingableRetryable, timeService, logger) err = timeoutRetryStrategy.Try() if err != nil { return bosherr.Errorf("Waiting for virtual guest with ID '%d' is not pingable", virtualGuestId) } return nil }
func (vm SoftLayerVM) postCheckActiveTransactionsForOSReload(softLayerClient sl.Client) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } totalTime := time.Duration(0) for totalTime < bslcommon.TIMEOUT { activeTransactions, err := virtualGuestService.GetActiveTransactions(vm.ID()) if err != nil { return bosherr.WrapError(err, "Getting active transactions from SoftLayer client") } if len(activeTransactions) > 0 { vm.logger.Info(SOFTLAYER_VM_OS_RELOAD_TAG, "OS Reload transaction started") break } totalTime += bslcommon.POLLING_INTERVAL time.Sleep(bslcommon.POLLING_INTERVAL) } if totalTime >= bslcommon.TIMEOUT { return errors.New(fmt.Sprintf("Waiting for OS Reload transaction to start TIME OUT!")) } err = bslcommon.WaitForVirtualGuest(vm.softLayerClient, vm.ID(), "RUNNING") if err != nil { return bosherr.WrapError(err, fmt.Sprintf("PowerOn failed with VirtualGuest id %d", vm.ID())) } vm.logger.Info(SOFTLAYER_VM_OS_RELOAD_TAG, fmt.Sprintf("The virtual guest %d is powered on", vm.ID())) return nil }
func WaitForVirtualGuestToHaveNoRunningTransaction(softLayerClient sl.Client, virtualGuestId int, logger boshlog.Logger) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } runningTransactionsRetryable := boshretry.NewRetryable( func() (bool, error) { activeTransactions, err := virtualGuestService.GetActiveTransactions(virtualGuestId) if err != nil { return false, bosherr.WrapErrorf(err, "Getting active transaction against vitrual guest %d", virtualGuestId) } else { if len(activeTransactions) == 0 { return false, nil } return true, nil } }) timeService := clock.NewClock() timeoutRetryStrategy := boshretry.NewTimeoutRetryStrategy(TIMEOUT, POLLING_INTERVAL, runningTransactionsRetryable, timeService, logger) err = timeoutRetryStrategy.Try() if err != nil { return bosherr.Errorf("Waiting for virtual guest with ID '%d' to have no active transactions", virtualGuestId) } return nil }
func WaitForVirtualGuestUpgradeComplete(softLayerClient sl.Client, virtualGuestId int) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } totalTime := time.Duration(0) for totalTime < TIMEOUT { lastTransaction, err := virtualGuestService.GetLastTransaction(virtualGuestId) if err != nil { return bosherr.WrapErrorf(err, "Getting Last Complete Transaction for virtual guest with ID '%d'", virtualGuestId) } if strings.Contains(lastTransaction.TransactionGroup.Name, "Cloud Migrate") && strings.Contains(lastTransaction.TransactionStatus.FriendlyName, "Complete") { return nil } if strings.Contains(lastTransaction.TransactionGroup.Name, "Cloud Instance Upgrade") && strings.Contains(lastTransaction.TransactionStatus.FriendlyName, "Complete") { return nil } totalTime += POLLING_INTERVAL time.Sleep(POLLING_INTERVAL) } return bosherr.Errorf("Waiting for virtual guest with ID '%d' to update complete", virtualGuestId) }
func GetObjectDetailsOnVirtualGuest(softLayerClient sl.Client, virtualGuestId int) (datatypes.SoftLayer_Virtual_Guest, error) { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return datatypes.SoftLayer_Virtual_Guest{}, bosherr.WrapError(err, "Cannot get softlayer virtual guest service.") } virtualGuest, err := virtualGuestService.GetObject(virtualGuestId) if err != nil { return datatypes.SoftLayer_Virtual_Guest{}, bosherr.WrapErrorf(err, "Cannot get virtual guest with id: %d", virtualGuestId) } return virtualGuest, nil }
func ConfigureMetadataDiskOnVirtualGuest(softLayerClient sl.Client, virtualGuestId int) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } _, err = virtualGuestService.ConfigureMetadataDisk(virtualGuestId) if err != nil { return bosherr.WrapError(err, fmt.Sprintf("Configuring metadata on VirtualGuest `%d`", virtualGuestId)) } return nil }
func AttachEphemeralDiskToVirtualGuest(softLayerClient sl.Client, virtualGuestId int, diskSize int, logger boshlog.Logger) error { err := WaitForVirtualGuestLastCompleteTransaction(softLayerClient, virtualGuestId, "Service Setup") if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` has Service Setup transaction complete", virtualGuestId) } err = WaitForVirtualGuestToHaveNoRunningTransactions(softLayerClient, virtualGuestId) if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` to have no pending transactions", virtualGuestId) } service, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapErrorf(err, "Attaching ephemeral disk to VirtualGuest `%d`", virtualGuestId) } receipt, err := service.AttachEphemeralDisk(virtualGuestId, diskSize) if err != nil { if !strings.Contains(err.Error(), "HTTP error code") { return err } } if receipt.OrderId == 0 { return nil } err = WaitForVirtualGuestToHaveRunningTransaction(softLayerClient, virtualGuestId, logger) if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` to launch transaction", virtualGuestId) } err = WaitForVirtualGuestToHaveNoRunningTransaction(softLayerClient, virtualGuestId, logger) if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` no transcation in progress", virtualGuestId) } err = WaitForVirtualGuestUpgradeComplete(softLayerClient, virtualGuestId) if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d` upgrade complete", virtualGuestId) } err = WaitForVirtualGuest(softLayerClient, virtualGuestId, "RUNNING") if err != nil { return bosherr.WrapErrorf(err, "Waiting for VirtualGuest `%d`", virtualGuestId) } return nil }
func SetMetadataOnVirtualGuest(softLayerClient sl.Client, virtualGuestId int, metadata string) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } success, err := virtualGuestService.SetMetadata(virtualGuestId, metadata) if err != nil { return bosherr.WrapError(err, fmt.Sprintf("Setting metadata on VirtualGuest `%d`", virtualGuestId)) } if !success { return bosherr.WrapError(err, fmt.Sprintf("Failed to set metadata on VirtualGuest `%d`", virtualGuestId)) } return nil }
func WaitForVirtualGuest(softLayerClient sl.Client, virtualGuestId int, targetState string) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } totalTime := time.Duration(0) for totalTime < TIMEOUT { vgPowerState, err := virtualGuestService.GetPowerState(virtualGuestId) if err != nil { return bosherr.WrapErrorf(err, "Getting Power State for virtual guest with ID '%d'", virtualGuestId) } if strings.Contains(vgPowerState.KeyName, targetState) { return nil } totalTime += POLLING_INTERVAL time.Sleep(POLLING_INTERVAL) } return bosherr.Errorf("Waiting for virtual guest with ID '%d' to have be in state '%s'", virtualGuestId, targetState) }
func GetUserMetadataOnVirtualGuest(softLayerClient sl.Client, virtualGuestId int) ([]byte, error) { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return []byte{}, bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } attributes, err := virtualGuestService.GetUserData(virtualGuestId) if err != nil { return []byte{}, bosherr.WrapErrorf(err, "Getting metadata on VirtualGuest `%d`", virtualGuestId) } if len(attributes) == 0 { return []byte{}, bosherr.WrapErrorf(err, "Failed to get metadata on VirtualGuest `%d`", virtualGuestId) } sEnc := attributes[0].Value sDec, err := base64.StdEncoding.DecodeString(sEnc) if err != nil { return []byte{}, bosherr.WrapErrorf(err, "Failed to decode metadata returned from virtualGuest `%d`", virtualGuestId) } return sDec, nil }
func AttachEphemeralDiskToVirtualGuest(softLayerClient sl.Client, virtualGuestId int, diskSize int, timeout, pollingInterval time.Duration) error { err := WaitForVirtualGuest(softLayerClient, virtualGuestId, "RUNNING", timeout, pollingInterval) if err != nil { return bosherr.WrapError(err, fmt.Sprintf("Waiting for VirtualGuest `%d`", virtualGuestId)) } err = WaitForVirtualGuestToHaveNoRunningTransactions(softLayerClient, virtualGuestId, timeout, pollingInterval) if err != nil { return bosherr.WrapError(err, fmt.Sprintf("Waiting for VirtualGuest `%d` to have no pending transactions", virtualGuestId)) } service, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, fmt.Sprintf("Attaching ephemeral disk to VirtualGuest `%d`", virtualGuestId)) } err = service.AttachEphemeralDisk(virtualGuestId, diskSize) if err != nil { return bosherr.WrapError(err, fmt.Sprintf("Attaching ephemeral disk to VirtualGuest `%d`", virtualGuestId)) } return nil }
func (vm SoftLayerVM) postCheckActiveTransactionsForDeleteVM(softLayerClient sl.Client, virtualGuestId int) error { virtualGuestService, err := softLayerClient.GetSoftLayer_Virtual_Guest_Service() if err != nil { return bosherr.WrapError(err, "Creating VirtualGuestService from SoftLayer client") } totalTime := time.Duration(0) for totalTime < bslcommon.TIMEOUT { activeTransactions, err := virtualGuestService.GetActiveTransactions(virtualGuestId) if err != nil { return bosherr.WrapError(err, "Getting active transactions from SoftLayer client") } if len(activeTransactions) > 0 { vm.logger.Info(SOFTLAYER_VM_LOG_TAG, "Delete VM transaction started", nil) break } totalTime += bslcommon.POLLING_INTERVAL time.Sleep(bslcommon.POLLING_INTERVAL) } if totalTime >= bslcommon.TIMEOUT { return errors.New(fmt.Sprintf("Waiting for DeleteVM transaction to start TIME OUT!")) } totalTime = time.Duration(0) for totalTime < bslcommon.TIMEOUT { vm1, err := virtualGuestService.GetObject(virtualGuestId) if err != nil || vm1.Id == 0 { vm.logger.Info(SOFTLAYER_VM_LOG_TAG, "VM doesn't exist. Delete done", nil) break } activeTransaction, err := virtualGuestService.GetActiveTransaction(virtualGuestId) if err != nil { return bosherr.WrapError(err, "Getting active transactions from SoftLayer client") } averageDuration := activeTransaction.TransactionStatus.AverageDuration if strings.HasPrefix(averageDuration, ".") || averageDuration == "" { averageDuration = "0" + averageDuration } averageTransactionDuration, err := strconv.ParseFloat(averageDuration, 32) if err != nil { averageTransactionDuration = 0 } if averageTransactionDuration > 30 { vm.logger.Info(SOFTLAYER_VM_LOG_TAG, "Deleting VM instance had been launched and it is a long transaction. Please check Softlayer Portal", nil) break } vm.logger.Info(SOFTLAYER_VM_LOG_TAG, "This is a short transaction, waiting for all active transactions to complete", nil) totalTime += bslcommon.POLLING_INTERVAL time.Sleep(bslcommon.POLLING_INTERVAL) } if totalTime >= bslcommon.TIMEOUT { return errors.New(fmt.Sprintf("After deleting a vm, waiting for active transactions to complete TIME OUT!")) } return nil }
}) }) Context("#GetSoftLayer_Account_Service", func() { It("returns a instance implemementing the SoftLayer_Account_Service interface", func() { var accountService softlayer.SoftLayer_Account_Service accountService, err := client.GetSoftLayer_Account_Service() Expect(err).ToNot(HaveOccurred()) Expect(accountService).ToNot(BeNil()) }) }) Context("#GetSoftLayer_Virtual_Guest_Service", func() { It("returns a instance implemementing the SoftLayer_Virtual_Guest_Service interface", func() { var virtualGuestService softlayer.SoftLayer_Virtual_Guest_Service virtualGuestService, err := client.GetSoftLayer_Virtual_Guest_Service() Expect(err).ToNot(HaveOccurred()) Expect(virtualGuestService).ToNot(BeNil()) }) }) Context("#GetSoftLayer_Ssh_Key_Service", func() { It("returns a instance implemementing the SoftLayer_Ssh_Key_Service interface", func() { var sshKeyService softlayer.SoftLayer_Security_Ssh_Key_Service sshKeyService, err := client.GetSoftLayer_Security_Ssh_Key_Service() Expect(err).ToNot(HaveOccurred()) Expect(sshKeyService).ToNot(BeNil()) }) }) Context("#GetSoftLayer_Product_Order_Service", func() {