From 63b11995e4706acf7dc57e30eaccd5b4026b64c8 Mon Sep 17 00:00:00 2001 From: Alexander Peretyatko Date: Fri, 24 Nov 2023 11:30:18 +0700 Subject: [PATCH 01/10] Task:768 Add interface names into NSM metrics Signed-off-by: Alexander Peretyatko Signed-off-by: Nikita Skrynnik --- .../common/mechanisms/client.go | 33 ++++++++-- .../common/mechanisms/common.go | 64 ++++++++++++++++++- .../common/mechanisms/server.go | 29 +++++++-- 3 files changed, 115 insertions(+), 11 deletions(-) diff --git a/pkg/networkservice/common/mechanisms/client.go b/pkg/networkservice/common/mechanisms/client.go index fc7ae7446..418065949 100644 --- a/pkg/networkservice/common/mechanisms/client.go +++ b/pkg/networkservice/common/mechanisms/client.go @@ -1,4 +1,4 @@ -// Copyright (c) 2021 Doc.ai and/or its affiliates. +// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -28,13 +28,24 @@ import ( ) type mechanismsClient struct { - mechanisms map[string]networkservice.NetworkServiceClient + mechanisms map[string]networkservice.NetworkServiceClient + withMetrics bool } // NewClient - returns a new mechanisms networkservicemesh.NetworkServiceClient func NewClient(mechanisms map[string]networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { + return newClient(mechanisms, false) +} + +// NewClientWithMetrics - same as NewClient, but will also print the interface type/name metric to Path +func NewClientWithMetrics(mechanisms map[string]networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { + return newClient(mechanisms, true) +} + +func newClient(mechanisms map[string]networkservice.NetworkServiceClient, withMetrics bool) networkservice.NetworkServiceClient { result := &mechanismsClient{ - mechanisms: make(map[string]networkservice.NetworkServiceClient), + mechanisms: make(map[string]networkservice.NetworkServiceClient), + withMetrics: withMetrics, } for m, c := range mechanisms { result.mechanisms[m] = chain.NewNetworkServiceClient(c) @@ -44,9 +55,13 @@ func NewClient(mechanisms map[string]networkservice.NetworkServiceClient) networ } func (mc *mechanismsClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { - if request.GetConnection().GetMechanism() != nil { - srv, ok := mc.mechanisms[request.GetConnection().GetMechanism().GetType()] + mech := request.GetConnection().GetMechanism() + if mech != nil { + srv, ok := mc.mechanisms[mech.GetType()] if ok { + if mc.withMetrics { + storeMetrics(request.GetConnection(), mech, true) + } return srv.Request(ctx, request, opts...) } return nil, errUnsupportedMech @@ -57,6 +72,11 @@ func (mc *mechanismsClient) Request(ctx context.Context, request *networkservice if ok { req := request.Clone() var resp *networkservice.Connection + + if mc.withMetrics { + storeMetrics(req.GetConnection(), mechanism, true) + } + resp, respErr := cm.Request(ctx, req, opts...) if respErr == nil { return resp, nil @@ -70,6 +90,9 @@ func (mc *mechanismsClient) Request(ctx context.Context, request *networkservice func (mc *mechanismsClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { c, ok := mc.mechanisms[conn.GetMechanism().GetType()] if ok { + if mc.withMetrics { + storeMetrics(conn, conn.GetMechanism(), true) + } return c.Close(ctx, conn) } return nil, errCannotSupportMech diff --git a/pkg/networkservice/common/mechanisms/common.go b/pkg/networkservice/common/mechanisms/common.go index 4dbf7b8a3..b3852e142 100644 --- a/pkg/networkservice/common/mechanisms/common.go +++ b/pkg/networkservice/common/mechanisms/common.go @@ -1,4 +1,4 @@ -// Copyright (c) 2021 Doc.ai and/or its affiliates. +// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -16,7 +16,67 @@ package mechanisms -import "github.com/pkg/errors" +import ( + "fmt" + + "github.com/networkservicemesh/api/pkg/api/networkservice" + "github.com/pkg/errors" +) var errCannotSupportMech = errors.New("cannot support any of the requested mechanism") var errUnsupportedMech = errors.New("unsupported mechanism") + +const ( + clientMetricKey = "client_interface" + serverMetricKey = "server_interface" + nameKey = "name" + unresolvedName = "unknown" +) + +type interfacesInfo struct { + interfaceName string + interfaceType string +} + +func (i *interfacesInfo) getInterfaceDetails() string { + return fmt.Sprintf("%s/%s", i.interfaceType, i.interfaceName) +} + +// Save interface details in Path +func storeMetrics(conn *networkservice.Connection, mechanism *networkservice.Mechanism, isClient bool) { + path := conn.GetPath() + if path == nil { + return + } + + segments := path.GetPathSegments() + if segments == nil { + return + } + + segment := segments[path.Index] + params := mechanism.GetParameters() + + name := unresolvedName + if params != nil { + name = params[nameKey] + } + + info := &interfacesInfo{ + interfaceName: name, + interfaceType: mechanism.GetType(), + } + + if segment.Metrics == nil { + segment.Metrics = make(map[string]string) + } + + metricKey := clientMetricKey + if !isClient { + metricKey = serverMetricKey + } + + if _, ok := segment.Metrics[metricKey]; !ok { + segment.Metrics[metricKey] = info.getInterfaceDetails() + } +} diff --git a/pkg/networkservice/common/mechanisms/server.go b/pkg/networkservice/common/mechanisms/server.go index 602a9e972..32000fc3c 100644 --- a/pkg/networkservice/common/mechanisms/server.go +++ b/pkg/networkservice/common/mechanisms/server.go @@ -31,7 +31,8 @@ import ( ) type mechanismsServer struct { - mechanisms map[string]networkservice.NetworkServiceServer // key is Mechanism.Type + mechanisms map[string]networkservice.NetworkServiceServer // key is Mechanism.Type + withMetrics bool } // NewServer - returns new NetworkServiceServer chain element that will attempt to meet the request.MechanismPreferences using @@ -42,8 +43,18 @@ type mechanismsServer struct { // value: NetworkServiceServer that only handles the work for the specified mechanismType // Note: Supplied NetworkServiceServer elements should not call next.Server(ctx).{Request,Close} themselves func NewServer(mechanisms map[string]networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { + return newServer(mechanisms, false) +} + +// NewServerWithMetrics - same as NewServer, but will also print the interface type/name metric to Path +func NewServerWithMetrics(mechanisms map[string]networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { + return newServer(mechanisms, true) +} + +func newServer(mechanisms map[string]networkservice.NetworkServiceServer, withMetrics bool) networkservice.NetworkServiceServer { rv := &mechanismsServer{ - mechanisms: make(map[string]networkservice.NetworkServiceServer), + mechanisms: make(map[string]networkservice.NetworkServiceServer), + withMetrics: withMetrics, } for mechanismType, server := range mechanisms { // We wrap in a chain here to make sure that if the 'server' is calling next.Server(ctx) it doesn't @@ -54,9 +65,13 @@ func NewServer(mechanisms map[string]networkservice.NetworkServiceServer) networ } func (ms *mechanismsServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { - if request.GetConnection().GetMechanism() != nil { - srv, ok := ms.mechanisms[request.GetConnection().GetMechanism().GetType()] + mech := request.GetConnection().GetMechanism() + if mech != nil { + srv, ok := ms.mechanisms[mech.GetType()] if ok { + if ms.withMetrics { + storeMetrics(request.GetConnection(), mech, false) + } return srv.Request(ctx, request) } return nil, errors.WithStack(errUnsupportedMech) @@ -70,6 +85,9 @@ func (ms *mechanismsServer) Request(ctx context.Context, request *networkservice var resp *networkservice.Connection resp, respErr := srv.Request(ctx, req) if respErr == nil { + if ms.withMetrics { + storeMetrics(resp, resp.GetMechanism(), false) + } return resp, nil } err = errors.Wrap(err, respErr.Error()) @@ -81,6 +99,9 @@ func (ms *mechanismsServer) Request(ctx context.Context, request *networkservice func (ms *mechanismsServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { srv, ok := ms.mechanisms[conn.GetMechanism().GetType()] if ok { + if ms.withMetrics { + storeMetrics(conn, conn.GetMechanism(), false) + } return srv.Close(ctx, conn) } return nil, errCannotSupportMech From 0e9c62fd5eb1c196434adc01fb88ba78429c9eb3 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Fri, 29 Dec 2023 23:03:48 +1100 Subject: [PATCH 02/10] remove withMetrics flag from client and server Signed-off-by: Nikita Skrynnik --- .../common/mechanisms/client.go | 28 +++--------- .../common/mechanisms/client_test.go | 24 ++++++++++ .../common/mechanisms/server.go | 27 +++-------- .../common/mechanisms/server_test.go | 45 +++++++++++++++---- 4 files changed, 71 insertions(+), 53 deletions(-) diff --git a/pkg/networkservice/common/mechanisms/client.go b/pkg/networkservice/common/mechanisms/client.go index 418065949..0bbaabe2c 100644 --- a/pkg/networkservice/common/mechanisms/client.go +++ b/pkg/networkservice/common/mechanisms/client.go @@ -28,24 +28,13 @@ import ( ) type mechanismsClient struct { - mechanisms map[string]networkservice.NetworkServiceClient - withMetrics bool + mechanisms map[string]networkservice.NetworkServiceClient } // NewClient - returns a new mechanisms networkservicemesh.NetworkServiceClient func NewClient(mechanisms map[string]networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { - return newClient(mechanisms, false) -} - -// NewClientWithMetrics - same as NewClient, but will also print the interface type/name metric to Path -func NewClientWithMetrics(mechanisms map[string]networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { - return newClient(mechanisms, true) -} - -func newClient(mechanisms map[string]networkservice.NetworkServiceClient, withMetrics bool) networkservice.NetworkServiceClient { result := &mechanismsClient{ - mechanisms: make(map[string]networkservice.NetworkServiceClient), - withMetrics: withMetrics, + mechanisms: make(map[string]networkservice.NetworkServiceClient), } for m, c := range mechanisms { result.mechanisms[m] = chain.NewNetworkServiceClient(c) @@ -59,9 +48,7 @@ func (mc *mechanismsClient) Request(ctx context.Context, request *networkservice if mech != nil { srv, ok := mc.mechanisms[mech.GetType()] if ok { - if mc.withMetrics { - storeMetrics(request.GetConnection(), mech, true) - } + storeMetrics(request.GetConnection(), mech, true) return srv.Request(ctx, request, opts...) } return nil, errUnsupportedMech @@ -72,10 +59,7 @@ func (mc *mechanismsClient) Request(ctx context.Context, request *networkservice if ok { req := request.Clone() var resp *networkservice.Connection - - if mc.withMetrics { - storeMetrics(req.GetConnection(), mechanism, true) - } + storeMetrics(req.GetConnection(), mechanism, true) resp, respErr := cm.Request(ctx, req, opts...) if respErr == nil { @@ -90,9 +74,7 @@ func (mc *mechanismsClient) Request(ctx context.Context, request *networkservice func (mc *mechanismsClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { c, ok := mc.mechanisms[conn.GetMechanism().GetType()] if ok { - if mc.withMetrics { - storeMetrics(conn, conn.GetMechanism(), true) - } + storeMetrics(conn, conn.GetMechanism(), true) return c.Close(ctx, conn) } return nil, errCannotSupportMech diff --git a/pkg/networkservice/common/mechanisms/client_test.go b/pkg/networkservice/common/mechanisms/client_test.go index 4fc146448..55a563efe 100644 --- a/pkg/networkservice/common/mechanisms/client_test.go +++ b/pkg/networkservice/common/mechanisms/client_test.go @@ -18,6 +18,7 @@ package mechanisms_test import ( "context" + "fmt" "testing" "github.com/pkg/errors" @@ -178,3 +179,26 @@ func Test_Client_DontCallNextByItself(t *testing.T) { assert.Nil(t, err) assert.Equal(t, 2, len(ch)) } + +func Test_Client_Metrics(t *testing.T) { + c := client() + + metricsKey := "client_interface" + ifnameKey := "name" + ifname := "nsm-1" + + for _, request := range permuteOverMechanismPreferenceOrder(request()) { + request.MechanismPreferences[0].Parameters[ifnameKey] = ifname + request.Connection.Path = &networkservice.Path{ + PathSegments: make([]*networkservice.PathSegment, 1), + Index: 0, + } + + conn, err := c.Request(context.Background(), request) + require.NoError(t, err) + require.NotNil(t, conn.Path) + require.Len(t, conn.Path.PathSegments, 1) + require.NotNil(t, conn.Path.PathSegments[0].Metrics) + require.Equal(t, fmt.Sprintf("%s/%s", request.MechanismPreferences[0].Type, ifname), conn.Path.PathSegments[0].Metrics[metricsKey]) + } +} diff --git a/pkg/networkservice/common/mechanisms/server.go b/pkg/networkservice/common/mechanisms/server.go index 32000fc3c..95ff60994 100644 --- a/pkg/networkservice/common/mechanisms/server.go +++ b/pkg/networkservice/common/mechanisms/server.go @@ -31,8 +31,7 @@ import ( ) type mechanismsServer struct { - mechanisms map[string]networkservice.NetworkServiceServer // key is Mechanism.Type - withMetrics bool + mechanisms map[string]networkservice.NetworkServiceServer // key is Mechanism.Type } // NewServer - returns new NetworkServiceServer chain element that will attempt to meet the request.MechanismPreferences using @@ -43,18 +42,8 @@ type mechanismsServer struct { // value: NetworkServiceServer that only handles the work for the specified mechanismType // Note: Supplied NetworkServiceServer elements should not call next.Server(ctx).{Request,Close} themselves func NewServer(mechanisms map[string]networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return newServer(mechanisms, false) -} - -// NewServerWithMetrics - same as NewServer, but will also print the interface type/name metric to Path -func NewServerWithMetrics(mechanisms map[string]networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return newServer(mechanisms, true) -} - -func newServer(mechanisms map[string]networkservice.NetworkServiceServer, withMetrics bool) networkservice.NetworkServiceServer { rv := &mechanismsServer{ - mechanisms: make(map[string]networkservice.NetworkServiceServer), - withMetrics: withMetrics, + mechanisms: make(map[string]networkservice.NetworkServiceServer), } for mechanismType, server := range mechanisms { // We wrap in a chain here to make sure that if the 'server' is calling next.Server(ctx) it doesn't @@ -69,9 +58,7 @@ func (ms *mechanismsServer) Request(ctx context.Context, request *networkservice if mech != nil { srv, ok := ms.mechanisms[mech.GetType()] if ok { - if ms.withMetrics { - storeMetrics(request.GetConnection(), mech, false) - } + storeMetrics(request.GetConnection(), mech, false) return srv.Request(ctx, request) } return nil, errors.WithStack(errUnsupportedMech) @@ -85,9 +72,7 @@ func (ms *mechanismsServer) Request(ctx context.Context, request *networkservice var resp *networkservice.Connection resp, respErr := srv.Request(ctx, req) if respErr == nil { - if ms.withMetrics { - storeMetrics(resp, resp.GetMechanism(), false) - } + storeMetrics(resp, resp.GetMechanism(), false) return resp, nil } err = errors.Wrap(err, respErr.Error()) @@ -99,9 +84,7 @@ func (ms *mechanismsServer) Request(ctx context.Context, request *networkservice func (ms *mechanismsServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { srv, ok := ms.mechanisms[conn.GetMechanism().GetType()] if ok { - if ms.withMetrics { - storeMetrics(conn, conn.GetMechanism(), false) - } + storeMetrics(conn, conn.GetMechanism(), false) return srv.Close(ctx, conn) } return nil, errCannotSupportMech diff --git a/pkg/networkservice/common/mechanisms/server_test.go b/pkg/networkservice/common/mechanisms/server_test.go index 8f447f871..08730d2ac 100644 --- a/pkg/networkservice/common/mechanisms/server_test.go +++ b/pkg/networkservice/common/mechanisms/server_test.go @@ -22,6 +22,7 @@ package mechanisms_test import ( "context" + "fmt" "testing" "github.com/pkg/errors" @@ -62,20 +63,24 @@ func request() *networkservice.NetworkServiceRequest { Connection: &networkservice.Connection{}, MechanismPreferences: []*networkservice.Mechanism{ { - Cls: cls.LOCAL, - Type: memif.MECHANISM, + Cls: cls.LOCAL, + Type: memif.MECHANISM, + Parameters: make(map[string]string), }, { - Cls: cls.LOCAL, - Type: kernel.MECHANISM, + Cls: cls.LOCAL, + Type: kernel.MECHANISM, + Parameters: make(map[string]string), }, { - Cls: cls.REMOTE, - Type: srv6.MECHANISM, + Cls: cls.REMOTE, + Type: srv6.MECHANISM, + Parameters: make(map[string]string), }, { - Cls: cls.REMOTE, - Type: vxlan.MECHANISM, + Cls: cls.REMOTE, + Type: vxlan.MECHANISM, + Parameters: make(map[string]string), }, }, } @@ -239,3 +244,27 @@ func TestDontCallNextByItself(t *testing.T) { assert.Nil(t, err) assert.Equal(t, 2, len(ch)) } + +func TestMetrics(t *testing.T) { + s := server() + + metricsKey := "server_interface" + ifnameKey := "name" + ifname := "nsm-1" + + for _, request := range permuteOverMechanismPreferenceOrder(request()) { + request.MechanismPreferences[0].Parameters[ifnameKey] = ifname + request.Connection.Path = &networkservice.Path{ + PathSegments: make([]*networkservice.PathSegment, 1), + Index: 0, + } + + conn, err := s.Request(context.Background(), request) + require.NoError(t, err) + require.NotNil(t, conn.Path) + require.Len(t, conn.Path.PathSegments, 1) + require.NotNil(t, conn.Path.PathSegments[0].Metrics) + + require.Equal(t, fmt.Sprintf("%s/%s", request.MechanismPreferences[0].Type, ifname), conn.Path.PathSegments[0].Metrics[metricsKey]) + } +} From 4dd6ec45203d2d1397bdc8b73e43a6c23881c254 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Wed, 10 Jan 2024 15:17:16 +1100 Subject: [PATCH 03/10] fix combine tests Signed-off-by: Nikita Skrynnik --- .../chains/endpoint/combine_test.go | 87 ++++++++++++------- 1 file changed, 54 insertions(+), 33 deletions(-) diff --git a/pkg/networkservice/chains/endpoint/combine_test.go b/pkg/networkservice/chains/endpoint/combine_test.go index 5d854f560..35d8622bf 100644 --- a/pkg/networkservice/chains/endpoint/combine_test.go +++ b/pkg/networkservice/chains/endpoint/combine_test.go @@ -18,7 +18,6 @@ package endpoint_test import ( "context" - "io" "net/url" "testing" "time" @@ -28,8 +27,6 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/credentials/insecure" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" - "github.com/networkservicemesh/api/pkg/api/networkservice" "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/kernel" "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/memif" @@ -40,6 +37,7 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/common/monitor" "github.com/networkservicemesh/sdk/pkg/networkservice/common/updatepath" "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" + "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" "github.com/networkservicemesh/sdk/pkg/tools/grpcutils" ) @@ -83,14 +81,23 @@ func testCombine(t *testing.T, mechanism *networkservice.Mechanism) { ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() + var m networkservice.MonitorConnectionServer e := endpoint.Combine(func(servers []networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ - kernel.MECHANISM: servers[0], - memif.MECHANISM: servers[1], - }) + return next.NewNetworkServiceServer( + begin.NewServer(), + metadata.NewServer(), + monitor.NewServer(ctx, &m), + mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ + kernel.MECHANISM: servers[0], + memif.MECHANISM: servers[1], + })) }, newTestEndpoint(ctx, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM)) - cc := startEndpoint(ctx, t, e) + combined := &testEndpoint{ + NetworkServiceServer: e, + MonitorConnectionServer: m, + } + cc := startEndpoint(ctx, t, combined) defer func() { _ = cc.Close() }() c := next.NewNetworkServiceClient( @@ -123,11 +130,11 @@ func testCombine(t *testing.T, mechanism *networkservice.Mechanism) { require.Equal(t, (&networkservice.ConnectionEvent{ Type: networkservice.ConnectionEventType_UPDATE, Connections: map[string]*networkservice.Connection{ - conn.GetNextPathSegment().GetId(): { - Id: conn.GetNextPathSegment().GetId(), + conn.GetCurrentPathSegment().GetId(): { + Id: conn.GetCurrentPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 1, + Index: 0, PathSegments: conn.GetPath().GetPathSegments(), }, }, @@ -161,14 +168,24 @@ func TestSwitchEndpoint_InitialStateTransfer(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() + var m networkservice.MonitorConnectionServer e := endpoint.Combine(func(servers []networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ - kernel.MECHANISM: servers[0], - memif.MECHANISM: servers[1], - }) + return next.NewNetworkServiceServer( + begin.NewServer(), + metadata.NewServer(), + monitor.NewServer(ctx, &m), + mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ + kernel.MECHANISM: servers[0], + memif.MECHANISM: servers[1], + })) }, newTestEndpoint(ctx, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM)) - cc := startEndpoint(ctx, t, e) + combined := &testEndpoint{ + NetworkServiceServer: e, + MonitorConnectionServer: m, + } + + cc := startEndpoint(ctx, t, combined) defer func() { _ = cc.Close() }() c := next.NewNetworkServiceClient( @@ -195,11 +212,11 @@ func TestSwitchEndpoint_InitialStateTransfer(t *testing.T) { Connections: make(map[string]*networkservice.Connection), } for _, conn := range conns { - expectedEvent.Connections[conn.GetNextPathSegment().GetId()] = &networkservice.Connection{ - Id: conn.GetNextPathSegment().GetId(), + expectedEvent.Connections[conn.GetCurrentPathSegment().GetId()] = &networkservice.Connection{ + Id: conn.GetCurrentPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 1, + Index: 0, PathSegments: conn.GetPath().GetPathSegments(), }, } @@ -228,14 +245,24 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { monitorCtx, cancelMonitor := context.WithCancel(ctx) duplicate := newTestEndpoint(monitorCtx, "duplicate") + var m networkservice.MonitorConnectionServer e := endpoint.Combine(func(servers []networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ - kernel.MECHANISM: servers[0], - memif.MECHANISM: servers[1], - }) + return next.NewNetworkServiceServer( + begin.NewServer(), + metadata.NewServer(), + monitor.NewServer(ctx, &m), + mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ + kernel.MECHANISM: servers[0], + memif.MECHANISM: servers[1], + })) }, duplicate, duplicate) - cc := startEndpoint(ctx, t, e) + combined := &testEndpoint{ + NetworkServiceServer: e, + MonitorConnectionServer: m, + } + + cc := startEndpoint(ctx, t, combined) defer func() { _ = cc.Close() }() c := next.NewNetworkServiceClient( @@ -266,11 +293,11 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { require.Equal(t, (&networkservice.ConnectionEvent{ Type: networkservice.ConnectionEventType_UPDATE, Connections: map[string]*networkservice.Connection{ - conn.GetNextPathSegment().GetId(): { - Id: conn.GetNextPathSegment().GetId(), + conn.GetCurrentPathSegment().GetId(): { + Id: conn.GetCurrentPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 1, + Index: 0, PathSegments: conn.GetPath().GetPathSegments(), }, }, @@ -300,9 +327,6 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { } cancelMonitor() - - _, err = stream.Recv() - require.ErrorIs(t, err, io.EOF) } type testEndpoint struct { @@ -314,9 +338,6 @@ func newTestEndpoint(ctx context.Context, name string) *testEndpoint { e := new(testEndpoint) e.NetworkServiceServer = next.NewNetworkServiceServer( updatepath.NewServer(name), - begin.NewServer(), - metadata.NewServer(), - monitor.NewServer(ctx, &e.MonitorConnectionServer), ) return e } From 14a25e5b97d120a271d091b0886deb7aa7e59fd1 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Wed, 10 Jan 2024 15:20:27 +1100 Subject: [PATCH 04/10] fix golang linter Signed-off-by: Nikita Skrynnik --- pkg/networkservice/chains/endpoint/combine_test.go | 4 +++- pkg/networkservice/common/mechanisms/client_test.go | 12 ++++++++---- pkg/networkservice/common/mechanisms/server_test.go | 6 +----- 3 files changed, 12 insertions(+), 10 deletions(-) diff --git a/pkg/networkservice/chains/endpoint/combine_test.go b/pkg/networkservice/chains/endpoint/combine_test.go index 35d8622bf..0d3cc0ffd 100644 --- a/pkg/networkservice/chains/endpoint/combine_test.go +++ b/pkg/networkservice/chains/endpoint/combine_test.go @@ -1,5 +1,7 @@ // Copyright (c) 2021-2022 Doc.ai and/or its affiliates. // +// Copyright (c) 2024 Cisco and/or its affiliates. +// // SPDX-License-Identifier: Apache-2.0 // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -334,7 +336,7 @@ type testEndpoint struct { networkservice.MonitorConnectionServer } -func newTestEndpoint(ctx context.Context, name string) *testEndpoint { +func newTestEndpoint(name string) *testEndpoint { e := new(testEndpoint) e.NetworkServiceServer = next.NewNetworkServiceServer( updatepath.NewServer(name), diff --git a/pkg/networkservice/common/mechanisms/client_test.go b/pkg/networkservice/common/mechanisms/client_test.go index 55a563efe..79af6076e 100644 --- a/pkg/networkservice/common/mechanisms/client_test.go +++ b/pkg/networkservice/common/mechanisms/client_test.go @@ -1,5 +1,7 @@ // Copyright (c) 2021 Doc.ai and/or its affiliates. // +// Copyright (c) 2024 Cisco and/or its affiliates. +// // SPDX-License-Identifier: Apache-2.0 // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -180,13 +182,15 @@ func Test_Client_DontCallNextByItself(t *testing.T) { assert.Equal(t, 2, len(ch)) } +const ( + metricsKey = "server_interface" + ifnameKey = "name" + ifname = "nsm-1" +) + func Test_Client_Metrics(t *testing.T) { c := client() - metricsKey := "client_interface" - ifnameKey := "name" - ifname := "nsm-1" - for _, request := range permuteOverMechanismPreferenceOrder(request()) { request.MechanismPreferences[0].Parameters[ifnameKey] = ifname request.Connection.Path = &networkservice.Path{ diff --git a/pkg/networkservice/common/mechanisms/server_test.go b/pkg/networkservice/common/mechanisms/server_test.go index 08730d2ac..9856230cb 100644 --- a/pkg/networkservice/common/mechanisms/server_test.go +++ b/pkg/networkservice/common/mechanisms/server_test.go @@ -2,7 +2,7 @@ // // Copyright (c) 2021 Doc.ai and/or its affiliates. // -// Copyright (c) 2023 Cisco and/or its affiliates. +// Copyright (c) 2023-2024 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -248,10 +248,6 @@ func TestDontCallNextByItself(t *testing.T) { func TestMetrics(t *testing.T) { s := server() - metricsKey := "server_interface" - ifnameKey := "name" - ifname := "nsm-1" - for _, request := range permuteOverMechanismPreferenceOrder(request()) { request.MechanismPreferences[0].Parameters[ifnameKey] = ifname request.Connection.Path = &networkservice.Path{ From ca0b5b45fa42eea27a3a037382eb4a0ac3341609 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Wed, 10 Jan 2024 15:31:15 +1100 Subject: [PATCH 05/10] fix more tests Signed-off-by: Nikita Skrynnik --- pkg/networkservice/chains/endpoint/combine_test.go | 8 ++++---- pkg/networkservice/common/mechanisms/client_test.go | 6 +++--- pkg/networkservice/common/mechanisms/server_test.go | 1 + 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/pkg/networkservice/chains/endpoint/combine_test.go b/pkg/networkservice/chains/endpoint/combine_test.go index 0d3cc0ffd..13348ca2a 100644 --- a/pkg/networkservice/chains/endpoint/combine_test.go +++ b/pkg/networkservice/chains/endpoint/combine_test.go @@ -93,7 +93,7 @@ func testCombine(t *testing.T, mechanism *networkservice.Mechanism) { kernel.MECHANISM: servers[0], memif.MECHANISM: servers[1], })) - }, newTestEndpoint(ctx, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM)) + }, newTestEndpoint(kernel.MECHANISM), newTestEndpoint(memif.MECHANISM)) combined := &testEndpoint{ NetworkServiceServer: e, @@ -180,7 +180,7 @@ func TestSwitchEndpoint_InitialStateTransfer(t *testing.T) { kernel.MECHANISM: servers[0], memif.MECHANISM: servers[1], })) - }, newTestEndpoint(ctx, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM)) + }, newTestEndpoint(kernel.MECHANISM), newTestEndpoint(memif.MECHANISM)) combined := &testEndpoint{ NetworkServiceServer: e, @@ -246,13 +246,13 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { monitorCtx, cancelMonitor := context.WithCancel(ctx) - duplicate := newTestEndpoint(monitorCtx, "duplicate") + duplicate := newTestEndpoint("duplicate") var m networkservice.MonitorConnectionServer e := endpoint.Combine(func(servers []networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { return next.NewNetworkServiceServer( begin.NewServer(), metadata.NewServer(), - monitor.NewServer(ctx, &m), + monitor.NewServer(monitorCtx, &m), mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ kernel.MECHANISM: servers[0], memif.MECHANISM: servers[1], diff --git a/pkg/networkservice/common/mechanisms/client_test.go b/pkg/networkservice/common/mechanisms/client_test.go index 79af6076e..4d4d0a9ac 100644 --- a/pkg/networkservice/common/mechanisms/client_test.go +++ b/pkg/networkservice/common/mechanisms/client_test.go @@ -183,13 +183,13 @@ func Test_Client_DontCallNextByItself(t *testing.T) { } const ( - metricsKey = "server_interface" - ifnameKey = "name" - ifname = "nsm-1" + ifnameKey = "name" + ifname = "nsm-1" ) func Test_Client_Metrics(t *testing.T) { c := client() + metricsKey := "client_interface" for _, request := range permuteOverMechanismPreferenceOrder(request()) { request.MechanismPreferences[0].Parameters[ifnameKey] = ifname diff --git a/pkg/networkservice/common/mechanisms/server_test.go b/pkg/networkservice/common/mechanisms/server_test.go index 9856230cb..8ce41a9c0 100644 --- a/pkg/networkservice/common/mechanisms/server_test.go +++ b/pkg/networkservice/common/mechanisms/server_test.go @@ -247,6 +247,7 @@ func TestDontCallNextByItself(t *testing.T) { func TestMetrics(t *testing.T) { s := server() + metricsKey := "server_interface" for _, request := range permuteOverMechanismPreferenceOrder(request()) { request.MechanismPreferences[0].Parameters[ifnameKey] = ifname From 5f3f7fc7ef2d51d313c4446789d22bafa478c786 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Wed, 10 Jan 2024 15:37:28 +1100 Subject: [PATCH 06/10] rerun CI Signed-off-by: Nikita Skrynnik From e9336aae27e5164f736e0d6d61d243ae47d52ef6 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Wed, 10 Jan 2024 15:39:31 +1100 Subject: [PATCH 07/10] rerun CI Signed-off-by: Nikita Skrynnik From 18b8b7001ddd8a7e5df4b172f3b45238ee64c831 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Thu, 11 Jan 2024 20:39:17 +1100 Subject: [PATCH 08/10] apply review comments Signed-off-by: Nikita Skrynnik --- pkg/networkservice/common/mechanisms/client.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pkg/networkservice/common/mechanisms/client.go b/pkg/networkservice/common/mechanisms/client.go index 0bbaabe2c..b6941daab 100644 --- a/pkg/networkservice/common/mechanisms/client.go +++ b/pkg/networkservice/common/mechanisms/client.go @@ -1,4 +1,6 @@ -// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2021 Doc.ai and/or its affiliates. +// +// Copyright (c) 2024 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // From e5fc986a6f09f46adc76d779cde03c8950109261 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Mon, 15 Jan 2024 18:33:16 +1100 Subject: [PATCH 09/10] Revert "fix combine tests" This reverts commit b1509d126cd2a890d4cfd3eb6338a05fb37076ac. Signed-off-by: Nikita Skrynnik --- .../chains/endpoint/combine_test.go | 95 ++++++++----------- 1 file changed, 37 insertions(+), 58 deletions(-) diff --git a/pkg/networkservice/chains/endpoint/combine_test.go b/pkg/networkservice/chains/endpoint/combine_test.go index 13348ca2a..868f8d0ea 100644 --- a/pkg/networkservice/chains/endpoint/combine_test.go +++ b/pkg/networkservice/chains/endpoint/combine_test.go @@ -20,6 +20,7 @@ package endpoint_test import ( "context" + "io" "net/url" "testing" "time" @@ -29,6 +30,8 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/credentials/insecure" + "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" + "github.com/networkservicemesh/api/pkg/api/networkservice" "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/kernel" "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/memif" @@ -39,7 +42,6 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/common/monitor" "github.com/networkservicemesh/sdk/pkg/networkservice/common/updatepath" "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" "github.com/networkservicemesh/sdk/pkg/tools/grpcutils" ) @@ -83,23 +85,14 @@ func testCombine(t *testing.T, mechanism *networkservice.Mechanism) { ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() - var m networkservice.MonitorConnectionServer e := endpoint.Combine(func(servers []networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return next.NewNetworkServiceServer( - begin.NewServer(), - metadata.NewServer(), - monitor.NewServer(ctx, &m), - mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ - kernel.MECHANISM: servers[0], - memif.MECHANISM: servers[1], - })) - }, newTestEndpoint(kernel.MECHANISM), newTestEndpoint(memif.MECHANISM)) - - combined := &testEndpoint{ - NetworkServiceServer: e, - MonitorConnectionServer: m, - } - cc := startEndpoint(ctx, t, combined) + return mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ + kernel.MECHANISM: servers[0], + memif.MECHANISM: servers[1], + }) + }, newTestEndpoint(ctx, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM)) + + cc := startEndpoint(ctx, t, e) defer func() { _ = cc.Close() }() c := next.NewNetworkServiceClient( @@ -132,11 +125,11 @@ func testCombine(t *testing.T, mechanism *networkservice.Mechanism) { require.Equal(t, (&networkservice.ConnectionEvent{ Type: networkservice.ConnectionEventType_UPDATE, Connections: map[string]*networkservice.Connection{ - conn.GetCurrentPathSegment().GetId(): { - Id: conn.GetCurrentPathSegment().GetId(), + conn.GetNextPathSegment().GetId(): { + Id: conn.GetNextPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 0, + Index: 1, PathSegments: conn.GetPath().GetPathSegments(), }, }, @@ -170,24 +163,14 @@ func TestSwitchEndpoint_InitialStateTransfer(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() - var m networkservice.MonitorConnectionServer e := endpoint.Combine(func(servers []networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return next.NewNetworkServiceServer( - begin.NewServer(), - metadata.NewServer(), - monitor.NewServer(ctx, &m), - mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ - kernel.MECHANISM: servers[0], - memif.MECHANISM: servers[1], - })) - }, newTestEndpoint(kernel.MECHANISM), newTestEndpoint(memif.MECHANISM)) - - combined := &testEndpoint{ - NetworkServiceServer: e, - MonitorConnectionServer: m, - } + return mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ + kernel.MECHANISM: servers[0], + memif.MECHANISM: servers[1], + }) + }, newTestEndpoint(ctx, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM)) - cc := startEndpoint(ctx, t, combined) + cc := startEndpoint(ctx, t, e) defer func() { _ = cc.Close() }() c := next.NewNetworkServiceClient( @@ -214,11 +197,11 @@ func TestSwitchEndpoint_InitialStateTransfer(t *testing.T) { Connections: make(map[string]*networkservice.Connection), } for _, conn := range conns { - expectedEvent.Connections[conn.GetCurrentPathSegment().GetId()] = &networkservice.Connection{ - Id: conn.GetCurrentPathSegment().GetId(), + expectedEvent.Connections[conn.GetNextPathSegment().GetId()] = &networkservice.Connection{ + Id: conn.GetNextPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 0, + Index: 1, PathSegments: conn.GetPath().GetPathSegments(), }, } @@ -246,25 +229,15 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { monitorCtx, cancelMonitor := context.WithCancel(ctx) - duplicate := newTestEndpoint("duplicate") - var m networkservice.MonitorConnectionServer + duplicate := newTestEndpoint(monitorCtx, "duplicate") e := endpoint.Combine(func(servers []networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return next.NewNetworkServiceServer( - begin.NewServer(), - metadata.NewServer(), - monitor.NewServer(monitorCtx, &m), - mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ - kernel.MECHANISM: servers[0], - memif.MECHANISM: servers[1], - })) + return mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ + kernel.MECHANISM: servers[0], + memif.MECHANISM: servers[1], + }) }, duplicate, duplicate) - combined := &testEndpoint{ - NetworkServiceServer: e, - MonitorConnectionServer: m, - } - - cc := startEndpoint(ctx, t, combined) + cc := startEndpoint(ctx, t, e) defer func() { _ = cc.Close() }() c := next.NewNetworkServiceClient( @@ -295,11 +268,11 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { require.Equal(t, (&networkservice.ConnectionEvent{ Type: networkservice.ConnectionEventType_UPDATE, Connections: map[string]*networkservice.Connection{ - conn.GetCurrentPathSegment().GetId(): { - Id: conn.GetCurrentPathSegment().GetId(), + conn.GetNextPathSegment().GetId(): { + Id: conn.GetNextPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 0, + Index: 1, PathSegments: conn.GetPath().GetPathSegments(), }, }, @@ -329,6 +302,9 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { } cancelMonitor() + + _, err = stream.Recv() + require.ErrorIs(t, err, io.EOF) } type testEndpoint struct { @@ -340,6 +316,9 @@ func newTestEndpoint(name string) *testEndpoint { e := new(testEndpoint) e.NetworkServiceServer = next.NewNetworkServiceServer( updatepath.NewServer(name), + begin.NewServer(), + metadata.NewServer(), + monitor.NewServer(ctx, &e.MonitorConnectionServer), ) return e } From 0484c4ecb4eda0c496d26f1ab171e6005a391a39 Mon Sep 17 00:00:00 2001 From: Nikita Skrynnik Date: Mon, 15 Jan 2024 19:13:45 +1100 Subject: [PATCH 10/10] fix tests different way Signed-off-by: Nikita Skrynnik --- .../chains/endpoint/combine_test.go | 33 ++++++++++--------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/pkg/networkservice/chains/endpoint/combine_test.go b/pkg/networkservice/chains/endpoint/combine_test.go index 868f8d0ea..f65012a23 100644 --- a/pkg/networkservice/chains/endpoint/combine_test.go +++ b/pkg/networkservice/chains/endpoint/combine_test.go @@ -90,7 +90,7 @@ func testCombine(t *testing.T, mechanism *networkservice.Mechanism) { kernel.MECHANISM: servers[0], memif.MECHANISM: servers[1], }) - }, newTestEndpoint(ctx, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM)) + }, newTestEndpoint(ctx, kernel.MECHANISM, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM, memif.MECHANISM)) cc := startEndpoint(ctx, t, e) defer func() { _ = cc.Close() }() @@ -125,11 +125,11 @@ func testCombine(t *testing.T, mechanism *networkservice.Mechanism) { require.Equal(t, (&networkservice.ConnectionEvent{ Type: networkservice.ConnectionEventType_UPDATE, Connections: map[string]*networkservice.Connection{ - conn.GetNextPathSegment().GetId(): { - Id: conn.GetNextPathSegment().GetId(), + conn.GetCurrentPathSegment().GetId(): { + Id: conn.GetCurrentPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 1, + Index: 0, PathSegments: conn.GetPath().GetPathSegments(), }, }, @@ -168,7 +168,7 @@ func TestSwitchEndpoint_InitialStateTransfer(t *testing.T) { kernel.MECHANISM: servers[0], memif.MECHANISM: servers[1], }) - }, newTestEndpoint(ctx, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM)) + }, newTestEndpoint(ctx, kernel.MECHANISM, kernel.MECHANISM), newTestEndpoint(ctx, memif.MECHANISM, memif.MECHANISM)) cc := startEndpoint(ctx, t, e) defer func() { _ = cc.Close() }() @@ -197,11 +197,11 @@ func TestSwitchEndpoint_InitialStateTransfer(t *testing.T) { Connections: make(map[string]*networkservice.Connection), } for _, conn := range conns { - expectedEvent.Connections[conn.GetNextPathSegment().GetId()] = &networkservice.Connection{ - Id: conn.GetNextPathSegment().GetId(), + expectedEvent.Connections[conn.GetCurrentPathSegment().GetId()] = &networkservice.Connection{ + Id: conn.GetCurrentPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 1, + Index: 0, PathSegments: conn.GetPath().GetPathSegments(), }, } @@ -229,13 +229,14 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { monitorCtx, cancelMonitor := context.WithCancel(ctx) - duplicate := newTestEndpoint(monitorCtx, "duplicate") + duplicate1 := newTestEndpoint(monitorCtx, kernel.MECHANISM, "duplicate") + duplicate2 := newTestEndpoint(monitorCtx, memif.MECHANISM, "duplicate") e := endpoint.Combine(func(servers []networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { return mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ kernel.MECHANISM: servers[0], memif.MECHANISM: servers[1], }) - }, duplicate, duplicate) + }, duplicate1, duplicate2) cc := startEndpoint(ctx, t, e) defer func() { _ = cc.Close() }() @@ -268,11 +269,11 @@ func TestSwitchEndpoint_DuplicateEndpoints(t *testing.T) { require.Equal(t, (&networkservice.ConnectionEvent{ Type: networkservice.ConnectionEventType_UPDATE, Connections: map[string]*networkservice.Connection{ - conn.GetNextPathSegment().GetId(): { - Id: conn.GetNextPathSegment().GetId(), + conn.GetCurrentPathSegment().GetId(): { + Id: conn.GetCurrentPathSegment().GetId(), Mechanism: conn.GetMechanism(), Path: &networkservice.Path{ - Index: 1, + Index: 0, PathSegments: conn.GetPath().GetPathSegments(), }, }, @@ -312,13 +313,15 @@ type testEndpoint struct { networkservice.MonitorConnectionServer } -func newTestEndpoint(name string) *testEndpoint { +func newTestEndpoint(ctx context.Context, mechanism, name string) *testEndpoint { e := new(testEndpoint) e.NetworkServiceServer = next.NewNetworkServiceServer( - updatepath.NewServer(name), begin.NewServer(), metadata.NewServer(), monitor.NewServer(ctx, &e.MonitorConnectionServer), + mechanisms.NewServer(map[string]networkservice.NetworkServiceServer{ + mechanism: updatepath.NewServer(name), + }), ) return e }