Merge pull request #58 from scaleway/fix-57

Fix 57

Author: moul

api.go

@@ -380,10 +380,23 @@ type ScalewayServer struct {
 	Organization string `json:"organization,omitempty"`
 }
 
-// ScalewayServerPathNameDefinition represents a Scaleway C1 server with only its name as field
-type ScalewayServerPathNameDefinition struct {
-	// Name is the user-defined name of the server
-	Name string `json:"name"`
+// ScalewayServerPatchDefinition represents a Scaleway C1 server with nullable fields (for PATCH)
+type ScalewayServerPatchDefinition struct {
+	Name              *string                    `json:"name,omitempty"`
+	CreationDate      *string                    `json:"creation_date,omitempty"`
+	ModificationDate  *string                    `json:"modification_date,omitempty"`
+	Image             *ScalewayImage             `json:"image,omitempty"`
+	DynamicIPRequired *bool                      `json:"dynamic_ip_required,omitempty"`
+	PublicAddress     *ScalewayIPAddress         `json:"public_ip,omitempty"`
+	State             *string                    `json:"state,omitempty"`
+	StateDetail       *string                    `json:"state_detail,omitempty"`
+	PrivateIP         *string                    `json:"private_ip,omitempty"`
+	Bootscript        *ScalewayBootscript        `json:"bootscript,omitempty"`
+	Hostname          *string                    `json:"hostname,omitempty"`
+	Volumes           *map[string]ScalewayVolume `json:"volumes,omitempty"`
+	SecurityGroup     *ScalewaySecurityGroup     `json:"security_group,omitempty"`
+	Organization      *string                    `json:"organization,omitempty"`
+	//Tags            *[]string                  `json:"tags",omitempty`
 }
 
 // ScalewayServerDefinition represents a Scaleway C1 server with image definition
@@ -682,8 +695,8 @@ func (s *ScalewayAPI) PostServer(definition ScalewayServerDefinition) (string, e
 	return "", error
 }
 
-// PatchServerName changes the name of the server
-func (s *ScalewayAPI) PatchServerName(serverID string, definition ScalewayServerPathNameDefinition) error {
+// PatchServer updates a server
+func (s *ScalewayAPI) PatchServer(serverID string, definition ScalewayServerPatchDefinition) error {
 	resp, err := s.PatchResponse(fmt.Sprintf("servers/%s", serverID), definition)
 	if err != nil {
 		return err

api_helpers.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"os"
 	"strings"
 	"sync"
 	"time"
@@ -40,6 +41,66 @@ type ScalewayResolvedIdentifier struct {
 	Needle string
 }
 
+// fillIdentifierCache fills the cache by fetching fro the API
+func fillIdentifierCache(api *ScalewayAPI) {
+	log.Debugf("Filling the cache")
+	var wg sync.WaitGroup
+	wg.Add(5)
+	go func() {
+		api.GetServers(true, 0)
+		wg.Done()
+	}()
+	go func() {
+		api.GetImages()
+		wg.Done()
+	}()
+	go func() {
+		api.GetSnapshots()
+		wg.Done()
+	}()
+	go func() {
+		api.GetVolumes()
+		wg.Done()
+	}()
+	go func() {
+		api.GetBootscripts()
+		wg.Done()
+	}()
+	wg.Wait()
+}
+
+// getIdentifier returns a an identifier if the resolved needles only match one element, else, it exists the program
+func getIdentifier(api *ScalewayAPI, needle string) *ScalewayIdentifier {
+	idents := resolveIdentifier(api, needle)
+
+	if len(idents) == 1 {
+		return &idents[0]
+	}
+	if len(idents) == 0 {
+		log.Fatalf("No such identifier: %s", needle)
+	}
+	log.Errorf("Too many candidates for %s (%d)", needle, len(idents))
+	for _, identifier := range idents {
+		// FIXME: also print the name
+		log.Infof("- %s", identifier.Identifier)
+	}
+	os.Exit(1)
+	return nil
+}
+
+// resolveIdentifier resolves needle provided by the user
+func resolveIdentifier(api *ScalewayAPI, needle string) []ScalewayIdentifier {
+	idents := api.Cache.LookUpIdentifiers(needle)
+	if len(idents) > 0 {
+		return idents
+	}
+
+	fillIdentifierCache(api)
+
+	idents = api.Cache.LookUpIdentifiers(needle)
+	return idents
+}
+
 // resolveIdentifiers resolves needles provided by the user
 func resolveIdentifiers(api *ScalewayAPI, needles []string, out chan ScalewayResolvedIdentifier) {
 	// first attempt, only lookup from the cache
@@ -57,29 +118,8 @@ func resolveIdentifiers(api *ScalewayAPI, needles []string, out chan ScalewayRes
 	}
 	// fill the cache by fetching from the API and resolve missing identifiers
 	if len(unresolved) > 0 {
-		var wg sync.WaitGroup
-		wg.Add(5)
-		go func() {
-			api.GetServers(true, 0)
-			wg.Done()
-		}()
-		go func() {
-			api.GetImages()
-			wg.Done()
-		}()
-		go func() {
-			api.GetSnapshots()
-			wg.Done()
-		}()
-		go func() {
-			api.GetVolumes()
-			wg.Done()
-		}()
-		go func() {
-			api.GetBootscripts()
-			wg.Done()
-		}()
-		wg.Wait()
+		fillIdentifierCache(api)
+
 		for _, needle := range unresolved {
 			idents := api.Cache.LookUpIdentifiers(needle)
 			out <- ScalewayResolvedIdentifier{

cli.go

@@ -165,6 +165,7 @@ var commands = []*Command{
 	cmdKill,
 	cmdLogin,
 	cmdLogs,
+	cmdPatch,
 	cmdPort,
 	cmdPs,
 	cmdRename,

patch.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	log "github.com/Sirupsen/logrus"
+)
+
+var cmdPatch = &Command{
+	Exec:        runPatch,
+	UsageLine:   "_patch [OPTIONS] IDENTIFIER FIELD=VALUE",
+	Description: "",
+	Hidden:      true,
+	Help:        "PATCH an object on the API",
+	Examples: `
+    $ scw _patch myserver state_detail=booted
+`,
+}
+
+func init() {
+	cmdPatch.Flag.BoolVar(&patchHelp, []string{"h", "-help"}, false, "Print usage")
+}
+
+// Flags
+var patchHelp bool // -h, --help flag
+
+func runPatch(cmd *Command, args []string) {
+	if patchHelp {
+		cmd.PrintUsage()
+	}
+	if len(args) != 2 {
+		cmd.PrintShortUsage()
+	}
+
+	// Parsing FIELD=VALUE
+	updateParts := strings.Split(args[1], "=")
+	if len(updateParts) != 2 {
+		cmd.PrintShortUsage()
+	}
+	fieldName := updateParts[0]
+	newValue := updateParts[1]
+
+	ident := getIdentifier(cmd.API, args[0])
+	switch ident.Type {
+	case IdentifierServer:
+		var payload ScalewayServerPatchDefinition
+
+		switch fieldName {
+		case "state_detail":
+			payload.StateDetail = &newValue
+		case "name":
+			payload.Name = &newValue
+			log.Warnf("Use 'scw rename instead'")
+		default:
+			log.Fatalf("'_patch server %s=' not implemented", fieldName)
+		}
+
+		err := cmd.API.PatchServer(ident.Identifier, payload)
+		if err != nil {
+			log.Fatalf("Cannot rename server: %v", err)
+		}
+	default:
+		log.Fatalf("_patch not implemented for this kind of object")
+	}
+	fmt.Println(ident.Identifier)
+}

rename.go

@@ -26,13 +26,13 @@ func runRename(cmd *Command, args []string) {
 
 	serverID := cmd.API.GetServerID(args[0])
 
-	var server ScalewayServerPathNameDefinition
-	server.Name = args[1]
+	var server ScalewayServerPatchDefinition
+	server.Name = &args[1]
 
-	err := cmd.API.PatchServerName(serverID, server)
+	err := cmd.API.PatchServer(serverID, server)
 	if err != nil {
 		log.Fatalf("Cannot rename server: %v", err)
 	} else {
-		cmd.API.Cache.InsertServer(serverID, server.Name)
+		cmd.API.Cache.InsertServer(serverID, *server.Name)
 	}
 }