WIP: better handling of cache conflict results

Author: moul

api/api.go

@@ -13,6 +13,7 @@ import (
 	"net/url"
 	"os"
 	"strings"
+	"text/tabwriter"
 	"text/template"
 
 	log "github.com/Sirupsen/logrus"
@@ -913,7 +914,7 @@ func (s *ScalewayAPI) PutVolume(volumeID string, definition ScalewayVolumePutDef
 }
 
 // ResolveServer attempts the find a matching Identifier for the input string
-func (s *ScalewayAPI) ResolveServer(needle string) ([]string, error) {
+func (s *ScalewayAPI) ResolveServer(needle string) ([]ScalewayResolverResult, error) {
 	servers := s.Cache.LookUpServers(needle, true)
 	if len(servers) == 0 {
 		_, err := s.GetServers(true, 0)
@@ -1184,20 +1185,28 @@ func (s *ScalewayAPI) GetServerID(needle string) string {
 		log.Fatalf("Unable to resolve server %s: %s", needle, err)
 	}
 	if len(servers) == 1 {
-		return servers[0]
+		return servers[0].Identifier
 	}
 	if len(servers) == 0 {
 		log.Fatalf("No such server: %s", needle)
 	}
-	log.Errorf("Too many candidates for %s (%d)", needle, len(servers))
-	for _, identifier := range servers {
-		// FIXME: also print the name
-		log.Infof("- %s", identifier)
-	}
+
+	showResolverResults(needle, servers)
 	os.Exit(1)
 	return ""
 }
 
+func showResolverResults(needle string, results []ScalewayResolverResult) error {
+	log.Errorf("Too many candidates for %s (%d)", needle, len(results))
+
+	w := tabwriter.NewWriter(os.Stderr, 20, 1, 3, ' ', 0)
+	defer w.Flush()
+	for _, result := range results {
+		fmt.Fprintf(w, "- %s\t%s\t%s\n", result.TruncIdentifier(), result.CodeName(), result.Name)
+	}
+	return nil
+}
+
 // GetSnapshotID returns exactly one snapshot matching or dies
 func (s *ScalewayAPI) GetSnapshotID(needle string) string {
 	// Parses optional type prefix, i.e: "snapshot:name" -> "name"

api/cache.go

@@ -6,6 +6,7 @@ package api
 
 import (
 	"encoding/json"
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -69,6 +70,27 @@ type ScalewayIdentifier struct {
 	Type int
 }
 
+// ScalewayResolverResult is a structure containing human-readable information
+// about resolver results. This structure is used to display the user choices.
+type ScalewayResolverResult struct {
+	Identifier string
+	Type       string
+	Name       string
+}
+
+func (s *ScalewayResolverResult) TruncIdentifier() string {
+	return s.Identifier[:8]
+}
+
+func (s *ScalewayResolverResult) CodeName() string {
+	name := strings.ToLower(s.Name)
+	name = regexp.MustCompile(`[^a-z0-9-]`).ReplaceAllString(name, "-")
+	name = regexp.MustCompile(`--+`).ReplaceAllString(name, "-")
+	name = strings.Trim(name, "-")
+
+	return fmt.Sprintf("%s:%s", strings.ToLower(s.Type), name)
+}
+
 // NewScalewayCache loads a per-user cache
 func NewScalewayCache() (*ScalewayCache, error) {
 	homeDir := os.Getenv("HOME") // *nix
@@ -260,32 +282,64 @@ func (c *ScalewayCache) LookUpBootscripts(needle string, acceptUUID bool) []stri
 }
 
 // LookUpServers attempts to return identifiers matching a pattern
-func (c *ScalewayCache) LookUpServers(needle string, acceptUUID bool) []string {
+func (c *ScalewayCache) LookUpServers(needle string, acceptUUID bool) []ScalewayResolverResult {
 	c.Lock.Lock()
 	defer c.Lock.Unlock()
 
-	var res []string
-	var exactMatches []string
+	var res []ScalewayResolverResult
+	var exactMatches []ScalewayResolverResult
 
 	if acceptUUID && uuid.Parse(needle) != nil {
-		res = append(res, needle)
+		entry := ScalewayResolverResult{
+			Identifier: needle,
+			Name:       needle,
+			Type:       "Server",
+		}
+		res = append(res, entry)
 	}
 
 	nameRegex := regexp.MustCompile(`(?i)` + regexp.MustCompile(`[_-]`).ReplaceAllString(needle, ".*"))
 	for identifier, name := range c.Servers {
 		if name == needle {
-			exactMatches = append(exactMatches, identifier)
+			entry := ScalewayResolverResult{
+				Identifier: identifier,
+				Name:       name,
+				Type:       "Server",
+			}
+			exactMatches = append(exactMatches, entry)
 		}
 		if strings.HasPrefix(identifier, needle) || nameRegex.MatchString(name) {
-			res = append(res, identifier)
+			entry := ScalewayResolverResult{
+				Identifier: identifier,
+				Name:       name,
+				Type:       "Server",
+			}
+			res = append(res, entry)
 		}
 	}
 
 	if len(exactMatches) == 1 {
 		return exactMatches
 	}
 
-	return utils.RemoveDuplicates(res)
+	return removeDuplicatesResults(res)
+}
+
+// removeDuplicatesResults transforms an array into a unique array
+func removeDuplicatesResults(elements []ScalewayResolverResult) []ScalewayResolverResult {
+	encountered := map[string]ScalewayResolverResult{}
+
+	// Create a map of all unique elements.
+	for v := range elements {
+		encountered[elements[v].Identifier] = elements[v]
+	}
+
+	// Place all keys from the map into a slice.
+	results := []ScalewayResolverResult{}
+	for _, result := range encountered {
+		results = append(results, result)
+	}
+	return results
 }
 
 // parseNeedle parses a user needle and try to extract a forced object type
@@ -319,9 +373,9 @@ func (c *ScalewayCache) LookUpIdentifiers(needle string) []ScalewayIdentifier {
 	identifierType, needle := parseNeedle(needle)
 
 	if identifierType&(IdentifierUnknown|IdentifierServer) > 0 {
-		for _, identifier := range c.LookUpServers(needle, false) {
+		for _, result := range c.LookUpServers(needle, false) {
 			results = append(results, ScalewayIdentifier{
-				Identifier: identifier,
+				Identifier: result.Identifier,
 				Type:       IdentifierServer,
 			})
 		}