Debug grpc to fetch subscribe preferences of a yang path

Makefile

@@ -91,6 +91,24 @@ endif
 swsscommon_wrap:
 	make -C swsscommon
 
+.SECONDEXPANSION:
+
+PROTOC_PATH := $(PATH):$(GOBIN)
+PROTOC_OPTS := -I$(CURDIR)/vendor -I/usr/local/include -I/usr/include
+
+# Generate following go & grpc bindings using teh legacy protoc-gen-go
+PROTO_GO_BINDINGS += proto/sonic_internal.pb.go
+PROTO_GO_BINDINGS += proto/gnoi/sonic_debug.pb.go
+
+$(PROTO_GO_BINDINGS): $$(patsubst %.pb.go,%.proto,$$@) | $(GOBIN)/protoc-gen-go
+	PATH=$(PROTOC_PATH) protoc -I$(@D) $(PROTOC_OPTS) --go_out=plugins=grpc:$(@D) $<
+
+$(GOBIN)/protoc-gen-go:
+	cd $$(mktemp -d) && \
+	$(GO) mod init protoc && \
+	$(GO) install github.com/golang/protobuf/protoc-gen-go
+
+
 DBCONFG = $(DBDIR)/database_config.json
 ENVFILE = build/test/env.txt
 TESTENV = $(shell cat $(ENVFILE))

gnmi_server/debug.go

@@ -0,0 +1,108 @@
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+//  Copyright 2023 Broadcom. The term Broadcom refers to Broadcom Inc. and/or //
+//  its subsidiaries.                                                         //
+//                                                                            //
+//  Licensed under the Apache License, Version 2.0 (the "License");           //
+//  you may not use this file except in compliance with the License.          //
+//  You may obtain a copy of the License at                                   //
+//                                                                            //
+//     http://www.apache.org/licenses/LICENSE-2.0                             //
+//                                                                            //
+//  Unless required by applicable law or agreed to in writing, software       //
+//  distributed under the License is distributed on an "AS IS" BASIS,         //
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  //
+//  See the License for the specific language governing permissions and       //
+//  limitations under the License.                                            //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+package gnmi
+
+import (
+	"sort"
+	"time"
+
+	"github.com/Azure/sonic-mgmt-common/translib"
+	"github.com/Azure/sonic-mgmt-common/translib/path"
+	gnmipb "github.com/openconfig/gnmi/proto/gnmi"
+	"github.com/sonic-net/sonic-gnmi/common_utils"
+	spb_gnoi "github.com/sonic-net/sonic-gnmi/proto/gnoi"
+	"github.com/sonic-net/sonic-gnmi/transl_utils"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (srv *Server) GetSubscribePreferences(req *spb_gnoi.SubscribePreferencesReq, stream spb_gnoi.Debug_GetSubscribePreferencesServer) error {
+	ctx := stream.Context()
+	ctx, err := authenticate(srv.config.UserAuth, ctx)
+	if err != nil {
+		return err
+	}
+
+	translPaths := make([]translib.IsSubscribePath, 0, len(req.GetPath()))
+	for i, p := range req.GetPath() {
+		reqPath, err := transl_utils.ConvertToURI(nil, p,
+			&path.AppendModulePrefix{}, &path.AddWildcardKeys{})
+		if err != nil {
+			return status.Error(codes.InvalidArgument, "Unknown path: "+path.String(p))
+		}
+
+		translPaths = append(translPaths, translib.IsSubscribePath{
+			ID:   uint32(i),
+			Path: reqPath,
+			Mode: translib.TargetDefined,
+		})
+	}
+
+	rc, _ := common_utils.GetContext(ctx)
+	trResp, err := translib.IsSubscribeSupported(translib.IsSubscribeRequest{
+		Paths: translPaths,
+		User:  translib.UserRoles{Name: rc.Auth.User, Roles: rc.Auth.Roles},
+	})
+	if err != nil {
+		return status.Error(codes.InvalidArgument, err.Error())
+	}
+
+	// When the path supports on_change but some of its subpaths do not, extra entries
+	// gets appended with same request ID. Group such entries by ID.
+	sort.Slice(trResp, func(i, j int) bool {
+		return trResp[i].ID < trResp[j].ID ||
+			(trResp[i].ID == trResp[j].ID && trResp[i].Path < trResp[j].Path)
+	})
+
+	for _, r := range trResp {
+		pathStr, err := path.New(r.Path)
+		if err != nil {
+			return status.Error(codes.Internal, err.Error())
+		}
+		pref := &spb_gnoi.SubscribePreference{
+			Path:              pathStr,
+			WildcardSupported: r.IsWildcardSupported,
+			OnChangeSupported: r.IsOnChangeSupported,
+			TargetDefinedMode: gnmipb.SubscriptionMode_SAMPLE,
+			MinSampleInterval: uint64(r.MinInterval) * uint64(time.Second),
+		}
+		if !r.IsSubPath && hasOnChangeDisabledSubpath(r.ID, trResp) {
+			pref.OnChangeSupported = false
+		}
+		if r.IsOnChangeSupported && r.PreferredType == translib.OnChange {
+			pref.TargetDefinedMode = gnmipb.SubscriptionMode_ON_CHANGE
+		}
+
+		if err = stream.Send(pref); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func hasOnChangeDisabledSubpath(id uint32, allPrefs []*translib.IsSubscribeResponse) bool {
+	for _, p := range allPrefs {
+		if p.ID == id && p.IsSubPath && !p.IsOnChangeSupported {
+			return true
+		}
+	}
+	return false
+}

gnmi_server/server.go

@@ -163,6 +163,7 @@ func NewServer(config *Config, opts []grpc.ServerOption) (*Server, error) {
 	if srv.config.EnableTranslibWrite {		
 		spb_gnoi.RegisterSonicServiceServer(srv.s, srv)
 	}
+	spb_gnoi.RegisterDebugServer(srv.s, srv)
 	log.V(1).Infof("Created Server on %s, read-only: %t", srv.Address(), !srv.config.EnableTranslibWrite)
 	return srv, nil
 }

gnmi_server/server_test.go

@@ -99,6 +99,20 @@ func loadDBNotStrict(t *testing.T, rclient *redis.Client, mpi map[string]interfa
 	}
 }
 
+func createClient(t *testing.T, port int) *grpc.ClientConn {
+	t.Helper()
+	cred := credentials.NewTLS(&tls.Config{InsecureSkipVerify: true})
+	conn, err := grpc.Dial(
+		fmt.Sprintf("127.0.0.1:%d", port),
+		grpc.WithTransportCredentials(cred),
+	)
+	if err != nil {
+		t.Fatalf("Dialing to :%d failed: %v", port, err)
+	}
+	t.Cleanup(func() { conn.Close() })
+	return conn
+}
+
 func createServer(t *testing.T, port int64) *Server {
 	t.Helper()
 	certificate, err := testcert.NewCert()

gnmi_server/transl_sub_test.go

@@ -3,6 +3,7 @@ package gnmi
 import (
 	"crypto/tls"
 	"fmt"
+	"io"
 	"path/filepath"
 	"reflect"
 	"strings"
@@ -18,11 +19,10 @@ import (
 	extnpb "github.com/openconfig/gnmi/proto/gnmi_ext"
 	"github.com/openconfig/ygot/ygot"
 	spb "github.com/sonic-net/sonic-gnmi/proto"
+	spb_gnoi "github.com/sonic-net/sonic-gnmi/proto/gnoi"
 	dbconfig "github.com/sonic-net/sonic-gnmi/sonic_db_config"
 	"golang.org/x/net/context"
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/status"
 )
 
@@ -875,17 +875,11 @@ func doSet(t *testing.T, data ...interface{}) {
 		}
 	}
 
-	cred := credentials.NewTLS(&tls.Config{InsecureSkipVerify: true})
-	conn, err := grpc.Dial("127.0.0.1:8081", grpc.WithTransportCredentials(cred))
-	if err != nil {
-		t.Fatalf("Could not create client: %v", err)
-	}
-
+	client := gnmipb.NewGNMIClient(createClient(t, 8081))
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
-	defer conn.Close()
 
-	_, err = gnmipb.NewGNMIClient(conn).Set(ctx, req)
+	_, err := client.Set(ctx, req)
 	if err != nil {
 		t.Fatalf("Set failed: %v", err)
 	}
@@ -935,3 +929,155 @@ func newBundleVersion(t *testing.T, version string) *extnpb.Extension {
 	ext := &extnpb.RegisteredExtension{Id: spb.BUNDLE_VERSION_EXT, Msg: v}
 	return &extnpb.Extension{Ext: &extnpb.Extension_RegisteredExt{RegisteredExt: ext}}
 }
+
+func TestDebugSubscribePreferences(t *testing.T) {
+	s := createServer(t, 8081)
+	go runServer(t, s)
+	defer s.s.Stop()
+
+	ifTop := &spb_gnoi.SubscribePreference{
+		Path:              strToPath("/openconfig-interfaces:interfaces/interface[name=*]"),
+		OnChangeSupported: false,
+		TargetDefinedMode: ON_CHANGE,
+		WildcardSupported: true,
+	}
+	ifMtu := &spb_gnoi.SubscribePreference{
+		Path:              strToPath("/openconfig-interfaces:interfaces/interface[name=*]/config/mtu"),
+		OnChangeSupported: true,
+		TargetDefinedMode: ON_CHANGE,
+		WildcardSupported: true,
+	}
+	ifStat := &spb_gnoi.SubscribePreference{
+		Path:              strToPath("/openconfig-interfaces:interfaces/interface[name=*]/state/counters"),
+		OnChangeSupported: false,
+		TargetDefinedMode: SAMPLE,
+		WildcardSupported: true,
+	}
+	aclConfig := &spb_gnoi.SubscribePreference{
+		Path:              strToPath("/openconfig-acl:acl/acl-sets/acl-set[name=*][type=*]/config"),
+		OnChangeSupported: true,
+		TargetDefinedMode: ON_CHANGE,
+		WildcardSupported: true,
+	}
+	yanglib := &spb_gnoi.SubscribePreference{
+		Path:              strToPath("/ietf-yang-library:modules-state/module-set-id"),
+		OnChangeSupported: false,
+		TargetDefinedMode: SAMPLE,
+		WildcardSupported: false,
+	}
+
+	t.Run("invalid_path", func(t *testing.T) {
+		_, err := getSubscribePreferences(t, nil)
+		if res, _ := status.FromError(err); res.Code() != codes.InvalidArgument {
+			t.Fatalf("Expecting InvalidArgument error; got %v", err)
+		}
+	})
+
+	t.Run("unknown_path", func(t *testing.T) {
+		_, err := getSubscribePreferences(t, strToPath("/unknown"))
+		if res, _ := status.FromError(err); res.Code() != codes.InvalidArgument {
+			t.Fatalf("Expecting InvalidArgument error; got %v", err)
+		}
+	})
+
+	t.Run("onchange_supported", func(t *testing.T) {
+		verifySubscribePreferences(t,
+			[]*gnmipb.Path{ifMtu.Path},
+			[]*spb_gnoi.SubscribePreference{ifMtu})
+	})
+
+	t.Run("onchange_unsupported", func(t *testing.T) {
+		verifySubscribePreferences(t,
+			[]*gnmipb.Path{ifStat.Path},
+			[]*spb_gnoi.SubscribePreference{ifStat})
+	})
+
+	t.Run("onchange_mixed", func(t *testing.T) {
+		verifySubscribePreferences(t,
+			[]*gnmipb.Path{ifTop.Path},
+			[]*spb_gnoi.SubscribePreference{ifTop, ifStat})
+	})
+
+	t.Run("nondb_path", func(t *testing.T) {
+		verifySubscribePreferences(t,
+			[]*gnmipb.Path{yanglib.Path},
+			[]*spb_gnoi.SubscribePreference{yanglib})
+	})
+
+	t.Run("unprefixed_path", func(t *testing.T) {
+		verifySubscribePreferences(t,
+			[]*gnmipb.Path{strToPath("/acl/acl-sets/acl-set/config")},
+			[]*spb_gnoi.SubscribePreference{aclConfig})
+	})
+
+	t.Run("multiple_paths", func(t *testing.T) {
+		verifySubscribePreferences(t,
+			[]*gnmipb.Path{yanglib.Path, ifTop.Path, aclConfig.Path},
+			[]*spb_gnoi.SubscribePreference{yanglib, ifTop, ifStat, aclConfig})
+	})
+}
+
+func TestDebugSubscribePreferences_dummy(t *testing.T) {
+	// Dummy testcase to increase code coverage !!!
+	f := func(_ ...interface{}) {}
+	for _, m := range []*spb_gnoi.SubscribePreferencesReq{nil, {}} {
+		f(m.String(), m.GetPath())
+		f(m.Descriptor())
+	}
+	for _, p := range []*spb_gnoi.SubscribePreference{nil, {}} {
+		f(p.String(), p.GetPath(), p.GetOnChangeSupported(), p.GetTargetDefinedMode(), p.GetWildcardSupported(), p.GetMinSampleInterval())
+		f(p.Descriptor())
+	}
+}
+
+func getSubscribePreferences(t *testing.T, paths ...*gnmipb.Path) ([]*spb_gnoi.SubscribePreference, error) {
+	t.Helper()
+	client := spb_gnoi.NewDebugClient(createClient(t, 8081))
+	stream, err := client.GetSubscribePreferences(
+		context.Background(),
+		&spb_gnoi.SubscribePreferencesReq{Path: paths},
+	)
+	if err != nil {
+		t.Fatalf("Could not invoke GetSubscribePreferences: %v", err)
+	}
+
+	var prefs []*spb_gnoi.SubscribePreference
+	for {
+		if p, err := stream.Recv(); err == nil {
+			prefs = append(prefs, p)
+		} else if err == io.EOF {
+			break
+		} else {
+			return prefs, err
+		}
+	}
+
+	return prefs, nil
+}
+
+func verifySubscribePreferences(t *testing.T, paths []*gnmipb.Path, exp []*spb_gnoi.SubscribePreference) {
+	t.Helper()
+	resp, err := getSubscribePreferences(t, paths...)
+	if err != nil {
+		t.Fatalf("GetSubscribePreferences returned error: %v", err)
+	}
+	if len(resp) != len(exp) {
+		t.Fatalf("Expected: %s\nReceived: %s", prefsText(exp), prefsText(resp))
+	}
+	for i, ex := range exp {
+		if ex.MinSampleInterval == 0 {
+			resp[i].MinSampleInterval = 0 // ignore MinSampleInterval for comparison
+		}
+		if !proto.Equal(ex, resp[i]) {
+			t.Fatalf("Expected: %s\nReceived: %s", prefsText(exp), prefsText(resp))
+		}
+	}
+}
+
+func prefsText(prefs []*spb_gnoi.SubscribePreference) string {
+	var s []string
+	for _, p := range prefs {
+		s = append(s, proto.MarshalTextString(p))
+	}
+	return "[\n" + strings.Join(s, "\n") + "]"
+}