introduce ExplicitDeleteVisitor

Author: steiler

pkg/tree/entry.go

@@ -155,6 +155,8 @@ type Entry interface {
 	BreadthSearch(ctx context.Context, path string) ([]Entry, error)
 	DeepCopy(tc *TreeContext, parent Entry) (Entry, error)
 	GetLeafVariantEntries() LeafVariantEntries
+	// returns true if the Entry contains leafvariants (presence container, field or leaflist)
+	HoldsLeafvariants() bool
 }
 
 type EntryVisitor interface {
@@ -163,7 +165,7 @@ type EntryVisitor interface {
 }
 
 type LeafVariantEntry interface {
-	MarkDelete(onlyIntended bool)
+	MarkDelete(onlyIntended bool) *LeafEntry
 	GetEntry() Entry
 	String() string
 }
@@ -172,5 +174,7 @@ type LeafVariantEntries interface {
 	MarkOwnerForDeletion(owner string, onlyIntended bool) *LeafEntry
 	GetHighestPrecedence(onlyNewOrUpdated bool, includeDefaults bool) *LeafEntry
 	GetRunning() *LeafEntry
-	DeleteByOwner(owner string) bool
+	DeleteByOwner(owner string) *LeafEntry
+	AddExplicitDeleteEntry(owner string, priority int32) *LeafEntry
+	GetByOwner(owner string) *LeafEntry
 }

pkg/tree/intent_path_mapping.go

@@ -6,33 +6,60 @@ import (
 	sdcpb "github.com/sdcio/sdc-protos/sdcpb"
 )
 
-type DeletePaths struct {
-	data map[string]*sdcpb.PathSet
+type DeletePathSet struct {
+	data map[string]*DeletePathPrio
 }
 
-func NewDeletePaths() *DeletePaths {
-	return &DeletePaths{
-		data: map[string]*sdcpb.PathSet{},
+func NewDeletePaths() *DeletePathSet {
+	return &DeletePathSet{
+		data: map[string]*DeletePathPrio{},
 	}
 }
 
-func (dp *DeletePaths) Add(intentName string, pathset *sdcpb.PathSet) {
-	set, exists := dp.data[intentName]
+func (dp *DeletePathSet) Add(intentName string, prio int32, pathset *sdcpb.PathSet) {
+	dpp, exists := dp.data[intentName]
 	if !exists {
-		set = sdcpb.NewPathSet()
-		dp.data[intentName] = set
+		dpp = NewDeletePathPrio(intentName, prio)
+		dp.data[intentName] = dpp
 	}
-	set.Join(pathset)
+	if pathset == nil {
+		return
+	}
+	dpp.paths.Join(pathset)
 }
 
-func (dp *DeletePaths) Items() iter.Seq[*sdcpb.Path] {
-	return func(yield func(*sdcpb.Path) bool) {
+func (dp *DeletePathSet) Items() iter.Seq[*DeletePathPrio] {
+	return func(yield func(*DeletePathPrio) bool) {
 		for _, val := range dp.data {
-			for path := range val.Items() {
-				if !yield(path) {
-					return
-				}
+			if !yield(val) {
+				return
 			}
 		}
 	}
 }
+
+type DeletePathPrio struct {
+	owner string
+	prio  int32
+	paths *sdcpb.PathSet
+}
+
+func NewDeletePathPrio(owner string, prio int32) *DeletePathPrio {
+	return &DeletePathPrio{
+		prio:  prio,
+		owner: owner,
+		paths: sdcpb.NewPathSet(),
+	}
+}
+
+func (dpp *DeletePathPrio) PathItems() iter.Seq[*sdcpb.Path] {
+	return dpp.paths.Items()
+}
+
+func (dpp *DeletePathPrio) GetPrio() int32 {
+	return dpp.prio
+}
+
+func (dpp *DeletePathPrio) GetOwner() string {
+	return dpp.owner
+}

pkg/tree/leaf_entry.go

@@ -2,6 +2,7 @@ package tree
 
 import (
 	"fmt"
+	"strings"
 	"sync"
 
 	"github.com/sdcio/data-server/pkg/tree/types"
@@ -65,8 +66,9 @@ func (l *LeafEntry) MarkNew() {
 	l.IsNew = true
 }
 
-func (l *LeafEntry) RemoveDeleteFlag() {
+func (l *LeafEntry) RemoveDeleteFlag() *LeafEntry {
 	l.Delete = false
+	return l
 }
 
 func (l *LeafEntry) GetDeleteFlag() bool {
@@ -99,11 +101,12 @@ func (l *LeafEntry) GetNewFlag() bool {
 	return l.IsNew
 }
 
-func (l *LeafEntry) DropDeleteFlag() {
+func (l *LeafEntry) DropDeleteFlag() *LeafEntry {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	l.Delete = false
 	l.DeleteOnlyIntended = false
+	return l
 }
 
 // MarkDelete indicate that the entry is to be deleted
@@ -118,11 +121,30 @@ func (l *LeafEntry) MarkDelete(onlyIntended bool) {
 	l.IsNew = false
 }
 
+// MarkExpliciteDelete indicate that the entry is to be explicitely deleted
+func (l *LeafEntry) MarkExpliciteDelete() {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.Delete = true
+	l.IsExplicitDelete = true
+	l.IsUpdated = false
+	l.IsNew = false
+}
+
 // String returns a string representation of the LeafEntry
 func (l *LeafEntry) String() string {
 	return fmt.Sprintf("Owner: %s, Priority: %d, Value: %s, New: %t, Delete: %t, Update: %t, DeleteIntendedOnly: %t, ExplicitDelete: %t", l.Owner(), l.Priority(), utils.TypedValueToString(l.Value()), l.GetNewFlag(), l.GetDeleteFlag(), l.GetUpdateFlag(), l.GetDeleteOnlyIntendedFlag(), l.GetExplicitDeleteFlag())
 }
 
+// Compare used for slices.SortFunc. Sorts by path and if equal paths then by owner as the second criteria
+func (l *LeafEntry) Compare(other *LeafEntry) int {
+	result := strings.Compare(l.GetPathSlice().String(), other.GetPathSlice().String())
+	if result != 0 {
+		return result
+	}
+	return strings.Compare(l.Update.Owner(), other.Update.Owner())
+}
+
 // NewLeafEntry constructor for a new LeafEntry
 func NewLeafEntry(c *types.Update, flags *types.UpdateInsertFlags, parent Entry) *LeafEntry {
 	le := &LeafEntry{
@@ -132,3 +154,13 @@ func NewLeafEntry(c *types.Update, flags *types.UpdateInsertFlags, parent Entry)
 	flags.Apply(le)
 	return le
 }
+
+func (l *LeafEntry) Equal(other *LeafEntry) bool {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	equal := l.Update.Equal(other.Update)
+	if !equal {
+		return false
+	}
+	return l.Delete == other.Delete && l.IsUpdated == other.IsUpdated && l.IsNew == other.IsNew && l.IsExplicitDelete == other.IsExplicitDelete && l.DeleteOnlyIntended == other.DeleteOnlyIntended
+}

pkg/tree/leaf_variant_slice.go

@@ -1,6 +1,12 @@
 package tree
 
-import "github.com/sdcio/data-server/pkg/tree/types"
+import (
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/sdcio/data-server/pkg/tree/types"
+)
 
 type LeafVariantSlice []*LeafEntry
 
@@ -11,3 +17,47 @@ func (lvs LeafVariantSlice) ToUpdateSlice() types.UpdateSlice {
 	}
 	return result
 }
+
+// Equal checks equality of the LeafVariantSlice with the other LeafVariantSlice
+func (lvs LeafVariantSlice) Equal(otherLvs LeafVariantSlice) (bool, error) {
+
+	// check for equal length
+	if len(lvs) != len(otherLvs) {
+		return false, fmt.Errorf("LeafVariantSlices differ in length %d vs. %d", len(lvs), len(otherLvs))
+	}
+
+	// sort lvs
+	slices.SortFunc(lvs, func(le1, le2 *LeafEntry) int {
+		return le1.Compare(le2)
+	})
+	// sort otherLvs
+	slices.SortFunc(lvs, func(le1, le2 *LeafEntry) int {
+		return le1.Compare(le2)
+	})
+
+	// compare one by one
+	for idx, le1 := range lvs {
+		equal := le1.Equal(otherLvs[idx])
+		if !equal {
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+func (lvs LeafVariantSlice) String() string {
+	sb := strings.Builder{}
+	first := true
+	sep := ""
+	for _, item := range lvs {
+		sb.WriteString(sep)
+		sb.WriteString(strings.Join(item.GetPathSlice(), " "))
+		sb.WriteString(" -> ")
+		sb.WriteString(item.String())
+		if first {
+			sep = "\n"
+			first = false
+		}
+	}
+	return sb.String()
+}

pkg/tree/leaf_variants.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/sdcio/data-server/pkg/tree/types"
 	"github.com/sdcio/data-server/pkg/utils"
+	sdcpb "github.com/sdcio/sdc-protos/sdcpb"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -27,7 +28,7 @@ func newLeafVariants(tc *TreeContext, parentEnty Entry) *LeafVariants {
 
 func (lv *LeafVariants) Add(le *LeafEntry) {
 	if leafVariant := lv.GetByOwner(le.Owner()); leafVariant != nil {
-		if leafVariant.Equal(le.Update) {
+		if leafVariant.Update.Equal(le.Update) {
 			// it seems like the element was not deleted, so drop the delete flag
 			leafVariant.DropDeleteFlag()
 		} else {
@@ -408,3 +409,9 @@ func (lv *LeafVariants) GetDeviations(ch chan<- *types.DeviationEntry, isActiveC
 	}
 
 }
+
+func (lv *LeafVariants) AddExplicitDeleteEntry(intentName string, priority int32) *LeafEntry {
+	le := NewLeafEntry(types.NewUpdate(lv.parentEntry.Path(), &sdcpb.TypedValue{}, priority, intentName, 0), types.NewUpdateInsertFlags().SetExplicitDeleteFlag(), lv.parentEntry)
+	lv.Add(le)
+	return le
+}

pkg/tree/root_entry.go

@@ -11,14 +11,15 @@ import (
 	"github.com/sdcio/data-server/pkg/tree/importer"
 	"github.com/sdcio/data-server/pkg/tree/tree_persist"
 	"github.com/sdcio/data-server/pkg/tree/types"
+	"github.com/sdcio/data-server/pkg/utils"
 	sdcpb "github.com/sdcio/sdc-protos/sdcpb"
 	log "github.com/sirupsen/logrus"
 )
 
 // RootEntry the root of the cache.Update tree
 type RootEntry struct {
 	*sharedEntryAttributes
-	explicitDeletes *DeletePaths
+	explicitDeletes *DeletePathSet
 }
 
 var (
@@ -89,11 +90,15 @@ func (r *RootEntry) ImportConfig(ctx context.Context, basePath types.PathSlice,
 		return err
 	}
 
-	r.explicitDeletes.Add(intentName, importer.GetDeletes())
+	r.explicitDeletes.Add(intentName, intentPrio, importer.GetDeletes())
 
 	return e.ImportConfig(ctx, importer, intentName, intentPrio, flags)
 }
 
+func (r *RootEntry) AddExplicitDeletes(intentName string, priority int32, pathset *sdcpb.PathSet) {
+	r.explicitDeletes.Add(intentName, priority, pathset)
+}
+
 func (r *RootEntry) Validate(ctx context.Context, vCfg *config.Validation) (types.ValidationResults, *types.ValidationStatOverall) {
 	// perform validation
 	// we use a channel and cumulate all the errors
@@ -235,18 +240,31 @@ func (r *RootEntry) DeleteSubtreePaths(deletes types.DeleteEntriesList, intentNa
 }
 
 func (r *RootEntry) FinishInsertionPhase(ctx context.Context) error {
+	edvs := ExplicitDeleteVisitors{}
+
 	// apply the explicit deletes
-	edv := NewExplicitDeleteVisitor()
-	for path := range r.explicitDeletes.Items() {
-		entry, err := r.NavigateSdcpbPath(ctx, path.Elem, true)
-		if err != nil {
-			log.Warnf("Applying explicit delete: path %s not found, skipping", path.ToXPath(false))
-		}
-		err = entry.Walk(ctx, edv)
-		if err != nil {
-			return err
+	for deletePathPrio := range r.explicitDeletes.Items() {
+		edv := NewExplicitDeleteVisitor(deletePathPrio.GetOwner(), deletePathPrio.GetPrio())
+
+		for path := range deletePathPrio.PathItems() {
+			// set the priority
+			// navigate to the stated path
+			entry, err := r.NavigateSdcpbPath(ctx, path.GetElem(), true)
+			if err != nil {
+				log.Warnf("Applying explicit delete: path %s not found, skipping", path.ToXPath(false))
+			}
+
+			// walk the whole branch adding the explicit delete leafvariant
+			err = entry.Walk(ctx, edv)
+			if err != nil {
+				return err
+			}
+			edvs[deletePathPrio.GetOwner()] = edv
 		}
 	}
+	log.Debugf("ExplicitDeletes added: %s", utils.MapToString(edvs.Stats(), ", ", func(k string, v int) string {
+		return fmt.Sprintf("%s=%d", k, v)
+	}))
 
 	return r.sharedEntryAttributes.FinishInsertionPhase(ctx)
 }

pkg/tree/sharedEntryAttributes.go

@@ -440,6 +440,18 @@ func (s *sharedEntryAttributes) Walk(ctx context.Context, v EntryVisitor) error
 	return nil
 }
 
+func (s *sharedEntryAttributes) HoldsLeafvariants() bool {
+	switch x := s.schema.GetSchema().(type) {
+	case *sdcpb.SchemaElem_Container:
+		return x.Container.GetIsPresence()
+	case *sdcpb.SchemaElem_Leaflist:
+		return true
+	case *sdcpb.SchemaElem_Field:
+		return true
+	}
+	return false
+}
+
 // GetSchemaKeys checks for the schema of the entry, and returns the defined keys
 func (s *sharedEntryAttributes) GetSchemaKeys() []string {
 	if s.schema != nil {

pkg/tree/types/update_insert_flags.go

@@ -2,6 +2,7 @@ package types
 
 type LeafEntry interface {
 	MarkDelete(onlyIntended bool)
+	MarkExpliciteDelete()
 	MarkNew()
 }
 
@@ -70,6 +71,9 @@ func (f *UpdateInsertFlags) Apply(le LeafEntry) *UpdateInsertFlags {
 		le.MarkNew()
 		return f
 	}
+	if f.explicitDelete {
+		le.MarkExpliciteDelete()
+	}
 	return f
 }