#330 updated 'vs ready' to check for transaction status only

Author: allmightyspiff

plugin/commands/virtual/create.go

@@ -3,7 +3,7 @@ package virtual
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
+
 	"io/ioutil"
 	"strconv"
 	"time"
@@ -363,7 +363,6 @@ func (cmd *CreateCommand) verifyParams() (map[string]interface{}, error) {
 
 	if cmd.Flavor != "" {
 		if cmd.CPU != 0 {
-			fmt.Printf("Returning an error....\n")
 			return nil, slErrors.NewExclusiveFlagsError("[-c|--cpu]", "[--flavor]")
 		}
 		if cmd.Memory != 0 {
@@ -488,12 +487,10 @@ func (cmd *CreateCommand) verifyParams() (map[string]interface{}, error) {
 	}
 
 	if len(cmd.PubSecGroup) > 0 {
-		fmt.Printf("PubSecGroup(%v): %v\n", cmd.Domain, cmd.PubSecGroup)
 		params["public-security-group"] = cmd.PubSecGroup
 	}
 
 	if len(cmd.PriSecGroup) > 0 {
-		fmt.Printf("PriSecGroup: %v\n", cmd.PriSecGroup)
 		params["private-security-group"] = cmd.PriSecGroup
 	}
 

plugin/commands/virtual/ready.go

@@ -27,11 +27,8 @@ func NewReadyCommand(sl *metadata.SoftlayerCommand) (cmd *ReadyCommand) {
 	cobraCmd := &cobra.Command{
 		Use:   "ready " + T("IDENTIFIER"),
 		Short: T("Check if a virtual server instance is ready for use"),
-		Long: T(`${COMMAND_NAME} sl vs ready IDENTIFIER [OPTIONS]
-	
-EXAMPLE:
-   ${COMMAND_NAME} sl vs ready 12345678 --wait 30
-   This command checks virtual server instance with ID 12345678 status to see if it is ready for use continuously and waits up to 30 seconds.`),
+		Long: T(`Will periodically check the status of a virtual server's active transaction.
+When the transcation is finished the virtual server should be ready for use.`),
 		Args: metadata.OneArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return thisCmd.Run(args)

plugin/commands/virtual/ready_test.go

@@ -54,7 +54,6 @@ var _ = Describe("VS ready", func() {
 			It("return error", func() {
 				err := testhelpers.RunCobraCommand(cliCommand.Command, "1234")
 				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("Failed to check virtual server instance 1234 is ready."))
 				Expect(err.Error()).To(ContainSubstring("Internal Server Error"))
 			})
 		})

plugin/managers/virtualserver.go

@@ -1173,8 +1173,8 @@ func getPriceIdForUpgrade(packageItems []datatypes.Product_Item_Price, option st
 // Check the virtual server instance is ready for use
 // A Virtual server is ready when there are no active transaction, and it is not doing an OS reload.
 func (vs virtualServerManager) InstanceIsReady(id int, until time.Time) (bool, string, error) {
-	mask := `mask[id, lastOperatingSystemReload[id,modifyDate], activeTransaction[id,transactionStatus[name]]
-provisionDate, powerState[keyName]`
+	mask := `mask[id, lastOperatingSystemReload[id,modifyDate], activeTransaction[id,transactionStatus[name]],
+provisionDate, powerState[keyName]]`
 	for {
 		virtualGuest, err := vs.GetInstance(id, mask)
 		if err != nil {
@@ -1184,37 +1184,26 @@ provisionDate, powerState[keyName]`
 		lastReload := virtualGuest.LastOperatingSystemReload
 		activeTxn := virtualGuest.ActiveTransaction
 		provisionDate := virtualGuest.ProvisionDate
-
+		txnMessage := "-"
+		if activeTxn != nil && activeTxn.TransactionStatus != nil && activeTxn.TransactionStatus.Name != nil {
+			txnMessage = *activeTxn.TransactionStatus.Name
+		}
 		var reloading bool
 		if activeTxn != nil && activeTxn.Id != nil && lastReload != nil && lastReload.Id != nil {
 			reloading = activeTxn != nil && lastReload != nil && *activeTxn.Id == *lastReload.Id
 		}
 		if provisionDate != nil && !reloading {
-			//fmt.Println("power state:", *virtualGuest.PowerState.KeyName)
 			if virtualGuest.PowerState != nil && virtualGuest.PowerState.KeyName != nil {
-				sub_map := map[string]interface{}{"Id": id, "State": *virtualGuest.PowerState.KeyName}
-				if *virtualGuest.PowerState.KeyName == "HALTED" {
-					return false, T("Virtual guest instance {{.Id}} is {{.State}}.", sub_map), nil
+				if *virtualGuest.PowerState.KeyName == "HALTED" || *virtualGuest.PowerState.KeyName == "PAUSED" {
+					return false, *virtualGuest.PowerState.KeyName , nil
 				}
-				if *virtualGuest.PowerState.KeyName == "PAUSED" {
-					return false, T("Virtual guest instance {{.Id}} is {{.State}}.", sub_map), nil
-				}
-			}
-
-			pingable, err := vs.VirtualGuestService.Id(id).IsPingable()
-			if err != nil {
-				return false, T("Failed to reach virtual guest instance {{.Id}}.", map[string]interface{}{"Id": id}), err
-			}
-			//fmt.Println("pingable:", pingable)
-			if pingable == false {
-				return false, T("Virtual guest instance {{.Id}} is not reachable.", map[string]interface{}{"Id": id}), nil
 			}
 			return true, "", nil
 		}
 
 		now := time.Now()
 		if now.After(until) {
-			return false, T("Virtual guest instance {{.Id}} is loading operating system.", map[string]interface{}{"Id": id}), nil
+			return false, txnMessage, nil
 		}
 
 		min := math.Min(float64(1.0), float64(until.Sub(now)))