Merge pull request #185 from kevindelgado/extract-items

Expose ExtractItems as the opposite of RemoveItems

Author: k8s-ci-robot

fieldpath/set.go

@@ -206,6 +206,40 @@ func (s *Set) WithPrefix(pe PathElement) *Set {
 	return subset
 }
 
+// Leaves returns a set containing only the leaf paths
+// of a set.
+func (s *Set) Leaves() *Set {
+	leaves := PathElementSet{}
+	im := 0
+	ic := 0
+
+	// any members that are not also children are leaves
+outer:
+	for im < len(s.Members.members) {
+		member := s.Members.members[im]
+
+		for ic < len(s.Children.members) {
+			d := member.Compare(s.Children.members[ic].pathElement)
+			if d == 0 {
+				ic++
+				im++
+				continue outer
+			} else if d < 0 {
+				break
+			} else /* if d > 0 */ {
+				ic++
+			}
+		}
+		leaves.members = append(leaves.members, member)
+		im++
+	}
+
+	return &Set{
+		Members:  leaves,
+		Children: *s.Children.Leaves(),
+	}
+}
+
 // setNode is a pair of PathElement / Set, for the purpose of expressing
 // nested set membership.
 type setNode struct {
@@ -455,3 +489,17 @@ func (s *SetNodeMap) iteratePrefix(prefix Path, f func(Path)) {
 		n.set.iteratePrefix(append(prefix, pe), f)
 	}
 }
+
+// Leaves returns a SetNodeMap containing
+// only setNodes with leaf PathElements.
+func (s *SetNodeMap) Leaves() *SetNodeMap {
+	out := &SetNodeMap{}
+	out.members = make(sortedSetNode, len(s.members))
+	for i, n := range s.members {
+		out.members[i] = setNode{
+			pathElement: n.pathElement,
+			set:         n.set.Leaves(),
+		}
+	}
+	return out
+}

fieldpath/set_test.go

@@ -140,6 +140,12 @@ func BenchmarkFieldSet(b *testing.B) {
 				randOperand().RecursiveDifference(randOperand())
 			}
 		})
+		b.Run(fmt.Sprintf("leaves-%v", here.size), func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				randOperand().Leaves()
+			}
+		})
 	}
 }
 
@@ -456,6 +462,106 @@ func TestSetIntersectionDifference(t *testing.T) {
 	})
 }
 
+func TestSetLeaves(t *testing.T) {
+	table := []struct {
+		name     string
+		input    *Set
+		expected *Set
+	}{
+		{
+			name:     "empty set",
+			input:    NewSet(),
+			expected: NewSet(),
+		}, {
+			name: "all leaves",
+			input: NewSet(
+				_P("path1"),
+				_P("path2"),
+				_P("path3"),
+			),
+			expected: NewSet(
+				_P("path1"),
+				_P("path2"),
+				_P("path3"),
+			),
+		}, {
+			name: "only one leaf",
+			input: NewSet(
+				_P("root"),
+				_P("root", "l1"),
+				_P("root", "l1", "l2"),
+				_P("root", "l1", "l2", "l3"),
+			),
+			expected: NewSet(
+				_P("root", "l1", "l2", "l3"),
+			),
+		}, {
+			name: "multiple values, check for overwrite",
+			input: NewSet(
+				_P("root", KeyByFields("name", "a")),
+				_P("root", KeyByFields("name", "a"), "name"),
+				_P("root", KeyByFields("name", "a"), "value", "b"),
+				_P("root", KeyByFields("name", "a"), "value", "c"),
+			),
+			expected: NewSet(
+				_P("root", KeyByFields("name", "a"), "name"),
+				_P("root", KeyByFields("name", "a"), "value", "b"),
+				_P("root", KeyByFields("name", "a"), "value", "c"),
+			),
+		}, {
+			name: "multiple values and nested",
+			input: NewSet(
+				_P("root", KeyByFields("name", "a")),
+				_P("root", KeyByFields("name", "a"), "name"),
+				_P("root", KeyByFields("name", "a"), "value", "b"),
+				_P("root", KeyByFields("name", "a"), "value", "b", "d"),
+				_P("root", KeyByFields("name", "a"), "value", "c"),
+			),
+			expected: NewSet(
+				_P("root", KeyByFields("name", "a"), "name"),
+				_P("root", KeyByFields("name", "a"), "value", "b", "d"),
+				_P("root", KeyByFields("name", "a"), "value", "c"),
+			),
+		}, {
+			name: "all-in-one",
+			input: NewSet(
+				_P("root"),
+				_P("root", KeyByFields("name", "a")),
+				_P("root", KeyByFields("name", "a"), "name"),
+				_P("root", KeyByFields("name", "a"), "value", "b"),
+				_P("root", KeyByFields("name", "a"), "value", "b", "c"),
+				_P("root", KeyByFields("name", "a"), "value", "d"),
+				_P("root", KeyByFields("name", "a"), "value", "e"),
+				_P("root", "x"),
+				_P("root", "x", "y"),
+				_P("root", "x", "z"),
+				_P("root", KeyByFields("name", "p")),
+				_P("root", KeyByFields("name", "p"), "name"),
+				_P("root", KeyByFields("name", "p"), "value", "q"),
+			),
+			expected: NewSet(
+				_P("root", KeyByFields("name", "a"), "name"),
+				_P("root", KeyByFields("name", "a"), "value", "b", "c"),
+				_P("root", KeyByFields("name", "a"), "value", "d"),
+				_P("root", KeyByFields("name", "a"), "value", "e"),
+				_P("root", "x", "y"),
+				_P("root", "x", "z"),
+				_P("root", KeyByFields("name", "p"), "name"),
+				_P("root", KeyByFields("name", "p"), "value", "q"),
+			),
+		},
+	}
+
+	for _, tt := range table {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.input.Leaves(); !tt.expected.Equals(got) {
+				t.Errorf("expected %v, got %v for input %v", tt.expected, got, tt.input)
+			}
+		})
+	}
+
+}
+
 func TestSetDifference(t *testing.T) {
 	table := []struct {
 		name                      string

internal/fixture/state.go

@@ -341,6 +341,83 @@ func (f ForceApplyObject) preprocess(parser Parser) (Operation, error) {
 	return f, nil
 }
 
+// ExtractApply is a type of operation. It simulates extracting an object
+// the state based on the manager you have applied with, merging the
+// apply object with that extracted object and reapplying that.
+type ExtractApply struct {
+	Manager    string
+	APIVersion fieldpath.APIVersion
+	Object     typed.YAMLObject
+}
+
+var _ Operation = &ExtractApply{}
+
+func (e ExtractApply) run(state *State) error {
+	p, err := e.preprocess(state.Parser)
+	if err != nil {
+		return err
+	}
+	return p.run(state)
+}
+
+func (e ExtractApply) preprocess(parser Parser) (Operation, error) {
+
+	tv, err := parser.Type(string(e.APIVersion)).FromYAML(FixTabsOrDie(e.Object))
+	if err != nil {
+		return nil, err
+	}
+	return ExtractApplyObject{
+		Manager:    e.Manager,
+		APIVersion: e.APIVersion,
+		Object:     tv,
+	}, nil
+}
+
+type ExtractApplyObject struct {
+	Manager    string
+	APIVersion fieldpath.APIVersion
+	Object     *typed.TypedValue
+}
+
+var _ Operation = &ExtractApplyObject{}
+
+func (e ExtractApplyObject) run(state *State) error {
+	if state.Live == nil {
+		return state.ApplyObject(e.Object, e.APIVersion, e.Manager, true)
+	}
+	// Get object from state and convert it to current APIVersion
+	current, err := state.Updater.Converter.Convert(state.Live, e.APIVersion)
+	if err != nil {
+		return err
+	}
+	// Get set based on the manager you've applied with
+	set := fieldpath.NewSet()
+	mgr := state.Managers[e.Manager]
+	if mgr != nil {
+		// we cannot extract a set that is for a different version
+		if mgr.APIVersion() != e.APIVersion {
+			return fmt.Errorf("existing managed fieldpath set APIVersion (%s) differs from desired (%s), unable to extract", mgr.APIVersion(), e.APIVersion)
+		}
+		// trying to extract the fieldSet directly will return everything
+		// under the first path in the set, so we must filter out all
+		// the non-leaf nodes from the fieldSet
+		set = mgr.Set().Leaves()
+	}
+	// ExtractFields from the state object based on the set
+	extracted := current.ExtractItems(set)
+	// Merge ApplyObject on top of the extracted object
+	obj, err := extracted.Merge(e.Object)
+	if err != nil {
+		return err
+	}
+	// Reapply that to the state
+	return state.ApplyObject(obj, e.APIVersion, e.Manager, true)
+}
+
+func (e ExtractApplyObject) preprocess(parser Parser) (Operation, error) {
+	return e, nil
+}
+
 // Update is a type of operation. It is a controller type of
 // update. Errors are passed along.
 type Update struct {