update: cleanup unnecessary upgrade logic

- remove functions and calls not needed for 3.2 (should be removed in
  3.0 already)
  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

@@ -256,7 +256,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(platform)
 	if err != nil {

pkg/cluster/cluster_config.go

@@ -98,6 +98,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("nonexistent field path: %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
+}