actions: refactor to move template and manifest rendering to a helper by ykaliuta · Pull Request #1563 · opendatahub-io/opendatahub-operator

ykaliuta · 2025-01-24T15:57:14Z

Jira: https://issues.redhat.com/browse/RHOAIENG-15921

The PR adds two abstractions

generic caching functionality:

hash the key
if the hash is the same as the stored one, return stored resource
otherwise render the resource
store the key and the resource
return the resource

The hashing key function and resource type are parameters.

resource rendering, which uses the first abstraction to cache rendered manifests and performs accounting.

Then two rendering actions, kustomize and templates, rewritten to use resource rendering abstraction.

See details in the commit messages.

Signed-off-by: Yauheni Kaliuta ykaliuta@redhat.com

Description

How Has This Been Tested?

Screenshot or short clip

Merge criteria

You have read the contributors guide.
Commit messages are meaningful - have a clear and concise summary and detailed explanation of what was changed and why.
Pull Request contains a description of the solution, a link to the JIRA issue, and to any dependent or related Pull Request.
Testing instructions have been added in the PR body (for PRs involving changes that are not immediately obvious).
The developer has manually tested the changes and verified that the changes work

openshift-ci · 2025-01-24T15:57:19Z

Skipping CI for Draft Pull Request.
If you want CI signal for your change, please convert it to an actual PR.
You can still manually trigger a test run with /test all

ykaliuta · 2025-01-24T15:58:00Z

/cc @lburgazzoli

github-actions · 2025-01-24T15:58:20Z

This PR can't be merged just yet 😢

Please run make generate manifests api-docs and commit the changes.

For more info: https://github.com/opendatahub-io/opendatahub-operator/actions/runs/12953054333

codecov · 2025-01-24T16:00:46Z

Codecov Report

Attention: Patch coverage is 97.59036% with 2 lines in your changes missing coverage. Please review.

Project coverage is 20.50%. Comparing base (39da621) to head (fd89af3).
Report is 5 commits behind head on main.

Files with missing lines	Patch %	Lines
...ontroller/actions/resourcecacher/resourcecacher.go	93.75%	2 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main    #1563      +/-   ##
==========================================
+ Coverage   20.33%   20.50%   +0.16%     
==========================================
  Files         163      165       +2     
  Lines       11164    11199      +35     
==========================================
+ Hits         2270     2296      +26     
- Misses       8657     8672      +15     
+ Partials      237      231       -6

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

ugiordan · 2025-01-27T13:14:03Z

+	"github.com/opendatahub-io/opendatahub-operator/v2/pkg/controller/types"
+)
+
+type Renderer interface {


Suggested change

type Renderer interface {

// Renderer defines an interface for rendering resources.

type Renderer interface {

ugiordan · 2025-01-27T13:14:18Z

+	Render(r Renderer, rr *types.ReconciliationRequest) (any, bool, error)
+}
+
+type CachingKeyFn func(rr *types.ReconciliationRequest) ([]byte, error)


Suggested change

type CachingKeyFn func(rr *types.ReconciliationRequest) ([]byte, error)

// CachingKeyFn is a function type used to generate a caching key based on the reconciliation request.

type CachingKeyFn func(rr *types.ReconciliationRequest) ([]byte, error)

ugiordan · 2025-01-27T13:14:38Z

+
+type CachingKeyFn func(rr *types.ReconciliationRequest) ([]byte, error)
+
+type Cacher struct {


Suggested change

type Cacher struct {

// Cacher provides caching capabilities for rendered resources.

type Cacher struct {

ugiordan · 2025-01-27T13:15:45Z

+
+type CacherOpts func(*Cacher)
+
+func (s *Cacher) SetKey(key CachingKeyFn) {


Suggested change

func (s *Cacher) SetKey(key CachingKeyFn) {

// SetKey sets the caching key function for the Cacher.

func (s *Cacher) SetKey(key CachingKeyFn) {

ugiordan · 2025-01-27T14:18:56Z

+	resList := resources.UnstructuredList(resUnstructured)
+
+	if acted {
+		controllerName := strings.ToLower(rr.Instance.GetObjectKind().GroupVersionKind().Kind)


Suggested change

controllerName := strings.ToLower(rr.Instance.GetObjectKind().GroupVersionKind().Kind)

// Track the number of rendered resources for monitoring

controllerName := strings.ToLower(rr.Instance.GetObjectKind().GroupVersionKind().Kind)

ugiordan · 2025-01-27T14:19:14Z

+		controllerName := strings.ToLower(rr.Instance.GetObjectKind().GroupVersionKind().Kind)
+		render.RenderedResourcesTotal.WithLabelValues(controllerName, s.Name()).Add(float64(len(resList)))
+
+		rr.Generated = true


Suggested change

rr.Generated = true

// Mark the reconciliation request as having generated resources

rr.Generated = true

ugiordan · 2025-01-27T14:20:00Z

+	// deep copy object so changes done in the pipelines won't
+	// alter them


Suggested change

// deep copy object so changes done in the pipelines won't

// alter them

// Append cloned resources to the reconciliation request,

// ensuring a deep copy so changes in the pipeline don't alter the original objects.

ugiordan · 2025-01-27T14:23:19Z

+	return res, true, nil
 }

 func (a *Action) render(rr *types.ReconciliationRequest) ([]unstructured.Unstructured, error) {


Suggested change

func (a *Action) render(rr *types.ReconciliationRequest) ([]unstructured.Unstructured, error) {

// render handles the rendering of resources using the Kustomize engine.

func (a *Action) render(rr *types.ReconciliationRequest) ([]unstructured.Unstructured, error) {

ugiordan · 2025-01-27T14:24:11Z

+}

-		rr.Generated = true
+func (a *Action) Render(_ cacher.Renderer, rr *types.ReconciliationRequest) (any, bool, error) {


Suggested change

func (a *Action) Render(_ cacher.Renderer, rr *types.ReconciliationRequest) (any, bool, error) {

// Render is a wrapper for rendering the reconciliation request using Kustomize.

// It returns the rendered resources and indicates if any resources were acted upon.

func (a *Action) Render(_ cacher.Renderer, rr *types.ReconciliationRequest) (any, bool, error) {

ugiordan · 2025-01-27T14:25:25Z

@ykaliuta, I believe the same caching abstraction can be applied to the action_render_templates as well.

…flux/component-updates/odh-kueue-controller-v2-17 chore(deps): update odh-kueue-controller-v2-17 to 3f5e5f0

ykaliuta · 2025-01-30T05:05:56Z

/test all

ykaliuta · 2025-01-30T08:43:29Z

/test opendatahub-operator-e2e

ugiordan · 2025-02-06T07:37:54Z

/retest

ugiordan · 2025-02-06T07:43:20Z

@ugiordan I added some comments to the update, but I usually do not add obvious comments like /* increment i */ i++. If you think, something unclear and should be commented, I'll add.

Makes sense! I tend to comment everything for readability, but sometimes it’s a bit too much! 😆

ykaliuta · 2025-02-06T18:42:29Z

/unhold

ykaliuta · 2025-02-06T22:02:18Z

/test opendatahub-operator-e2e

ykaliuta · 2025-02-10T10:18:40Z

/test opendatahub-operator-e2e

ykaliuta · 2025-02-10T17:53:36Z

/test all

ykaliuta · 2025-02-11T08:32:47Z

/retest

ykaliuta · 2025-02-11T13:55:03Z

/test all

ykaliuta · 2025-02-12T10:01:01Z

/test all

The caching code for all caching Actions is pretty much the same 1) hash the key 2) if the hash is the same as the stored one, return stored resource 3) otherwise render the resource 4) store the key and the resource 5) return the resource Abstract this logic into Cacher[T] generic type, where T is the type of the resource, which is supposed to be included as a composition in on the higher levels. The core engine is implemented as Render method which accepts actual renderer (function) and return boolean value in addition to the resources indicating if it performed rendering. It supposed to be used in resource rendering actions for accounting. The renderer should return (error, T). Put renderer as the last argument to make more convenient to call with a closure. Copy CachingKeyFn type. In future it can be extented to accept context for possible debug logging. Define contract, CachingKeyFn should not return empty hash. (!!!) The code originally is taken pretty much from the existing kustomize rendering Action. But taking into account the contract, refactor the code to avoid comparation of the result (and nil assignments) since with generics to work with both nilable (maps, arrays, etc) and non-nilable (ints, strings) types it requires some extra handling of Zero values. Zero values are still required for return values in error case, so implement Zero[T] generic function. With the assumption make "empty key" a error condition, it removes need of extra comparation. Move actual rendering and cache update into separate function, it makes main Render function more clear without extra indentation. Possible usage supposed to be ``` type Action struct { cacher.Cacher[resources.UnstructuredList] // action data } type ActionOpts func(*Action) func WithCache() ActionOpts { return func(a *Action) { a.Cacher.SetKeyFn(types.Hash) // or own } } func (s *Action) run(ctx context.Context, rr *types.ReconciliationRequest) error { //... res, acted, err := a.Cacher.Render(ctx, rr, s.render) if acted { /* may be do something */ } // use resources } func (s *Action) render(ctx context.Context, rr *types.ReconciliationRequest) (resources.UnstructuredList, error) { result := make(resources.UnstructuredList) // make some resources return result, nil } func NewAction(opts ...ActionOpts) actions.Fn { for _, opt := range opts { opt(&action) } return action.run } ``` with reconciler creation ``` func (s *componentHandler) NewComponentReconciler(ctx context.Context, mgr ctrl.Manager) error { _, err := reconciler.ReconcilerFor( mgr, &componentApi.Type{}, ). // ... WithAction(foobar.NewAction( foobar.WithCache(), )) } ``` Pay attention to signature of render() and call to Cacher.Render() from run(). Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com>

Make an abstract wrapper on the raw cacher.Cacher[T] to work on actions whose Renderer produces resources (resources.UnstructuredList) to be recorded into ReconciliationRequest.Manifests and later deployed (deleted) to the cluster. Performs common tasks: - invalidate caching if devflags enabled; - account resources if they were generated (and skip cached ones); - add resources to the ReconciliationRequest. Created constructor which accepts mandatory name. Since it is used in prometheus, it's recommended to make it lower case. At this moment this is the only part which interested in the origin of resources (cached or not) and it's supposed to be used in actions whose final goal is to add resources to the request (which is done by this helper), so change signature of its Render() method (comparing to cacher.Cacher) to return only error. The code is basically copied from manifest/template rendering actions run() method. Usage (changed run() comparing to cacher.Cacher): ``` type Action struct { resourcecacher.ResourceCacher // action data } type ActionOpts func(*Action) func WithCache() ActionOpts { return func(a *Action) { a.ResourceCacher.SetKeyFn(types.Hash) // or own } } func (s *Action) run(ctx context.Context, rr *types.ReconciliationRequest) error { //... return a.ResourceCacher.Render(ctx, rr, s.render) } func (s *Action) render(ctx context.Context, rr *types.ReconciliationRequest) (resources.UnstructuredList, error) { result := make(resources.UnstructuredList) // make some resources return result, nil } func NewAction(opts ...ActionOpts) actions.Fn { action := Action{ ResourceCacher: resourcecacher.NewResourceCacher("mycoolaction"), } for _, opt := range opts { opt(&action) } return action.run } ``` Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com>

All the run() functionality now implemented by the ResourceCacher, so just call its Render() in run(). Amend WithCache() as required by ResourceCacher to set its CachingKeyFn and remove CachingKeyFn initialization from NewAction. Change render() signature to return resources.UnstructuredList RendererEngine is used as a field initializer now, so no need to export, rename to rendererEngine. Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com>

The same changes as to manifests rendering. Just keep `data` field initialization in NewAction, used in render(). Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com>

openshift-ci · 2025-02-13T09:06:55Z

[APPROVALNOTIFIER] This PR is APPROVED

This pull-request has been approved by: lburgazzoli, zdtsw

The full list of commands accepted by this bot can be found here.

The pull request process is described here

Details

Needs approval from an approver in each of these files:

~~OWNERS~~ [lburgazzoli,zdtsw]

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment

…opendatahub-io#1563) * actions: abstract caching functionality into cacher The caching code for all caching Actions is pretty much the same 1) hash the key 2) if the hash is the same as the stored one, return stored resource 3) otherwise render the resource 4) store the key and the resource 5) return the resource Abstract this logic into Cacher[T] generic type, where T is the type of the resource, which is supposed to be included as a composition in on the higher levels. The core engine is implemented as Render method which accepts actual renderer (function) and return boolean value in addition to the resources indicating if it performed rendering. It supposed to be used in resource rendering actions for accounting. The renderer should return (error, T). Put renderer as the last argument to make more convenient to call with a closure. Copy CachingKeyFn type. In future it can be extented to accept context for possible debug logging. Define contract, CachingKeyFn should not return empty hash. (!!!) The code originally is taken pretty much from the existing kustomize rendering Action. But taking into account the contract, refactor the code to avoid comparation of the result (and nil assignments) since with generics to work with both nilable (maps, arrays, etc) and non-nilable (ints, strings) types it requires some extra handling of Zero values. Zero values are still required for return values in error case, so implement Zero[T] generic function. With the assumption make "empty key" a error condition, it removes need of extra comparation. Move actual rendering and cache update into separate function, it makes main Render function more clear without extra indentation. Possible usage supposed to be ``` type Action struct { cacher.Cacher[resources.UnstructuredList] // action data } type ActionOpts func(*Action) func WithCache() ActionOpts { return func(a *Action) { a.Cacher.SetKeyFn(types.Hash) // or own } } func (s *Action) run(ctx context.Context, rr *types.ReconciliationRequest) error { //... res, acted, err := a.Cacher.Render(ctx, rr, s.render) if acted { /* may be do something */ } // use resources } func (s *Action) render(ctx context.Context, rr *types.ReconciliationRequest) (resources.UnstructuredList, error) { result := make(resources.UnstructuredList) // make some resources return result, nil } func NewAction(opts ...ActionOpts) actions.Fn { for _, opt := range opts { opt(&action) } return action.run } ``` with reconciler creation ``` func (s *componentHandler) NewComponentReconciler(ctx context.Context, mgr ctrl.Manager) error { _, err := reconciler.ReconcilerFor( mgr, &componentApi.Type{}, ). // ... WithAction(foobar.NewAction( foobar.WithCache(), )) } ``` Pay attention to signature of render() and call to Cacher.Render() from run(). Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> * actions: abstract resource caching into resourcecacher Make an abstract wrapper on the raw cacher.Cacher[T] to work on actions whose Renderer produces resources (resources.UnstructuredList) to be recorded into ReconciliationRequest.Manifests and later deployed (deleted) to the cluster. Performs common tasks: - invalidate caching if devflags enabled; - account resources if they were generated (and skip cached ones); - add resources to the ReconciliationRequest. Created constructor which accepts mandatory name. Since it is used in prometheus, it's recommended to make it lower case. At this moment this is the only part which interested in the origin of resources (cached or not) and it's supposed to be used in actions whose final goal is to add resources to the request (which is done by this helper), so change signature of its Render() method (comparing to cacher.Cacher) to return only error. The code is basically copied from manifest/template rendering actions run() method. Usage (changed run() comparing to cacher.Cacher): ``` type Action struct { resourcecacher.ResourceCacher // action data } type ActionOpts func(*Action) func WithCache() ActionOpts { return func(a *Action) { a.ResourceCacher.SetKeyFn(types.Hash) // or own } } func (s *Action) run(ctx context.Context, rr *types.ReconciliationRequest) error { //... return a.ResourceCacher.Render(ctx, rr, s.render) } func (s *Action) render(ctx context.Context, rr *types.ReconciliationRequest) (resources.UnstructuredList, error) { result := make(resources.UnstructuredList) // make some resources return result, nil } func NewAction(opts ...ActionOpts) actions.Fn { action := Action{ ResourceCacher: resourcecacher.NewResourceCacher("mycoolaction"), } for _, opt := range opts { opt(&action) } return action.run } ``` Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> * actions: use resourcecacher for manifests rendering All the run() functionality now implemented by the ResourceCacher, so just call its Render() in run(). Amend WithCache() as required by ResourceCacher to set its CachingKeyFn and remove CachingKeyFn initialization from NewAction. Change render() signature to return resources.UnstructuredList RendererEngine is used as a field initializer now, so no need to export, rename to rendererEngine. Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> * actions: use resourcecacher for template rendering The same changes as to manifests rendering. Just keep `data` field initialization in NewAction, used in render(). Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> --------- Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com>

…1666) * Improve gc service/action (#1656) * Improve gc service/action * Remove useless lock * Fix typos * Improve error handling * update: remove ondelete not used for cleanup steps (#1621) * update: remove ondelete not used for cleanup steps - we do not unpatch auth in smcp since we do not support unmanaged case --------- Signed-off-by: Wen Zhou <wenzhou@redhat.com> * actions: refactor to move template and manifest rendering to a helper (#1563) * actions: abstract caching functionality into cacher The caching code for all caching Actions is pretty much the same 1) hash the key 2) if the hash is the same as the stored one, return stored resource 3) otherwise render the resource 4) store the key and the resource 5) return the resource Abstract this logic into Cacher[T] generic type, where T is the type of the resource, which is supposed to be included as a composition in on the higher levels. The core engine is implemented as Render method which accepts actual renderer (function) and return boolean value in addition to the resources indicating if it performed rendering. It supposed to be used in resource rendering actions for accounting. The renderer should return (error, T). Put renderer as the last argument to make more convenient to call with a closure. Copy CachingKeyFn type. In future it can be extented to accept context for possible debug logging. Define contract, CachingKeyFn should not return empty hash. (!!!) The code originally is taken pretty much from the existing kustomize rendering Action. But taking into account the contract, refactor the code to avoid comparation of the result (and nil assignments) since with generics to work with both nilable (maps, arrays, etc) and non-nilable (ints, strings) types it requires some extra handling of Zero values. Zero values are still required for return values in error case, so implement Zero[T] generic function. With the assumption make "empty key" a error condition, it removes need of extra comparation. Move actual rendering and cache update into separate function, it makes main Render function more clear without extra indentation. Possible usage supposed to be ``` type Action struct { cacher.Cacher[resources.UnstructuredList] // action data } type ActionOpts func(*Action) func WithCache() ActionOpts { return func(a *Action) { a.Cacher.SetKeyFn(types.Hash) // or own } } func (s *Action) run(ctx context.Context, rr *types.ReconciliationRequest) error { //... res, acted, err := a.Cacher.Render(ctx, rr, s.render) if acted { /* may be do something */ } // use resources } func (s *Action) render(ctx context.Context, rr *types.ReconciliationRequest) (resources.UnstructuredList, error) { result := make(resources.UnstructuredList) // make some resources return result, nil } func NewAction(opts ...ActionOpts) actions.Fn { for _, opt := range opts { opt(&action) } return action.run } ``` with reconciler creation ``` func (s *componentHandler) NewComponentReconciler(ctx context.Context, mgr ctrl.Manager) error { _, err := reconciler.ReconcilerFor( mgr, &componentApi.Type{}, ). // ... WithAction(foobar.NewAction( foobar.WithCache(), )) } ``` Pay attention to signature of render() and call to Cacher.Render() from run(). Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> * actions: abstract resource caching into resourcecacher Make an abstract wrapper on the raw cacher.Cacher[T] to work on actions whose Renderer produces resources (resources.UnstructuredList) to be recorded into ReconciliationRequest.Manifests and later deployed (deleted) to the cluster. Performs common tasks: - invalidate caching if devflags enabled; - account resources if they were generated (and skip cached ones); - add resources to the ReconciliationRequest. Created constructor which accepts mandatory name. Since it is used in prometheus, it's recommended to make it lower case. At this moment this is the only part which interested in the origin of resources (cached or not) and it's supposed to be used in actions whose final goal is to add resources to the request (which is done by this helper), so change signature of its Render() method (comparing to cacher.Cacher) to return only error. The code is basically copied from manifest/template rendering actions run() method. Usage (changed run() comparing to cacher.Cacher): ``` type Action struct { resourcecacher.ResourceCacher // action data } type ActionOpts func(*Action) func WithCache() ActionOpts { return func(a *Action) { a.ResourceCacher.SetKeyFn(types.Hash) // or own } } func (s *Action) run(ctx context.Context, rr *types.ReconciliationRequest) error { //... return a.ResourceCacher.Render(ctx, rr, s.render) } func (s *Action) render(ctx context.Context, rr *types.ReconciliationRequest) (resources.UnstructuredList, error) { result := make(resources.UnstructuredList) // make some resources return result, nil } func NewAction(opts ...ActionOpts) actions.Fn { action := Action{ ResourceCacher: resourcecacher.NewResourceCacher("mycoolaction"), } for _, opt := range opts { opt(&action) } return action.run } ``` Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> * actions: use resourcecacher for manifests rendering All the run() functionality now implemented by the ResourceCacher, so just call its Render() in run(). Amend WithCache() as required by ResourceCacher to set its CachingKeyFn and remove CachingKeyFn initialization from NewAction. Change render() signature to return resources.UnstructuredList RendererEngine is used as a field initializer now, so no need to export, rename to rendererEngine. Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> * actions: use resourcecacher for template rendering The same changes as to manifests rendering. Just keep `data` field initialization in NewAction, used in render(). Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> --------- Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> * chore: move Release strcuts from pkg/cluster to apis/common (#1580) Structs that are part of the public APIs should be in the apis packages for consistency and to avoid cyclic import issues (cherry picked from commit 1760dee) * feat(test): support for Succeed and MatchError in testf framework (#1628) (cherry picked from commit a774767) * chore(kserve): wrap error returned by FromUnstructured (#1646) (cherry picked from commit 9402f6a) --------- Signed-off-by: Wen Zhou <wenzhou@redhat.com> Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com> Co-authored-by: Luca Burgazzoli <lburgazzoli@users.noreply.github.com> Co-authored-by: Yauheni Kaliuta <ykaliuta@redhat.com>

openshift-ci Bot added the do-not-merge/work-in-progress label Jan 24, 2025

ykaliuta mentioned this pull request Jan 24, 2025

Map component versions to RHOAI status for better visibility #1559

Merged

5 tasks

openshift-ci Bot requested a review from lburgazzoli January 24, 2025 15:58

ugiordan requested changes Jan 27, 2025

View reviewed changes

openshift-ci Bot assigned ugiordan Jan 27, 2025

ykaliuta force-pushed the caching-action branch from f316a77 to c4f5a74 Compare January 29, 2025 21:26

ykaliuta changed the title ~~RFC: Caching action~~ actions: refactor to move template and manifest rendering in a helper Jan 29, 2025

ykaliuta force-pushed the caching-action branch 2 times, most recently from b3b34ca to e9e2fed Compare January 29, 2025 21:37

ykaliuta marked this pull request as ready for review January 29, 2025 21:38

openshift-ci Bot removed the do-not-merge/work-in-progress label Jan 29, 2025

openshift-ci Bot requested review from CFSNM and asanzgom January 29, 2025 21:38

ykaliuta marked this pull request as draft January 29, 2025 21:42

openshift-ci Bot added the do-not-merge/work-in-progress label Jan 29, 2025

ykaliuta force-pushed the caching-action branch 2 times, most recently from 2559e06 to 34bf0d9 Compare January 30, 2025 05:05

ykaliuta marked this pull request as ready for review January 30, 2025 05:12

openshift-ci Bot removed the do-not-merge/work-in-progress label Jan 30, 2025

openshift-ci Bot requested review from AjayJagan and lphiri January 30, 2025 05:12

ykaliuta force-pushed the caching-action branch from 34bf0d9 to b0b8909 Compare January 30, 2025 06:38

ykaliuta force-pushed the caching-action branch from a139306 to 2f5c0cb Compare February 6, 2025 18:33

ykaliuta changed the title ~~actions: refactor to move template and manifest rendering in a helper~~ actions: refactor to move template and manifest rendering to a helper Feb 6, 2025

lburgazzoli approved these changes Feb 10, 2025

View reviewed changes

openshift-ci Bot assigned lburgazzoli Feb 10, 2025

openshift-ci Bot added lgtm approved labels Feb 10, 2025

Yauheni Kaliuta added 4 commits February 12, 2025 17:39

actions: use resourcecacher for template rendering

fd89af3

The same changes as to manifests rendering. Just keep `data` field initialization in NewAction, used in render(). Signed-off-by: Yauheni Kaliuta <ykaliuta@redhat.com>

ykaliuta force-pushed the caching-action branch from 2f5c0cb to fd89af3 Compare February 13, 2025 01:07

openshift-ci Bot removed the lgtm label Feb 13, 2025

zdtsw approved these changes Feb 13, 2025

View reviewed changes

openshift-ci Bot assigned zdtsw Feb 13, 2025

openshift-ci Bot added the lgtm label Feb 13, 2025

lburgazzoli approved these changes Feb 13, 2025

View reviewed changes

openshift-merge-bot Bot merged commit 0e50224 into opendatahub-io:main Feb 13, 2025

zdtsw mentioned this pull request Feb 14, 2025

[Sync] changes from ODH to rhoai- improve + cleanup code + refactor #1666

Merged

5 tasks

	type Renderer interface {
	// Renderer defines an interface for rendering resources.
	type Renderer interface {

	type CachingKeyFn func(rr *types.ReconciliationRequest) ([]byte, error)
	// CachingKeyFn is a function type used to generate a caching key based on the reconciliation request.
	type CachingKeyFn func(rr *types.ReconciliationRequest) ([]byte, error)


		type CachingKeyFn func(rr *types.ReconciliationRequest) ([]byte, error)

		type Cacher struct {

	type Cacher struct {
	// Cacher provides caching capabilities for rendered resources.
	type Cacher struct {


		type CacherOpts func(*Cacher)

		func (s *Cacher) SetKey(key CachingKeyFn) {

	func (s *Cacher) SetKey(key CachingKeyFn) {
	// SetKey sets the caching key function for the Cacher.
	func (s *Cacher) SetKey(key CachingKeyFn) {

	controllerName := strings.ToLower(rr.Instance.GetObjectKind().GroupVersionKind().Kind)
	// Track the number of rendered resources for monitoring
	controllerName := strings.ToLower(rr.Instance.GetObjectKind().GroupVersionKind().Kind)

	rr.Generated = true
	// Mark the reconciliation request as having generated resources
	rr.Generated = true

		// deep copy object so changes done in the pipelines won't
		// alter them

	func (a Action) render(rr types.ReconciliationRequest) ([]unstructured.Unstructured, error) {
	// render handles the rendering of resources using the Kustomize engine.
	func (a Action) render(rr types.ReconciliationRequest) ([]unstructured.Unstructured, error) {

Conversation

ykaliuta commented Jan 24, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Description

How Has This Been Tested?

Screenshot or short clip

Merge criteria

Uh oh!

openshift-ci Bot commented Jan 24, 2025

Uh oh!

ykaliuta commented Jan 24, 2025

Uh oh!

github-actions Bot commented Jan 24, 2025

This PR can't be merged just yet 😢

Uh oh!

codecov Bot commented Jan 24, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ugiordan commented Jan 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

ykaliuta commented Jan 30, 2025

Uh oh!

ykaliuta commented Jan 30, 2025

Uh oh!

ugiordan commented Feb 6, 2025

Uh oh!

ugiordan commented Feb 6, 2025

Uh oh!

ykaliuta commented Feb 6, 2025

Uh oh!

ykaliuta commented Feb 6, 2025

Uh oh!

ykaliuta commented Feb 10, 2025

Uh oh!

ykaliuta commented Feb 10, 2025

Uh oh!

ykaliuta commented Feb 11, 2025

Uh oh!

ykaliuta commented Feb 11, 2025

Uh oh!

ykaliuta commented Feb 12, 2025

Uh oh!

openshift-ci Bot commented Feb 13, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

ykaliuta commented Jan 24, 2025 •

edited

Loading

codecov Bot commented Jan 24, 2025 •

edited

Loading

ugiordan commented Jan 27, 2025 •

edited

Loading