Presence Containers (#645)

* This commit adds support for YANG presence containers. It adds a tag to
the field of generated Go Struct. When rendering JSON documents, before
deleting/omitting empty containers, it checks for this struct field tag.

As per the OpenConfig style guide, YANG presence containers are not
used, as such this would only be used with 3rd party YANG models. As
such a CLI knob is added to generator.go to enable this behavior with
-yangpresence=true

* fix broken test case because of resync with master

* Changes Requested #1 in #645

* Adding #645 requested changes:
- adding tests in ygot/render_test.go:
  - testing a presence container in a list entry (ISIS overload usecase)
  - testing a presence container in a non-presence container
    (system/ssh-server usecase)

- adding tests in ytypes/container_test.go:
  - adding tests in TestUnmarshalContainer

* Updated minor comments in #645

Author: hansthienpondt

generator/generator.go

@@ -86,6 +86,7 @@ var (
 	generateRename          = flag.Bool("generate_rename", false, "If set to true, rename methods are generated for lists within the Go code.")
 	addAnnotations          = flag.Bool("annotations", false, "If set to true, metadata annotations are added within the generated structs.")
 	annotationPrefix        = flag.String("annotation_prefix", ygen.DefaultAnnotationPrefix, "String to be appended to each metadata field within the generated structs if annoations is set to true.")
+	addYangPresence         = flag.Bool("yangpresence", false, "If set to true, a tag will be added to the field of a generated Go struct to indicate when a YANG presence container is being used.")
 	generateAppend          = flag.Bool("generate_append", false, "If set to true, append methods are generated for YANG lists (Go maps) within the Go code.")
 	generateGetters         = flag.Bool("generate_getters", false, "If set to true, getter methdos that retrieve or create an element are generated for YANG container (Go struct pointer) or list (Go map) fields within the generated code.")
 	generateDelete          = flag.Bool("generate_delete", false, "If set to true, delete methods are generated for YANG lists (Go maps) within the Go code.")
@@ -349,6 +350,7 @@ func main() {
 				GenerateRenameMethod:                *generateRename,
 				AddAnnotationFields:                 *addAnnotations,
 				AnnotationPrefix:                    *annotationPrefix,
+				AddYangPresence:                     *addYangPresence,
 				GenerateGetters:                     *generateGetters,
 				GenerateDeleteMethod:                *generateDelete,
 				GenerateAppendMethod:                *generateAppend,

testdata/modules/presence-container-example.yang

@@ -0,0 +1,38 @@
+module presence-container-example {
+  prefix "pc";
+  namespace "urn:pc";
+  description
+  "A simple test module with a YANG presence container";
+
+  grouping parent-config {
+    leaf one { type string; }
+    leaf three {
+      type enumeration {
+        enum ONE;
+        enum TWO;
+      }
+    }
+    leaf four {
+      type binary;
+    }
+  }
+
+  container parent {
+    description
+      "I am a parent container
+       that has 4 children.";
+    container child {
+      presence "This is an example presence container";
+      container config {
+        uses parent-config;
+      }
+      container state {
+        config false;
+        uses parent-config;
+        leaf two { type string; }
+      }
+    }
+  }
+}
+
+

util/yang.go

@@ -188,6 +188,12 @@ func IsYgotAnnotation(s reflect.StructField) bool {
 	return ok
 }
 
+// IsYangPresence reports whether struct field s is a YANG presence container.
+func IsYangPresence(s reflect.StructField) bool {
+	_, ok := s.Tag.Lookup("yangPresence")
+	return ok
+}
+
 // IsSimpleEnumerationType returns true when the type supplied is a simple
 // enumeration (i.e., a leaf that is defined as type enumeration { ... },
 // and is not a typedef that contains an enumeration, or a union that

util/yang_test.go

@@ -1019,6 +1019,41 @@ func TestIsYgotAnnotation(t *testing.T) {
 	}
 }
 
+func TestIsYangPresence(t *testing.T) {
+	type testStruct struct {
+		Yes *string `yangPresence:"true"`
+		No  *string
+	}
+	structFieldYes, ok := reflect.TypeOf(testStruct{}).FieldByName("Yes")
+	if !ok {
+		t.Fatalf("Cannot find field Yes in testStruct")
+	}
+
+	structFieldNo, ok := reflect.TypeOf(testStruct{}).FieldByName("No")
+	if !ok {
+		t.Fatalf("Cannot find field No in testStruct")
+	}
+	tests := []struct {
+		name string
+		in   reflect.StructField
+		want bool
+	}{{
+		name: "yangPresence container/field",
+		in:   structFieldYes,
+		want: true,
+	}, {
+		name: "standard field",
+		in:   structFieldNo,
+		want: false,
+	}}
+
+	for _, tt := range tests {
+		if got := IsYangPresence(tt.in); got != tt.want {
+			t.Errorf("%s: IsYangPresence(%#v): did not get expected result, got: %v, want: %v", tt.name, tt.in, got, tt.want)
+		}
+	}
+}
+
 // complexUnionTypeName is the name used to refer to the name of the union
 // type containing the slice of input types to the functions.
 const complexUnionTypeName = "complexUnionTypeName"

ygen/codegen.go

@@ -191,6 +191,13 @@ type GoOpts struct {
 	// AnnotationPrefix specifies the string which is prefixed to the name of
 	// annotation fields. It defaults to Λ.
 	AnnotationPrefix string
+	// AddYangPresence specifies whether tags should be added to the generated
+	// fields of a struct. When set to true, a struct tag will be added to the field
+	// when a YANG container is a presence container
+	// https://datatracker.ietf.org/doc/html/rfc6020#section-7.5.1
+	// a field tag of `yangPresence="true"` will only be added if the container is
+	// a YANG presence container, and will be omitted if this is not the case.
+	AddYangPresence bool
 	// GenerateGetters specifies whether GetOrCreate* methods should be created
 	// for struct pointer (YANG container) and map (YANG list) fields of generated
 	// structs.

ygen/codegen_test.go

@@ -1171,6 +1171,22 @@ func TestSimpleStructs(t *testing.T) {
 			},
 		},
 		wantErrSubstring: "has a union key containing a binary",
+	}, {
+		name:    "module with presence containers",
+		inFiles: []string{filepath.Join(datapath, "presence-container-example.yang")},
+		inConfig: GeneratorConfig{
+			TransformationOptions: TransformationOpts{
+				GenerateFakeRoot: true,
+				FakeRootName:     "device",
+			},
+			GoOptions: GoOpts{
+				GenerateSimpleUnions:    true,
+				GenerateLeafGetters:     true,
+				GeneratePopulateDefault: true,
+				AddYangPresence:         true,
+			},
+		},
+		wantStructsCodeFile: filepath.Join(TestRoot, "testdata/structs/presence-container-example.formatted-txt"),
 	}}
 
 	for _, tt := range tests {

ygen/gogen.go

@@ -1699,6 +1699,15 @@ func writeGoStruct(targetStruct *Directory, goStructElements map[string]*Directo
 
 		metadataTagBuf.WriteString(` ygotAnnotation:"true"`)
 
+		if goOpts.AddYangPresence {
+			// TODO(wenovus):
+			// a presence container is an unimplemented keyword in goyang.
+			// if and when this changes, the field lookup below would need to change as well.
+			if field.IsContainer() && len(field.Extra["presence"]) > 0 {
+				tagBuf.WriteString(` yangPresence:"true"`)
+			}
+		}
+
 		fieldDef.Tags = tagBuf.String()
 
 		// Append the generated field definition to the set of fields of the struct.

ygen/gogen_test.go

@@ -536,6 +536,135 @@ func (t *InputStruct) Validate(opts ...ygot.ValidationOption) error {
 // that are included in the generated code.
 func (t *InputStruct) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }
 
+// ΛBelongingModule returns the name of the module in whose namespace
+// InputStruct belongs.
+func (*InputStruct) ΛBelongingModule() string {
+	return "exmod"
+}
+`,
+		},
+	}, {
+		name: "nested container in struct with presence container",
+		inStructToMap: &Directory{
+			Name: "InputStruct",
+			Entry: &yang.Entry{
+				Name: "input-struct",
+				Parent: &yang.Entry{
+					Name: "root-module",
+					Node: &yang.Module{
+						Name: "exmod",
+						Namespace: &yang.Value{
+							Name: "u:exmod",
+						},
+						Modules: modules,
+					},
+				},
+				Node: &yang.Module{
+					Name: "exmod",
+					Namespace: &yang.Value{
+						Name: "u:exmod",
+					},
+					Modules: modules,
+				},
+				Extra: map[string][]interface{}{
+					"presence": {&yang.Value{Name: "presence c1"}},
+				},
+			},
+			Fields: map[string]*yang.Entry{
+				"c1": {
+					Name: "c1",
+					Dir:  map[string]*yang.Entry{},
+					Kind: yang.DirectoryEntry,
+					Parent: &yang.Entry{
+						Name: "input-struct",
+						Parent: &yang.Entry{
+							Name: "root-module",
+							Node: &yang.Module{
+								Name: "exmod",
+								Namespace: &yang.Value{
+									Name: "u:exmod",
+								},
+								Modules: modules,
+							},
+						},
+					},
+					Node: &yang.Leaf{
+						Parent: &yang.Module{
+							Name: "exmod",
+							Namespace: &yang.Value{
+								Name: "u:exmod",
+							},
+							Modules: modules,
+						},
+					},
+					Extra: map[string][]interface{}{
+						"presence": {&yang.Value{Name: "presence c1"}},
+					},
+				},
+			},
+			Path: []string{"", "root-module", "input-struct"},
+		},
+		inGoOpts: GoOpts{
+			AddYangPresence: true,
+		},
+		inUniqueDirectoryNames: map[string]string{"/root-module/input-struct/c1": "InputStruct_C1"},
+		wantCompressed: wantGoStructOut{
+			structs: `
+// InputStruct represents the /root-module/input-struct YANG schema element.
+type InputStruct struct {
+	C1	*InputStruct_C1	` + "`" + `path:"c1" module:"exmod" yangPresence:"true"` + "`" + `
+}
+
+// IsYANGGoStruct ensures that InputStruct implements the yang.GoStruct
+// interface. This allows functions that need to handle this struct to
+// identify it as being generated by ygen.
+func (*InputStruct) IsYANGGoStruct() {}
+`,
+			methods: `
+// Validate validates s against the YANG schema corresponding to its type.
+func (t *InputStruct) Validate(opts ...ygot.ValidationOption) error {
+	if err := ytypes.Validate(SchemaTree["InputStruct"], t, opts...); err != nil {
+		return err
+	}
+	return nil
+}
+
+// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
+// that are included in the generated code.
+func (t *InputStruct) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }
+
+// ΛBelongingModule returns the name of the module in whose namespace
+// InputStruct belongs.
+func (*InputStruct) ΛBelongingModule() string {
+	return "exmod"
+}
+`,
+		},
+		wantUncompressed: wantGoStructOut{
+			structs: `
+// InputStruct represents the /root-module/input-struct YANG schema element.
+type InputStruct struct {
+	C1	*InputStruct_C1	` + "`" + `path:"c1" module:"exmod" yangPresence:"true"` + "`" + `
+}
+
+// IsYANGGoStruct ensures that InputStruct implements the yang.GoStruct
+// interface. This allows functions that need to handle this struct to
+// identify it as being generated by ygen.
+func (*InputStruct) IsYANGGoStruct() {}
+`,
+			methods: `
+// Validate validates s against the YANG schema corresponding to its type.
+func (t *InputStruct) Validate(opts ...ygot.ValidationOption) error {
+	if err := ytypes.Validate(SchemaTree["InputStruct"], t, opts...); err != nil {
+		return err
+	}
+	return nil
+}
+
+// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
+// that are included in the generated code.
+func (t *InputStruct) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }
+
 // ΛBelongingModule returns the name of the module in whose namespace
 // InputStruct belongs.
 func (*InputStruct) ΛBelongingModule() string {