github.com/redhat-appstudio/e2e-tests@v0.0.0-20240520140907-9709f6f59323/pkg/clients/release/releases.go (about)

     1  package release
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  
     7  	releaseApi "github.com/redhat-appstudio/release-service/api/v1alpha1"
     8  	pipeline "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1"
     9  	corev1 "k8s.io/api/core/v1"
    10  	rbac "k8s.io/api/rbac/v1"
    11  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    12  	"k8s.io/apimachinery/pkg/types"
    13  	"sigs.k8s.io/controller-runtime/pkg/client"
    14  )
    15  
    16  // CreateRelease creates a new Release using the given parameters.
    17  func (r *ReleaseController) CreateRelease(name, namespace, snapshot, releasePlan string) (*releaseApi.Release, error) {
    18  	release := &releaseApi.Release{
    19  		ObjectMeta: metav1.ObjectMeta{
    20  			Name:      name,
    21  			Namespace: namespace,
    22  		},
    23  		Spec: releaseApi.ReleaseSpec{
    24  			Snapshot:    snapshot,
    25  			ReleasePlan: releasePlan,
    26  		},
    27  	}
    28  
    29  	return release, r.KubeRest().Create(context.Background(), release)
    30  }
    31  
    32  // CreateReleasePipelineRoleBindingForServiceAccount creates a RoleBinding for the passed serviceAccount to enable
    33  // retrieving the necessary CRs from the passed namespace.
    34  func (r *ReleaseController) CreateReleasePipelineRoleBindingForServiceAccount(namespace string, serviceAccount *corev1.ServiceAccount) (*rbac.RoleBinding, error) {
    35  	roleBinding := &rbac.RoleBinding{
    36  		ObjectMeta: metav1.ObjectMeta{
    37  			GenerateName: "release-service-pipeline-rolebinding-",
    38  			Namespace:    namespace,
    39  		},
    40  		RoleRef: rbac.RoleRef{
    41  			APIGroup: rbac.GroupName,
    42  			Kind:     "ClusterRole",
    43  			Name:     "release-pipeline-resource-role",
    44  		},
    45  		Subjects: []rbac.Subject{
    46  			{
    47  				Kind:      "ServiceAccount",
    48  				Name:      serviceAccount.Name,
    49  				Namespace: serviceAccount.Namespace,
    50  			},
    51  		},
    52  	}
    53  	err := r.KubeRest().Create(context.Background(), roleBinding)
    54  	if err != nil {
    55  		return nil, err
    56  	}
    57  	return roleBinding, nil
    58  }
    59  
    60  // GetRelease returns the release with in the given namespace.
    61  // It can find a Release CR based on provided name or a name of an associated Snapshot
    62  func (r *ReleaseController) GetRelease(releaseName, snapshotName, namespace string) (*releaseApi.Release, error) {
    63  	ctx := context.Background()
    64  	if len(releaseName) > 0 {
    65  		release := &releaseApi.Release{}
    66  		err := r.KubeRest().Get(ctx, types.NamespacedName{Name: releaseName, Namespace: namespace}, release)
    67  		if err != nil {
    68  			return nil, fmt.Errorf("failed to get Release with name '%s' in '%s' namespace", releaseName, namespace)
    69  		}
    70  		return release, nil
    71  	}
    72  	releaseList := &releaseApi.ReleaseList{}
    73  	opts := []client.ListOption{
    74  		client.InNamespace(namespace),
    75  	}
    76  	if err := r.KubeRest().List(context.Background(), releaseList, opts...); err != nil {
    77  		return nil, err
    78  	}
    79  	for _, r := range releaseList.Items {
    80  		if len(snapshotName) > 0 && r.Spec.Snapshot == snapshotName {
    81  			return &r, nil
    82  		}
    83  	}
    84  	return nil, fmt.Errorf("could not find Release CR based on associated Snapshot '%s' in '%s' namespace", snapshotName, namespace)
    85  }
    86  
    87  // GetReleases returns the list of Release CR in the given namespace.
    88  func (r *ReleaseController) GetReleases(namespace string) (*releaseApi.ReleaseList, error) {
    89  	releaseList := &releaseApi.ReleaseList{}
    90  	opts := []client.ListOption{
    91  		client.InNamespace(namespace),
    92  	}
    93  	err := r.KubeRest().List(context.Background(), releaseList, opts...)
    94  
    95  	return releaseList, err
    96  }
    97  
    98  // GetFirstReleaseInNamespace returns the first Release from  list of releases in the given namespace.
    99  func (r *ReleaseController) GetFirstReleaseInNamespace(namespace string) (*releaseApi.Release, error) {
   100  	releaseList, err := r.GetReleases(namespace)
   101  
   102  	if err != nil || len(releaseList.Items) < 1 {
   103  		return nil, fmt.Errorf("could not find any Releases in namespace %s: %+v", namespace, err)
   104  	}
   105  	return &releaseList.Items[0], nil
   106  }
   107  
   108  // GetPipelineRunInNamespace returns the Release PipelineRun referencing the given release.
   109  func (r *ReleaseController) GetPipelineRunInNamespace(namespace, releaseName, releaseNamespace string) (*pipeline.PipelineRun, error) {
   110  	pipelineRuns := &pipeline.PipelineRunList{}
   111  	opts := []client.ListOption{
   112  		client.MatchingLabels{
   113  			"release.appstudio.openshift.io/name":      releaseName,
   114  			"release.appstudio.openshift.io/namespace": releaseNamespace,
   115  		},
   116  		client.InNamespace(namespace),
   117  	}
   118  
   119  	err := r.KubeRest().List(context.Background(), pipelineRuns, opts...)
   120  
   121  	if err == nil && len(pipelineRuns.Items) > 0 {
   122  		return &pipelineRuns.Items[0], nil
   123  	}
   124  
   125  	return nil, fmt.Errorf("couldn't find PipelineRun in managed namespace '%s' for a release '%s' in '%s' namespace because of err:'%w'", namespace, releaseName, releaseNamespace, err)
   126  }