update: cleanup unnecessary upgrade logic

- remove functions and calls not needed for 3.1
  jupyterhub resource cleanup
  rbac for modelreg
  envoyfilter patch for serving
  watson resource docs
  patch odhdashboardconfig for trusty enablement
- move and cleanup function for AP to HWP migration

Signed-off-by: Wen Zhou <[email protected]>

Author: zdtsw

cmd/main.go

@@ -258,7 +258,7 @@ func main() { //nolint:funlen,maintidx,gocyclo
 	}
 
 	// get old release version before we create default DSCI CR
-	oldReleaseVersion, _ := upgrade.GetDeployedRelease(ctx, setupClient)
+	oldReleaseVersion, _ := cluster.GetDeployedRelease(ctx, setupClient)
 
 	secretCache, err := createSecretCacheConfig(ctx, setupClient, platform)
 	if err != nil {

pkg/cluster/cluster_config.go

@@ -90,6 +90,46 @@ func GetRelease() common.Release {
 	return clusterConfig.Release
 }
 
+// GetDeployedRelease retrieves the currently deployed release version from the cluster.
+// It first attempts to get the release from the DSCInitialization (DSCI) instance,
+// and if not found, falls back to the DataScienceCluster (DSC) instance.
+//
+// This function is useful during upgrades to determine what version is currently deployed
+// before applying any changes.
+//
+// Parameters:
+//   - ctx: The context for the request
+//   - cli: The Kubernetes client used to retrieve resources
+//
+// Returns:
+//   - common.Release: The deployed release information, or an empty Release if not found
+//   - error: An error if the retrieval fails for reasons other than "not found"
+func GetDeployedRelease(ctx context.Context, cli client.Client) (common.Release, error) {
+	dsciInstance, err := GetDSCI(ctx, cli)
+	switch {
+	case k8serr.IsNotFound(err):
+		break
+	case err != nil:
+		return common.Release{}, err
+	default:
+		return dsciInstance.Status.Release, nil
+	}
+
+	// no DSCI CR found, try with DSC CR
+	dscInstances, err := GetDSC(ctx, cli)
+	switch {
+	case k8serr.IsNotFound(err):
+		break
+	case err != nil:
+		return common.Release{}, err
+	default:
+		return dscInstances.Status.Release, nil
+	}
+
+	// could be a clean installation or both CRs are deleted already
+	return common.Release{}, nil
+}
+
 func GetClusterInfo() ClusterInfo {
 	return clusterConfig.ClusterInfo
 }

pkg/cluster/resources.go

@@ -173,6 +173,25 @@ func GetHardwareProfile(ctx context.Context, cli client.Client, name, namespace
 	return hwProfile, nil
 }
 
+// CreateHardwareProfile creates a HardwareProfile resource in the cluster.
+// If the resource already exists, it returns nil (idempotent operation).
+//
+// Parameters:
+//   - ctx: The context for the request
+//   - cli: The Kubernetes client used to create the resource
+//   - hwp: The HardwareProfile to create
+//
+// Returns:
+//   - error: An error if the creation fails for reasons other than "already exists"
+func CreateHardwareProfile(ctx context.Context, cli client.Client, hwp *infrav1.HardwareProfile) error {
+	if err := cli.Create(ctx, hwp); err != nil {
+		if !k8serr.IsAlreadyExists(err) {
+			return fmt.Errorf("failed to create HardwareProfile '%s/%s': %w", hwp.Namespace, hwp.Name, err)
+		}
+	}
+	return nil
+}
+
 // UpdatePodSecurityRolebinding update default rolebinding which is created in applications namespace by manifests
 // being used by different components and SRE monitoring.
 func UpdatePodSecurityRolebinding(ctx context.Context, cli client.Client, namespace string, serviceAccountsList ...string) error {

pkg/resources/resources.go

@@ -11,10 +11,12 @@ import (
 	"slices"
 
 	"github.com/davecgh/go-spew/spew"
+	"github.com/hashicorp/go-multierror"
 	routev1 "github.com/openshift/api/route/v1"
 	"gopkg.in/yaml.v3"
 	corev1 "k8s.io/api/core/v1"
 	k8serr "k8s.io/apimachinery/pkg/api/errors"
+	"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"
@@ -23,10 +25,23 @@ import (
 	"k8s.io/client-go/discovery"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
 )
 
 const PlatformFieldOwner = "platform.opendatahub.io"
 
+// ResourceSpec defines a specification for identifying and filtering Kubernetes resources
+// based on their GroupVersionKind, namespace, and field values.
+type ResourceSpec struct {
+	Gvk       schema.GroupVersionKind
+	Namespace string
+	// FieldPath specifies the path to the field for filtering, like ["metadata", "name"]
+	FieldPath []string
+	// FilterValues contains the values to match against the field - if the field value
+	// matches any of these values, the resource will be processed (e.g., deleted)
+	FilterValues []string
+}
+
 func ToUnstructured(obj any) (*unstructured.Unstructured, error) {
 	data, err := runtime.DefaultUnstructuredConverter.ToUnstructured(obj)
 	if err != nil {
@@ -631,3 +646,95 @@ func ListAvailableAPIResources(
 
 	return items, nil
 }
+
+// DeleteResources iterates through a list of ResourceSpec and deletes matching Kubernetes resources.
+// It collects all errors encountered during deletion and returns them as a multierror.
+//
+// Parameters:
+//   - ctx: The context for the operation
+//   - c: The Kubernetes client used to list and delete resources
+//   - resources: A slice of ResourceSpec defining which resources to delete
+//
+// Returns:
+//   - error: A multierror containing all errors encountered, or nil if all deletions succeeded
+func DeleteResources(ctx context.Context, c client.Client, resources []ResourceSpec) error {
+	var errors *multierror.Error
+
+	for _, res := range resources {
+		err := DeleteOneResource(ctx, c, res)
+		errors = multierror.Append(errors, err)
+	}
+
+	return errors.ErrorOrNil()
+}
+
+// DeleteOneResource deletes all Kubernetes resources matching the given ResourceSpec.
+// It lists resources of the specified GVK in the given namespace, filters them based on
+// the field path and values, and deletes matching resources.
+//
+// Parameters:
+//   - ctx: The context for the operation
+//   - c: The Kubernetes client used to list and delete resources
+//   - res: The ResourceSpec defining which resources to delete
+//
+// Returns:
+//   - error: An error if the operation fails, or nil on success
+func DeleteOneResource(ctx context.Context, c client.Client, res ResourceSpec) error {
+	log := logf.FromContext(ctx)
+	list := &unstructured.UnstructuredList{}
+	list.SetGroupVersionKind(res.Gvk)
+
+	err := c.List(ctx, list, client.InNamespace(res.Namespace))
+	if err != nil {
+		if meta.IsNoMatchError(err) {
+			log.Info("CRD not found, will not delete", "gvk", res.Gvk.String())
+			return nil
+		}
+		return fmt.Errorf("failed to list %s: %w", res.Gvk.Kind, err)
+	}
+
+	for _, item := range list.Items {
+		v, ok, err := unstructured.NestedString(item.Object, res.FieldPath...)
+		if err != nil {
+			return fmt.Errorf("failed to get field %v for %s %s/%s: %w", res.FieldPath, res.Gvk.Kind, res.Namespace, item.GetName(), err)
+		}
+
+		if !ok {
+			return fmt.Errorf("unexisting path to delete: %v", res.FieldPath)
+		}
+
+		for _, targetValue := range res.FilterValues {
+			if v == targetValue {
+				err = c.Delete(ctx, &item)
+				if err != nil {
+					return fmt.Errorf("failed to delete %s %s/%s: %w", res.Gvk.Kind, res.Namespace, item.GetName(), err)
+				}
+				log.Info("Deleted object", "name", item.GetName(), "gvk", res.Gvk.String(), "namespace", res.Namespace)
+			}
+		}
+	}
+
+	return nil
+}
+
+// UnsetOwnerReferences removes all owner references from a Kubernetes object and updates it.
+// This is useful when you need to orphan a resource from its owner.
+//
+// Parameters:
+//   - ctx: The context for the operation
+//   - cli: The Kubernetes client used to update the resource
+//   - instanceName: The name of the instance (used for error reporting)
+//   - odhObject: The unstructured object whose owner references should be removed
+//
+// Returns:
+//   - error: An error if the update operation fails, or nil if there are no owner references or update succeeds
+func UnsetOwnerReferences(ctx context.Context, cli client.Client, instanceName string, odhObject *unstructured.Unstructured) error {
+	if odhObject.GetOwnerReferences() != nil {
+		// set to nil as updates
+		odhObject.SetOwnerReferences(nil)
+		if err := cli.Update(ctx, odhObject); err != nil {
+			return fmt.Errorf("error unset ownerreference for CR %s : %w", instanceName, err)
+		}
+	}
+	return nil
+}