Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package nelm for openSUSE:Factory checked in at 2026-07-17 01:44:12 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/nelm (Old) and /work/SRC/openSUSE:Factory/.nelm.new.24530 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "nelm" Fri Jul 17 01:44:12 2026 rev:31 rq:1366169 version:1.25.0 Changes: -------- --- /work/SRC/openSUSE:Factory/nelm/nelm.changes 2026-07-13 14:28:49.116958968 +0200 +++ /work/SRC/openSUSE:Factory/.nelm.new.24530/nelm.changes 2026-07-17 01:45:02.428403830 +0200 @@ -1,0 +2,13 @@ +Thu Jul 16 10:52:19 UTC 2026 - Johannes Kastl <[email protected]> + +- Update to version 1.25.0: + * Features + - add automatic deploy dependency detection for KEDA + ScaledObjects (#631) (6ccf7ec), closes #456 + * Bug Fixes + - hangs on very long pod log lines (#638) (6e75224) + - no more "no match for resource kind" errors (679e6ec) + - retry also on conversion webhooks unavailability (7f5713b) + - show actual error if webhook retries fail (17a4604) + +------------------------------------------------------------------- Old: ---- nelm-1.24.3.obscpio New: ---- nelm-1.25.0.obscpio ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ nelm.spec ++++++ --- /var/tmp/diff_new_pack.oRxvgs/_old 2026-07-17 01:45:04.016457413 +0200 +++ /var/tmp/diff_new_pack.oRxvgs/_new 2026-07-17 01:45:04.020457549 +0200 @@ -17,7 +17,7 @@ Name: nelm -Version: 1.24.3 +Version: 1.25.0 Release: 0 Summary: Helm 3 alternative License: Apache-2.0 ++++++ _service ++++++ --- /var/tmp/diff_new_pack.oRxvgs/_old 2026-07-17 01:45:04.076459438 +0200 +++ /var/tmp/diff_new_pack.oRxvgs/_new 2026-07-17 01:45:04.088459843 +0200 @@ -3,7 +3,7 @@ <param name="url">https://github.com/werf/nelm.git</param> <param name="scm">git</param> <param name="exclude">.git</param> - <param name="revision">refs/tags/v1.24.3</param> + <param name="revision">refs/tags/v1.25.0</param> <param name="versionformat">@PARENT_TAG@</param> <param name="versionrewrite-pattern">v(.*)</param> <param name="changesgenerate">enable</param> ++++++ _servicedata ++++++ --- /var/tmp/diff_new_pack.oRxvgs/_old 2026-07-17 01:45:04.124461058 +0200 +++ /var/tmp/diff_new_pack.oRxvgs/_new 2026-07-17 01:45:04.132461328 +0200 @@ -3,6 +3,6 @@ <param name="url">https://github.com/werf/nelm</param> <param name="changesrevision">9366af9135202b7d705c71fef6c7dbe0231c0345</param></service><service name="tar_scm"> <param name="url">https://github.com/werf/nelm.git</param> - <param name="changesrevision">c0c3c7ab1457fbf634acee9b2d2a29b9cdc101d4</param></service></servicedata> + <param name="changesrevision">6c9bf7ee20e927cc031abedda4dbe1949e5f5af8</param></service></servicedata> (No newline at EOF) ++++++ nelm-1.24.3.obscpio -> nelm-1.25.0.obscpio ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/CHANGELOG.md new/nelm-1.25.0/CHANGELOG.md --- old/nelm-1.24.3/CHANGELOG.md 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/CHANGELOG.md 2026-06-18 11:27:01.000000000 +0200 @@ -1,5 +1,20 @@ # Changelog +## [1.25.0](https://github.com/werf/nelm/compare/v1.24.3...v1.25.0) (2026-06-18) + + +### Features + +* add automatic deploy dependency detection for KEDA ScaledObjects ([#631](https://github.com/werf/nelm/issues/631)) ([6ccf7ec](https://github.com/werf/nelm/commit/6ccf7ec6c431394225c1bf6524fd18cf8022f1fd)), closes [#456](https://github.com/werf/nelm/issues/456) + + +### Bug Fixes + +* hangs on very long pod log lines ([#638](https://github.com/werf/nelm/issues/638)) ([6e75224](https://github.com/werf/nelm/commit/6e75224d27d1ad2fef1620bbf10e72868ca9ca2b)) +* no more "no match for resource kind" errors ([679e6ec](https://github.com/werf/nelm/commit/679e6ec795cc08823ef783e288c15ac5668b7e3b)) +* retry also on conversion webhooks unavailability ([7f5713b](https://github.com/werf/nelm/commit/7f5713b2721944e08e5f65e58a85d6a85c695289)) +* show actual error if webhook retries fail ([17a4604](https://github.com/werf/nelm/commit/17a460431ed09474064dd4f1b23b29d6ef915f02)) + ## [1.24.3](https://github.com/werf/nelm/compare/v1.24.2...v1.24.3) (2026-06-08) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/README.md new/nelm-1.25.0/README.md --- old/nelm-1.24.3/README.md 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/README.md 2026-06-18 11:27:01.000000000 +0200 @@ -1,5 +1,10 @@ + <p align="center"> - <img src="resources/images/nelm-logo.png" style="max-height:100%;" height="100"> + <picture> + <source media="(prefers-color-scheme: dark)" srcset="resources/images/nelm-logo-white.svg"> + <source media="(prefers-color-scheme: light)" srcset="resources/images/nelm-logo-black.svg"> + <img alt="Nelm logo" src="resources/images/nelm-logo-white.svg" height="70"> + </picture> </p> <!-- <p align="center"> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/go.mod new/nelm-1.25.0/go.mod --- old/nelm-1.24.3/go.mod 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/go.mod 2026-06-18 11:27:01.000000000 +0200 @@ -58,7 +58,7 @@ github.com/tidwall/sjson v1.2.5 github.com/wI2L/jsondiff v0.5.0 github.com/werf/common-go v0.0.0-20251113140850-a1a98e909e9b - github.com/werf/kubedog v0.13.1-0.20260115171811-304218f24308 + github.com/werf/kubedog v0.13.1-0.20260616105957-2c00b08fb99e github.com/werf/lockgate v0.1.1 github.com/werf/logboek v0.6.1 github.com/xeipuuv/gojsonschema v1.2.0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/go.sum new/nelm-1.25.0/go.sum --- old/nelm-1.24.3/go.sum 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/go.sum 2026-06-18 11:27:01.000000000 +0200 @@ -435,8 +435,8 @@ github.com/wI2L/jsondiff v0.5.0/go.mod h1:qqG6hnK0Lsrz2BpIVCxWiK9ItsBCpIZQiv0izJjOZ9s= github.com/werf/common-go v0.0.0-20251113140850-a1a98e909e9b h1:58850oFrnw5Jy5YaB8QifXz75qpGotfx6qqZ9Q2my1A= github.com/werf/common-go v0.0.0-20251113140850-a1a98e909e9b/go.mod h1:MXS0JR9zut+oR9oEM8PEkdXXoEbKDILTmWopt0z1eZs= -github.com/werf/kubedog v0.13.1-0.20260115171811-304218f24308 h1:ee55f/lNya8V9jCBsQWDhvOw6y1fB0uysop8te9aUcM= -github.com/werf/kubedog v0.13.1-0.20260115171811-304218f24308/go.mod h1:gu4EY4hxtiYVDy5o6WE2lRZS0YWqrOV0HS//GTYyrUE= +github.com/werf/kubedog v0.13.1-0.20260616105957-2c00b08fb99e h1:0GnrtMMti+Qywd4bs4tHtchBS61EzS6t1NYqMPql5dE= +github.com/werf/kubedog v0.13.1-0.20260616105957-2c00b08fb99e/go.mod h1:gu4EY4hxtiYVDy5o6WE2lRZS0YWqrOV0HS//GTYyrUE= github.com/werf/lockgate v0.1.1 h1:S400JFYjtWfE4i4LY9FA8zx0fMdfui9DPrBiTciCrx4= github.com/werf/lockgate v0.1.1/go.mod h1:0yIFSLq9ausy6ejNxF5uUBf/Ib6daMAfXuCaTMZJzIE= github.com/werf/logboek v0.6.1 h1:oEe6FkmlKg0z0n80oZjLplj6sXcBeLleCkjfOOZEL2g= diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/action/release_uninstall.go new/nelm-1.25.0/pkg/action/release_uninstall.go --- old/nelm-1.24.3/pkg/action/release_uninstall.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/action/release_uninstall.go 2026-06-18 11:27:01.000000000 +0200 @@ -87,7 +87,8 @@ return releaseUninstall(ctx, ctxCancelFn, releaseName, releaseNamespace, opts) } - ctx, _ = context.WithTimeoutCause(ctx, opts.Timeout, fmt.Errorf("context timed out: action timed out after %s", opts.Timeout.String())) + ctx, timeoutCancel := context.WithTimeoutCause(ctx, opts.Timeout, fmt.Errorf("context timed out: action timed out after %s", opts.Timeout.String())) + defer timeoutCancel() defer ctxCancelFn(fmt.Errorf("context canceled: action finished")) actionCh := make(chan error, 1) @@ -414,6 +415,7 @@ taskState := kdutil.NewConcurrent( statestore.NewAbsenceTaskState(nsMeta.Name, "", nsMeta.GroupVersionKind, statestore.AbsenceTaskStateOptions{}), ) + tracker := dyntracker.NewDynamicAbsenceTracker(taskState, informerFactory, clientFactory.Dynamic(), clientFactory.Mapper(), dyntracker.DynamicAbsenceTrackerOptions{ Timeout: opts.TrackDeletionTimeout, }) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/chart/chart_render.go new/nelm-1.25.0/pkg/chart/chart_render.go --- old/nelm-1.24.3/pkg/chart/chart_render.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/chart/chart_render.go 2026-06-18 11:27:01.000000000 +0200 @@ -278,9 +278,11 @@ } if opts.Remote { - clientFactory.Discovery().Invalidate() + if err := clientFactory.KubeClient().ResetDiscoveryCache(ctx); err != nil { + return nil, fmt.Errorf("refresh discovery: %w", err) + } - kubeVersion, err := clientFactory.Discovery().ServerVersion() + kubeVersion, err := clientFactory.KubeClient().ServerVersion(ctx) if err != nil { return nil, fmt.Errorf("get kubernetes server version: %w", err) } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/chart/chart_render_ai_test.go new/nelm-1.25.0/pkg/chart/chart_render_ai_test.go --- old/nelm-1.24.3/pkg/chart/chart_render_ai_test.go 1970-01-01 01:00:00.000000000 +0100 +++ new/nelm-1.25.0/pkg/chart/chart_render_ai_test.go 2026-06-18 11:27:01.000000000 +0200 @@ -0,0 +1,158 @@ +//go:build ai_tests + +package chart + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + apimeta "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/version" + "k8s.io/client-go/discovery" + discfake "k8s.io/client-go/discovery/fake" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/kubernetes" + ktesting "k8s.io/client-go/testing" + + "github.com/werf/nelm/pkg/kube" + "github.com/werf/nelm/pkg/resource/spec" +) + +var ( + _ kube.ClientFactorier = (*chartCapabilitiesClientFactory)(nil) + _ kube.KubeClienter = (*chartCapabilitiesKubeClient)(nil) +) + +type chartCapabilitiesClientFactory struct { + discoveryClient discovery.CachedDiscoveryInterface + kubeClient kube.KubeClienter +} + +func (f *chartCapabilitiesClientFactory) Discovery() discovery.CachedDiscoveryInterface { + return f.discoveryClient +} + +func (f *chartCapabilitiesClientFactory) Dynamic() dynamic.Interface { + panic("not implemented") +} + +func (f *chartCapabilitiesClientFactory) KubeClient() kube.KubeClienter { + return f.kubeClient +} + +func (f *chartCapabilitiesClientFactory) KubeConfig() *kube.KubeConfig { + panic("not implemented") +} + +func (f *chartCapabilitiesClientFactory) LegacyClientGetter() *kube.LegacyClientGetter { + panic("not implemented") +} + +func (f *chartCapabilitiesClientFactory) Mapper() apimeta.ResettableRESTMapper { + panic("not implemented") +} + +func (f *chartCapabilitiesClientFactory) Static() kubernetes.Interface { + panic("not implemented") +} + +type chartCapabilitiesKubeClient struct { + refreshCount int + serverVersionSawRefresh bool +} + +func (c *chartCapabilitiesKubeClient) Apply(ctx context.Context, spec *spec.ResourceSpec, opts kube.KubeClientApplyOptions) (*unstructured.Unstructured, error) { + panic("not implemented") +} + +func (c *chartCapabilitiesKubeClient) Create(ctx context.Context, spec *spec.ResourceSpec, opts kube.KubeClientCreateOptions) (*unstructured.Unstructured, error) { + panic("not implemented") +} + +func (c *chartCapabilitiesKubeClient) Delete(ctx context.Context, meta *spec.ResourceMeta, opts kube.KubeClientDeleteOptions) error { + panic("not implemented") +} + +func (c *chartCapabilitiesKubeClient) GVKToGVR(ctx context.Context, gvk schema.GroupVersionKind) (schema.GroupVersionResource, bool, error) { + panic("not implemented") +} + +func (c *chartCapabilitiesKubeClient) Get(ctx context.Context, meta *spec.ResourceMeta, opts kube.KubeClientGetOptions) (*unstructured.Unstructured, error) { + panic("not implemented") +} + +func (c *chartCapabilitiesKubeClient) MergePatch(ctx context.Context, meta *spec.ResourceMeta, patch []byte, opts kube.KubeClientMergePatchOptions) (*unstructured.Unstructured, error) { + panic("not implemented") +} + +func (c *chartCapabilitiesKubeClient) Namespaced(ctx context.Context, gvk schema.GroupVersionKind) (bool, error) { + panic("not implemented") +} + +func (c *chartCapabilitiesKubeClient) ResetAndRetryOnUnknownGVR(ctx context.Context, fn func() error) error { + return fn() +} + +func (c *chartCapabilitiesKubeClient) ResetDiscoveryCache(ctx context.Context) error { + c.refreshCount++ + + return nil +} + +func (c *chartCapabilitiesKubeClient) ServerVersion(ctx context.Context) (*version.Info, error) { + if c.refreshCount > 0 { + c.serverVersionSawRefresh = true + } + + return &version.Info{GitVersion: "v1.34.0", Major: "1", Minor: "34"}, nil +} + +type chartCapabilitiesDiscovery struct { + *discfake.FakeDiscovery + + kubeClient *chartCapabilitiesKubeClient +} + +func newChartCapabilitiesDiscovery(kubeClient *chartCapabilitiesKubeClient) *chartCapabilitiesDiscovery { + fakeDiscovery := &discfake.FakeDiscovery{ + Fake: &ktesting.Fake{}, + FakedServerVersion: &version.Info{ + GitVersion: "v1.34.0", + Major: "1", + Minor: "34", + }, + } + fakeDiscovery.Resources = []*metav1.APIResourceList{} + + return &chartCapabilitiesDiscovery{ + FakeDiscovery: fakeDiscovery, + kubeClient: kubeClient, + } +} + +func (d *chartCapabilitiesDiscovery) Fresh() bool { + return true +} + +func (d *chartCapabilitiesDiscovery) Invalidate() {} + +func TestAI_BuildChartCapabilitiesRefreshesKubeClientDiscovery(t *testing.T) { + fakeKubeClient := &chartCapabilitiesKubeClient{} + fakeDiscovery := newChartCapabilitiesDiscovery(fakeKubeClient) + clientFactory := &chartCapabilitiesClientFactory{ + discoveryClient: fakeDiscovery, + kubeClient: fakeKubeClient, + } + + capabilities, err := buildChartCapabilities(context.Background(), clientFactory, buildChartCapabilitiesOptions{Remote: true}) + require.NoError(t, err) + + assert.Equal(t, 1, fakeKubeClient.refreshCount) + assert.Equal(t, "v1.34.0", capabilities.KubeVersion.Version) + assert.True(t, fakeKubeClient.serverVersionSawRefresh) +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/common/common.go new/nelm-1.25.0/pkg/common/common.go --- old/nelm-1.24.3/pkg/common/common.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/common/common.go 2026-06-18 11:27:01.000000000 +0200 @@ -97,12 +97,14 @@ DefaultDiffContextLines = 3 DefaultFieldManager = "helm" // TODO(major): update to a more recent version? Not sure about backwards compatibility. - DefaultLocalKubeVersion = "1.20.0" - DefaultLogColorMode = log.LogColorModeAuto - DefaultNetworkParallelism = 30 - DefaultProgressPrintInterval = 5 * time.Second - DefaultQPSLimit = 30 - DefaultReleaseHistoryLimit = 10 + DefaultLocalKubeVersion = "1.20.0" + DefaultLogColorMode = log.LogColorModeAuto + DefaultMapperNoMatchRetryInterval = 500 * time.Millisecond + DefaultMapperNoMatchRetryTimeout = 10 * time.Second + DefaultNetworkParallelism = 30 + DefaultProgressPrintInterval = 5 * time.Second + DefaultQPSLimit = 30 + DefaultReleaseHistoryLimit = 10 // DefaultResourceValidationKubeVersion Kubernetes version to use during resource validation by kubeconform DefaultResourceValidationKubeVersion = "1.35.0" DefaultWebhookRetryTimeout = 2 * time.Minute diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/helm/pkg/provenance/sign_test.go new/nelm-1.25.0/pkg/helm/pkg/provenance/sign_test.go --- old/nelm-1.24.3/pkg/helm/pkg/provenance/sign_test.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/helm/pkg/provenance/sign_test.go 2026-06-18 11:27:01.000000000 +0200 @@ -25,6 +25,8 @@ "testing" pgperrors "golang.org/x/crypto/openpgp/errors" //nolint + + "github.com/werf/nelm/pkg/helm/pkg/werf/helmopts" ) const ( @@ -76,7 +78,7 @@ ` func TestMessageBlock(t *testing.T) { - out, err := messageBlock(testChartfile) + out, err := messageBlock(testChartfile, helmopts.HelmOptions{}) if err != nil { t.Fatal(err) } @@ -221,7 +223,7 @@ t.Fatal(err) } - sig, err := signer.ClearSign(testChartfile) + sig, err := signer.ClearSign(testChartfile, helmopts.HelmOptions{}) if err != nil { t.Fatal(err) } @@ -252,7 +254,7 @@ // ensure that signing always fails signer.Entity.PrivateKey.PrivateKey = failSigner{} - sig, err := signer.ClearSign(testChartfile) + sig, err := signer.ClearSign(testChartfile, helmopts.HelmOptions{}) if err == nil { t.Fatal("didn't get an error from ClearSign but expected one") } @@ -271,7 +273,7 @@ t.Fatal(err) } - sig, err := signer.ClearSign(testChartfile) + sig, err := signer.ClearSign(testChartfile, helmopts.HelmOptions{}) if err != nil { t.Fatal(err) } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/kube/client_kube.go new/nelm-1.25.0/pkg/kube/client_kube.go --- old/nelm-1.24.3/pkg/kube/client_kube.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/kube/client_kube.go 2026-06-18 11:27:01.000000000 +0200 @@ -14,6 +14,7 @@ "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/types" kvwait "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/apimachinery/pkg/version" "k8s.io/client-go/discovery" "k8s.io/client-go/dynamic" "k8s.io/client-go/kubernetes" @@ -31,32 +32,43 @@ Apply(ctx context.Context, spec *spec.ResourceSpec, opts KubeClientApplyOptions) (*unstructured.Unstructured, error) MergePatch(ctx context.Context, meta *spec.ResourceMeta, patch []byte, opts KubeClientMergePatchOptions) (*unstructured.Unstructured, error) Delete(ctx context.Context, meta *spec.ResourceMeta, opts KubeClientDeleteOptions) error + GVKToGVR(ctx context.Context, gvk schema.GroupVersionKind) (schema.GroupVersionResource, bool, error) + Namespaced(ctx context.Context, gvk schema.GroupVersionKind) (bool, error) + ResetDiscoveryCache(ctx context.Context) error + ServerVersion(ctx context.Context) (*version.Info, error) + ResetAndRetryOnUnknownGVR(ctx context.Context, fn func() error) error } // High-level Kubernetes Client. Always prefer using it instead of static/dynamic Kubernetes // go-client directly. Provides caching, which works as long as there is no other client or other // program modifying Kubernetes resources that we work with through this client. type KubeClient struct { - clusterCache *ttlcache.Cache[string, *clusterCacheEntry] - discoveryClient discovery.CachedDiscoveryInterface - dynamicClient dynamic.Interface - mapper apimeta.ResettableRESTMapper - resourceLocks *sync.Map - staticClient kubernetes.Interface + clusterCache *ttlcache.Cache[string, *clusterCacheEntry] + discoveryClient discovery.CachedDiscoveryInterface + dynamicClient dynamic.Interface + mapper apimeta.ResettableRESTMapper + mapperNoMatchRetryInterval time.Duration + mapperNoMatchRetryTimeout time.Duration + mapperRefreshLock *sync.RWMutex + resourceLocks *sync.Map + staticClient kubernetes.Interface } func NewKubeClient(staticClient kubernetes.Interface, dynamicClient dynamic.Interface, discoveryClient discovery.CachedDiscoveryInterface, mapper apimeta.ResettableRESTMapper) *KubeClient { - clusterCache := ttlcache.New[string, *clusterCacheEntry]( + clusterCache := ttlcache.New( ttlcache.WithDisableTouchOnHit[string, *clusterCacheEntry](), ) return &KubeClient{ - clusterCache: clusterCache, - discoveryClient: discoveryClient, - dynamicClient: dynamicClient, - mapper: mapper, - resourceLocks: &sync.Map{}, - staticClient: staticClient, + clusterCache: clusterCache, + discoveryClient: discoveryClient, + dynamicClient: dynamicClient, + mapper: mapper, + mapperNoMatchRetryInterval: common.DefaultMapperNoMatchRetryInterval, + mapperNoMatchRetryTimeout: common.DefaultMapperNoMatchRetryTimeout, + mapperRefreshLock: &sync.RWMutex{}, + resourceLocks: &sync.Map{}, + staticClient: staticClient, } } @@ -66,8 +78,18 @@ lock.Lock() defer lock.Unlock() - gvr, namespaced, err := spec.GVKtoGVR(resSpec.GroupVersionKind, c.mapper) - if err != nil { + var ( + gvr schema.GroupVersionResource + namespaced bool + err error + ) + if err := c.ResetAndRetryOnUnknownGVR(ctx, func() error { + var err error + + gvr, namespaced, err = c.GVKToGVR(ctx, resSpec.GroupVersionKind) + + return err + }); err != nil { return nil, fmt.Errorf("convert GVK to GVR: %w", err) } @@ -116,7 +138,9 @@ } if spec.IsCRDFromGR(gvr.GroupResource()) && !opts.DryRun { - c.mapper.Reset() + if err := c.waitForCRDDiscoverability(ctx, resSpec); err != nil { + return nil, fmt.Errorf("wait for CRD discoverability: %w", err) + } } log.Default.TraceStruct(ctx, resultObj, "Server-side %sapplied resource %q via Kubernetes API:", lo.Ternary(opts.DryRun, "dry-run ", ""), resSpec.IDHuman()) @@ -130,8 +154,18 @@ lock.Lock() defer lock.Unlock() - gvr, namespaced, err := spec.GVKtoGVR(resSpec.GroupVersionKind, c.mapper) - if err != nil { + var ( + gvr schema.GroupVersionResource + namespaced bool + err error + ) + if err := c.ResetAndRetryOnUnknownGVR(ctx, func() error { + var err error + + gvr, namespaced, err = c.GVKToGVR(ctx, resSpec.GroupVersionKind) + + return err + }); err != nil { return nil, fmt.Errorf("convert GVK to GVR: %w", err) } @@ -176,7 +210,9 @@ c.clusterCache.Set(resSpec.IDWithVersion(), &clusterCacheEntry{obj: resultObj.DeepCopy()}, 0) if spec.IsCRDFromGR(gvr.GroupResource()) { - c.mapper.Reset() + if err := c.waitForCRDDiscoverability(ctx, resSpec); err != nil { + return nil, fmt.Errorf("wait for CRD discoverability: %w", err) + } } log.Default.TraceStruct(ctx, resultObj, "Created resource %q via Kubernetes API:", resSpec.IDHuman()) @@ -190,8 +226,18 @@ lock.Lock() defer lock.Unlock() - gvr, namespaced, err := spec.GVKtoGVR(resMeta.GroupVersionKind, c.mapper) - if err != nil { + var ( + gvr schema.GroupVersionResource + namespaced bool + ) + + if err := c.ResetAndRetryOnUnknownGVR(ctx, func() error { + var err error + + gvr, namespaced, err = c.GVKToGVR(ctx, resMeta.GroupVersionKind) + + return err + }); err != nil { return fmt.Errorf("convert GVK to GVR: %w", err) } @@ -223,6 +269,18 @@ return nil } +func (c *KubeClient) GVKToGVR(_ context.Context, gvk schema.GroupVersionKind) (schema.GroupVersionResource, bool, error) { + c.mapperRefreshLock.RLock() + defer c.mapperRefreshLock.RUnlock() + + gvr, namespaced, err := spec.GVKtoGVR(gvk, c.mapper) + if err != nil { + return schema.GroupVersionResource{}, false, fmt.Errorf("get GVK to GVR mapping: %w", err) + } + + return gvr, namespaced, nil +} + func (c *KubeClient) Get(ctx context.Context, resMeta *spec.ResourceMeta, opts KubeClientGetOptions) (*unstructured.Unstructured, error) { lock := c.resourceLock(resMeta) @@ -243,8 +301,18 @@ } } - gvr, namespaced, err := spec.GVKtoGVR(resMeta.GroupVersionKind, c.mapper) - if err != nil { + var ( + gvr schema.GroupVersionResource + namespaced bool + ) + + if err := c.ResetAndRetryOnUnknownGVR(ctx, func() error { + var err error + + gvr, namespaced, err = c.GVKToGVR(ctx, resMeta.GroupVersionKind) + + return err + }); err != nil { return nil, fmt.Errorf("convert GVK to GVR: %w", err) } @@ -272,8 +340,18 @@ lock.Lock() defer lock.Unlock() - gvr, namespaced, err := spec.GVKtoGVR(resMeta.GroupVersionKind, c.mapper) - if err != nil { + var ( + gvr schema.GroupVersionResource + namespaced bool + ) + + if err := c.ResetAndRetryOnUnknownGVR(ctx, func() error { + var err error + + gvr, namespaced, err = c.GVKToGVR(ctx, resMeta.GroupVersionKind) + + return err + }); err != nil { return nil, fmt.Errorf("convert GVK to GVR: %w", err) } @@ -299,6 +377,95 @@ return resultObj, nil } +func (c *KubeClient) Namespaced(_ context.Context, gvk schema.GroupVersionKind) (bool, error) { + c.mapperRefreshLock.RLock() + defer c.mapperRefreshLock.RUnlock() + + namespaced, err := spec.Namespaced(gvk, c.mapper) + if err != nil { + return false, fmt.Errorf("check resource scope: %w", err) + } + + return namespaced, nil +} + +func (c *KubeClient) ResetAndRetryOnUnknownGVR(ctx context.Context, fn func() error) error { + firstErr := fn() + if firstErr == nil { + return nil + } + + if !apimeta.IsNoMatchError(firstErr) { + return firstErr + } + + var resultErr error + + func() { + retryCtx, cancel := context.WithTimeout(ctx, c.mapperNoMatchRetryTimeout) + defer cancel() + + lastErr := firstErr + + if err := c.ResetDiscoveryCache(retryCtx); err != nil { + resultErr = fmt.Errorf("reset discovery cache after mapper NoMatch: %w", err) + + return + } + + if err := kvwait.PollUntilContextCancel(retryCtx, c.mapperNoMatchRetryInterval, false, func(ctx context.Context) (bool, error) { + if err := fn(); err != nil { + lastErr = err + if apimeta.IsNoMatchError(err) { + if err := c.ResetDiscoveryCache(ctx); err != nil { + return false, fmt.Errorf("reset discovery cache after mapper NoMatch: %w", err) + } + + return false, nil + } + + return false, err + } + + return true, nil + }); err != nil { + if retryCtx.Err() != nil { + if ctx.Err() != nil { + resultErr = fmt.Errorf("retry mapper NoMatch: %w", context.Cause(ctx)) + + return + } + + resultErr = fmt.Errorf("retry mapper NoMatch timed out after %s: %w", c.mapperNoMatchRetryTimeout.String(), lastErr) + + return + } + + resultErr = err + } + }() + + return resultErr +} + +func (c *KubeClient) ResetDiscoveryCache(_ context.Context) error { + c.mapperRefreshLock.Lock() + defer c.mapperRefreshLock.Unlock() + + c.resetDiscoveryCacheNoLock() + + return nil +} + +func (c *KubeClient) ServerVersion(_ context.Context) (*version.Info, error) { + versionInfo, err := c.discoveryClient.ServerVersion() + if err != nil { + return nil, fmt.Errorf("get kubernetes server version: %w", err) + } + + return versionInfo, nil +} + func (c *KubeClient) clientResource(gvr schema.GroupVersionResource, namespace, defaultNamespace string, namespaced bool) dynamic.ResourceInterface { if namespaced { if namespace == "" { @@ -311,12 +478,40 @@ return c.dynamicClient.Resource(gvr) } +func (c *KubeClient) resetDiscoveryCacheNoLock() { + c.discoveryClient.Invalidate() + c.mapper.Reset() +} + func (c *KubeClient) resourceLock(meta *spec.ResourceMeta) *sync.Mutex { lock, _ := c.resourceLocks.LoadOrStore(meta.IDWithVersion(), &sync.Mutex{}) return lock.(*sync.Mutex) } +func (c *KubeClient) waitForCRDDiscoverability(ctx context.Context, resSpec *spec.ResourceSpec) error { + servedGVKs, err := servedCRDGVKs(resSpec.Unstruct) + if err != nil { + return fmt.Errorf("extract served GVKs: %w", err) + } + + if err := c.ResetDiscoveryCache(ctx); err != nil { + return fmt.Errorf("refresh discovery: %w", err) + } + + for _, gvk := range servedGVKs { + if err := c.ResetAndRetryOnUnknownGVR(ctx, func() error { + _, _, err := c.GVKToGVR(ctx, gvk) + + return err + }); err != nil { + return fmt.Errorf("resolve served GVK %q: %w", gvk.String(), err) + } + } + + return nil +} + type KubeClientGetOptions struct { DefaultNamespace string TryCache bool @@ -352,21 +547,23 @@ retryCtx, cancel := context.WithTimeoutCause(ctx, common.DefaultWebhookRetryTimeout, fmt.Errorf("context timed out: webhook retry timed out after %s", common.DefaultWebhookRetryTimeout.String())) defer cancel() + var lastErr error if err := kvwait.PollUntilContextCancel(retryCtx, 2*time.Second, true, func(ctx context.Context) (bool, error) { - if err := fn(); err != nil { - if IsWebhookErr(err) { - log.Default.Debug(ctx, "Retrying due to webhook error: %s", err) + lastErr = fn() + if lastErr != nil { + if IsWebhookErr(lastErr) { + log.Default.Debug(ctx, "Retrying due to webhook error: %s", lastErr) return false, nil } - return false, err + return false, lastErr } return true, nil }); err != nil { if retryCtx.Err() != nil { - return fmt.Errorf("retryable on webhook error: %w", context.Cause(retryCtx)) + return fmt.Errorf("retryable on webhook error: %w due to: %w", context.Cause(retryCtx), lastErr) } return fmt.Errorf("retryable on webhook error: %w", err) @@ -374,3 +571,70 @@ return nil } + +func servedCRDGVKs(obj *unstructured.Unstructured) ([]schema.GroupVersionKind, error) { + group, found, err := unstructured.NestedString(obj.UnstructuredContent(), "spec", "group") + if err != nil { + return nil, fmt.Errorf("get spec.group: %w", err) + } + + if !found || group == "" { + return nil, fmt.Errorf("get spec.group: value not found") + } + + kind, found, err := unstructured.NestedString(obj.UnstructuredContent(), "spec", "names", "kind") + if err != nil { + return nil, fmt.Errorf("get spec.names.kind: %w", err) + } + + if !found || kind == "" { + return nil, fmt.Errorf("get spec.names.kind: value not found") + } + + var result []schema.GroupVersionKind + + versions, found, err := unstructured.NestedSlice(obj.UnstructuredContent(), "spec", "versions") + if err != nil { + return nil, fmt.Errorf("get spec.versions: %w", err) + } + + if found { + for i, rawVersion := range versions { + versionMap, ok := rawVersion.(map[string]any) + if !ok { + return nil, fmt.Errorf("get spec.versions[%d]: expected object", i) + } + + served, _, err := unstructured.NestedBool(versionMap, "served") + if err != nil { + return nil, fmt.Errorf("get spec.versions[%d].served: %w", i, err) + } + + if !served { + continue + } + + version, found, err := unstructured.NestedString(versionMap, "name") + if err != nil { + return nil, fmt.Errorf("get spec.versions[%d].name: %w", i, err) + } + + if !found || version == "" { + return nil, fmt.Errorf("get spec.versions[%d].name: value not found", i) + } + + result = append(result, schema.GroupVersionKind{Group: group, Version: version, Kind: kind}) + } + } else { + version, found, err := unstructured.NestedString(obj.UnstructuredContent(), "spec", "version") + if err != nil { + return nil, fmt.Errorf("get spec.version: %w", err) + } + + if found && version != "" { + result = append(result, schema.GroupVersionKind{Group: group, Version: version, Kind: kind}) + } + } + + return result, nil +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/kube/client_kube_ai_test.go new/nelm-1.25.0/pkg/kube/client_kube_ai_test.go --- old/nelm-1.24.3/pkg/kube/client_kube_ai_test.go 1970-01-01 01:00:00.000000000 +0100 +++ new/nelm-1.25.0/pkg/kube/client_kube_ai_test.go 2026-06-18 11:27:01.000000000 +0200 @@ -0,0 +1,296 @@ +//go:build ai_tests + +package kube + +import ( + "context" + "errors" + "fmt" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + apimeta "k8s.io/apimachinery/pkg/api/meta" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + discfake "k8s.io/client-go/discovery/fake" + dynfake "k8s.io/client-go/dynamic/fake" + "k8s.io/client-go/kubernetes/scheme" + ktesting "k8s.io/client-go/testing" + + "github.com/werf/nelm/pkg/resource/spec" +) + +type testCachedDiscoveryClient struct { + *discfake.FakeDiscovery + + invalidateCount int +} + +func newTestCachedDiscoveryClient() *testCachedDiscoveryClient { + return &testCachedDiscoveryClient{ + FakeDiscovery: &discfake.FakeDiscovery{Fake: &ktesting.Fake{}}, + } +} + +func (c *testCachedDiscoveryClient) Fresh() bool { + return true +} + +func (c *testCachedDiscoveryClient) Invalidate() { + c.invalidateCount++ +} + +type testResettableMapper struct { + err error + mappingCalls int + resetCount int + succeedAfterResets int +} + +func (m *testResettableMapper) KindFor(resource schema.GroupVersionResource) (schema.GroupVersionKind, error) { + panic("not implemented") +} + +func (m *testResettableMapper) KindsFor(resource schema.GroupVersionResource) ([]schema.GroupVersionKind, error) { + panic("not implemented") +} + +func (m *testResettableMapper) RESTMapping(gk schema.GroupKind, versions ...string) (*apimeta.RESTMapping, error) { + m.mappingCalls++ + if m.err != nil { + return nil, m.err + } + + version := "v1" + if len(versions) > 0 { + version = versions[0] + } + + if m.resetCount < m.succeedAfterResets { + return nil, &apimeta.NoKindMatchError{GroupKind: gk, SearchedVersions: []string{version}} + } + + scope := apimeta.RESTScopeNamespace + if gk.Group == "" && gk.Kind == "Namespace" { + scope = apimeta.RESTScopeRoot + } + + return &apimeta.RESTMapping{ + Resource: schema.GroupVersionResource{Group: gk.Group, Version: version, Resource: strings.ToLower(gk.Kind) + "s"}, + GroupVersionKind: schema.GroupVersionKind{Group: gk.Group, Version: version, Kind: gk.Kind}, + Scope: scope, + }, nil +} + +func (m *testResettableMapper) RESTMappings(gk schema.GroupKind, versions ...string) ([]*apimeta.RESTMapping, error) { + mapping, err := m.RESTMapping(gk, versions...) + if err != nil { + return nil, err + } + + return []*apimeta.RESTMapping{mapping}, nil +} + +func (m *testResettableMapper) Reset() { + m.resetCount++ +} + +func (m *testResettableMapper) ResourceFor(input schema.GroupVersionResource) (schema.GroupVersionResource, error) { + panic("not implemented") +} + +func (m *testResettableMapper) ResourceSingularizer(resource string) (string, error) { + panic("not implemented") +} + +func (m *testResettableMapper) ResourcesFor(input schema.GroupVersionResource) ([]schema.GroupVersionResource, error) { + panic("not implemented") +} + +func TestAI_KubeClientDelete_UsesRetryingGVKResolution(t *testing.T) { + client, discoveryClient, mapper := newTestKubeClient(1) + client.dynamicClient = dynfake.NewSimpleDynamicClient(scheme.Scheme) + meta := spec.NewResourceMeta("widget", "default", "default", "", schema.GroupVersionKind{Group: "example.com", Version: "v1", Kind: "Widget"}, nil, nil) + + err := client.Delete(context.Background(), meta, KubeClientDeleteOptions{DefaultNamespace: "default"}) + require.NoError(t, err) + + assert.Equal(t, 2, mapper.mappingCalls) + assert.Equal(t, 1, discoveryClient.invalidateCount) +} + +func TestAI_KubeClientGVKToGVR_DoesNotRetryNonNoMatch(t *testing.T) { + client, discoveryClient, mapper := newTestKubeClient(0) + boom := errors.New("discovery forbidden") + mapper.err = boom + + err := client.ResetAndRetryOnUnknownGVR(context.Background(), func() error { + _, _, err := client.GVKToGVR(context.Background(), schema.GroupVersionKind{Group: "example.com", Version: "v1", Kind: "Widget"}) + + return err + }) + require.ErrorIs(t, err, boom) + + assert.Equal(t, 1, mapper.mappingCalls) + assert.Equal(t, 0, mapper.resetCount) + assert.Equal(t, 0, discoveryClient.invalidateCount) +} + +func TestAI_KubeClientGVKToGVR_RetriesNoMatchAfterRefresh(t *testing.T) { + client, discoveryClient, mapper := newTestKubeClient(1) + + var ( + gvr schema.GroupVersionResource + namespaced bool + ) + + err := client.ResetAndRetryOnUnknownGVR(context.Background(), func() error { + var err error + + gvr, namespaced, err = client.GVKToGVR(context.Background(), schema.GroupVersionKind{Group: "example.com", Version: "v1", Kind: "Widget"}) + + return err + }) + require.NoError(t, err) + + assert.Equal(t, schema.GroupVersionResource{Group: "example.com", Version: "v1", Resource: "widgets"}, gvr) + assert.True(t, namespaced) + assert.Equal(t, 2, mapper.mappingCalls) + assert.Equal(t, 1, mapper.resetCount) + assert.Equal(t, 1, discoveryClient.invalidateCount) +} + +func TestAI_KubeClientGVKToGVR_StopsOnContextCancellation(t *testing.T) { + client, _, _ := newTestKubeClient(1000) + ctx, cancel := context.WithCancelCause(context.Background()) + cancel(fmt.Errorf("mapping canceled")) + + err := client.ResetAndRetryOnUnknownGVR(ctx, func() error { + _, _, err := client.GVKToGVR(ctx, schema.GroupVersionKind{Group: "example.com", Version: "v1", Kind: "Widget"}) + + return err + }) + require.Error(t, err) + + assert.Contains(t, err.Error(), "mapping canceled") +} + +func TestAI_KubeClientGVKToGVR_SucceedsWithoutRetry(t *testing.T) { + client, discoveryClient, mapper := newTestKubeClient(0) + + gvr, namespaced, err := client.GVKToGVR(context.Background(), schema.GroupVersionKind{Group: "apps", Version: "v1", Kind: "Deployment"}) + require.NoError(t, err) + + assert.Equal(t, schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}, gvr) + assert.True(t, namespaced) + assert.Equal(t, 1, mapper.mappingCalls) + assert.Equal(t, 0, mapper.resetCount) + assert.Equal(t, 0, discoveryClient.invalidateCount) +} + +func TestAI_KubeClientGVKToGVR_TimesOutOnRepeatedNoMatch(t *testing.T) { + client, discoveryClient, mapper := newTestKubeClient(1000) + client.mapperNoMatchRetryTimeout = 5 * time.Millisecond + client.mapperNoMatchRetryInterval = time.Millisecond + + err := client.ResetAndRetryOnUnknownGVR(context.Background(), func() error { + _, _, err := client.GVKToGVR(context.Background(), schema.GroupVersionKind{Group: "example.com", Version: "v1", Kind: "Widget"}) + + return err + }) + require.Error(t, err) + + assert.Contains(t, err.Error(), "retry mapper NoMatch timed out after") + assert.True(t, mapper.resetCount > 0) + assert.Equal(t, mapper.resetCount, discoveryClient.invalidateCount) +} + +func TestAI_KubeClientNamespaced_RetriesNoMatchAfterRefresh(t *testing.T) { + client, discoveryClient, mapper := newTestKubeClient(1) + + var namespaced bool + + err := client.ResetAndRetryOnUnknownGVR(context.Background(), func() error { + var err error + + namespaced, err = client.Namespaced(context.Background(), schema.GroupVersionKind{Group: "apps", Version: "v1", Kind: "Deployment"}) + + return err + }) + require.NoError(t, err) + + assert.True(t, namespaced) + assert.Equal(t, 2, mapper.mappingCalls) + assert.Equal(t, 1, mapper.resetCount) + assert.Equal(t, 1, discoveryClient.invalidateCount) +} + +func TestAI_KubeClientRefreshDiscovery_InvalidatesDiscoveryAndResetsMapper(t *testing.T) { + client, discoveryClient, mapper := newTestKubeClient(0) + + require.NoError(t, client.ResetDiscoveryCache(context.Background())) + + assert.Equal(t, 1, discoveryClient.invalidateCount) + assert.Equal(t, 1, mapper.resetCount) +} + +func TestAI_KubeClientWaitForCRDDiscoverability_ResolvesServedGVKs(t *testing.T) { + client, discoveryClient, mapper := newTestKubeClient(2) + crd := newTestCRD(map[string]any{ + "group": "example.com", + "names": map[string]any{ + "kind": "Widget", + "plural": "widgets", + }, + "scope": "Namespaced", + "versions": []any{ + map[string]any{"name": "v1", "served": true}, + map[string]any{"name": "v2", "served": false}, + }, + }) + + err := client.waitForCRDDiscoverability(context.Background(), crd) + require.NoError(t, err) + + assert.Equal(t, 2, discoveryClient.invalidateCount) + assert.Equal(t, 2, mapper.resetCount) + assert.Equal(t, 2, mapper.mappingCalls) +} + +func TestAI_ServedCRDGVKs_SupportsV1Beta1VersionFieldWithOmittedScope(t *testing.T) { + crd := newTestCRD(map[string]any{ + "group": "example.com", + "names": map[string]any{ + "kind": "Widget", + }, + "version": "v1beta1", + }) + + gvks, err := servedCRDGVKs(crd.Unstruct) + require.NoError(t, err) + + assert.Equal(t, []schema.GroupVersionKind{{Group: "example.com", Version: "v1beta1", Kind: "Widget"}}, gvks) +} + +func newTestCRD(crdSpec map[string]any) *spec.ResourceSpec { + return &spec.ResourceSpec{ + Unstruct: &unstructured.Unstructured{ + Object: map[string]any{ + "spec": crdSpec, + }, + }, + } +} + +func newTestKubeClient(succeedAfterResets int) (*KubeClient, *testCachedDiscoveryClient, *testResettableMapper) { + discoveryClient := newTestCachedDiscoveryClient() + mapper := &testResettableMapper{succeedAfterResets: succeedAfterResets} + client := NewKubeClient(nil, nil, discoveryClient, mapper) + client.mapperNoMatchRetryTimeout = time.Second + client.mapperNoMatchRetryInterval = time.Millisecond + + return client, discoveryClient, mapper +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/kube/error.go new/nelm-1.25.0/pkg/kube/error.go --- old/nelm-1.24.3/pkg/kube/error.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/kube/error.go 2026-06-18 11:27:01.000000000 +0200 @@ -21,5 +21,7 @@ } func IsWebhookErr(err error) bool { - return err != nil && strings.Contains(err.Error(), "failed calling webhook") + return err != nil && + (strings.Contains(err.Error(), "Internal error occurred: failed calling webhook") || + strings.Contains(err.Error(), "Internal error occurred: conversion webhook for")) } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/plan/legacy_progress_reporter_ai_test.go new/nelm-1.25.0/pkg/plan/legacy_progress_reporter_ai_test.go --- old/nelm-1.24.3/pkg/plan/legacy_progress_reporter_ai_test.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/plan/legacy_progress_reporter_ai_test.go 2026-06-18 11:27:01.000000000 +0200 @@ -5,6 +5,7 @@ import ( "context" "testing" + "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -466,6 +467,16 @@ } } +func TestAI_ResolveNamespace_UnknownGVKFallbackIsFast(t *testing.T) { + mapper := newFakeRESTMapper() + startedAt := time.Now() + + got := resolveNamespace(gvkCRD, "", "release-ns", mapper) + + assert.Equal(t, "release-ns", got) + assert.Less(t, time.Since(startedAt), 100*time.Millisecond) +} + func TestAI_SendNonBlocking_DoesNotPanicOnClosedChannel(t *testing.T) { ch := make(chan progrep.ProgressReport, 1) close(ch) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/plan/plan_execute.go new/nelm-1.25.0/pkg/plan/plan_execute.go --- old/nelm-1.24.3/pkg/plan/plan_execute.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/plan/plan_execute.go 2026-06-18 11:27:01.000000000 +0200 @@ -164,7 +164,7 @@ return fmt.Errorf("delete resource: %w", err) } - namespace, err := getNamespace(opConfig.ResourceSpec.ResourceMeta, releaseNamespace, clientFactory) + namespace, err := getNamespace(ctx, opConfig.ResourceSpec.ResourceMeta, releaseNamespace, clientFactory) if err != nil { return fmt.Errorf("determine resource namespace: %w", err) } @@ -199,7 +199,7 @@ func execOpTrackAbsence(ctx context.Context, op *Operation, releaseNamespace string, taskStore *kdutil.Concurrent[*statestore.TaskStore], informerFactory *kdutil.Concurrent[*informer.InformerFactory], timeout time.Duration, clientFactory kube.ClientFactorier) error { opConfig := op.Config.(*OperationConfigTrackAbsence) - namespace, err := getNamespace(opConfig.ResourceMeta, releaseNamespace, clientFactory) + namespace, err := getNamespace(ctx, opConfig.ResourceMeta, releaseNamespace, clientFactory) if err != nil { return fmt.Errorf("determine resource namespace: %w", err) } @@ -226,7 +226,7 @@ func execOpTrackPresence(ctx context.Context, op *Operation, releaseNamespace string, taskStore *kdutil.Concurrent[*statestore.TaskStore], informerFactory *kdutil.Concurrent[*informer.InformerFactory], timeout time.Duration, clientFactory kube.ClientFactorier) error { opConfig := op.Config.(*OperationConfigTrackPresence) - namespace, err := getNamespace(opConfig.ResourceMeta, releaseNamespace, clientFactory) + namespace, err := getNamespace(ctx, opConfig.ResourceMeta, releaseNamespace, clientFactory) if err != nil { return fmt.Errorf("determine resource namespace: %w", err) } @@ -253,7 +253,7 @@ func execOpTrackReadiness(ctx context.Context, op *Operation, releaseNamespace string, taskStore *kdutil.Concurrent[*statestore.TaskStore], logStore *kdutil.Concurrent[*logstore.LogStore], informerFactory *kdutil.Concurrent[*informer.InformerFactory], timeout time.Duration, clientFactory kube.ClientFactorier) error { opConfig := op.Config.(*OperationConfigTrackReadiness) - namespace, err := getNamespace(opConfig.ResourceMeta, releaseNamespace, clientFactory) + namespace, err := getNamespace(ctx, opConfig.ResourceMeta, releaseNamespace, clientFactory) if err != nil { return fmt.Errorf("determine resource namespace: %w", err) } @@ -388,9 +388,22 @@ return executableOpsIDs } -func getNamespace(resMeta *spec.ResourceMeta, releaseNamespace string, clientFactory kube.ClientFactorier) (string, error) { - var namespace string - if namespaced, err := spec.Namespaced(resMeta.GroupVersionKind, clientFactory.Mapper()); err != nil { +func getNamespace(ctx context.Context, resMeta *spec.ResourceMeta, releaseNamespace string, clientFactory kube.ClientFactorier) (string, error) { + var ( + namespace string + namespaced bool + ) + + if err := clientFactory.KubeClient().ResetAndRetryOnUnknownGVR(ctx, func() error { + var err error + + namespaced, err = clientFactory.KubeClient().Namespaced(ctx, resMeta.GroupVersionKind) + if err != nil { + return fmt.Errorf("check resource scope: %w", err) + } + + return nil + }); err != nil { return "", fmt.Errorf("check if resource is namespaced: %w", err) } else if namespaced { if resMeta.Namespace != "" { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/resource/dependency.go new/nelm-1.25.0/pkg/resource/dependency.go --- old/nelm-1.24.3/pkg/resource/dependency.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/resource/dependency.go 2026-06-18 11:27:01.000000000 +0200 @@ -88,6 +88,10 @@ if deps, found := parseBindingSubjects(unstruct); found { dependencies = append(dependencies, deps...) } + case schema.GroupKind{Kind: "ScaledObject", Group: "keda.sh"}: + if dep, found := parseScaleTargetRef(unstruct); found { + dependencies = append(dependencies, dep) + } } return dependencies @@ -583,6 +587,40 @@ }, ResourceState: common.ResourceStatePresent, } + + return dep, true +} + +func parseScaleTargetRef(unstruct *unstructured.Unstructured) (dep *InternalDependency, found bool) { + name, found := nestedStringNotEmpty(unstruct.Object, "spec", "scaleTargetRef", "name") + if !found { + return nil, false + } + + kind, found := nestedStringNotEmpty(unstruct.Object, "spec", "scaleTargetRef", "kind") + if !found { + kind = "Deployment" + } + + apiVersion, found := nestedStringNotEmpty(unstruct.Object, "spec", "scaleTargetRef", "apiVersion") + if !found { + apiVersion = "apps/v1" + } + + gv, err := schema.ParseGroupVersion(apiVersion) + if err != nil { + return nil, false + } + + dep = &InternalDependency{ + ResourceMatcher: &spec.ResourceMatcher{ + Names: []string{name}, + Namespaces: []string{unstruct.GetNamespace()}, + Groups: []string{gv.Group}, + Kinds: []string{kind}, + }, + ResourceState: common.ResourceStatePresent, + } return dep, true } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/pkg/resource/resource_test.go new/nelm-1.25.0/pkg/resource/resource_test.go --- old/nelm-1.24.3/pkg/resource/resource_test.go 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/pkg/resource/resource_test.go 2026-06-18 11:27:01.000000000 +0200 @@ -713,6 +713,137 @@ } }, }, + { + expect: func(resSpec *spec.ResourceSpec) *resource.InstallableResource { + res := defaultInstallableResource(resSpec) + res.AutoInternalDependencies = []*resource.InternalDependency{ + { + ResourceMatcher: &spec.ResourceMatcher{ + Names: []string{"test-statefulset"}, + Namespaces: []string{""}, + Groups: []string{"apps"}, + Kinds: []string{"StatefulSet"}, + }, + ResourceState: common.ResourceStatePresent, + }, + } + + return res + }, + input: func() *spec.ResourceSpec { + return spec.NewResourceSpec(&unstructured.Unstructured{ + Object: map[string]interface{}{ + "apiVersion": "keda.sh/v1alpha1", + "kind": "ScaledObject", + "metadata": map[string]interface{}{ + "name": "test-scaledobject", + }, + "spec": map[string]interface{}{ + "scaleTargetRef": map[string]interface{}{ + "name": "test-statefulset", + "kind": "StatefulSet", + "apiVersion": "apps/v1", + }, + }, + }, + }, s.releaseNamespace, spec.ResourceSpecOptions{}) + }, + name: `for ScaledObject resource with auto internal dependency on scale target`, + }, + { + expect: func(resSpec *spec.ResourceSpec) *resource.InstallableResource { + res := defaultInstallableResource(resSpec) + res.AutoInternalDependencies = []*resource.InternalDependency{ + { + ResourceMatcher: &spec.ResourceMatcher{ + Names: []string{"test-deployment"}, + Namespaces: []string{""}, + Groups: []string{"apps"}, + Kinds: []string{"Deployment"}, + }, + ResourceState: common.ResourceStatePresent, + }, + } + + return res + }, + input: func() *spec.ResourceSpec { + return spec.NewResourceSpec(&unstructured.Unstructured{ + Object: map[string]interface{}{ + "apiVersion": "keda.sh/v1alpha1", + "kind": "ScaledObject", + "metadata": map[string]interface{}{ + "name": "test-scaledobject", + }, + "spec": map[string]interface{}{ + "scaleTargetRef": map[string]interface{}{ + "name": "test-deployment", + }, + }, + }, + }, s.releaseNamespace, spec.ResourceSpecOptions{}) + }, + name: `for ScaledObject resource with auto internal dependency on scale target with default kind and apiVersion`, + }, + { + expect: func(resSpec *spec.ResourceSpec) *resource.InstallableResource { + return defaultInstallableResource(resSpec) + }, + input: func() *spec.ResourceSpec { + return spec.NewResourceSpec(&unstructured.Unstructured{ + Object: map[string]interface{}{ + "apiVersion": "keda.sh/v1alpha1", + "kind": "ScaledObject", + "metadata": map[string]interface{}{ + "name": "test-scaledobject", + }, + "spec": map[string]interface{}{ + "scaleTargetRef": map[string]interface{}{ + "kind": "Deployment", + }, + }, + }, + }, s.releaseNamespace, spec.ResourceSpecOptions{}) + }, + name: `for ScaledObject resource without scaleTargetRef name and therefore without auto internal dependency`, + }, + { + expect: func(resSpec *spec.ResourceSpec) *resource.InstallableResource { + res := defaultInstallableResource(resSpec) + res.AutoInternalDependencies = []*resource.InternalDependency{ + { + ResourceMatcher: &spec.ResourceMatcher{ + Names: []string{"test-rollout"}, + Namespaces: []string{""}, + Groups: []string{"argoproj.io"}, + Kinds: []string{"Rollout"}, + }, + ResourceState: common.ResourceStatePresent, + }, + } + + return res + }, + input: func() *spec.ResourceSpec { + return spec.NewResourceSpec(&unstructured.Unstructured{ + Object: map[string]interface{}{ + "apiVersion": "keda.sh/v1alpha1", + "kind": "ScaledObject", + "metadata": map[string]interface{}{ + "name": "test-scaledobject", + }, + "spec": map[string]interface{}{ + "scaleTargetRef": map[string]interface{}{ + "name": "test-rollout", + "kind": "Rollout", + "apiVersion": "argoproj.io/v1alpha1", + }, + }, + }, + }, s.releaseNamespace, spec.ResourceSpecOptions{}) + }, + name: `for ScaledObject resource with auto internal dependency on custom resource scale target`, + }, } for _, tc := range testCases { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/resources/images/nelm-logo-black.svg new/nelm-1.25.0/resources/images/nelm-logo-black.svg --- old/nelm-1.24.3/resources/images/nelm-logo-black.svg 1970-01-01 01:00:00.000000000 +0100 +++ new/nelm-1.25.0/resources/images/nelm-logo-black.svg 2026-06-18 11:27:01.000000000 +0200 @@ -0,0 +1,7 @@ +<svg width="276" height="97" viewBox="0 0 276 97" fill="none" xmlns="http://www.w3.org/2000/svg";> +<path d="M229.176 29.0015C229.226 29.3962 229.25 29.7908 229.25 30.1855L229.472 32.4795C229.522 32.8742 229.546 33.2688 229.546 33.6635C232.26 30.0128 235.812 28.1875 240.202 28.1875C242.965 28.1875 245.185 28.7548 246.862 29.8895C248.54 31.0242 249.847 32.5288 250.784 34.4035C252.314 32.3808 254.04 30.8515 255.964 29.8155C257.938 28.7302 260.232 28.1875 262.846 28.1875C265.066 28.1875 266.966 28.5575 268.544 29.2975C270.172 30.0375 271.455 31.0735 272.392 32.4055C273.379 33.7375 274.094 35.2915 274.538 37.0675C274.982 38.7942 275.204 40.6442 275.204 42.6175V67.9995H266.768V45.7255C266.768 44.5415 266.694 43.3575 266.546 42.1735C266.398 40.9895 266.078 39.9288 265.584 38.9915C265.14 38.0048 264.474 37.2155 263.586 36.6235C262.698 35.9822 261.514 35.6615 260.034 35.6615C258.456 35.6615 257.148 36.0562 256.112 36.8455C255.126 37.5855 254.336 38.4982 253.744 39.5835C253.202 40.6688 252.832 41.9022 252.634 43.2835C252.437 44.6155 252.338 45.9475 252.338 47.2795V67.9995H243.976V45.5775C2 43.976 44.4428 243.902 43.3082 243.754 42.1735C243.656 40.9895 243.384 39.9288 242.94 38.9915C242.496 38.0542 241.83 37.2648 240.942 36.6235C240.104 35.9822 238.92 35.6615 237.39 35.6615C235.812 35.6615 234.48 36.0562 233.394 36.8455C232.358 37.6348 231.544 38.6215 230.952 39.8055C230.36 40.9402 229.966 42.1982 229.768 43.5795C229.571 44.9115 229.472 46.1448 229.472 47.2795V67.9995H221.11V29.0015H229.176Z" fill="#262429"/> +<path d="M203.575 67.9996V15.6816H212.011V67.9996H203.575Z" fill="#262429"/> +<path d="M167.9 51.3499C167.999 52.7806 168.295 54.1126 168.788 55.3459C169.281 56.5793 169.947 57.6646 170.786 58.6019C171.674 59.4899 172.735 60.2053 173.968 60.7479C175.251 61.2906 176.731 61.5619 178.408 61.5619C180.184 61.5619 181.812 61.2413 183.292 60.5999C184.772 59.9586 185.857 58.8486 186.548 57.2699H195.206C194.713 59.2433 193.899 60.9453 192.764 62.3759C191.679 63.8066 190.371 64.9906 188.842 65.9279C187.362 66.8159 185.709 67.4819 183.884 67.9259C182.108 68.3206 180.209 68.5179 178.186 68.5179C175.078 68.5179 172.34 68.0493 169.972 67.1119C167.653 66.1746 165.705 64.8179 164.126 63.0419C162.547 61.2659 161.363 59.1693 160.574 56.7519C159.834 54.2853 159.464 51.5226 159.464 48.4639C159.464 45.5039 159.883 42.8153 160.722 40.3979C161.561 37.9313 162.769 35.8099 164.348 34.0339C165.976 32.2579 167.925 30.8766 170.194 29.8899C172.463 28.8539 175.053 28.3359 177.964 28.3359C181.023 28.3359 183.662 28.8539 185.882 29.8899C188.102 30.8766 189.952 32.2333 191.432 33.9599C192.96 1 35.6866 194.096 37.7093 194.836 40.0279C195.576 42.3466 195.946 44.8626 195.946 47.5759C195.946 48.8586 195.872 50.1166 195.724 51.3499H167.9ZM187.732 44.9859C187.633 42.0259 186.696 39.7319 184.92 38.1039C183.144 36.4759 180.85 35.6619 178.038 35.6619C176.459 35.6619 175.078 35.9086 173.894 36.4019C172.71 36.8953 171.699 37.5613 170.86 38.3999C170.071 39.2386 169.429 40.2253 168.936 41.3599C168.443 42.4946 168.122 43.7033 167.974 44.9859H187.732Z" fill="#262429"/> +<path d="M116.701 67.9999V29.0019H124.767L125.211 34.4039C126.642 32.3813 128.418 30.8766 130.539 29.8899C132.71 28.8539 135.004 28.3359 137.421 28.3359C140.184 28.3359 142.503 28.8046 144.377 29.7419C146.301 30.6793 147.855 31.9619 149.039 33.5899C150.273 35.2179 151.136 37.1419 151.629 39.3619C152.172 41.5819 152.443 43.9993 152.443 46.6139V67.9999H144.007V47.8719C144.007 46.1946 143.884 44.6406 143.637 43.2099C143.44 41.7793 143.021 40.5213 142.379 39.4359C141.738 38.3013 140.825 37.4133 139.641 36.7719C138.507 36.1306 137.027 35.8099 135.201 35.8099C133.475 35.8099 131.896 36.2293 130.465 37.0679C129.084 37.9066 127.999 38.9919 127.209 40.3239C126.469 41.6559 125.927 43.1359 125.581 44.7639C125.285 46.3919 125.137 47.9459 125.137 49.4259V67.9999H116.701Z" fill="#262429"/> +<path d="M80.8278 97L80.8609 8.06955L72.7913 0H0V88.9304L8.06955 97H80.8278ZM14.6178 88.4674L40.4139 55.4616L66.21 88.4674H14.6178ZM8.56563 52.7828H31.6498L8.56563 82.3161V52.7828ZM8.56563 14.6839L31.6498 44.2172H8.56563V14.6839ZM66.2431 8.56563L40.447 41.5714L14.6178 8.56563H66.2431ZM72.2953 44.2172H49.211L72.2953 14.6839V44.2172ZM72.2953 82.3161L49.211 52.7828H72.2953V82.3161Z" fill="#004DF2"/> +</svg> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/resources/images/nelm-logo-white.svg new/nelm-1.25.0/resources/images/nelm-logo-white.svg --- old/nelm-1.24.3/resources/images/nelm-logo-white.svg 1970-01-01 01:00:00.000000000 +0100 +++ new/nelm-1.25.0/resources/images/nelm-logo-white.svg 2026-06-18 11:27:01.000000000 +0200 @@ -0,0 +1,7 @@ +<svg width="276" height="97" viewBox="0 0 276 97" fill="none" xmlns="http://www.w3.org/2000/svg";> +<path d="M229.176 29.0015C229.226 29.3962 229.25 29.7908 229.25 30.1855L229.472 32.4795C229.522 32.8742 229.546 33.2688 229.546 33.6635C232.26 30.0128 235.812 28.1875 240.202 28.1875C242.965 28.1875 245.185 28.7548 246.862 29.8895C248.54 31.0242 249.847 32.5288 250.784 34.4035C252.314 32.3808 254.04 30.8515 255.964 29.8155C257.938 28.7302 260.232 28.1875 262.846 28.1875C265.066 28.1875 266.966 28.5575 268.544 29.2975C270.172 30.0375 271.455 31.0735 272.392 32.4055C273.379 33.7375 274.094 35.2915 274.538 37.0675C274.982 38.7942 275.204 40.6442 275.204 42.6175V67.9995H266.768V45.7255C266.768 44.5415 266.694 43.3575 266.546 42.1735C266.398 40.9895 266.078 39.9288 265.584 38.9915C265.14 38.0048 264.474 37.2155 263.586 36.6235C262.698 35.9822 261.514 35.6615 260.034 35.6615C258.456 35.6615 257.148 36.0562 256.112 36.8455C255.126 37.5855 254.336 38.4982 253.744 39.5835C253.202 40.6688 252.832 41.9022 252.634 43.2835C252.437 44.6155 252.338 45.9475 252.338 47.2795V67.9995H243.976V45.5775C2 43.976 44.4428 243.902 43.3082 243.754 42.1735C243.656 40.9895 243.384 39.9288 242.94 38.9915C242.496 38.0542 241.83 37.2648 240.942 36.6235C240.104 35.9822 238.92 35.6615 237.39 35.6615C235.812 35.6615 234.48 36.0562 233.394 36.8455C232.358 37.6348 231.544 38.6215 230.952 39.8055C230.36 40.9402 229.966 42.1982 229.768 43.5795C229.571 44.9115 229.472 46.1448 229.472 47.2795V67.9995H221.11V29.0015H229.176Z" fill="white"/> +<path d="M203.575 67.9996V15.6816H212.011V67.9996H203.575Z" fill="white"/> +<path d="M167.9 51.3499C167.999 52.7806 168.295 54.1126 168.788 55.3459C169.281 56.5793 169.947 57.6646 170.786 58.6019C171.674 59.4899 172.735 60.2053 173.968 60.7479C175.251 61.2906 176.731 61.5619 178.408 61.5619C180.184 61.5619 181.812 61.2413 183.292 60.5999C184.772 59.9586 185.857 58.8486 186.548 57.2699H195.206C194.713 59.2433 193.899 60.9453 192.764 62.3759C191.679 63.8066 190.371 64.9906 188.842 65.9279C187.362 66.8159 185.709 67.4819 183.884 67.9259C182.108 68.3206 180.209 68.5179 178.186 68.5179C175.078 68.5179 172.34 68.0493 169.972 67.1119C167.653 66.1746 165.705 64.8179 164.126 63.0419C162.547 61.2659 161.363 59.1693 160.574 56.7519C159.834 54.2853 159.464 51.5226 159.464 48.4639C159.464 45.5039 159.883 42.8153 160.722 40.3979C161.561 37.9313 162.769 35.8099 164.348 34.0339C165.976 32.2579 167.925 30.8766 170.194 29.8899C172.463 28.8539 175.053 28.3359 177.964 28.3359C181.023 28.3359 183.662 28.8539 185.882 29.8899C188.102 30.8766 189.952 32.2333 191.432 33.9599C192.96 1 35.6866 194.096 37.7093 194.836 40.0279C195.576 42.3466 195.946 44.8626 195.946 47.5759C195.946 48.8586 195.872 50.1166 195.724 51.3499H167.9ZM187.732 44.9859C187.633 42.0259 186.696 39.7319 184.92 38.1039C183.144 36.4759 180.85 35.6619 178.038 35.6619C176.459 35.6619 175.078 35.9086 173.894 36.4019C172.71 36.8953 171.699 37.5613 170.86 38.3999C170.071 39.2386 169.429 40.2253 168.936 41.3599C168.443 42.4946 168.122 43.7033 167.974 44.9859H187.732Z" fill="white"/> +<path d="M116.701 67.9999V29.0019H124.767L125.211 34.4039C126.642 32.3813 128.418 30.8766 130.539 29.8899C132.71 28.8539 135.004 28.3359 137.421 28.3359C140.184 28.3359 142.503 28.8046 144.377 29.7419C146.301 30.6793 147.855 31.9619 149.039 33.5899C150.273 35.2179 151.136 37.1419 151.629 39.3619C152.172 41.5819 152.443 43.9993 152.443 46.6139V67.9999H144.007V47.8719C144.007 46.1946 143.884 44.6406 143.637 43.2099C143.44 41.7793 143.021 40.5213 142.379 39.4359C141.738 38.3013 140.825 37.4133 139.641 36.7719C138.507 36.1306 137.027 35.8099 135.201 35.8099C133.475 35.8099 131.896 36.2293 130.465 37.0679C129.084 37.9066 127.999 38.9919 127.209 40.3239C126.469 41.6559 125.927 43.1359 125.581 44.7639C125.285 46.3919 125.137 47.9459 125.137 49.4259V67.9999H116.701Z" fill="white"/> +<path d="M80.8278 97L80.8609 8.06955L72.7913 0H0V88.9304L8.06955 97H80.8278ZM14.6178 88.4674L40.4139 55.4616L66.21 88.4674H14.6178ZM8.56563 52.7828H31.6498L8.56563 82.3161V52.7828ZM8.56563 14.6839L31.6498 44.2172H8.56563V14.6839ZM66.2431 8.56563L40.447 41.5714L14.6178 8.56563H66.2431ZM72.2953 44.2172H49.211L72.2953 14.6839V44.2172ZM72.2953 82.3161L49.211 52.7828H72.2953V82.3161Z" fill="white"/> +</svg> Binary files old/nelm-1.24.3/resources/images/nelm-logo.png and new/nelm-1.25.0/resources/images/nelm-logo.png differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nelm-1.24.3/trdl_channels.yaml new/nelm-1.25.0/trdl_channels.yaml --- old/nelm-1.24.3/trdl_channels.yaml 2026-06-08 18:00:18.000000000 +0200 +++ new/nelm-1.25.0/trdl_channels.yaml 2026-06-18 11:27:01.000000000 +0200 @@ -2,12 +2,12 @@ - name: "1" channels: - name: alpha - version: 1.24.1 + version: 1.24.3 - name: beta - version: 1.24.0 + version: 1.24.1 - name: ea - version: 1.23.2 + version: 1.24.0 - name: stable - version: 1.22.0 + version: 1.23.2 - name: rock-solid version: 1.22.0 ++++++ nelm.obsinfo ++++++ --- /var/tmp/diff_new_pack.oRxvgs/_old 2026-07-17 01:45:06.032525439 +0200 +++ /var/tmp/diff_new_pack.oRxvgs/_new 2026-07-17 01:45:06.104527869 +0200 @@ -1,5 +1,5 @@ name: nelm -version: 1.24.3 -mtime: 1780934418 -commit: c0c3c7ab1457fbf634acee9b2d2a29b9cdc101d4 +version: 1.25.0 +mtime: 1781774821 +commit: 6c9bf7ee20e927cc031abedda4dbe1949e5f5af8 ++++++ vendor.tar.gz ++++++ /work/SRC/openSUSE:Factory/nelm/vendor.tar.gz /work/SRC/openSUSE:Factory/.nelm.new.24530/vendor.tar.gz differ: char 90, line 2
