From da0bd390f9a333a11a177889b508aef3dce0c96b Mon Sep 17 00:00:00 2001 From: hmod2001 <59151407+hmod2001@users.noreply.github.com> Date: Fri, 20 Nov 2026 14:57:38 -0500 Subject: [PATCH 1/3] Carry validated AFT filtering, recovery and cache fixes --- .../otg_tests/afts_prefix_filtering/README.md | 21 +- .../aft_diagnostics_test.go | 221 +++++ .../afts_prefix_filtering_test.go | 741 ++++++++++++++--- .../afts_prefix_filtering/metadata.textproto | 9 + .../policy_set_diagnostics_test.go | 260 ++++++ .../afts_prefix_filtering_dualstack_test.go | 62 +- .../metadata.textproto | 9 + .../afts_prefix_filtering_dynamic_test.go | 597 +++++++++++--- .../metadata.textproto | 10 + .../aft_diagnostics_test.go | 401 ++++++++++ .../afts_prefix_filtering_resilience_test.go | 757 ++++++++++++++++-- .../metadata.textproto | 10 + .../aft_prefix_filtering_service.go | 422 ++++++++-- internal/telemetry/aftcache/aft_cache.go | 345 ++++++-- 14 files changed, 3457 insertions(+), 408 deletions(-) create mode 100644 feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/aft_diagnostics_test.go create mode 100644 feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/policy_set_diagnostics_test.go create mode 100644 feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/aft_diagnostics_test.go diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/README.md b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/README.md index 0431b735b73..b446a11ae1e 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/README.md +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/README.md @@ -33,6 +33,9 @@ See also: `198.51.100.0/24`, `203.0.113.0/28`, `100.64.0.0/24`, `2001:DB8:1::/64`, and `2001:DB8:3::/64`. +- Cisco excludes the testbed-provided default routes from the prefix-set policies and expected results because the test does not install their next hops. + Other vendors retain the original default-route checks and include `0.0.0.0/0` in `PREFIX-SET-A` and `::/0` in `PREFIX-SET-B`. + - The DUT is pre-configured with the following routing policies under `/routing-policy/policy-definitions/`: @@ -63,10 +66,13 @@ See also: `PREFIX-SET-A` (REJECT_ROUTE); statement 20 accepts all remaining routes (unconditional ACCEPT_ROUTE). The prefix-set acts as an exclusion list. - - `POLICY-TAG-MATCH`: Statement 100 matches routes carrying tag `999` + - `POLICY-TAG-MATCH` (non-Cisco): Statement 100 matches routes carrying tag `999` (ACCEPT_ROUTE). No installed route uses this tag, so the policy matches nothing. + - `POLICY-DROP-ALL` (Cisco only): One unconditional `REJECT_ROUTE` statement. + AFT-6.1.7 uses this policy on Cisco, where tag matching is unsupported by the AFT filter. + ### Test Case Iteration **AFT-6.1.1** is a parameterized test. Its subscribe and validate steps must be @@ -310,6 +316,14 @@ subscribe: { ### AFT-6.1.7 - Negative: Non-Prefix-Set Match Criteria +On Cisco, substitute `POLICY-DROP-ALL` for `POLICY-TAG-MATCH` throughout this +case. This is because this vendor does not support tag matching, just prefix +matching. +This Cisco variant covers unconditional policy rejection and live transitions between drop-all and prefix-set filtering; it does not cover route-tag evaluation. +Keep the same subscription open through all three Cisco stages. +Cisco can retain prefixes needed for next-hop resolution under drop-all, and the IPv6 family remains unfiltered. +The Cisco assertions check that the three IPv4 test prefixes are absent, rather than requiring an empty AFT across both families. + #### Fresh Subscribe with Non-Matching Policy - Configure the global-filter `ipv4-policy` to `POLICY-TAG-MATCH`. @@ -324,6 +338,9 @@ subscribe: { - Configure the global-filter `ipv4-policy` to `POLICY-PREFIX-SET-A`. +- On Cisco, update the policy reference directly on the same subscription, without first deleting the global filter. + Verify that `100.64.0.0/24` remains absent while the two prefixes in `PREFIX-SET-A` appear. + - Establish a gNMI Subscribe session and wait for `SYNC`. Verify notifications are received for `198.51.100.0/24` and `203.0.113.0/28`. @@ -332,6 +349,8 @@ subscribe: { - Verify that delete notifications are received for the previously streamed prefixes `198.51.100.0/24` and `203.0.113.0/28`. +- On Cisco, wait for both prefixes to disappear after restoring `POLICY-DROP-ALL`. + - Verify that **no** new update notifications are received. ## OpenConfig Path and RPC Coverage diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/aft_diagnostics_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/aft_diagnostics_test.go new file mode 100644 index 00000000000..96fc4a094e3 --- /dev/null +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/aft_diagnostics_test.go @@ -0,0 +1,221 @@ +// Copyright 2026 Google LLC +// +// 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 aftsprefixfiltering_test + +import ( + "compress/gzip" + "context" + "flag" + "fmt" + "io" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/openconfig/featureprofiles/internal/telemetry/aftcache" + gpb "github.com/openconfig/gnmi/proto/gnmi" + "github.com/openconfig/ondatra" + "github.com/openconfig/testt" +) + +// aftFilterDiagnostics records the policy and prefixes whose effective state +// must be preserved before a failed subtest returns to the parent suite. +type aftFilterDiagnostics struct { + networkInstance string + policy string + prefixSets []string + prefixes []string +} + +// logAFTDiagnosticCLI uses a separate deadline for each command. In particular, +// a collector timeout must not cancel the commands that explain that timeout. +func logAFTDiagnosticCLI(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, command string) { + t.Helper() + logAFTDiagnosticCLIAtStage(ctx, t, dut, "", command) +} + +// saveAFTDiagnostic preserves complete output under the runner's persistent log +// directory. Test temporary directories are deleted before FireX copies logs. +func saveAFTDiagnostic(t *testing.T, stage, command, output string) { + t.Helper() + var directory string + for _, name := range []string{"log_dir", "outputs_dir"} { + if option := flag.Lookup(name); option != nil && option.Value.String() != "" { + directory = option.Value.String() + break + } + } + if directory == "" { + directory = os.Getenv("TEST_UNDECLARED_OUTPUTS_DIR") + } + if directory == "" { + directory = "." + } + directory = filepath.Join(directory, "aft_diagnostics") + if err := os.MkdirAll(directory, 0755); err != nil { + t.Logf("AFT diagnostic artifact directory unavailable: %v", err) + return + } + label := strings.Map(func(r rune) rune { + if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' { + return r + } + return '_' + }, stage+"-"+command) + if len(label) > 120 { + label = label[:120] + } + suffix := ".txt" + if len(output) > 64*1024 { + suffix += ".gz" + } + file, err := os.CreateTemp(directory, label+"-*"+suffix) + if err != nil { + t.Logf("AFT diagnostic artifact creation failed: %v", err) + return + } + if err := file.Chmod(0644); err != nil { + t.Logf("AFT diagnostic artifact permissions for %s: %v", file.Name(), err) + } + var writer io.Writer = file + var compressed *gzip.Writer + if strings.HasSuffix(suffix, ".gz") { + compressed = gzip.NewWriter(file) + writer = compressed + } + _, headerErr := fmt.Fprintf(writer, "UTC: %s\nTest: %s\nStage: %s\nCommand: %s\n\n", time.Now().UTC().Format(time.RFC3339Nano), t.Name(), stage, command) + _, writeErr := io.WriteString(writer, output) + var compressErr error + if compressed != nil { + compressErr = compressed.Close() + } + closeErr := file.Close() + t.Logf("AFT diagnostic full artifact=%s uncompressedBytes=%d headerError=%v writeError=%v compressError=%v closeError=%v", file.Name(), len(output), headerErr, writeErr, compressErr, closeErr) +} + +func logAFTDiagnosticCLIAtStage(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, stage, command string) (string, error) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return "", nil + } + if ctx.Err() != nil { + t.Logf("AFT diagnostic CLI skipped command=%q: %v", command, ctx.Err()) + return "", ctx.Err() + } + var output string + var commandErr error + if failure := testt.CaptureFatal(t, func(tb testing.TB) { + readCtx, cancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) + defer cancel() + started := time.Now() + t.Logf("AFT diagnostic CLI start UTC=%s command=%q", started.UTC().Format(time.RFC3339Nano), command) + response, err := dut.RawAPIs().CLI(tb).RunCommand(readCtx, command) + if err != nil { + commandErr = err + t.Logf("AFT diagnostic CLI command=%q elapsed=%v failed: %v", command, time.Since(started), err) + return + } + output = response.Output() + saveAFTDiagnostic(t, stage, command, output) + sample := output + const maxOutput = 64 * 1024 + if len(sample) > maxOutput { + t.Logf("AFT diagnostic CLI command=%q output=%d bytes; logging last %d bytes", command, len(output), maxOutput) + sample = sample[len(sample)-maxOutput:] + } + t.Logf("AFT diagnostic CLI end UTC=%s stage=%q command=%q elapsed=%v:\n%s", time.Now().UTC().Format(time.RFC3339Nano), stage, command, time.Since(started), sample) + }); failure != nil { + commandErr = fmt.Errorf("%s", *failure) + t.Logf("AFT diagnostic CLI command=%q unavailable: %s", command, *failure) + } + return output, commandErr +} + +// capture records native configuration and the OpenConfig filter binding. +// The PoC oper_cache_ctl tool is unavailable on the image under investigation. +func (d aftFilterDiagnostics) capture(t *testing.T, dut *ondatra.DUTDevice, stage string) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return + } + ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(90*time.Second)) + defer cancel() + t.Logf("AFT filter diagnostics start UTC=%s stage=%q NI=%s policy=%s", time.Now().UTC().Format(time.RFC3339Nano), stage, d.networkInstance, d.policy) + defer func() { + t.Logf("AFT filter diagnostics end UTC=%s stage=%q contextError=%v", time.Now().UTC().Format(time.RFC3339Nano), stage, ctx.Err()) + }() + logAFTDiagnosticCLIAtStage(ctx, t, dut, stage, "show running-config route-policy "+d.policy) + for _, name := range d.prefixSets { + logAFTDiagnosticCLIAtStage(ctx, t, dut, stage, "show running-config prefix-set "+name) + } + client, err := dialGNMI(t, dut) + if err != nil { + t.Logf("AFT diagnostic global-filter Get unavailable: %v", err) + return + } + path := globalFilterPolicyPath(d.networkInstance, "ipv4-policy") + path.Elem = path.Elem[:len(path.Elem)-2] // Read config and state together. + readCtx, readCancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) + defer readCancel() + request := &gpb.GetRequest{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, + Path: []*gpb.Path{path}, Type: gpb.GetRequest_ALL, Encoding: gpb.Encoding_JSON_IETF, + } + response, err := client.Get(readCtx, request) + t.Logf("AFT diagnostic global-filter Get UTC=%s stage=%q request=%v response=%v error=%v", time.Now().UTC().Format(time.RFC3339Nano), stage, request, response, err) + if d.policy == policyPfxSetA { + diagnosticPolicyGet(ctx, t, dut, client, stage+" OpenConfig policy views", + statementPrefixSetConfigPath(d.policy, defaultStatementName), + policyStatementPath(d.policy, defaultStatementName), policyDefinitionPath(d.policy)) + } +} + +// captureFailure runs from a defer, including after t.Fatalf on a collector +// timeout. It observes the failing configuration without retrying a Set or +// reattaching a policy. A fresh stream is opened only after the old one stops. +func (d aftFilterDiagnostics) captureFailure(t *testing.T, dut *ondatra.DUTDevice, stage string, cancel context.CancelFunc, collector *aftcache.AFTStreamSession) { + t.Helper() + if dut.Vendor() != ondatra.CISCO || !t.Failed() { + return + } + t.Logf("AFT failure diagnostics UTC=%s stage=%q clientStreamProgress=%+v (buffer is on the test client)", time.Now().UTC().Format(time.RFC3339Nano), stage, collector.Progress()) + d.capture(t, dut, stage+" failure before collector cancellation") + ctx, diagnosticCancel := context.WithDeadline(context.Background(), time.Now().Add(45*time.Second)) + defer diagnosticCancel() + for _, command := range []string{"show logging", "show grpc trace all", "show telemetry model-driven trace all"} { + logAFTDiagnosticCLI(ctx, t, dut, command) + } + cancel() + waitCtx, waitCancel := context.WithDeadline(context.Background(), time.Now().Add(10*time.Second)) + defer waitCancel() + if err := collector.WaitStopped(waitCtx); err != nil { + t.Logf("Raw filtered-prefix probe skipped: main AFT collector did not stop: %v", err) + return + } + got, err := readGlobalFilterPolicy(t, dut, d.networkInstance, "ipv4-policy") + t.Logf("AFT failure diagnostic active-policy check UTC=%s stage=%q got=%q expected=%q error=%v", time.Now().UTC().Format(time.RFC3339Nano), stage, got, d.policy, err) + if err != nil || got != d.policy { + t.Log("Raw filtered-prefix probe skipped: expected filter is no longer confirmed active") + return + } + probeRawFilteredPrefixes(t, dut, d.networkInstance, d.prefixes) + if d.policy == policyPfxSetA && strings.Contains(stage, "prefix deletions after swap") { + // The original failure and raw stream are preserved before any probe + // configuration is created. These policies are never attached to AFT. + probePolicySetForms(t, dut) + } +} diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/afts_prefix_filtering_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/afts_prefix_filtering_test.go index dfcdc5a8661..1ad2afe4eeb 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/afts_prefix_filtering_test.go +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/afts_prefix_filtering_test.go @@ -12,7 +12,9 @@ package aftsprefixfiltering_test import ( "context" + "encoding/json" "fmt" + "strings" "sync" "testing" "time" @@ -32,18 +34,21 @@ import ( const ( v4PfxSetA = "PREFIX-SET-A" + v4PfxSetB = "PREFIX-SET-B-V4" v6PfxSetB = "PREFIX-SET-B" vrfPfxSetA = "PREFIX-SET-VRF-A" subnetPfxSetV4 = "PREFIX-SET-SUBNET" subnetPfxSetV6 = "PREFIX-SET-SUBNET-V6" policyPfxSetA = "POLICY-PREFIX-SET-A" policyPfxSetB = "POLICY-PREFIX-SET-B" + policyPfxSetBV4 = "POLICY-PREFIX-SET-B-V4" policyVrfA = "POLICY-PREFIX-SET-VRF-A" policySubnet = "POLICY-SUBNET" policySubnetV6 = "POLICY-SUBNET-V6" policyMultiStmt = "POLICY-MULTI-STMT" policyDenyPfxSetA = "POLICY-DENY-PREFIX-SET-A" policyTagMatch = "POLICY-TAG-MATCH" + policyDropAll = "POLICY-DROP-ALL" policyNotYetExist = "POLICY-DOES-NOT-YET-EXIST" pfxSetNotYetExist = "PREFIX-SET-DOES-NOT-YET-EXIST" secondStatementName = "20" @@ -53,6 +58,7 @@ const ( defaultStatementName = aftpf.DefaultStatementName pfxMode = aftpf.PfxMode subscriptionWait = aftpf.AFTSubscriptionWait + aftCheckInterval = 45 * time.Second staticRouteIndex = aftpf.StaticRouteIndex defaultV4Route = "0.0.0.0/0" defaultV6Route = "::/0" @@ -72,19 +78,46 @@ var ( "2001:db8:2::/64", "2001:db8:3::/64", } + // Cisco excludes testbed-provided defaults through policyPrefixSetMembers; + // other vendors retain their original default-route coverage. pfxSetAMembers = []string{ "198.51.100.0/24", "203.0.113.0/28", "198.51.100.1/32", - defaultV4Route, } pfxSetBMembers = []string{ "2001:db8:2::/64", "2001:db8:2::1/128", - defaultV6Route, } + // No route for this IPv4 prefix is installed by AFT-6.1.4. This lets + // Cisco's IPv4 policy swap avoid the cross-family reference in the + // previously rejected Set request. + v4PfxSetBMembers = []string{"192.0.2.128/25"} ) +func policyPrefixSetMembers(dut *ondatra.DUTDevice, ipv4 bool) []string { + members, defaultRoute := pfxSetBMembers, defaultV6Route + if ipv4 { + members, defaultRoute = pfxSetAMembers, defaultV4Route + } + if dut.Vendor() == ondatra.CISCO { + // This test does not install Cisco's defaults through the ATE, so + // their next hops must not be assumed to match the test routes. + return members + } + return append(append([]string(nil), members...), defaultRoute) +} + +// policyStringValue keeps the original leaf encoding on other vendors. +func policyStringValue(dut *ondatra.DUTDevice, value string) *gpb.TypedValue { + if dut.Vendor() == ondatra.CISCO { + // XR requires JSON_IETF for these string-valued configuration Sets. + encoded, _ := json.Marshal(value) // A string always marshals successfully. + return &gpb.TypedValue{Value: &gpb.TypedValue_JsonIetfVal{JsonIetfVal: encoded}} + } + return &gpb.TypedValue{Value: &gpb.TypedValue_StringVal{StringVal: value}} +} + // configurePolicies configures the routing policies and prefix-sets required by the AFT-6.1 test procedures func configurePolicies(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch) { t.Helper() @@ -99,7 +132,7 @@ func configurePolicies(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatc PolicyName: policyPfxSetA, StatementNames: []string{defaultStatementName}, PrefixSetNames: []string{v4PfxSetA}, - PrefixList: pfxSetAMembers, + PrefixList: policyPrefixSetMembers(dut, true), PrefixMode: pfxMode, MatchPrefixSet: true, MatchSetOption: oc.E_RoutingPolicy_MatchSetOptionsRestrictedType(oc.RoutingPolicy_MatchSetOptionsType_ANY), @@ -109,12 +142,26 @@ func configurePolicies(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatc PolicyName: policyPfxSetB, StatementNames: []string{defaultStatementName}, PrefixSetNames: []string{v6PfxSetB}, - PrefixList: pfxSetBMembers, + PrefixList: policyPrefixSetMembers(dut, false), PrefixMode: pfxMode, MatchPrefixSet: true, MatchSetOption: oc.E_RoutingPolicy_MatchSetOptionsRestrictedType(oc.RoutingPolicy_MatchSetOptionsType_ANY), PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, }) + if dut.Vendor() == ondatra.CISCO { + // AFT-6.1.4 swaps the prefix-set of an IPv4 policy. Use a second + // IPv4 set with no installed AFT entry on Cisco; keep the existing + // IPv6 PREFIX-SET-B for the independent IPv6 cases. + aftpf.AddPrefixSetPolicy(t, rp, aftpf.PrefixSetPolicyParams{ + PolicyName: policyPfxSetBV4, + StatementNames: []string{defaultStatementName}, + PrefixSetNames: []string{v4PfxSetB}, + PrefixList: v4PfxSetBMembers, + PrefixMode: pfxMode, + MatchPrefixSet: true, + PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, + }) + } aftpf.AddPrefixSetPolicy(t, rp, aftpf.PrefixSetPolicyParams{ PolicyName: policyVrfA, StatementNames: []string{defaultStatementName}, @@ -160,13 +207,23 @@ func configurePolicies(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatc PrefixDeny: true, PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, }) - aftpf.AddPrefixSetPolicy(t, rp, aftpf.PrefixSetPolicyParams{ - PolicyName: policyTagMatch, - StatementNames: []string{tagStatementName}, - MatchPrefixSet: true, - SetTag: true, - PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, - }) + if dut.Vendor() == ondatra.CISCO { + // Cisco's AFT filter supports an unconditional drop, while a tag + // condition disables filtering because it is unsupported. + aftpf.AddPrefixSetPolicy(t, rp, aftpf.PrefixSetPolicyParams{ + PolicyName: policyDropAll, + StatementNames: []string{defaultStatementName}, + PolicyResult: oc.RoutingPolicy_PolicyResultType_REJECT_ROUTE, + }) + } else { + aftpf.AddPrefixSetPolicy(t, rp, aftpf.PrefixSetPolicyParams{ + PolicyName: policyTagMatch, + StatementNames: []string{tagStatementName}, + MatchPrefixSet: true, + SetTag: true, + PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, + }) + } gnmi.BatchReplace(batch, gnmi.OC().RoutingPolicy().Config(), rp) batch.Set(t, dut) } @@ -246,6 +303,12 @@ func statementPrefixSetConfigPath(policyName, statementName string) *gpb.Path { } } +func policyStatementPath(policyName, statementName string) *gpb.Path { + path := statementPrefixSetConfigPath(policyName, statementName) + path.Elem = path.Elem[:5] + return path +} + // setGlobalFilterExpectCode sets the global-filter policy leaves and returns an // error unless the gNMI Set fails with exactly the given status code. func setGlobalFilterExpectCode(t *testing.T, dut *ondatra.DUTDevice, niName, v4Policy, v6Policy string, @@ -267,16 +330,17 @@ func setGlobalFilterExpectCode(t *testing.T, dut *ondatra.DUTDevice, niName, v4P if v4Policy != "" { updates = append(updates, &gpb.Update{ Path: globalFilterPolicyPath(niName, "ipv4-policy"), - Val: &gpb.TypedValue{Value: &gpb.TypedValue_StringVal{StringVal: v4Policy}}, + Val: policyStringValue(dut, v4Policy), }) } if v6Policy != "" { updates = append(updates, &gpb.Update{ Path: globalFilterPolicyPath(niName, "ipv6-policy"), - Val: &gpb.TypedValue{Value: &gpb.TypedValue_StringVal{StringVal: v6Policy}}, + Val: policyStringValue(dut, v6Policy), }) } req := &gpb.SetRequest{Update: updates} + t.Logf("Sending AFT global-filter negative-check gNMI SetRequest: %v", req) _, setErr := client.Set(context.Background(), req) if setErr == nil { if wantCode == codes.OK { @@ -291,7 +355,7 @@ func setGlobalFilterExpectCode(t *testing.T, dut *ondatra.DUTDevice, niName, v4P } // deletePolicyExpectCode attempts to delete a policy-definition and returns -// an error unless the gNMI Set RPC fails with exactly the given status code. +// an error unless the gNMI Set RPC returns the given status code. func deletePolicyExpectCode(t *testing.T, dut *ondatra.DUTDevice, policyName string, wantCode codes.Code) error { t.Helper() client, err := dialGNMI(t, dut) @@ -299,8 +363,13 @@ func deletePolicyExpectCode(t *testing.T, dut *ondatra.DUTDevice, policyName str return err } req := &gpb.SetRequest{Delete: []*gpb.Path{policyDefinitionPath(policyName)}} + t.Logf("Sending policy-definition delete gNMI SetRequest: %v", req) _, setErr := client.Set(context.Background(), req) if setErr == nil { + if wantCode == codes.OK { + t.Logf("Deleted policy %s while it was referenced by the global filter", policyName) + return nil + } return fmt.Errorf("gNMI Set deleting policy %s succeeded, want error with code %v", policyName, wantCode) } if got := status.Code(setErr); got != wantCode { @@ -310,6 +379,78 @@ func deletePolicyExpectCode(t *testing.T, dut *ondatra.DUTDevice, policyName str return nil } +// readGlobalFilterPolicy checks the configured policy, not the streamed state. +func readGlobalFilterPolicy(t *testing.T, dut *ondatra.DUTDevice, niName, leaf string) (string, error) { + t.Helper() + client, err := dialGNMI(t, dut) + if err != nil { + return "", err + } + ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second) + defer cancel() + resp, err := client.Get(ctx, &gpb.GetRequest{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, + Path: []*gpb.Path{globalFilterPolicyPath(niName, leaf)}, + Type: gpb.GetRequest_CONFIG, + Encoding: aftpf.ConfigEncoding(dut), + }) + if err != nil { + return "", fmt.Errorf("read global-filter %s: %w", leaf, err) + } + for _, notification := range resp.GetNotification() { + for _, update := range notification.GetUpdate() { + if update.GetVal() == nil { + return "", fmt.Errorf("global-filter %s Get returned an empty update: %v", leaf, update) + } + var value any + switch typed := update.GetVal().GetValue().(type) { + case *gpb.TypedValue_JsonIetfVal: + if err := json.Unmarshal(typed.JsonIetfVal, &value); err != nil { + return "", fmt.Errorf("decode global-filter %s: %w", leaf, err) + } + case *gpb.TypedValue_JsonVal: + if err := json.Unmarshal(typed.JsonVal, &value); err != nil { + return "", fmt.Errorf("decode global-filter %s: %w", leaf, err) + } + case *gpb.TypedValue_StringVal: + value = typed.StringVal + default: + return "", fmt.Errorf("unexpected global-filter %s encoding %T", leaf, typed) + } + if policy, ok := globalFilterPolicyValue(value, leaf); ok { + return policy, nil + } + } + } + return "", fmt.Errorf("global-filter %s not found in Get response: %v", leaf, resp) +} + +// globalFilterPolicyValue accepts either a leaf- or container-valued JSON_IETF Get. +func globalFilterPolicyValue(value any, leaf string) (string, bool) { + switch value := value.(type) { + case string: + return value, true + case map[string]any: + for key, child := range value { + if i := strings.LastIndexByte(key, ':'); i >= 0 { + key = key[i+1:] + } + if key == leaf { + policy, ok := child.(string) + return policy, ok + } + } + for _, child := range value { + if nested, ok := child.(map[string]any); ok { + if policy, ok := globalFilterPolicyValue(nested, leaf); ok { + return policy, true + } + } + } + } + return "", false +} + // deletePolicy deletes a policy-definition using the ygot-generated OC path. func deletePolicy(t *testing.T, dut *ondatra.DUTDevice, policyName string) error { t.Helper() @@ -358,21 +499,197 @@ func updatePolicyStatementPrefixSet(t *testing.T, dut *ondatra.DUTDevice, policy req := &gpb.SetRequest{Update: []*gpb.Update{ { Path: statementPrefixSetConfigPath(policyName, statementName), - Val: &gpb.TypedValue{Value: &gpb.TypedValue_StringVal{StringVal: newPrefixSet}}, + Val: policyStringValue(dut, newPrefixSet), }, }} - if _, err := client.Set(context.Background(), req); err != nil { + started := time.Now() + t.Logf("Sending prefix-set reference gNMI SetRequest UTC=%s: %v", started.UTC().Format(time.RFC3339Nano), req) + response, setErr := client.Set(context.Background(), req) + t.Logf("Prefix-set reference Set end UTC=%s elapsed=%v status=%s error=%v response=%v", time.Now().UTC().Format(time.RFC3339Nano), time.Since(started), status.Code(setErr), setErr, response) + if dut.Vendor() == ondatra.CISCO { + saveAFTDiagnostic(t, "prefix-set leaf Update "+policyName, "gNMI Set", fmt.Sprintf("UTC: %s\nRequest: %v\nResponse: %v\nError: %v\n", started.UTC().Format(time.RFC3339Nano), req, response, setErr)) + } + if setErr != nil { return fmt.Errorf("failed to update policy %s statement %s prefix-set to %s: %w", - policyName, statementName, newPrefixSet, err) + policyName, statementName, newPrefixSet, setErr) } return nil } +// replacePolicyPrefixSet replaces AFT-6.1.4's complete single-statement policy. +// The policy remains attached, so the same AFT subscription can verify the +// resulting streamed deletions. This helper reconstructs the entire policy +// and must not be used for policies containing additional statements. +func replacePolicyPrefixSet(t *testing.T, dut *ondatra.DUTDevice, policyName, statementName, + newPrefixSet string) error { + t.Helper() + client, err := dialGNMI(t, dut) + if err != nil { + return err + } + statement := map[string]any{ + "name": statementName, + "config": map[string]any{"name": statementName}, + "conditions": map[string]any{"match-prefix-set": map[string]any{ + "config": map[string]any{"prefix-set": newPrefixSet, "match-set-options": "ANY"}, + }}, + "actions": map[string]any{"config": map[string]any{"policy-result": "ACCEPT_ROUTE"}}, + } + policyJSON, err := json.Marshal(map[string]any{ + "name": policyName, + "config": map[string]any{"name": policyName}, + "statements": map[string]any{"statement": []any{statement}}, + }) + if err != nil { + return fmt.Errorf("marshal replacement policy: %w", err) + } + req := &gpb.SetRequest{ + Prefix: &gpb.Path{Origin: "openconfig"}, + Replace: []*gpb.Update{{ + Path: policyDefinitionPath(policyName), + Val: &gpb.TypedValue{Value: &gpb.TypedValue_JsonIetfVal{JsonIetfVal: policyJSON}}, + }}, + } + started := time.Now() + t.Logf("Sending full-policy prefix-set replacement gNMI SetRequest UTC=%s: %v", started.UTC().Format(time.RFC3339Nano), req) + ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second) + defer cancel() + response, setErr := client.Set(ctx, req) + t.Logf("Full-policy prefix-set replacement Set end UTC=%s elapsed=%v status=%s error=%v response=%v", time.Now().UTC().Format(time.RFC3339Nano), time.Since(started), status.Code(setErr), setErr, response) + if dut.Vendor() == ondatra.CISCO { + saveAFTDiagnostic(t, "prefix-set policy Replace "+policyName, "gNMI Set", fmt.Sprintf("UTC: %s\nRequest: %v\nResponse: %v\nError: %v\n", started.UTC().Format(time.RFC3339Nano), req, response, setErr)) + } + if setErr != nil { + return fmt.Errorf("replace complete policy %s (statement %s) with prefix-set %s: %w", + policyName, statementName, newPrefixSet, setErr) + } + return nil +} + +// logConfigPath logs a time-bounded CONFIG readback without replacing the test's +// Set or streamed-AFT assertions. A failed Get is diagnostic, not a test result. +func logConfigPath(t *testing.T, dut *ondatra.DUTDevice, label string, path *gpb.Path) { + t.Helper() + client, err := dialGNMI(t, dut) + if err != nil { + t.Logf("%s CONFIG readback: dial failed: %v", label, err) + return + } + ctx, cancel := context.WithTimeout(t.Context(), 15*time.Second) + defer cancel() + resp, err := client.Get(ctx, &gpb.GetRequest{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, + Path: []*gpb.Path{path}, + Type: gpb.GetRequest_CONFIG, + Encoding: aftpf.ConfigEncoding(dut), + }) + if err != nil { + t.Logf("%s CONFIG readback for %v failed: %v", label, path, err) + return + } + t.Logf("%s CONFIG readback for %v: %v", label, path, resp) +} + +func prefixSetConfigPath(name string) *gpb.Path { + return &gpb.Path{Elem: []*gpb.PathElem{ + {Name: "routing-policy"}, + {Name: "defined-sets"}, + {Name: "prefix-sets"}, + {Name: "prefix-set", Key: map[string]string{"name": name}}, + {Name: "config"}, + }} +} + +func logCiscoCommand(t *testing.T, dut *ondatra.DUTDevice, command string) { + t.Helper() + logAFTDiagnosticCLI(context.Background(), t, dut, command) +} + +// probeRawFilteredPrefixes observes exact AFT prefixes directly from the DUT. +// It does not feed the test's validation cache, so it can distinguish a +// server-side filtering failure from a cache/decoder problem. +func probeRawFilteredPrefixes(t *testing.T, dut *ondatra.DUTDevice, niName string, prefixes []string) { + t.Helper() + client, err := dialGNMI(t, dut) + if err != nil { + t.Logf("Raw filtered-prefix probe dial failed: %v", err) + return + } + ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(75*time.Second)) + defer cancel() + stream, err := client.Subscribe(ctx) + if err != nil { + t.Logf("Raw filtered-prefix probe Subscribe failed: %v", err) + return + } + var subscriptions []*gpb.Subscription + for _, prefix := range prefixes { + path := &gpb.Path{Elem: []*gpb.PathElem{ + {Name: "ipv4-unicast"}, + {Name: "ipv4-entry", Key: map[string]string{"prefix": prefix}}, + }} + subscriptions = append(subscriptions, &gpb.Subscription{Path: path, Mode: gpb.SubscriptionMode_ON_CHANGE}) + } + req := &gpb.SubscribeRequest{Request: &gpb.SubscribeRequest_Subscribe{Subscribe: &gpb.SubscriptionList{ + Mode: gpb.SubscriptionList_STREAM, + Encoding: gpb.Encoding_PROTO, + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name(), Elem: []*gpb.PathElem{ + {Name: "network-instances"}, + {Name: "network-instance", Key: map[string]string{"name": niName}}, + {Name: "afts"}, + }}, + Subscription: subscriptions, + }}} + t.Logf("Raw filtered-prefix probe sending SubscribeRequest UTC=%s: %v", time.Now().UTC().Format(time.RFC3339Nano), req) + if err := stream.Send(req); err != nil { + t.Logf("Raw filtered-prefix probe Send failed: %v", err) + return + } + updates, deletes, notifications := 0, 0, 0 + for { + resp, err := stream.Recv() + if err != nil { + t.Logf("Raw filtered-prefix probe ended before SyncResponse: prefixes=%v notifications=%d updates=%d deletes=%d error=%v", + prefixes, notifications, updates, deletes, err) + return + } + if n := resp.GetUpdate(); n != nil { + notifications++ + updates += len(n.GetUpdate()) + deletes += len(n.GetDelete()) + if notifications <= 12 { + t.Logf("Raw filtered-prefix probe notification %d UTC=%s: %v", + notifications, time.Now().UTC().Format(time.RFC3339Nano), n) + } + } + if resp.GetSyncResponse() { + t.Logf("Raw filtered-prefix probe SyncResponse UTC=%s: prefixes=%v notifications=%d updates=%d deletes=%d", + time.Now().UTC().Format(time.RFC3339Nano), prefixes, notifications, updates, deletes) + return + } + } +} + +// collectAndVerify uses a shorter check interval for Cisco's multi-stage suite. +// The default two-minute interval spends much of the suite's timeout waiting +// between successive stages; 45 seconds also leaves room for the full-cache +// conversions after a filter is removed. +func collectAndVerify(t *testing.T, dut *ondatra.DUTDevice, cfg aftpf.RunCollectorParams, + present, absent []string) *aftcache.AFTData { + t.Helper() + if dut.Vendor() == ondatra.CISCO { + cfg.CheckInterval = aftCheckInterval + } + return aftpf.CollectAndVerify(t, dut, cfg, present, absent) +} + // rawAFTStream is a raw gNMI STREAM subscription to afts/global-filter/state, // used to observe the delete notification emitted when the filter is removed. type rawAFTStream struct { - mu sync.Mutex - notifs []*gpb.Notification + mu sync.Mutex + notifs []*gpb.Notification + syncResponses int + receiveErr error } // newRawAFTStream opens a raw STREAM ON_CHANGE subscription on @@ -414,18 +731,56 @@ func newRawAFTStream(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, for { resp, err := sub.Recv() if err != nil { + rs.mu.Lock() + rs.receiveErr = err + rs.mu.Unlock() return } + rs.mu.Lock() + if resp.GetSyncResponse() { + rs.syncResponses++ + } if n := resp.GetUpdate(); n != nil { - rs.mu.Lock() rs.notifs = append(rs.notifs, n) - rs.mu.Unlock() } + rs.mu.Unlock() } }() return rs, nil } +// logStateDeleteDiagnostics reports the notification paths seen by the raw +// filter-state stream. A parent-path delete may remove the policy leaf even +// when the exact leaf name is absent from the notification's delete path. +func (rs *rawAFTStream) logStateDeleteDiagnostics(t *testing.T, policyLeaf string) { + t.Helper() + rs.mu.Lock() + notifs := append([]*gpb.Notification(nil), rs.notifs...) + syncResponses, receiveErr := rs.syncResponses, rs.receiveErr + rs.mu.Unlock() + t.Logf("global-filter/state %s delete diagnostic: syncResponses=%d notifications=%d receiveErr=%v", + policyLeaf, syncResponses, len(notifs), receiveErr) + const maxUpdatePaths = 10 + updatePaths := 0 + deletePaths := 0 + for _, notification := range notifs { + for _, path := range notification.GetDelete() { + deletePaths++ + t.Logf("global-filter/state delete notification: timestamp=%d prefix=%v delete=%v", + notification.GetTimestamp(), notification.GetPrefix(), path) + } + for _, update := range notification.GetUpdate() { + updatePaths++ + if updatePaths <= maxUpdatePaths { + t.Logf("global-filter/state update notification: timestamp=%d prefix=%v path=%v value=%v", + notification.GetTimestamp(), notification.GetPrefix(), update.GetPath(), update.GetVal()) + } + } + } + t.Logf("global-filter/state %s delete diagnostic: deletePaths=%d updatePaths=%d (logged first %d updates)", + policyLeaf, deletePaths, updatePaths, maxUpdatePaths) +} + // awaitStateDelete blocks until a delete notification is observed for the // given global-filter/state policy leaf, or until timeout. func (rs *rawAFTStream) awaitStateDelete(timeout time.Duration, policyLeaf string) bool { @@ -439,18 +794,23 @@ func (rs *rawAFTStream) awaitStateDelete(timeout time.Duration, policyLeaf strin return false } -// hasStateDelete reports whether a delete notification referencing the -// global-filter subtree deleted the named policy leaf. +// hasStateDelete accepts either a leaf delete or a delete of its containing +// global-filter/state subtree. A delete elsewhere in global-filter does not +// establish that this state leaf was removed. func (rs *rawAFTStream) hasStateDelete(policyLeaf string) bool { rs.mu.Lock() defer rs.mu.Unlock() for _, n := range rs.notifs { - if !notificationHasName(n, "global-filter") { - continue - } for _, d := range n.GetDelete() { - for _, e := range d.GetElem() { - if e.GetName() == policyLeaf { + path := append(append([]*gpb.PathElem{}, n.GetPrefix().GetElem()...), d.GetElem()...) + if len(path) < 2 { + continue + } + for i := 0; i+1 < len(path); i++ { + if path[i].GetName() != "global-filter" || path[i+1].GetName() != "state" { + continue + } + if len(path) == i+2 || (len(path) == i+3 && path[i+2].GetName() == policyLeaf) { return true } } @@ -459,31 +819,6 @@ func (rs *rawAFTStream) hasStateDelete(policyLeaf string) bool { return false } -// notificationHasName reports whether the given path element name appears -// anywhere in the notification's prefix, update paths, or delete paths. -func notificationHasName(n *gpb.Notification, name string) bool { - for _, e := range n.GetPrefix().GetElem() { - if e.GetName() == name { - return true - } - } - for _, u := range n.GetUpdate() { - for _, e := range u.GetPath().GetElem() { - if e.GetName() == name { - return true - } - } - } - for _, d := range n.GetDelete() { - for _, e := range d.GetElem() { - if e.GetName() == name { - return true - } - } - } - return false -} - // verifyNexthopGroupsAndNexthopsRetained confirms the next-hop-group and // next-hops backing a prefix are still present in the filtered AFT. func verifyNexthopGroupsAndNexthopsRetained(aft *aftcache.AFTData, prefix string) error { @@ -544,10 +879,19 @@ func runPrefixSetIteration(t *testing.T, dut *ondatra.DUTDevice, tc prefixSetIte t.Logf("%s - Initial Synchronization", tc.name) collector := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - collector.ListenUntilPreUpdateHook(context.Background(), t, subscriptionWait, - []aftcache.NotificationHook{aftcache.VerifyAtomicFlagHook(t)}, - aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, - map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true})) + defer func() { + if t.Failed() { + t.Logf("%s AFT collector progress at failure: %+v", tc.name, collector.Progress()) + } + }() + hooks := []aftcache.NotificationHook{aftcache.VerifyAtomicFlagHook(t)} + stop := aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, + map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}) + if dut.Vendor() == ondatra.CISCO { + collector.ListenUntilPreUpdateHookWithInterval(context.Background(), t, subscriptionWait, aftCheckInterval, hooks, stop) + } else { + collector.ListenUntilPreUpdateHook(context.Background(), t, subscriptionWait, hooks, stop) + } initialAFT, err := collector.ToAFT(t, dut) if err != nil { t.Errorf("%s: ToAFT failed: %v", tc.name, err) @@ -571,7 +915,7 @@ func runPrefixSetIteration(t *testing.T, dut *ondatra.DUTDevice, tc prefixSetIte // Keep watching the same streaming session so the dynamic add is // observed as an incremental notification on the existing stream. - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, map[string]bool{tc.dynamicAddPrefix: true}, @@ -583,7 +927,7 @@ func runPrefixSetIteration(t *testing.T, dut *ondatra.DUTDevice, tc prefixSetIte // Same session again: the delete must be seen as a streamed // deletion notification, not by re-subscribing after the fact. - delAFT := aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + delAFT := collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.DeletionStoppingCondition(t, dut, map[string]bool{tc.dynamicAddPrefix: true}), @@ -601,7 +945,7 @@ func runPrefixSetIteration(t *testing.T, dut *ondatra.DUTDevice, tc prefixSetIte // Drain the existing stream and confirm the non-matching prefix // never surfaces; it must stay absent from the filtered view. - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.DeletionStoppingCondition(t, dut, map[string]bool{tc.dynamicNonMatchPrefix: true}), @@ -625,6 +969,7 @@ func runPrefixSetIteration(t *testing.T, dut *ondatra.DUTDevice, tc prefixSetIte wantDeleteLeaf = "ipv6-policy" } if !rawStream.awaitStateDelete(subscriptionWait, wantDeleteLeaf) { + rawStream.logStateDeleteDiagnostics(t, wantDeleteLeaf) t.Errorf("%s: did not receive global-filter/state/%s delete notification after removing the filter", tc.name, wantDeleteLeaf) } @@ -633,7 +978,7 @@ func runPrefixSetIteration(t *testing.T, dut *ondatra.DUTDevice, tc prefixSetIte liftWant := map[string]bool{tc.nonMatchPrefix: true} // The filter removal is validated on the same stream: the previously // filtered-out prefix must now appear as a streamed update. - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, liftWant, @@ -668,7 +1013,7 @@ func testPrefixSetPolicySubscription(t *testing.T, dut *ondatra.DUTDevice) { policyName: policyPfxSetA, ipv4: true, nextHop: atePort1.IPv4, - matchPrefixes: []string{"198.51.100.0/24", "203.0.113.0/28", defaultV4Route}, + matchPrefixes: []string{"198.51.100.0/24", "203.0.113.0/28"}, nonMatchPrefix: "100.64.0.0/24", dynamicAddPrefix: "198.51.100.1/32", dynamicNonMatchPrefix: "100.64.1.0/24", @@ -678,7 +1023,7 @@ func testPrefixSetPolicySubscription(t *testing.T, dut *ondatra.DUTDevice) { policyName: policyPfxSetB, ipv4: false, nextHop: atePort1.IPv6, - matchPrefixes: []string{"2001:db8:2::/64", defaultV6Route}, + matchPrefixes: []string{"2001:db8:2::/64"}, nonMatchPrefix: "2001:db8:1::/64", dynamicAddPrefix: "2001:db8:2::1/128", dynamicNonMatchPrefix: "2001:db8:4::/64", @@ -703,6 +1048,14 @@ func testPrefixSetPolicySubscription(t *testing.T, dut *ondatra.DUTDevice) { } for i, tc := range cases { + if dut.Vendor() != ondatra.CISCO { + switch tc.policyName { + case policyPfxSetA: + tc.matchPrefixes = append(tc.matchPrefixes, defaultV4Route) + case policyPfxSetB: + tc.matchPrefixes = append(tc.matchPrefixes, defaultV6Route) + } + } t.Run(tc.name, func(t *testing.T) { runPrefixSetIteration(t, dut, tc, i) }) @@ -720,10 +1073,25 @@ func testNonExistentPolicy(t *testing.T, dut *ondatra.DUTDevice) { ni := deviations.DefaultNetworkInstance(dut) matchPrefix := "198.51.100.128/25" + wantSetCode := codes.FailedPrecondition + if dut.Vendor() == ondatra.CISCO { + // Cisco permits a global-filter reference before its routing-policy + // definition exists. Verify that both references were stored, then + // create the policy and continue testing the filtered AFT view. + wantSetCode = codes.OK + } if err := setGlobalFilterExpectCode(t, dut, ni, policyNotYetExist, policyNotYetExist, - codes.FailedPrecondition); err != nil { + wantSetCode); err != nil { t.Errorf("Non-existent policy check: %v", err) } + if dut.Vendor() == ondatra.CISCO { + for _, leaf := range []string{"ipv4-policy", "ipv6-policy"} { + if got, err := readGlobalFilterPolicy(t, dut, ni, leaf); err != nil || got != policyNotYetExist { + t.Fatalf("Non-existent policy check: global-filter %s got %q, want %q (err: %v)", + leaf, got, policyNotYetExist, err) + } + } + } root := &oc.Root{} rp := root.GetOrCreateRoutingPolicy() @@ -752,7 +1120,7 @@ func testNonExistentPolicy(t *testing.T, dut *ondatra.DUTDevice) { wantPrefixes := map[string]bool{matchPrefix: true} collector := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, @@ -780,6 +1148,19 @@ func testPolicyDeletion(t *testing.T, dut *ondatra.DUTDevice) { ni := deviations.DefaultNetworkInstance(dut) wantPrefixes := map[string]bool{"198.51.100.0/24": true, "203.0.113.0/28": true} liftWant := map[string]bool{"100.64.0.0/24": true} + filteredOut := map[string]bool{"100.64.0.0/24": true} + root := &oc.Root{} + rp := root.GetOrCreateRoutingPolicy() + aftpf.AddPrefixSetPolicy(t, rp, aftpf.PrefixSetPolicyParams{ + PolicyName: policyPfxSetA, + StatementNames: []string{defaultStatementName}, + PrefixSetNames: []string{v4PfxSetA}, + PrefixList: policyPrefixSetMembers(dut, true), + PrefixMode: pfxMode, + MatchPrefixSet: true, + MatchSetOption: oc.E_RoutingPolicy_MatchSetOptionsRestrictedType(oc.RoutingPolicy_MatchSetOptionsType_ANY), + PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, + }) aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{ V4Policy: policyPfxSetA, @@ -788,7 +1169,7 @@ func testPolicyDeletion(t *testing.T, dut *ondatra.DUTDevice) { }) collector := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, @@ -796,8 +1177,49 @@ func testPolicyDeletion(t *testing.T, dut *ondatra.DUTDevice) { Timeout: subscriptionWait, }, nil, nil) - if err := deletePolicyExpectCode(t, dut, policyPfxSetA, codes.FailedPrecondition); err != nil { - t.Errorf("Policy-still-referenced check: %v", err) + wantDeleteCode := codes.FailedPrecondition + if dut.Vendor() == ondatra.CISCO { + // Cisco's configuration policy allows deletion of a routing-policy + // definition even while the AFT global filter references it. The + // subsequent atomic-delete check still needs that definition and + // reference, so restore and verify them after this successful delete. + wantDeleteCode = codes.OK + if got, err := readGlobalFilterPolicy(t, dut, ni, "ipv4-policy"); err != nil || got != policyPfxSetA { + t.Fatalf("Policy-still-referenced check: IPv4 filter before delete got %q, want %q (err: %v)", got, policyPfxSetA, err) + } + if !gnmi.Lookup(t, dut, gnmi.OC().RoutingPolicy().PolicyDefinition(policyPfxSetA).Config()).IsPresent() { + t.Fatalf("Policy-still-referenced check: policy %q was absent before delete", policyPfxSetA) + } + } + if err := deletePolicyExpectCode(t, dut, policyPfxSetA, wantDeleteCode); err != nil { + t.Fatalf("Policy-still-referenced check: %v", err) + } + if dut.Vendor() == ondatra.CISCO { + if gnmi.Lookup(t, dut, gnmi.OC().RoutingPolicy().PolicyDefinition(policyPfxSetA).Config()).IsPresent() { + t.Fatalf("Policy-still-referenced check: policy %q still exists after successful delete", policyPfxSetA) + } + restoreBatch := &gnmi.SetBatch{} + gnmi.BatchUpdate(restoreBatch, gnmi.OC().RoutingPolicy().Config(), rp) + restoreBatch.Set(t, dut) + aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{ + V4Policy: policyPfxSetA, + VRFName: ni, + }) + if !gnmi.Lookup(t, dut, gnmi.OC().RoutingPolicy().PolicyDefinition(policyPfxSetA).Config()).IsPresent() { + t.Fatalf("Policy-still-referenced check: policy %q was not restored", policyPfxSetA) + } + if got, err := readGlobalFilterPolicy(t, dut, ni, "ipv4-policy"); err != nil || got != policyPfxSetA { + t.Fatalf("Policy-still-referenced check: restored IPv4 filter got %q, want %q (err: %v)", got, policyPfxSetA, err) + } + collectAndVerify(t, dut, aftpf.RunCollectorParams{ + Ctx: context.Background(), + Collector: collector, + // The wanted routes can already be present while the collector is + // still processing the deletion of the formerly unfiltered route. + Stop: aftcache.InitialSyncStoppingConditionWithAbsentPrefixes(t, dut, wantPrefixes, filteredOut, + map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}), + Timeout: subscriptionWait, + }, []string{"198.51.100.0/24", "203.0.113.0/28"}, []string{"100.64.0.0/24"}) } if err := deleteGlobalFilterAndPolicyAtomic(t, dut, ni, policyPfxSetA); err != nil { @@ -806,7 +1228,7 @@ func testPolicyDeletion(t *testing.T, dut *ondatra.DUTDevice) { } // Same session observes the atomic filter+policy delete as a streamed change. - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, liftWant, @@ -814,18 +1236,6 @@ func testPolicyDeletion(t *testing.T, dut *ondatra.DUTDevice) { Timeout: subscriptionWait, }, []string{"100.64.0.0/24"}, nil) - root := &oc.Root{} - rp := root.GetOrCreateRoutingPolicy() - aftpf.AddPrefixSetPolicy(t, rp, aftpf.PrefixSetPolicyParams{ - PolicyName: policyPfxSetA, - StatementNames: []string{defaultStatementName}, - PrefixSetNames: []string{v4PfxSetA}, - PrefixList: pfxSetAMembers, - PrefixMode: pfxMode, - MatchPrefixSet: true, - MatchSetOption: oc.E_RoutingPolicy_MatchSetOptionsRestrictedType(oc.RoutingPolicy_MatchSetOptionsType_ANY), - PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, - }) batch := &gnmi.SetBatch{} gnmi.BatchUpdate(batch, gnmi.OC().RoutingPolicy().Config(), rp) batch.Set(t, dut) @@ -836,10 +1246,10 @@ func testPolicyDeletion(t *testing.T, dut *ondatra.DUTDevice) { }) // Same session observes the policy re-configuration as streamed updates. - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, - Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, + Stop: aftcache.InitialSyncStoppingConditionWithAbsentPrefixes(t, dut, wantPrefixes, filteredOut, map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}), Timeout: subscriptionWait, }, []string{"198.51.100.0/24", "203.0.113.0/28"}, []string{"100.64.0.0/24"}) @@ -852,7 +1262,7 @@ func testPolicyDeletion(t *testing.T, dut *ondatra.DUTDevice) { } // Same session observes the multi-step filter+policy delete as streamed deletions. - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, liftWant, @@ -879,26 +1289,67 @@ func testChangeReferencedPrefixSet(t *testing.T, dut *ondatra.DUTDevice) { wantPrefixes := map[string]bool{"198.51.100.0/24": true, "203.0.113.0/28": true} collector := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + diagnostics := aftFilterDiagnostics{ + networkInstance: ni, + policy: policyPfxSetA, + prefixSets: []string{v4PfxSetA, v4PfxSetB}, + prefixes: []string{"198.51.100.0/24", "203.0.113.0/28"}, + } + stage := "AFT-6.1.4 initial subscription" + failureCaptured := false + captureFailure := func() { + if !failureCaptured && t.Failed() { + failureCaptured = true + diagnostics.captureFailure(t, dut, stage, cancel, collector) + } + } + defer captureFailure() + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}), Timeout: subscriptionWait, }, []string{"198.51.100.0/24", "203.0.113.0/28"}, nil) - - if err := updatePolicyStatementPrefixSet(t, dut, policyPfxSetA, defaultStatementName, v6PfxSetB); err != nil { + diagnostics.capture(t, dut, "AFT-6.1.4 before prefix-set swap") + stage = "AFT-6.1.4 prefix-set swap" + + newPrefixSet := v6PfxSetB + setPrefixSetReference := updatePolicyStatementPrefixSet + if dut.Vendor() == ondatra.CISCO { + // Cisco-specific XR limitation: individual fields within the native + // route-policy bag cannot be set independently. Replace the complete + // OpenConfig policy definition so the mapper can replace the whole + // bag, for both the policy change and cleanup. This test policy has + // only statement 10, which is included in full in each replacement. + // An uninstalled IPv4 set keeps the active IPv4 policy in-family. + newPrefixSet = v4PfxSetB + setPrefixSetReference = replacePolicyPrefixSet + } + referencePath := statementPrefixSetConfigPath(policyPfxSetA, defaultStatementName) + logConfigPath(t, dut, "before prefix-set swap", referencePath) + logConfigPath(t, dut, "replacement prefix-set", prefixSetConfigPath(newPrefixSet)) + if err := setPrefixSetReference(t, dut, policyPfxSetA, defaultStatementName, newPrefixSet); err != nil { + diagnostics.capturePolicyOperation(t, dut, "AFT-6.1.4 prefix-set swap rejected", v4PfxSetA) + logConfigPath(t, dut, "after failed prefix-set swap", referencePath) + logCiscoCommand(t, dut, "show running-config route-policy "+policyPfxSetA) + logCiscoCommand(t, dut, "show logging") t.Errorf("Failed to swap prefix-set reference: %v", err) return } + diagnostics.capturePolicyOperation(t, dut, "AFT-6.1.4 accepted prefix-set swap", newPrefixSet) + logConfigPath(t, dut, "after prefix-set swap", referencePath) + diagnostics.capture(t, dut, "AFT-6.1.4 after prefix-set swap") + stage = "AFT-6.1.4 waiting for prefix deletions after swap" // Same session observes the prefix-set swap as streamed deletions. - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.DeletionStoppingCondition(t, dut, map[string]bool{"198.51.100.0/24": true}), Timeout: subscriptionWait, }, nil, []string{"198.51.100.0/24", "203.0.113.0/28"}) + stage = "AFT-6.1.4 prefix deletion stability check" // The swap only produces delete notifications for PREFIX-SET-A's members; // PREFIX-SET-B's members were never installed in the AFT, so there is no @@ -915,7 +1366,10 @@ func testChangeReferencedPrefixSet(t *testing.T, dut *ondatra.DUTDevice) { }) } - if err := updatePolicyStatementPrefixSet(t, dut, policyPfxSetA, defaultStatementName, v4PfxSetA); err != nil { + // Preserve a nonfatal ToAFT error before cleanup restores the policy. + captureFailure() + stage = "AFT-6.1.4 cleanup" + if err := setPrefixSetReference(t, dut, policyPfxSetA, defaultStatementName, v4PfxSetA); err != nil { t.Errorf("Cleanup: failed to restore prefix-set reference: %v", err) } if err := deleteGlobalFilter(t, dut, ni); err != nil { @@ -941,7 +1395,7 @@ func testMultiStatementPolicy(t *testing.T, dut *ondatra.DUTDevice) { wantPrefixes := map[string]bool{"198.51.100.0/24": true, "203.0.113.0/28": true, extraPrefix: true} collector := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, @@ -969,7 +1423,7 @@ func testDenyActionPolicy(t *testing.T, dut *ondatra.DUTDevice) { wantPrefixes := map[string]bool{"100.64.0.0/24": true} collector := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, @@ -982,32 +1436,72 @@ func testDenyActionPolicy(t *testing.T, dut *ondatra.DUTDevice) { } } -// testNonPrefixSetMatchCriteria implements AFT-6.1.7. +// testNonPrefixSetMatchCriteria implements AFT-6.1.7. Cisco uses an +// unconditional drop policy to cover an empty policy view and live transitions; +// this substitution does not exercise tag matching. func testNonPrefixSetMatchCriteria(t *testing.T, dut *ondatra.DUTDevice) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() ni := deviations.DefaultNetworkInstance(dut) + policyName, policyDescription := policyTagMatch, "tag-match" + if dut.Vendor() == ondatra.CISCO { + policyName, policyDescription = policyDropAll, "drop-all" + t.Log("Cisco AFT-6.1.7 uses an unconditional drop policy for empty-view and live-transition coverage; tag matching is unsupported") + } aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{ - V4Policy: policyTagMatch, + V4Policy: policyName, V6Policy: "", VRFName: ni, }) + diagnostics := aftFilterDiagnostics{ + networkInstance: ni, + policy: policyName, + prefixes: []string{"198.51.100.0/24", "203.0.113.0/28", "100.64.0.0/24"}, + } + diagnostics.capture(t, dut, "AFT-6.1.7 "+policyDescription+" policy attached") + if dut.Vendor() == ondatra.CISCO { + // Record the applied policy and test routes if drop-all does not + // exclude them. Required next-hop resolution routes may remain visible. + if got, err := readGlobalFilterPolicy(t, dut, ni, "ipv4-policy"); err != nil { + t.Logf("%s IPv4 global-filter CONFIG readback failed: %v", policyDescription, err) + } else { + t.Logf("%s IPv4 global-filter CONFIG readback: %q", policyDescription, got) + } + logConfigPath(t, dut, policyDescription+" policy definition", policyDefinitionPath(policyName)) + logCiscoCommand(t, dut, "show running-config route-policy "+policyName) + for _, prefix := range []string{"198.51.100.0/24", "203.0.113.0/28", "100.64.0.0/24"} { + logCiscoCommand(t, dut, "show route "+prefix+" detail") + } + } collector := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + stage := "AFT-6.1.7 initial " + policyDescription + " subscription" + defer func() { + diagnostics.captureFailure(t, dut, stage, cancel, collector) + }() + absentPrefixes := map[string]bool{"198.51.100.0/24": true, "203.0.113.0/28": true, "100.64.0.0/24": true} + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, - Stop: aftcache.InitialSyncStoppingCondition(t, dut, map[string]bool{}, + // Wait for the initial SyncResponse and for all forbidden prefixes + // to disappear; an empty desired-prefix set alone stops too early. + Stop: aftcache.InitialSyncStoppingConditionWithAbsentPrefixes(t, dut, nil, absentPrefixes, map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}), Timeout: subscriptionWait, }, nil, []string{"198.51.100.0/24", "203.0.113.0/28", "100.64.0.0/24"}) + stage = "AFT-6.1.7 transition to prefix-set policy" - if err := deleteGlobalFilter(t, dut, ni); err != nil { - t.Errorf("Failed to delete global-filter: %v", err) - return + if dut.Vendor() != ondatra.CISCO { + if err := deleteGlobalFilter(t, dut, ni); err != nil { + t.Errorf("Failed to delete global-filter: %v", err) + return + } } + // Replace Cisco's policy reference directly, preserving the same stream + // and avoiding an unfiltered interval between drop-all and prefix filtering. + diagnostics.policy = policyPfxSetA aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{ V4Policy: policyPfxSetA, V6Policy: "", @@ -1016,28 +1510,46 @@ func testNonPrefixSetMatchCriteria(t *testing.T, dut *ondatra.DUTDevice) { // Same session observes the transition to the prefix-set policy as streamed updates. wantPrefixes := map[string]bool{"198.51.100.0/24": true, "203.0.113.0/28": true} - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + stop := aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, + map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}) + var absent []string + if dut.Vendor() == ondatra.CISCO { + absent = []string{"100.64.0.0/24"} + stop = aftcache.InitialSyncStoppingConditionWithAbsentPrefixes(t, dut, wantPrefixes, + map[string]bool{"100.64.0.0/24": true}, + map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}) + } + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, - Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, - map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}), - Timeout: subscriptionWait, - }, nil, nil) + Stop: stop, + Timeout: subscriptionWait, + }, nil, absent) + diagnostics.policy = policyName aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{ - V4Policy: policyTagMatch, + V4Policy: policyName, V6Policy: "", VRFName: ni, }) + diagnostics.capture(t, dut, "AFT-6.1.7 transition back to "+policyDescription+" policy") + stage = "AFT-6.1.7 waiting for deletions after " + policyDescription + " transition" - // Same session observes the transition back to tag-match as streamed deletions. - aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ + // Same session observes the transition back as streamed deletions. + deletePrefixes := map[string]bool{"198.51.100.0/24": true} + absentAfterTransition := []string{"198.51.100.0/24", "203.0.113.0/28"} + if dut.Vendor() == ondatra.CISCO { + deletePrefixes = absentPrefixes + absentAfterTransition = append(absentAfterTransition, "100.64.0.0/24") + } + collectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, - Stop: aftcache.DeletionStoppingCondition(t, dut, map[string]bool{"198.51.100.0/24": true}), + Stop: aftcache.DeletionStoppingCondition(t, dut, deletePrefixes), Timeout: subscriptionWait, - }, nil, []string{"198.51.100.0/24", "203.0.113.0/28"}) + }, nil, absentAfterTransition) + stage = "AFT-6.1.7 cleanup" if err := deleteGlobalFilter(t, dut, ni); err != nil { t.Errorf("Cleanup: failed to delete global-filter: %v", err) } @@ -1085,12 +1597,13 @@ func TestAFTPrefixFiltering(t *testing.T) { aftpf.AwaitBGPConvergence(t, dut, ni) - aftpf.CheckForDefaultRoutes(t, &aftpf.CheckForDefaultRoutesParams{ - DUT: dut, - NetworkInstance: ni, - IPv4Route: defaultV4Route, - IPv6Route: defaultV6Route, - }) + if dut.Vendor() != ondatra.CISCO { + aftpf.CheckForDefaultRoutes(t, &aftpf.CheckForDefaultRoutesParams{ + DUT: dut, NetworkInstance: ni, + IPv4Route: defaultV4Route, IPv6Route: defaultV6Route, + }) + } + tests := []struct { name string test func(t *testing.T, dut *ondatra.DUTDevice) diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/metadata.textproto b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/metadata.textproto index 6ef9e95b812..9f14f554ec2 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/metadata.textproto +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/metadata.textproto @@ -19,3 +19,12 @@ platform_exceptions: { link_local_instead_of_nh: true } } + +platform_exceptions: { + platform: { + vendor: CISCO + } + deviations: { + ipv4_missing_enabled: true + } +} diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/policy_set_diagnostics_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/policy_set_diagnostics_test.go new file mode 100644 index 00000000000..2ae3a3fbd41 --- /dev/null +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/policy_set_diagnostics_test.go @@ -0,0 +1,260 @@ +// Copyright 2026 Google LLC +// +// 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 aftsprefixfiltering_test + +import ( + "context" + "encoding/json" + "fmt" + "io" + "strings" + "testing" + "time" + + gpb "github.com/openconfig/gnmi/proto/gnmi" + "github.com/openconfig/ondatra" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/encoding/prototext" +) + +// diagnosticPolicyGet records the complete response, including parent-valued +// responses, rather than relying on the generated OpenConfig client cache. +func diagnosticPolicyGet(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, client gpb.GNMIClient, stage string, paths ...*gpb.Path) (*gpb.GetResponse, error) { + t.Helper() + readCtx, cancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) + defer cancel() + request := &gpb.GetRequest{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, + Path: paths, Type: gpb.GetRequest_CONFIG, Encoding: gpb.Encoding_JSON_IETF, + } + response, err := client.Get(readCtx, request) + output := fmt.Sprintf("Request:\n%s\nResponse:\n%s\nError: %v\n", prototext.Format(request), prototext.Format(response), err) + saveAFTDiagnostic(t, stage, "gNMI CONFIG Get", output) + t.Logf("AFT policy Get UTC=%s stage=%q status=%s request=%v response=%v error=%v", time.Now().UTC().Format(time.RFC3339Nano), stage, status.Code(err), request, response, err) + return response, err +} + +func diagnosticPolicyReference(response *gpb.GetResponse) (string, error) { + for _, notification := range response.GetNotification() { + for _, update := range notification.GetUpdate() { + var value any + switch typed := update.GetVal().GetValue().(type) { + case *gpb.TypedValue_JsonIetfVal: + if err := json.Unmarshal(typed.JsonIetfVal, &value); err != nil { + return "", err + } + case *gpb.TypedValue_JsonVal: + if err := json.Unmarshal(typed.JsonVal, &value); err != nil { + return "", err + } + case *gpb.TypedValue_StringVal: + return typed.StringVal, nil + default: + continue + } + if reference, ok := globalFilterPolicyValue(value, "prefix-set"); ok { + return reference, nil + } + } + } + return "", fmt.Errorf("no prefix-set reference in exact-leaf Get response") +} + +// policySetViews prints a compact comparison of the exact OpenConfig leaf and +// the native RPL text. This is diagnostic evidence, not an AFT assertion. +func policySetViews(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, client gpb.GNMIClient, stage, policy, expected string) bool { + t.Helper() + response, getErr := diagnosticPolicyGet(ctx, t, dut, client, stage+" exact leaf", statementPrefixSetConfigPath(policy, defaultStatementName)) + var configRef string + if getErr == nil { + configRef, getErr = diagnosticPolicyReference(response) + } + native, cliErr := logAFTDiagnosticCLIAtStage(ctx, t, dut, stage, "show running-config route-policy "+policy) + var nativeRef string + for _, line := range strings.Split(native, "\n") { + fields := strings.Fields(line) + for i := 0; i+2 < len(fields); i++ { + if fields[i] == "destination" && fields[i+1] == "in" { + nativeRef = fields[i+2] + } + } + } + output := fmt.Sprintf("stage=%q policy=%q expected=%q OpenConfig=%q nativeRPL=%q GetError=%v CLIError=%v", stage, policy, expected, configRef, nativeRef, getErr, cliErr) + t.Logf("AFT policy comparison UTC=%s %s", time.Now().UTC().Format(time.RFC3339Nano), output) + saveAFTDiagnostic(t, stage, "policy comparison", output) + return getErr == nil && cliErr == nil && configRef == expected && nativeRef == expected +} + +// capturePolicyOperation captures the trace rings immediately after the Set, +// before diagnostic Gets and later AFT processing fill them with other work. +func (d aftFilterDiagnostics) capturePolicyOperation(t *testing.T, dut *ondatra.DUTDevice, stage, expected string) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return + } + ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(90*time.Second)) + defer cancel() + t.Logf("AFT policy operation diagnostics start UTC=%s stage=%q", time.Now().UTC().Format(time.RFC3339Nano), stage) + for _, command := range []string{ + "show grpc trace all", + "show telemetry model-driven trace all", + "show configuration commit list 5", + "show configuration commit changes last 1 diff", + } { + logAFTDiagnosticCLIAtStage(ctx, t, dut, stage, command) + } + client, err := dialGNMI(t, dut) + if err != nil { + t.Logf("AFT policy operation Get unavailable: %v", err) + return + } + policySetViews(ctx, t, dut, client, stage+" shared client", d.policy, expected) + diagnosticPolicyGet(ctx, t, dut, client, stage+" statement and policy", policyStatementPath(d.policy, defaultStatementName), policyDefinitionPath(d.policy)) + // A new connection checks whether the changed leaf is visible beyond the + // connection that issued the Set. It does not populate the AFT cache. + dialCtx, dialCancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) + defer dialCancel() + freshClient, err := dut.RawAPIs().BindingDUT().DialGNMI(dialCtx) + if err != nil { + t.Logf("AFT policy independent DialGNMI failed: %v", err) + return + } + if closer, ok := freshClient.(io.Closer); ok { + defer closer.Close() + } + t.Logf("AFT policy independent client UTC=%s stage=%q client=%p", time.Now().UTC().Format(time.RFC3339Nano), stage, freshClient) + policySetViews(ctx, t, dut, freshClient, stage+" independent client", d.policy, expected) +} + +// diagnosticPolicyObjects builds complete objects for request-scope probes. +// Each probe policy is unique, unattached, and removed after its observation. +func diagnosticPolicyObjects(name, prefixSet string) (map[string]any, map[string]any, map[string]any) { + statement := map[string]any{ + "name": defaultStatementName, + "config": map[string]any{"name": defaultStatementName}, + "conditions": map[string]any{"match-prefix-set": map[string]any{ + "config": map[string]any{"prefix-set": prefixSet, "match-set-options": "ANY"}, + }}, + "actions": map[string]any{"config": map[string]any{"policy-result": "ACCEPT_ROUTE"}}, + } + policy := map[string]any{ + "name": name, "config": map[string]any{"name": name}, + "statements": map[string]any{"statement": []any{statement}}, + } + root := map[string]any{"policy-definitions": map[string]any{"policy-definition": []any{policy}}} + return statement, policy, root +} + +func diagnosticPolicySet(ctx context.Context, t *testing.T, client gpb.GNMIClient, stage string, request *gpb.SetRequest) error { + t.Helper() + setCtx, cancel := context.WithDeadline(ctx, time.Now().Add(15*time.Second)) + defer cancel() + started := time.Now() + response, err := client.Set(setCtx, request) + output := fmt.Sprintf("StartUTC: %s\nElapsed: %v\nRequest:\n%s\nResponse:\n%s\nError: %v\nStatus:\n%s", started.UTC().Format(time.RFC3339Nano), time.Since(started), prototext.Format(request), prototext.Format(response), err, prototext.Format(status.Convert(err).Proto())) + saveAFTDiagnostic(t, stage, "gNMI Set", output) + t.Logf("AFT policy Set probe UTC=%s stage=%q elapsed=%v status=%s request=%v response=%v error=%v", time.Now().UTC().Format(time.RFC3339Nano), stage, time.Since(started), status.Code(err), request, response, err) + return err +} + +// probePolicySetForms runs only after AFT-6.1.4 has failed and its original +// subscription has stopped. Results cannot change that test's pass/fail status. +func probePolicySetForms(t *testing.T, dut *ondatra.DUTDevice) { + t.Helper() + ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(3*time.Minute)) + defer cancel() + client, err := dialGNMI(t, dut) + if err != nil { + t.Logf("AFT policy Set probes unavailable: %v", err) + return + } + rootPath := &gpb.Path{Elem: []*gpb.PathElem{{Name: "routing-policy"}}} + forms := []string{"leaf-no-origin", "leaf-openconfig", "match-config-openconfig", "statement-no-origin", "statement-openconfig", "policy-openconfig", "root-openconfig"} + runID := time.Now().UnixNano() + for index, form := range forms { + if dut.Vendor() == ondatra.CISCO && strings.HasPrefix(form, "leaf-") { + t.Logf("AFT policy Set probe %s skipped: Cisco does not support single-leaf prefix-set updates", form) + continue + } + if ctx.Err() != nil { + t.Logf("AFT policy Set probes stopped before %s: %v", form, ctx.Err()) + return + } + func() { + name := fmt.Sprintf("AFT-DIAG-%d-%d", runID, index) + stage := "AFT-6.1.4 probe " + form + // Keep target empty in both variants so origin is the only + // difference between the paired requests. + origin := &gpb.Path{Origin: "openconfig"} + encode := func(value any) *gpb.TypedValue { + // All values below contain only strings, slices, and maps. + data, _ := json.Marshal(value) + return &gpb.TypedValue{Value: &gpb.TypedValue_JsonIetfVal{JsonIetfVal: data}} + } + _, _, baseline := diagnosticPolicyObjects(name, v4PfxSetB) + // Clean up even if creation partially succeeds or the budget ends. + defer func() { + cleanupCtx, cleanupCancel := context.WithDeadline(context.Background(), time.Now().Add(20*time.Second)) + defer cleanupCancel() + cleanupErr := diagnosticPolicySet(cleanupCtx, t, client, stage+" cleanup", &gpb.SetRequest{Prefix: origin, Delete: []*gpb.Path{policyDefinitionPath(name)}}) + remaining, readErr := logAFTDiagnosticCLIAtStage(cleanupCtx, t, dut, stage+" cleanup verification", "show running-config route-policy "+name) + present := false + for _, line := range strings.Split(remaining, "\n") { + present = present || strings.TrimSpace(line) == "route-policy "+name + } + t.Logf("AFT policy Set probe cleanup policy=%s nativeStillPresent=%t deleteError=%v readError=%v", name, present, cleanupErr, readErr) + }() + if err := diagnosticPolicySet(ctx, t, client, stage+" create baseline", &gpb.SetRequest{ + Prefix: origin, Update: []*gpb.Update{{Path: rootPath, Val: encode(baseline)}}, + }); err != nil { + return + } + if !policySetViews(ctx, t, dut, client, stage+" baseline", name, v4PfxSetB) { + t.Logf("AFT policy Set probe %s skipped: native and OpenConfig baseline not confirmed", form) + return + } + statement, policy, root := diagnosticPolicyObjects(name, v4PfxSetA) + path, value, replace := statementPrefixSetConfigPath(name, defaultStatementName), any(v4PfxSetA), false + switch form { + case "match-config-openconfig": + path.Elem = path.Elem[:len(path.Elem)-1] + value = map[string]any{"prefix-set": v4PfxSetA, "match-set-options": "ANY"} + case "statement-no-origin", "statement-openconfig": + path, value, replace = policyStatementPath(name, defaultStatementName), statement, true + // Match the original statement Replace payload exactly. + delete(statement, "name") + case "policy-openconfig": + path, value, replace = policyDefinitionPath(name), policy, true + case "root-openconfig": + path, value = rootPath, root + } + request := &gpb.SetRequest{Prefix: origin} + if strings.HasSuffix(form, "no-origin") { + request.Prefix = nil + } + update := &gpb.Update{Path: path, Val: encode(value)} + if replace { + request.Replace = []*gpb.Update{update} + } else { + request.Update = []*gpb.Update{update} + } + setErr := diagnosticPolicySet(ctx, t, client, stage+" change reference", request) + // Preserve the mutation's trace before Gets add unrelated records. + logAFTDiagnosticCLIAtStage(ctx, t, dut, stage, "show grpc trace all") + consistent := policySetViews(ctx, t, dut, client, stage+" result", name, v4PfxSetA) + t.Logf("AFT policy Set probe result form=%s policy=%s rpcStatus=%s nativeAndOpenConfigChanged=%t", form, name, status.Code(setErr), consistent) + }() + } +} diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dualstack/afts_prefix_filtering_dualstack_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dualstack/afts_prefix_filtering_dualstack_test.go index cf9f9314a61..300a31f5e31 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dualstack/afts_prefix_filtering_dualstack_test.go +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dualstack/afts_prefix_filtering_dualstack_test.go @@ -16,6 +16,7 @@ package aftsprefixfilteringdualstack_test import ( "context" + "strings" "testing" aftpf "github.com/openconfig/featureprofiles/internal/aft_prefix_filtering" @@ -103,6 +104,30 @@ func configurePolicies(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatc batch.Set(t, dut) } +// ciscoDualStackNextHopsMatch is used only by the Cisco collector. Resolution +// must produce at least one NH object, including for testbed-provided defaults. +// Default NH addresses are deliberately unconstrained (including interface NHs +// with an unspecified address). Every other prefix retains exact ATE IP checks. +func ciscoDualStackNextHopsMatch(prefix string, nextHops []*aftcache.NextHop, wantIPv4, wantIPv6 string) bool { + if len(nextHops) == 0 { + return false + } + isDefault := prefix == defaultV4Route || prefix == defaultV6Route + want := wantIPv4 + if strings.Contains(prefix, ":") { + want = wantIPv6 + } + for _, nextHop := range nextHops { + if nextHop == nil { + return false + } + if !isDefault && nextHop.IP != want { + return false + } + } + return true +} + // testSimultaneousDualStackPolicy implements AFT-6.2.1. func testSimultaneousDualStackPolicy(t *testing.T, dut *ondatra.DUTDevice) { ctx, cancel := context.WithCancel(context.Background()) @@ -122,12 +147,22 @@ func testSimultaneousDualStackPolicy(t *testing.T, dut *ondatra.DUTDevice) { wantPrefixes[p] = true } collector := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) + stoppingCondition := aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, + map[string]bool{aftpf.ATEPort1.IPv4: true}, map[string]bool{aftpf.ATEPort1.IPv6: true}) + if dut.Vendor() == ondatra.CISCO { + // Default routes come from the testbed, not ConfigureBaseRoutes. Require + // their AFT entries and resolved NH objects, but do not assume ATE IPs. + // The five test-created matching prefixes retain exact ATE NH checks. + stoppingCondition = aftcache.InitialSyncStoppingConditionWithNextHopValidator(t, dut, wantPrefixes, + func(prefix string, nextHops []*aftcache.NextHop) (bool, error) { + return ciscoDualStackNextHopsMatch(prefix, nextHops, aftpf.ATEPort1.IPv4, aftpf.ATEPort1.IPv6), nil + }) + } aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, - Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, - map[string]bool{aftpf.ATEPort1.IPv4: true}, map[string]bool{aftpf.ATEPort1.IPv6: true}), - Timeout: aftpf.AFTSubscriptionWait, + Stop: stoppingCondition, + Timeout: aftpf.AFTSubscriptionWait, }, allMatch, nonMatchPrefixes) t.Logf("AFT-6.2.1 - Swap policies: IPv4 policy %s and IPv6 policy %s match nothing", policyPfxSetB, policyPfxSetA) @@ -137,14 +172,31 @@ func testSimultaneousDualStackPolicy(t *testing.T, dut *ondatra.DUTDevice) { VRFName: ni, }) + wantDeleted := map[string]bool{} + var presentAfterSwap, absentAfterSwap []string + for _, prefix := range allMatch { + // Cisco-specific: AFT prefixes covering IP next-hop addresses are + // implicitly included and therefore made visible. The two + // default routes cover all addresses in their respective families, + // so require them to remain present after the swap. Only the five + // test-created matching routes are expected to receive deletions. + if dut.Vendor() == ondatra.CISCO && (prefix == defaultV4Route || prefix == defaultV6Route) { + presentAfterSwap = append(presentAfterSwap, prefix) + continue + } + wantDeleted[prefix] = true + absentAfterSwap = append(absentAfterSwap, prefix) + } + t.Logf("AFT-6.2.1 - After policy swap: expect present=%v absent=%v", presentAfterSwap, absentAfterSwap) + // Reuse the same streaming session so the policy swap is observed as // streamed deletions rather than a fresh re-subscription. aftpf.CollectAndVerify(t, dut, aftpf.RunCollectorParams{ Ctx: context.Background(), Collector: collector, - Stop: aftcache.DeletionStoppingCondition(t, dut, wantPrefixes), + Stop: aftcache.DeletionStoppingCondition(t, dut, wantDeleted), Timeout: aftpf.AFTSubscriptionWait, - }, nil, allMatch) + }, presentAfterSwap, absentAfterSwap) if err := aftpf.AFTDeleteGlobalFilter(t, dut, ni); err != nil { t.Errorf("Cleanup: failed to delete global-filter: %v", err) diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dualstack/metadata.textproto b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dualstack/metadata.textproto index e1e732bd20d..685fb38aaf6 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dualstack/metadata.textproto +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dualstack/metadata.textproto @@ -18,3 +18,12 @@ platform_exceptions: { link_local_instead_of_nh: true } } + +platform_exceptions: { + platform: { + vendor: CISCO + } + deviations: { + ipv4_missing_enabled: true + } +} diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dynamic/afts_prefix_filtering_dynamic_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dynamic/afts_prefix_filtering_dynamic_test.go index bb3da231a43..cf84716491e 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dynamic/afts_prefix_filtering_dynamic_test.go +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dynamic/afts_prefix_filtering_dynamic_test.go @@ -12,6 +12,12 @@ package afts_prefix_filtering_dynamic_test import ( "context" + "fmt" + "net" + "net/netip" + "sort" + "strconv" + "strings" "testing" "time" @@ -21,6 +27,7 @@ import ( "github.com/openconfig/featureprofiles/internal/cfgplugins" "github.com/openconfig/featureprofiles/internal/deviations" "github.com/openconfig/featureprofiles/internal/fptest" + "github.com/openconfig/featureprofiles/internal/helpers" "github.com/openconfig/featureprofiles/internal/telemetry/aftcache" "github.com/openconfig/ondatra" "github.com/openconfig/ondatra/gnmi" @@ -29,36 +36,33 @@ import ( ) const ( - vrfName = "VRF-A" - v4PfxSet = "PREFIX-SET-A" - v6PfxSet = "PREFIX-SET-B" - v4Policy = "POLICY-PREFIX-SET-A" - v6Policy = "POLICY-PREFIX-SET-B" - matchAllPolicy = "POLICY-MATCH-ALL" - subscriptionWait = 5 * time.Minute - prefixAFT1V4 = "198.51.100.0/24" - prefixAFT2V4 = "203.0.113.0/28" - prefixAFT3V4 = "192.0.2.0/24" - prefixAFT1V6 = "2001:db8:2::/64" - prefixAFT2V6 = "2001:db8:2::1/128" - prefixAFT3V6 = "2001:db8:2::2/128" - vrfV4Pfx = "100.64.1.0/24" - vrfV6Pfx = "2001:db8:3::/64" - vrfRouteV4Pfx = "90.0.0.1" - vrfRouteV6Pfx = "4000::1" - maskRange = "exact" - notificationWaitTime = subscriptionWait - staticRouteIndex = 100 - pfxCount = 1 - aftFilterDUTAS = 65001 - vrfRoutes = 5000 + vrfName = "VRF-A" + v4PfxSet = "PREFIX-SET-A" + v6PfxSet = "PREFIX-SET-B" + v4Policy = "POLICY-PREFIX-SET-A" + v6Policy = "POLICY-PREFIX-SET-B" + matchAllPolicy = "POLICY-MATCH-ALL" + subscriptionWait = 5 * time.Minute + prefixAFT1V4 = "198.51.100.0/24" + prefixAFT2V4 = "203.0.113.0/28" + prefixAFT3V4 = "192.0.2.0/24" + prefixAFT3V4Cisco = "198.51.101.0/24" + prefixAFT1V6 = "2001:db8:2::/64" + prefixAFT2V6 = "2001:db8:2::1/128" + prefixAFT3V6 = "2001:db8:2::2/128" + vrfV4Pfx = "100.64.1.0/24" + vrfV6Pfx = "2001:db8:3::/64" + vrfRouteV4Pfx = "90.0.0.1" + vrfRouteV6Pfx = "4000::1" + maskRange = "exact" + notificationWaitTime = 30 * time.Second + notificationCheckInterval = 5 * time.Second + staticRouteIndex = 100 + pfxCount = 1 + aftFilterDUTAS = 65001 + vrfRoutes = 5000 ) -// notificationCollectorTimeout extends past the next two-minute periodic -// hook after subscriptionWait, so a missing notification produces the -// WaitForNotification diagnostic before the collector context expires. -const notificationCollectorTimeout = subscriptionWait + 90*time.Second - var ( dutPort1 = attrs.Attributes{ Desc: "DUT to ATE Port 1", @@ -143,6 +147,19 @@ type dynamicUpdateTestParams struct { isIPv6 bool } +func dynamicIPv4Prefix(dut *ondatra.DUTDevice) string { + if dut.Vendor() == ondatra.CISCO { + // Cisco-specific: prefixes covering IP next-hop addresses remain + // visible implicitly even when not specified by the AFT + // global-filter policy. 192.0.2.0/24 covers the ATE next hop + // 192.0.2.2, so use a different prefix such that adding it to the + // prefix set causes a visibility change. + // Route setup and the dynamic policy checks must use the same prefix. + return prefixAFT3V4Cisco + } + return prefixAFT3V4 +} + // TestMain runs featureprofile tests. func TestMain(m *testing.M) { fptest.RunTests(m) @@ -153,9 +170,14 @@ func TestAFTPrefixFilteringDynamicUpdates(t *testing.T) { dut := ondatra.DUT(t, "dut") ate := ondatra.ATE(t, "ate") batch := configureDUT(t, dut) - configurePolicies(t, dut, batch) + v4Prefixes := append([]string(nil), defaultIPv4Prefixes...) + for i, prefix := range v4Prefixes { + if prefix == prefixAFT3V4 { + v4Prefixes[i] = dynamicIPv4Prefix(dut) + } + } aftpf.ConfigureNetworkInstanceStaticRoute(t, dut, batch, aftpf.NetworkInstanceStaticRouteParams{ - DefaultPrefixes: defaultIPv4Prefixes, + DefaultPrefixes: v4Prefixes, VRFPrefixes: vrfV4Prefixes, DefaultNextHop: atePort1.IPv4, VRFNextHop: atePort2.IPv4, @@ -209,12 +231,14 @@ func TestAFTPrefixFilteringDynamicUpdates(t *testing.T) { } } -// configureDUT configures the DUT with the necessary VRF, interfaces, BGP, and redistribution policies. -func configureDUT(t *testing.T, dut *ondatra.DUTDevice) *gnmi.SetBatch { +// configureOpenConfigDUT preserves the original non-Cisco configuration +// sequence, with policies installed before BGP attaches their references. +func configureOpenConfigDUT(t *testing.T, dut *ondatra.DUTDevice) *gnmi.SetBatch { t.Helper() batch := &gnmi.SetBatch{} fptest.ConfigureDefaultNetworkInstance(t, dut) configureHardwareInit(t, dut) + installRoutingPolicies(t, dut) p1 := dut.Port(t, "port1") p2 := dut.Port(t, "port2") configureDUTInterface(t, dut, batch, &dutPort1, p1) @@ -231,6 +255,225 @@ func configureDUT(t *testing.T, dut *ondatra.DUTDevice) *gnmi.SetBatch { return batch } +func configureDUTPort(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch, attrs *attrs.Attributes, p *ondatra.Port, niName string) { + t.Helper() + ocPath := gnmi.OC() + cfgplugins.AssignToNetworkInstance(t, dut, p.Name(), niName, 0) + i := attrs.NewOCInterface(p.Name(), dut) + gnmi.BatchUpdate(batch, ocPath.Interface(p.Name()).Config(), i) +} + +// configureDUT selects the original setup sequence or Cisco's XR prerequisites. +func configureDUT(t *testing.T, dut *ondatra.DUTDevice) *gnmi.SetBatch { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return configureOpenConfigDUT(t, dut) + } + fptest.ConfigureDefaultNetworkInstance(t, dut) + configureHardwareInit(t, dut) + installRoutingPolicies(t, dut) + + // IOS XR needs the VRF address families before BGP can configure its + // address families and neighbors in this network instance. + nonDefaultNI := cfgplugins.ConfigureNetworkInstance(t, dut, vrfName, false) + cfgplugins.UpdateNetworkInstanceOnDut(t, dut, vrfName, nonDefaultNI) + if dut.Vendor() == ondatra.CISCO { + helpers.GnmiCLIConfig(t, dut, + "vrf "+vrfName+"\n address-family ipv4 unicast\n address-family ipv6 unicast\n!\n") + } + verifyVRFAddressFamilies(t, dut) + + p1 := dut.Port(t, "port1") + p2 := dut.Port(t, "port2") + configureDUTInterfaceBase(t, dut, p1) + configureDUTInterfaceBase(t, dut, p2) + // Cisco's unassigned port 1 is already in DEFAULT; explicitly assigning + // the reserved routing-table name is rejected by XR. + cfgplugins.AssignToNetworkInstance(t, dut, p2.Name(), vrfName, 0) + verifyVRFAddressFamilies(t, dut) + interfaceBatch := &gnmi.SetBatch{} + configureDUTInterface(t, dut, interfaceBatch, &dutPort1, p1) + configureDUTInterface(t, dut, interfaceBatch, &dutPort2, p2) + interfaceBatch.Set(t, dut) + + cfgplugins.EnableDefaultNetworkInstanceBgp(t, dut, aftFilterDUTAS) + defaultNI := cfgplugins.ConfigureNetworkInstance(t, dut, deviations.DefaultNetworkInstance(dut), true) + configureBGP(t, dut, defaultNI, nonDefaultNI) + configureBGPGlobal(t, dut, defaultNI) + initializeCiscoVRFBGPAddressFamilies(t, dut) + configureBGPGlobal(t, dut, nonDefaultNI) + configureBGPNeighbors(t, dut, defaultNI) + configureBGPNeighbors(t, dut, nonDefaultNI) + aftpf.ApplyBGPMaxPrefixes(t, dut, aftpf.BGPPrefixParams{V4Prefix: atePort1.IPv4, V6Prefix: atePort1.IPv6, NetworkInstance: defaultNI}) + return &gnmi.SetBatch{} +} + +// initializeCiscoVRFBGPAddressFamilies creates the global VPN parents and +// per-VRF BGP address families before OpenConfig updates the VRF's BGP protocol +// and neighbors. +func initializeCiscoVRFBGPAddressFamilies(t *testing.T, dut *ondatra.DUTDevice) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return + } + // IOS XR requires VPNv4/VPNv6 in the same BGP instance before enabling + // IPv4/IPv6 unicast within a BGP VRF. + t.Log("Configuring global BGP VPNv4 and VPNv6 parent address families in instance BGP") + helpers.GnmiCLIConfig(t, dut, fmt.Sprintf( + "router bgp %d instance BGP\n address-family vpnv4 unicast\n !\n address-family vpnv6 unicast\n !\n!\n", aftFilterDUTAS)) + config := readCiscoBGPInstanceConfig(t, dut) + for _, family := range []string{"vpnv4", "vpnv6"} { + if !strings.Contains(config, "\n address-family "+family+" unicast\n") { + t.Fatalf("BGP instance BGP is missing global %s unicast", family) + } + } + rd := fmt.Sprintf("%d:64", aftFilterDUTAS) + steps := []struct { + name string + cli string + wantVRFConfig []string + }{ + { + name: "BGP VRF context and route distinguisher", + cli: fmt.Sprintf("router bgp %d instance BGP\n vrf %s\n rd %s\n !\n!\n", aftFilterDUTAS, vrfName, rd), + wantVRFConfig: []string{" rd " + rd}, + }, + { + name: "IPv4 BGP VRF address family", + cli: fmt.Sprintf("router bgp %d instance BGP\n vrf %s\n address-family ipv4 unicast\n !\n !\n!\n", aftFilterDUTAS, vrfName), + wantVRFConfig: []string{" rd " + rd, " address-family ipv4 unicast"}, + }, + { + name: "IPv6 BGP VRF address family", + cli: fmt.Sprintf("router bgp %d instance BGP\n vrf %s\n address-family ipv6 unicast\n !\n !\n!\n", aftFilterDUTAS, vrfName), + wantVRFConfig: []string{" rd " + rd, " address-family ipv4 unicast", " address-family ipv6 unicast"}, + }, + } + for _, step := range steps { + t.Logf("Configuring %s in %s", step.name, vrfName) + helpers.GnmiCLIConfig(t, dut, step.cli) + verifyCiscoVRFBGPConfig(t, dut, step.wantVRFConfig...) + } +} + +func readCiscoBGPInstanceConfig(t *testing.T, dut *ondatra.DUTDevice) string { + t.Helper() + ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second) + defer cancel() + response, err := dut.RawAPIs().CLI(t).RunCommand(ctx, "show running-config router bgp") + if err != nil { + t.Fatalf("failed to read BGP running config: %v", err) + } + config := strings.ReplaceAll(response.Output(), "\r\n", "\n") + t.Logf("BGP running config while initializing VRF %s:\n%s", vrfName, config) + config = "\n" + config + instanceMarker := fmt.Sprintf("router bgp %d instance BGP\n", aftFilterDUTAS) + instanceIndex := strings.Index(config, "\n"+instanceMarker) + if instanceIndex < 0 { + t.Fatalf("BGP running config is missing %q", strings.TrimSpace(instanceMarker)) + } + instanceConfig := config[instanceIndex+1:] + if end := strings.Index(instanceConfig, "\nrouter bgp "); end >= 0 { + instanceConfig = instanceConfig[:end] + } + return instanceConfig +} + +func verifyCiscoVRFBGPConfig(t *testing.T, dut *ondatra.DUTDevice, wantLines ...string) { + t.Helper() + config := readCiscoBGPInstanceConfig(t, dut) + vrfMarker := " vrf " + vrfName + "\n" + vrfIndex := strings.Index(config, vrfMarker) + if vrfIndex < 0 { + t.Fatalf("BGP running config is missing VRF %s", vrfName) + } + vrfConfig := config[vrfIndex+len(vrfMarker):] + if end := strings.Index(vrfConfig, "\n !"); end >= 0 { + vrfConfig = vrfConfig[:end] + } + for _, want := range wantLines { + if !strings.Contains("\n"+vrfConfig+"\n", "\n"+want+"\n") { + t.Fatalf("BGP VRF %s running config is missing %q", vrfName, want) + } + } +} + +// verifyVRFAddressFamilies checks that both VRF address families are present +// on Cisco before configuring BGP under the VRF. +func verifyVRFAddressFamilies(t *testing.T, dut *ondatra.DUTDevice) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return + } + ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second) + defer cancel() + response, err := dut.RawAPIs().CLI(t).RunCommand(ctx, "show running-config vrf "+vrfName) + if err != nil { + t.Fatalf("failed to verify VRF %s address families in running config: %v", vrfName, err) + } + t.Logf("VRF %s running config:\n%s", vrfName, response.Output()) + if !strings.Contains(response.Output(), "vrf "+vrfName) { + t.Fatalf("VRF %s is missing from the running config", vrfName) + } + for _, want := range []string{"address-family ipv4 unicast", "address-family ipv6 unicast"} { + if !strings.Contains(response.Output(), want) { + t.Fatalf("VRF %s running config is missing %q", vrfName, want) + } + } +} + +// configureBGPGlobal commits the protocol's global address families before +// any neighbors are configured in either network instance. +func configureBGPGlobal(t *testing.T, dut *ondatra.DUTDevice, ni *oc.NetworkInstance) { + t.Helper() + const bgpName = "BGP" + proto := ni.GetOrCreateProtocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, bgpName) + bgp := proto.GetOrCreateBgp() + globalOnly := &oc.NetworkInstance_Protocol{ + Identifier: oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, + Name: ygot.String(bgpName), + Enabled: ygot.Bool(true), + Bgp: &oc.NetworkInstance_Protocol_Bgp{Global: bgp.GetOrCreateGlobal()}, + } + path := gnmi.OC().NetworkInstance(ni.GetName()).Protocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, bgpName) + t.Logf("Configuring BGP global address families in %s before neighbors", ni.GetName()) + gnmi.Update(t, dut, path.Config(), globalOnly) +} + +// configureBGPNeighbors commits each neighbor and its AF-specific policies +// after the global BGP address families exist on the DUT. +func configureBGPNeighbors(t *testing.T, dut *ondatra.DUTDevice, ni *oc.NetworkInstance) { + t.Helper() + const bgpName = "BGP" + bgp := ni.GetOrCreateProtocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, bgpName).GetOrCreateBgp() + path := gnmi.OC().NetworkInstance(ni.GetName()).Protocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, bgpName) + var neighbors []string + for addr := range bgp.Neighbor { + neighbors = append(neighbors, addr) + } + sort.Strings(neighbors) + for _, addr := range neighbors { + t.Logf("Configuring BGP neighbor %s in %s", addr, ni.GetName()) + gnmi.Update(t, dut, path.Bgp().Neighbor(addr).Config(), bgp.Neighbor[addr]) + } +} + +// configureDUTInterfaceBase creates the interface and subinterface before +// attaching them to a network instance; IP addresses are added afterward. +func configureDUTInterfaceBase(t *testing.T, dut *ondatra.DUTDevice, p *ondatra.Port) { + t.Helper() + i := &oc.Interface{ + Name: ygot.String(p.Name()), + Type: oc.IETFInterfaces_InterfaceType_ethernetCsmacd, + } + if deviations.InterfaceEnabled(dut) { + i.Enabled = ygot.Bool(true) + } + i.GetOrCreateEthernet() + i.GetOrCreateSubinterface(0) + gnmi.Update(t, dut, gnmi.OC().Interface(p.Name()).Config(), i) +} + // configureDUTInterface configure interfaces on DUT. func configureDUTInterface(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch, attrs *attrs.Attributes, p *ondatra.Port) { t.Helper() @@ -243,7 +486,9 @@ func configureDUTInterface(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.Set } i.GetOrCreateEthernet() i4 := i.GetOrCreateSubinterface(0).GetOrCreateIpv4() - i4.Enabled = ygot.Bool(true) + if dut.Vendor() != ondatra.CISCO || (deviations.InterfaceEnabled(dut) && !deviations.IPv4MissingEnabled(dut)) { + i4.Enabled = ygot.Bool(true) + } av4 := i4.GetOrCreateAddress(attrs.IPv4) av4.PrefixLength = ygot.Uint8(attrs.IPv4Len) i6 := i.GetOrCreateSubinterface(0).GetOrCreateIpv6() @@ -253,15 +498,6 @@ func configureDUTInterface(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.Set gnmi.BatchUpdate(batch, ocPath.Interface(p.Name()).Config(), i) } -// configureDUTPort configure DUT ports. -func configureDUTPort(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch, attrs *attrs.Attributes, p *ondatra.Port, niName string) { - t.Helper() - ocPath := gnmi.OC() - cfgplugins.AssignToNetworkInstance(t, dut, p.Name(), niName, 0) - i := attrs.NewOCInterface(p.Name(), dut) - gnmi.BatchUpdate(batch, ocPath.Interface(p.Name()).Config(), i) -} - // configureHardwareInit sets up the initial hardware configuration on the DUT. // It pushes hardware initialization configurations for the VRF Selection Extended // and Policy Forwarding features. @@ -354,7 +590,7 @@ func testIPv4DynamicUpdates(t *testing.T, dut *ondatra.DUTDevice) { testID: "AFT-6.4.1", prefixSet: v4PfxSet, initialAllowedPrefixes: []string{prefixAFT1V4, prefixAFT2V4}, - dynamicPrefix: prefixAFT3V4, + dynamicPrefix: dynamicIPv4Prefix(dut), nhIP: atePort1.IPv4, maskRange: maskRange, policyName: v4Policy, @@ -387,6 +623,171 @@ func testIPv6DynamicUpdates(t *testing.T, dut *ondatra.DUTDevice) { ) } +// ciscoIPv6NeighborMatches requires the address, interface and MAC in the same +// native neighbor record. The record can be wrapped, and XR may abbreviate +// FourHundredGigE as FH. Multicast adjacency rows must not be joined to it. +func ciscoIPv6NeighborMatches(t *testing.T, output, intf string, address netip.Addr, wantMAC net.HardwareAddr) (bool, error) { + t.Helper() + interfaceNames := map[string]bool{intf: true, intf + ".0": true} + if strings.HasPrefix(intf, "FourHundredGigE") { + shortName := "FH" + strings.TrimPrefix(intf, "FourHundredGigE") + interfaceNames[shortName] = true + interfaceNames[shortName+".0"] = true + } + var records [][]string + pending := -1 + complete := func(fields []string) bool { + hasMAC, hasInterface := false, false + for _, field := range fields { + if mac, err := net.ParseMAC(field); err == nil && len(mac) == 6 { + hasMAC = true + } + if strings.Contains(field, "/") && !strings.Contains(field, ":") { + hasInterface = hasInterface || (field[0] >= 'A' && field[0] <= 'Z') || (field[0] >= 'a' && field[0] <= 'z') + } + } + return hasMAC && hasInterface + } + for _, line := range strings.Split(output, "\n") { + fields := strings.Fields(line) + if len(fields) == 0 { + pending = -1 + continue + } + if ip, err := netip.ParseAddr(fields[0]); err == nil && ip.Is6() { + records = append(records, fields) + pending = len(records) - 1 + } else { + // Only a partial neighbor record may consume a continuation line. + _, ageErr := strconv.ParseUint(fields[0], 10, 64) + mac, macErr := net.ParseMAC(fields[0]) + continuation := ageErr == nil || fields[0] == "-" || (macErr == nil && len(mac) == 6) || interfaceNames[fields[0]] + if pending < 0 || !continuation { + pending = -1 + continue + } + records[pending] = append(records[pending], fields...) + } + if pending >= 0 && complete(records[pending]) { + pending = -1 + } + } + matched := false + for _, record := range records { + ip, err := netip.ParseAddr(record[0]) + if err != nil || ip.WithZone("") != address { + continue + } + correctInterface := false + var macs []net.HardwareAddr + for _, field := range record[1:] { + if interfaceNames[field] { + correctInterface = true + } + if mac, err := net.ParseMAC(field); err == nil && len(mac) == 6 { + macs = append(macs, mac) + } + } + if !correctInterface { + continue + } + t.Logf("IPv6 neighbor validation selected record: address=%s interface=%s fields=%v", address, intf, record) + if len(macs) == 0 { + return false, fmt.Errorf("neighbor %s on %s has no resolved MAC: %v", address, intf, record) + } + for _, mac := range macs { + if !strings.EqualFold(mac.String(), wantMAC.String()) { + return false, fmt.Errorf("neighbor %s on %s has MAC %s, want %s", address, intf, mac, wantMAC) + } + } + matched = true + } + if !matched { + return false, fmt.Errorf("no native neighbor record for %s with MAC %s on %s", address, wantMAC, intf) + } + return true, nil +} + +// verifiedCiscoDefaultPeer checks the exact port-1 peer for both address +// families. IOS XR may expose the IPv6 forwarding next hop as the peer's +// link-local address rather than its configured global address. We accept that +// equivalent only after native ND confirms its address, MAC, and interface. +func verifiedCiscoDefaultPeer(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, needIPv6 bool) func(string, []*aftcache.NextHop) (bool, error) { + t.Helper() + intf := dut.Port(t, "port1").Name() + wantIPv4 := netip.MustParseAddr(atePort1.IPv4) + wantIPv6 := netip.MustParseAddr(atePort1.IPv6) + var linkLocal netip.Addr + verified := false + verificationDetail := "IPv6 neighbor was not checked" + if needIPv6 { + mac, err := net.ParseMAC(atePort1.MAC) + if err != nil || len(mac) != 6 { + t.Fatalf("ATE port1 must have a 48-bit MAC, got %q (%v)", atePort1.MAC, err) + } + address := [16]byte{0xfe, 0x80} + copy(address[8:], []byte{mac[0] ^ 0x02, mac[1], mac[2], 0xff, 0xfe, mac[3], mac[4], mac[5]}) + linkLocal = netip.AddrFrom16(address) + cliCtx, cancel := context.WithDeadline(ctx, time.Now().Add(20*time.Second)) + neighbors, err := dut.RawAPIs().CLI(t).RunCommand(cliCtx, "show ipv6 neighbors") + cancel() + if err != nil { + verificationDetail = fmt.Sprintf("native ND lookup failed: %v", err) + } else { + verified, err = ciscoIPv6NeighborMatches(t, neighbors.Output(), intf, linkLocal, mac) + verificationDetail = fmt.Sprintf("native ND verified=%t, detail=%v", verified, err) + } + t.Logf("Cisco IPv6 peer identity: interface=%s global=%s candidate link-local=%s expected MAC=%s %s", intf, wantIPv6, linkLocal, mac, verificationDetail) + } + return func(prefix string, nextHops []*aftcache.NextHop) (bool, error) { + if len(nextHops) == 0 { + return false, nil + } + ipv6 := strings.Contains(prefix, ":") + for _, nextHop := range nextHops { + if nextHop == nil || nextHop.IP == "" { + return false, nil + } + ip, err := netip.ParseAddr(nextHop.IP) + if err != nil { + return false, fmt.Errorf("invalid next-hop address %q: %w", nextHop.IP, err) + } + ip = ip.WithZone("") + correctInterface := nextHop.IntfName == "" || nextHop.IntfName == intf || nextHop.IntfName == intf+".0" + if !correctInterface { + return false, nil + } + if !ipv6 && ip != wantIPv4 { + return false, nil + } + if ipv6 { + if ip == linkLocal && !verified { + return false, fmt.Errorf("cannot verify IPv6 next hop %s on %s for %s: %s", ip, intf, prefix, verificationDetail) + } + if ip != wantIPv6 && (ip != linkLocal || !verified || nextHop.IntfName == "") { + return false, nil + } + } + } + return true, nil + } +} + +// awaitDynamicNotification checks only notifications received after this +// mutation's checkpoint. The short polling interval makes the 30-second +// notification deadline meaningful without changing the shared cache default. +func awaitDynamicNotification(ctx context.Context, t *testing.T, collector *aftcache.AFTStreamSession, since int, addPrefix, deletePrefix string) { + t.Helper() + t.Logf("Waiting for same-stream AFT update=%q delete=%q after notification index %d", addPrefix, deletePrefix, since) + aftpf.RunCollector(t, aftpf.RunCollectorParams{ + Ctx: ctx, + Collector: collector, + Stop: aftcache.WaitForNotification(t, aftcache.NotificationExpectation{AddPrefix: addPrefix, DeletePrefix: deletePrefix, NotificationWait: notificationWaitTime, SinceIndex: since}), + Timeout: notificationWaitTime, + CheckInterval: notificationCheckInterval, + }) +} + // testDynamicUpdates validates dynamic AFT prefix filtering behavior for both IPv4 and IPv6 route policies. func testDynamicUpdates(t *testing.T, dut *ondatra.DUTDevice, pArgs dynamicUpdateTestParams) { t.Helper() @@ -401,6 +802,7 @@ func testDynamicUpdates(t *testing.T, dut *ondatra.DUTDevice, pArgs dynamicUpdat policyCfg.V4Policy = pArgs.policyName } aftpf.ConfigureGlobalFilterPolicies(t, dut, policyCfg) + verifyDynamicPolicyMatch(t, dut, pArgs.policyName, pArgs.prefixSet) if pArgs.isIPv6 { wantPrefixes = aftpf.GeneratePrefixes(t, aftpf.GeneratePrefixesParams{ @@ -426,19 +828,25 @@ func testDynamicUpdates(t *testing.T, dut *ondatra.DUTDevice, pArgs dynamicUpdat Context: ctx, Client: gnmiClient, }) + // The dynamic cases compare notification epochs on this same stream. + // Keep the raw notifications even if the optional debug flag is disabled. + collector.WithDebug() //---------------------------------------------------------------------- // Initial Sync //---------------------------------------------------------------------- t.Logf("%s - Initial Synchronization", pArgs.testID) + initialStop := aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, + map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}) + if dut.Vendor() == ondatra.CISCO { + initialStop = aftcache.InitialSyncStoppingConditionWithNextHopValidator(t, dut, wantPrefixes, + verifiedCiscoDefaultPeer(ctx, t, dut, pArgs.isIPv6)) + } aftpf.RunCollector(t, aftpf.RunCollectorParams{ Ctx: ctx, Collector: collector, - Stop: aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, - map[string]bool{atePort1.IPv4: true}, - map[string]bool{atePort1.IPv6: true}, - ), - Timeout: subscriptionWait, + Stop: initialStop, + Timeout: subscriptionWait, }) initialAFT, err := collector.ToAFT(t, dut) if err != nil { @@ -449,32 +857,28 @@ func testDynamicUpdates(t *testing.T, dut *ondatra.DUTDevice, pArgs dynamicUpdat InfoAFT: initialAFT, Prefixes: pArgs.initialAllowedPrefixes, }) + // The route must be hidden before changing the prefix set; otherwise an + // unrelated notification could make the add stage appear to pass. + aftpf.VerifyPrefixesAbsent(t, aftpf.PrefixesParams{InfoAFT: initialAFT, Prefixes: []string{pArgs.dynamicPrefix}}) //---------------------------------------------------------------------- // AFT-6.4.X.1 Add Prefix //---------------------------------------------------------------------- t.Logf("%s.1 - Addition of Prefix to Active Set", pArgs.testID) + beforeAdd := len(collector.Notifications()) aftpf.AddPrefixToPrefixSet(t, dut, aftpf.AddPrefixToPrefixSetParams{ PrefixSetName: pArgs.prefixSet, Prefix: pArgs.dynamicPrefix, MaskRange: pArgs.maskRange, }) + verifyDynamicPolicyMatch(t, dut, pArgs.policyName, pArgs.prefixSet) // Wait for ADD notification on the SAME stream. - aftpf.RunCollector(t, - aftpf.RunCollectorParams{ - Ctx: ctx, - Collector: collector, - Stop: aftcache.WaitForNotification(t, - aftcache.NotificationExpectation{ - AddPrefix: pArgs.dynamicPrefix, - NotificationWait: notificationWaitTime, - }), - Timeout: notificationCollectorTimeout, - }) + awaitDynamicNotification(ctx, t, collector, beforeAdd, pArgs.dynamicPrefix, "") //---------------------------------------------------------------------- // AFT-6.4.X.2 Delete Prefix //---------------------------------------------------------------------- t.Logf("%s.2 - Deletion of Prefix from Active Set", pArgs.testID) + beforeDelete := len(collector.Notifications()) aftpf.RemovePrefixFromPrefixSet(t, dut, aftpf.RemovePrefixFromPrefixSetParams{ PrefixSetName: pArgs.prefixSet, @@ -482,38 +886,20 @@ func testDynamicUpdates(t *testing.T, dut *ondatra.DUTDevice, pArgs dynamicUpdat MaskRange: pArgs.maskRange, }, ) - verifyPrefixRemovedFromPrefixSet(t, dut, pArgs.prefixSet, pArgs.initialAllowedPrefixes[0], pArgs.maskRange) + verifyDynamicPolicyMatch(t, dut, pArgs.policyName, pArgs.prefixSet) // Wait for DELETE notification on SAME stream. - aftpf.RunCollector(t, - aftpf.RunCollectorParams{ - Ctx: ctx, - Collector: collector, - Stop: aftcache.WaitForNotification(t, - aftcache.NotificationExpectation{ - DeletePrefix: pArgs.initialAllowedPrefixes[0], - NotificationWait: notificationWaitTime, - }), - Timeout: notificationCollectorTimeout, - }) + awaitDynamicNotification(ctx, t, collector, beforeDelete, "", pArgs.initialAllowedPrefixes[0]) + verifyPrefixRemovedFromPrefixSet(t, dut, pArgs.prefixSet, pArgs.initialAllowedPrefixes[0], pArgs.maskRange) //---------------------------------------------------------------------- // AFT-6.4.X.3 Atomic Add/Delete //---------------------------------------------------------------------- t.Logf("%s.3 - Simultaneous Addition and Deletion", pArgs.testID) + beforeSwap := len(collector.Notifications()) atomicPrefixSetSwap(t, dut, pArgs.prefixSet, pArgs.initialAllowedPrefixes[0], pArgs.initialAllowedPrefixes[1], pArgs.maskRange) - verifyPrefixRemovedFromPrefixSet(t, dut, pArgs.prefixSet, pArgs.initialAllowedPrefixes[1], pArgs.maskRange) + verifyDynamicPolicyMatch(t, dut, pArgs.policyName, pArgs.prefixSet) // Wait for BOTH notifications on SAME stream. - aftpf.RunCollector(t, - aftpf.RunCollectorParams{ - Ctx: ctx, - Collector: collector, - Stop: aftcache.WaitForNotification(t, - aftcache.NotificationExpectation{ - AddPrefix: pArgs.initialAllowedPrefixes[0], - DeletePrefix: pArgs.initialAllowedPrefixes[1], - NotificationWait: notificationWaitTime, - }), - Timeout: notificationCollectorTimeout, - }) + awaitDynamicNotification(ctx, t, collector, beforeSwap, pArgs.initialAllowedPrefixes[0], pArgs.initialAllowedPrefixes[1]) + verifyPrefixRemovedFromPrefixSet(t, dut, pArgs.prefixSet, pArgs.initialAllowedPrefixes[1], pArgs.maskRange) //---------------------------------------------------------------------- // Final verification //---------------------------------------------------------------------- @@ -528,17 +914,36 @@ func testDynamicUpdates(t *testing.T, dut *ondatra.DUTDevice, pArgs dynamicUpdat // verifyPrefixRemovedFromPrefixSet verifies that the specified prefix no longer exists in the given prefix-set configuration. func verifyPrefixRemovedFromPrefixSet(t *testing.T, dut *ondatra.DUTDevice, prefixSetName, prefix, maskRange string) { t.Helper() - path := gnmi.OC().RoutingPolicy().DefinedSets().PrefixSet(prefixSetName).Prefix(prefix, maskRange).Config() - if val, present := gnmi.Lookup(t, dut, path).Val(); present { - t.Fatalf("Prefix %s mask-range %s still exists in prefix-set %s: %+v", prefix, maskRange, prefixSetName, val) + set := gnmi.Get[*oc.RoutingPolicy_DefinedSets_PrefixSet](t, dut, + gnmi.OC().RoutingPolicy().DefinedSets().PrefixSet(prefixSetName).Config()) + if entry := set.GetPrefix(prefix, maskRange); entry != nil { + t.Fatalf("Prefix %s mask-range %s still exists in prefix-set %s: %+v", prefix, maskRange, prefixSetName, entry) } t.Logf("Verified prefix %s mask-range %s removed from prefix-set %s", prefix, maskRange, prefixSetName) } +func verifyDynamicPolicyMatch(t *testing.T, dut *ondatra.DUTDevice, policyName, prefixSetName string) { + t.Helper() + policy := gnmi.Get[*oc.RoutingPolicy_PolicyDefinition](t, dut, + gnmi.OC().RoutingPolicy().PolicyDefinition(policyName).Config()) + got := policy.GetStatement("10").GetConditions().GetMatchPrefixSet().GetPrefixSet() + t.Logf("Dynamic AFT filter policy readback: policy=%s statement=10 match-prefix-set=%q, want %q", policyName, got, prefixSetName) + if got != prefixSetName { + t.Fatalf("Dynamic AFT filter policy %s does not match prefix-set %s (got %q)", policyName, prefixSetName, got) + } +} + // atomicPrefixSetSwap atomically updates a prefix set. -// It adds one prefix and removes another using a single gNMI Set transaction. +// Replacing the complete set adds one prefix and removes another in one Set. func atomicPrefixSetSwap(t *testing.T, dut *ondatra.DUTDevice, prefixName, addPrefixVal, delPrefixVal, prefixMode string) { t.Helper() + if dut.Vendor() == ondatra.CISCO { + // XR cannot change entries within the native prefix-set bag. + aftpf.ReplacePrefixSetMembers(t, dut, prefixName, + []aftpf.PrefixSetMember{{Prefix: addPrefixVal, MaskRange: prefixMode}}, + []aftpf.PrefixSetMember{{Prefix: delPrefixVal, MaskRange: prefixMode}}) + return + } batch := &gnmi.SetBatch{} addPath := gnmi.OC().RoutingPolicy().DefinedSets().PrefixSet(prefixName).Prefix(addPrefixVal, prefixMode) addEntry := &oc.RoutingPolicy_DefinedSets_PrefixSet_Prefix{ @@ -551,16 +956,16 @@ func atomicPrefixSetSwap(t *testing.T, dut *ondatra.DUTDevice, prefixName, addPr batch.Set(t, dut) } -// configurePolicies configures all routing policies required for AFT prefix -// filtering tests and installs them on the DUT using the provided gNMI batch. -func configurePolicies(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch) { +// installRoutingPolicies installs the routing policies before BGP references them. +func installRoutingPolicies(t *testing.T, dut *ondatra.DUTDevice) { t.Helper() root := &oc.Root{} rp := root.GetOrCreateRoutingPolicy() configureCommonPolicies(t, rp) configureDynamicUpdatePolicies(t, rp) - gnmi.BatchReplace(batch, gnmi.OC().RoutingPolicy().Config(), rp) - batch.Set(t, dut) + policyBatch := &gnmi.SetBatch{} + gnmi.BatchReplace(policyBatch, gnmi.OC().RoutingPolicy().Config(), rp) + policyBatch.Set(t, dut) } // configureDynamicUpdatePolicies configures IPv4 and IPv6 routing policies @@ -573,10 +978,9 @@ func configureDynamicUpdatePolicies(t *testing.T, rp *oc.RoutingPolicy) { PolicyName: v4Policy, StatementNames: []string{"10"}, PrefixSetNames: []string{v4PfxSet}, + MatchPrefixSet: true, PrefixList: policyIPv4Prefixes, PrefixMode: maskRange, - MatchPrefixSet: true, - MatchSetOption: oc.RoutingPolicy_MatchSetOptionsRestrictedType_ANY, PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, }) // IPv6 dynamic prefix filtering policy. @@ -585,10 +989,9 @@ func configureDynamicUpdatePolicies(t *testing.T, rp *oc.RoutingPolicy) { PolicyName: v6Policy, StatementNames: []string{"10"}, PrefixSetNames: []string{v6PfxSet}, + MatchPrefixSet: true, PrefixList: policyIPv6Prefixes, PrefixMode: maskRange, - MatchPrefixSet: true, - MatchSetOption: oc.RoutingPolicy_MatchSetOptionsRestrictedType_ANY, PolicyResult: oc.RoutingPolicy_PolicyResultType_ACCEPT_ROUTE, }) } diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dynamic/metadata.textproto b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dynamic/metadata.textproto index e6c04dcb4eb..32bc00467b2 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dynamic/metadata.textproto +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_dynamic/metadata.textproto @@ -5,6 +5,7 @@ uuid: "82a0e32f-4f79-43dc-a2f3-da48275c539e" plan_id: "AFT-6.4" description: "AFT Prefix Filtering Dynamic Updates" testbed: TESTBED_DUT_ATE_2LINKS + platform_exceptions: { platform: { vendor: ARISTA @@ -16,3 +17,12 @@ platform_exceptions: { bgp_missing_oc_max_prefixes_configuration: true } } + +platform_exceptions: { + platform: { + vendor: CISCO + } + deviations: { + ipv4_missing_enabled: true + } +} diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/aft_diagnostics_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/aft_diagnostics_test.go new file mode 100644 index 00000000000..178ecfc7dd0 --- /dev/null +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/aft_diagnostics_test.go @@ -0,0 +1,401 @@ +// Copyright 2026 Google LLC +// +// 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 afts_prefix_filtering_resilience_test + +import ( + "context" + "encoding/json" + "fmt" + "io" + "sort" + "strconv" + "strings" + "testing" + "time" + + aftpf "github.com/openconfig/featureprofiles/internal/aft_prefix_filtering" + "github.com/openconfig/featureprofiles/internal/deviations" + "github.com/openconfig/featureprofiles/internal/telemetry/aftcache" + gpb "github.com/openconfig/gnmi/proto/gnmi" + "github.com/openconfig/ondatra" + "github.com/openconfig/testt" + "google.golang.org/grpc" + "google.golang.org/grpc/status" +) + +// This client belongs to this test run, not aftpf's package-wide sync.Once. +// The parent context outlives the reboot subtest and later policy subtests. +type resilienceFilterClient struct { + ctx context.Context + client gpb.GNMIClient + createdAt time.Time +} + +func (c *resilienceFilterClient) connect(t *testing.T, dut *ondatra.DUTDevice) { + t.Helper() + if c.client != nil { + t.Fatal("AFT filter client must be retired before reconnecting") + } + ctx, cancel := context.WithDeadline(c.ctx, time.Now().Add(20*time.Second)) + defer cancel() + client, err := dut.RawAPIs().BindingDUT().DialGNMI(ctx, grpc.WithBlock()) + if err != nil { + t.Fatalf("Failed to connect test-owned AFT filter client: %v", err) + } + c.client, c.createdAt = client, time.Now() + t.Logf("AFT test-owned filter client connected UTC=%s client=%p", c.createdAt.UTC().Format(time.RFC3339Nano), c.client) +} + +func (c *resilienceFilterClient) close(t *testing.T) { + t.Helper() + if c.client == nil { + return + } + if closer, ok := c.client.(io.Closer); ok { + if err := closer.Close(); err != nil { + t.Logf("AFT filter client close failed: %v", err) + } + } else { + // Binding clients commonly hide their grpc.ClientConn. Do not claim + // to close that transport, or reset shared state used by other callers. + t.Logf("AFT filter client %p exposes no io.Closer; retiring it from all subsequent filter Sets", c.client) + } + c.client = nil + c.createdAt = time.Time{} +} + +// Diagnostic commands and reads never replace the original failure, retry a +// failed Set, or supply values to the subscription cache. Independent deadlines +// allow evidence to be collected even after a collector's context expires. +func logAFTDiagnosticCLI(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, command string) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return + } + if failure := testt.CaptureFatal(t, func(tb testing.TB) { + readCtx, cancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) + defer cancel() + started := time.Now() + t.Logf("AFT diagnostic CLI start UTC=%s command=%q", started.UTC().Format(time.RFC3339Nano), command) + response, err := dut.RawAPIs().CLI(tb).RunCommand(readCtx, command) + if err != nil { + t.Logf("AFT diagnostic CLI command=%q elapsed=%v failed: %v", command, time.Since(started), err) + return + } + output := response.Output() + // Traces can be large. Preserve the newest evidence and report the + // truncation rather than flooding the console with entire trace rings. + const maxCLIBytes = 64 * 1024 + if len(output) > maxCLIBytes { + t.Logf("AFT diagnostic CLI command=%q output=%d bytes; logging last %d bytes", command, len(output), maxCLIBytes) + output = output[len(output)-maxCLIBytes:] + } + t.Logf("AFT diagnostic CLI end UTC=%s command=%q elapsed=%v:\n%s", time.Now().UTC().Format(time.RFC3339Nano), command, time.Since(started), output) + }); failure != nil { + t.Logf("AFT diagnostic CLI command=%q unavailable: %s", command, *failure) + } +} + +func newAFTDiagnosticClient(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice) (gpb.GNMIClient, func()) { + t.Helper() + var client gpb.GNMIClient + if failure := testt.CaptureFatal(t, func(tb testing.TB) { + dialCtx, cancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) + defer cancel() + var err error + client, err = dut.RawAPIs().BindingDUT().DialGNMI(dialCtx) + t.Logf("AFT diagnostic new DialGNMI UTC=%s client=%p error=%v (bypasses the shared filter client)", time.Now().UTC().Format(time.RFC3339Nano), client, err) + if err != nil { + client = nil + } + }); failure != nil { + t.Logf("AFT diagnostic DialGNMI unavailable: %s", *failure) + } + return client, func() { + if closer, ok := client.(io.Closer); ok { + if err := closer.Close(); err != nil { + t.Logf("AFT diagnostic client close failed: %v", err) + } + } else if client != nil { + t.Log("AFT diagnostic gNMI client does not expose io.Closer") + } + } +} + +func logAFTDiagnosticGet(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, client gpb.GNMIClient, path string) *gpb.GetResponse { + t.Helper() + return logAFTDiagnosticGetType(ctx, t, dut, client, path, gpb.GetRequest_ALL) +} + +func logAFTDiagnosticGetType(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, client gpb.GNMIClient, path string, dataType gpb.GetRequest_DataType) *gpb.GetResponse { + t.Helper() + if client == nil { + t.Logf("AFT diagnostic Get skipped: no client for %s", path) + return nil + } + readCtx, cancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) + defer cancel() + request := &gpb.GetRequest{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, + Path: []*gpb.Path{gnmiPath(t, path)}, Type: dataType, Encoding: aftpf.ConfigEncoding(dut), + } + started := time.Now() + response, err := client.Get(readCtx, request) + t.Logf("AFT diagnostic JSON_IETF Get UTC=%s path=%s elapsed=%v status=%s error=%v request=%v response=%v", + time.Now().UTC().Format(time.RFC3339Nano), path, time.Since(started), status.Code(err), err, request, response) + return response +} + +func configureGlobalFilterPoliciesWithDiagnostics(t *testing.T, dut *ondatra.DUTDevice, filterClient *resilienceFilterClient, cfg aftpf.ConfigureGlobalFilterPoliciesParams) { + t.Helper() + if filterClient.client == nil { + t.Fatal("No test-owned AFT filter client: DUT recovery/reconnection did not complete; refusing the cached pre-reboot client") + } + cfg.Client, cfg.ClientCreatedAt = filterClient.client, filterClient.createdAt + cfg.OnSetFailure = func(setErr error) { + ctx, cancel := context.WithDeadline(context.WithoutCancel(t.Context()), time.Now().Add(45*time.Second)) + defer cancel() + t.Logf("AFT filter Set failure diagnostics UTC=%s NI=%s expected IPv4=%q IPv6=%q original error=%v; no Set retry", + time.Now().UTC().Format(time.RFC3339Nano), cfg.VRFName, cfg.V4Policy, cfg.V6Policy, setErr) + logAFTDiagnosticCLI(ctx, t, dut, "show logging") + client, closeClient := newAFTDiagnosticClient(ctx, t, dut) + defer closeClient() + logAFTDiagnosticGet(ctx, t, dut, client, "/system/state/current-datetime") + // A lost response does not establish whether the Set was committed. + // Log config and state through the new client without modifying either. + logAFTDiagnosticGet(ctx, t, dut, client, fmt.Sprintf("/network-instances/network-instance[name=%s]/afts/global-filter", cfg.VRFName)) + } + aftpf.ConfigureGlobalFilterPolicies(t, dut, cfg) +} + +func logVRFNextHopDiagnostics(t *testing.T, dut *ondatra.DUTDevice, collector *aftcache.AFTStreamSession, prefix string) { + t.Helper() + ctx, cancel := context.WithDeadline(context.WithoutCancel(t.Context()), time.Now().Add(90*time.Second)) + defer cancel() + t.Logf("AFT VRF chain diagnostics UTC=%s NI=%s prefix=%s stream=%+v (CLIENT buffer, not DUT queue)", + time.Now().UTC().Format(time.RFC3339Nano), vrfName, prefix, collector.Progress()) + nextHopNI := vrfName + if dut.Vendor() == ondatra.CISCO { + // Match the validation collector: Cisco's VRF-A prefix refers to + // forwarding objects held globally under DEFAULT. + nextHopNI = deviations.DefaultNetworkInstance(dut) + } + t.Logf("AFT diagnostic collector scope: prefixNI=%s nextHopGroupNI=%s nextHopNI=%s", vrfName, nextHopNI, nextHopNI) + groupIDs := map[uint64]bool{} + nextHopIDs := map[uint64]bool{} + if snapshot, err := collector.ToAFT(t, dut); err != nil { + t.Logf("AFT diagnostic subscription cache conversion failed: %v", err) + } else { + id, present := snapshot.Prefixes[prefix] + t.Logf("AFT diagnostic SUBSCRIPTION cache NI=%s prefix=%s present=%t NHG=%d prefixes=%d groups=%d nextHops=%d", + vrfName, prefix, present, id, len(snapshot.Prefixes), len(snapshot.NextHopGroups), len(snapshot.NextHops)) + if present { + groupIDs[id] = true + t.Logf("AFT diagnostic SUBSCRIPTION cache referenced NHG %d: %+v", id, snapshot.NextHopGroups[id]) + if group := snapshot.NextHopGroups[id]; group != nil { + for _, index := range group.NHIDs { + nextHopIDs[index] = true + } + for _, index := range diagnosticIDs(nextHopIDs, 8) { + t.Logf("AFT diagnostic SUBSCRIPTION cache referenced NH %d: %+v", index, snapshot.NextHops[index]) + } + } + } + } + logAFTDiagnosticCLI(ctx, t, dut, "show logging") + logAFTDiagnosticCLI(ctx, t, dut, fmt.Sprintf("show route vrf %s %s detail", vrfName, prefix)) + logAFTDiagnosticCLI(ctx, t, dut, fmt.Sprintf("show cef vrf %s %s detail", vrfName, prefix)) + client, closeClient := newAFTDiagnosticClient(ctx, t, dut) + defer closeClient() + base := fmt.Sprintf("/network-instances/network-instance[name=%s]/afts", vrfName) + entryPath := fmt.Sprintf("%s/ipv4-unicast/ipv4-entry[prefix=%s]", base, prefix) + // Explicit STATE requests avoid conflating an ALL/config mapper failure + // with absent operational data. Compare the whole entry with its state. + for _, path := range []string{entryPath, entryPath + "/state"} { + response := logAFTDiagnosticGetType(ctx, t, dut, client, path, gpb.GetRequest_STATE) + for _, id := range diagnosticUintLeaves(t, response, "next-hop-group") { + groupIDs[id] = true + } + } + // Inspect only this route's references: at most four NHGs and eight NHs. + // Do not dump the scale tables or feed fresh reads into the stream cache. + for _, ni := range []string{vrfName, deviations.DefaultNetworkInstance(dut)} { + niBase := fmt.Sprintf("/network-instances/network-instance[name=%s]/afts", ni) + ids := map[uint64]bool{} + if ni == nextHopNI { + for index := range nextHopIDs { + ids[index] = true + } + } + // Compare the referenced group in both NIs. These diagnostic reads + // never supply values to validation; on Cisco, validation itself + // follows the DEFAULT NHG/NH subscriptions while retaining VRF-A + // prefix isolation. + for _, id := range diagnosticIDs(groupIDs, 4) { + t.Logf("AFT diagnostic referenced NHG comparison: routeNI=%s lookupNI=%s id=%d; not used for validation", vrfName, ni, id) + response := logAFTDiagnosticGetType(ctx, t, dut, client, fmt.Sprintf("%s/next-hop-groups/next-hop-group[id=%d]", niBase, id), gpb.GetRequest_STATE) + for _, index := range diagnosticUintLeaves(t, response, "index") { + ids[index] = true + } + } + for _, index := range diagnosticIDs(ids, 8) { + logAFTDiagnosticGetType(ctx, t, dut, client, fmt.Sprintf("%s/next-hops/next-hop[index=%d]", niBase, index), gpb.GetRequest_STATE) + } + } + // Each path gets a separate, short-lived stream to identify which subtree + // emits updates, returns SyncResponse, or terminates. Do not merge any of + // these responses into the validation collector. + nextHopBase := fmt.Sprintf("/network-instances/network-instance[name=%s]/afts", nextHopNI) + for _, path := range []string{entryPath, nextHopBase + "/next-hop-groups/next-hop-group", nextHopBase + "/next-hops/next-hop"} { + logAFTDiagnosticSubscription(ctx, t, dut, client, path) + } + logAFTDiagnosticCLI(ctx, t, dut, "show cef misc") + logAFTDiagnosticCLI(ctx, t, dut, "show telemetry model-driven trace all") + logAFTDiagnosticCLI(ctx, t, dut, "show grpc trace all") +} + +func logAFTDiagnosticSubscription(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, client gpb.GNMIClient, path string) { + t.Helper() + if client == nil || ctx.Err() != nil { + t.Logf("AFT diagnostic subscription skipped path=%s clientAvailable=%t contextError=%v", path, client != nil, ctx.Err()) + return + } + readCtx, cancel := context.WithDeadline(ctx, time.Now().Add(8*time.Second)) + defer cancel() + request := &gpb.SubscribeRequest{Request: &gpb.SubscribeRequest_Subscribe{Subscribe: &gpb.SubscriptionList{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, + Mode: gpb.SubscriptionList_STREAM, Encoding: gpb.Encoding_PROTO, UpdatesOnly: false, + Subscription: []*gpb.Subscription{{Path: gnmiPath(t, path), Mode: gpb.SubscriptionMode_ON_CHANGE}}, + }}} + started := time.Now() + t.Logf("AFT diagnostic independent PROTO subscription start UTC=%s path=%s request=%v", started.UTC().Format(time.RFC3339Nano), path, request) + stream, err := client.Subscribe(readCtx) + responses, updates, deletes, syncs := 0, 0, 0, 0 + stopReason := "RPC error" + defer func() { + t.Logf("AFT diagnostic independent PROTO subscription end UTC=%s path=%s elapsed=%v responses=%d updates=%d deletes=%d SyncResponses=%d stop=%s status=%s error=%v contextError=%v", + time.Now().UTC().Format(time.RFC3339Nano), path, time.Since(started), responses, updates, deletes, syncs, stopReason, status.Code(err), err, readCtx.Err()) + }() + if err != nil { + return + } + if err = stream.Send(request); err != nil { + return + } + // Bound both duration and response count even if the server is busy. Only + // the first three responses are sampled in the log; counts include all. + for responses < 128 { + var response *gpb.SubscribeResponse + response, err = stream.Recv() + if err != nil { + return + } + responses++ + if responses <= 3 { + sample := response.String() + if len(sample) > 4096 { + sample = sample[:4096] + " [truncated]" + } + t.Logf("AFT diagnostic PROTO sample path=%s response=%d: %s", path, responses, sample) + } + updates += len(response.GetUpdate().GetUpdate()) + deletes += len(response.GetUpdate().GetDelete()) + if response.GetSyncResponse() { + syncs++ + stopReason = "initial SyncResponse (cancel diagnostic stream)" + return + } + if _, ok := response.GetResponse().(*gpb.SubscribeResponse_Error); ok { + stopReason = fmt.Sprintf("server error response: %v", response.GetError()) + return + } + } + stopReason = "128-response cap reached before SyncResponse" +} + +func diagnosticIDs(ids map[uint64]bool, limit int) []uint64 { + var result []uint64 + for id := range ids { + result = append(result, id) + } + sort.Slice(result, func(i, j int) bool { return result[i] < result[j] }) + if len(result) > limit { + result = result[:limit] + } + return result +} + +// Decode diagnostic IDs without float64 conversion: AFT's uint64 identifiers +// can exceed JSON's exactly representable floating-point integer range. +func diagnosticUintLeaves(t *testing.T, response *gpb.GetResponse, leaf string) []uint64 { + ids := map[uint64]bool{} + add := func(value any) { + id, err := strconv.ParseUint(fmt.Sprint(value), 10, 64) + if err != nil { + t.Logf("AFT diagnostic cannot decode %s=%v: %v", leaf, value, err) + return + } + ids[id] = true + } + var visit func(any) + visit = func(value any) { + switch node := value.(type) { + case map[string]any: + for key, child := range node { + if key[strings.LastIndex(key, ":")+1:] == leaf { + add(child) + } else { + visit(child) + } + } + case []any: + for _, child := range node { + visit(child) + } + } + } + for _, notification := range response.GetNotification() { + for _, update := range notification.GetUpdate() { + var decoded any + switch value := update.GetVal().GetValue().(type) { + case *gpb.TypedValue_JsonIetfVal: + decoder := json.NewDecoder(strings.NewReader(string(value.JsonIetfVal))) + decoder.UseNumber() + if err := decoder.Decode(&decoded); err != nil { + t.Logf("AFT diagnostic JSON decode failed: %v", err) + continue + } + case *gpb.TypedValue_UintVal: + decoded = value.UintVal + case *gpb.TypedValue_StringVal: + decoded = value.StringVal + default: + t.Logf("AFT diagnostic unsupported ID encoding: %T", value) + continue + } + switch decoded.(type) { + case map[string]any, []any: + visit(decoded) + default: + path := notificationUpdatePath(t, notification.GetPrefix(), update.GetPath()) + last := path[strings.LastIndex(path, "/")+1:] + if last[strings.LastIndex(last, ":")+1:] == leaf { + add(decoded) + } + } + } + } + return diagnosticIDs(ids, len(ids)) +} diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/afts_prefix_filtering_resilience_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/afts_prefix_filtering_resilience_test.go index 703c48b70a6..cea658cf1a0 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/afts_prefix_filtering_resilience_test.go +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/afts_prefix_filtering_resilience_test.go @@ -12,9 +12,14 @@ package afts_prefix_filtering_resilience_test import ( "context" + "encoding/json" "errors" "flag" "fmt" + "net" + "net/netip" + "sort" + "strconv" "strings" "sync" "testing" @@ -28,6 +33,7 @@ import ( "github.com/openconfig/featureprofiles/internal/cfgplugins" "github.com/openconfig/featureprofiles/internal/deviations" "github.com/openconfig/featureprofiles/internal/fptest" + "github.com/openconfig/featureprofiles/internal/helpers" "github.com/openconfig/featureprofiles/internal/iputil" "github.com/openconfig/featureprofiles/internal/telemetry/aftcache" gpb "github.com/openconfig/gnmi/proto/gnmi" @@ -60,6 +66,9 @@ const ( // policyChangeWait is the maximum time allowed, per AFT-6.3.3, for a // collector to observe prefixes newly admitted by a global-filter change. policyChangeWait = 60 * time.Second + // The final policy-change check must run before its 60-second deadline; + // the AFT cache's default two-minute periodic check cannot do that. + policyChangeCheckInterval = 5 * time.Second // streamTerminationWait is the maximum time to wait for an active gNMI AFT // stream to terminate after the DUT reboot is issued. streamTerminationWait = 2 * time.Minute @@ -199,7 +208,14 @@ func TestAFTPrefixFilteringResilience(t *testing.T) { defer aftpf.UnconfigureToStoreRunningGNMIConfig(t, dut) } batch := configureDUT(t, dut) - configurePolicies(t, dut, batch) + filterClient := &resilienceFilterClient{ctx: t.Context()} + filterClient.connect(t, dut) + t.Cleanup(func() { filterClient.close(t) }) + configureGlobalFilterPoliciesWithDiagnostics(t, dut, filterClient, aftpf.ConfigureGlobalFilterPoliciesParams{ + V4Policy: ipv4Policy, + V6Policy: ipv6Policy, + VRFName: deviations.DefaultNetworkInstance(dut), + }) aftpf.ConfigureNetworkInstanceStaticRoute(t, dut, batch, aftpf.NetworkInstanceStaticRouteParams{ DefaultPrefixes: defaultIPv4Prefixes, VRFPrefixes: vrfV4Prefixes, @@ -225,7 +241,7 @@ func TestAFTPrefixFilteringResilience(t *testing.T) { tests := []struct { name string desc string - test func(t *testing.T, dut *ondatra.DUTDevice) + test func(t *testing.T, dut *ondatra.DUTDevice, filterClient *resilienceFilterClient) }{ { name: "AFTValidationAfterDeviceReboot", @@ -246,18 +262,20 @@ func TestAFTPrefixFilteringResilience(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { t.Log("Starting test") - tc.test(t, dut) + tc.test(t, dut, filterClient) t.Log("Finished test") }) } } -// configureDUT configures the DUT with the necessary VRF, interfaces, BGP, and redistribution policies. -func configureDUT(t *testing.T, dut *ondatra.DUTDevice) *gnmi.SetBatch { +// configureOpenConfigDUT preserves the original non-Cisco configuration +// sequence, with policies installed before BGP attaches their references. +func configureOpenConfigDUT(t *testing.T, dut *ondatra.DUTDevice) *gnmi.SetBatch { t.Helper() batch := &gnmi.SetBatch{} fptest.ConfigureDefaultNetworkInstance(t, dut) configureHardwareInit(t, dut) + installRoutingPolicies(t, dut) p1 := dut.Port(t, "port1") p2 := dut.Port(t, "port2") configureDUTInterface(t, dut, batch, &dutPort1, p1) @@ -273,6 +291,224 @@ func configureDUT(t *testing.T, dut *ondatra.DUTDevice) *gnmi.SetBatch { return batch } +func configureNetworkInstanceOnDUTPort(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch, attrs *attrs.Attributes, p *ondatra.Port, niName string) { + t.Helper() + d := gnmi.OC() + cfgplugins.AssignToNetworkInstance(t, dut, p.Name(), niName, 0) + i := attrs.NewOCInterface(p.Name(), dut) + gnmi.BatchUpdate(batch, d.Interface(p.Name()).Config(), i) +} + +// configureDUT selects the original setup sequence or Cisco's XR prerequisites. +func configureDUT(t *testing.T, dut *ondatra.DUTDevice) *gnmi.SetBatch { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return configureOpenConfigDUT(t, dut) + } + fptest.ConfigureDefaultNetworkInstance(t, dut) + configureHardwareInit(t, dut) + installRoutingPolicies(t, dut) + + // IOS XR needs the VRF address families before BGP can configure its + // address families and neighbors in this network instance. + nonDefaultNI := cfgplugins.ConfigureNetworkInstance(t, dut, vrfName, false) + cfgplugins.UpdateNetworkInstanceOnDut(t, dut, vrfName, nonDefaultNI) + if dut.Vendor() == ondatra.CISCO { + helpers.GnmiCLIConfig(t, dut, + "vrf "+vrfName+"\n address-family ipv4 unicast\n address-family ipv6 unicast\n!\n") + } + verifyVRFAddressFamilies(t, dut) + + p1 := dut.Port(t, "port1") + p2 := dut.Port(t, "port2") + configureDUTInterfaceBase(t, dut, p1) + configureDUTInterfaceBase(t, dut, p2) + // Cisco's unassigned port 1 is already in DEFAULT; explicitly assigning + // the reserved routing-table name is rejected by XR. + cfgplugins.AssignToNetworkInstance(t, dut, p2.Name(), vrfName, 0) + verifyVRFAddressFamilies(t, dut) + interfaceBatch := &gnmi.SetBatch{} + configureDUTInterface(t, dut, interfaceBatch, &dutPort1, p1) + configureDUTInterface(t, dut, interfaceBatch, &dutPort2, p2) + interfaceBatch.Set(t, dut) + + cfgplugins.EnableDefaultNetworkInstanceBgp(t, dut, aftFilterDUTAS) + defaultNI := cfgplugins.ConfigureNetworkInstance(t, dut, deviations.DefaultNetworkInstance(dut), true) + configureScaleBGP(t, dut, defaultNI, nonDefaultNI) + configureBGPGlobal(t, dut, defaultNI) + initializeCiscoVRFBGPAddressFamilies(t, dut) + configureBGPGlobal(t, dut, nonDefaultNI) + configureBGPNeighbors(t, dut, defaultNI) + configureBGPNeighbors(t, dut, nonDefaultNI) + return &gnmi.SetBatch{} +} + +// initializeCiscoVRFBGPAddressFamilies creates the global VPN parents and +// per-VRF BGP address families before OpenConfig updates the VRF's BGP protocol +// and neighbors. +func initializeCiscoVRFBGPAddressFamilies(t *testing.T, dut *ondatra.DUTDevice) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return + } + // IOS XR requires VPNv4/VPNv6 in the same BGP instance before enabling + // IPv4/IPv6 unicast within a BGP VRF. + t.Log("Configuring global BGP VPNv4 and VPNv6 parent address families in instance BGP") + helpers.GnmiCLIConfig(t, dut, fmt.Sprintf( + "router bgp %d instance BGP\n address-family vpnv4 unicast\n !\n address-family vpnv6 unicast\n !\n!\n", aftFilterDUTAS)) + config := readCiscoBGPInstanceConfig(t, dut) + for _, family := range []string{"vpnv4", "vpnv6"} { + if !strings.Contains(config, "\n address-family "+family+" unicast\n") { + t.Fatalf("BGP instance BGP is missing global %s unicast", family) + } + } + rd := fmt.Sprintf("%d:63", aftFilterDUTAS) + steps := []struct { + name string + cli string + wantVRFConfig []string + }{ + { + name: "BGP VRF context and route distinguisher", + cli: fmt.Sprintf("router bgp %d instance BGP\n vrf %s\n rd %s\n !\n!\n", aftFilterDUTAS, vrfName, rd), + wantVRFConfig: []string{" rd " + rd}, + }, + { + name: "IPv4 BGP VRF address family", + cli: fmt.Sprintf("router bgp %d instance BGP\n vrf %s\n address-family ipv4 unicast\n !\n !\n!\n", aftFilterDUTAS, vrfName), + wantVRFConfig: []string{" rd " + rd, " address-family ipv4 unicast"}, + }, + { + name: "IPv6 BGP VRF address family", + cli: fmt.Sprintf("router bgp %d instance BGP\n vrf %s\n address-family ipv6 unicast\n !\n !\n!\n", aftFilterDUTAS, vrfName), + wantVRFConfig: []string{" rd " + rd, " address-family ipv4 unicast", " address-family ipv6 unicast"}, + }, + } + for _, step := range steps { + t.Logf("Configuring %s in %s", step.name, vrfName) + helpers.GnmiCLIConfig(t, dut, step.cli) + verifyCiscoVRFBGPConfig(t, dut, step.wantVRFConfig...) + } +} + +func readCiscoBGPInstanceConfig(t *testing.T, dut *ondatra.DUTDevice) string { + t.Helper() + ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second) + defer cancel() + response, err := dut.RawAPIs().CLI(t).RunCommand(ctx, "show running-config router bgp") + if err != nil { + t.Fatalf("failed to read BGP running config: %v", err) + } + config := strings.ReplaceAll(response.Output(), "\r\n", "\n") + t.Logf("BGP running config while initializing VRF %s:\n%s", vrfName, config) + config = "\n" + config + instanceMarker := fmt.Sprintf("router bgp %d instance BGP\n", aftFilterDUTAS) + instanceIndex := strings.Index(config, "\n"+instanceMarker) + if instanceIndex < 0 { + t.Fatalf("BGP running config is missing %q", strings.TrimSpace(instanceMarker)) + } + instanceConfig := config[instanceIndex+1:] + if end := strings.Index(instanceConfig, "\nrouter bgp "); end >= 0 { + instanceConfig = instanceConfig[:end] + } + return instanceConfig +} + +func verifyCiscoVRFBGPConfig(t *testing.T, dut *ondatra.DUTDevice, wantLines ...string) { + t.Helper() + config := readCiscoBGPInstanceConfig(t, dut) + vrfMarker := " vrf " + vrfName + "\n" + vrfIndex := strings.Index(config, vrfMarker) + if vrfIndex < 0 { + t.Fatalf("BGP running config is missing VRF %s", vrfName) + } + vrfConfig := config[vrfIndex+len(vrfMarker):] + if end := strings.Index(vrfConfig, "\n !"); end >= 0 { + vrfConfig = vrfConfig[:end] + } + for _, want := range wantLines { + if !strings.Contains("\n"+vrfConfig+"\n", "\n"+want+"\n") { + t.Fatalf("BGP VRF %s running config is missing %q", vrfName, want) + } + } +} + +// verifyVRFAddressFamilies checks that both VRF address families are present +// on Cisco before configuring BGP under the VRF. +func verifyVRFAddressFamilies(t *testing.T, dut *ondatra.DUTDevice) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + return + } + ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second) + defer cancel() + response, err := dut.RawAPIs().CLI(t).RunCommand(ctx, "show running-config vrf "+vrfName) + if err != nil { + t.Fatalf("failed to verify VRF %s address families in running config: %v", vrfName, err) + } + t.Logf("VRF %s running config:\n%s", vrfName, response.Output()) + if !strings.Contains(response.Output(), "vrf "+vrfName) { + t.Fatalf("VRF %s is missing from the running config", vrfName) + } + for _, want := range []string{"address-family ipv4 unicast", "address-family ipv6 unicast"} { + if !strings.Contains(response.Output(), want) { + t.Fatalf("VRF %s running config is missing %q", vrfName, want) + } + } +} + +// configureBGPGlobal commits the protocol's global address families before +// any neighbors are configured in either network instance. +func configureBGPGlobal(t *testing.T, dut *ondatra.DUTDevice, ni *oc.NetworkInstance) { + t.Helper() + const bgpName = "BGP" + proto := ni.GetOrCreateProtocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, bgpName) + bgp := proto.GetOrCreateBgp() + globalOnly := &oc.NetworkInstance_Protocol{ + Identifier: oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, + Name: ygot.String(bgpName), + Enabled: ygot.Bool(true), + Bgp: &oc.NetworkInstance_Protocol_Bgp{Global: bgp.GetOrCreateGlobal()}, + } + path := gnmi.OC().NetworkInstance(ni.GetName()).Protocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, bgpName) + t.Logf("Configuring BGP global address families in %s before neighbors", ni.GetName()) + gnmi.Update(t, dut, path.Config(), globalOnly) +} + +// configureBGPNeighbors commits each neighbor and its AF-specific policies +// after the global BGP address families exist on the DUT. +func configureBGPNeighbors(t *testing.T, dut *ondatra.DUTDevice, ni *oc.NetworkInstance) { + t.Helper() + const bgpName = "BGP" + bgp := ni.GetOrCreateProtocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, bgpName).GetOrCreateBgp() + path := gnmi.OC().NetworkInstance(ni.GetName()).Protocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP, bgpName) + var neighbors []string + for addr := range bgp.Neighbor { + neighbors = append(neighbors, addr) + } + sort.Strings(neighbors) + for _, addr := range neighbors { + t.Logf("Configuring BGP neighbor %s in %s", addr, ni.GetName()) + gnmi.Update(t, dut, path.Bgp().Neighbor(addr).Config(), bgp.Neighbor[addr]) + } +} + +// configureDUTInterfaceBase creates the interface and subinterface before +// attaching them to a network instance; IP addresses are added afterward. +func configureDUTInterfaceBase(t *testing.T, dut *ondatra.DUTDevice, p *ondatra.Port) { + t.Helper() + i := &oc.Interface{ + Name: ygot.String(p.Name()), + Type: oc.IETFInterfaces_InterfaceType_ethernetCsmacd, + } + if deviations.InterfaceEnabled(dut) { + i.Enabled = ygot.Bool(true) + } + i.GetOrCreateEthernet() + i.GetOrCreateSubinterface(0) + gnmi.Update(t, dut, gnmi.OC().Interface(p.Name()).Config(), i) +} + // configureDUTInterface configure interfaces on DUT. func configureDUTInterface(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch, attrs *attrs.Attributes, p *ondatra.Port) { t.Helper() @@ -285,7 +521,9 @@ func configureDUTInterface(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.Set } i.GetOrCreateEthernet() i4 := i.GetOrCreateSubinterface(0).GetOrCreateIpv4() - i4.Enabled = ygot.Bool(true) + if dut.Vendor() != ondatra.CISCO || (deviations.InterfaceEnabled(dut) && !deviations.IPv4MissingEnabled(dut)) { + i4.Enabled = ygot.Bool(true) + } av4 := i4.GetOrCreateAddress(attrs.IPv4) av4.PrefixLength = ygot.Uint8(attrs.IPv4Len) i6 := i.GetOrCreateSubinterface(0).GetOrCreateIpv6() @@ -295,15 +533,6 @@ func configureDUTInterface(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.Set gnmi.BatchUpdate(batch, d.Interface(p.Name()).Config(), i) } -// configureNetworkInstanceOnDUTPort configure DUT ports. -func configureNetworkInstanceOnDUTPort(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch, attrs *attrs.Attributes, p *ondatra.Port, niName string) { - t.Helper() - d := gnmi.OC() - cfgplugins.AssignToNetworkInstance(t, dut, p.Name(), niName, 0) - i := attrs.NewOCInterface(p.Name(), dut) - gnmi.BatchUpdate(batch, d.Interface(p.Name()).Config(), i) -} - // configureHardwareInit sets up the initial hardware configuration on the DUT. // It pushes the hardware initialization configuration for the VRF Selection // Extended and Policy Forwarding features. @@ -429,8 +658,11 @@ func runCollectorsConcurrently(t *testing.T, cfgs ...aftpf.RunCollectorParams) { } // awaitScaleBGPConvergence waits for the eBGP sessions in the default network -// instance and in the non-default VRF to establish and for the expected scale -// IPv4/IPv6 route counts to be installed. +// instance and in the non-default VRF to establish and for route readiness. +// The shared helper retains DEFAULT's installed-counter checks. For Cisco +// VRFs, whose per-peer RIB-installed counter is unsupported, it checks native +// BGP accepted/best-path counts and BGP-origin AFT summaries instead. This is +// only setup validation; the later per-prefix/filter-isolation checks remain. func awaitScaleBGPConvergence(t *testing.T, dut *ondatra.DUTDevice) { t.Helper() aftpf.AwaitScaleBGPConvergence(t, dut, aftpf.BGPConvergenceParams{ @@ -447,7 +679,7 @@ func awaitScaleBGPConvergence(t *testing.T, dut *ondatra.DUTDevice) { // testAfterReboot validates that AFT filtering policies and filtered entries // are preserved across a DUT reboot. -func testAfterReboot(t *testing.T, dut *ondatra.DUTDevice) { +func testAfterReboot(t *testing.T, dut *ondatra.DUTDevice, filterClient *resilienceFilterClient) { t.Helper() ctx, cancel := context.WithCancel(t.Context()) defer cancel() @@ -459,7 +691,7 @@ func testAfterReboot(t *testing.T, dut *ondatra.DUTDevice) { aftSession1 := aftcache.NewAFTStreamSession(ctx, t, aftClient1, dut) aftSession2 := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) t.Log("Collecting initial filtered AFT entries") - stoppingCondition := aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}) + stoppingCondition := aftcache.InitialSyncStoppingConditionWithNextHopValidator(t, dut, wantPrefixes, verifiedDefaultPeerValidator(ctx, t, dut)) aftBefore, err := fetchAFT(ctx, t, dut, aftSession1, aftSession2, stoppingCondition, wantPrefixes, aftConvergenceTime) if err != nil { t.Fatalf("Failed to fetch initial AFT: %v", err) @@ -476,12 +708,18 @@ func testAfterReboot(t *testing.T, dut *ondatra.DUTDevice) { // created after the DUT is already down). monitoredStream := startAFTStream(ctx, t, aftClient1) t.Log("Rebooting DUT") + filterClient.close(t) + t.Logf("AFT reboot marker: issuing reboot UTC=%s; test-owned filter client retired", time.Now().UTC().Format(time.RFC3339Nano)) rebootDUT(t, dut) // The subscription is active while the DUT reboots; verify the stream is // terminated by the DUT going down. verifyStreamTerminated(t, monitoredStream) // Wait for DUT recovery. waitForReboot(t, dut, lastBootTime) + t.Logf("AFT reboot marker: DUT recovery observed UTC=%s", time.Now().UTC().Format(time.RFC3339Nano)) + // Never send the next policy Set over the pre-reboot transport. Reconnect + // explicitly; a failed Set still fails the test and is not retried. + filterClient.connect(t, dut) // Verify policy persistence after reboot. verifyGlobalFilterPolicies(t, dut, ipv4Policy, ipv6Policy) // The reboot tears down the eBGP sessions, so wait for them to re-establish @@ -493,7 +731,8 @@ func testAfterReboot(t *testing.T, dut *ondatra.DUTDevice) { t.Log("Re-establishing AFT subscriptions") aftSession3 := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) aftSession4 := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - stoppingCondition2 := aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, map[string]bool{atePort1.IPv4: true}, map[string]bool{atePort1.IPv6: true}) + // Re-read neighbor identity after reboot rather than trusting pre-reboot ND. + stoppingCondition2 := aftcache.InitialSyncStoppingConditionWithNextHopValidator(t, dut, wantPrefixes, verifiedDefaultPeerValidator(ctx, t, dut)) aftAfter, err := fetchAFT(ctx, t, dut, aftSession3, aftSession4, stoppingCondition2, wantPrefixes, aftConvergenceTime) if err != nil { t.Fatalf("Failed to fetch AFT after reboot: %v", err) @@ -616,75 +855,414 @@ func verifyGlobalFilterPolicies(t *testing.T, dut *ondatra.DUTDevice, wantIPv4Po ctx, cancel := context.WithCancel(t.Context()) defer cancel() configReq := &gpb.GetRequest{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, Path: []*gpb.Path{ gnmiPath(t, ocPolicyConfigPathV4), gnmiPath(t, ocPolicyConfigPathV6), }, - Type: gpb.GetRequest_CONFIG, + Type: gpb.GetRequest_CONFIG, + Encoding: aftpf.ConfigEncoding(dut), } configResp, err := gnmiClient.Get(ctx, configReq) if err != nil { t.Fatalf("GNMI Get for global-filter config failed: %v", err) } stateReq := &gpb.GetRequest{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, Path: []*gpb.Path{ gnmiPath(t, ocPolicyStatePathV4), gnmiPath(t, ocPolicyStatePathV6), }, - Type: gpb.GetRequest_STATE, + Type: gpb.GetRequest_STATE, + Encoding: aftpf.ConfigEncoding(dut), } stateResp, err := gnmiClient.Get(ctx, stateReq) if err != nil { t.Fatalf("GNMI Get for global-filter state failed: %v", err) } - var gotConfigIPv4Policy string - var gotConfigIPv6Policy string - for _, notif := range configResp.GetNotification() { - for _, upd := range notif.GetUpdate() { - path, err := ygot.PathToString(upd.GetPath()) + gotConfigIPv4Policy, gotConfigIPv6Policy := globalFilterPoliciesFromGet(t, configResp) + gotStateIPv4Policy, gotStateIPv6Policy := globalFilterPoliciesFromGet(t, stateResp) + if gotConfigIPv4Policy != wantIPv4Policy { + t.Fatalf("IPv4 config policy mismatch got=%q want=%q", gotConfigIPv4Policy, wantIPv4Policy) + } + if gotConfigIPv6Policy != wantIPv6Policy { + t.Fatalf("IPv6 config policy mismatch got=%q want=%q", gotConfigIPv6Policy, wantIPv6Policy) + } + if gotStateIPv4Policy != wantIPv4Policy { + t.Fatalf("IPv4 state policy mismatch got=%q want=%q", gotStateIPv4Policy, wantIPv4Policy) + } + if gotStateIPv6Policy != wantIPv6Policy { + t.Fatalf("IPv6 state policy mismatch got=%q want=%q", gotStateIPv6Policy, wantIPv6Policy) + } + t.Logf("Verified persisted global-filter config/state policies for %q: ipv4=%q ipv6=%q", niName, gotConfigIPv4Policy, gotConfigIPv6Policy) + } +} + +// typedStringLeaves handles both scalar and container JSON_IETF responses. +// Namespace prefixes on JSON field names are stripped, not policy values. +func typedStringLeaves(value *gpb.TypedValue, leaf string, fullPath string) ([]string, error) { + var decoded any + switch v := value.GetValue().(type) { + case *gpb.TypedValue_StringVal: + decoded = v.StringVal + case *gpb.TypedValue_JsonIetfVal: + if err := json.Unmarshal(v.JsonIetfVal, &decoded); err != nil { + return nil, err + } + case *gpb.TypedValue_JsonVal: + if err := json.Unmarshal(v.JsonVal, &decoded); err != nil { + return nil, err + } + default: + return nil, fmt.Errorf("unsupported string-leaf value %T", value.GetValue()) + } + if scalar, ok := decoded.(string); ok { + if strings.HasSuffix(fullPath, "/"+leaf) { + return []string{scalar}, nil + } + return nil, nil + } + var values []string + var visit func(any) error + visit = func(node any) error { + switch node := node.(type) { + case map[string]any: + for key, child := range node { + if i := strings.LastIndex(key, ":"); i >= 0 { + key = key[i+1:] + } + if key == leaf { + s, ok := child.(string) + if !ok { + return fmt.Errorf("%s is %T, not a string", leaf, child) + } + values = append(values, s) + } else if err := visit(child); err != nil { + return err + } + } + case []any: + for _, child := range node { + if err := visit(child); err != nil { + return err + } + } + } + return nil + } + err := visit(decoded) + return values, err +} + +func notificationUpdatePath(t *testing.T, prefix, path *gpb.Path) string { + t.Helper() + // A scalar update may carry its entire path in either field. + if prefix == nil { + prefix = &gpb.Path{} + } + if path == nil { + path = &gpb.Path{} + } + prefixText, err := ygot.PathToString(prefix) + if err != nil { + t.Fatalf("Invalid notification prefix: %v", err) + } + pathText, err := ygot.PathToString(path) + if err != nil { + t.Fatalf("Invalid update path: %v", err) + } + return strings.TrimRight(prefixText, "/") + "/" + strings.TrimLeft(pathText, "/") +} + +func globalFilterPoliciesFromGet(t *testing.T, response *gpb.GetResponse) (string, string) { + t.Helper() + policies := map[string]string{} + for _, notification := range response.GetNotification() { + for _, update := range notification.GetUpdate() { + path := notificationUpdatePath(t, notification.GetPrefix(), update.GetPath()) + for _, leaf := range []string{"ipv4-policy", "ipv6-policy"} { + values, err := typedStringLeaves(update.GetVal(), leaf, path) if err != nil { - t.Fatalf("PathToString failed: %v", err) + t.Fatalf("Decode global-filter %s at %s: %v", leaf, path, err) + } + for _, value := range values { + if old, present := policies[leaf]; present && old != value { + t.Fatalf("Conflicting %s values: %q and %q", leaf, old, value) + } + policies[leaf] = value } - val := upd.GetVal().GetStringVal() - switch { - case strings.Contains(path, "ipv4-policy"): - gotConfigIPv4Policy = val - case strings.Contains(path, "ipv6-policy"): - gotConfigIPv6Policy = val + } + } + } + for _, leaf := range []string{"ipv4-policy", "ipv6-policy"} { + if _, present := policies[leaf]; !present { + t.Fatalf("Get response is missing global-filter %s: %v", leaf, response) + } + } + return policies["ipv4-policy"], policies["ipv6-policy"] +} + +// verifiedDefaultPeerValidator accepts the exact expected global next hop, +// permitting an absent interface-ref but rejecting a conflicting one. A +// link-local next hop additionally requires a verified MAC/interface mapping. +// It never accepts an arbitrary fe80:: address or rewrites cached telemetry. +func verifiedDefaultPeerValidator(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice) func(string, []*aftcache.NextHop) (bool, error) { + t.Helper() + if dut.Vendor() != ondatra.CISCO { + // Retain the original exact ATE IP checks. The verified link-local + // alternative and interface checks below address Cisco telemetry. + return func(prefix string, nextHops []*aftcache.NextHop) (bool, error) { + if len(nextHops) == 0 { + return false, nil + } + want := atePort1.IPv4 + if strings.Contains(prefix, ":") { + want = atePort1.IPv6 + } + for _, nextHop := range nextHops { + if nextHop == nil || nextHop.IP != want { + return false, nil } } + return true, nil } - var gotStateIPv4Policy string - var gotStateIPv6Policy string - for _, notif := range stateResp.GetNotification() { - for _, upd := range notif.GetUpdate() { - path, err := ygot.PathToString(upd.GetPath()) + } + intf := dut.Port(t, "port1").Name() + mac, err := net.ParseMAC(atePort1.MAC) + if err != nil || len(mac) != 6 { + t.Fatalf("ATE port1 must have a 48-bit MAC, got %q (%v)", atePort1.MAC, err) + } + // OTG's default IPv6 link-local address uses modified EUI-64. Derivation + // gives a candidate only; ND must confirm that address belongs to this MAC. + address := [16]byte{0xfe, 0x80} + copy(address[8:], []byte{mac[0] ^ 0x02, mac[1], mac[2], 0xff, 0xfe, mac[3], mac[4], mac[5]}) + linkLocal := netip.AddrFrom16(address) + global := netip.MustParseAddr(atePort1.IPv6) + neighborPath := fmt.Sprintf("/interfaces/interface[name=%s]/subinterfaces/subinterface[index=0]/ipv6/neighbors/neighbor[ip=%s]/state/link-layer-address", intf, linkLocal) + path := gnmiPath(t, neighborPath) + path.Origin = "openconfig" + readCtx, readCancel := context.WithDeadline(ctx, time.Now().Add(30*time.Second)) + response, readErr := dut.RawAPIs().GNMI(t).Get(readCtx, &gpb.GetRequest{ + Prefix: &gpb.Path{Target: dut.Name()}, Path: []*gpb.Path{path}, + Type: gpb.GetRequest_STATE, Encoding: aftpf.ConfigEncoding(dut), + }) + readCancel() + verified := false + verificationDetail := "gNMI returned no matching neighbor MAC" + if readErr != nil { + verificationDetail = fmt.Sprintf("gNMI lookup failed: %v", readErr) + t.Logf("Cannot verify IPv6 link-local peer via %s: %v", neighborPath, readErr) + } else { + var returnedMACs []string + for _, notification := range response.GetNotification() { + for _, update := range notification.GetUpdate() { + values, err := typedStringLeaves(update.GetVal(), "link-layer-address", notificationUpdatePath(t, notification.GetPrefix(), update.GetPath())) if err != nil { - t.Fatalf("PathToString failed: %v", err) + t.Logf("Cannot decode IPv6 neighbor MAC: %v", err) + continue } - val := upd.GetVal().GetStringVal() - switch { - case strings.Contains(path, "ipv4-policy"): - gotStateIPv4Policy = val - case strings.Contains(path, "ipv6-policy"): - gotStateIPv6Policy = val + returnedMACs = append(returnedMACs, values...) + } + } + // A missing or conflicting mapping must not broaden the expectation. + verified = len(returnedMACs) > 0 + for _, value := range returnedMACs { + got, err := net.ParseMAC(value) + if err != nil || !strings.EqualFold(got.String(), mac.String()) { + verified = false + } + } + verificationDetail = fmt.Sprintf("gNMI returned MACs=%v, expected=%s", returnedMACs, mac) + t.Logf("IPv6 peer identity: interface=%s global=%s candidate link-local=%s expected MAC=%s returned MACs=%v verified=%t", intf, global, linkLocal, mac, returnedMACs, verified) + } + if !verified && dut.Vendor() == ondatra.CISCO { + // The image may not expose the OC neighbor MAC leaf. Verify the same + // address/MAC/interface association through native ND, not merely + // the EUI-64 derivation or a match on an arbitrary link-local address. + cliCtx, cliCancel := context.WithDeadline(ctx, time.Now().Add(20*time.Second)) + neighbors, cliErr := dut.RawAPIs().CLI(t).RunCommand(cliCtx, "show ipv6 neighbors") + cliCancel() + if cliErr != nil { + verificationDetail += fmt.Sprintf("; native ND lookup failed: %v", cliErr) + t.Logf("Native IPv6 neighbor verification failed: %v", cliErr) + } else { + t.Logf("Native IPv6 neighbors for peer identity verification:\n%s", neighbors.Output()) + var matchErr error + verified, matchErr = ciscoIPv6NeighborMatches(t, neighbors.Output(), intf, linkLocal, mac) + verificationDetail += fmt.Sprintf("; native ND verified=%t, detail=%v", verified, matchErr) + t.Logf("Native IPv6 peer identity: interface=%s link-local=%s expected MAC=%s verified=%t detail=%v", intf, linkLocal, mac, verified, matchErr) + } + } + var logMu sync.Mutex + logged := map[string]bool{} + diagnosed := map[uint64]bool{} + return func(prefix string, nextHops []*aftcache.NextHop) (bool, error) { + if len(nextHops) == 0 { + return false, nil + } + wantIPv4 := netip.MustParseAddr(atePort1.IPv4) + for _, nextHop := range nextHops { + if nextHop == nil || nextHop.IP == "" { + // A partially received NH can carry its interface before its IP. + return false, nil + } + ip, err := netip.ParseAddr(nextHop.IP) + if err != nil { + return false, fmt.Errorf("invalid next-hop address %q: %w", nextHop.IP, err) + } + ip = ip.WithZone("") + correctInterface := nextHop.IntfName == intf || nextHop.IntfName == intf+".0" + // Static/global IP next hops may omit interface-ref. Restore the + // original exact-IP validation in that case, but never ignore an + // explicitly wrong interface. Link-local next hops remain scoped. + if !ip.IsLinkLocalUnicast() && nextHop.IntfName == "" { + correctInterface = true + logMu.Lock() + // Limit raw Gets to four distinct NH entries per validator; + // concurrent collectors must not repeatedly dump the NH table. + diagnose := !diagnosed[nextHop.Index] && len(diagnosed) < 4 + if diagnose { + diagnosed[nextHop.Index] = true + } + logMu.Unlock() + if diagnose { + logRawNextHop(ctx, t, dut, prefix, nextHop) } } + correctIP := ip == wantIPv4 + if strings.Contains(prefix, ":") { + if ip == linkLocal && !verified { + // Repeating AFT convergence checks cannot repair a missing + // identity lookup. Fail with both lookup results immediately. + return false, fmt.Errorf("cannot verify IPv6 next hop %s on %s for prefix %s: %s", ip, intf, prefix, verificationDetail) + } + correctIP = ip == global || (verified && ip == linkLocal) + } + if !correctInterface || !correctIP { + key := nextHop.IP + "@" + nextHop.IntfName + logMu.Lock() + if !logged[key] { + t.Logf("Next-hop identity mismatch for %s: IP=%s interface=%q, want port1=%s; link-local %s verified=%t", prefix, nextHop.IP, nextHop.IntfName, intf, linkLocal, verified) + logged[key] = true + } + logMu.Unlock() + return false, nil + } } - if gotConfigIPv4Policy != wantIPv4Policy { - t.Fatalf("IPv4 config policy mismatch got=%q want=%q", gotConfigIPv4Policy, wantIPv4Policy) + return true, nil + } +} + +// ciscoIPv6NeighborMatches requires the address, interface and MAC in the same +// native neighbor record. Wrapped rows are supported; an entry on another port +// cannot verify this peer, and conflicting MACs on the expected port fail. +func ciscoIPv6NeighborMatches(t *testing.T, output, intf string, address netip.Addr, wantMAC net.HardwareAddr) (bool, error) { + t.Helper() + interfaceNames := map[string]bool{intf: true, intf + ".0": true} + // XR's native ND table prints FourHundredGigE as FH. Accept that + // specific alias with the complete port suffix, not a substring match + // that could mistake another port (for example /10 versus /100). + if strings.HasPrefix(intf, "FourHundredGigE") { + shortName := "FH" + strings.TrimPrefix(intf, "FourHundredGigE") + interfaceNames[shortName] = true + interfaceNames[shortName+".0"] = true + } + var records [][]string + // Only a partially printed neighbor may consume a continuation line. + // In particular, [Mcast adjacency] is a separate record, not a neighbor's + // continuation: its zero MAC must never be attributed to the peer above it. + pending := -1 + complete := func(fields []string) bool { + hasMAC, hasInterface := false, false + for _, field := range fields { + if mac, err := net.ParseMAC(field); err == nil && len(mac) == 6 { + hasMAC = true + } + if strings.Contains(field, "/") && !strings.Contains(field, ":") { + // Interface names have a port suffix; locations such as + // 0/0/CPU0 do not start with a letter. + hasInterface = hasInterface || (field[0] >= 'A' && field[0] <= 'Z') || (field[0] >= 'a' && field[0] <= 'z') + } } - if gotConfigIPv6Policy != wantIPv6Policy { - t.Fatalf("IPv6 config policy mismatch got=%q want=%q", gotConfigIPv6Policy, wantIPv6Policy) + return hasMAC && hasInterface + } + for _, line := range strings.Split(output, "\n") { + fields := strings.Fields(line) + if len(fields) == 0 { + pending = -1 + continue } - if gotStateIPv4Policy != wantIPv4Policy { - t.Fatalf("IPv4 state policy mismatch got=%q want=%q", gotStateIPv4Policy, wantIPv4Policy) + if ip, err := netip.ParseAddr(fields[0]); err == nil && ip.Is6() { + records = append(records, fields) + pending = len(records) - 1 + } else { + // Wrapped XR rows begin with an age or a MAC. Reject headers, + // multicast rows and unrelated CLI text as record boundaries. + _, ageErr := strconv.ParseUint(fields[0], 10, 64) + mac, macErr := net.ParseMAC(fields[0]) + continuation := ageErr == nil || fields[0] == "-" || (macErr == nil && len(mac) == 6) || interfaceNames[fields[0]] + if pending < 0 || !continuation { + pending = -1 + continue + } + records[pending] = append(records[pending], fields...) } - if gotStateIPv6Policy != wantIPv6Policy { - t.Fatalf("IPv6 state policy mismatch got=%q want=%q", gotStateIPv6Policy, wantIPv6Policy) + if pending >= 0 && complete(records[pending]) { + pending = -1 } - t.Logf("Verified persisted global-filter config/state policies for %q: ipv4=%q ipv6=%q", niName, gotConfigIPv4Policy, gotConfigIPv6Policy) } + matched := false + for _, record := range records { + ip, err := netip.ParseAddr(record[0]) + if err != nil || ip.WithZone("") != address { + continue + } + correctInterface := false + var macs []net.HardwareAddr + for _, field := range record[1:] { + if interfaceNames[field] { + correctInterface = true + } + if mac, err := net.ParseMAC(field); err == nil && len(mac) == 6 { + macs = append(macs, mac) + } + } + if !correctInterface { + continue + } + t.Logf("IPv6 neighbor validation selected record: address=%s interface=%s fields=%v", address, intf, record) + if len(macs) == 0 { + return false, fmt.Errorf("neighbor %s on %s has no resolved MAC: %v", address, intf, record) + } + for _, mac := range macs { + if !strings.EqualFold(mac.String(), wantMAC.String()) { + return false, fmt.Errorf("neighbor %s on %s has MAC %s, want %s", address, intf, mac, wantMAC) + } + } + matched = true + } + if !matched { + return false, fmt.Errorf("no native neighbor record for %s with MAC %s on %s", address, wantMAC, intf) + } + return true, nil +} + +func logRawNextHop(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, prefix string, nextHop *aftcache.NextHop) { + t.Helper() + t.Logf("Global next hop has no decoded interface-ref: prefix=%s index=%d IP=%s decoded=%+v; checking raw DUT telemetry", prefix, nextHop.Index, nextHop.IP, nextHop) + path := gnmiPath(t, fmt.Sprintf("/network-instances/network-instance[name=%s]/afts/next-hops/next-hop[index=%d]", deviations.DefaultNetworkInstance(dut), nextHop.Index)) + readCtx, cancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) + defer cancel() + response, err := dut.RawAPIs().GNMI(t).Get(readCtx, &gpb.GetRequest{ + Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, Path: []*gpb.Path{path}, + Type: gpb.GetRequest_STATE, Encoding: aftpf.ConfigEncoding(dut), + }) + if err != nil { + t.Logf("Raw next-hop diagnostic for index %d failed: %v", nextHop.Index, err) + return + } + // This is a fresh read, not a replacement for the subscription cache. + t.Logf("Raw next-hop diagnostic for index %d: %v", nextHop.Index, response) } // gnmiPath converts a string-based gNMI path into a structured gNMI Path. @@ -697,11 +1275,9 @@ func gnmiPath(t *testing.T, path string) *gpb.Path { return p } -// configurePolicies configures all routing policies required for AFT filtering -// validation, including base policies and scale filtering policies. It also -// applies the default global filter policies and pushes the routing policy -// configuration to the DUT. -func configurePolicies(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch) { +// installRoutingPolicies installs all routing policies before BGP or the AFT +// global filter references them. +func installRoutingPolicies(t *testing.T, dut *ondatra.DUTDevice) { t.Helper() root := &oc.Root{} rp := root.GetOrCreateRoutingPolicy() @@ -709,14 +1285,9 @@ func configurePolicies(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatc ipv6ScalePrefixes := generateScaleIPv6Prefixes(t) configureBasePolicies(t, rp) configureScalePolicies(t, rp, ipv4ScalePrefixes, ipv6ScalePrefixes) - aftpf.ConfigureGlobalFilterPolicies(t, dut, - aftpf.ConfigureGlobalFilterPoliciesParams{ - V4Policy: ipv4Policy, - V6Policy: ipv6Policy, - VRFName: deviations.DefaultNetworkInstance(dut), - }) - gnmi.BatchReplace(batch, gnmi.OC().RoutingPolicy().Config(), rp) - batch.Set(t, dut) + policyBatch := &gnmi.SetBatch{} + gnmi.BatchReplace(policyBatch, gnmi.OC().RoutingPolicy().Config(), rp) + policyBatch.Set(t, dut) } // configureBasePolicies configures the common routing policies used by the @@ -960,7 +1531,7 @@ func rebootDUT(t *testing.T, dut *ondatra.DUTDevice) { // 4. Measure synchronization time. // 5. Verify synchronization completes within deadline. // 6. Verify only expected filtered prefixes are streamed. -func testScaleFiltering(t *testing.T, dut *ondatra.DUTDevice) { +func testScaleFiltering(t *testing.T, dut *ondatra.DUTDevice, filterClient *resilienceFilterClient) { t.Helper() var ipv4Prefixes, ipv6Prefixes []string // Enumerate the scale routes advertised via BGP from the ATE @@ -1030,6 +1601,9 @@ func testScaleFiltering(t *testing.T, dut *ondatra.DUTDevice) { ipv4: false, }, } + // Record the post-reboot baseline before scale policy Sets, so old MDT + // closures can be distinguished from any new transport/queue failure. + logAFTDiagnosticCLI(t.Context(), t, dut, "show logging") for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { // Scope the streaming context to this scenario. Each scenario opens two @@ -1057,11 +1631,11 @@ func testScaleFiltering(t *testing.T, dut *ondatra.DUTDevice) { aftSession1 := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) aftSession2 := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) if tc.ipv4 { - aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: tc.policyName, V6Policy: "", VRFName: deviations.DefaultNetworkInstance(dut)}) + configureGlobalFilterPoliciesWithDiagnostics(t, dut, filterClient, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: tc.policyName, V6Policy: "", VRFName: deviations.DefaultNetworkInstance(dut)}) stoppingCondition = aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, map[string]bool{atePort1.IPv4: true}, nil) } else { - aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: "", V6Policy: tc.policyName, VRFName: deviations.DefaultNetworkInstance(dut)}) - stoppingCondition = aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, nil, map[string]bool{atePort1.IPv6: true}) + configureGlobalFilterPoliciesWithDiagnostics(t, dut, filterClient, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: "", V6Policy: tc.policyName, VRFName: deviations.DefaultNetworkInstance(dut)}) + stoppingCondition = aftcache.InitialSyncStoppingConditionWithNextHopValidator(t, dut, wantPrefixes, verifiedDefaultPeerValidator(ctx, t, dut)) } // Measure synchronization time start := time.Now() @@ -1158,25 +1732,41 @@ func unmatchedScalePrefixes(prefixes []string, matchPercent int) []string { // 5. No leakage between collectors. // 6. Policy-change behavior. // 7. Collector stability during filter updates. -func testPerNIFiltering(t *testing.T, dut *ondatra.DUTDevice) { +func testPerNIFiltering(t *testing.T, dut *ondatra.DUTDevice, filterClient *resilienceFilterClient) { t.Helper() ctx, cancel := context.WithCancel(t.Context()) defer cancel() // Configure NI-specific AFT filters t.Log("Configuring per-network-instance AFT filters") - aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: ipv4Policy, V6Policy: ipv6Policy, VRFName: deviations.DefaultNetworkInstance(dut)}) - aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: vrfAPolicy, V6Policy: vrfAPolicy, VRFName: vrfName}) + configureGlobalFilterPoliciesWithDiagnostics(t, dut, filterClient, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: ipv4Policy, V6Policy: ipv6Policy, VRFName: deviations.DefaultNetworkInstance(dut)}) + configureGlobalFilterPoliciesWithDiagnostics(t, dut, filterClient, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: vrfAPolicy, V6Policy: vrfAPolicy, VRFName: vrfName}) // Expected prefixes defaultWant := aftpf.GeneratePrefixes(t, aftpf.GeneratePrefixesParams{V4Prefixes: []string{matchPrefixAft1, matchPrefixAft2}, V6Prefixes: nil, PfxCount: pfxCount}) - vrfWant := aftpf.GeneratePrefixes(t, aftpf.GeneratePrefixesParams{V4Prefixes: []string{matchPrefixAft1}, V6Prefixes: nil, PfxCount: pfxCount}) + // POLICY-PREFIX-SET-VRF-A admits 100.64.1.0/24, not the DEFAULT + // policy's 198.51.100.0/24 (which the negative check below excludes). + vrfWant := aftpf.GeneratePrefixes(t, aftpf.GeneratePrefixesParams{V4Prefixes: []string{matchVrfPfx1}, V6Prefixes: nil, PfxCount: pfxCount}) // Collector-1 (DEFAULT) collector1 := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) - // Collector-2 (VRF-A) - collector2 := aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) + // Collector-2: prefixes remain scoped to VRF-A. The session helper uses + // DEFAULT for Cisco's global NHGs/NHs, and VRF-A for other vendors. + // Shared forwarding objects are not leaked prefixes; the route-isolation + // checks below still examine only this collector's VRF-A prefix tables. + collector2 := aftcache.NewAFTStreamSessionForNetworkInstance(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut, vrfName) + defer func() { + if t.Failed() { + logVRFNextHopDiagnostics(t, dut, collector2, matchVrfPfx1) + } + }() + t.Logf("AFT per-NI collectors created UTC=%s DEFAULT=%+v VRF-A=%+v", time.Now().UTC().Format(time.RFC3339Nano), collector1.Progress(), collector2.Progress()) // Initial sync validation t.Log("Validating initial filtered AFT state") defaultStop := aftcache.InitialSyncStoppingCondition(t, dut, defaultWant, map[string]bool{atePort1.IPv4: true}, nil) vrfStop := aftcache.InitialSyncStoppingCondition(t, dut, vrfWant, map[string]bool{atePort2.IPv4: true}, nil) + checkVRF := vrfStop.PeriodicFunc + vrfStop.PeriodicFunc = func(session *aftcache.AFTStreamSession) (bool, error) { + t.Logf("AFT VRF-A readiness UTC=%s stream=%+v (CLIENT buffer, not DUT queue)", time.Now().UTC().Format(time.RFC3339Nano), session.Progress()) + return checkVRF(session) + } aftpf.RunCollector(t, aftpf.RunCollectorParams{Ctx: ctx, Collector: collector1, Stop: defaultStop, Timeout: subscriptionWait}) aftpf.RunCollector(t, aftpf.RunCollectorParams{Ctx: ctx, Collector: collector2, Stop: vrfStop, Timeout: subscriptionWait}) defaultAFT, err := collector1.ToAFT(t, dut) @@ -1226,7 +1816,7 @@ func testPerNIFiltering(t *testing.T, dut *ondatra.DUTDevice) { }) // Change VRF-A policy to MATCH-ALL t.Log("Changing VRF-A policy to POLICY-MATCH-ALL") - aftpf.ConfigureGlobalFilterPolicies(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: matchAllPolicy, V6Policy: matchAllPolicy, VRFName: vrfName}) + configureGlobalFilterPoliciesWithDiagnostics(t, dut, filterClient, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: matchAllPolicy, V6Policy: matchAllPolicy, VRFName: vrfName}) // Collector1 should remain stable defaultAFTAfter, err := collector1.ToAFT(t, dut) if err != nil { @@ -1238,7 +1828,7 @@ func testPerNIFiltering(t *testing.T, dut *ondatra.DUTDevice) { // Collector 2's stream, so re-establish the subscription and validate the // full set of VRF-A prefixes after SYNC on the new stream. t.Log("Re-establishing Collector2 subscription after the VRF-A filter policy change") - collector2 = reestablishAFTSession(ctx, t, dut) + collector2 = reestablishAFTSession(ctx, t, dut, vrfName) // Collector2 should now receive all VRF-A routes within 60 seconds. t.Log("Waiting for Collector2 to receive all VRF-A routes") wantAllVRF := []string{matchPrefixAft1, matchVrfPfx1, matchVrfPfx3, matchVrfPfx2} @@ -1298,7 +1888,7 @@ func waitForPrefixesPresent(ctx context.Context, t *testing.T, dut *ondatra.DUTD t.Helper() wantPrefixes := aftpf.GeneratePrefixes(t, aftpf.GeneratePrefixesParams{V4Prefixes: prefixes, V6Prefixes: nil, PfxCount: pfxCount}) stoppingCondition := aftcache.InitialSyncStoppingCondition(t, dut, wantPrefixes, map[string]bool{nextHop: true}, nil) - session.ListenUntil(ctx, t, timeout, stoppingCondition) + session.ListenUntilWithInterval(ctx, t, timeout, policyChangeCheckInterval, stoppingCondition) } // reestablishAFTSession dials a new gNMI client and returns a fresh AFT stream @@ -1307,7 +1897,8 @@ func waitForPrefixesPresent(ctx context.Context, t *testing.T, dut *ondatra.DUTD // previous session's stream may therefore already be closed, and continuing to // listen on it would fail instead of validating the new filter behaviour, so // the verification is always performed on a re-established subscription. -func reestablishAFTSession(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice) *aftcache.AFTStreamSession { +// The constructor preserves the prefix NI and Cisco's DEFAULT NHG/NH scope. +func reestablishAFTSession(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, networkInstance string) *aftcache.AFTStreamSession { t.Helper() - return aftcache.NewAFTStreamSession(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut) + return aftcache.NewAFTStreamSessionForNetworkInstance(ctx, t, aftpf.GnmiClientSession(t, dut, aftpf.PrefixesParams{Ctx: ctx}), dut, networkInstance) } diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/metadata.textproto b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/metadata.textproto index c4c2a22efa3..c6f21b555d2 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/metadata.textproto +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/metadata.textproto @@ -5,6 +5,7 @@ uuid: "0475e688-c645-43ef-a50c-6ed1f3606ed8" plan_id: "AFT-6.3" description: "AFT Prefix Filtering Resilience" testbed: TESTBED_DUT_ATE_2LINKS + platform_exceptions: { platform: { vendor: ARISTA @@ -16,3 +17,12 @@ platform_exceptions: { retain_gnmi_cfg_after_reboot: true } } + +platform_exceptions: { + platform: { + vendor: CISCO + } + deviations: { + ipv4_missing_enabled: true + } +} diff --git a/internal/aft_prefix_filtering/aft_prefix_filtering_service.go b/internal/aft_prefix_filtering/aft_prefix_filtering_service.go index f6d6c481977..5ed371620ec 100644 --- a/internal/aft_prefix_filtering/aft_prefix_filtering_service.go +++ b/internal/aft_prefix_filtering/aft_prefix_filtering_service.go @@ -21,8 +21,12 @@ package aft_prefix_filtering_service import ( "context" + "encoding/json" "flag" "fmt" + "regexp" + "sort" + "strconv" "strings" "sync" "testing" @@ -39,8 +43,12 @@ import ( "github.com/openconfig/ondatra/gnmi" "github.com/openconfig/ondatra/gnmi/oc" "github.com/openconfig/ondatra/netutil" + "github.com/openconfig/testt" "github.com/openconfig/ygnmi/ygnmi" "github.com/openconfig/ygot/ygot" + "google.golang.org/grpc" + "google.golang.org/grpc/peer" + "google.golang.org/grpc/status" ) const ( @@ -106,10 +114,12 @@ var ( } // Local variables for the AFT prefix-filtering service - debugNotifications = flag.Bool("debug_notifications", true, "Enable full AFT notification recording") - gnmiOnce sync.Once - gnmiClient gpb.GNMIClient - gnmiErr error + debugNotifications = flag.Bool("debug_notifications", true, "Enable full AFT notification recording") + gnmiOnce sync.Once + gnmiClient gpb.GNMIClient + gnmiErr error + gnmiClientCreatedAt time.Time + ciscoBGPPrefixCounts = regexp.MustCompile(`(?i)([0-9][0-9,]*)\s+accepted prefixes,\s*([0-9][0-9,]*)\s+are bestpaths`) ) // PrefixesParams contains the prefixes expected to be present in the AFT cache. @@ -152,16 +162,21 @@ func VerifyPrefixesAbsent(t *testing.T, cfg PrefixesParams) { // RunCollectorParams contains the parameters required to execute an AFT collector. // It runs until the supplied stopping condition is satisfied. type RunCollectorParams struct { - Ctx context.Context - Collector *aftcache.AFTStreamSession - Stop aftcache.PeriodicHook - Timeout time.Duration + Ctx context.Context + Collector *aftcache.AFTStreamSession + Stop aftcache.PeriodicHook + Timeout time.Duration + CheckInterval time.Duration // Zero retains the default AFT cache interval. } // RunCollector starts the AFT stream collector. // It blocks until the supplied stopping condition is satisfied or the collector times out. func RunCollector(t *testing.T, cfg RunCollectorParams) { t.Helper() + if cfg.CheckInterval > 0 { + cfg.Collector.ListenUntilWithInterval(cfg.Ctx, t, cfg.Timeout, cfg.CheckInterval, cfg.Stop) + return + } cfg.Collector.ListenUntil(cfg.Ctx, t, cfg.Timeout, cfg.Stop) } @@ -199,6 +214,12 @@ type RemovePrefixFromPrefixSetParams struct { // RemovePrefixFromPrefixSet removes the specified prefix entry from the given routing-policy prefix-set on the DUT. func RemovePrefixFromPrefixSet(t *testing.T, dut *ondatra.DUTDevice, cfg RemovePrefixFromPrefixSetParams) { t.Helper() + if dut.Vendor() == ondatra.CISCO { + // XR cannot mutate entries inside the native prefix-set bag. + ReplacePrefixSetMembers(t, dut, cfg.PrefixSetName, nil, + []PrefixSetMember{{Prefix: cfg.Prefix, MaskRange: cfg.MaskRange}}) + return + } batch := &gnmi.SetBatch{} gnmi.BatchDelete(batch, gnmi.OC().RoutingPolicy().DefinedSets().PrefixSet(cfg.PrefixSetName).Prefix(cfg.Prefix, cfg.MaskRange).Config()) batch.Set(t, dut) @@ -257,7 +278,9 @@ func configureDUTInterface(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.Set } i.GetOrCreateEthernet() i4 := i.GetOrCreateSubinterface(0).GetOrCreateIpv4() - i4.Enabled = ygot.Bool(true) + if dut.Vendor() != ondatra.CISCO || (deviations.InterfaceEnabled(dut) && !deviations.IPv4MissingEnabled(dut)) { + i4.Enabled = ygot.Bool(true) + } av4 := i4.GetOrCreateAddress(a.IPv4) av4.PrefixLength = ygot.Uint8(a.IPv4Len) i6 := i.GetOrCreateSubinterface(0).GetOrCreateIpv6() @@ -287,7 +310,7 @@ func ConfigureATE(t *testing.T, ate *ondatra.ATEDevice) (gosnappi.Config, []stri // (1.5M IPv4 and 500k IPv6). func ConfigureBGP(t *testing.T, dut *ondatra.DUTDevice, batch *gnmi.SetBatch, ni *oc.NetworkInstance) { t.Helper() - configureBGPInstance(t, ni, DUTPort1.IPv4, []bgpNeighborSpec{ + configureBGPInstance(t, dut, ni, DUTPort1.IPv4, []bgpNeighborSpec{ {address: ATEPort1.IPv4, peerGroup: bgpV4PeerGroup, v4: true}, {address: ATEPort2.IPv6, peerGroup: bgpV6PeerGroup, v4: false}, }) @@ -327,7 +350,7 @@ func ConfigureScaleBGP(t *testing.T, dut *ondatra.DUTDevice, cfg BGPParams) { t.Helper() v4PeerGroup := fmt.Sprintf("%s-%s", bgpV4PeerGroup, cfg.NetworkInstance.GetName()) v6PeerGroup := fmt.Sprintf("%s-%s", bgpV6PeerGroup, cfg.NetworkInstance.GetName()) - configureBGPInstance(t, cfg.NetworkInstance, cfg.RouterID, []bgpNeighborSpec{ + configureBGPInstance(t, dut, cfg.NetworkInstance, cfg.RouterID, []bgpNeighborSpec{ {address: cfg.V4Neighbor, peerGroup: v4PeerGroup, v4: true}, {address: cfg.V6Neighbor, peerGroup: v6PeerGroup, v4: false}, }) @@ -347,7 +370,7 @@ type bgpNeighborSpec struct { // configureBGPInstance configures a complete eBGP protocol instance in the given network instance. // It applies the supplied router ID and single-AFI neighbors with the accept-all import/export policy. -func configureBGPInstance(t *testing.T, ni *oc.NetworkInstance, routerID string, neighbors []bgpNeighborSpec) { +func configureBGPInstance(t *testing.T, dut *ondatra.DUTDevice, ni *oc.NetworkInstance, routerID string, neighbors []bgpNeighborSpec) { t.Helper() if ni == nil { t.Fatalf("Network Instance is not configured") @@ -364,11 +387,23 @@ func configureBGPInstance(t *testing.T, ni *oc.NetworkInstance, routerID string, nb := bgp.GetOrCreateNeighbor(n.address) nb.PeerAs = ygot.Uint32(ateAS) nb.Enabled = ygot.Bool(true) - nb.GetOrCreateAfiSafi(oc.BgpTypes_AFI_SAFI_TYPE_IPV4_UNICAST).Enabled = ygot.Bool(n.v4) - nb.GetOrCreateAfiSafi(oc.BgpTypes_AFI_SAFI_TYPE_IPV6_UNICAST).Enabled = ygot.Bool(!n.v4) - ap := nb.GetOrCreateApplyPolicy() - ap.ImportPolicy = []string{PolicyMatchAll} - ap.ExportPolicy = []string{PolicyMatchAll} + v4 := nb.GetOrCreateAfiSafi(oc.BgpTypes_AFI_SAFI_TYPE_IPV4_UNICAST) + v4.Enabled = ygot.Bool(n.v4) + v6 := nb.GetOrCreateAfiSafi(oc.BgpTypes_AFI_SAFI_TYPE_IPV6_UNICAST) + v6.Enabled = ygot.Bool(!n.v4) + if dut.Vendor() != ondatra.CISCO || deviations.RoutePolicyUnderAFIUnsupported(dut) { + ap := nb.GetOrCreateApplyPolicy() + ap.ImportPolicy = []string{PolicyMatchAll} + ap.ExportPolicy = []string{PolicyMatchAll} + } else if n.v4 { + ap := v4.GetOrCreateApplyPolicy() + ap.ImportPolicy = []string{PolicyMatchAll} + ap.ExportPolicy = []string{PolicyMatchAll} + } else { + ap := v6.GetOrCreateApplyPolicy() + ap.ImportPolicy = []string{PolicyMatchAll} + ap.ExportPolicy = []string{PolicyMatchAll} + } } } @@ -472,16 +507,31 @@ type BGPConvergenceParams struct { V6RouteCount uint32 } -// AwaitScaleBGPConvergence waits for both eBGP sessions to establish and for -// the expected IPv4 and IPv6 prefix counts to be installed. It records -// failures with t.Errorf so the caller can continue. +// AwaitScaleBGPConvergence waits for both eBGP sessions and route readiness. +// DEFAULT and other vendors use the per-neighbor RIB-installed counter. Cisco +// non-default VRFs instead use native BGP accepted/best-path counts together +// with BGP-origin AFT summary counts; see awaitCiscoVRFBGPConvergence. +// Existing installed-counter checks record failures with t.Errorf. A failed +// Cisco VRF prerequisite stops the test before its AFT filtering checks. func AwaitScaleBGPConvergence(t *testing.T, dut *ondatra.DUTDevice, cfg BGPConvergenceParams) { t.Helper() + sessionsEstablished := true if err := awaitBGPEstablished(t, dut, cfg.NetworkInstance, cfg.V4Neighbor); err != nil { t.Errorf("%v", err) + sessionsEstablished = false } if err := awaitBGPEstablished(t, dut, cfg.NetworkInstance, cfg.V6Neighbor); err != nil { t.Errorf("%v", err) + sessionsEstablished = false + } + if dut.Vendor() == ondatra.CISCO && cfg.NetworkInstance != deviations.DefaultNetworkInstance(dut) { + if !sessionsEstablished { + t.Fatalf("Cisco VRF %s is not ready: both BGP sessions must be ESTABLISHED", cfg.NetworkInstance) + } + if err := awaitCiscoVRFBGPConvergence(t, dut, cfg); err != nil { + t.Fatalf("Cisco VRF route readiness failed: %v", err) + } + return } if err := awaitBGPPrefixCount(t, dut, cfg.NetworkInstance, cfg.V4Neighbor, oc.BgpTypes_AFI_SAFI_TYPE_IPV4_UNICAST, cfg.V4RouteCount); err != nil { t.Errorf("%v", err) @@ -525,6 +575,119 @@ func awaitBGPPrefixCount(t *testing.T, dut *ondatra.DUTDevice, niName, neighbor return nil } +// awaitCiscoVRFBGPConvergence avoids a RIB counter that IOS XR implements only +// for the default routing table. Querying prefixes/state/installed under a VRF +// does not make that per-peer RIB counter available, even when routes forward. +// This restriction is in RIB's infosrc counter DB/query (rib_server_infosrc_db.c +// and rib_server_edm.c), not a missing BGP VRF address-family prerequisite. +// Native BGP accepted/best-path counts do support VRFs, but bestpaths alone do +// not prove RIB installation: another protocol can win RIB selection. Therefore +// require both the per-peer BGP counts and the VRF's BGP-origin AFT population. +// The summary is aggregate, not per-peer or per-prefix. These tests have one +// advertising peer per AF in each VRF, and their later prefix/filter checks +// remain necessary to validate route identity and isolation. +func awaitCiscoVRFBGPConvergence(t *testing.T, dut *ondatra.DUTDevice, cfg BGPConvergenceParams) error { + t.Helper() + if deviations.AFTSummaryOCUnsupported(dut) { + return fmt.Errorf("%s needs supported BGP-origin AFT summaries to verify forwarding readiness", cfg.NetworkInstance) + } + client, err := ygnmi.NewClient(dut.RawAPIs().GNMI(t), ygnmi.WithTarget(dut.ID())) + if err != nil { + return fmt.Errorf("create VRF AFT summary client: %w", err) + } + summaries := gnmi.OC().NetworkInstance(cfg.NetworkInstance).Afts().AftSummaries() + checks := []struct { + family string + neighbor string + want uint64 + query ygnmi.SingletonQuery[uint64] + }{ + {"ipv4", cfg.V4Neighbor, uint64(cfg.V4RouteCount), summaries.Ipv4Unicast().Protocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP).Counters().AftEntries().State()}, + {"ipv6", cfg.V6Neighbor, uint64(cfg.V6RouteCount), summaries.Ipv6Unicast().Protocol(oc.PolicyTypes_INSTALL_PROTOCOL_TYPE_BGP).Counters().AftEntries().State()}, + } + // Share one deadline across both AFs, rather than spending a full timeout + // sequentially on each. The explicit deadline also avoids the runner's + // context.WithTimeout multiplier extending this setup wait. + ctx, cancel := context.WithDeadline(t.Context(), time.Now().Add(bgpConvergenceWait)) + defer cancel() + ticker := time.NewTicker(30 * time.Second) + defer ticker.Stop() + lastOutputs := make([]string, len(checks)) + lastCounts := make([]string, len(checks)) + converged := false + defer func() { + if !converged { + for i, check := range checks { + t.Logf("Last %s %s readiness: %s\nLast native neighbor output for %s:\n%s", cfg.NetworkInstance, check.family, lastCounts[i], check.neighbor, lastOutputs[i]) + } + } + }() + t.Logf("Checking Cisco VRF %s using native BGP counts and BGP-origin AFT summaries, not the default-only per-peer RIB-installed counter", cfg.NetworkInstance) + for { + ready := true + for i, check := range checks { + // Match the named BGP instance used by ConfigureScaleBGP; querying + // an unnamed instance could return unrelated or missing peers. + command := fmt.Sprintf("show bgp instance BGP vrf %s %s unicast neighbors %s", cfg.NetworkInstance, check.family, check.neighbor) + readCtx, readCancel := context.WithDeadline(ctx, time.Now().Add(30*time.Second)) + response, err := dut.RawAPIs().CLI(t).RunCommand(readCtx, command) + readCancel() + if err != nil { + return fmt.Errorf("%s: %w", command, err) + } + output := response.Output() + if lastOutputs[i] == "" { + t.Logf("Initial output from %q:\n%s", command, output) + } + lastOutputs[i] = output + accepted, bestpaths, err := parseCiscoBGPPrefixCounts(output) + if err != nil { + return fmt.Errorf("%s: %w", command, err) + } + lastCounts[i] = fmt.Sprintf("accepted=%d, bestpaths=%d, BGP AFT entries=not read yet, want >= %d", accepted, bestpaths, check.want) + readCtx, readCancel = context.WithDeadline(ctx, time.Now().Add(30*time.Second)) + value, err := ygnmi.Lookup(readCtx, client, check.query) + readCancel() + if err != nil { + return fmt.Errorf("read %s %s BGP AFT summary: %w", cfg.NetworkInstance, check.family, err) + } + entries, present := value.Val() + lastCounts[i] = fmt.Sprintf("accepted=%d, bestpaths=%d, BGP AFT entries=%d (present=%t), want >= %d", accepted, bestpaths, entries, present, check.want) + t.Logf("VRF %s %s neighbor %s readiness: %s", cfg.NetworkInstance, check.family, check.neighbor, lastCounts[i]) + if accepted < check.want || bestpaths < check.want || !present || entries < check.want { + ready = false + } + } + if ready { + converged = true + return nil + } + select { + case <-ctx.Done(): + return fmt.Errorf("%s native BGP/AFT counts did not converge within %v: %w", cfg.NetworkInstance, bgpConvergenceWait, ctx.Err()) + case <-ticker.C: + } + } +} + +// parseCiscoBGPPrefixCounts requires an unambiguous native counter line. +// Missing/changed CLI syntax must fail explicitly, not silently become zero. +func parseCiscoBGPPrefixCounts(output string) (uint64, uint64, error) { + matches := ciscoBGPPrefixCounts.FindAllStringSubmatch(output, -1) + if len(matches) != 1 { + return 0, 0, fmt.Errorf("expected one 'accepted prefixes, ... are bestpaths' counter line, got %d", len(matches)) + } + accepted, err := strconv.ParseUint(strings.ReplaceAll(matches[0][1], ",", ""), 10, 64) + if err != nil { + return 0, 0, fmt.Errorf("parse accepted prefix count: %w", err) + } + bestpaths, err := strconv.ParseUint(strings.ReplaceAll(matches[0][2], ",", ""), 10, 64) + if err != nil { + return 0, 0, fmt.Errorf("parse best-path count: %w", err) + } + return accepted, bestpaths, nil +} + // DialGNMI returns a shared raw gNMI client, dialing it once and caching it // for reuse. It is needed for raw paths that are not present in the OC tree. func DialGNMI(t *testing.T, dut *ondatra.DUTDevice) (gpb.GNMIClient, error) { @@ -536,10 +699,67 @@ func DialGNMI(t *testing.T, dut *ondatra.DUTDevice) (gpb.GNMIClient, error) { return } gnmiClient = client + gnmiClientCreatedAt = time.Now().UTC() }) + t.Logf("AFT shared gNMI client: UTC=%s createdUTC=%s client=%p DUT=%s dialError=%v (reused across calls, including reboot)", + time.Now().UTC().Format(time.RFC3339Nano), gnmiClientCreatedAt.Format(time.RFC3339Nano), gnmiClient, dut.Name(), gnmiErr) return gnmiClient, gnmiErr } +// globalFilterPolicyPath builds the raw OpenConfig path for an AFT +// global-filter policy leaf. Raw paths are required until the generated +// ondatra OC bindings include the openconfig-aft-global-filter augment. +func globalFilterPolicyPath(niName, leaf string) *gpb.Path { + return &gpb.Path{ + Origin: "openconfig", + Elem: []*gpb.PathElem{ + {Name: "network-instances"}, + {Name: "network-instance", Key: map[string]string{"name": niName}}, + {Name: "afts"}, + {Name: "global-filter"}, + {Name: "config"}, + {Name: leaf}, + }, + } +} + +// ConfigEncoding selects XR's required configuration encoding while retaining +// the original JSON encoding on other vendors. +func ConfigEncoding(dut *ondatra.DUTDevice) gpb.Encoding { + if dut.Vendor() == ondatra.CISCO { + return gpb.Encoding_JSON_IETF + } + return gpb.Encoding_JSON +} + +// globalFilterPolicyUpdates builds updates for the non-empty policy names in +// cfg. Sending both updates in one SetRequest applies dual-stack policy changes +// atomically from the client's perspective. +func globalFilterPolicyUpdates(cfg ConfigureGlobalFilterPoliciesParams) ([]*gpb.Update, error) { + var updates []*gpb.Update + if cfg.V4Policy != "" { + policyJSON, err := json.Marshal(cfg.V4Policy) + if err != nil { + return nil, fmt.Errorf("marshal IPv4 global-filter policy %q: %w", cfg.V4Policy, err) + } + updates = append(updates, &gpb.Update{ + Path: globalFilterPolicyPath(cfg.VRFName, "ipv4-policy"), + Val: &gpb.TypedValue{Value: &gpb.TypedValue_JsonIetfVal{JsonIetfVal: policyJSON}}, + }) + } + if cfg.V6Policy != "" { + policyJSON, err := json.Marshal(cfg.V6Policy) + if err != nil { + return nil, fmt.Errorf("marshal IPv6 global-filter policy %q: %w", cfg.V6Policy, err) + } + updates = append(updates, &gpb.Update{ + Path: globalFilterPolicyPath(cfg.VRFName, "ipv6-policy"), + Val: &gpb.TypedValue{Value: &gpb.TypedValue_JsonIetfVal{JsonIetfVal: policyJSON}}, + }) + } + return updates, nil +} + // AFTDeleteGlobalFilter deletes both global-filter policy leaves for the given network-instance. func AFTDeleteGlobalFilter(t *testing.T, dut *ondatra.DUTDevice, niName string) error { t.Helper() @@ -550,18 +770,19 @@ func AFTDeleteGlobalFilter(t *testing.T, dut *ondatra.DUTDevice, niName string) return nil } } - // For vendors that support the OpenConfig afts/global-filter augment - // (openconfig-aft-global-filter.yang, added in openconfig/public models - // 3.3.0), delete the IPv4/IPv6 filter policy leaves through the typed OC - // path API. The generated ondatra `oc` bindings do not yet contain the - // GlobalFilter container, so the calls below are commented out; uncomment - // them once the bindings are regenerated against openconfig/public >= 3.3.0. - // batch := &gnmi.SetBatch{} - // gnmi.BatchDelete(batch, gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter().Ipv4Policy().Config()) - // gnmi.BatchDelete(batch, gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter().Ipv6Policy().Config()) - // batch.Set(t, dut) - // return nil - return fmt.Errorf("AFT global filter deletion is expected to be supported on %s, but no OpenConfig implementation is available", dut.Vendor()) + + client, err := DialGNMI(t, dut) + if err != nil { + return err + } + _, err = client.Set(context.Background(), &gpb.SetRequest{Delete: []*gpb.Path{ + globalFilterPolicyPath(niName, "ipv4-policy"), + globalFilterPolicyPath(niName, "ipv6-policy"), + }}) + if err != nil { + return fmt.Errorf("failed to delete AFT global-filter policies from network-instance %q: %w", niName, err) + } + return nil } // ConfigureToStoreRunningGNMIConfig configures the DUT to persist gNMI @@ -696,6 +917,13 @@ type ConfigureGlobalFilterPoliciesParams struct { V4Policy string V6Policy string VRFName string + // Client optionally supplies a caller-owned connection. This lets reboot + // tests replace their client without resetting the package-wide cached one. + Client gpb.GNMIClient + ClientCreatedAt time.Time + // OnSetFailure optionally collects diagnostics before the original Set + // error fails the test. It must not retry the Set or change its result. + OnSetFailure func(error) } // ConfigureGlobalFilterPolicies configures AFT global-filter policies for the specified network-instance. @@ -709,22 +937,42 @@ func ConfigureGlobalFilterPolicies(t *testing.T, dut *ondatra.DUTDevice, cfg Con } } - // For vendors that support the OpenConfig afts/global-filter augment - // (openconfig-aft-global-filter.yang, added in openconfig/public models - // 3.3.0), attach the IPv4/IPv6 filter policies through the typed OC path - // API. The generated ondatra `oc` bindings do not yet contain the - // GlobalFilter container, so the calls below are commented out; uncomment - // them once the bindings are regenerated against openconfig/public >= 3.3.0. - // batch := &gnmi.SetBatch{} - // if cfg.V4Policy != "" { - // gnmi.BatchUpdate(batch, gnmi.OC().NetworkInstance(cfg.VRFName).Afts().GlobalFilter().Ipv4Policy().Config(), cfg.V4Policy) - // } - // if cfg.V6Policy != "" { - // gnmi.BatchUpdate(batch, gnmi.OC().NetworkInstance(cfg.VRFName).Afts().GlobalFilter().Ipv6Policy().Config(), cfg.V6Policy) - // } - // batch.Set(t, dut) - // return - t.Fatalf("AFT global filter policy is expected to be supported on %s, but no OpenConfig implementation is available", dut.Vendor()) + updates, err := globalFilterPolicyUpdates(cfg) + if err != nil { + t.Fatalf("Failed to encode AFT global-filter policies: %v", err) + } + if len(updates) == 0 { + return + } + if dut.Vendor() != ondatra.CISCO { + // JSON_IETF addresses XR's encoding restriction. Preserve JSON on + // other vendors rather than changing their required capabilities. + for _, update := range updates { + update.Val = &gpb.TypedValue{Value: &gpb.TypedValue_JsonVal{JsonVal: update.GetVal().GetJsonIetfVal()}} + } + } + client, createdAt := cfg.Client, cfg.ClientCreatedAt + if client == nil { + client, err = DialGNMI(t, dut) + if err != nil { + t.Fatalf("Failed to dial gNMI while configuring AFT global-filter policies: %v", err) + } + createdAt = gnmiClientCreatedAt + } + request := &gpb.SetRequest{Update: updates} + t.Logf("Sending AFT global-filter gNMI SetRequest: %v", request) + started := time.Now() + t.Logf("AFT global-filter Set start: UTC=%s NI=%s client=%p createdUTC=%s", started.UTC().Format(time.RFC3339Nano), cfg.VRFName, client, createdAt.UTC().Format(time.RFC3339Nano)) + var remote peer.Peer + response, err := client.Set(context.Background(), request, grpc.Peer(&remote)) + t.Logf("AFT global-filter Set end: UTC=%s NI=%s elapsed=%v peer=%v status=%s error=%v response=%v", + time.Now().UTC().Format(time.RFC3339Nano), cfg.VRFName, time.Since(started), remote.Addr, status.Code(err), err, response) + if err != nil { + if cfg.OnSetFailure != nil { + cfg.OnSetFailure(err) + } + t.Fatalf("Failed to configure AFT global-filter policies in network-instance %q: %v", cfg.VRFName, err) + } } // NetworkInstanceStaticRouteParams holds the parameters required to @@ -808,9 +1056,87 @@ type AddPrefixToPrefixSetParams struct { MaskRange string } +// PrefixSetMember identifies one entry in a routing-policy prefix set. +type PrefixSetMember struct { + Prefix string + MaskRange string +} + +func prefixSetMembers(ps *oc.RoutingPolicy_DefinedSets_PrefixSet) []string { + var members []string + if ps != nil { + for key := range ps.Prefix { + members = append(members, fmt.Sprintf("%s [%s]", key.IpPrefix, key.MasklengthRange)) + } + } + sort.Strings(members) + return members +} + +// ReplacePrefixSetMembers reads the current set, changes its membership, and +// replaces the whole prefix-set in one gNMI operation. The IOS XR image used +// by AFT-6.4 rejected an individual-entry replacement under /prefixes. This +// operation preserves unrelated members during add, remove, and swap stages. +func ReplacePrefixSetMembers(t *testing.T, dut *ondatra.DUTDevice, name string, add, remove []PrefixSetMember) { + t.Helper() + path := gnmi.OC().RoutingPolicy().DefinedSets().PrefixSet(name).Config() + current := gnmi.Get[*oc.RoutingPolicy_DefinedSets_PrefixSet](t, dut, path) + if current.GetName() != "" && current.GetName() != name { + t.Fatalf("Read prefix-set %q but received name %q", name, current.GetName()) + } + current.Name = ygot.String(name) + t.Logf("Prefix-set %s before mutation: %v", name, prefixSetMembers(current)) + for _, member := range remove { + if current.GetPrefix(member.Prefix, member.MaskRange) == nil { + t.Fatalf("Cannot remove absent prefix-set member %s [%s] from %s", member.Prefix, member.MaskRange, name) + } + current.DeletePrefix(member.Prefix, member.MaskRange) + } + for _, member := range add { + if current.GetPrefix(member.Prefix, member.MaskRange) != nil { + t.Fatalf("Cannot add existing prefix-set member %s [%s] to %s", member.Prefix, member.MaskRange, name) + } + current.GetOrCreatePrefix(member.Prefix, member.MaskRange) + } + want := prefixSetMembers(current) + batch := &gnmi.SetBatch{} + gnmi.BatchReplace(batch, path, current) + t.Logf("Prefix-set %s whole-set replace request (want members %v): %s", name, want, batch.String()) + setFailure := testt.CaptureFatal(t, func(tb testing.TB) { + t.Logf("Prefix-set %s whole-set replace response: %v", name, batch.Set(tb, dut)) + }) + if setFailure != nil { + t.Logf("Prefix-set %s whole-set replace failed: %s", name, *setFailure) + } + var readback *oc.RoutingPolicy_DefinedSets_PrefixSet + readFailure := testt.CaptureFatal(t, func(tb testing.TB) { + readback = gnmi.Get[*oc.RoutingPolicy_DefinedSets_PrefixSet](tb, dut, path) + }) + if readFailure != nil { + t.Logf("Prefix-set %s post-Set readback failed: %s", name, *readFailure) + } else { + t.Logf("Prefix-set %s post-Set readback members: %v", name, prefixSetMembers(readback)) + } + if setFailure != nil { + t.Fatalf("Whole-set replace for prefix-set %s failed: %s", name, *setFailure) + } + if readFailure != nil { + t.Fatalf("Whole-set replace for prefix-set %s succeeded, but readback failed: %s", name, *readFailure) + } + if got := prefixSetMembers(readback); strings.Join(got, "\n") != strings.Join(want, "\n") { + t.Fatalf("Prefix-set %s post-Set members got %v, want %v", name, got, want) + } +} + // AddPrefixToPrefixSet adds a prefix entry to an existing routing policy prefix-set. func AddPrefixToPrefixSet(t *testing.T, dut *ondatra.DUTDevice, cfg AddPrefixToPrefixSetParams) { t.Helper() + if dut.Vendor() == ondatra.CISCO { + // XR requires replacing the complete native prefix-set bag. + ReplacePrefixSetMembers(t, dut, cfg.PrefixSetName, + []PrefixSetMember{{Prefix: cfg.Prefix, MaskRange: cfg.MaskRange}}, nil) + return + } batch := &gnmi.SetBatch{} path := gnmi.OC().RoutingPolicy().DefinedSets().PrefixSet(cfg.PrefixSetName).Prefix(cfg.Prefix, cfg.MaskRange) entry := &oc.RoutingPolicy_DefinedSets_PrefixSet_Prefix{ diff --git a/internal/telemetry/aftcache/aft_cache.go b/internal/telemetry/aftcache/aft_cache.go index 7dfe7193042..2fc1b07d714 100644 --- a/internal/telemetry/aftcache/aft_cache.go +++ b/internal/telemetry/aftcache/aft_cache.go @@ -26,6 +26,7 @@ import ( "slices" "strconv" "strings" + "sync/atomic" "testing" "time" @@ -106,17 +107,34 @@ var unusedPaths = []string{ } func subscriptionPaths(dut *ondatra.DUTDevice) map[string][]string { - defaultNetworkInstance := deviations.DefaultNetworkInstance(dut) + return subscriptionPathsForNetworkInstance(dut, deviations.DefaultNetworkInstance(dut)) +} + +// nextHopNetworkInstanceName separates the route's NI from the NI holding its +// forwarding objects. Cisco AFT NHGs and NHs are globally scoped in DEFAULT, +// including those referenced by prefixes in non-default VRFs. Other vendors +// retain the existing per-NI scope for all AFT objects. +func nextHopNetworkInstanceName(dut *ondatra.DUTDevice, prefixNetworkInstance string) string { + if dut.Vendor() == ondatra.CISCO { + return deviations.DefaultNetworkInstance(dut) + } + return prefixNetworkInstance +} + +// Use the same path mapping for the request and cache traversal: collecting +// global NHGs/NHs is insufficient if ToAFT still searches under the route's NI. +func subscriptionPathsForNetworkInstance(dut *ondatra.DUTDevice, networkInstance string) map[string][]string { + nextHopNI := nextHopNetworkInstanceName(dut, networkInstance) return map[string][]string{ "prefix": { - fmt.Sprintf("network-instances/network-instance[name=%s]/afts/ipv4-unicast/ipv4-entry", defaultNetworkInstance), - fmt.Sprintf("network-instances/network-instance[name=%s]/afts/ipv6-unicast/ipv6-entry", defaultNetworkInstance), + fmt.Sprintf("network-instances/network-instance[name=%s]/afts/ipv4-unicast/ipv4-entry", networkInstance), + fmt.Sprintf("network-instances/network-instance[name=%s]/afts/ipv6-unicast/ipv6-entry", networkInstance), }, "nhg": { - fmt.Sprintf("network-instances/network-instance[name=%s]/afts/next-hop-groups/next-hop-group", defaultNetworkInstance), + fmt.Sprintf("network-instances/network-instance[name=%s]/afts/next-hop-groups/next-hop-group", nextHopNI), }, "nh": { - fmt.Sprintf("network-instances/network-instance[name=%s]/afts/next-hops/next-hop", defaultNetworkInstance), + fmt.Sprintf("network-instances/network-instance[name=%s]/afts/next-hops/next-hop", nextHopNI), }, } } @@ -200,6 +218,8 @@ type aftNextHopGroupConditional struct { // aftNextHop represents an AFT next hop. type aftNextHop struct { + // Index identifies the received NH entry for targeted raw telemetry diagnostics. + Index uint64 // IntfName contains the interface name of the next hop. IntfName string // IP contains the IP address of the next hop. @@ -208,6 +228,9 @@ type aftNextHop struct { LSPName string } +// NextHop exposes the resolved IP address and interface to opt-in validators. +type NextHop = aftNextHop + // generateCacheTraversalPaths converts a map of subscription paths to a map of cache traversal paths. // For example: // input: @@ -287,7 +310,7 @@ func (ss *AFTStreamSession) ToAFT(t *testing.T, dut *ondatra.DUTDevice) (*AFTDat } return nil } - cacheTraversalPaths, err := generateCacheTraversalPaths(subscriptionPaths(dut)) + cacheTraversalPaths, err := generateCacheTraversalPaths(subscriptionPathsForNetworkInstance(dut, ss.networkInstanceName(dut))) if err != nil { return nil, err } @@ -430,6 +453,14 @@ func (c *aftCache) addAFTNotification(n *gnmipb.SubscribeResponse) error { if update == nil { return fmt.Errorf("SubscribeResponse missing Update: %v", n) } + // Require an explicit delete path instead of deleting the notification + // prefix through an empty relative path. Check here so every collector, + // including those without notification hooks, validates this format. + for i, path := range update.GetDelete() { + if len(path.GetElem()) == 0 && len(path.GetElement()) == 0 { + return fmt.Errorf("delete path at index %d is empty; expected an explicit path relative to the notification prefix. Notification: %v", i, update) + } + } if update.GetPrefix() == nil { update.Prefix = &gnmipb.Path{} } @@ -468,18 +499,40 @@ type aftSubscriptionResponse struct { err error } +type streamCounters struct { + received atomic.Uint64 + processed atomic.Uint64 + syncReceived atomic.Uint64 + processingSince atomic.Int64 + lastReceived atomic.Int64 + receiveFailure atomic.Pointer[aftSubscriptionResponse] +} + +// StreamProgress reports how far a subscription has progressed without traversing its cache. +type StreamProgress struct { + ReceivedResponses uint64 + ProcessedResponses uint64 + SyncReceived uint64 + Buffered int + BufferCapacity int + ProcessingFor time.Duration + LastReceivedAt time.Time + ReceiveError string + StreamStopped bool +} + // aftSubscribe subscribes to a gNMI client and creates a channel to read from the subscription // stream asynchronously. // TODO: Split out the watching logic into a blocking function. // This is somewhat bad practice. I was surprised that this function spawned a goroutine. // Functions should not return if they spawn goroutines. (Assume the caller will cancel the context // on return.) -func aftSubscribe(ctx context.Context, t *testing.T, c gnmipb.GNMIClient, dut *ondatra.DUTDevice) <-chan *aftSubscriptionResponse { +func aftSubscribe(ctx context.Context, t *testing.T, c gnmipb.GNMIClient, dut *ondatra.DUTDevice, counters *streamCounters, networkInstance string) (<-chan *aftSubscriptionResponse, <-chan struct{}) { sub, err := c.Subscribe(ctx) if err != nil { t.Fatalf("error in Subscribe(): %v", err) } - req, err := checkForRoutesRequest(dut) + req, err := checkForRoutesRequestForNetworkInstance(dut, networkInstance) if err != nil { t.Fatalf("error preparing subscribe request: %v", err) } @@ -489,44 +542,96 @@ func aftSubscribe(ctx context.Context, t *testing.T, c gnmipb.GNMIClient, dut *o } buffer := make(chan *aftSubscriptionResponse, aftBufferSize) + stopped := make(chan struct{}) // Don't need to close the buffer channel. We don't need that signal, the stream stopping logic is with the consumer. go func() { + defer close(stopped) for { n, err := sub.Recv() - resp := &aftSubscriptionResponse{n, err} + if err != nil { + counters.receiveFailure.Store(&aftSubscriptionResponse{err: err}) + if ctx.Err() == nil { + // Record the client queue at the actual receive failure, + // before its error waits behind any buffered notifications. + // This is not the DUT's MDT destination queue. + t.Logf("DUT %s NI=%s AFT stream receive failed UTC=%s: %v; CLIENT buffered notifications=%d/%d received=%d processed=%d (not the DUT queue)", + dut.Name(), networkInstance, time.Now().UTC().Format(time.RFC3339Nano), err, + len(buffer), cap(buffer), counters.received.Load(), counters.processed.Load()) + select { + case buffer <- &aftSubscriptionResponse{err: err}: + case <-ctx.Done(): + } + } + return + } + counters.received.Add(1) + counters.lastReceived.Store(time.Now().UnixNano()) + if n.GetSyncResponse() { + counters.syncReceived.Add(1) + t.Logf("DUT %s gNMI AFT SyncResponse arrived; buffered notifications=%d/%d", + dut.Name(), len(buffer), cap(buffer)) + } + resp := &aftSubscriptionResponse{notification: n} select { case buffer <- resp: case <-ctx.Done(): - // Context cancellation also makes sub.Recv() return an error. We rely on the out channel's - // buffer filling up or random chance (select picks a random available case) to hit - // <-ctx.Done() and return. return } } }() - return buffer + return buffer, stopped } // AFTStreamSession represents a single gNMI AFT streaming session and cached AFT state. It contains // a subscription that can be used across multiple calls to ListenUntil(). type AFTStreamSession struct { + networkInstance string buffer <-chan *aftSubscriptionResponse + streamStopped <-chan struct{} + counters *streamCounters Cache *aftCache start time.Time notifications []*gnmipb.SubscribeResponse missingPrefixes map[string]bool failingNHPrefixes map[string]bool + syncResponses int debugMode bool } func (ss *AFTStreamSession) sessionPrefix() string { - return fmt.Sprintf("[%s-%d]", ss.Cache.target, ss.start.UnixNano()) + return fmt.Sprintf("[%s-%s-%d]", ss.Cache.target, ss.networkInstance, ss.start.UnixNano()) +} + +func (ss *AFTStreamSession) networkInstanceName(dut *ondatra.DUTDevice) string { + if ss.networkInstance != "" { + return ss.networkInstance + } + return deviations.DefaultNetworkInstance(dut) } // NewAFTStreamSession constructs an AFTStreamSession. It subscribes to a given gNMI client. func NewAFTStreamSession(ctx context.Context, t *testing.T, c gnmipb.GNMIClient, dut *ondatra.DUTDevice) *AFTStreamSession { + return NewAFTStreamSessionForNetworkInstance(ctx, t, c, dut, deviations.DefaultNetworkInstance(dut)) +} + +// NewAFTStreamSessionForNetworkInstance scopes prefix subscriptions and cache +// traversal to the selected NI. On Cisco, NHGs/NHs are collected and traversed +// in DEFAULT instead; this does not subscribe to DEFAULT prefixes or relax +// per-VRF prefix isolation. Recreated sessions use the same mapping. +func NewAFTStreamSessionForNetworkInstance(ctx context.Context, t *testing.T, c gnmipb.GNMIClient, dut *ondatra.DUTDevice, networkInstance string) *AFTStreamSession { + t.Helper() + if networkInstance == "" { + t.Fatal("AFT subscription requires a nonempty network instance") + } + t.Logf("AFT collector scope: vendor=%s prefixNI=%s nextHopGroupNI=%s nextHopNI=%s", + dut.Vendor(), networkInstance, nextHopNetworkInstanceName(dut, networkInstance), nextHopNetworkInstanceName(dut, networkInstance)) + counters := &streamCounters{} + buffer, stopped := aftSubscribe(ctx, t, c, dut, counters, networkInstance) return &AFTStreamSession{ - buffer: aftSubscribe(ctx, t, c, dut), + networkInstance: networkInstance, + buffer: buffer, + streamStopped: stopped, + counters: counters, Cache: newAFTCache(dut.Name()), notifications: []*gnmipb.SubscribeResponse{}, missingPrefixes: make(map[string]bool), @@ -535,6 +640,42 @@ func NewAFTStreamSession(ctx context.Context, t *testing.T, c gnmipb.GNMIClient, } } +// WaitStopped waits for the subscription receive loop to exit after its context is cancelled. +func (ss *AFTStreamSession) WaitStopped(ctx context.Context) error { + select { + case <-ss.streamStopped: + return nil + case <-ctx.Done(): + return ctx.Err() + } +} + +// Progress returns cheap, concurrency-safe stream counters for diagnostics. +func (ss *AFTStreamSession) Progress() StreamProgress { + p := StreamProgress{ + ReceivedResponses: ss.counters.received.Load(), + ProcessedResponses: ss.counters.processed.Load(), + SyncReceived: ss.counters.syncReceived.Load(), + Buffered: len(ss.buffer), + BufferCapacity: cap(ss.buffer), + } + if since := ss.counters.processingSince.Load(); since != 0 { + p.ProcessingFor = time.Since(time.Unix(0, since)) + } + if received := ss.counters.lastReceived.Load(); received != 0 { + p.LastReceivedAt = time.Unix(0, received).UTC() + } + if failure := ss.counters.receiveFailure.Load(); failure != nil { + p.ReceiveError = failure.err.Error() + } + select { + case <-ss.streamStopped: + p.StreamStopped = true + default: + } + return p +} + // WithDebug enables the storage of all gNMI notifications for debugging purposes. // Warning: This will significantly increase memory usage. func (ss *AFTStreamSession) WithDebug() *AFTStreamSession { @@ -605,21 +746,44 @@ func (ss *AFTStreamSession) ListenUntil(ctx context.Context, t *testing.T, timeo ss.ListenUntilPreUpdateHook(ctx, t, timeout, nil, stoppingCondition) } +// ListenUntilWithInterval is like ListenUntil, but checks the stopping condition +// at the requested interval. Other sessions retain the default interval. +func (ss *AFTStreamSession) ListenUntilWithInterval(ctx context.Context, t *testing.T, timeout, checkInterval time.Duration, stoppingCondition PeriodicHook) { + t.Helper() + ss.listenUntilPreUpdateHookWithInterval(ctx, t, timeout, checkInterval, nil, stoppingCondition) +} + // ListenUntilPreUpdateHook updates AFT with notifications from a gNMI client in streaming mode, // and stops listening based on the stoppingCondition hook. It also runs the preUpdateHooks before updating the AFT cache. func (ss *AFTStreamSession) ListenUntilPreUpdateHook(ctx context.Context, t *testing.T, timeout time.Duration, preUpdateHooks []NotificationHook, stoppingCondition PeriodicHook) { t.Helper() + ss.listenUntilPreUpdateHookWithInterval(ctx, t, timeout, periodicInterval, preUpdateHooks, stoppingCondition) +} + +// ListenUntilPreUpdateHookWithInterval is like ListenUntilPreUpdateHook, but +// checks the stopping condition at the requested interval. +func (ss *AFTStreamSession) ListenUntilPreUpdateHookWithInterval(ctx context.Context, t *testing.T, timeout, checkInterval time.Duration, preUpdateHooks []NotificationHook, stoppingCondition PeriodicHook) { + t.Helper() + ss.listenUntilPreUpdateHookWithInterval(ctx, t, timeout, checkInterval, preUpdateHooks, stoppingCondition) +} + +func (ss *AFTStreamSession) listenUntilPreUpdateHookWithInterval(ctx context.Context, t *testing.T, timeout, checkInterval time.Duration, preUpdateHooks []NotificationHook, stoppingCondition PeriodicHook) { + t.Helper() + if checkInterval <= 0 { + t.Fatalf("AFT stopping-condition check interval must be positive, got %v", checkInterval) + } ss.start = time.Now() defer ss.loggingFinal(t) // Print stats one more time before exiting even in case of fatal error. phs := []PeriodicHook{loggingPeriodicHook(t, ss.start), stoppingCondition} - ss.listenUntil(ctx, t, timeout, preUpdateHooks, phs) + ss.listenUntil(ctx, t, timeout, checkInterval, preUpdateHooks, phs) } -func (ss *AFTStreamSession) listenUntil(ctx context.Context, t *testing.T, timeout time.Duration, preUpdateHooks []NotificationHook, periodicHooks []PeriodicHook) { +func (ss *AFTStreamSession) listenUntil(ctx context.Context, t *testing.T, timeout, checkInterval time.Duration, preUpdateHooks []NotificationHook, periodicHooks []PeriodicHook) { t.Helper() ctx, cancel := context.WithTimeout(ctx, timeout) defer cancel() - periodicTicker := time.NewTicker(periodicInterval) + periodicTicker := time.NewTicker(checkInterval) + defer periodicTicker.Stop() for { select { case resp := <-ss.buffer: @@ -631,6 +795,7 @@ func (ss *AFTStreamSession) listenUntil(ctx context.Context, t *testing.T, timeo if ss.debugMode { ss.notifications = append(ss.notifications, resp.notification) } + ss.counters.processingSince.Store(time.Now().UnixNano()) for _, hook := range preUpdateHooks { err := hook.NotificationFunc(ss.Cache, resp.notification) if err != nil { @@ -638,6 +803,8 @@ func (ss *AFTStreamSession) listenUntil(ctx context.Context, t *testing.T, timeo } } err := ss.Cache.addAFTNotification(resp.notification) + ss.counters.processingSince.Store(0) + ss.counters.processed.Add(1) switch { case errors.Is(err, cache.ErrStale): // TODO: The log line below is currently commented out to avoid stale log messages. Uncomment it later if the additional logging is required. @@ -646,18 +813,38 @@ func (ss *AFTStreamSession) listenUntil(ctx context.Context, t *testing.T, timeo case err != nil: t.Fatalf("error updating AFT cache with response %v: %v", resp.notification, err) } + if resp.notification.GetSyncResponse() { + ss.syncResponses++ + t.Logf("%s gNMI AFT SyncResponse processed after %v; buffered notifications=%d/%d", + ss.sessionPrefix(), time.Since(ss.start).Truncate(time.Millisecond), + len(ss.buffer), cap(ss.buffer)) + } case <-periodicTicker.C: s := time.Now() + t.Logf("%s periodic check start: syncResponsesProcessed=%d buffered notifications=%d/%d", + ss.sessionPrefix(), ss.syncResponses, len(ss.buffer), cap(ss.buffer)) + stop := false for _, hook := range periodicHooks { + hookStart := time.Now() done, err := hook.PeriodicFunc(ss) + t.Logf("%s periodic hook %q took %v; buffered notifications=%d/%d", + ss.sessionPrefix(), hook.Description, + time.Since(hookStart).Truncate(time.Millisecond), len(ss.buffer), cap(ss.buffer)) if err != nil { t.Fatalf("error in PeriodicHook %q: %v", hook.Description, err) } if done { - return + stop = true + break } } d := time.Since(s) + t.Logf("%s periodic check end: duration=%v syncResponsesProcessed=%d buffered notifications=%d/%d", + ss.sessionPrefix(), d.Truncate(time.Millisecond), ss.syncResponses, + len(ss.buffer), cap(ss.buffer)) + if stop { + return + } if d > periodicDeadline { // If periodic hooks take too long, we can't guarantee we can catch up on processing // notifications and the test may slow down artificially. The periodic hooks should be @@ -700,7 +887,31 @@ func DeletionStoppingCondition(t *testing.T, dut *ondatra.DUTDevice, wantDeleteP // InitialSyncStoppingCondition returns a PeriodicHook which can be used to check if all wanted prefixes have been received with given next hop IP addresses. func InitialSyncStoppingCondition(t *testing.T, dut *ondatra.DUTDevice, wantPrefixes, wantIPV4NHs, wantIPV6NHs map[string]bool) PeriodicHook { - nhFailCount := 0 + return initialSyncStoppingCondition(t, dut, wantPrefixes, nil, wantIPV4NHs, wantIPV6NHs, nil) +} + +// InitialSyncStoppingConditionWithAbsentPrefixes also waits for unwanted +// prefixes to disappear. It checks presence, absence, and next hops against +// the same cache snapshot, avoiding another expensive AFT conversion. +func InitialSyncStoppingConditionWithAbsentPrefixes(t *testing.T, dut *ondatra.DUTDevice, wantPrefixes, absentPrefixes, wantIPV4NHs, wantIPV6NHs map[string]bool) PeriodicHook { + return initialSyncStoppingCondition(t, dut, wantPrefixes, absentPrefixes, wantIPV4NHs, wantIPV6NHs, nil) +} + +// InitialSyncStoppingConditionWithNextHopValidator checks all expected prefixes +// and their resolved next hops using a caller-supplied identity check. It does +// not modify telemetry or change the exact-IP behavior of existing callers. +// The validator must be safe for concurrent collectors and must not mutate NHs. +func InitialSyncStoppingConditionWithNextHopValidator(t *testing.T, dut *ondatra.DUTDevice, wantPrefixes map[string]bool, validate func(string, []*NextHop) (bool, error)) PeriodicHook { + t.Helper() + if validate == nil { + t.Fatal("next-hop validator is required") + } + return initialSyncStoppingCondition(t, dut, wantPrefixes, nil, nil, nil, validate) +} + +func initialSyncStoppingCondition(t *testing.T, dut *ondatra.DUTDevice, wantPrefixes, absentPrefixes, wantIPV4NHs, wantIPV6NHs map[string]bool, validate func(string, []*NextHop) (bool, error)) PeriodicHook { + // Two collectors may share the hook. Keep the retry counter race-free. + var nhFailCount atomic.Int32 const nhFailLimit = 20 const maxSamplePrefixes = 10 logDuration := func(start time.Time, stage, prefix string) { @@ -710,6 +921,12 @@ func InitialSyncStoppingCondition(t *testing.T, dut *ondatra.DUTDevice, wantPref Description: "Initial sync stopping condition", PeriodicFunc: func(ss *AFTStreamSession) (bool, error) { prefix := ss.sessionPrefix() + // With only negative expectations, an empty pre-sync cache would + // otherwise satisfy the condition before any DUT state arrives. + if len(wantPrefixes) == 0 && len(absentPrefixes) > 0 && ss.syncResponses == 0 { + t.Logf("%s Waiting for initial AFT SyncResponse before checking absent prefixes.", prefix) + return false, nil + } start := time.Now() a, err := ss.ToAFT(t, dut) logDuration(start, "Convert cache to AFT", prefix) @@ -746,6 +963,12 @@ func InitialSyncStoppingCondition(t *testing.T, dut *ondatra.DUTDevice, wantPref return false, nil } ss.missingPrefixes = make(map[string]bool) // All prefixes are present, so clear the list. + for p := range absentPrefixes { + if _, ok := gotPrefixes[p]; ok { + t.Logf("%s Unwanted prefix %s is still present; waiting for its streamed deletion.", prefix, p) + return false, nil + } + } // Check next hops. checkNHStart := time.Now() @@ -754,6 +977,24 @@ func InitialSyncStoppingCondition(t *testing.T, dut *ondatra.DUTDevice, wantPref ss.failingNHPrefixes = make(map[string]bool) for p := range wantPrefixes { resolved, err := a.resolveRoute(p) + if validate != nil { + if err != nil && !errors.Is(err, ErrNotExist) { + return false, fmt.Errorf("error resolving next hops for prefix %v: %w", p, err) + } + valid := false + if err == nil { + valid, err = validate(p, resolved) + if err != nil { + return false, fmt.Errorf("next-hop validation for %s: %w", p, err) + } + } + if valid { + nCorrect++ + } else { + ss.failingNHPrefixes[p] = true + } + continue + } got := map[string]bool{} switch { // Skip the check if NH is not found, retry on next periodic hook. Report missing NHs after timeout. @@ -786,8 +1027,7 @@ func InitialSyncStoppingCondition(t *testing.T, dut *ondatra.DUTDevice, wantPref t.Logf("%s Got %d of %d correct NH so far.", prefix, nCorrect, nPrefixes) logDuration(checkNHStart, "Check Next Hops", prefix) if nCorrect != nPrefixes { - nhFailCount++ - if nhFailCount == nhFailLimit { + if nhFailCount.Add(1) == nhFailLimit { return false, fmt.Errorf("after %d tries, next hop validation still fails", nhFailLimit) } t.Logf("%s %d prefixes with failing next hop validation", prefix, len(ss.failingNHPrefixes)) @@ -925,7 +1165,7 @@ func parseNH(n *gnmipb.Notification) (uint64, *aftNextHop, error) { } // Loop over update, looking for ip-address, lsp-name, and/or interface name. found := false - nh := &aftNextHop{} + nh := &aftNextHop{Index: nhID} for _, u := range updates { path, err = ygot.PathToSchemaPath(u.Path) switch { @@ -1060,6 +1300,10 @@ func parsePrefix(t *testing.T, n *gnmipb.Notification, sessionPrefix string) (st } func checkForRoutesRequest(dut *ondatra.DUTDevice) (*gnmipb.SubscribeRequest, error) { + return checkForRoutesRequestForNetworkInstance(dut, deviations.DefaultNetworkInstance(dut)) +} + +func checkForRoutesRequestForNetworkInstance(dut *ondatra.DUTDevice, networkInstance string) (*gnmipb.SubscribeRequest, error) { subReq := &gnmipb.SubscribeRequest_Subscribe{ Subscribe: &gnmipb.SubscriptionList{ Mode: gnmipb.SubscriptionList_STREAM, @@ -1067,7 +1311,7 @@ func checkForRoutesRequest(dut *ondatra.DUTDevice) (*gnmipb.SubscribeRequest, er Encoding: gnmipb.Encoding_PROTO, }, } - for _, paths := range subscriptionPaths(dut) { + for _, paths := range subscriptionPathsForNetworkInstance(dut, networkInstance) { for _, p := range paths { pp, err := ygot.StringToPath(p, ygot.StructuredPath) if err != nil { @@ -1150,6 +1394,9 @@ type NotificationExpectation struct { AddPrefix string DeletePrefix string NotificationWait time.Duration + // SinceIndex excludes notifications already processed before a mutation. + // It is an index in AFTStreamSession.Notifications and requires WithDebug. + SinceIndex int } // WaitForNotification returns a PeriodicHook that waits for the expected update @@ -1165,7 +1412,10 @@ func WaitForNotification(t *testing.T, cfg NotificationExpectation) PeriodicHook updateFound: cfg.AddPrefix == "", deleteFound: cfg.DeletePrefix == "", } - for _, resp := range ss.Notifications() { + if cfg.SinceIndex < 0 || cfg.SinceIndex > len(ss.Notifications()) { + return false, fmt.Errorf("invalid notification checkpoint %d (processed %d)", cfg.SinceIndex, len(ss.Notifications())) + } + for _, resp := range ss.Notifications()[cfg.SinceIndex:] { update := resp.GetUpdate() if update == nil { // Ignore SubscribeResponse messages that do not contain an Update, @@ -1190,57 +1440,32 @@ func WaitForNotification(t *testing.T, cfg NotificationExpectation) PeriodicHook } } -// pathHasPrefixKey returns true if path contains the supplied route-prefix key. -func pathHasPrefixKey(path *gnmipb.Path, prefix string) bool { - if path == nil { - return false - } +// entryPathHasPrefix looks for an exact AFT entry key in a notification path. +func entryPathHasPrefix(path *gnmipb.Path, prefix string) bool { for _, elem := range path.GetElem() { - for _, keyVal := range elem.GetKey() { - if keyVal == prefix { - return true - } + if (elem.GetName() == "ipv4-entry" || elem.GetName() == "ipv6-entry") && elem.GetKey()["prefix"] == prefix { + return true } } return false } -// hasUpdateNotification returns true if the specified prefix appears in the -// notification prefix or in any UPDATE path. For atomic containers in -// Subscribe and Get responses, gNMI section 3.5.2.5 permits a server to place -// the list key in Notification.Prefix and make the UPDATE path relative to -// that prefix. Checking both locations handles this encoding as well as -// notifications with the key directly in an UPDATE path. +// hasUpdateNotification matches an entry key in either the notification prefix +// or the relative update path. func hasUpdateNotification(update *gnmipb.Notification, prefix string) bool { - if len(update.GetUpdate()) == 0 { - return false - } - if pathHasPrefixKey(update.GetPrefix(), prefix) { - return true - } for _, upd := range update.GetUpdate() { - if pathHasPrefixKey(upd.GetPath(), prefix) { + if entryPathHasPrefix(update.GetPrefix(), prefix) || entryPathHasPrefix(upd.GetPath(), prefix) { return true } } return false } -// hasDeleteNotification returns true if the specified prefix appears in the -// notification prefix or in any DELETE path. For atomic containers in -// Subscribe and Get responses, gNMI section 3.5.2.5 permits a server to place -// the list key in Notification.Prefix and make the DELETE path relative to -// that prefix. Checking both locations handles this encoding as well as -// notifications with the key directly in a DELETE path. +// hasDeleteNotification matches an entry key in either the notification prefix +// or the relative delete path. func hasDeleteNotification(update *gnmipb.Notification, prefix string) bool { - if len(update.GetDelete()) == 0 { - return false - } - if pathHasPrefixKey(update.GetPrefix(), prefix) { - return true - } for _, del := range update.GetDelete() { - if pathHasPrefixKey(del, prefix) { + if entryPathHasPrefix(update.GetPrefix(), prefix) || entryPathHasPrefix(del, prefix) { return true } } From d62cbb14b51468d233c1fbeedbc96c13fdbb8e09 Mon Sep 17 00:00:00 2001 From: hmod2001 <59151407+hmod2001@users.noreply.github.com> Date: Fri, 20 Nov 2026 14:58:17 -0500 Subject: [PATCH 2/3] Use generated Ondatra AFT global-filter bindings Pin the public OpenConfig 5.11 global-filter regeneration and use typed policy configuration, deletion and CONFIG/STATE reads. Preserve batching, Cisco JSON_IETF encoding and fresh reconnect transports. Include the wire-contract check and Jenkins reproduction instructions. AFT-6.1 passed all seven groups and four prefix variants from the prepared public checkout; all four AFT binaries compiled. --- docs/aft-typed-global-filter-bindings.md | 159 +++++ .../aft_diagnostics_test.go | 3 +- .../afts_prefix_filtering_test.go | 154 ++-- .../afts_prefix_filtering_resilience_test.go | 116 +-- go.mod | 139 ++-- go.sum | 663 ++++++++++++++++++ .../typed_global_filter_test.go | 116 +++ .../aft_prefix_filtering_service.go | 105 +-- 8 files changed, 1145 insertions(+), 310 deletions(-) create mode 100644 docs/aft-typed-global-filter-bindings.md create mode 100644 internal/aft_binding_contract/typed_global_filter_test.go diff --git a/docs/aft-typed-global-filter-bindings.md b/docs/aft-typed-global-filter-bindings.md new file mode 100644 index 00000000000..af9cd42d26d --- /dev/null +++ b/docs/aft-typed-global-filter-bindings.md @@ -0,0 +1,159 @@ +# AFT global-filter tests with typed Ondatra bindings + +The AFT-6.1 through AFT-6.4 tests use generated paths beneath +`gnmi.OC().NetworkInstance(name).Afts().GlobalFilter()` for policy updates, +deletion, expected-error checks, and CONFIG/STATE readback. Dual-stack changes +remain batched into one Set RPC, and Cisco uses JSON_IETF string encoding. +Readback explicitly uses gNMI Get, including the fresh transport after reboot. +Resilience readback uses four typed leaf Get requests in place of two paired +requests. + +Direct subscriptions remain where a test must inspect notification deletion +or atomic flags. Their global-filter paths come from generated state queries. +These protocol assertions are separate from manual policy configuration paths. + +## Dependency + +Upstream Ondatra v0.15.1 uses OpenConfig models v5.11.0 but omits +`openconfig-aft-global-filter.yang` from its generator inputs. The pinned public +B4FireX Ondatra fork adds this input and regenerates the OC bindings from that +release. It is a regeneration of the public release, rather than an unchanged +upstream release. See [openconfig/ondatra#159](https://github.com/openconfig/ondatra/issues/159). + +The replacement module in `go.mod` is public and immutable. No private Git +credentials or sibling checkout are required. Go 1.26.3 is required by Ondatra. + +The checkout selects the dependency automatically: + +```go +require github.com/openconfig/ondatra v0.15.1 + +replace github.com/openconfig/ondatra => github.com/b4firex/ondatra v0.0.0-20261120174419-ff486025d4fa +``` + +`gnmi/generate.sh` is a source-generation script in the Ondatra repository. +Featureprofiles consumes the generated Go packages through this module pin; +it does not execute that script while building or running a test. The added +generator input is `public/release/models/aft/openconfig-aft-global-filter.yang`. +Updating only the model version at line 21 does not add that input. + +## Jenkins / FireX + +The bindings update is part of the checkout through `go.mod` and `go.sum`. +The build must preserve that replacement and use Go 1.26.3 or later; no manual +binding regeneration or private Ondatra checkout is needed. + +Select this PR from `b4firex/featureprofiles`. The B4 Jenkins `Public` repository +choice defaults to `openconfig/featureprofiles`, so a PR number in the B4FireX +fork also requires selecting the fork's repository URL. In an existing B4 +runlist, the source settings are: + +```yaml +internal_test: false +test_repo_url: https://github.com/b4firex/featureprofiles.git +``` + +Select this PR's number with the job's Test PR setting. Clear the old internal +`test_branch` and any explicit test revision, and leave the job's Test branch +and Test commit hash fields empty. Keep the existing AFT package selections +and the intended testbed/image profile. A source selection that still points +to the internal branch will not exercise these changes. + +Use the established B4 SIM runtime profile described below when reproducing +the local simulator results. The module pin supplies the bindings; the normal +runner still supplies the simulator, binding/testbed files, service access and +traffic-generator setup. + +## Running a checkout + +Use Go 1.26.3 or later, a C toolchain and libpcap development headers. The +normal binding and testbed files must describe the selected DUT and ATE. Go +fetches the pinned public dependency; do not edit module replacements locally +or copy generated bindings into the checkout. + +The following checks do not reserve or configure a testbed: + +```bash +go list -mod=readonly -m github.com/openconfig/ondatra +go test -mod=readonly ./internal/aft_binding_contract +``` + +For example, with absolute paths to a prepared binding, testbed and output +directory, AFT-6.3 can be selected with: + +```bash +go test -mod=readonly -v -count=1 -timeout=60m \ + ./feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience \ + -args -binding="$AFT_BINDING" -testbed="$AFT_TESTBED" \ + -outputs_dir="$AFT_OUTPUTS" +``` + +That command executes a device reboot. Run each suite on an appropriate owned +testbed. The package selections and overall deadlines used for validation are: + +| Suite | Directory under `feature/afts/filtered_streaming/otg_tests/` | Go timeout | +|---|---|---| +| AFT-6.1 | `afts_prefix_filtering` | `90m` | +| AFT-6.2 | `afts_prefix_filtering_dualstack` | `30m` | +| AFT-6.3 | `afts_prefix_filtering_resilience` | `60m` | +| AFT-6.4 | `afts_prefix_filtering_dynamic` | `60m` | + +### Matching the simulator results + +The passing local runs built a separate runtime copy with the B4 SIM overlay +`internal/fptest/otg_patch.go` and its gomonkey v2.14.0 dependency. That overlay +adds a ten-second delay before traffic and doubles `context.WithTimeout` +deadlines process-wide. It is not included in this featureprofiles change. +A plain `go test` invocation above therefore does not reproduce that entire +runtime profile by itself. Matching the prior SIM results requires the same +runner-provided overlay, image and OTG version, with a fresh SIM for each suite. +The SIM runs also supplied +`-deviation_ate_port_link_state_operations_unsupported`. + +Before declaring the SIM ready, enable and commit both test interfaces, verify +native Up/Up state after OTG setup, and repeat that check immediately before +test launch. BGP establishment and expected route counts must also succeed. +The previously observed startup failures occurred before AFT feature checks; +the bindings pin cannot repair interface or BGP readiness. + +The dependency is reproducible from the checkout. AFT-6.1 was rerun from the +prepared public checkout with this profile. The table below distinguishes +that run, the existing AFT-6.2/6.3 evidence, and the AFT-6.4 runtime gap. + +## Validation + +`go test ./internal/aft_binding_contract` checks the generated wire paths, +single-RPC dual-stack updates, JSON_IETF values, target preservation, +CONFIG/STATE Get types, atomic filter-plus-policy deletion, and gRPC error +propagation without connecting to a DUT or ATE. + +All four suites compiled from the prepared public checkout with the public +dependency pin. The typed wire-contract test and a runtime check of the +existing SIM context multiplier passed. The Go entrypoint used by the B4 +Jenkins pipeline also resolved the pinned public dependency successfully with +Go 1.26.3. + +Simulator runs using matching generated binding and AFT source produced: + +| Suite | Result | +|---|---| +| AFT-6.1 | PASS on 2026-11-20 from the prepared public checkout: all seven groups and four prefix-policy variants | +| AFT-6.2 | Existing PASS: dual-stack filtering and policy-swap withdrawal | +| AFT-6.3 | Existing PASS: cold reboot, scale, and per-network-instance filtering | +| AFT-6.4 | Rerun pending; the initial attempt stopped during BGP setup | + +AFT-6.3 verified matching typed CONFIG/STATE values before and after a real +cold reboot, with approximately 152 seconds of reboot recovery. All six scale +cases passed. The simulator environment used IOS XR 26.4.1.34I and OTG +1.48.0-5. Its existing harness overlay supplies a ten-second pre-traffic delay +and doubles context deadlines. These results qualify that environment; they +are simulator validation. Only AFT-6.1 was rerun from the prepared public +checkout; AFT-6.2/6.3 retain their previous passing evidence with matching AFT +and generated binding source. A Jenkins build has not been submitted for this +publication. + +The change also carries the AFT test fixes required by the tested source: +policy-transition/readback checks, refreshed connections after reboot, +per-network-instance setup, dynamic neighbor resolution, failure diagnostics, +and AFT cache deletion handling. AFT-6.4 still needs simulator validation after +verified interface and BGP bring-up. diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/aft_diagnostics_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/aft_diagnostics_test.go index 96fc4a094e3..6ed59d09747 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/aft_diagnostics_test.go +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/aft_diagnostics_test.go @@ -167,8 +167,9 @@ func (d aftFilterDiagnostics) capture(t *testing.T, dut *ondatra.DUTDevice, stag t.Logf("AFT diagnostic global-filter Get unavailable: %v", err) return } - path := globalFilterPolicyPath(d.networkInstance, "ipv4-policy") + path := globalFilterPolicyPath(t, d.networkInstance, "ipv4-policy") path.Elem = path.Elem[:len(path.Elem)-2] // Read config and state together. + path.Origin = "" // The request prefix supplies the OpenConfig origin. readCtx, readCancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second)) defer readCancel() request := &gpb.GetRequest{ diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/afts_prefix_filtering_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/afts_prefix_filtering_test.go index 1ad2afe4eeb..8b268197f29 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/afts_prefix_filtering_test.go +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering/afts_prefix_filtering_test.go @@ -28,6 +28,7 @@ import ( "github.com/openconfig/ondatra" "github.com/openconfig/ondatra/gnmi" "github.com/openconfig/ondatra/gnmi/oc" + "github.com/openconfig/ygnmi/ygnmi" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) @@ -266,21 +267,24 @@ func policyDefinitionPath(policyName string) *gpb.Path { } } -// globalFilterPolicyPath builds the gNMI path for an afts/global-filter policy -// config leaf (ipv4-policy or ipv6-policy) under a network-instance. -// TODO: replace this raw gNMI path with the ygot-generated OC path once the -// afts/global-filter schema is supported in featureprofiles. -func globalFilterPolicyPath(niName, leaf string) *gpb.Path { - return &gpb.Path{ - Elem: []*gpb.PathElem{ - {Name: "network-instances"}, - {Name: "network-instance", Key: map[string]string{"name": niName}}, - {Name: "afts"}, - {Name: "global-filter"}, - {Name: "config"}, - {Name: leaf}, - }, +// globalFilterPolicyPath resolves a generated OC policy path for wire-level diagnostics. +func globalFilterPolicyPath(t *testing.T, niName, leaf string) *gpb.Path { + t.Helper() + filter := gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter() + var query ygnmi.ConfigQuery[string] + switch leaf { + case "ipv4-policy": + query = filter.Ipv4Policy().Config() + case "ipv6-policy": + query = filter.Ipv6Policy().Config() + default: + t.Fatalf("Unknown global-filter policy leaf %q", leaf) + } + path, _, err := ygnmi.ResolvePath(query.PathStruct()) + if err != nil { + t.Fatalf("Resolve generated global-filter path: %v", err) } + return path } // statementPrefixSetConfigPath builds the gNMI path for the match-prefix-set @@ -314,34 +318,24 @@ func policyStatementPath(policyName, statementName string) *gpb.Path { func setGlobalFilterExpectCode(t *testing.T, dut *ondatra.DUTDevice, niName, v4Policy, v6Policy string, wantCode codes.Code) error { t.Helper() - if deviations.AftsGlobalFilterPolicyOCUnsupported(dut) { - switch dut.Vendor() { - case ondatra.ARISTA: - t.Log("Skipping AFT global-filter negative check: unsupported on EOS") - return nil - } + if deviations.AftsGlobalFilterPolicyOCUnsupported(dut) && dut.Vendor() == ondatra.ARISTA { + t.Log("Skipping AFT global-filter negative check: unsupported on EOS") + return nil } - - client, err := dialGNMI(t, dut) + client, err := aftpf.TypedGNMIClient(t, dut, nil) if err != nil { return err } - var updates []*gpb.Update + filter := gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter() + batch := &ygnmi.SetBatch{} if v4Policy != "" { - updates = append(updates, &gpb.Update{ - Path: globalFilterPolicyPath(niName, "ipv4-policy"), - Val: policyStringValue(dut, v4Policy), - }) + ygnmi.BatchUpdate(batch, filter.Ipv4Policy().Config(), v4Policy) } if v6Policy != "" { - updates = append(updates, &gpb.Update{ - Path: globalFilterPolicyPath(niName, "ipv6-policy"), - Val: policyStringValue(dut, v6Policy), - }) + ygnmi.BatchUpdate(batch, filter.Ipv6Policy().Config(), v6Policy) } - req := &gpb.SetRequest{Update: updates} - t.Logf("Sending AFT global-filter negative-check gNMI SetRequest: %v", req) - _, setErr := client.Set(context.Background(), req) + t.Logf("Sending typed AFT global-filter negative-check Set batch: %s", batch) + _, setErr := batch.Set(context.Background(), client, ygnmi.WithEncoding(aftpf.ConfigEncoding(dut))) if setErr == nil { if wantCode == codes.OK { return nil @@ -382,47 +376,27 @@ func deletePolicyExpectCode(t *testing.T, dut *ondatra.DUTDevice, policyName str // readGlobalFilterPolicy checks the configured policy, not the streamed state. func readGlobalFilterPolicy(t *testing.T, dut *ondatra.DUTDevice, niName, leaf string) (string, error) { t.Helper() - client, err := dialGNMI(t, dut) + client, err := aftpf.TypedGNMIClient(t, dut, nil) if err != nil { return "", err } ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second) defer cancel() - resp, err := client.Get(ctx, &gpb.GetRequest{ - Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, - Path: []*gpb.Path{globalFilterPolicyPath(niName, leaf)}, - Type: gpb.GetRequest_CONFIG, - Encoding: aftpf.ConfigEncoding(dut), - }) + filter := gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter() + var query ygnmi.ConfigQuery[string] + switch leaf { + case "ipv4-policy": + query = filter.Ipv4Policy().Config() + case "ipv6-policy": + query = filter.Ipv6Policy().Config() + default: + return "", fmt.Errorf("unknown global-filter policy leaf %q", leaf) + } + value, err := ygnmi.Get(ctx, client, query, ygnmi.WithUseGet()) if err != nil { return "", fmt.Errorf("read global-filter %s: %w", leaf, err) } - for _, notification := range resp.GetNotification() { - for _, update := range notification.GetUpdate() { - if update.GetVal() == nil { - return "", fmt.Errorf("global-filter %s Get returned an empty update: %v", leaf, update) - } - var value any - switch typed := update.GetVal().GetValue().(type) { - case *gpb.TypedValue_JsonIetfVal: - if err := json.Unmarshal(typed.JsonIetfVal, &value); err != nil { - return "", fmt.Errorf("decode global-filter %s: %w", leaf, err) - } - case *gpb.TypedValue_JsonVal: - if err := json.Unmarshal(typed.JsonVal, &value); err != nil { - return "", fmt.Errorf("decode global-filter %s: %w", leaf, err) - } - case *gpb.TypedValue_StringVal: - value = typed.StringVal - default: - return "", fmt.Errorf("unexpected global-filter %s encoding %T", leaf, typed) - } - if policy, ok := globalFilterPolicyValue(value, leaf); ok { - return policy, nil - } - } - } - return "", fmt.Errorf("global-filter %s not found in Get response: %v", leaf, resp) + return value, nil } // globalFilterPolicyValue accepts either a leaf- or container-valued JSON_IETF Get. @@ -462,26 +436,20 @@ func deletePolicy(t *testing.T, dut *ondatra.DUTDevice, policyName string) error // policy-definition in a single atomic gNMI Set request. func deleteGlobalFilterAndPolicyAtomic(t *testing.T, dut *ondatra.DUTDevice, niName, policyName string) error { t.Helper() - if deviations.AftsGlobalFilterPolicyOCUnsupported(dut) { - switch dut.Vendor() { - case ondatra.ARISTA: - t.Log("Skipping atomic AFT global-filter + policy delete: unsupported on EOS") - return nil - } + if deviations.AftsGlobalFilterPolicyOCUnsupported(dut) && dut.Vendor() == ondatra.ARISTA { + t.Log("Skipping atomic AFT global-filter + policy delete: unsupported on EOS") + return nil } - - client, err := dialGNMI(t, dut) + client, err := aftpf.TypedGNMIClient(t, dut, nil) if err != nil { return err } - req := &gpb.SetRequest{ - Delete: []*gpb.Path{ - globalFilterPolicyPath(niName, "ipv4-policy"), - globalFilterPolicyPath(niName, "ipv6-policy"), - policyDefinitionPath(policyName), - }, - } - if _, err := client.Set(context.Background(), req); err != nil { + filter := gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter() + batch := &ygnmi.SetBatch{} + ygnmi.BatchDelete(batch, filter.Ipv4Policy().Config()) + ygnmi.BatchDelete(batch, filter.Ipv6Policy().Config()) + ygnmi.BatchDelete(batch, gnmi.OC().RoutingPolicy().PolicyDefinition(policyName).Config()) + if _, err := batch.Set(context.Background(), client); err != nil { return fmt.Errorf("atomic delete failed: %w", err) } return nil @@ -694,8 +662,8 @@ type rawAFTStream struct { // newRawAFTStream opens a raw STREAM ON_CHANGE subscription on // afts/global-filter/state, reading notifications in the background. -// TODO: replace this raw gNMI subscription with the ygot-generated OC path -// once the afts/global-filter schema is supported in featureprofiles. +// Its generated OC path selects the subtree; the direct subscription retains +// notification deletion paths and atomic flags for protocol assertions. func newRawAFTStream(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, niName string) (*rawAFTStream, error) { t.Helper() client, err := dialGNMI(t, dut) @@ -706,20 +674,22 @@ func newRawAFTStream(ctx context.Context, t *testing.T, dut *ondatra.DUTDevice, if err != nil { return nil, fmt.Errorf("subscribe() failed: %w", err) } + statePath, _, err := ygnmi.ResolvePath(gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter().Ipv4Policy().State().PathStruct()) + if err != nil { + return nil, fmt.Errorf("resolve generated global-filter state path: %v", err) + } + statePath.Elem = statePath.Elem[:len(statePath.Elem)-1] + prefixLength := len(statePath.Elem) - 2 req := &gpb.SubscribeRequest{Request: &gpb.SubscribeRequest_Subscribe{Subscribe: &gpb.SubscriptionList{ Mode: gpb.SubscriptionList_STREAM, Encoding: gpb.Encoding_PROTO, Prefix: &gpb.Path{ - Origin: "openconfig", + Origin: "openconfig", // ResolvePath returns elements; the transport supplies the origin. Target: dut.Name(), - Elem: []*gpb.PathElem{ - {Name: "network-instances"}, - {Name: "network-instance", Key: map[string]string{"name": niName}}, - {Name: "afts"}, - }, + Elem: statePath.Elem[:prefixLength], }, Subscription: []*gpb.Subscription{{ - Path: &gpb.Path{Elem: []*gpb.PathElem{{Name: "global-filter"}, {Name: "state"}}}, + Path: &gpb.Path{Elem: statePath.Elem[prefixLength:]}, Mode: gpb.SubscriptionMode_ON_CHANGE, }}, }}} diff --git a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/afts_prefix_filtering_resilience_test.go b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/afts_prefix_filtering_resilience_test.go index cea658cf1a0..cb9e82b92cc 100644 --- a/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/afts_prefix_filtering_resilience_test.go +++ b/feature/afts/filtered_streaming/otg_tests/afts_prefix_filtering_resilience/afts_prefix_filtering_resilience_test.go @@ -833,69 +833,43 @@ func isEndpointUnreachableError(err error) bool { func verifyGlobalFilterPolicies(t *testing.T, dut *ondatra.DUTDevice, wantIPv4Policy, wantIPv6Policy string) { t.Helper() if deviations.AftsGlobalFilterPolicyOCUnsupported(dut) { - switch dut.Vendor() { - case ondatra.ARISTA: + if dut.Vendor() == ondatra.ARISTA { aftpf.VerifyGlobalFilterPoliciesCLI(t, dut, aftpf.ConfigureGlobalFilterPoliciesParams{V4Policy: wantIPv4Policy, V6Policy: wantIPv6Policy}) } - } else { - // network-instance is a keyed list, so the query must be scoped to a - // single instance. Without the [name=...] key the DUT would either - // reject the request or return the global-filter policies of every - // network instance, and the last notification received would - // non-deterministically overwrite the values checked below. - niName := deviations.DefaultNetworkInstance(dut) - ocPolicyConfigPathV4 := fmt.Sprintf("/network-instances/network-instance[name=%s]/afts/global-filter/config/ipv4-policy", niName) - ocPolicyConfigPathV6 := fmt.Sprintf("/network-instances/network-instance[name=%s]/afts/global-filter/config/ipv6-policy", niName) - ocPolicyStatePathV4 := fmt.Sprintf("/network-instances/network-instance[name=%s]/afts/global-filter/state/ipv4-policy", niName) - ocPolicyStatePathV6 := fmt.Sprintf("/network-instances/network-instance[name=%s]/afts/global-filter/state/ipv6-policy", niName) - gnmiClient, err := dut.RawAPIs().BindingDUT().DialGNMI(t.Context()) - if err != nil { - t.Fatalf("Failed to dial GNMI: %v", err) - } - ctx, cancel := context.WithCancel(t.Context()) - defer cancel() - configReq := &gpb.GetRequest{ - Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, - Path: []*gpb.Path{ - gnmiPath(t, ocPolicyConfigPathV4), - gnmiPath(t, ocPolicyConfigPathV6), - }, - Type: gpb.GetRequest_CONFIG, - Encoding: aftpf.ConfigEncoding(dut), - } - configResp, err := gnmiClient.Get(ctx, configReq) - if err != nil { - t.Fatalf("GNMI Get for global-filter config failed: %v", err) - } - stateReq := &gpb.GetRequest{ - Prefix: &gpb.Path{Origin: "openconfig", Target: dut.Name()}, - Path: []*gpb.Path{ - gnmiPath(t, ocPolicyStatePathV4), - gnmiPath(t, ocPolicyStatePathV6), - }, - Type: gpb.GetRequest_STATE, - Encoding: aftpf.ConfigEncoding(dut), - } - stateResp, err := gnmiClient.Get(ctx, stateReq) + return + } + niName := deviations.DefaultNetworkInstance(dut) + transport, err := dut.RawAPIs().BindingDUT().DialGNMI(t.Context()) + if err != nil { + t.Fatalf("Failed to dial GNMI: %v", err) + } + client, err := aftpf.TypedGNMIClient(t, dut, transport) + if err != nil { + t.Fatalf("Failed to create typed GNMI client: %v", err) + } + ctx, cancel := context.WithCancel(t.Context()) + defer cancel() + filter := gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter() + checks := []struct { + name string + query ygnmi.SingletonQuery[string] + want string + }{ + {"IPv4 config", filter.Ipv4Policy().Config(), wantIPv4Policy}, + {"IPv6 config", filter.Ipv6Policy().Config(), wantIPv6Policy}, + {"IPv4 state", filter.Ipv4Policy().State(), wantIPv4Policy}, + {"IPv6 state", filter.Ipv6Policy().State(), wantIPv6Policy}, + } + for _, check := range checks { + got, err := ygnmi.Get(ctx, client, check.query, ygnmi.WithUseGet()) if err != nil { - t.Fatalf("GNMI Get for global-filter state failed: %v", err) - } - gotConfigIPv4Policy, gotConfigIPv6Policy := globalFilterPoliciesFromGet(t, configResp) - gotStateIPv4Policy, gotStateIPv6Policy := globalFilterPoliciesFromGet(t, stateResp) - if gotConfigIPv4Policy != wantIPv4Policy { - t.Fatalf("IPv4 config policy mismatch got=%q want=%q", gotConfigIPv4Policy, wantIPv4Policy) - } - if gotConfigIPv6Policy != wantIPv6Policy { - t.Fatalf("IPv6 config policy mismatch got=%q want=%q", gotConfigIPv6Policy, wantIPv6Policy) - } - if gotStateIPv4Policy != wantIPv4Policy { - t.Fatalf("IPv4 state policy mismatch got=%q want=%q", gotStateIPv4Policy, wantIPv4Policy) + t.Fatalf("Typed GNMI Get for global-filter %s failed: %v", check.name, err) } - if gotStateIPv6Policy != wantIPv6Policy { - t.Fatalf("IPv6 state policy mismatch got=%q want=%q", gotStateIPv6Policy, wantIPv6Policy) + if got != check.want { + t.Fatalf("%s policy mismatch got=%q want=%q", check.name, got, check.want) } - t.Logf("Verified persisted global-filter config/state policies for %q: ipv4=%q ipv6=%q", niName, gotConfigIPv4Policy, gotConfigIPv6Policy) } + t.Logf("Verified persisted global-filter config/state policies for %q: ipv4=%q ipv6=%q", niName, wantIPv4Policy, wantIPv6Policy) } // typedStringLeaves handles both scalar and container JSON_IETF responses. @@ -974,34 +948,6 @@ func notificationUpdatePath(t *testing.T, prefix, path *gpb.Path) string { return strings.TrimRight(prefixText, "/") + "/" + strings.TrimLeft(pathText, "/") } -func globalFilterPoliciesFromGet(t *testing.T, response *gpb.GetResponse) (string, string) { - t.Helper() - policies := map[string]string{} - for _, notification := range response.GetNotification() { - for _, update := range notification.GetUpdate() { - path := notificationUpdatePath(t, notification.GetPrefix(), update.GetPath()) - for _, leaf := range []string{"ipv4-policy", "ipv6-policy"} { - values, err := typedStringLeaves(update.GetVal(), leaf, path) - if err != nil { - t.Fatalf("Decode global-filter %s at %s: %v", leaf, path, err) - } - for _, value := range values { - if old, present := policies[leaf]; present && old != value { - t.Fatalf("Conflicting %s values: %q and %q", leaf, old, value) - } - policies[leaf] = value - } - } - } - } - for _, leaf := range []string{"ipv4-policy", "ipv6-policy"} { - if _, present := policies[leaf]; !present { - t.Fatalf("Get response is missing global-filter %s: %v", leaf, response) - } - } - return policies["ipv4-policy"], policies["ipv6-policy"] -} - // verifiedDefaultPeerValidator accepts the exact expected global next hop, // permitting an absent interface-ref but rejecting a conflicting one. A // link-local next hop additionally requires a verified MAC/interface mapping. diff --git a/go.mod b/go.mod index 1804ada564e..7ee8118ef3c 100644 --- a/go.mod +++ b/go.mod @@ -1,9 +1,9 @@ module github.com/openconfig/featureprofiles -go 1.26.1 +go 1.26.3 require ( - cloud.google.com/go/pubsub v1.50.1 + cloud.google.com/go/pubsub v1.51.0 cloud.google.com/go/storage v1.56.0 github.com/cisco-open/go-p4 v0.1.2 github.com/go-git/go-billy/v5 v5.9.0 @@ -15,7 +15,7 @@ require ( github.com/google/uuid v1.6.0 github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 github.com/kr/pretty v0.3.1 - github.com/open-traffic-generator/snappi/gosnappi v1.61.1 + github.com/open-traffic-generator/snappi/gosnappi v1.62.0 github.com/openconfig/attestz v0.6.15 github.com/openconfig/bootz v0.7.1 github.com/openconfig/containerz v0.0.0-20260402080039-aa3f8fb7974b @@ -30,9 +30,9 @@ require ( github.com/openconfig/goyang v1.6.3 github.com/openconfig/gribi v1.9.1 github.com/openconfig/gribigo v0.1.1 - github.com/openconfig/kne v0.1.18 + github.com/openconfig/kne v0.3.5 github.com/openconfig/models-ci v1.0.2-0.20231113233730-f0986391428e - github.com/openconfig/ondatra v0.14.10 + github.com/openconfig/ondatra v0.15.1 github.com/openconfig/qualification-reporter v0.1.3 github.com/openconfig/testt v0.0.0-20251119232631-fbbd49c39452 github.com/openconfig/ygnmi v0.15.0 @@ -46,12 +46,12 @@ require ( github.com/yoheimuta/go-protoparser/v4 v4.9.0 github.com/yuin/goldmark v1.4.13 go.mozilla.org/pkcs7 v0.9.0 - golang.org/x/crypto v0.57.0 + golang.org/x/crypto v0.58.0 golang.org/x/exp v0.0.0-20260908205506-85c1c2202aba - golang.org/x/oauth2 v0.36.0 - golang.org/x/text v0.42.0 - google.golang.org/api v0.278.0 - google.golang.org/grpc v1.84.0 + golang.org/x/oauth2 v0.37.0 + golang.org/x/text v0.43.0 + google.golang.org/api v0.309.0 + google.golang.org/grpc v1.85.0 google.golang.org/protobuf v1.36.12 gopkg.in/yaml.v2 v2.4.0 gopkg.in/yaml.v3 v3.0.1 @@ -60,20 +60,20 @@ require ( require ( bitbucket.org/creachadair/stringset v0.0.14 // indirect - cel.dev/expr v0.25.2 // indirect - cloud.google.com/go v0.121.6 // indirect - cloud.google.com/go/auth v0.20.0 // indirect - cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect - cloud.google.com/go/compute/metadata v0.9.0 // indirect - cloud.google.com/go/iam v1.5.3 // indirect - cloud.google.com/go/monitoring v1.24.3 // indirect - cloud.google.com/go/pubsub/v2 v2.0.0 // indirect + cel.dev/expr v0.25.3 // indirect + cloud.google.com/go v0.123.0 // indirect + cloud.google.com/go/auth v0.24.1-0.20261001053825-dbc26066f70a // indirect + cloud.google.com/go/auth/oauth2adapt v0.3.0 // indirect + cloud.google.com/go/compute/metadata v0.10.0 // indirect + cloud.google.com/go/iam v1.12.0 // indirect + cloud.google.com/go/monitoring v1.30.0 // indirect + cloud.google.com/go/pubsub/v2 v2.8.0 // indirect dario.cat/mergo v1.0.0 // indirect - github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.34.0 // indirect + github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.35.0 // indirect github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0 // indirect github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0 // indirect github.com/Masterminds/semver/v3 v3.5.0 // indirect - github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29 // indirect github.com/ProtonMail/go-crypto v1.1.6 // indirect github.com/aristanetworks/arista-ceoslab-operator/v2 v2.1.2 // indirect github.com/carlmontanari/difflibgo v0.0.0-20210718194309-31b9e131c298 // indirect @@ -84,17 +84,18 @@ require ( github.com/cloudflare/circl v1.6.3 // indirect github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 // indirect github.com/coredhcp/coredhcp v0.0.0-20260217182248-a0841cb3038f // indirect - github.com/creack/pty v1.1.18 // indirect + github.com/creack/pty v1.1.24 // indirect github.com/cyphar/filepath-securejoin v0.6.1 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/drivenets/cdnos-controller v1.7.4 // indirect - github.com/emicklei/go-restful/v3 v3.10.2 // indirect + github.com/drivenets/cdnos-controller v1.7.9 // indirect + github.com/emicklei/go-restful/v3 v3.13.0 // indirect github.com/emirpasic/gods v1.18.1 // indirect - github.com/envoyproxy/go-control-plane/envoy v1.37.0 // indirect + github.com/envoyproxy/go-control-plane/envoy v1.39.1-0.20260819172001-e6e3fd93e4be // indirect github.com/envoyproxy/protoc-gen-validate v1.3.3 // indirect - github.com/evanphx/json-patch/v5 v5.6.0 // indirect + github.com/evanphx/json-patch/v5 v5.9.11 // indirect github.com/felixge/httpsnoop v1.1.0 // indirect github.com/fsnotify/fsnotify v1.10.1 // indirect + github.com/fxamacker/cbor/v2 v2.9.1 // indirect github.com/ghodss/yaml v1.0.0 // indirect github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect github.com/go-jose/go-jose/v4 v4.1.4 // indirect @@ -119,14 +120,16 @@ require ( github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect github.com/golang/protobuf v1.5.4 // indirect github.com/google/gnostic v0.6.9 // indirect + github.com/google/gnostic-models v0.7.1 // indirect github.com/google/go-querystring v1.1.0 // indirect github.com/google/go-tpm v0.9.8 // indirect github.com/google/gofuzz v1.2.0 // indirect - github.com/google/s2a-go v0.1.9 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.15 // indirect - github.com/googleapis/gax-go/v2 v2.22.0 // indirect + github.com/google/s2a-go v0.1.11 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.23 // indirect + github.com/googleapis/gax-go/v2 v2.26.2 // indirect + github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.31.0 // indirect - github.com/imdario/mergo v0.3.15 // indirect + github.com/imdario/mergo v0.3.16 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/insomniacslk/dhcp v0.0.0-20260407060928-11b94ed970f2 // indirect github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect @@ -142,12 +145,13 @@ require ( github.com/mitchellh/go-wordwrap v1.0.1 // indirect github.com/moby/spdystream v0.5.1 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect - github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/networkop/meshnet-cni v0.3.1-0.20230525201116-d7c306c635cf // indirect - github.com/open-traffic-generator/keng-operator v0.3.28 // indirect + github.com/open-traffic-generator/keng-operator v0.4.4 // indirect github.com/openconfig/grpctunnel v0.1.0 // indirect - github.com/openconfig/lemming/operator v0.2.0 // indirect + github.com/openconfig/kne/third_party/meshnet v0.5.5 // indirect + github.com/openconfig/lemming/operator v0.2.9 // indirect github.com/patrickmn/go-cache v2.1.0+incompatible // indirect github.com/pelletier/go-toml/v2 v2.4.3 // indirect github.com/pierrec/lz4/v4 v4.1.22 // indirect @@ -157,55 +161,64 @@ require ( github.com/rifflock/lfshook v0.0.0-20180920164130-b9218ef580f5 // indirect github.com/rogpeppe/go-internal v1.14.1 // indirect github.com/sagikazarmark/locafero v0.12.0 // indirect - github.com/scrapli/scrapligo v1.1.11 // indirect + github.com/scrapli/scrapligo v1.4.3 // indirect github.com/scrapli/scrapligocfg v1.0.0 // indirect github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect github.com/sirikothe/gotextfsm v1.0.1-0.20200816110946-6aa2cfd355e4 // indirect - github.com/sirupsen/logrus v1.9.4 // indirect + github.com/sirupsen/logrus v1.10.2 // indirect github.com/skeema/knownhosts v1.3.1 // indirect github.com/spf13/afero v1.15.0 // indirect github.com/spf13/cast v1.10.0 // indirect github.com/spiffe/go-spiffe/v2 v2.8.1 // indirect - github.com/srl-labs/srl-controller v0.6.1 // indirect + github.com/srl-labs/srl-controller v0.7.1 // indirect github.com/srl-labs/srlinux-scrapli v0.6.0 // indirect github.com/subosito/gotenv v1.6.0 // indirect github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 // indirect + github.com/x448/float16 v0.8.4 // indirect github.com/xanzy/ssh-agent v0.3.3 // indirect go.opencensus.io v0.24.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/contrib/detectors/gcp v1.44.0 // indirect - go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.71.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.71.0 // indirect - go.opentelemetry.io/otel v1.46.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.46.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 // indirect - go.opentelemetry.io/otel/metric v1.46.0 // indirect - go.opentelemetry.io/otel/sdk v1.46.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.46.0 // indirect - go.opentelemetry.io/otel/trace v1.46.0 // indirect + go.opentelemetry.io/contrib/detectors/gcp v1.45.0 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.72.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.72.0 // indirect + go.opentelemetry.io/otel v1.47.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.47.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.47.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.47.0 // indirect + go.opentelemetry.io/otel/log v1.47.0 // indirect + go.opentelemetry.io/otel/metric v1.47.0 // indirect + go.opentelemetry.io/otel/sdk v1.47.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.47.0 // indirect + go.opentelemetry.io/otel/trace v1.47.0 // indirect go.opentelemetry.io/proto/otlp v1.11.0 // indirect go.uber.org/atomic v1.11.0 // indirect + go.yaml.in/yaml/v2 v2.4.4 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect - golang.org/x/net v0.59.0 // indirect - golang.org/x/sync v0.23.0 // indirect - golang.org/x/sys v0.48.0 // indirect - golang.org/x/term v0.46.0 // indirect - golang.org/x/time v0.15.0 // indirect - google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260921155816-b14227669459 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260921155816-b14227669459 // indirect + golang.org/x/net v0.61.0 // indirect + golang.org/x/sync v0.24.0 // indirect + golang.org/x/sys v0.49.0 // indirect + golang.org/x/term v0.47.0 // indirect + golang.org/x/time v0.16.0 // indirect + google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260928230214-8a89bd6388cc // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20261019180522-ce908d29299b // indirect + gopkg.in/evanphx/json-patch.v4 v4.13.0 // indirect gopkg.in/inf.v0 v0.9.1 // indirect gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect gopkg.in/warnings.v0 v0.1.2 // indirect - k8s.io/api v0.26.3 // indirect - k8s.io/apimachinery v0.26.3 // indirect - k8s.io/client-go v0.26.3 // indirect - k8s.io/kube-openapi v0.0.0-20230308215209-15aac26d736a // indirect - k8s.io/utils v0.0.0-20230313181309-38a27ef9d749 // indirect + k8s.io/api v0.37.1 // indirect + k8s.io/apimachinery v0.37.1 // indirect + k8s.io/client-go v0.37.1 // indirect + k8s.io/kube-openapi v0.0.0-20260721132016-d427ff9ee9ad // indirect + k8s.io/streaming v0.37.1 // indirect + k8s.io/utils v0.0.0-20261023123148-ca04ba58ecab // indirect lukechampine.com/uint128 v1.3.0 // indirect - sigs.k8s.io/controller-runtime v0.14.5 // indirect - sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect - sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect - sigs.k8s.io/yaml v1.3.0 // indirect + sigs.k8s.io/controller-runtime v0.24.1 // indirect + sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 // indirect + sigs.k8s.io/randfill v1.0.0 // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect + sigs.k8s.io/structured-merge-diff/v6 v6.4.2 // indirect + sigs.k8s.io/yaml v1.6.0 // indirect ) + +replace github.com/openconfig/ondatra => github.com/b4firex/ondatra v0.0.0-20261120174419-ff486025d4fa diff --git a/go.sum b/go.sum index 9b3da53e290..e0db1f3b1c5 100644 --- a/go.sum +++ b/go.sum @@ -2,39 +2,303 @@ bitbucket.org/creachadair/stringset v0.0.14 h1:t1ejQyf8utS4GZV/4fM+1gvYucggZkfhb bitbucket.org/creachadair/stringset v0.0.14/go.mod h1:Ej8fsr6rQvmeMDf6CCWMWGb14H9mz8kmDgPPTdiVT0w= cel.dev/expr v0.25.2 h1:K6j46C81hXtZQfuX60cVWQFBJahKSE2gfRbNuvr5bFs= cel.dev/expr v0.25.2/go.mod h1:hrXvqGP6G6gyx8UAHSHJ5RGk//1Oj5nXQ2NI02Nrsg4= +cel.dev/expr v0.25.3 h1:A2jO8jwOugrrovveCWfj0KEZOfqiLgAcwjpHPhzIGw0= +cel.dev/expr v0.25.3/go.mod h1:hrXvqGP6G6gyx8UAHSHJ5RGk//1Oj5nXQ2NI02Nrsg4= cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.121.6 h1:waZiuajrI28iAf40cWgycWNgaXPO06dupuS+sgibK6c= cloud.google.com/go v0.121.6/go.mod h1:coChdst4Ea5vUpiALcYKXEpR1S9ZgXbhEzzMcMR66vI= +cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= +cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= +cloud.google.com/go/accessapproval v1.13.0 h1:kx3RQSS0VglTngQTPfywgVj+xFgre/vJouGETBlPU1E= +cloud.google.com/go/accessapproval v1.13.0/go.mod h1:7bmInw17bQX+ZPi7YmReC3xKymDrMmxXaUnaI6zQOqI= +cloud.google.com/go/accesscontextmanager v1.15.0 h1:0baVgug9IFV8y5cIoD4iN/m/QtJzk2k+j3MW+zJWCVw= +cloud.google.com/go/accesscontextmanager v1.15.0/go.mod h1:YjW9urferk8i9ALwBF3bmdcogZeQYRn2yWwR8nkhsBc= +cloud.google.com/go/aiplatform v1.126.0 h1:5PxeWpQfkAyN8mtgtVp4H5nP+ntwPLFMjNREVdiolR0= +cloud.google.com/go/aiplatform v1.126.0/go.mod h1:iR3za3evdprLe1XL2pLu0cYVCuTbc87QG0pgvcgiJlE= +cloud.google.com/go/analytics v0.35.0 h1:GuwmzJHIaQRvtko6g4wW1ngQ7rpDvDLZ8M3iP3kiflU= +cloud.google.com/go/analytics v0.35.0/go.mod h1:V9Qef2N0y8GDqQ9FTlmM2XpDEMYonZJRPSUNGZlPCcc= +cloud.google.com/go/apigateway v1.13.0 h1:IENNmFQlMsl58RlvYHf6wxBNQFeP+lAnVNcyxtmByTE= +cloud.google.com/go/apigateway v1.13.0/go.mod h1:pvEpOuuOIw2ev9VCcOyVkDXHHL4lvgMuqIe7XjJ8JoU= +cloud.google.com/go/apigeeconnect v1.12.0 h1:YvZhi0QkHobBRMrN6ri9PUPnnhgEd4VpW0+yo1WI7r0= +cloud.google.com/go/apigeeconnect v1.12.0/go.mod h1:mYJekCKZHc2ia5yZX5lwtexTn9CzsOfb6+sh/2hi42Q= +cloud.google.com/go/apigeeregistry v1.1.0 h1:2zIogaYq7dF4E1dAGC4MUnasRuSmohsMl7wVuJ963/4= +cloud.google.com/go/apigeeregistry v1.1.0/go.mod h1:4ZFhQlxMuyfDMz9ORDSV8FPZtf2yPQkKjigsFtrrE4Y= +cloud.google.com/go/appengine v1.15.0 h1:0MiBM2KGk1WAhh489WoELQ7IeW2qw6HTE6nZIlrOw5U= +cloud.google.com/go/appengine v1.15.0/go.mod h1:/8gGZsOX5GDjOo4mAWk8IV59p2991dxTbEtKIlhDjzU= +cloud.google.com/go/area120 v0.15.0 h1:9v6HeQsBpfRqoZtNeLI4V8SQ7Jcmt6s2gmgbjl0fVFc= +cloud.google.com/go/area120 v0.15.0/go.mod h1:jD1fw9W4xxIZMY68g7PpbCPleoeGddFs5jPcdhfg3+Y= +cloud.google.com/go/artifactregistry v1.26.0 h1:iq5kkdY2FJY8RkkNghUelb3EOcqyy7dVhfDGVk/Xw9g= +cloud.google.com/go/artifactregistry v1.26.0/go.mod h1:c5FPi5GtDBP+OAr5kKhCBNQDT9ZgAyobXQjekx93VWs= +cloud.google.com/go/asset v1.28.0 h1:M6YE1exBuZQhTi8wfIKrwjKK6b2ySfHKgrqXjPZA4EM= +cloud.google.com/go/asset v1.28.0/go.mod h1:Pnvjhay8/FgodOH9uJC8OkfJfRtSnNIIU4WSxg5JfJw= +cloud.google.com/go/assuredworkloads v1.19.0 h1:XyNQ9SBX0eUkZYCZhC8dOY6ZFeSF6/OIjHn5dQs78Jo= +cloud.google.com/go/assuredworkloads v1.19.0/go.mod h1:/UGGtFCMokM3sGJ4FxjfmLvvFpPa5I/Oz68mwk4Su+0= cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA= cloud.google.com/go/auth v0.20.0/go.mod h1:942/yi/itH1SsmpyrbnTMDgGfdy2BUqIKyd0cyYLc5Q= +cloud.google.com/go/auth v0.24.1-0.20261001053825-dbc26066f70a h1:jW1ZLFy9oa5ai8LOI40z6s+DL1cO/L1KSm9hVGnibn8= +cloud.google.com/go/auth v0.24.1-0.20261001053825-dbc26066f70a/go.mod h1:1dmBXa9xfBvBr39ZnDUDkaaA91ccq9CcqENDgJA4d7c= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= +cloud.google.com/go/auth/oauth2adapt v0.3.0 h1:FY8oSZpCYoUNv6QxVODuMjQz4IlSOVeiQtZ08vLPz88= +cloud.google.com/go/auth/oauth2adapt v0.3.0/go.mod h1:7+2uCm7++XFO+/lN06c2HXpDXb/NMNn2/UwyBPbTnkk= +cloud.google.com/go/automl v1.21.0 h1:brKXr4i9AMVfgbCKOYSu4rnIoz1ILIgcIAy3nerzEGc= +cloud.google.com/go/automl v1.21.0/go.mod h1:MNbhUevuECzM3jqSOM7hmOedOdRJkm8xbbXW44SU15U= +cloud.google.com/go/baremetalsolution v1.10.0 h1:6MaZilXzGZJ3mGqbSCdDezs9yrze6kcmBABsRUZ/aYI= +cloud.google.com/go/baremetalsolution v1.10.0/go.mod h1:xhhT9VQiKPFd2fUs4oeDSRrxV0sb0PGeVmuZoUE2cBA= +cloud.google.com/go/batch v1.20.0 h1:nTL5x9HA1yVdPIdeqcbLjNnV9iYDYvMNmP6AnZ+qbHU= +cloud.google.com/go/batch v1.20.0/go.mod h1:ABT/5QqsIDsONa+n/8C7XYPjwh/kjOEPXukcRTaMsCg= +cloud.google.com/go/beyondcorp v1.8.0 h1:rsyle6zjxce2s57BpULw5u170xS+KSjFENSY7C0MZbs= +cloud.google.com/go/beyondcorp v1.8.0/go.mod h1:aVxzwamO8H4GXWQHowBAmL0KYNfYpW4E6Do2wfP0RYs= +cloud.google.com/go/bigquery v1.79.0 h1:+tW6oRuP/4dOgdl/p32on0+3OktVQtU+veOMxhjoOhE= +cloud.google.com/go/bigquery v1.79.0/go.mod h1:QTt5tgZxqqvZs3dOZKpvriGqy+CdvY9LyetirFZRPOE= +cloud.google.com/go/bigtable v1.47.0 h1:NGLgDSr/i79BTGCjxH/maPKxyvl5q8/SsBsyLK52kdI= +cloud.google.com/go/bigtable v1.47.0/go.mod h1:GUM6PdkG3rrDse9kugqvX5+ktwo3ldfLtLi1VFn5Wj4= +cloud.google.com/go/billing v1.26.0 h1:6RRjbRd6iZKZFb7/MgRvmXKq/Ism02ckkZLJazj4CQ0= +cloud.google.com/go/billing v1.26.0/go.mod h1:axqDO1uHegh7u5qngkTfqN1djAeLGsWAFAblERgmgEk= +cloud.google.com/go/binaryauthorization v1.16.0 h1:f1iNUaHWP9XPdh6grftTlIRuJSBytud4j51l1Jce94E= +cloud.google.com/go/binaryauthorization v1.16.0/go.mod h1:E+iC5Avu4pdItdzGiSGHnh6TfQrl+KmPxDDg/T/VuHs= +cloud.google.com/go/certificatemanager v1.15.0 h1:PwljEZlI3lZgoFUG0pnIBNOwrQUaAP+gS0ZahTwUZBA= +cloud.google.com/go/certificatemanager v1.15.0/go.mod h1:8dfGG2/TbUpCNqsCF/TIMOGV0OVvU6nhkZWTU4MmCXU= +cloud.google.com/go/channel v1.27.0 h1:fqDZDzVw61c4iIUe7rQ+cBYlBdSZ3yqnzw5WrZTPjqs= +cloud.google.com/go/channel v1.27.0/go.mod h1:9ekufBLXuQ6j1oyqtDSIp29qWU5EwCi8WUi9qkLn3MA= +cloud.google.com/go/cloudbuild v1.36.0 h1:MqlyiKjtiIquUYhfrIIKqGaWmCJUeuOH4Y1oc4EXNjw= +cloud.google.com/go/cloudbuild v1.36.0/go.mod h1:l61dO9wnjSWD2HZMMTXwxL5bWKBhN/yXaDaHCX5+stY= +cloud.google.com/go/clouddms v1.14.0 h1:oaktwVyUeKTuzjpde3xbpmc9bAQPQq6WJWOBr7K6YEA= +cloud.google.com/go/clouddms v1.14.0/go.mod h1:qSwET2Q27cJ4wCDsPsbkagXqQqkWfOy+gU3RjMsT/c8= +cloud.google.com/go/cloudtasks v1.18.0 h1:KzT7hfix/9/xAf20tNPIxwX59XGpRF0Lun2t8LHOj9E= +cloud.google.com/go/cloudtasks v1.18.0/go.mod h1:3KeCxwtGEyaySL7CR3lMmEa2I4mq1ynXdgmfNiO4RYE= +cloud.google.com/go/compute v1.62.0 h1:tJ7lKJ8YEVa6vZX03Jc8o1YePbjKDOQhDw1BscMZ1bs= +cloud.google.com/go/compute v1.62.0/go.mod h1:Xm6PbsLgBpAg4va77ljbBdpMjzuU+uPp5Ze2dnZq7lw= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= +cloud.google.com/go/compute/metadata v0.10.0 h1:pyKMUQSwchgkIBBJGdILqQbs/BNJXqwSA7Ej6LAvvtY= +cloud.google.com/go/compute/metadata v0.10.0/go.mod h1:rGFHRrIif570kSibjFTMbt6/4/tzgJWFGI/HVol4GIk= +cloud.google.com/go/contactcenterinsights v1.23.0 h1:EtrRf8T7ajR+dR8nseDxwKy3o1VaWP1GFAu7lgMmT9A= +cloud.google.com/go/contactcenterinsights v1.23.0/go.mod h1:uB/kygbfYH/gWEq3NEgq3QRI7/MvpjFyX81ajcW5YAI= +cloud.google.com/go/container v1.51.0 h1:KdeWHqwlOvABdhkhSTSb4QFySMOuXnc3UUoQMmq9lic= +cloud.google.com/go/container v1.51.0/go.mod h1:EvqoT2eXfxLweXXUlhAMGR0sOAB00XPzEjoL01esSDs= +cloud.google.com/go/containeranalysis v0.19.0 h1:89ZhFvJHWzX9/jUJy/IEVbtSa2hv4+NtsvwWMEsUYnY= +cloud.google.com/go/containeranalysis v0.19.0/go.mod h1:Zq0XHzUIa0oTa7H6aSR8HWqeJnoRI9syUcYJzfozjZQ= +cloud.google.com/go/datacatalog v1.33.0 h1:8V80PpoAGdOOr2QhBrp4wZ66MDCbATdAB/fmVmo5rlU= +cloud.google.com/go/datacatalog v1.33.0/go.mod h1:/EMN04S73fZcPdtNg86VYLDrhi2HheMehQtMCS86Klk= +cloud.google.com/go/dataflow v0.16.0 h1:BchGCAl9QIZ/pyTGokv5V3daxBTrXsOmrU4ARXoTNd4= +cloud.google.com/go/dataflow v0.16.0/go.mod h1:BWhSrIGmsMfuYj3J+nJ2Tw7tplRR6r28kvRiqCD3WlQ= +cloud.google.com/go/dataform v1.2.0 h1:eAIsWhr6AbUIX+wOdfctO6hAr9UoQnTR2qQW739XH1I= +cloud.google.com/go/dataform v1.2.0/go.mod h1:Lhkjd6L04/nBqsEo7S9Tx7D+Vm0pDDDZuKczewAJuX0= +cloud.google.com/go/datafusion v1.14.0 h1:56rjOW8xFBnTOLgTEWdU09KhVC2/X+y/ukzux7zYqBE= +cloud.google.com/go/datafusion v1.14.0/go.mod h1:2z+uDUKkLPacNNos5lW1Jf1IRDoFyeE+glJ4hmxF2Uc= +cloud.google.com/go/datalabeling v0.15.0 h1:9TL2kwlO/ODD1fne3uvgTLa53SttwrQi92Bn7KWnKhg= +cloud.google.com/go/datalabeling v0.15.0/go.mod h1:H8WSRKD9XYCDXDlZE3bPgvV7UYI0F05e+ufKev2AFc8= +cloud.google.com/go/dataplex v1.36.0 h1:r4O6RHEkwHr41ItsTUym0ZgH1iDf48R+W8fI7KoMNl8= +cloud.google.com/go/dataplex v1.36.0/go.mod h1:ftgNMXBt+wJ4wPVNvYJ3UY3VTZtKS/i/uFEQppaEbKk= +cloud.google.com/go/dataproc/v2 v2.25.0 h1:IF1wxkXvcgoTP92NVqX6QNDf2SdKNZFPa2IWeSKP310= +cloud.google.com/go/dataproc/v2 v2.25.0/go.mod h1:hkiM6kzc8CwLGoquMN1oghyhuI1fE0girmChH4h9W7w= +cloud.google.com/go/dataqna v0.13.0 h1:VR1y/NuN+RvPkmfmlowbmk60BLINR4MgZAusVFIGQjU= +cloud.google.com/go/dataqna v0.13.0/go.mod h1:XiVVFTOEJLBSvm3ILbyjXngGQYpjb/66MSksqz/56fs= +cloud.google.com/go/datastore v1.25.0 h1:zUjMnCLCcRZVDSdQIXsbnNCl1SVRNw5Jm0J77gPaPKs= +cloud.google.com/go/datastore v1.25.0/go.mod h1:jvJVNe+S2nHVIndV1H/B4s9K3MLsTMqOKlxSrzHTxB4= +cloud.google.com/go/datastream v1.21.0 h1:hrWGASBj85xs6wpnx9ifdSBYiRLhKDgQrA1HjeNYBhc= +cloud.google.com/go/datastream v1.21.0/go.mod h1:z9AlkQGdXqkeyO5HE+D6sYbOkLJYB4BCZpXFPX/1Vpo= +cloud.google.com/go/deploy v1.33.0 h1:2PdZ8kbIztLVRMrIN/wHbalZeZZikQlxBptBFK+eEtM= +cloud.google.com/go/deploy v1.33.0/go.mod h1:QdF3plD8D5gV2RmkTXBB6cHrq490WlpFr1SChdOJO2Y= +cloud.google.com/go/dialogflow v1.84.0 h1:BymJ6nPotDcnphK2/D0VHMAfakjJlIV5GqxLHQg/Tos= +cloud.google.com/go/dialogflow v1.84.0/go.mod h1:OU8Lj1aw5Vr2hl9ifW+vsKnc2b4iJH+41U7nZ4whg3U= +cloud.google.com/go/dlp v1.34.0 h1:SI7KSLOtAfhEAw3af8NxpKHGHbJ9BkoM7805TMaU6m4= +cloud.google.com/go/dlp v1.34.0/go.mod h1:+haQd/n0QTv5BK7wZnCk2qctd5sfKL50jjh9E6N0d/Q= +cloud.google.com/go/documentai v1.49.0 h1:WLZOaWvK4NH7xMLxANsDgIdXugeqmVyYRCbVN1m87DQ= +cloud.google.com/go/documentai v1.49.0/go.mod h1:VyQA+SxPnCPlVLSJ5UcFx+LQm8JCzK7uUXdkOaAHvG8= +cloud.google.com/go/domains v0.16.0 h1:h+lcYPxyEulj5SYuH3+OwOsLZb4DTW11QX6nlxxXQ1I= +cloud.google.com/go/domains v0.16.0/go.mod h1:O5AhaEyUAgZC2X4M10nSu3dQt2cJLtbjhtrNrdeSPF8= +cloud.google.com/go/edgecontainer v1.10.0 h1:4WOjcIZRCB4ynxH9Zs1tteIcm2LD58VUCLLmIwLYUAc= +cloud.google.com/go/edgecontainer v1.10.0/go.mod h1:g4xb11IzVWa9peXNTlnNguKP8uJVvMK4zZeDlGS2Wus= +cloud.google.com/go/errorreporting v0.9.0 h1:LlE2SVIbz0k+OSeNTksk34inr3Fy62JMhHUvNaS8f7c= +cloud.google.com/go/errorreporting v0.9.0/go.mod h1:V7ojx7z76JITDZNGyDNkIIa9nNEkQzF6Yj+VHl2YF84= +cloud.google.com/go/essentialcontacts v1.12.0 h1:+AtGn+hYLdr62sMqP0ZGMRzp9A4t+MSWe8eZoD/ho+M= +cloud.google.com/go/essentialcontacts v1.12.0/go.mod h1:W8fTL17jP6vmsPHQaCT5rOjWGohEssuqDUroxnjST0A= +cloud.google.com/go/eventarc v1.25.0 h1:+XAJNEmxJIPZLMtzLYdUZN61Kmqx62hWLry4AsWaTwo= +cloud.google.com/go/eventarc v1.25.0/go.mod h1:ncY2NKHKiX+sUjIfxVozrivvmJQ4HWo2znxms7AxlP8= +cloud.google.com/go/filestore v1.16.0 h1:2GXy5jvq2oUX6HnCpx3GjzSqlcMz8K9gkHaF9HPcYNE= +cloud.google.com/go/filestore v1.16.0/go.mod h1:szr35omqptDEuXgBbJ8PdVdYM3lf/Md96kNufWr1tVs= +cloud.google.com/go/firestore v1.24.0 h1:x0Z3hrgjYgo2wI9whuBRQcNc2hYwzZDQy/7pkUXbXcs= +cloud.google.com/go/firestore v1.24.0/go.mod h1:5aojyjN4olKUnBZDCRWwM+NsdrrCX3t1qfyERZGOonM= +cloud.google.com/go/functions v1.25.0 h1:ndUtLkam3XF9b0t2zVACH9D/EgFBISbVuQFqRz/X58k= +cloud.google.com/go/functions v1.25.0/go.mod h1:b/tqakoKeAkj9RspEjqswWf5299Lkz9C/742QUD3OEk= +cloud.google.com/go/gkebackup v1.14.0 h1:li3BtGRis1QYrkLo8+Iq2wf5WbP9v3sz9VoUw8WqgaA= +cloud.google.com/go/gkebackup v1.14.0/go.mod h1:kaD4l/s0ONcb3L9iHC8PzG1XkC5ggPwA/KAl6yAyQGs= +cloud.google.com/go/gkeconnect v1.0.0 h1:IDuAD/w0Xph8k/31vdt6pBkDdRx55lVXz7gW8ABOfCs= +cloud.google.com/go/gkeconnect v1.0.0/go.mod h1:5iWSBQzMIRLwUHUWVhxxcNK45ZPE8ntyBgE0MkavlqQ= +cloud.google.com/go/gkehub v0.22.0 h1:gHKPoWQuWpd9dXLoC58dxwBvSYTNc5/fdYYcs3JUn1s= +cloud.google.com/go/gkehub v0.22.0/go.mod h1:WiXX1w9ZHwKZVUDwL//YQfjfWS7yE0I/ym3smZn9iwE= +cloud.google.com/go/gkemulticloud v1.12.0 h1:3LPj8ro7bPdZ0BlQJwby25G32rRezGLRdhNM6U3AxGs= +cloud.google.com/go/gkemulticloud v1.12.0/go.mod h1:vLNCxGah7pPIoNSX4Yx+hb8klqA0lzzXTWBSut9KzRo= +cloud.google.com/go/gsuiteaddons v1.12.0 h1:kz9DyBk84wZCda2Rdha1MOIf7/9x6R+N+LuH9B3zYFs= +cloud.google.com/go/gsuiteaddons v1.12.0/go.mod h1:rm/XT7wmwOFGn7jmWtVV65QmZCakzTbHLSojIC4Hskg= cloud.google.com/go/iam v1.5.3 h1:+vMINPiDF2ognBJ97ABAYYwRgsaqxPbQDlMnbHMjolc= cloud.google.com/go/iam v1.5.3/go.mod h1:MR3v9oLkZCTlaqljW6Eb2d3HGDGK5/bDv93jhfISFvU= +cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk= +cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY= +cloud.google.com/go/iap v1.17.0 h1:BDAVJy+juq7cMRumIx9toc4pt1K7zXoZdAI3lDD6D3g= +cloud.google.com/go/iap v1.17.0/go.mod h1:b+r+yjrss2WmAEzNrQQjlEdD5E9B8c47mOF7XnqT+z0= +cloud.google.com/go/ids v1.11.0 h1:394LkKIavhv/+oQVMtbXe9WQqCeY9wSFcHktqC9ZkLE= +cloud.google.com/go/ids v1.11.0/go.mod h1:+drdvU0pQ4x5uYiWCv364VOeIpTN/PETBrdR51D4Tjk= +cloud.google.com/go/iot v1.13.0 h1:pyt1EuMFpbV/2BlmYlXr+HBnUNSPKlP9dVK/dpFTu1U= +cloud.google.com/go/iot v1.13.0/go.mod h1:62W4n2fe/Ct66NWJEfCB5suZ3XsL5Atx+MxFjScr+9s= cloud.google.com/go/kms v1.26.0 h1:cK9mN2cf+9V63D3H1f6koxTatWy39aTI/hCjz1I+adU= cloud.google.com/go/kms v1.26.0/go.mod h1:pHKOdFJm63hxBsiPkYtowZPltu9dW0MWvBa6IA4HM58= +cloud.google.com/go/kms v1.32.0 h1:s+rEluaaZKhLVjrIWG7uNBsnWbiitElzNzFGyp6+nIg= +cloud.google.com/go/kms v1.32.0/go.mod h1:CSGvW6GnMQbY+1nOHcIzhMtHSbExXlOmCKjWtYVjcpA= +cloud.google.com/go/language v1.18.0 h1:q58bL7rmxvw6Q6VHt+wjFsAE1Tj/JkuAEIR4+84rx9U= +cloud.google.com/go/language v1.18.0/go.mod h1:xSeiVB4UiA9wYmFy2GWjf1Mb1K3uR1Yi/80qoqTxH04= +cloud.google.com/go/lifesciences v0.16.0 h1:T+7N3oVHK8a7BhX6HJLrBW8xEbMV9iY8Mb+aOl7r6+A= +cloud.google.com/go/lifesciences v0.16.0/go.mod h1:axEwGa3A63+vCXIis+0Zkseu8KecqtNoSn7x0zyjJfM= cloud.google.com/go/logging v1.13.2 h1:qqlHCBvieJT9Cdq4QqYx1KPadCQ2noD4FK02eNqHAjA= cloud.google.com/go/logging v1.13.2/go.mod h1:zaybliM3yun1J8mU2dVQ1/qDzjbOqEijZCn6hSBtKak= +cloud.google.com/go/logging v1.19.0 h1:NCqhdVUg3wQ8Cobdf16FDSuTGi3+6+hdSBHrY5TsR6Q= +cloud.google.com/go/logging v1.19.0/go.mod h1:i40NZCHC9Gqvod4yE+yQfDWwlgwW/SrshkkGibCHxcA= cloud.google.com/go/longrunning v0.8.0 h1:LiKK77J3bx5gDLi4SMViHixjD2ohlkwBi+mKA7EhfW8= cloud.google.com/go/longrunning v0.8.0/go.mod h1:UmErU2Onzi+fKDg2gR7dusz11Pe26aknR4kHmJJqIfk= +cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= +cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= +cloud.google.com/go/managedidentities v1.13.0 h1:ZzWkg3LSrIi9OdzCK3bxutexvw1dDDg9+tOMitbkOXw= +cloud.google.com/go/managedidentities v1.13.0/go.mod h1:lUYH5r6QEJTHqjgga0WFeiieqJ0iRwEuQSk20O41Vj0= +cloud.google.com/go/maps v1.37.0 h1:YoTRWohpNKeKxdQynorwHH69NZuUM06divZtqGPYjUA= +cloud.google.com/go/maps v1.37.0/go.mod h1:oalKFBmf2eHmdr3OvfEiiBlOakNlVitYYEPcM3TTUB4= +cloud.google.com/go/mediatranslation v0.13.0 h1:qqMRAK0mhc9M+lM6pb791oh3DYUbwLcIy58jOyXtadE= +cloud.google.com/go/mediatranslation v0.13.0/go.mod h1:kjZrowuigFr+Bf1HM1TCtp1a3E3kfG1ovPK5VEuaNAQ= +cloud.google.com/go/memcache v1.17.0 h1:l/co1jsmVLkNyl8uMqj1u1HIwd3AhCvGdHbEAIPb6jc= +cloud.google.com/go/memcache v1.17.0/go.mod h1:QQpFWgJvrFaQ6DgmitHejdbkLg8SJfHg5BzltKEWSt0= +cloud.google.com/go/metastore v1.20.0 h1:kz0XBkP531MB1IR9jTY6/DB33UFP5Df1vFpPNgW1iPk= +cloud.google.com/go/metastore v1.20.0/go.mod h1:/bhZoizjM5iOrqWJeAFDw7c16C783wEftqofnJgKKYI= cloud.google.com/go/monitoring v1.24.3 h1:dde+gMNc0UhPZD1Azu6at2e79bfdztVDS5lvhOdsgaE= cloud.google.com/go/monitoring v1.24.3/go.mod h1:nYP6W0tm3N9H/bOw8am7t62YTzZY+zUeQ+Bi6+2eonI= +cloud.google.com/go/monitoring v1.30.0 h1:r/d+JUbyKmJ8b07iznuKfzVzrIXTWxHQ3lBRm3x2LlY= +cloud.google.com/go/monitoring v1.30.0/go.mod h1:htlUR0QWVMrjFzZmN4LGnMAve9xB/eduwjmINxVZ8RM= +cloud.google.com/go/networkconnectivity v1.27.0 h1:ieYJjbUn2L9ZSzEB9+qKgtoD3/l1/qAnId/Z6KE4ZBo= +cloud.google.com/go/networkconnectivity v1.27.0/go.mod h1:pCnczH2W/cnLSlnsnN+VzBoXlM81ZoUGuuacFBGThyw= +cloud.google.com/go/networkmanagement v1.30.0 h1:LqYm91vSQk3NM6fHjthseRh4xrDvhXIWQBsQY/Ksus8= +cloud.google.com/go/networkmanagement v1.30.0/go.mod h1:3SBf5T7jyGzw5jqJWE7TUDRhIl2E029jggbeoFEgt5E= +cloud.google.com/go/networksecurity v0.19.0 h1:PzJnbVd0sS2+xDR9hnk31NAyqFt9qB8ohLn7XIsKIBA= +cloud.google.com/go/networksecurity v0.19.0/go.mod h1:VWDFX+stDgzZYDsCX1Wy/JO9Tlw7g/V1UHbiORVgqq0= +cloud.google.com/go/notebooks v1.18.0 h1:BgxdQcoRSSjiyszWNOTu3fmXG/6Ks4W2sHgjx0BAke0= +cloud.google.com/go/notebooks v1.18.0/go.mod h1:fXU6A3TJ2YobFy6fxOr4tKZZ8QgTjdJAqDIykOB85Gk= +cloud.google.com/go/optimization v1.12.0 h1:Cd4DgujNhEMcjfaVLGqbjfDwVDnmS1Bc93cx9TE8ZYw= +cloud.google.com/go/optimization v1.12.0/go.mod h1:28gzCUmeCLcT4vctGEo71QF4b60TYkKQo5y8Gs2KPq8= +cloud.google.com/go/orchestration v1.17.0 h1:dqf2HzqUi4CaaDiNfv6jVoZjz9lF0HWjyIEgccxPHMk= +cloud.google.com/go/orchestration v1.17.0/go.mod h1:Lf/Czqh4Jfy3IFpvDkKWjfjkYFI+tj6nAjq5ihivrq4= +cloud.google.com/go/orgpolicy v1.20.0 h1:kpVcE/OsC5aAzHCsAiuQSg3+s6ILzgPTuPZyS7n7ejA= +cloud.google.com/go/orgpolicy v1.20.0/go.mod h1:9LHqEGx5P5dhansdKTNIEXpM+QbebAIOs66+HUID4aQ= +cloud.google.com/go/osconfig v1.22.0 h1:r5lzneR9GNixJ96lZ6oIfJK9Cd5sKpnzZJe1LcGZf4w= +cloud.google.com/go/osconfig v1.22.0/go.mod h1:bUL0FaSR2ahPcFRRYnd6a0LyUzsQYIdUpBq8Tmxg8fE= +cloud.google.com/go/oslogin v1.18.0 h1:OkccORMcY2XEHwN5+AP0XH/SCUNBl39GGjaQuSCVcIw= +cloud.google.com/go/oslogin v1.18.0/go.mod h1:3Oa36T3781Mv+yCSVYlfasi7auHjfPFqvNOd1q92umc= +cloud.google.com/go/phishingprotection v0.13.0 h1:6WJF1z3Ie8fZAiCRpeSGB81h6s86XWS2SBC9iQUZxX8= +cloud.google.com/go/phishingprotection v0.13.0/go.mod h1:2gyYqwNjePPEocXDkDve3EuJPaRqN/E7fp28K3arR0k= +cloud.google.com/go/policytroubleshooter v1.16.0 h1:V3CcqzY6FhY2c2idRGZv0Ef4mFinLnXnfDFtAhxyTfM= +cloud.google.com/go/policytroubleshooter v1.16.0/go.mod h1:FZg3IW3exF6wc9eO/iBYijsGqiiCzc9mjZhsxgATXYA= +cloud.google.com/go/privatecatalog v0.16.0 h1:SBhcVNVhgEGT1edcfSFY/KSiy2xSQTSQUpY12f10rmw= +cloud.google.com/go/privatecatalog v0.16.0/go.mod h1:Dq1bSHRRaDqFr7Rb7UntXVjh1reeY6YdzYicL0EPTrM= cloud.google.com/go/pubsub v1.50.1 h1:fzbXpPyJnSGvWXF1jabhQeXyxdbCIkXTpjXHy7xviBM= cloud.google.com/go/pubsub v1.50.1/go.mod h1:6YVJv3MzWJUVdvQXG081sFvS0dWQOdnV+oTo++q/xFk= +cloud.google.com/go/pubsub v1.51.0 h1:XOaCejsqX7EEtUdQz+WPag66wWsUUGliyCOfGPKfo90= +cloud.google.com/go/pubsub v1.51.0/go.mod h1:NERXf11sd82UV3VnflcUj8POIyQUXT/QwrKlxD8di/I= cloud.google.com/go/pubsub/v2 v2.0.0 h1:0qS6mRJ41gD1lNmM/vdm6bR7DQu6coQcVwD+VPf0Bz0= cloud.google.com/go/pubsub/v2 v2.0.0/go.mod h1:0aztFxNzVQIRSZ8vUr79uH2bS3jwLebwK6q1sgEub+E= +cloud.google.com/go/pubsub/v2 v2.8.0 h1:mDGFPDisDUcv0fEkiYQX+BRbenlzdnV6BdH2eb9YQ/M= +cloud.google.com/go/pubsub/v2 v2.8.0/go.mod h1:OUQLW4ZkmJ0lVvXpP+2Kk0acWWO2pTg5nJ3xaq786ag= +cloud.google.com/go/pubsublite v1.10.0 h1:kqNk9e0gt0/Eu6lChjDlgu4B8k/399FZFpAU4LNq4Co= +cloud.google.com/go/pubsublite v1.10.0/go.mod h1:o9NVNBY4m8LubZqRCJtBdxpjP8DAsYizsxC6Z1vI7Dk= +cloud.google.com/go/recaptchaenterprise/v2 v2.26.0 h1:9qDHoQtUIZ8FDN5uFAfnNz8jyyXdpAJf6rMN4ZMmMcU= +cloud.google.com/go/recaptchaenterprise/v2 v2.26.0/go.mod h1:+ntF70/j7qBa6G/pwmYA0mkBcDeTCXV6WDqUL7GObfs= +cloud.google.com/go/recommendationengine v0.15.0 h1:G0tmQXp67YDaduvde7AX+cIdTtDCo2PBMeqv8SBOpnw= +cloud.google.com/go/recommendationengine v0.15.0/go.mod h1:Yx45rCF3A5fLSeXxSkXOCTXSBDBogrQnR7kUTJHwYxw= +cloud.google.com/go/recommender v1.19.0 h1:fJ6oO/7Ta/yzfRHcuJUln9iCeo6FDb5yIi2L7eLldzs= +cloud.google.com/go/recommender v1.19.0/go.mod h1:LRh+1HJjLx2kDE3S65AIlG/lvwA0llEFWYPD/QtgoaU= +cloud.google.com/go/redis v1.24.0 h1:lV6xFUF7t3fm2ZRFjB4IVNkznG9EVwetYVJYwzmW8pc= +cloud.google.com/go/redis v1.24.0/go.mod h1:ebtw9WLFKswecHO2ifNykuteNJNwoPqMCHz4UI11kF4= +cloud.google.com/go/resourcemanager v1.16.0 h1:aDf2RuuQ1Z+kbHHDzHyJNMHPGRFK+cMYfZIhWRaeRX0= +cloud.google.com/go/resourcemanager v1.16.0/go.mod h1:Hn4HPkLRnTuiUhFEFJg736Brt7BwlS84xYU06sc3STc= +cloud.google.com/go/resourcesettings v1.8.3 h1:13HOFU7v4cEvIHXSAQbinF4wp2Baybbq7q9FMctg1Ek= +cloud.google.com/go/resourcesettings v1.8.3/go.mod h1:BzgfXFHIWOOmHe6ZV9+r3OWfpHJgnqXy8jqwx4zTMLw= +cloud.google.com/go/retail v1.32.0 h1:u27GLYlnNsQrqzcvSlpZK0L6Ig8k3PEuXGkUdNFCOn4= +cloud.google.com/go/retail v1.32.0/go.mod h1:t9w9mBarD59BnFHTST2LoiCP5608ZlEfniHLgA6OoH0= +cloud.google.com/go/run v1.22.0 h1:U56fxJWdrT+yjo4S/Vrtw5m69NdNL11Cyv9jX2JOi1s= +cloud.google.com/go/run v1.22.0/go.mod h1:Wo0aTNrqfftGmbxPPraeOxSUDUZ2c7IVNg2dk8Qm1Bs= +cloud.google.com/go/scheduler v1.16.0 h1:EPdChptxnvCasdMixuu58247qhKMO1iAlrVaQhvuRyE= +cloud.google.com/go/scheduler v1.16.0/go.mod h1:0hsZg0MZJADyke1lutI0FHAYJR8Dtm8oIivXkmpACkA= +cloud.google.com/go/secretmanager v1.20.0 h1:GjE3NoyFXo7ipRPy26PMmg4oRX1Ra8fswH45r16rWV0= +cloud.google.com/go/secretmanager v1.20.0/go.mod h1:9OmSuOeiiUicANglrbdKWSnT3gYkRcXuUQDk7dDW0zU= +cloud.google.com/go/security v1.26.0 h1:xp/htSPHpyqo225Ju6PjNS9jxfcOEQMxnF229Oze62g= +cloud.google.com/go/security v1.26.0/go.mod h1:nd0i5OHXtJduMt0n6UnEojy7fiTfnfj/PSDeD7LAD+c= +cloud.google.com/go/securitycenter v1.45.0 h1:k5uzLtTSxnh4fwG+8nIcuwDjEE3J+6xe2wcZ72cys7s= +cloud.google.com/go/securitycenter v1.45.0/go.mod h1:7mAlzsCsKlEVmciAFORl431laDGpoKGFkSQndAzFs30= +cloud.google.com/go/servicedirectory v1.17.0 h1:yrohWkwM8t5JfEFCmmlyksKnpMpvxM8XbRpwg+yIo64= +cloud.google.com/go/servicedirectory v1.17.0/go.mod h1:CtgjXS1idj3s9Q6tB68021Rzk8Q6decV6+ldXC1BoBk= +cloud.google.com/go/shell v1.13.0 h1:vJ/g4BXCwBRMmUxHoNjdbE0DRh5Aysw/+vrZ/aPl0yc= +cloud.google.com/go/shell v1.13.0/go.mod h1:9WWf3xHQUElP5fL/lB9IJ/MMMnN2W/T86cBp+pXFFWo= +cloud.google.com/go/spanner v1.91.0 h1:XwXfcZ0kc1NT9Uu2IsThFiWtYptB+WgLn/KZEZcyzRg= +cloud.google.com/go/spanner v1.91.0/go.mod h1:8NB5a7qgwIhGD19Ly+vkpKffPL78vIG9RcrgsuREha0= +cloud.google.com/go/speech v1.36.0 h1:ZcmRKcY02vkF3o/Eaa9yI3i1baNFTF4ctyDZVRfnNS0= +cloud.google.com/go/speech v1.36.0/go.mod h1:tiSA8MiX49o1ngq5Ww2JFTvfjKxtAuBKY/UIH6coCPg= cloud.google.com/go/storage v1.56.0 h1:iixmq2Fse2tqxMbWhLWC9HfBj1qdxqAmiK8/eqtsLxI= cloud.google.com/go/storage v1.56.0/go.mod h1:Tpuj6t4NweCLzlNbw9Z9iwxEkrSem20AetIeH/shgVU= +cloud.google.com/go/storagetransfer v1.19.0 h1:jh+3SegMUulEhuJbkADCv8lmfRC8/pCpxja4oex2Ns8= +cloud.google.com/go/storagetransfer v1.19.0/go.mod h1:sy4ImXynHkm9CKmbILtmzLN36PHh7JOhUTpqXf5SvMs= +cloud.google.com/go/talent v1.14.0 h1:dUNSwgBUFlDEMHJpmntEvDeLkPQAoEzBrvDbNfS/UeQ= +cloud.google.com/go/talent v1.14.0/go.mod h1:jieYQngp1YqRtqV2t92w3LTrjuLV05kMM4BZMUUneaw= +cloud.google.com/go/texttospeech v1.22.0 h1:xGqQv2LB4nttaBNMepCm19EQ0Sk0YdjzPvklDU+LYsI= +cloud.google.com/go/texttospeech v1.22.0/go.mod h1:bAksATiWPKaw8r8wVgANa4GkVdsyFE4y9ulRzKyuJec= +cloud.google.com/go/tpu v1.14.0 h1:u2f8Lhezy6piu0BB3+4pTLw9xyOeU5n8PCgWjbjCitk= +cloud.google.com/go/tpu v1.14.0/go.mod h1:1pggTTG5npfxea6vYjyl60Fg09VgbM7efBgVjnFZjpo= cloud.google.com/go/trace v1.11.7 h1:kDNDX8JkaAG3R2nq1lIdkb7FCSi1rCmsEtKVsty7p+U= cloud.google.com/go/trace v1.11.7/go.mod h1:TNn9d5V3fQVf6s4SCveVMIBS2LJUqo73GACmq/Tky0s= +cloud.google.com/go/trace v1.16.0 h1:GmQovzFc5F0CNfl0VLgL64aoTtu7xsM0YajW2GlG9+E= +cloud.google.com/go/trace v1.16.0/go.mod h1:r+bdAn16dKLSV1G2D5v3e58IlQlizfxWrUfjx7kM7X0= +cloud.google.com/go/translate v1.18.0 h1:2dxWfGMG7y5vobxD2pPyngnfPPIk4MYdNB9QK5sEbuc= +cloud.google.com/go/translate v1.18.0/go.mod h1:aRVIE+P+7fngk8HwwFAgis5QA7wphGpKrFpdNoWtGCM= +cloud.google.com/go/video v1.33.0 h1:zPA41kNscRrJeRo/xD73TjNCFAnRDnP9ViNPuWARVeg= +cloud.google.com/go/video v1.33.0/go.mod h1:hEx8TNpQT6kdjMVsywePvT8BCb63Ee3F/R0GRa9wnzo= +cloud.google.com/go/videointelligence v1.17.0 h1:cd+s4jLMS59xiYLT6eQ6PVKP8R0PskgifXDa7YwMUUU= +cloud.google.com/go/videointelligence v1.17.0/go.mod h1:Phxz7AQpvXoOvz+KrrOZEJRo4CDgYXMDVDqhCtdF1jc= +cloud.google.com/go/vision/v2 v2.15.0 h1:aTR1vj4++WtS9HD6YdGuoaYygMTJ873WaoV9sYjlQCc= +cloud.google.com/go/vision/v2 v2.15.0/go.mod h1:DUdjdFkXqPvEoPC4WDYFvYCn0LlAZ4vVz29A0bXvW90= +cloud.google.com/go/vmmigration v1.16.0 h1:OPGMxx73owRHMve5B4L6W+0KQUwlunyE9kfbYzFHqug= +cloud.google.com/go/vmmigration v1.16.0/go.mod h1:ILrSjXnHMpdamkkAU8fjMKKMsH27B6FLC5kv/6TkLy0= +cloud.google.com/go/vmwareengine v1.9.0 h1:vdSutihjzH5iYEFlN+1x+gDm4xzj6Md2yMzXADKI5cQ= +cloud.google.com/go/vmwareengine v1.9.0/go.mod h1:zXXuUaIpvDhsV6sR+JdQfcQ4V5+pDarrp7FW7nOdS2I= +cloud.google.com/go/vpcaccess v1.14.0 h1:fFa1i67AjC/3MuG5GPlvx36sIMeffpsIs3kI1C7S3Jk= +cloud.google.com/go/vpcaccess v1.14.0/go.mod h1:MxbVgr+2fpIFIEIdSmgnb8ykNWRPVtslpmWijp7an68= +cloud.google.com/go/webrisk v1.17.0 h1:t2WMlBo3xXxH6k5kTSkyIYUl24AHgmBI76F/5OqAPRY= +cloud.google.com/go/webrisk v1.17.0/go.mod h1:ypwCZ+G/SXyUZ+x3ppxn1hu+6tDifGNd/OpwPtCdJHI= +cloud.google.com/go/websecurityscanner v1.12.0 h1:iV+hAXeEo8kKtFWDZWPp9Z0fsziZnuOt4nCCYp68RP0= +cloud.google.com/go/websecurityscanner v1.12.0/go.mod h1:cZSc9HqoFdccL1mqZtPIInOd4R8PBGwI20wdnrz6AO8= +cloud.google.com/go/workflows v1.20.0 h1:qROpn1zRDdeIjUP9w9O3MHXJEg8v/pzVMicAcw9vLvQ= +cloud.google.com/go/workflows v1.20.0/go.mod h1:TC9yx7VpjGdBBeKM8FG2EMtms5Q9nyTqI+2uV9bDNs4= +cyphar.com/go-pathrs v0.2.1 h1:9nx1vOgwVvX1mNBWDu93+vaceedpbsDqo+XuBGL40b8= +cyphar.com/go-pathrs v0.2.1/go.mod h1:y8f1EMG7r+hCuFf/rXsKqMJrJAUoADZGNh5/vZPKcGc= dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/Azure/go-autorest v14.2.0+incompatible h1:V5VMDjClD3GiElqLWO7mz2MxNAK/vTfRHdAubSIPRgs= +github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24= +github.com/Azure/go-autorest/autorest v0.11.18 h1:90Y4srNYrwOtAgVo3ndrQkTYn6kf1Eg/AjTFJ8Is2aM= +github.com/Azure/go-autorest/autorest v0.11.18/go.mod h1:dSiJPy22c3u0OtOKDNttNgqpNFY/GeWa7GH/Pz56QRA= +github.com/Azure/go-autorest/autorest/adal v0.9.13 h1:Mp5hbtOePIzM8pJVRa3YLrWWmZtoxRXqUEzCfJt3+/Q= +github.com/Azure/go-autorest/autorest/adal v0.9.13/go.mod h1:W/MM4U6nLxnIskrw4UwWzlHfGjwUS50aOsc/I3yuU8M= +github.com/Azure/go-autorest/autorest/date v0.3.0 h1:7gUk1U5M/CQbp9WoqinNzJar+8KY+LPI6wiWrP/myHw= +github.com/Azure/go-autorest/autorest/date v0.3.0/go.mod h1:BI0uouVdmngYNUzGWeSYnokU+TrmwEsOqdt8Y6sso74= +github.com/Azure/go-autorest/logger v0.2.1 h1:IG7i4p/mDa2Ce4TRyAO8IHnVhAVF3RFU+ZtXWSmf4Tg= +github.com/Azure/go-autorest/logger v0.2.1/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8= +github.com/Azure/go-autorest/tracing v0.6.0 h1:TYi4+3m5t6K48TGI9AUdb+IzbnSxvnvUMfuitfgcfuo= +github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs= +github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.34.0 h1:yzIYdwuro811Z27D3T80Wkd3rqZzb0K43nner7Eh1yE= github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.34.0/go.mod h1:pJTkW8hEUIIi3Pf65lPZOnn4Y81yCllX6IWk2jNXdkM= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.35.0 h1:bN1gA3of5bXtbnLsRPrwfmbbe7A5UWFlcTHseujLnpc= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.35.0/go.mod h1:Yj5vHEz/aAepZGliRJsA6uvHAVAQyEwajq9ORCHPxzM= github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0 h1:owcC2UnmsZycprQ5RfRgjydWhuoxg71LUfyiQdijZuM= github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0/go.mod h1:ZPpqegjbE99EPKsu3iUWV22A04wzGPcAY/ziSIQEEgs= github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.53.0 h1:4LP6hvB4I5ouTbGgWtixJhgED6xdf67twf9PoY96Tbg= @@ -46,27 +310,57 @@ github.com/Masterminds/semver/v3 v3.5.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lpr github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29 h1:0kQAzHq8vLs7Pptv+7TxjdETLf/nIqJpIB4oC6Ba4vY= +github.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29/go.mod h1:ZWa7ssZJT30CCDGJ7fk/2SBTq9BIQrrVjrcss0UW2s0= +github.com/NYTimes/gziphandler v1.1.1 h1:ZUDjpQae29j0ryrS0u/B8HZfJBtBQHjqw2rQ2cqUQ3I= +github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c= +github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw= github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE= +github.com/PuerkitoBio/purell v1.1.1 h1:WEQqlqaGbrPkxLJWfBwQmfEAE1Z7ONdDLqrN38tNFfI= +github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= +github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 h1:d+Bc7a5rLufV/sSk/8dngufqelfh6jnri85riMAaF/M= +github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8= github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= +github.com/antihax/optional v1.0.0 h1:xK2lYat7ZLaVVcIuj82J8kIro4V6kDe0AUDFboUCwcg= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ= +github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= github.com/aristanetworks/arista-ceoslab-operator/v2 v2.1.2 h1:1aAxwwu4xyfiU1/FX2D5x/jsF/sxFVkjVhvF661isM4= github.com/aristanetworks/arista-ceoslab-operator/v2 v2.1.2/go.mod h1:/mvSt2fEmlVEU7dppip3UNz/MUt380f50dFsZRGn83o= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/b4firex/ondatra v0.0.0-20261120174419-ff486025d4fa h1:ks4MQNGfeA+Vm/0xYooqjGG1NSwLK8mT1z3N51OSH6s= +github.com/b4firex/ondatra v0.0.0-20261120174419-ff486025d4fa/go.mod h1:fTAKgaYZar7dpD81aapPnXpTNm+MfqljpNyC/b1iovM= +github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.24.4 h1:95H15Og1clikBrKr/DuzMXkQzECs1M6hhoGXLwLQOZE= +github.com/bits-and-blooms/bitset v1.24.4/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= +github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= +github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= +github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= +github.com/briandowns/spinner v1.23.2 h1:Zc6ecUnI+YzLmJniCfDNaMbW0Wid1d5+qcTq4L2FW8w= +github.com/briandowns/spinner v1.23.2/go.mod h1:LaZeM4wm2Ywy6vO571mvhQNRcWfRUnXOs0RcKV0wYKM= +github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs= github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= +github.com/bwesterb/go-ristretto v1.2.3 h1:1w53tCkGhCQ5djbat3+MH0BAQ5Kfgbt56UZQ/JMzngw= +github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= github.com/carlmontanari/difflibgo v0.0.0-20210718194309-31b9e131c298 h1:Y8rTum6LZ8oP/2aC+OaaP76OCjHbunKMkim81mzNCH0= github.com/carlmontanari/difflibgo v0.0.0-20210718194309-31b9e131c298/go.mod h1:+3MuSIeC3qmdSesR12cTLeb47R/Vvo+bHdB6hC5HShk= github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw= +github.com/census-instrumentation/opencensus-proto v0.2.1 h1:glEXhBS5PSLLv4IXzLA5yPRVX4bilULVyxxbrfOtDAk= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= @@ -74,20 +368,35 @@ github.com/chappjc/logrus-prefix v0.0.0-20180227015900-3a1d64819adb h1:aZTKxMmin github.com/chappjc/logrus-prefix v0.0.0-20180227015900-3a1d64819adb/go.mod h1:xzXc1S/L+64uglB3pw54o8kqyM6KFYpTeC9Q6+qZIu8= github.com/cisco-open/go-p4 v0.1.2 h1:ycRluNWG3yz86pnEg78d87C25rx7fJQvEv5l77TKfQ0= github.com/cisco-open/go-p4 v0.1.2/go.mod h1:pXywOqfJvcYm7PB2qj8Ib3w9EvAAL44xLbGaUKpeX4Y= +github.com/client9/misspell v0.3.4 h1:ta993UF76GwbvJcIo3Y68y/M3WxlpEHPWIGDkJYwzJI= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8= github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403 h1:cqQfy1jclcSy/FwLjemeg3SR1yaINm74aQyupQ0Bl8M= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os8IaYg++6uMOdKK83QtkkvJik= github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= +github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI= +github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M= +github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE= +github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk= +github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= +github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= +github.com/containernetworking/cni v0.8.1 h1:7zpDnQ3T3s4ucOuJ/ZCLrYBxzkg0AELFfII3Epo9TmI= +github.com/containernetworking/cni v0.8.1/go.mod h1:LGwApLUm2FpoOfxTDEeq8T9ipbpZ61X79hmU3w8FmsY= +github.com/containernetworking/plugins v0.9.1 h1:FD1tADPls2EEi3flPc2OegIY1M9pUa9r2Quag7HMLV8= +github.com/containernetworking/plugins v0.9.1/go.mod h1:xP/idU2ldlzN6m4p5LmGiwRDjeJr6FLK6vuiUwoH7P8= github.com/coredhcp/coredhcp v0.0.0-20260217182248-a0841cb3038f h1:Bj+yhDYB9fypuXEJimRf9iRqHenZ/lqR7OPJ8e4GGQs= github.com/coredhcp/coredhcp v0.0.0-20260217182248-a0841cb3038f/go.mod h1:S6hmg58KixGhVg8FRxJhr2tSFKxqW+1umjwHiEqGwlo= +github.com/cpuguy83/go-md2man/v2 v2.0.6 h1:XJtiaUW6dEEqVuZiMTn1ldk455QWwEIsMIJlo5vtkx0= github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= +github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s= +github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE= github.com/cyphar/filepath-securejoin v0.6.1 h1:5CeZ1jPXEiYt3+Z6zqprSAgSWiggmpVyciv8syjIpVE= github.com/cyphar/filepath-securejoin v0.6.1/go.mod h1:A8hd4EnAeyujCJRrICiOWqjS1AX0a9kM5XL+NwKoYSc= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -96,17 +405,34 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y= github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/docker/distribution v2.8.0+incompatible h1:l9EaZDICImO1ngI+uTifW+ZYvvz7fKISBAKpg+MbWbY= +github.com/docker/distribution v2.8.0+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w= +github.com/docker/docker v28.5.2+incompatible h1:DBX0Y0zAjZbSrm1uzOkdr1onVghKaftjlSWt4AFexzM= +github.com/docker/docker v28.5.2+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/go-connections v0.8.2 h1:9d9DEokx5W7qlr0shkFXIxEA7+TTD+llwzcykSlxMNc= +github.com/docker/go-connections v0.8.2/go.mod h1:no1qkHdjq7kLMGUXYAduOhYPSJxxvgWBh7ogVvptn3Q= +github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= +github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 h1:bWDMxwH3px2JBh6AyO7hdCn/PkvCZXii8TGj7sbtEbQ= github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= github.com/drivenets/cdnos-controller v1.7.4 h1:UI6aJGfu1jny9sR1tC1+TNWVA+fuzsaedMyikqECrL4= github.com/drivenets/cdnos-controller v1.7.4/go.mod h1:s+rGGwx3UZ8TECpeC3htXJv+3sF+VK7fFiYgesxD0vA= +github.com/drivenets/cdnos-controller v1.7.9 h1:HVzIZ1yfpnfgCaxgUNRtZpNp2+W6TNagkwyijXmGFm0= +github.com/drivenets/cdnos-controller v1.7.9/go.mod h1:Y+oQvdUgyJRXtkxw00xggwNNz5P0MVlUU84CPidC8NQ= github.com/eapache/channels v1.1.0 h1:F1taHcn7/F0i8DYqKXJnyhJcVpp2kgFcNePxXtnyu4k= github.com/eapache/channels v1.1.0/go.mod h1:jMm2qB5Ubtg9zLd+inMZd2/NUvXgzmWXsDaLyQIGfH0= github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o= github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE= +github.com/emicklei/go-restful v2.9.5+incompatible h1:spTtZBk5DYEvbxMVutUuTyh1Ao2r4iyvLdACqsl/Ljk= +github.com/emicklei/go-restful v2.9.5+incompatible/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs= github.com/emicklei/go-restful/v3 v3.10.2 h1:hIovbnmBTLjHXkqEBUz3HGpXZdM7ZrE9fJIZIqlJLqE= github.com/emicklei/go-restful/v3 v3.10.2/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +github.com/emicklei/go-restful/v3 v3.13.0 h1:C4Bl2xDndpU6nJ4bc1jXd+uTmYPVUwkD6bFY/oTyCes= +github.com/emicklei/go-restful/v3 v3.13.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= @@ -118,6 +444,8 @@ github.com/envoyproxy/go-control-plane v0.14.0 h1:hbG2kr4RuFj222B6+7T83thSPqLjwB github.com/envoyproxy/go-control-plane v0.14.0/go.mod h1:NcS5X47pLl/hfqxU70yPwL9ZMkUlwlKxtAohpi2wBEU= github.com/envoyproxy/go-control-plane/envoy v1.37.0 h1:u3riX6BoYRfF4Dr7dwSOroNfdSbEPe9Yyl09/B6wBrQ= github.com/envoyproxy/go-control-plane/envoy v1.37.0/go.mod h1:DReE9MMrmecPy+YvQOAOHNYMALuowAnbjjEMkkWOi6A= +github.com/envoyproxy/go-control-plane/envoy v1.39.1-0.20260819172001-e6e3fd93e4be h1:SWe0x6yfglnxuvOiYgTTnNq7QD/yvqthOh1RBI8Bj8w= +github.com/envoyproxy/go-control-plane/envoy v1.39.1-0.20260819172001-e6e3fd93e4be/go.mod h1:PYEOlng9XcrulfyWpm49jECTPV0LT4q8cO7fLW/xwgk= github.com/envoyproxy/go-control-plane/ratelimit v0.1.0 h1:/G9QYbddjL25KvtKTv3an9lx6VBE2cnb8wp1vEGNYGI= github.com/envoyproxy/go-control-plane/ratelimit v0.1.0/go.mod h1:Wk+tMFAFbCXaJPzVVHnPgRKdUdwW/KdbRt94AzgRee4= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= @@ -127,17 +455,28 @@ github.com/evanphx/json-patch v5.6.0+incompatible h1:jBYDEEiFBPxA0v50tFdvOzQQTCv github.com/evanphx/json-patch v5.6.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/evanphx/json-patch/v5 v5.6.0 h1:b91NhWfaz02IuVxO9faSllyAtNXHMPkC5J8sJCLunww= github.com/evanphx/json-patch/v5 v5.6.0/go.mod h1:G79N1coSVB93tBe7j6PhzjmR3/2VvlbKOFpnXhI9Bw4= +github.com/evanphx/json-patch/v5 v5.9.11 h1:/8HVnzMq13/3x9TPvjG08wUGqBTmZBsCWzjTM0wiaDU= +github.com/evanphx/json-patch/v5 v5.9.11/go.mod h1:3j+LviiESTElxA4p3EMKAB9HXj3/XEtnUf6OZxqIQTM= +github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= +github.com/flowstack/go-jsonschema v0.1.1 h1:dCrjGJRXIlbDsLAgTJZTjhwUJnnxVWl1OgNyYh5nyDc= github.com/flowstack/go-jsonschema v0.1.1/go.mod h1:yL7fNggx1o8rm9RlgXv7hTBWxdBM0rVwpMwimd3F3N0= +github.com/form3tech-oss/jwt-go v3.2.3+incompatible h1:7ZaBxOI7TMoYBfyA3cQHErNNyAWIKUMIwqxEtgHOs5c= +github.com/form3tech-oss/jwt-go v3.2.3+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho= github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo= +github.com/fxamacker/cbor/v2 v2.9.1 h1:2rWm8B193Ll4VdjsJY28jxs70IdDsHRWgQYAI80+rMQ= +github.com/fxamacker/cbor/v2 v2.9.1/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c= github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU= +github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= +github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= github.com/go-git/go-billy/v5 v5.9.0 h1:jItGXszUDRtR/AlferWPTMN4j38BQ88XnXKbilmmBPA= @@ -148,7 +487,9 @@ github.com/go-git/go-git/v5 v5.19.2 h1:wkfn7vOlUBu8ivAWKBWisTiwJK4jYHzTF8Ndv1LyG github.com/go-git/go-git/v5 v5.19.2/go.mod h1:QqCBE1EFN5ddFmrliLQ3/ntRCUjZU3EJuwuB/jWEHjk= github.com/go-jose/go-jose/v4 v4.1.4 h1:moDMcTHmvE6Groj34emNPLs/qtYXRVcd6S7NHbHz3kA= github.com/go-jose/go-jose/v4 v4.1.4/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08= +github.com/go-kit/log v0.1.0 h1:DGJh0Sm43HbOeYDNnVZFl8BvcYVvjD5bqYJvp0REbwQ= github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= +github.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= @@ -157,10 +498,26 @@ github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-logr/zapr v1.2.3 h1:a9vnzlIBPQBBkeaR9IuMUfmVOrQlkoC4YfPoFkX3T7A= github.com/go-logr/zapr v1.2.3/go.mod h1:eIauM6P8qSvTw5o2ez6UEAfGjQKrxQTl5EoK+Qa2oG4= +github.com/go-logr/zapr v1.3.0 h1:XGdV8XW8zdwFiwOA2Dryh1gj2KRQyOOoNmBy4EplIcQ= +github.com/go-logr/zapr v1.3.0/go.mod h1:YKepepNBd1u/oyhd/yQmtjVXmm9uML4IXUgMOwR8/Gg= +github.com/go-openapi/analysis v1.0.0 h1:sNvbAGCJqUTqIAodr9IVqJMmuZas3YS9ms1dGK9yiJ4= +github.com/go-openapi/analysis v1.0.0/go.mod h1:NhYjJ57fnE+bcE7UwrJyMkhWA3Dfz7TdiBfTVAnos4Y= +github.com/go-openapi/errors v0.22.9 h1:HI9+SyVYiRzyeBQGv0CbWbQa+u2S0nny7G7AhY+UMiM= +github.com/go-openapi/errors v0.22.9/go.mod h1:R73q66sXP2smzAGgFOI4nqtusRK2xN5pYCjsij+KX58= github.com/go-openapi/jsonpointer v1.0.1 h1:2KxywRmNwJkT/FMBa3iRNHEaAxSJvjqoufQZy3au1Mg= github.com/go-openapi/jsonpointer v1.0.1/go.mod h1:wI7ZYsFmbIi9nBXOZqgDaS/bqOchRGZjqxFli7FBYxY= github.com/go-openapi/jsonreference v1.0.1 h1:4zJ7AmYDKNmD3aSpfPnFNCFA5E80/xMHUNKgydaLh38= github.com/go-openapi/jsonreference v1.0.1/go.mod h1:dYplQXa6p5lXprLcJ8LE2iU7vNpXsAHDQ5ZAgL+Qx3A= +github.com/go-openapi/loads v0.25.2 h1:+uNsDlRQfYtZTrh+3pdwampcAqZVPuBJW0IA82aZHII= +github.com/go-openapi/loads v0.25.2/go.mod h1:RXsfJEQGGNv4uw8u/KdmF8Vh8OR4fTfs9ZO4QrzNohA= +github.com/go-openapi/runtime v0.33.2 h1:HSxskMs0WmpCdQvBWVxHt2t2mXMwn8DDav3VtVidwig= +github.com/go-openapi/runtime v0.33.2/go.mod h1:NQpSLiIsEAIpZDEs6xUrhjm6ZiQh85X8bHKlqLPgNP8= +github.com/go-openapi/runtime/server-middleware v0.33.2 h1:BVFjAaW4Jh/kZ4QSsgDrGzLuSuaKzSiyvappUFKxgUk= +github.com/go-openapi/runtime/server-middleware v0.33.2/go.mod h1:E3mWY61/UgBJ5EUmKh+h6A1oQQdD1U4raowVMmPmQug= +github.com/go-openapi/spec v1.0.0 h1:JtB/GHOj+eetjse6YvxqLze88oEekl/4uPBethvzRrA= +github.com/go-openapi/spec v1.0.0/go.mod h1:boj1PRhqS0x5jylgcNp9BRWxenphrh7vVNYZ90IRCoo= +github.com/go-openapi/strfmt v0.27.2 h1:SG32SlbwNy92s0KJiVxt2joJeFdqIYHvwrA0OU6HqzQ= +github.com/go-openapi/strfmt v0.27.2/go.mod h1:M4CKsMO0Fb8qR10+1Ra75wCKNNquy+Vj+4LWZrhTo2E= github.com/go-openapi/swag v0.29.2 h1:9n8frkcsuQRA0INU31VbxNxt1zBaHxrHYGEf5BUjFi4= github.com/go-openapi/swag v0.29.2/go.mod h1:RkCiX1gCVXWgLOavDXE3ALJrQ/VO2ziiIzOUs3z10xo= github.com/go-openapi/swag/cmdutils v0.29.2 h1:cXEzX/nWCODon251f+1HgL75/R4XXML5IZxgLCWMoro= @@ -169,6 +526,8 @@ github.com/go-openapi/swag/conv v0.29.2 h1:8c9shoB8l0QRSR6ymq1llHdBWDqpIgJfjTGHx github.com/go-openapi/swag/conv v0.29.2/go.mod h1:AZS0YigTNf8qNtD6WqJz/N4RUNmpr76SyjFGkq4+p6Q= github.com/go-openapi/swag/fileutils v0.29.2 h1:mdUL+Vw5ah1fO1AvFCoHeIyv7YZsCz2MN3KNqd/lLVI= github.com/go-openapi/swag/fileutils v0.29.2/go.mod h1:7QKmmodjAebaq61lGVJa8ldLdGeMF4DSgYv8tXOGGo0= +github.com/go-openapi/swag/jsonname v0.25.5 h1:8p150i44rv/Drip4vWI3kGi9+4W9TdI3US3uUYSFhSo= +github.com/go-openapi/swag/jsonname v0.25.5/go.mod h1:jNqqikyiAK56uS7n8sLkdaNY/uq6+D2m2LANat09pKU= github.com/go-openapi/swag/jsonutils v0.29.2 h1:uZNSD2/rJDYAfvsLYkykTzXuyxM3QpDKV9jhRHrMu6k= github.com/go-openapi/swag/jsonutils v0.29.2/go.mod h1:ONTdNvj3Y+IXRzfa17E+Rgt2ns/qiSOYjIo2K7v2yDs= github.com/go-openapi/swag/jsonutils/fixtures_test v0.29.2 h1:w+Fd6EBOMGlC74GYGHqCLGyb3Bpams8TtNrgM/SG4jo= @@ -191,9 +550,14 @@ github.com/go-openapi/testify/enable/yaml/v2 v2.7.0 h1:wPW6YRgx3+SID1yUy/Xwa17L8 github.com/go-openapi/testify/enable/yaml/v2 v2.7.0/go.mod h1:mI1M88etYbc3PhgHsWQK2kwvNwW5aGFqMPbmib+SGIs= github.com/go-openapi/testify/v2 v2.7.0 h1:bycOreEj6wfBvijg3YFogZ/sFjTCDmQnwSodSzHa3X8= github.com/go-openapi/testify/v2 v2.7.0/go.mod h1:SgsVHtfooshd0tublTtJ50FPKhujf47YRqauXXOUxfw= +github.com/go-openapi/validate v1.0.0 h1:dFsYCLVUQUL6Vi2lQSexgwmCXDuHe7eWRDhQxkE+xYA= +github.com/go-openapi/validate v1.0.0/go.mod h1:wwXGRqMQzOZ7PCqBcgNk+DD9+Cacnxv7we5T0M/eA3Y= +github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI= github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= github.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro= github.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= @@ -205,6 +569,8 @@ github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4er github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ= github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= @@ -220,8 +586,16 @@ github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaS github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg= +github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4= +github.com/google/cel-go v0.27.0 h1:e7ih85+4qVrBuqQWTW4FKSqZYokVuc3HnhH5keboFTo= +github.com/google/cel-go v0.27.0/go.mod h1:tTJ11FWqnhw5KKpnWpvW9CJC3Y9GK4EIS0WXnBbebzw= github.com/google/gnostic v0.6.9 h1:ZK/5VhkoX835RikCHpSUJV9a+S3e1zLh59YnyWeBW+0= github.com/google/gnostic v0.6.9/go.mod h1:Nm8234We1lq6iB9OmlgNv3nH91XLLVZHCDayfA3xq+E= +github.com/google/gnostic-models v0.7.1 h1:SisTfuFKJSKM5CPZkffwi6coztzzeYUhc3v4yxLWH8c= +github.com/google/gnostic-models v0.7.1/go.mod h1:whL5G0m6dmc5cPxKc5bdKdEN3UjI7OUGxBlw57miDrQ= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= @@ -234,8 +608,12 @@ github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeN github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/go-github v17.0.0+incompatible h1:N0LgJ1j65A7kfXrZnUDaYCs/Sf4rEjNlfyDHW9dolSY= +github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ= github.com/google/go-github/v50 v50.1.0 h1:hMUpkZjklC5GJ+c3GquSqOP/T4BNsB7XohaPhtMOzRk= github.com/google/go-github/v50 v50.1.0/go.mod h1:Ev4Tre8QoKiolvbpOSG3FIi4Mlon3S2Nt9W5JYqKiwA= +github.com/google/go-pkcs11 v0.3.0 h1:PVRnTgtArZ3QQqTGtbtjtnIkzl2iY2kt24yqbrf7td8= +github.com/google/go-pkcs11 v0.3.0/go.mod h1:6eQoGcuNJpa7jnd5pMGdkSaQpNDYvPlXWMcjXXThLlY= github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= github.com/google/go-tpm v0.9.8 h1:slArAR9Ft+1ybZu0lBwpSmpwhRXaa85hWtMinMyRAWo= @@ -251,27 +629,52 @@ github.com/google/martian/v3 v3.3.3 h1:DIhPTQrbPkgs2yJYdXU/eNACCG5DVQjySNRNlflZ9 github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0= github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1 h1:K6RDEckDVWvDI9JAJYCmNdQXq6neHJOYx3V6jnqNEec= github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8= +github.com/google/pprof v0.0.0-20250403155104-27863c87afa6/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA= github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= +github.com/google/s2a-go v0.1.11 h1:7v1V1TraNGP63WptsAkNqr2w8jgm4vM6A6qx6Lsw9iM= +github.com/google/s2a-go v0.1.11/go.mod h1:pz4tyvwXvJLLbyrkh6FW1eS2zPUXMaTmyNhYtyP2tNw= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/enterprise-certificate-proxy v0.3.15 h1:xolVQTEXusUcAA5UgtyRLjelpFFHWlPQ4XfWGc7MBas= github.com/googleapis/enterprise-certificate-proxy v0.3.15/go.mod h1:vqVt9yG9480NtzREnTlmGSBmFrA+bzb0yl0TxoBQXOg= +github.com/googleapis/enterprise-certificate-proxy v0.3.23 h1:J+VGF1wjAM2dU2kKUXZxJdDppRLReWP7KWcclfngQhc= +github.com/googleapis/enterprise-certificate-proxy v0.3.23/go.mod h1:Y8NO/15GNLkrXI3OR5xOFmeU3XLX1sLSdtlXgJ0zmIw= github.com/googleapis/gax-go/v2 v2.22.0 h1:PjIWBpgGIVKGoCXuiCoP64altEJCj3/Ei+kSU5vlZD4= github.com/googleapis/gax-go/v2 v2.22.0/go.mod h1:irWBbALSr0Sk3qlqb9SyJ1h68WjgeFuiOzI4Rqw5+aY= +github.com/googleapis/gax-go/v2 v2.26.2 h1:ydkmNXxj7bEmmeK5AihkKnWxyOyBR9TDebvp5L5izk8= +github.com/googleapis/gax-go/v2 v2.26.2/go.mod h1:sMKqnMesnKH+3wiRJROcttA+cJoZoGbZl1vDQ8XYtGk= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= +github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 h1:JeSE6pjso5THxAzdVpqr6/geYxZytqFMBCOtn/ujyeo= +github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674/go.mod h1:r4w70xmWCQKmi1ONH4KIaBptdivuRPyosB9RmPlGEwA= github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI= github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8= +github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/grpc-ecosystem/grpc-gateway/v2 v2.31.0 h1:Bd7KaOxzULLxtZ/K5s1aLbWhR0+5RToO65TXHsf3bqQ= github.com/grpc-ecosystem/grpc-gateway/v2 v2.31.0/go.mod h1:nN7ts3dFXKtCZWc//yfkpcQNKJABg16/uDVAZpLDalo= github.com/h-fam/errdiff v1.0.2 h1:rPsW4ob2fMOIulwTEoZXaaUIuud7XUudw5SLKTZj3Ss= github.com/h-fam/errdiff v1.0.2/go.mod h1:FOzgnHXSEE3rRvmGXgmiqWl+H3lwLywYm9CSXqXrSTg= +github.com/hashicorp/go-version v1.9.0 h1:CeOIz6k+LoN3qX9Z0tyQrPtiB1DFYRPfCIBtaXPSCnA= +github.com/hashicorp/go-version v1.9.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hugelgupf/socketpair v0.0.0-20190730060125-05d35a94e714 h1:/jC7qQFrv8CrSJVmaolDVOxTfS9kc36uB6H40kdbQq8= +github.com/hugelgupf/socketpair v0.0.0-20190730060125-05d35a94e714/go.mod h1:2Goc3h8EklBH5mspfHFxBnEoURQCGzQQH1ga9Myjvis= +github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI= +github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/imdario/mergo v0.3.15 h1:M8XP7IuFNsqUx6VPK2P9OSmsYsI/YFaGil0uD21V3dM= github.com/imdario/mergo v0.3.15/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY= +github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4= +github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/insomniacslk/dhcp v0.0.0-20260407060928-11b94ed970f2 h1:G3irkWwmpl0vH/nn83K2AHqLUZweC7XAONuwXy/w9Co= @@ -279,8 +682,14 @@ github.com/insomniacslk/dhcp v0.0.0-20260407060928-11b94ed970f2/go.mod h1:qfvBmy github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jessevdk/go-flags v1.6.1 h1:Cvu5U8UGrLay1rZfv/zP7iLpSHGUZ/Ou68T0iX1bBK4= +github.com/jessevdk/go-flags v1.6.1/go.mod h1:Mk8T1hIAWpOiJiHa9rJASDK2UGWji0EuPGBnNLMooyc= +github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/josharian/native v1.1.0 h1:uuaP0hAbW7Y4l0ZRQ6C9zfb7Mg1mbFKry/xzDAfmtLA= github.com/josharian/native v1.1.0/go.mod h1:7X/raswPFr05uY3HiLlYeyQntB6OO7E/d2Cu7qoaN2w= +github.com/jsimonetti/rtnetlink v1.3.5 h1:hVlNQNRlLDGZz31gBPicsG7Q53rnlsz1l1Ix/9XlpVA= +github.com/jsimonetti/rtnetlink v1.3.5/go.mod h1:0LFedyiTkebnd43tE4YAkWGIq9jQphow4CcwxaT2Y00= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report/v2 v2.1.0 h1:X3+hPYlSczH9IMIpSC9CQSZA0L+BipYafciZUWHEmsc= @@ -291,29 +700,47 @@ github.com/kentik/patricia v1.2.1 h1:+ZyPXnEiFLbmT1yZR0JRfRUuNXmxROXdzI8YiSpTx5w github.com/kentik/patricia v1.2.1/go.mod h1:6jY40ESetsbfi04/S12iJlsiS6DYL2B2W+WAcqoDHtw= github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= +github.com/kisielk/errcheck v1.5.0 h1:e8esj/e4R+SAOwFwN+n3zr0nYeCyeweozKfO23MvHzY= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= +github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/lyft/protoc-gen-star/v2 v2.0.4 h1:JDlNKttNIRd68AAIychs0AqEpO8/I/WYi01OQ7Raw6Q= +github.com/lyft/protoc-gen-star/v2 v2.0.4/go.mod h1:amey7yeodaJhXSbf/TlLvWiqQfLOSpEk//mLlc+axEk= +github.com/magiconair/properties v1.8.9 h1:nWcCbLq1N2v/cpNsy5WvQ37Fb+YElfq20WJ/a8RkpQM= +github.com/magiconair/properties v1.8.9/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-sqlite3 v1.14.32 h1:JD12Ag3oLy1zQA+BNn74xRgaBbdhbNIDYvQUEuuErjs= +github.com/mattn/go-sqlite3 v1.14.32/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/mdlayher/netlink v1.7.2 h1:/UtM3ofJap7Vl4QWCPDGXY8d3GIY2UGSDbK+QWmY8/g= +github.com/mdlayher/netlink v1.7.2/go.mod h1:xraEF7uJbxLhc5fpHL4cPe221LI2bdttWlU+ZGLfQSw= github.com/mdlayher/packet v1.1.2 h1:3Up1NG6LZrsgDVn6X4L9Ge/iyRyxFEFD9o6Pr3Q1nQY= github.com/mdlayher/packet v1.1.2/go.mod h1:GEu1+n9sG5VtiRE4SydOmX5GTwyyYlteZiFU+x0kew4= github.com/mdlayher/socket v0.4.1 h1:eM9y2/jlbs1M615oshPQOHZzj6R6wMT7bX5NPiQvn2U= @@ -322,29 +749,71 @@ github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d h1:5PJl274Y63IEHC+7izoQ github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE= github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= +github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= +github.com/moby/go-archive v0.1.0 h1:Kk/5rdW/g+H8NHdJW2gsXyZ7UnzvJNOy6VKJqueWdcQ= +github.com/moby/go-archive v0.1.0/go.mod h1:G9B+YoujNohJmrIYFBpSd54GTUB4lt9S+xVQvsJyFuo= +github.com/moby/moby v28.5.2+incompatible h1:hIn6qcenb3JY1E3STwqEbBvJ8bha+u1LpqjX4CBvNCk= +github.com/moby/moby v28.5.2+incompatible/go.mod h1:fDXVQ6+S340veQPv35CzDahGBmHsiclFwfEygB/TWMc= +github.com/moby/moby/api v1.56.1 h1:PpWkvVPB7Fr/No8w+TfyJ/I6rWZ2YPZhT3JorIg+06c= +github.com/moby/moby/api v1.56.1/go.mod h1:sZ+THbVWkjOmBPPfbnzdD/G1LuIexWhqlSHHPTDQ1Uk= +github.com/moby/moby/client v0.6.2 h1:ekSPlMccrZGcw6Scb8T9D39qE0mB+XupU/yS0zNw9N4= +github.com/moby/moby/client v0.6.2/go.mod h1:DGcnO7qmPJrqobx/ggQgQ/AUk+2wgVdQv7uxB0/mEsc= +github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk= +github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc= github.com/moby/spdystream v0.5.1 h1:9sNYeYZUcci9R6/w7KDaFWEWeV4LStVG78Mpyq/Zm/Y= github.com/moby/spdystream v0.5.1/go.mod h1:xBAYlnt/ay+11ShkdFKNAG7LsyK/tmNBVvVOwrfMgdI= +github.com/moby/sys/atomicwriter v0.1.0 h1:kw5D/EqkBwsBFi0ss9v1VG3wIkVhzGvLklJ+w3A14Sw= +github.com/moby/sys/atomicwriter v0.1.0/go.mod h1:Ul8oqv2ZMNHOceF643P6FKPXeCmYtlQMvpizfsSoaWs= +github.com/moby/sys/sequential v0.6.0 h1:qrx7XFUd/5DxtqcoH1h438hF5TmOvzC/lspjy7zgvCU= +github.com/moby/sys/sequential v0.6.0/go.mod h1:uyv8EUTrca5PnDsdMGXhZe6CCe8U/UiTWd+lL+7b/Ko= +github.com/moby/sys/user v0.4.0 h1:jhcMKit7SA80hivmFJcbB1vqmw//wU61Zdui2eQXuMs= +github.com/moby/sys/user v0.4.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85uoHjs= +github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g= +github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28= +github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ= +github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= +github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f h1:y5//uYreIhSUg3J1GEMiLbxo1LJaP8RfCpH6pymGZus= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw= github.com/networkop/meshnet-cni v0.3.1-0.20230525201116-d7c306c635cf h1:9Pe9L0QCovb9o82inAVQitCo3IRnG9u45lRRm8QvgbU= github.com/networkop/meshnet-cni v0.3.1-0.20230525201116-d7c306c635cf/go.mod h1:VMkJl7N6e14GTWS0AnCDrnvJOT67hwOFVUcxTzt/EtE= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= +github.com/oapi-codegen/runtime v1.7.0 h1:t7358VYPvNbWJ9gdAkIK/smVeHpBf6yp8VTsaZsb/7k= +github.com/oapi-codegen/runtime v1.7.0/go.mod h1:GwV7hC2hviaMzj+ITfHVRESK5J2W/GefVwIND/bMGvU= +github.com/oklog/ulid/v2 v2.1.2 h1:IEclFb9JNvzYA6MW2SCxbLzcHTVsfqm3PrqGQJH5zec= +github.com/oklog/ulid/v2 v2.1.2/go.mod h1:rcEKHmBBKfef9DhnvX7y1HZBYxjXb0cP5ExxNsTT1QQ= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/ginkgo/v2 v2.9.2 h1:BA2GMJOtfGAfagzYtrAlufIP0lq6QERkFmHLMLPwFSU= github.com/onsi/ginkgo/v2 v2.9.2/go.mod h1:WHcJJG2dIlcCqVfBAwUCrJxSPFb6v4azBwgxeMeDuts= +github.com/onsi/ginkgo/v2 v2.27.4 h1:fcEcQW/A++6aZAZQNUmNjvA9PSOzefMJBerHJ4t8v8Y= +github.com/onsi/ginkgo/v2 v2.27.4/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo= github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= +github.com/onsi/gomega v1.39.0 h1:y2ROC3hKFmQZJNFeGAMeHZKkjBL65mIZcvrLQBF9k6Q= +github.com/onsi/gomega v1.39.0/go.mod h1:ZCU1pkQcXDO5Sl9/VVEGlDyp+zm0m1cmeG5TOzLgdh4= github.com/open-traffic-generator/keng-operator v0.3.28 h1:FpDe1wtGODN7ByAhF2LxMIlbDqb5yVmbSE5Y49nyc28= github.com/open-traffic-generator/keng-operator v0.3.28/go.mod h1:+koaOnSyrJHdzxnaye+M6k+ZbszQlWI9u3tMxSpORNA= +github.com/open-traffic-generator/keng-operator v0.4.4 h1:zTwQBv23+31acdpedLT/YOEZ++jbQPJQHmRknQPwwo4= +github.com/open-traffic-generator/keng-operator v0.4.4/go.mod h1:wx3uQ0BksX240XbfzhfAw5ezNsQTA/ZsxKB12nY/1rM= github.com/open-traffic-generator/snappi/gosnappi v1.61.1 h1:zUqpuJtW0+Gtz3dO0KzrRKWyg+86iDWo7eLDhpe57To= github.com/open-traffic-generator/snappi/gosnappi v1.61.1/go.mod h1:bJjeYas1fQjkM8BWOUI749+OUIxfyV3jpEsaX3FUxyM= +github.com/open-traffic-generator/snappi/gosnappi v1.62.0 h1:YasOgXVeJXR15eQArUNgQO8Q1cqJBtq3k1l/DMzXQyU= +github.com/open-traffic-generator/snappi/gosnappi v1.62.0/go.mod h1:18dMKRwM+09c8xQVPRX2iQD9EFpLUDB3lF7LM9LL9Ow= github.com/openconfig/attestz v0.6.15 h1:m8UOHvV+r8eDahJdnouQmDhkx/ZmkHatfoexQZ5pKdg= github.com/openconfig/attestz v0.6.15/go.mod h1:76Q6+o1Ihd4T3UTUfL86nWwI38nGYvpl7wkaXfe1In0= github.com/openconfig/bootz v0.7.1 h1:/dNcCgTcE2QPA/K7D4Zlwu+E/MeGLN6bpHHI051HUns= @@ -377,10 +846,16 @@ github.com/openconfig/grpctunnel v0.1.0 h1:EN99qtlExZczgQgp5ANnHRC/Rs62cAG+Tz2BQ github.com/openconfig/grpctunnel v0.1.0/go.mod h1:G04Pdu0pml98tdvXrvLaU+EBo3PxYfI9MYqpvdaEHLo= github.com/openconfig/kne v0.1.18 h1:8D9SexWhj6knxfvEficyVj0F13GIvF1pQz7TKwVDSUI= github.com/openconfig/kne v0.1.18/go.mod h1:VMKjKI9FoVTLh4uN94uoaFZCp1CDkml2Ms2qOi1B2WM= +github.com/openconfig/kne v0.3.5 h1:yAX6PnzrsifIkdS8g1sDvn7hY2Ct+ZR5e2TYBilZFMQ= +github.com/openconfig/kne v0.3.5/go.mod h1:17DeKgcwoDDY7ohxTU56HZq0bIooKUobK9uEaGTgcFw= +github.com/openconfig/kne/third_party/meshnet v0.5.5 h1:frtQ2W79anp9EgZD3JxtIrwLTVdzYba0DowDyNR17kI= +github.com/openconfig/kne/third_party/meshnet v0.5.5/go.mod h1:wde6RUlesK2tpnwUJo2yoX7sopNiWUwaIdNJaAnBAl8= github.com/openconfig/lemming v0.5.1 h1:Zk1HgdWDkDTYB/HSF9k17adB7wbUXlb38ss8MlVx0NQ= github.com/openconfig/lemming v0.5.1/go.mod h1:X2ilf2qGdOoJ+cXiB1d/MjlulcnpDOCh3W8AHHWuhnU= github.com/openconfig/lemming/operator v0.2.0 h1:dovZnR6lQkOHXcODli1NDOr/GVYrBY05KS5X11jxVbw= github.com/openconfig/lemming/operator v0.2.0/go.mod h1:LKgEXSR5VK2CAeh2uKijKAXFj42uQuwakrCHVPF0iII= +github.com/openconfig/lemming/operator v0.2.9 h1:l7XGj0kI2KtWonh5InTgVAfc5epErJWhy/s8uxj+7ZI= +github.com/openconfig/lemming/operator v0.2.9/go.mod h1:pUjAPw3FU9BUI/3xwkPooURsJ1oIYQHppWlNyzW0AGw= github.com/openconfig/models-ci v1.0.2-0.20231113233730-f0986391428e h1:6N4jXpZa/SXYcNpJFjjZvenxO/xnTwuUCgCEinhNLfU= github.com/openconfig/models-ci v1.0.2-0.20231113233730-f0986391428e/go.mod h1:w38G/kObu95PbtwMYVp6SKhkHCegJFwL8B58Ns84g4s= github.com/openconfig/ondatra v0.14.10 h1:fz11LoYFpLPLYmnLwMiSGKlr69d6eEJ9WNSoTYran/E= @@ -393,6 +868,11 @@ github.com/openconfig/ygnmi v0.15.0 h1:Cio+fv7+c8G/w3KpO9CK7BLLEMdBy9bO1q3RRsd5x github.com/openconfig/ygnmi v0.15.0/go.mod h1:COooftumNKJimjY1AY8Zoem+pLtTj9lpDBz6s21GXCo= github.com/openconfig/ygot v0.35.0 h1:RCS7a5h40cyGAZQjQZGA7SunPuKl188l94DYTnHFX9A= github.com/openconfig/ygot v0.35.0/go.mod h1:bMjol0ooiK1suQZ8vG3OVj+I6D8yk9/aP6zXCf+V0kQ= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040= +github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M= +github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU= github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/osrg/gobgp/v3 v3.27.1-0.20240614010451-0148e2d22dcf h1:KrVLbjNucHf+LrrGcwrH6hN0RyfmbPx9Vk5/iBsFfYY= github.com/osrg/gobgp/v3 v3.27.1-0.20240614010451-0148e2d22dcf/go.mod h1:ZGeSti9mURR/o5hf5R6T1FM5g1yiEBZbhP+TuqYJUpI= @@ -400,14 +880,19 @@ github.com/p4lang/p4runtime v1.5.0 h1:GSccPwIFfeRjyrUSDe19DmqsHia7tGsU8vFuH2JxPT github.com/p4lang/p4runtime v1.5.0/go.mod h1:exHLJdkEhs+S2DLCkdvHnLbw9uyJoIbAzwMmHUeD37Y= github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc= github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ= +github.com/pborman/getopt v1.1.0 h1:eJ3aFZroQqq0bWmraivjQNt6Dmm5M0h2JcDW38/Azb0= +github.com/pborman/getopt v1.1.0/go.mod h1:FxXoW1Re00sQG/+KIkuSqRL/LwQgSkv7uyac+STFsbk= github.com/pborman/uuid v1.2.1 h1:+ZZIw58t/ozdjRaXh/3awHfmWRbzYxJoAdNJxe/3pvw= github.com/pborman/uuid v1.2.1/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pelletier/go-toml/v2 v2.4.3 h1:GTRvJQutkOSftxIFD5xw9aepkYNuPWmVJpffdDPYVpY= github.com/pelletier/go-toml/v2 v2.4.3/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= +github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI= +github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU= github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU= github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= github.com/pjbgf/sha1cd v0.6.0 h1:3WJ8Wz8gvDz29quX1OcEmkAlUg9diU4GxJHqs0/XiwU= github.com/pjbgf/sha1cd v0.6.0/go.mod h1:lhpGlyHLpQZoxMv8HcgXvZEhcGs0PG/vsZnEJ7H0iCM= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e h1:aoZm08cpOy4WuID//EZDgcC4zIxODThtZNPirFr42+A= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -419,29 +904,45 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw= github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y= +github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= +github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= github.com/prometheus/common v0.42.0 h1:EKsfXEYo4JpWMHH5cg+KOUWeuJSov1Id8zGR8eeI1YM= github.com/prometheus/common v0.42.0/go.mod h1:xBwqVerjNdUDjgODMpudtOMwlOwf2SaTr1yjz4b7Zbc= +github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4= +github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw= github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI= github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY= +github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc= +github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo= github.com/protocolbuffers/txtpbfmt v0.0.0-20240823084532-8e6b51fa9bef h1:ej+64jiny5VETZTqcc1GFVAPEtaSk6U1D0kKC2MS5Yc= github.com/protocolbuffers/txtpbfmt v0.0.0-20240823084532-8e6b51fa9bef/go.mod h1:jgxiZysxFPM+iWKwQwPR+y+Jvo54ARd4EisXxKYpB5c= +github.com/redhat-nfvpe/koko v0.0.0-20210415181932-a18aa44814ea h1:TtTNq6CySsXrbFXgrztJASGdcrRlDlIKt07yqGK//fA= +github.com/redhat-nfvpe/koko v0.0.0-20210415181932-a18aa44814ea/go.mod h1:PE2c8qUUdHpM2GPw9ZAhKMD6HV/QJqTkPTbmsn/NV6c= github.com/rifflock/lfshook v0.0.0-20180920164130-b9218ef580f5 h1:mZHayPoR0lNmnHyvtYjDeq0zlVHn9K/ZXoy17ylucdo= github.com/rifflock/lfshook v0.0.0-20180920164130-b9218ef580f5/go.mod h1:GEXHk5HgEKCvEIIrSpFI3ozzG5xOKA2DVlEX/gGnewM= +github.com/rogpeppe/fastuuid v1.2.0 h1:Ppwyp6VYCF1nvBTXL3trRso7mXMlRrw9ooo375wvi2s= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/safchain/ethtool v0.0.0-20190326074333-42ed695e3de8 h1:2c1EFnZHIPCW8qKWgHMH/fX2PkSabFc5mrVzfUNdg5U= +github.com/safchain/ethtool v0.0.0-20190326074333-42ed695e3de8/go.mod h1:Z0q5wiBQGYcxhMZ6gUqHn6pYNLypFAvaL3UvgZLR0U4= github.com/sagikazarmark/locafero v0.12.0 h1:/NQhBAkUb4+fH1jivKHWusDYFjMOOKU88eegjfxfHb4= github.com/sagikazarmark/locafero v0.12.0/go.mod h1:sZh36u/YSZ918v0Io+U9ogLYQJ9tLLBmM4eneO6WwsI= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= github.com/scrapli/scrapligo v1.0.0/go.mod h1:jvRMdb90MNnswMiku8UNXj8JZaOIPhwhcqqFwr9qeoY= github.com/scrapli/scrapligo v1.1.7/go.mod h1:rRx/rT2oNPYztiT3/ik0FRR/Ro7AdzN/eR9AtF8A81Y= github.com/scrapli/scrapligo v1.1.11 h1:ATvpF2LDoxnd/HlfSj5A0IiJDro75D6nuCx8m6S44vU= github.com/scrapli/scrapligo v1.1.11/go.mod h1:XrSom4Gd87B110QkyTaTkuL2EbzEVOlgCJGKIZa6wns= +github.com/scrapli/scrapligo v1.4.3 h1:H1IkZrCqFHT+MaY/j4MgimjLPKFfPRymhxBGYeXUOWI= +github.com/scrapli/scrapligo v1.4.3/go.mod h1:pOWxVyPsQRrWTrkoSSDg05tjOqtWfLffAZtAsCc0w3M= github.com/scrapli/scrapligocfg v1.0.0 h1:540SuGqqM6rKN87SLCfR54IageQ6s3a/ZOycGRgbbak= github.com/scrapli/scrapligocfg v1.0.0/go.mod h1:9+6k9dQeIqEZEg6EK5YXEjuVb7h+nvvel26CY1RGjy4= github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= @@ -452,8 +953,12 @@ github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6Mwd github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w= github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g= +github.com/sirupsen/logrus v1.10.2/go.mod h1:SLEg8TqYulVKKfIGHldVp2K2aYz2DKSVBq4g/H5bR7Q= github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8= github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY= +github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw= +github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I= github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg= @@ -461,6 +966,8 @@ github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY= github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo= github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU= github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4= +github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk= github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= @@ -470,15 +977,21 @@ github.com/spiffe/go-spiffe/v2 v2.8.1 h1:eXZMLsu+3MLEPJyGJkolqtVrteZfQdUpOWj6LTi github.com/spiffe/go-spiffe/v2 v2.8.1/go.mod h1:47Q0Q9/AqGha8QLHp+kxpH4Wca7X7EnOtlIJy3mxZ3U= github.com/srl-labs/srl-controller v0.6.1 h1:hHduqG41wglpeVPD85RALTwWWcS+NqvU8V1pHJMQIZo= github.com/srl-labs/srl-controller v0.6.1/go.mod h1:PedxdPZPtDcC+wDOKhG6uXR4xgkHxb4JhW1cXNk/eaY= +github.com/srl-labs/srl-controller v0.7.1 h1:QZST5zXfXGCdSQUEb22iMvAwfQhfOcqzA3+Ae+ifd70= +github.com/srl-labs/srl-controller v0.7.1/go.mod h1:0QQEBd/vIn2PrXf5vgJ3jUsePjWgr19EkVN/VEGGsAE= github.com/srl-labs/srlinux-scrapli v0.6.0 h1:YQjckD+a7f6u2M+k4SmJUrDa7BFvoOTb2mMbPe6hLZM= github.com/srl-labs/srlinux-scrapli v0.6.0/go.mod h1:8hCoel3XaSyZD8hxSs8Pij/uZqaccd57mfeHgc0oJhM= github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= +github.com/stoewer/go-strcase v1.3.0 h1:g0eASXYtp+yvN9fK8sH94oCIk0fau9uV1/ZdJ0AVEzs= +github.com/stoewer/go-strcase v1.3.0/go.mod h1:fAH5hQ5pehh+j3nZfvwdk2RgEgQjAoM8wodgtPmh1xo= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= @@ -491,18 +1004,35 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY= +github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= +github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= +github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= +github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= +github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 h1:pyC9PaHYZFgEKFdlp3G8RaCKgVpHZnecvArXvPXcFkM= github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701/go.mod h1:P3a5rG4X7tI17Nn3aOIAYr5HbIMukwXG0urG0WuL8OA= github.com/vishvananda/netlink v1.2.1-beta.2 h1:Llsql0lnQEbHj0I1OuKyp8otXp0r3q0mPkuhwHfStVs= github.com/vishvananda/netlink v1.2.1-beta.2/go.mod h1:twkDnbuQxJYemMlGd4JFIcuhgX83tXhKS2B/PRMpOho= +github.com/vishvananda/netlink v1.3.1 h1:3AEMt62VKqz90r0tmNhog0r/PpWKmrEShJU0wJW6bV0= +github.com/vishvananda/netlink v1.3.1/go.mod h1:ARtKouGSTGchR8aMwmkzC0qiNPrrWO5JS/XMVl45+b4= github.com/vishvananda/netns v0.0.5 h1:DfiHV+j8bA32MFM7bfEunvT8IAqQ/NzSJHtcmW5zdEY= github.com/vishvananda/netns v0.0.5/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM= +github.com/wI2L/jsondiff v0.7.1 h1:Fg9+yj+1/x3UtPBJhR91TKEzRkrEEWcAcLbg9dzEaNM= +github.com/wI2L/jsondiff v0.7.1/go.mod h1:yAt2W7U6Jd4HK0RA8DGSGk0zDtfEtOUUJVnH/xICpjo= github.com/x-cray/logrus-prefixed-formatter v0.5.2 h1:00txxvfBM9muc0jiLIEAkAcIMJzfthRT6usrui8uGmg= github.com/x-cray/logrus-prefixed-formatter v0.5.2/go.mod h1:2duySbKsL6M18s5GU7VPsoEPHyzalCE06qoARUCeBBE= +github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= +github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c= github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= github.com/yoheimuta/go-protoparser/v4 v4.9.0 h1:zHRXzRjkOamwMkPu7bpiCtOpxHkM9c8zxQOvW99eWlo= github.com/yoheimuta/go-protoparser/v4 v4.9.0/go.mod h1:AHNNnSWnb0UoL4QgHPiOAg2BniQceFscPI5X/BZNHl8= @@ -510,8 +1040,12 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/zeebo/errs v1.4.0 h1:XNdoD/RRMKP7HD0UhJnIzUy74ISdGGxURlYG8HSWSfM= +github.com/zeebo/errs v1.4.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4= go.einride.tech/aip v0.73.0 h1:bPo4oqBo2ZQeBKo4ZzLb1kxYXTY1ysJhpvQyfuGzvps= go.einride.tech/aip v0.73.0/go.mod h1:Mj7rFbmXEgw0dq1dqJ7JGMvYCZZVxmGOR3S4ZcV5LvQ= +go.einride.tech/aip v0.83.0 h1:TI21IdeOnLTwZEJ3BxtImIZk6bsN2Q+sd0x99SLiQ+M= +go.einride.tech/aip v0.83.0/go.mod h1:E8+wdTApA70odnpFzJgsGogHozC2JCIhFJBKPr8bVig= go.mozilla.org/pkcs7 v0.9.0 h1:yM4/HS9dYv7ri2biPtxt8ikvB37a980dg69/pKmS+eI= go.mozilla.org/pkcs7 v0.9.0/go.mod h1:SNgMg+EgDFwmvSmLRTNKC5fegJjB7v23qTQ0XLGUNHk= go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= @@ -520,30 +1054,58 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/detectors/gcp v1.44.0 h1:NmLfL734pJhM0JKaYd2Y28+nY9dPRWYAAbxhRCrKXPw= go.opentelemetry.io/contrib/detectors/gcp v1.44.0/go.mod h1:tNAsgd8avTGke1+MndXlU5Cru4PQ9Ai/cCNWQv/ZJ/s= +go.opentelemetry.io/contrib/detectors/gcp v1.45.0 h1:9jR0ZPRok9ryaOQ2Wx8rg5F7Aon59mxrqbVI60/vlBk= +go.opentelemetry.io/contrib/detectors/gcp v1.45.0/go.mod h1:VSme3o2fvSg5bVg0dRzyHaj4Z5EVhG+g2Fde6LKzmQA= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.71.0 h1:B2h3uqicet1CT2N5TOFhS+Gq++9i0/CLmaxvhmhtP5s= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.71.0/go.mod h1:dylvB+ZiiwMvsDij9O84Uy7SijLgHMX4mbkncds+4Sw= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.72.0 h1:Tq+E65HaNbZTeqcLw6QUhsV+/EIWdkfUH2CQzcrlE5M= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.72.0/go.mod h1:A+EVhDakAj1waJBPhmTszZaSr08ww8MRRKy1nB1rqck= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.71.0 h1:3g7B90UzBltIDKq1/5mrTGxTnOFDV0ICOhLoxiZ8jlg= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.71.0/go.mod h1:Ef8SuTh59BT7+ofpDxN9z+yOlc4t2GjLmKDgYNJL/NU= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.72.0 h1:LxwW/9ctSCv+QkE/cLR7M91ZIkXNMqJtEMi1vCw9U8s= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.72.0/go.mod h1:tOsftB4SslBwwErVEPaenU2RpThXWPIU8DoJHEC4dyw= go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel v1.47.0 h1:j7ALJ/zgkS7Z6aeJW09p8VC9804bC+PpeTfCD4XPnOM= +go.opentelemetry.io/otel v1.47.0/go.mod h1:8wS9O2qfXrYrzp6hIF/HOYJJf/wIhFPhR2xLuP+iXQU= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 h1:OFnwLJr+pF3iHrlGSzbxyuo6/6HyBlnlN1CWEJmBVcw= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0/go.mod h1:716wFneO0ov19A2beH5hjfh9AK5z/VWNAtDijp1Y0/g= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.47.0 h1:julhjPeUH/q/7hinbSdDdqt5h7Zw9YWmRlWRhI0jd54= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.47.0/go.mod h1:Ao2mz688LH/tFf0yMAenidq6k2YNSx6SIY2q6jDACck= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.46.0 h1:w53CDeOA/Kurp7yRsegSr6pbbr759dOvJ+yNmWM6Hxs= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.46.0/go.mod h1:BOmGMCbAtvcJiSJ+hLuhgPLdDbimnraSl8irz3iY8sY= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.47.0 h1:UFpxOpYPmMNUtOWhdb+nC1WELIgVf8z9higURrbzYU4= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.47.0/go.mod h1:YBGjxe3lt0jtXoEXxGrGhv/jM7oUBUDVK7zhAvNyEjc= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 h1:KrC1YrQeSt46ITMWAbgQx1M1eV1/1TKzttrBzymPmss= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0/go.mod h1:zDSEzoEqsOrgBeGvH66KRgxh90VonFyJqBHA0Pk3+rM= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.47.0 h1:aXZXsZ012wOgVkqaiQv+Z/d8V0xKjmg70F6m4CE94lc= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.47.0/go.mod h1:ziu1gUIJhAaxM3EV1e3Ralk5AAyL1UOYz3lJJ4VSI38= go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.36.0 h1:rixTyDGXFxRy1xzhKrotaHy3/KXdPhlWARrCgK+eqUY= go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.36.0/go.mod h1:dowW6UsM9MKbJq5JTz2AMVp3/5iW5I/TStsk8S+CfHw= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.46.0 h1:KdRxPiAoMptR3vfWzvjjvutTsSiwbC2uG0496rzZNfo= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.46.0/go.mod h1:K/qSA+3G7Eovxi4K09wzrAgkWRnosS0DAOZeEpve7sM= +go.opentelemetry.io/otel/log v1.47.0 h1:cOTS1CcLbSQeZKanGJ+0JpF/+t4PELi3O3bbl2lqCcI= +go.opentelemetry.io/otel/log v1.47.0/go.mod h1:9byitSQ5pLC6PpqwGXjqdMKya6ZTswHRZh2vvXT33nw= go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/metric v1.47.0 h1:4PptaldXx3Eat1XjMZ68pPJEs5wrhlemctZE9a3UdWY= +go.opentelemetry.io/otel/metric v1.47.0/go.mod h1:ADGSXxRrXM6bjbvLo535EstVFlPpPYZm4LBKixjDHwU= go.opentelemetry.io/otel/metric/x v0.68.0 h1:TA/cBT23D3MnxYPwHL7YFOdYGdx0A0v+s7Mzotpd1dU= go.opentelemetry.io/otel/metric/x v0.68.0/go.mod h1:agudOmvWhwUTjgibWDzxD2PoWYnpw5Ht5jISYOD2Hd4= +go.opentelemetry.io/otel/metric/x v0.69.0 h1:DjRLr15H83v+hCW7JA9NoJvOkYTtmq5YoDRbe9deYpM= +go.opentelemetry.io/otel/metric/x v0.69.0/go.mod h1:uVvsMPMFFyj/HUQfrUnH3JjnOQ1dwFDorgFLRBasM0k= go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI= go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM= +go.opentelemetry.io/otel/sdk v1.47.0 h1:zWXEr4j2lFefG87TU6Yg8a7ngfohIKFZHKp0Hf5hC6I= +go.opentelemetry.io/otel/sdk v1.47.0/go.mod h1:VUc24kiOeoGsxG8G9ULx3fWKvB7jMhnGE8Oi607lgR0= go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE= go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4= +go.opentelemetry.io/otel/sdk/metric v1.47.0 h1:lfISg2j93VT6yqdk9OfUaZmw/GfcZqCCV3jdXtsPnKw= +go.opentelemetry.io/otel/sdk/metric v1.47.0/go.mod h1:ypLp+mW1Nt2x+Szt3b5/i1syodyts49lMOwxpDI3VGw= go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= +go.opentelemetry.io/otel/trace v1.47.0 h1:JOjX/Oci8K94QHddo+bbfya/Ai/nf6/dt9ZfrFNWSrM= +go.opentelemetry.io/otel/trace v1.47.0/go.mod h1:jNaSLa2PZEYFG6fRjJABAu+bw4FS08uDmPg28lTghu0= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= go.opentelemetry.io/proto/otlp v1.11.0 h1:5rrYs0Ykyj50sdU/JU0x8etU+LubXWb+gED6TbEdMIk= go.opentelemetry.io/proto/otlp v1.11.0/go.mod h1:SmVizdCOAm3XBtG1g1NnOdhW6jtddT72hLMhv8VwA8E= @@ -559,6 +1121,12 @@ go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN8 go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= go.uber.org/zap v1.25.0 h1:4Hvk6GtkucQ790dqmj7l1eEnRdKm3k3ZUrUMS2d5+5c= go.uber.org/zap v1.25.0/go.mod h1:JIAUzQIH94IC4fOJQm7gMmBJP5k7wQfdcnYdPoEXJYk= +go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc= +go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +go.universe.tf/metallb v0.16.1 h1:iVtjCslcUFMOEvuNeAyW2ygZxyW+6YjnNcEuCTOZezc= +go.universe.tf/metallb v0.16.1/go.mod h1:bcFtsBPqKJChcT7gf4bhRtR6HAu8TeY7OGLYanK2tOQ= +go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= +go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= @@ -571,18 +1139,25 @@ golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0 golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58= golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M= golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA= +golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54= +golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20260908205506-85c1c2202aba h1:Ck8QetSgk912qxWLMCKxd0in+aiyBQyDSMae6e/xmpU= golang.org/x/exp v0.0.0-20260908205506-85c1c2202aba/go.mod h1:50RgIsmK7OwqzTTeqcSXQW8SswW0o8fRcDxmqGluJ8E= +golang.org/x/exp/typeparams v0.0.0-20231219180239-dc181d75b848 h1:UhRVJ0i7bF9n/Hd8YjW3eKjlPVBHzbQdxrBgjbSKl64= +golang.org/x/exp/typeparams v0.0.0-20231219180239-dc181d75b848/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k= golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg= +golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -602,10 +1177,14 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.59.0 h1:5zfYln+w5XCxwrnMMJPufRgNoXEaGxl0wo5GqPXyues= golang.org/x/net v0.59.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg= +golang.org/x/net v0.61.0 h1:RR+6j/BTBCrggOLugxa+66R8FvoN6MHlzDlZIbN9YFw= +golang.org/x/net v0.61.0/go.mod h1:WgDCOTH8iwtB66T4/GfI94AHo/hhdb7Hah9NDseQfiI= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= +golang.org/x/oauth2 v0.37.0 h1:JUlcxA8oAtauLfiH8FX2/FkAWHAdi0QtGCGc+hofE98= +golang.org/x/oauth2 v0.37.0/go.mod h1:IxwZNxUULJmpBFf9K/9NTMSIfZZuvuTy1gGxhigP/58= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -615,6 +1194,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk= golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= +golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -638,12 +1219,16 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= +golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE= golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc= +golang.org/x/term v0.47.0 h1:cpyOwQkr2Nzxe2p6KnrTG7Ei2wtzjsuSjhpXXepZ/BM= +golang.org/x/term v0.47.0/go.mod h1:efAfAuG6RKABvg1ArGebRkvX6LXul14SM67o2e4mUCY= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= @@ -652,8 +1237,12 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI= golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E= +golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc= +golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= +golang.org/x/time v0.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE= +golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= @@ -667,18 +1256,31 @@ golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.50.0 h1:c2ifzfcuY7L90lZ2aKd8S4K2NpASF08SZx9ZuJkHmSU= golang.org/x/tools v0.50.0/go.mod h1:7ulVMw3831Mwi5EZD6RomGyffr4VFjuNYXf2BbCEAV0= +golang.org/x/tools v0.51.0 h1:k4Xc/1Om9jwkBJBo4NVLMSARBoWtK10mx+W5BnXCeAI= +golang.org/x/tools v0.51.0/go.mod h1:9eEncMayCV6zRMGhR5eZEC2iBx98qWcF1HZ9Z7wJOoA= +golang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM= +golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= +golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated h1:1h2MnaIAIXISqTFKdENegdpAgUXz6NrPEsbIeWaBRvM= +golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated/go.mod h1:RVAQXBGNv1ib0J382/DPCRS/BPnsGebyM1Gj5VSDpG8= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gomodules.xyz/jsonpatch/v2 v2.2.0 h1:4pT439QV83L+G9FkcCriY6EkpcK6r6bK+A5FBUMI7qY= gomodules.xyz/jsonpatch/v2 v2.2.0/go.mod h1:WXp+iVDkoLQqPudfQ9GBlwB2eZ5DKOnjQZCYdOS8GPY= +gomodules.xyz/jsonpatch/v2 v2.5.0 h1:JELs8RLM12qJGXU4u/TO3V25KW8GreMKl9pdkk14RM0= +gomodules.xyz/jsonpatch/v2 v2.5.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/api v0.278.0 h1:W7jiRvRi53VYFfZ/HoZjQBtJk7gOFbHD8ot1RzVZU6E= google.golang.org/api v0.278.0/go.mod h1:B9TqLBwJqVjp1mtt7WeoQwWRwvu/400y5lETOql+giQ= +google.golang.org/api v0.309.0 h1:DXP86di4cL3R3R6aUrJNUNthav2djJ99QbSOrN63238= +google.golang.org/api v0.309.0/go.mod h1:4XMH+b/ZEfuTbK7FnrFRY9c4xfFHVflGTKuy/i5wUmE= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= @@ -687,10 +1289,18 @@ google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEY google.golang.org/genproto v0.0.0-20220107163113-42d7afdf6368/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7 h1:XzmzkmB14QhVhgnawEVsOn6OFsnpyxNPRY9QV01dNB0= google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:L43LFes82YgSonw6iTXTxXUX1OlULt4AQtkik4ULL/I= +google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d h1:C9v1o0/4quuhOAfmRXA2j+we0PqZIp8traLdeogF3Ms= +google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20260921155816-b14227669459 h1:GS9OIt/j7c8bvBjYNgnKQysVfmV7e4jM0H8ZK95G4t8= google.golang.org/genproto/googleapis/api v0.0.0-20260921155816-b14227669459/go.mod h1:PX5/4vemwVoXtwEcRDWwcR1/r0qrosfx3qoVADMwnVE= +google.golang.org/genproto/googleapis/api v0.0.0-20260928230214-8a89bd6388cc h1:rZHRz0ogq4Pid1IKtA/ivHi8XONVF5tqUQXA2TtgpkE= +google.golang.org/genproto/googleapis/api v0.0.0-20260928230214-8a89bd6388cc/go.mod h1:K/n0XLazCJHjD73YuMyNJsN38BPPy1kfFnKxUXaThFU= +google.golang.org/genproto/googleapis/bytestream v0.0.0-20261019180522-ce908d29299b h1:EQdQLDJBQ7g53rvtSlDBkU1dKA/kM6N2BWS6HivIngQ= +google.golang.org/genproto/googleapis/bytestream v0.0.0-20261019180522-ce908d29299b/go.mod h1:RoCpRfcA27uTJ0TZb3Vyad8eLVakUKdLdV2yMdlm2+w= google.golang.org/genproto/googleapis/rpc v0.0.0-20260921155816-b14227669459 h1:b0xCahf3FK2m2Cv0p4vTozGPWncCvLfwV86UNg8xWU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260921155816-b14227669459/go.mod h1:OaIUM3+LpYcK2GXM4FTmhWoIq371Owdr+Cc7/BsYHHc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20261019180522-ce908d29299b h1:6WNWHZk91dp4gZ25642OALkuG1UVNZbwENJD19DnB8k= +google.golang.org/genproto/googleapis/rpc v0.0.0-20261019180522-ce908d29299b/go.mod h1:OaIUM3+LpYcK2GXM4FTmhWoIq371Owdr+Cc7/BsYHHc= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= @@ -702,6 +1312,12 @@ google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAG google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= google.golang.org/grpc v1.84.0 h1:soMyaPJ8pAak5PIQ0DGBUir0XRo2fRoMqhNWMLlLxO0= google.golang.org/grpc v1.84.0/go.mod h1:ljCht0DrxQrXBDRTZp52Qxh3Ffk8CdYm2sj4O2QN2C0= +google.golang.org/grpc v1.85.0 h1:BPBCfuVRQ1qvBhKDOq9uvQllMvO59rKsYhXpp7Dd8vw= +google.golang.org/grpc v1.85.0/go.mod h1:0rQrOD58yjal/0EaVbGBANindixsCZNQPDV3VKtaKuQ= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.6.2 h1:rgSNvqscFZ1JgV/4wH5GOsZFSFkR2Eua9As3KIr2LlM= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.6.2/go.mod h1:iMEtFwDlAhjDU9L5mY6U1XLwlIId/G3h+QcBHDIvrJ8= +google.golang.org/grpc/examples v0.0.0-20250407062114-b368379ef8f6 h1:ExN12ndbJ608cboPYflpTny6mXSzPrDLh0iTaVrRrds= +google.golang.org/grpc/examples v0.0.0-20250407062114-b368379ef8f6/go.mod h1:6ytKWczdvnpnO+m+JiG9NjEDzR1FJfsnmJdG7B8QVZ8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -721,9 +1337,14 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/errgo.v2 v2.1.0 h1:0vLT13EuvQ0hNvakwLuFZ/jYrLp5F3kcWHXdRggjCE8= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/evanphx/json-patch.v4 v4.13.0 h1:czT3CmqEaQ1aanPc5SdlgQrrEIb8w/wwCvWWnfEbYzo= +gopkg.in/evanphx/json-patch.v4 v4.13.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M= gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= @@ -743,27 +1364,69 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.8.1 h1:+JKf3xJ1ni4CwrhVg4/pqsfPGP6vNAXcKbMXJodYx3w= +honnef.co/go/tools v0.8.1/go.mod h1:XA+OnlRA9EDh/ukGvXMNSZNKGwFQJ+5dER0ioUkOxks= k8s.io/api v0.26.3 h1:emf74GIQMTik01Aum9dPP0gAypL8JTLl/lHa4V9RFSU= k8s.io/api v0.26.3/go.mod h1:PXsqwPMXBSBcL1lJ9CYDKy7kIReUydukS5JiRlxC3qE= +k8s.io/api v0.37.1 h1:l6N77U7tjwB5L056bgrBTJIEdevac/naBZ3iSvDNfpM= +k8s.io/api v0.37.1/go.mod h1:zSlbB1YpJ1YQlFVQy20UYll81UJSJJUMLhkhvg6Z78M= k8s.io/apiextensions-apiserver v0.26.3 h1:5PGMm3oEzdB1W/FTMgGIDmm100vn7IaUP5er36dB+YE= k8s.io/apiextensions-apiserver v0.26.3/go.mod h1:jdA5MdjNWGP+njw1EKMZc64xAT5fIhN6VJrElV3sfpQ= +k8s.io/apiextensions-apiserver v0.36.0 h1:Wt7E8J+VBCbj4FjiBfDTK/neXDDjyJVJc7xfuOHImZ0= +k8s.io/apiextensions-apiserver v0.36.0/go.mod h1:kGDjH0msuiIB3tgsYRV0kS9GqpMYMUsQ3GHv7TApyug= k8s.io/apimachinery v0.26.3 h1:dQx6PNETJ7nODU3XPtrwkfuubs6w7sX0M8n61zHIV/k= k8s.io/apimachinery v0.26.3/go.mod h1:ats7nN1LExKHvJ9TmwootT00Yz05MuYqPXEXaVeOy5I= +k8s.io/apimachinery v0.37.1 h1:hGCYyvKHCwtwMitj2vU4vYx0Z16N9GyZk9BBnz0wDAE= +k8s.io/apimachinery v0.37.1/go.mod h1:jF84AyUi/IRIXRot5f+lm6MpxoWI+F1XgjaMmwCdTFw= +k8s.io/apiserver v0.36.0 h1:Jg5OFAENUACByUCg15CmhZAYrr5ZyJ+jodyA1mHl3YE= +k8s.io/apiserver v0.36.0/go.mod h1:mHvwdHf+qKEm+1/hYm756SV+oREOKSPnsjagOpx6Vho= k8s.io/client-go v0.26.3 h1:k1UY+KXfkxV2ScEL3gilKcF7761xkYsSD6BC9szIu8s= k8s.io/client-go v0.26.3/go.mod h1:ZPNu9lm8/dbRIPAgteN30RSXea6vrCpFvq+MateTUuQ= +k8s.io/client-go v0.37.1 h1:QTv/5ha4jAHtW9qxxVBkQVFBRDb4jHfFopQqqMdc+wM= +k8s.io/client-go v0.37.1/go.mod h1:dnAPtTnCNY38Ho04D2KdY1F4IKausa9UbqaAZKl60SY= +k8s.io/component-base v0.36.0 h1:hFjEktssxiJhrK1zfybkH4kJOi8iZuF+mIDCqS5+jRo= +k8s.io/component-base v0.36.0/go.mod h1:JZvIfcNHk+uck+8LhJzhSBtydWXaZNQwX2OdL+Mnwsk= +k8s.io/cri-api v0.0.0-20191204094248-a6f63f369f6d h1:OpF0WA8LtC0MVPG5HzIsY77WinFa7pLXRtlc/ksOW1U= +k8s.io/cri-api v0.0.0-20191204094248-a6f63f369f6d/go.mod h1:BzAkbBHHp81d+aXzbiIcUbilLkbXa40B8mUHOk6EX3s= +k8s.io/gengo/v2 v2.0.0-20250922181213-ec3ebc5fd46b h1:gMplByicHV/TJBizHd9aVEsTYoJBnnUAT5MHlTkbjhQ= +k8s.io/gengo/v2 v2.0.0-20250922181213-ec3ebc5fd46b/go.mod h1:CgujABENc3KuTrcsdpGmrrASjtQsWCT7R99mEV4U/fM= +k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8= +k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I= k8s.io/klog/v2 v2.140.0 h1:Tf+J3AH7xnUzZyVVXhTgGhEKnFqye14aadWv7bzXdzc= k8s.io/klog/v2 v2.140.0/go.mod h1:o+/RWfJ6PwpnFn7OyAG3QnO47BFsymfEfrz6XyYSSp0= k8s.io/kube-openapi v0.0.0-20230308215209-15aac26d736a h1:gmovKNur38vgoWfGtP5QOGNOA7ki4n6qNYoFAgMlNvg= k8s.io/kube-openapi v0.0.0-20230308215209-15aac26d736a/go.mod h1:y5VtZWM9sHHc2ZodIH/6SHzXj+TPU5USoA8lcIeKEKY= +k8s.io/kube-openapi v0.0.0-20260721132016-d427ff9ee9ad h1:oXImqH8mQNk7PmvzKhmN3ddJoY6OnyM225MXwGHPm0A= +k8s.io/kube-openapi v0.0.0-20260721132016-d427ff9ee9ad/go.mod h1:0/mqHCVhlumdJ3BhCfnjSZQE037nAhNodh1/hK0T8/I= +k8s.io/kubernetes v1.14.6 h1:t8Q3aaWanmiariBBr3qYIcAL9o0pv4MB5tZtfbILJGk= +k8s.io/kubernetes v1.14.6/go.mod h1:ocZa8+6APFNC2tX1DZASIbocyYT5jHzqFVsY5aoB7Jk= +k8s.io/streaming v0.37.1 h1:TpzVfQeFuVndn2g9mFqxy1UcUYPwDzqjUmwR/IzJCWc= +k8s.io/streaming v0.37.1/go.mod h1:APlJR26ZWRcVy5bIEj0QRrKUXROtBHPcxl2NT7EAzPU= k8s.io/utils v0.0.0-20230313181309-38a27ef9d749 h1:xMMXJlJbsU8w3V5N2FLDQ8YgU8s1EoULdbQBcAeNJkY= k8s.io/utils v0.0.0-20230313181309-38a27ef9d749/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +k8s.io/utils v0.0.0-20261023123148-ca04ba58ecab h1:pjQrNLaF//ytZtWwCAHtW+pqwSKjtWDqzA8+TCX37RI= +k8s.io/utils v0.0.0-20261023123148-ca04ba58ecab/go.mod h1:DdQ0BJxlQtuMlKDqdg7X5IMMQCXIk2b3d1/4M9OhUYo= lukechampine.com/uint128 v1.3.0 h1:cDdUVfRwDUDovz610ABgFD17nXD4/uDgVHl2sC3+sbo= lukechampine.com/uint128 v1.3.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= +sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.34.0 h1:hSfpvjjTQXQY2Fol2CS0QHMNs/WI1MOSGzCm1KhM5ec= +sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.34.0/go.mod h1:Ve9uj1L+deCXFrPOk1LpFXqTg7LCFzFso6PA48q/XZw= sigs.k8s.io/controller-runtime v0.14.5 h1:6xaWFqzT5KuAQ9ufgUaj1G/+C4Y1GRkhrxl+BJ9i+5s= sigs.k8s.io/controller-runtime v0.14.5/go.mod h1:WqIdsAY6JBsjfc/CqO0CORmNtoCtE4S6qbPc9s68h+0= +sigs.k8s.io/controller-runtime v0.24.1 h1:miPEwrmirImAvgME1L9qebGHrOnGJoVmVdtOU9fRfo4= +sigs.k8s.io/controller-runtime v0.24.1/go.mod h1:vFkfY5fGt5xAC/sKb8IBFKgWPNKG9OUG29dR8Y2wImw= sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd h1:EDPBXCAspyGV4jQlpZSudPeMmr1bNJefnuqLsRAsHZo= sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0= +sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 h1:IpInykpT6ceI+QxKBbEflcR5EXP7sU1kvOlxwZh5txg= +sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730/go.mod h1:mdzfpAEoE6DHQEN0uh9ZbOCuHbLK5wOm7dK4ctXE9Tg= +sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU= +sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= sigs.k8s.io/structured-merge-diff/v4 v4.2.3 h1:PRbqxJClWWYMNV1dhaG4NsibJbArud9kFxnAMREiWFE= sigs.k8s.io/structured-merge-diff/v4 v4.2.3/go.mod h1:qjx8mGObPmV2aSZepjQjbmb2ihdVs8cGKBraizNC69E= +sigs.k8s.io/structured-merge-diff/v4 v4.4.1 h1:150L+0vs/8DA78h1u02ooW1/fFq/Lwr+sGiqlzvrtq4= +sigs.k8s.io/structured-merge-diff/v4 v4.4.1/go.mod h1:N8hJocpFajUSSeSJ9bOZ77VzejKZaXsTtZo4/u7Io08= +sigs.k8s.io/structured-merge-diff/v6 v6.4.2 h1:qdOxHwrl2Kaag1aQEarlYcOA9vSyGCp3CIki3aW8c4Q= +sigs.k8s.io/structured-merge-diff/v6 v6.4.2/go.mod h1:M3W8sfWvn2HhQDIbGWj3S099YozAsymCo/wrT5ohRUE= sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= +sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs= +sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4= diff --git a/internal/aft_binding_contract/typed_global_filter_test.go b/internal/aft_binding_contract/typed_global_filter_test.go new file mode 100644 index 00000000000..3c06c1a35bb --- /dev/null +++ b/internal/aft_binding_contract/typed_global_filter_test.go @@ -0,0 +1,116 @@ +// Copyright 2026 Google LLC +// +// 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 aft_binding_contract_test + +import ( + "context" + "encoding/json" + "testing" + + gpb "github.com/openconfig/gnmi/proto/gnmi" + "github.com/openconfig/ondatra/gnmi" + "github.com/openconfig/ygnmi/ygnmi" + "github.com/openconfig/ygot/ygot" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +type captureGNMI struct { + gpb.GNMIClient + sets []*gpb.SetRequest + gets []*gpb.GetRequest + setError error +} + +func (c *captureGNMI) Set(_ context.Context, request *gpb.SetRequest, _ ...grpc.CallOption) (*gpb.SetResponse, error) { + c.sets = append(c.sets, request) + return &gpb.SetResponse{}, c.setError +} + +func (c *captureGNMI) Get(_ context.Context, request *gpb.GetRequest, _ ...grpc.CallOption) (*gpb.GetResponse, error) { + c.gets = append(c.gets, request) + return &gpb.GetResponse{Notification: []*gpb.Notification{{ + Prefix: request.GetPrefix(), + Update: []*gpb.Update{{Path: request.GetPath()[0], Val: &gpb.TypedValue{ + Value: &gpb.TypedValue_JsonIetfVal{JsonIetfVal: []byte(`"POLICY-TEST"`)}}}}, + }}}, nil +} + +func TestTypedGlobalFilterWireContract(t *testing.T) { + fake := &captureGNMI{} + client, err := ygnmi.NewClient(fake, ygnmi.WithTarget("test-dut")) + if err != nil { + t.Fatal(err) + } + filter := gnmi.OC().NetworkInstance("VRF-A").Afts().GlobalFilter() + batch := &ygnmi.SetBatch{} + ygnmi.BatchUpdate(batch, filter.Ipv4Policy().Config(), "POLICY-TEST") + ygnmi.BatchUpdate(batch, filter.Ipv6Policy().Config(), "POLICY-TEST") + if _, err := batch.Set(context.Background(), client, ygnmi.WithEncoding(gpb.Encoding_JSON_IETF)); err != nil { + t.Fatal(err) + } + if len(fake.sets) != 1 || len(fake.sets[0].GetUpdate()) != 2 { + t.Fatalf("dual-stack update must use one RPC with two leaves: %v", fake.sets) + } + for i, update := range fake.sets[0].GetUpdate() { + path, err := ygot.PathToString(update.GetPath()) + if err != nil { + t.Fatal(err) + } + leaf := []string{"ipv4-policy", "ipv6-policy"}[i] + want := "/network-instances/network-instance[name=VRF-A]/afts/global-filter/config/" + leaf + if path != want { + t.Fatalf("path=%q, want %q", path, want) + } + var policy string + if err := json.Unmarshal(update.GetVal().GetJsonIetfVal(), &policy); err != nil || policy != "POLICY-TEST" { + t.Fatalf("JSON_IETF string value not preserved: %v, %v", update.GetVal(), err) + } + } + if fake.sets[0].GetPrefix().GetTarget() != "test-dut" { + t.Fatal("DUT target was not preserved") + } + for _, check := range []struct { + query ygnmi.SingletonQuery[string] + datatype gpb.GetRequest_DataType + }{ + {filter.Ipv4Policy().Config(), gpb.GetRequest_CONFIG}, + {filter.Ipv6Policy().State(), gpb.GetRequest_STATE}, + } { + value, err := ygnmi.Get(context.Background(), client, check.query, ygnmi.WithUseGet()) + if err != nil || value != "POLICY-TEST" { + t.Fatalf("typed Get value=%q, error=%v", value, err) + } + if fake.gets[len(fake.gets)-1].GetType() != check.datatype { + t.Fatalf("Get datatype not preserved: %v", fake.gets) + } + } + deletion := &ygnmi.SetBatch{} + ygnmi.BatchDelete(deletion, filter.Ipv4Policy().Config()) + ygnmi.BatchDelete(deletion, filter.Ipv6Policy().Config()) + ygnmi.BatchDelete(deletion, gnmi.OC().RoutingPolicy().PolicyDefinition("POLICY-TEST").Config()) + if _, err := deletion.Set(context.Background(), client); err != nil { + t.Fatal(err) + } + if len(fake.sets) != 2 || len(fake.sets[1].GetDelete()) != 3 { + t.Fatalf("filter + policy deletion must use one RPC: %v", fake.sets) + } + fake.setError = status.Error(codes.FailedPrecondition, "expected validation failure") + _, err = batch.Set(context.Background(), client) + if status.Code(err) != codes.FailedPrecondition { + t.Fatalf("negative-check status changed: %v", err) + } +} diff --git a/internal/aft_prefix_filtering/aft_prefix_filtering_service.go b/internal/aft_prefix_filtering/aft_prefix_filtering_service.go index 5ed371620ec..ed30962bd27 100644 --- a/internal/aft_prefix_filtering/aft_prefix_filtering_service.go +++ b/internal/aft_prefix_filtering/aft_prefix_filtering_service.go @@ -21,7 +21,6 @@ package aft_prefix_filtering_service import ( "context" - "encoding/json" "flag" "fmt" "regexp" @@ -46,8 +45,6 @@ import ( "github.com/openconfig/testt" "github.com/openconfig/ygnmi/ygnmi" "github.com/openconfig/ygot/ygot" - "google.golang.org/grpc" - "google.golang.org/grpc/peer" "google.golang.org/grpc/status" ) @@ -689,7 +686,7 @@ func parseCiscoBGPPrefixCounts(output string) (uint64, uint64, error) { } // DialGNMI returns a shared raw gNMI client, dialing it once and caching it -// for reuse. It is needed for raw paths that are not present in the OC tree. +// for reuse by AFT notification collectors and typed configuration clients. func DialGNMI(t *testing.T, dut *ondatra.DUTDevice) (gpb.GNMIClient, error) { t.Helper() gnmiOnce.Do(func() { @@ -706,21 +703,18 @@ func DialGNMI(t *testing.T, dut *ondatra.DUTDevice) (gpb.GNMIClient, error) { return gnmiClient, gnmiErr } -// globalFilterPolicyPath builds the raw OpenConfig path for an AFT -// global-filter policy leaf. Raw paths are required until the generated -// ondatra OC bindings include the openconfig-aft-global-filter augment. -func globalFilterPolicyPath(niName, leaf string) *gpb.Path { - return &gpb.Path{ - Origin: "openconfig", - Elem: []*gpb.PathElem{ - {Name: "network-instances"}, - {Name: "network-instance", Key: map[string]string{"name": niName}}, - {Name: "afts"}, - {Name: "global-filter"}, - {Name: "config"}, - {Name: leaf}, - }, +// TypedGNMIClient wraps the selected transport for generated OC queries. Reboot +// tests can supply their refreshed connection instead of the shared transport. +func TypedGNMIClient(t *testing.T, dut *ondatra.DUTDevice, transport gpb.GNMIClient) (*ygnmi.Client, error) { + t.Helper() + if transport == nil { + var err error + transport, err = DialGNMI(t, dut) + if err != nil { + return nil, err + } } + return ygnmi.NewClient(transport, ygnmi.WithTarget(dut.Name())) } // ConfigEncoding selects XR's required configuration encoding while retaining @@ -732,34 +726,6 @@ func ConfigEncoding(dut *ondatra.DUTDevice) gpb.Encoding { return gpb.Encoding_JSON } -// globalFilterPolicyUpdates builds updates for the non-empty policy names in -// cfg. Sending both updates in one SetRequest applies dual-stack policy changes -// atomically from the client's perspective. -func globalFilterPolicyUpdates(cfg ConfigureGlobalFilterPoliciesParams) ([]*gpb.Update, error) { - var updates []*gpb.Update - if cfg.V4Policy != "" { - policyJSON, err := json.Marshal(cfg.V4Policy) - if err != nil { - return nil, fmt.Errorf("marshal IPv4 global-filter policy %q: %w", cfg.V4Policy, err) - } - updates = append(updates, &gpb.Update{ - Path: globalFilterPolicyPath(cfg.VRFName, "ipv4-policy"), - Val: &gpb.TypedValue{Value: &gpb.TypedValue_JsonIetfVal{JsonIetfVal: policyJSON}}, - }) - } - if cfg.V6Policy != "" { - policyJSON, err := json.Marshal(cfg.V6Policy) - if err != nil { - return nil, fmt.Errorf("marshal IPv6 global-filter policy %q: %w", cfg.V6Policy, err) - } - updates = append(updates, &gpb.Update{ - Path: globalFilterPolicyPath(cfg.VRFName, "ipv6-policy"), - Val: &gpb.TypedValue{Value: &gpb.TypedValue_JsonIetfVal{JsonIetfVal: policyJSON}}, - }) - } - return updates, nil -} - // AFTDeleteGlobalFilter deletes both global-filter policy leaves for the given network-instance. func AFTDeleteGlobalFilter(t *testing.T, dut *ondatra.DUTDevice, niName string) error { t.Helper() @@ -771,14 +737,15 @@ func AFTDeleteGlobalFilter(t *testing.T, dut *ondatra.DUTDevice, niName string) } } - client, err := DialGNMI(t, dut) + client, err := TypedGNMIClient(t, dut, nil) if err != nil { return err } - _, err = client.Set(context.Background(), &gpb.SetRequest{Delete: []*gpb.Path{ - globalFilterPolicyPath(niName, "ipv4-policy"), - globalFilterPolicyPath(niName, "ipv6-policy"), - }}) + filter := gnmi.OC().NetworkInstance(niName).Afts().GlobalFilter() + batch := &ygnmi.SetBatch{} + ygnmi.BatchDelete(batch, filter.Ipv4Policy().Config()) + ygnmi.BatchDelete(batch, filter.Ipv6Policy().Config()) + _, err = batch.Set(context.Background(), client) if err != nil { return fmt.Errorf("failed to delete AFT global-filter policies from network-instance %q: %w", niName, err) } @@ -937,36 +904,36 @@ func ConfigureGlobalFilterPolicies(t *testing.T, dut *ondatra.DUTDevice, cfg Con } } - updates, err := globalFilterPolicyUpdates(cfg) - if err != nil { - t.Fatalf("Failed to encode AFT global-filter policies: %v", err) - } - if len(updates) == 0 { + if cfg.V4Policy == "" && cfg.V6Policy == "" { return } - if dut.Vendor() != ondatra.CISCO { - // JSON_IETF addresses XR's encoding restriction. Preserve JSON on - // other vendors rather than changing their required capabilities. - for _, update := range updates { - update.Val = &gpb.TypedValue{Value: &gpb.TypedValue_JsonVal{JsonVal: update.GetVal().GetJsonIetfVal()}} - } - } client, createdAt := cfg.Client, cfg.ClientCreatedAt if client == nil { + var err error client, err = DialGNMI(t, dut) if err != nil { t.Fatalf("Failed to dial gNMI while configuring AFT global-filter policies: %v", err) } createdAt = gnmiClientCreatedAt } - request := &gpb.SetRequest{Update: updates} - t.Logf("Sending AFT global-filter gNMI SetRequest: %v", request) + typedClient, err := TypedGNMIClient(t, dut, client) + if err != nil { + t.Fatalf("Failed to create typed AFT configuration client: %v", err) + } + filter := gnmi.OC().NetworkInstance(cfg.VRFName).Afts().GlobalFilter() + batch := &ygnmi.SetBatch{} + if cfg.V4Policy != "" { + ygnmi.BatchUpdate(batch, filter.Ipv4Policy().Config(), cfg.V4Policy) + } + if cfg.V6Policy != "" { + ygnmi.BatchUpdate(batch, filter.Ipv6Policy().Config(), cfg.V6Policy) + } + t.Logf("Sending typed AFT global-filter Set batch: %s", batch) started := time.Now() t.Logf("AFT global-filter Set start: UTC=%s NI=%s client=%p createdUTC=%s", started.UTC().Format(time.RFC3339Nano), cfg.VRFName, client, createdAt.UTC().Format(time.RFC3339Nano)) - var remote peer.Peer - response, err := client.Set(context.Background(), request, grpc.Peer(&remote)) - t.Logf("AFT global-filter Set end: UTC=%s NI=%s elapsed=%v peer=%v status=%s error=%v response=%v", - time.Now().UTC().Format(time.RFC3339Nano), cfg.VRFName, time.Since(started), remote.Addr, status.Code(err), err, response) + response, err := batch.Set(context.Background(), typedClient, ygnmi.WithEncoding(ConfigEncoding(dut))) + t.Logf("AFT global-filter Set end: UTC=%s NI=%s elapsed=%v status=%s error=%v response=%v", + time.Now().UTC().Format(time.RFC3339Nano), cfg.VRFName, time.Since(started), status.Code(err), err, response) if err != nil { if cfg.OnSetFailure != nil { cfg.OnSetFailure(err) From d9ea0aadaf06d3a624f005aaafe79812b42e1f07 Mon Sep 17 00:00:00 2001 From: hmod2001 <59151407+hmod2001@users.noreply.github.com> Date: Fri, 20 Nov 2026 15:30:59 -0500 Subject: [PATCH 3/3] Use upstream OpenConfig PR selection in Jenkins instructions --- docs/aft-typed-global-filter-bindings.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/aft-typed-global-filter-bindings.md b/docs/aft-typed-global-filter-bindings.md index af9cd42d26d..3125ecfa814 100644 --- a/docs/aft-typed-global-filter-bindings.md +++ b/docs/aft-typed-global-filter-bindings.md @@ -43,21 +43,21 @@ The bindings update is part of the checkout through `go.mod` and `go.sum`. The build must preserve that replacement and use Go 1.26.3 or later; no manual binding regeneration or private Ondatra checkout is needed. -Select this PR from `b4firex/featureprofiles`. The B4 Jenkins `Public` repository -choice defaults to `openconfig/featureprofiles`, so a PR number in the B4FireX -fork also requires selecting the fork's repository URL. In an existing B4 -runlist, the source settings are: +Select the upstream PR in `openconfig/featureprofiles`. Its source branch is +hosted in the B4FireX fork. In Jenkins, choose `Public` and enter the upstream +number in `Test PR`. For an existing B4 runlist, the equivalent source settings +are: ```yaml internal_test: false -test_repo_url: https://github.com/b4firex/featureprofiles.git +test_repo_url: https://github.com/openconfig/featureprofiles.git ``` -Select this PR's number with the job's Test PR setting. Clear the old internal -`test_branch` and any explicit test revision, and leave the job's Test branch -and Test commit hash fields empty. Keep the existing AFT package selections -and the intended testbed/image profile. A source selection that still points -to the internal branch will not exercise these changes. +Select the upstream PR's number with the job's Test PR setting. Clear the old +internal `test_branch`, any explicit test revision, and any repository override +that points to the fork. Leave the job's Test branch and Test commit hash fields +empty. Keep the existing AFT package selections and intended testbed/image +profile. Use the established B4 SIM runtime profile described below when reproducing the local simulator results. The module pin supplies the bindings; the normal