Fix the filtering framework to perform exact matches again

pkg/filter/all.go

@@ -15,12 +15,12 @@ func NewAllFilter() *AllFilter {
 	return &AllFilter{}
 }
 
-func (f *AllFilter) Filter(object meta.Object) (meta.Object, error) {
-	return object, nil
+func (f *AllFilter) Filter(object meta.Object) (filterer.Match, error) {
+	return filterer.NewMatch(object, false), nil
 }
 
 // The AllFilter shouldn't be used to match single Objects
-func (f *AllFilter) AmbiguousError() *filterer.AmbiguousError {
+func (f *AllFilter) AmbiguousError(_ []filterer.Match) *filterer.AmbiguousError {
 	return filterer.NewAmbiguousError("ambiguous query: AllFilter used to match single Object")
 }
 

pkg/filter/idname.go

@@ -8,11 +8,17 @@ import (
 	"github.com/weaveworks/ignite/pkg/util"
 )
 
+type IDNameMatch struct {
+	*filterer.GenericMatch
+	matches []string
+}
+
+var _ filterer.Match = &IDNameMatch{}
+
 // The IDNameFilter is the basic filter matching objects by their ID/name
 type IDNameFilter struct {
-	prefix  string
-	matches []string
-	kind    meta.Kind
+	prefix string
+	kind   meta.Kind
 }
 
 var _ filterer.MetaFilter = &IDNameFilter{}
@@ -23,14 +29,16 @@ func NewIDNameFilter(p string) *IDNameFilter {
 	}
 }
 
-func (f *IDNameFilter) FilterMeta(object meta.Object) (meta.Object, error) {
+func (f *IDNameFilter) FilterMeta(object meta.Object) (filterer.Match, error) {
 	if len(f.kind) == 0 {
 		f.kind = object.GetKind() // reflect.Indirect(reflect.ValueOf(object)).Type().Name()
 	}
 
-	if matches := util.MatchPrefix(f.prefix, string(object.GetUID()), object.GetName()); len(matches) > 0 {
-		f.matches = append(f.matches, matches...)
-		return object, nil
+	if matches, exact := util.MatchPrefix(f.prefix, string(object.GetUID()), object.GetName()); len(matches) > 0 {
+		return &IDNameMatch{
+			filterer.NewMatch(object, exact),
+			matches,
+		}, nil
 	}
 
 	return nil, nil
@@ -40,19 +48,24 @@ func (f *IDNameFilter) SetKind(k meta.Kind) {
 	f.kind = k
 }
 
-func (f *IDNameFilter) AmbiguousError() *filterer.AmbiguousError {
-	return filterer.NewAmbiguousError("ambiguous %s query: %q matched the following IDs/names: %s", f.kind, f.prefix, formatMatches(f.matches))
+func (f *IDNameFilter) AmbiguousError(matches []filterer.Match) *filterer.AmbiguousError {
+	return filterer.NewAmbiguousError("ambiguous %s query: %q matched the following IDs/names: %s", f.kind, f.prefix, formatMatches(matches))
 }
 
 func (f *IDNameFilter) NonexistentError() *filterer.NonexistentError {
 	return filterer.NewNonexistentError("can't find %s: no ID/name matches for %q", f.kind, f.prefix)
 }
 
-func formatMatches(matches []string) string {
+func formatMatches(input []filterer.Match) string {
 	var sb strings.Builder
+	var matches []string
+
+	for _, match := range input {
+		matches = append(matches, match.(*IDNameMatch).matches...)
+	}
 
-	for i, match := range matches {
-		sb.WriteString(match)
+	for i, str := range matches {
+		sb.WriteString(str)
 
 		if i+1 < len(matches) {
 			sb.WriteString(", ")

pkg/filter/name.go

@@ -7,9 +7,8 @@ import (
 
 // The NameFilter matches Objects by their exact name
 type NameFilter struct {
-	name    string
-	matches uint64
-	kind    meta.Kind
+	name string
+	kind meta.Kind
 }
 
 var _ filterer.MetaFilter = &NameFilter{}
@@ -20,14 +19,9 @@ func NewNameFilter(n string) *NameFilter {
 	}
 }
 
-func (f *NameFilter) FilterMeta(object meta.Object) (meta.Object, error) {
-	if len(f.kind) == 0 {
-		f.kind = object.GetKind() // reflect.Indirect(reflect.ValueOf(object)).Type().Name()
-	}
-
+func (f *NameFilter) FilterMeta(object meta.Object) (filterer.Match, error) {
 	if object.GetName() == f.name {
-		f.matches++
-		return object, nil
+		return filterer.NewMatch(object, true), nil
 	}
 
 	return nil, nil
@@ -37,8 +31,8 @@ func (f *NameFilter) SetKind(k meta.Kind) {
 	f.kind = k
 }
 
-func (f *NameFilter) AmbiguousError() *filterer.AmbiguousError {
-	return filterer.NewAmbiguousError("ambiguous %s query: %q matched %d names", f.kind, f.name, f.matches)
+func (f *NameFilter) AmbiguousError(_ []filterer.Match) *filterer.AmbiguousError {
+	return filterer.NewAmbiguousError("ambiguous %s query: %q matched multiple names", f.kind, f.name)
 }
 
 func (f *NameFilter) NonexistentError() *filterer.NonexistentError {

pkg/filter/vm.go

@@ -30,7 +30,7 @@ func NewVMFilterAll(p string, all bool) *VMFilter {
 	}
 }
 
-func (f *VMFilter) Filter(object meta.Object) (meta.Object, error) {
+func (f *VMFilter) Filter(object meta.Object) (filterer.Match, error) {
 	// Option to list just running VMs
 	if !f.all {
 		vm, ok := object.(*api.VM)

pkg/storage/filterer/filter.go

@@ -10,7 +10,8 @@ import (
 type BaseFilter interface {
 	// AmbiguousError specifies what to error if
 	// a single request returned multiple matches
-	AmbiguousError() *AmbiguousError
+	// The matches are given as an argument
+	AmbiguousError([]Match) *AmbiguousError
 	// NonexistentError specifies what to error if
 	// a single request returned no matches
 	NonexistentError() *NonexistentError
@@ -22,8 +23,9 @@ type BaseFilter interface {
 type ObjectFilter interface {
 	BaseFilter
 	// Every Object to be filtered is passed though Filter, which should
-	// return the Object on match, or nil if it doesn't match
-	Filter(meta.Object) (meta.Object, error)
+	// return the Object on match, or nil if it doesn't match.
+	// The boolean indicates an exact match.
+	Filter(meta.Object) (Match, error)
 }
 
 // MetaFilter implementations operate on meta.APIType objects,
@@ -33,7 +35,8 @@ type MetaFilter interface {
 	// Every Object to be filtered is passed though FilterMeta, which should
 	// return the Object on match, or nil if it doesn't match. The Objects
 	// given to FilterMeta are of type meta.APIType, stripped of other contents.
-	FilterMeta(meta.Object) (meta.Object, error)
+	// The boolean indicates an exact match.
+	FilterMeta(meta.Object) (Match, error)
 }
 
 type AmbiguousError struct {

pkg/storage/filterer/filterer.go

@@ -17,11 +17,12 @@ func NewFilterer(storage storage.Storage) *Filterer {
 	}
 }
 
-type filterFunc func(meta.Object) (meta.Object, error)
+type filterFunc func(meta.Object) (Match, error)
 
 // Find a single meta.Object of the given kind using the given filter
 func (f *Filterer) Find(kind meta.Kind, filter BaseFilter) (meta.Object, error) {
-	var result meta.Object
+	var results []Match
+	var exactMatch Match
 
 	// Fetch the sources, correct filtering method and if we're dealing with meta.APIType objects
 	sources, filterFunc, metaObjects, err := f.parseFilter(kind, filter)
@@ -34,16 +35,32 @@ func (f *Filterer) Find(kind meta.Kind, filter BaseFilter) (meta.Object, error)
 		if match, err := filterFunc(object); err != nil { // The filter returns meta.Object if it matches, otherwise nil
 			return nil, err
 		} else if match != nil {
-			if result != nil {
-				return nil, filter.AmbiguousError()
+			if match.Exact() {
+				if exactMatch != nil {
+					// We have multiple exact matches, the user has done something wrong
+					return nil, filter.AmbiguousError([]Match{exactMatch, match})
+				} else {
+					exactMatch = match
+				}
 			} else {
-				result = match
+				results = append(results, match)
 			}
 		}
 	}
 
-	if result == nil {
-		return nil, filter.NonexistentError()
+	var result meta.Object
+
+	// If we have an exact result, select it
+	if exactMatch != nil {
+		result = exactMatch.Object()
+	} else {
+		if len(results) == 0 {
+			return nil, filter.NonexistentError()
+		} else if len(results) > 1 {
+			return nil, filter.AmbiguousError(results)
+		}
+
+		result = results[0].Object()
 	}
 
 	// If we're filtering meta.APIType objects, load the full Object to be returned
@@ -69,7 +86,7 @@ func (f *Filterer) FindAll(kind meta.Kind, filter BaseFilter) ([]meta.Object, er
 		if match, err := filterFunc(object); err != nil { // The filter returns meta.Object if it matches, otherwise nil
 			return nil, err
 		} else if match != nil {
-			results = append(results, match)
+			results = append(results, match.Object())
 		}
 	}
 

pkg/storage/filterer/match.go

@@ -0,0 +1,38 @@
+package filterer
+
+import (
+	meta "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1"
+)
+
+// Match describes the result of filtering an Object
+// If the Object to be filtered didn't match, return nil
+type Match interface {
+	// Get the matched Object
+	Object() meta.Object
+	// Check if the match was exact
+	Exact() bool
+}
+
+// GenericMatch is the simplest implementation
+// of Match, carrying no additional data
+type GenericMatch struct {
+	object meta.Object
+	exact  bool
+}
+
+var _ Match = &GenericMatch{}
+
+func NewMatch(object meta.Object, exact bool) *GenericMatch {
+	return &GenericMatch{
+		object: object,
+		exact:  exact,
+	}
+}
+
+func (m *GenericMatch) Object() meta.Object {
+	return m.object
+}
+
+func (m *GenericMatch) Exact() bool {
+	return m.exact
+}

pkg/util/util.go

@@ -96,25 +96,24 @@ func RandomName() string {
 	return namegenerator.NewNameGenerator(time.Now().UTC().UnixNano()).Generate()
 }
 
-func MatchPrefix(prefix string, fields ...string) []string {
+func MatchPrefix(prefix string, fields ...string) ([]string, bool) {
 	var prefixMatches, exactMatches []string
 
 	for _, str := range fields {
-		if strings.HasPrefix(str, prefix) {
-			prefixMatches = append(prefixMatches, str)
-		}
-
 		if str == prefix {
 			exactMatches = append(exactMatches, str)
+		} else if strings.HasPrefix(str, prefix) {
+			prefixMatches = append(prefixMatches, str)
 		}
 	}
 
 	// If we have exact matches, return them
+	// and set the exact match boolean
 	if len(exactMatches) > 0 {
-		return exactMatches
+		return exactMatches, true
 	}
 
-	return prefixMatches
+	return prefixMatches, false
 }
 
 func TestRoot() (bool, error) {