fix identityref conversion

add more detailed log line
todo: validate enums
Fix NavigateLeafRef for leaf to leaflist references
allow correct parsing of leaf to leaflist leafrefs

Author: alexandernorth

pkg/datastore/target/nc.go

@@ -100,7 +100,7 @@ func (t *ncTarget) Get(ctx context.Context, req *sdcpb.GetDataRequest) (*sdcpb.G
 		return nil, err
 	}
 
-	log.Debugf("netconf response:\n%s", ncResponse.DocAsString())
+	log.Debugf("%s: netconf response:\n%s", t.name, ncResponse.DocAsString())
 
 	// cmlImport := xml.NewXmlTreeImporter(ncResponse.Doc.Root())
 

pkg/datastore/target/netconf/xml2SchemapbAdapter.go

@@ -146,7 +146,8 @@ func (x *XML2sdcpbConfigAdapter) transformContainer(ctx context.Context, e *etre
 // transformField transforms an etree.element of a configuration as an update into the provided *sdcpb.Notification.
 func (x *XML2sdcpbConfigAdapter) transformField(ctx context.Context, e *etree.Element, pelems []*sdcpb.PathElem, ls *sdcpb.LeafSchema, result *sdcpb.Notification) error {
 	path := pelems
-	for ls.GetType().GetLeafref() != "" {
+	schemaLeafType := ls.GetType()
+	for schemaLeafType.GetLeafref() != "" {
 		path, err := utils.NormalizedAbsPath(ls.Type.Leafref, path)
 		if err != nil {
 			return err
@@ -157,16 +158,18 @@ func (x *XML2sdcpbConfigAdapter) transformField(ctx context.Context, e *etree.El
 			return err
 		}
 
-		var schemaElem *sdcpb.SchemaElem_Field
-		var ok bool
-		if schemaElem, ok = schema.GetSchema().GetSchema().(*sdcpb.SchemaElem_Field); !ok {
-			return fmt.Errorf("node [%s] with leafref [%s] has non-field target type [%T: %v]", e.GetPath(), ls.GetType().GetLeafref(), schema.GetSchema().GetSchema(), schema.GetSchema().GetSchema())
+		switch se := schema.GetSchema().GetSchema().(type) {
+		case *sdcpb.SchemaElem_Leaflist:
+			schemaLeafType = se.Leaflist.GetType()
+		case *sdcpb.SchemaElem_Field:
+			schemaLeafType = se.Field.GetType()
+		default:
+			return fmt.Errorf("node [%s] with leafref [%s] has non-field or leaflist target type [%T]", e.GetPath(), ls.GetType().GetLeafref(), se)
 		}
-		ls = schemaElem.Field
 	}
 
 	// process terminal values
-	tv, err := StringElementToTypedValue(e.Text(), ls)
+	tv, err := utils.Convert(e.Text(), schemaLeafType)
 	if err != nil {
 		slt, errMarsh := json.Marshal(ls.Type)
 		if errMarsh != nil {

pkg/tree/sharedEntryAttributes.go

@@ -951,6 +951,9 @@ func (s *sharedEntryAttributes) Validate(ctx context.Context, resultChan chan<-
 
 	// validate the mandatory statement on this entry
 	if s.remainsToExist() {
+
+		// TODO: Validate Enums
+
 		if !vCfg.DisabledValidators.Mandatory {
 			s.validateMandatory(ctx, resultChan)
 		}

pkg/tree/validation_entry_leafref.go

@@ -109,6 +109,18 @@ func (s *sharedEntryAttributes) BreadthSearch(ctx context.Context, path string)
 // NavigateLeafRef
 func (s *sharedEntryAttributes) NavigateLeafRef(ctx context.Context) ([]Entry, error) {
 
+	// leafref path takes as an argument a string that MUST refer to a leaf or leaf-list node.
+	// e.g.
+	// leaf foo {
+	//   type leafref {
+	//     path "/bar/baz";
+	//   }
+	// }
+	// the runtime semantics are:
+	// If /bar/baz resolves to a leaf, then foo must have exactly the same value as that leaf.
+	// If /bar/baz resolves to a leaf-list, then foo must have a value equal to one of the existing entries in that leaf-list.
+	// Thus, the "pointer" is not to the entire leaf-list node, but to one instance of it, selected by value.
+
 	var lref string
 	switch {
 	case s.GetSchema().GetField().GetType().GetLeafref() != "":
@@ -121,34 +133,34 @@ func (s *sharedEntryAttributes) NavigateLeafRef(ctx context.Context) ([]Entry, e
 
 	lv := s.leafVariants.GetHighestPrecedence(false, true)
 
+	// value of node with type leafref
 	tv := lv.Value()
-	var values []*sdcpb.TypedValue
-
-	switch ttv := tv.Value.(type) {
-	case *sdcpb.TypedValue_LeaflistVal:
-		values = append(values, ttv.LeaflistVal.GetElement()...)
-	default:
-		values = append(values, tv)
-	}
-
-	var resultEntries []Entry
 
 	foundEntries, err := s.BreadthSearch(ctx, lref)
 	if err != nil {
 		return nil, err
 	}
 
-	resultEntries = []Entry{}
+	var resultEntries []Entry
 
 	for _, e := range foundEntries {
-
 		r, err := e.getHighestPrecedenceLeafValue(ctx)
 		if err != nil {
 			return nil, err
 		}
-		val := r.Value()
-		for _, value := range values {
-			if utils.EqualTypedValues(val, value) {
+		// Value of the resolved leafref
+		refVal := r.Value()
+		var vals []*sdcpb.TypedValue
+
+		switch tVal := refVal.Value.(type) {
+		case *sdcpb.TypedValue_LeaflistVal:
+			vals = append(vals, tVal.LeaflistVal.GetElement()...)
+		default:
+			vals = append(vals, refVal)
+		}
+		// loop through possible values of found reference (leaf -> 1 value, leaf-list -> 1+ values)
+		for _, val := range vals {
+			if utils.EqualTypedValues(val, tv) {
 				resultEntries = append(resultEntries, e)
 				break
 			}

pkg/utils/converter.go

@@ -140,7 +140,8 @@ func (c *Converter) ExpandUpdate(ctx context.Context, upd *sdcpb.Update) ([]*sdc
 			}
 		}
 
-		if rsp.Field.GetType().Type == "identityref" {
+		// We expect that all identityrefs are sent by schema-server as a identityref type now, not string
+		if rsp.Field.GetType().Type == "identityref" && upd.GetValue().GetStringVal() != "" {
 			upd.Value, err = Convert(upd.GetValue().GetStringVal(), rsp.Field.GetType())
 			if err != nil {
 				return nil, err