Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

feat(STONEINTG-488): react to application component deletion #273

Merged
merged 1 commit into from
Oct 2, 2023
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions config/rbac/role.yaml
Original file line number Diff line number Diff line change
Expand Up @@ -47,6 +47,12 @@ rules:
- patch
- update
- watch
- apiGroups:
- appstudio.redhat.com
resources:
- components/finalizers
14rcole marked this conversation as resolved.
Show resolved Hide resolved
verbs:
- update
- apiGroups:
- appstudio.redhat.com
resources:
Expand Down
132 changes: 132 additions & 0 deletions controllers/component/component_adapter.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,132 @@
/*
Copyright 2023.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package component

import (
"context"

applicationapiv1alpha1 "github.com/redhat-appstudio/application-api/api/v1alpha1"
"github.com/redhat-appstudio/integration-service/gitops"
h "github.com/redhat-appstudio/integration-service/helpers"
"github.com/redhat-appstudio/integration-service/loader"
"github.com/redhat-appstudio/integration-service/metrics"
"github.com/redhat-appstudio/operator-toolkit/controller"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
)

// Adapter holds the objects needed to reconcile a integration PipelineRun.
type Adapter struct {
component *applicationapiv1alpha1.Component
application *applicationapiv1alpha1.Application
loader loader.ObjectLoader
logger h.IntegrationLogger
client client.Client
context context.Context
}

// NewAdapter creates and returns an Adapter instance.
func NewAdapter(component *applicationapiv1alpha1.Component, application *applicationapiv1alpha1.Application, logger h.IntegrationLogger, loader loader.ObjectLoader, client client.Client,
context context.Context) *Adapter {
return &Adapter{
component: component,
application: application,
logger: logger,
loader: loader,
client: client,
context: context,
}
}

// EnsureComponentIsCleanedUp is an operation that will ensure components
// marked for deletion have a snapshot created without said component
func (a *Adapter) EnsureComponentIsCleanedUp() (controller.OperationResult, error) {
if !hasComponentBeenDeleted(a.component) {
return controller.ContinueProcessing()
}

applicationComponents, err := a.loader.GetAllApplicationComponents(a.client, a.context, a.application)
if err != nil {
a.logger.Error(err, "Failed to load application components")
return controller.RequeueWithError(err)
Josh-Everett marked this conversation as resolved.
Show resolved Hide resolved
}

var snapshotComponents []applicationapiv1alpha1.SnapshotComponent

for _, individualComponent := range *applicationComponents {
component := individualComponent
if a.component.Name != component.Name {
containerImage := component.Spec.ContainerImage
componentSource := gitops.GetComponentSourceFromComponent(&component)
snapshotComponents = append(snapshotComponents, applicationapiv1alpha1.SnapshotComponent{
Name: component.Name,
ContainerImage: containerImage,
Source: *componentSource,
})
}
}

if len(snapshotComponents) == 0 {
a.logger.Info("Application has no available snapshot components for snapshot creation")
return controller.StopProcessing()
}

_, err = a.createUpdatedSnapshot(&snapshotComponents)
if err != nil {
a.logger.Error(err, "Failed to create new snapshot after component deletion")
return controller.RequeueWithError(err)
MartinBasti marked this conversation as resolved.
Show resolved Hide resolved
}

return controller.ContinueProcessing()
}

// createUpdatedSnapshot prepares a Snapshot for a given application and component(s).
// In case the Snapshot can't be created, an error will be returned.
func (a *Adapter) createUpdatedSnapshot(snapshotComponents *[]applicationapiv1alpha1.SnapshotComponent) (*applicationapiv1alpha1.Snapshot, error) {
snapshot := gitops.NewSnapshot(a.application, snapshotComponents)
if snapshot.Labels == nil {
snapshot.Labels = map[string]string{}
}
snapshotType := gitops.SnapshotCompositeType
if len(*snapshotComponents) == 1 {
snapshotType = gitops.SnapshotComponentType
}
snapshot.Labels[gitops.SnapshotTypeLabel] = snapshotType

err := ctrl.SetControllerReference(a.application, snapshot, a.client.Scheme())
if err != nil {
a.logger.Error(err, "Failed to set controller refrence")
return nil, err
}

err = a.client.Create(a.context, snapshot)
if err != nil {
a.logger.Error(err, "Failed to create new snapshot on client")
return nil, err
}

go metrics.RegisterNewSnapshot()
dirgim marked this conversation as resolved.
Show resolved Hide resolved
return snapshot, nil
}

func hasComponentBeenDeleted(object client.Object) bool {

if comp, ok := object.(*applicationapiv1alpha1.Component); ok {
return !comp.ObjectMeta.DeletionTimestamp.IsZero()
}
return false
}
145 changes: 145 additions & 0 deletions controllers/component/component_adapter_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,145 @@
package component

import (
"bytes"
"reflect"
"time"

"github.com/tonglil/buflogr"

. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"

applicationapiv1alpha1 "github.com/redhat-appstudio/application-api/api/v1alpha1"
"github.com/redhat-appstudio/integration-service/loader"

metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

"github.com/redhat-appstudio/integration-service/helpers"
"k8s.io/apimachinery/pkg/api/errors"

"sigs.k8s.io/controller-runtime/pkg/client"
)

var _ = Describe("Component Adapter", Ordered, func() {
var (
adapter *Adapter
logger helpers.IntegrationLogger

hasApp *applicationapiv1alpha1.Application
hasComp *applicationapiv1alpha1.Component
hasComp2 *applicationapiv1alpha1.Component
)
const (
SampleCommit = "a2ba645d50e471d5f084b"
SampleRepoLink = "https://github.com/devfile-samples/devfile-sample-java-springboot-basic"
sample_revision = "random-value"
SampleDigest = "sha256:841328df1b9f8c4087adbdcfec6cc99ac8308805dea83f6d415d6fb8d40227c1"
SampleImageWithoutDigest = "quay.io/redhat-appstudio/sample-image"
SampleImage = SampleImageWithoutDigest + "@" + SampleDigest
)

BeforeAll(func() {

hasApp = &applicationapiv1alpha1.Application{
ObjectMeta: metav1.ObjectMeta{
Name: "application-sample",
Namespace: "default",
},
Spec: applicationapiv1alpha1.ApplicationSpec{
DisplayName: "application-sample",
Description: "This is an example application",
},
}
Expect(k8sClient.Create(ctx, hasApp)).Should(Succeed())

hasComp = &applicationapiv1alpha1.Component{
ObjectMeta: metav1.ObjectMeta{
Name: "component-sample",
Namespace: "default",
},
Spec: applicationapiv1alpha1.ComponentSpec{
ComponentName: "component-sample-2",
Application: hasApp.Name,
ContainerImage: SampleImage,
Source: applicationapiv1alpha1.ComponentSource{
ComponentSourceUnion: applicationapiv1alpha1.ComponentSourceUnion{
GitSource: &applicationapiv1alpha1.GitSource{
URL: SampleRepoLink,
Revision: SampleCommit,
},
},
},
},
Status: applicationapiv1alpha1.ComponentStatus{
LastBuiltCommit: "",
},
}
Expect(k8sClient.Create(ctx, hasComp)).Should(Succeed())

hasComp2 = &applicationapiv1alpha1.Component{
ObjectMeta: metav1.ObjectMeta{
Name: "component-second-sample",
Namespace: "default",
},
Spec: applicationapiv1alpha1.ComponentSpec{
ComponentName: "component-second-sample",
Application: "application-sample",
ContainerImage: SampleImage,
Source: applicationapiv1alpha1.ComponentSource{
ComponentSourceUnion: applicationapiv1alpha1.ComponentSourceUnion{
GitSource: &applicationapiv1alpha1.GitSource{
URL: SampleRepoLink,
},
},
},
},
}
Expect(k8sClient.Create(ctx, hasComp2)).Should(Succeed())
})

AfterAll(func() {
err := k8sClient.Delete(ctx, hasApp)
Expect(err == nil || errors.IsNotFound(err)).To(BeTrue())
err = k8sClient.Delete(ctx, hasComp)
Expect(err == nil || errors.IsNotFound(err)).To(BeTrue())
err = k8sClient.Delete(ctx, hasComp2)
Expect(err == nil || errors.IsNotFound(err)).To(BeTrue())
})

It("can create a new Adapter instance", func() {
Expect(reflect.TypeOf(NewAdapter(hasComp, hasApp, logger, loader.NewMockLoader(), k8sClient, ctx))).To(Equal(reflect.TypeOf(&Adapter{})))
})
It("ensures removing a component will result in a new snapshot being created", func() {
buf := bytes.Buffer{}

log := helpers.IntegrationLogger{Logger: buflogr.NewWithBuffer(&buf)}
adapter = NewAdapter(hasComp, hasApp, log, loader.NewMockLoader(), k8sClient, ctx)
adapter.context = loader.GetMockedContext(ctx, []loader.MockData{
{
ContextKey: loader.ApplicationContextKey,
Resource: hasApp,
},
{
ContextKey: loader.ApplicationComponentsContextKey,
Resource: []applicationapiv1alpha1.Component{*hasComp, *hasComp2},
},
})
snapshots := &applicationapiv1alpha1.SnapshotList{}
Eventually(func() bool {
k8sClient.List(ctx, snapshots, &client.ListOptions{Namespace: hasApp.Namespace})
return len(snapshots.Items) == 0
}, time.Second*20).Should(BeTrue())

now := metav1.NewTime(metav1.Now().Add(time.Second * 1))
hasComp.SetDeletionTimestamp(&now)

result, err := adapter.EnsureComponentIsCleanedUp()

Eventually(func() bool {
k8sClient.List(ctx, snapshots, &client.ListOptions{Namespace: hasApp.Namespace})
dirgim marked this conversation as resolved.
Show resolved Hide resolved
return !result.CancelRequest && len(snapshots.Items) == 1 && err == nil
}, time.Second*20).Should(BeTrue())
})

})
Loading
Loading