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 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 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 GetObjectDetailsOnStorage(softLayerClient sl.Client, volumeId int) (datatypes.SoftLayer_Network_Storage, error) { networkStorageService, err := softLayerClient.GetSoftLayer_Network_Storage_Service() if err != nil { return datatypes.SoftLayer_Network_Storage{}, bosherr.WrapError(err, "Cannot get network storage service.") } volume, err := networkStorageService.GetIscsiVolume(volumeId) if err != nil { return datatypes.SoftLayer_Network_Storage{}, bosherr.WrapErrorf(err, "Cannot get iSCSI volume with id: %d", volumeId) } return volume, 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 }
softlayer "github.com/maximilien/softlayer-go/softlayer" testhelpers "github.com/maximilien/softlayer-go/test_helpers" ) const configPath = "test_fixtures/cpi_methods/config.json" var _ = Describe("BOSH Director Level Integration for delete_stemcell", func() { var ( err error client softlayer.Client username, apiKey string vgbdtgService softlayer.SoftLayer_Virtual_Guest_Block_Device_Template_Group_Service configuration datatypes.SoftLayer_Container_Virtual_Guest_Block_Device_Template_Configuration rootTemplatePath, tmpConfigPath string virtual_disk_image_id int output map[string]interface{} replacementMap map[string]string ) BeforeEach(func() { username = os.Getenv("SL_USERNAME") Expect(username).ToNot(Equal(""), "username cannot be empty, set SL_USERNAME") apiKey = os.Getenv("SL_API_KEY") Expect(apiKey).ToNot(Equal(""), "apiKey cannot be empty, set SL_API_KEY")
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 }
package client_test import ( "os" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" slclient "github.com/maximilien/softlayer-go/client" softlayer "github.com/maximilien/softlayer-go/softlayer" ) var _ = Describe("SoftLayerClient", func() { var ( username string apiKey string client softlayer.Client ) BeforeEach(func() { username = os.Getenv("SL_USERNAME") apiKey = os.Getenv("SL_API_KEY") client = slclient.NewSoftLayerClient(username, apiKey) }) Context("#NewSoftLayerClient", func() { It("creates a new client with username and apiKey", func() { Expect(username).ToNot(Equal(""), "username cannot be empty, set SL_USERNAME") Expect(apiKey).ToNot(Equal(""), "apiKey cannot be empty, set SL_API_KEY")
"net" "net/http" "net/url" "os" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" slclient "github.com/maximilien/softlayer-go/client" softlayer "github.com/maximilien/softlayer-go/softlayer" ) var _ = Describe("SoftLayerClient", func() { var ( username string apiKey string client softlayer.Client ) BeforeEach(func() { username = os.Getenv("SL_USERNAME") apiKey = os.Getenv("SL_API_KEY") os.Setenv("NON_VERBOSE", "TRUE") client = slclient.NewSoftLayerClient(username, apiKey) }) Context("#NewSoftLayerClient", func() { It("creates a new client with username and apiKey", func() { Expect(username).ToNot(Equal(""), "username cannot be empty, set SL_USERNAME")