feat: remove reference validation

Author: teoincontatto

stackgres-k8s/src/common/src/main/java/io/stackgres/common/ErrorType.java

@@ -18,8 +18,6 @@ public enum ErrorType {
   POOL_CONFIG_BLOCKLIST("pooling-blocklist",
       "The pgbouncer configuration contains blocklisted parameters"),
   PG_VERSION_MISMATCH("postgres-major-version-mismatch", "Postgres versions doesn't match"),
-  INVALID_CR_REFERENCE("invalid-configuration-reference",
-      "Invalid configuration reference"),
   DEFAULT_CONFIGURATION("default-configuration",
       "Default configurations cannot be altered"),
   FORBIDDEN_CR_DELETION("forbidden-configuration-deletion",
@@ -28,16 +26,14 @@ public enum ErrorType {
       "Forbidden configuration update"),
   FORBIDDEN_CR_CREATION("forbidden-configuration-creation",
       "Forbidden configuration creation"),
+  FORBIDDEN_CLUSTER_CREATE("forbidden-cluster-create",
+      "Forbidden cluster create"),
   FORBIDDEN_CLUSTER_UPDATE("forbidden-cluster-update",
       "Forbidden cluster update"),
   FORBIDDEN_STREAM_UPDATE("forbidden-stream-update",
       "Forbidden stream update"),
   FORBIDDEN_AUTHORIZATION("forbidden-authorization",
       "Forbidden API role-based access control"),
-  INVALID_STORAGE_CLASS("invalid-storage-class",
-      "Invalid storage class"),
-  INVALID_SECRET("invalid-secret",
-      "Invalid secret"),
   EXTENSION_NOT_FOUND("extension-not-found",
       "Extension not found"),
   PG_CONFIG_PARAMETER("postgres-parameter",

stackgres-k8s/src/operator/src/main/java/io/stackgres/operator/conciliation/backup/BackupRequiredResourcesGenerator.java

@@ -7,7 +7,6 @@
 
 import java.util.Collection;
 import java.util.List;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
@@ -78,9 +77,10 @@ public List<HasMetadata> getRequiredResources(StackGresBackup config) {
     final String clusterNamespace = StackGresUtil.getNamespaceFromRelativeId(
         spec.getSgCluster(), backupNamespace);
 
-    final Optional<StackGresCluster> cluster = clusterFinder
+    final Optional<StackGresCluster> foundCluster = clusterFinder
         .findByNameAndNamespace(clusterName, clusterNamespace);
-    final Optional<StackGresProfile> profile = cluster
+
+    final Optional<StackGresProfile> foundProfile = foundCluster
         .map(StackGresCluster::getSpec)
         .map(StackGresClusterSpec::getSgInstanceProfile)
         .flatMap(profileName -> profileFinder
@@ -90,47 +90,51 @@ public List<HasMetadata> getRequiredResources(StackGresBackup config) {
 
     var contextBuilder = ImmutableStackGresBackupContext.builder()
         .source(config)
-        .foundCluster(cluster)
-        .foundProfile(profile)
+        .foundCluster(foundCluster)
+        .foundProfile(foundProfile)
         .clusterBackupNamespaces(clusterBackupNamespaces);
 
-    if (cluster.isPresent()
-        && isBackupInTheSameSgClusterNamespace(config, clusterNamespace)
+    if (clusterNamespace.equals(backupNamespace)
         && !isBackupFinished(config)) {
-      final var specConfiguration = cluster
+      if (foundCluster.isEmpty()) {
+        throw new IllegalArgumentException(
+            StackGresCluster.KIND + " " + clusterName + " was not found");
+      }
+
+      if (foundProfile.isEmpty()) {
+        throw new IllegalArgumentException(
+            StackGresProfile.KIND + " " + foundCluster.get().getSpec().getSgInstanceProfile() + " was not found");
+      }
+
+      final var specConfiguration = foundCluster
           .map(StackGresCluster::getSpec)
           .map(StackGresClusterSpec::getConfigurations);
 
-      final Optional<String> sgObjectStorageName = specConfiguration
+      final var sgObjectStorageName = specConfiguration
           .map(StackGresClusterConfigurations::getBackups)
           .map(Collection::stream)
           .flatMap(Stream::findFirst)
           .map(StackGresClusterBackupConfiguration::getSgObjectStorage);
 
       if (sgObjectStorageName.isEmpty()) {
         throw new IllegalArgumentException(
-            "SGBackup " + backupNamespace + "." + backupName
-                + " target SGCluster " + spec.getSgCluster()
-                + " without an SGObjectStorage");
+            StackGresBackup.KIND + " " + backupNamespace + "." + backupName
+                + " target " + StackGresCluster.KIND + " " + spec.getSgCluster()
+                + " without an " + StackGresObjectStorage.KIND);
       }
 
       sgObjectStorageName.ifPresent(objectStorageName -> contextBuilder.objectStorage(
           objectStorageFinder.findByNameAndNamespace(objectStorageName, backupNamespace)
               .orElseThrow(
                   () -> new IllegalArgumentException(
-                      "SGBackup " + backupNamespace + "." + backupName
-                          + " target SGCluster " + spec.getSgCluster()
-                          + " with a non existent SGObjectStorage " + objectStorageName))));
+                      StackGresBackup.KIND + " " + backupNamespace + "." + backupName
+                          + " target " + StackGresBackup.KIND + " " + spec.getSgCluster()
+                          + " with a non existent " + StackGresObjectStorage.KIND + " " + objectStorageName))));
     }
 
     return discoverer.generateResources(contextBuilder.build());
   }
 
-  private boolean isBackupInTheSameSgClusterNamespace(
-      StackGresBackup backup, String clusterNamespace) {
-    return Objects.equals(backup.getMetadata().getNamespace(), clusterNamespace);
-  }
-
   private boolean isBackupFinished(StackGresBackup backup) {
     return Optional.of(backup)
         .map(StackGresBackup::getStatus)

stackgres-k8s/src/operator/src/main/java/io/stackgres/operator/conciliation/dbops/DbOpsRequiredResourcesGenerator.java

@@ -5,13 +5,27 @@
 
 package io.stackgres.operator.conciliation.dbops;
 
+import static io.stackgres.common.StackGresUtil.getPostgresFlavorComponent;
+
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Stream;
 
+import com.google.common.collect.ImmutableMap;
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.fabric8.kubernetes.api.model.ObjectMeta;
+import io.fabric8.kubernetes.api.model.OwnerReference;
+import io.stackgres.common.DbOpsUtil;
+import io.stackgres.common.StackGresComponent;
+import io.stackgres.common.StackGresVersion;
 import io.stackgres.common.crd.sgcluster.StackGresCluster;
+import io.stackgres.common.crd.sgcluster.StackGresClusterDbOpsMajorVersionUpgradeStatus;
+import io.stackgres.common.crd.sgcluster.StackGresClusterDbOpsStatus;
 import io.stackgres.common.crd.sgcluster.StackGresClusterSpec;
+import io.stackgres.common.crd.sgcluster.StackGresClusterStatus;
 import io.stackgres.common.crd.sgconfig.StackGresConfig;
 import io.stackgres.common.crd.sgdbops.StackGresDbOps;
 import io.stackgres.common.crd.sgdbops.StackGresDbOpsBenchmark;
@@ -20,13 +34,17 @@
 import io.stackgres.common.crd.sgdbops.StackGresDbOpsSamplingStatus;
 import io.stackgres.common.crd.sgdbops.StackGresDbOpsSpec;
 import io.stackgres.common.crd.sgdbops.StackGresDbOpsStatus;
+import io.stackgres.common.crd.sgdistributedlogs.StackGresDistributedLogs;
+import io.stackgres.common.crd.sgpgconfig.StackGresPostgresConfig;
 import io.stackgres.common.crd.sgprofile.StackGresProfile;
 import io.stackgres.common.resource.CustomResourceFinder;
 import io.stackgres.common.resource.CustomResourceScanner;
 import io.stackgres.operator.conciliation.RequiredResourceGenerator;
 import io.stackgres.operator.conciliation.ResourceGenerationDiscoverer;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
+import org.jooq.lambda.Seq;
+import org.jooq.lambda.tuple.Tuple2;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -37,10 +55,21 @@ public class DbOpsRequiredResourcesGenerator
   protected static final Logger LOGGER = LoggerFactory
       .getLogger(DbOpsRequiredResourcesGenerator.class);
 
+  private final Map<StackGresComponent, Map<StackGresVersion, List<String>>> supportedPostgresVersions =
+      Stream.of(StackGresComponent.POSTGRESQL, StackGresComponent.BABELFISH)
+      .collect(ImmutableMap.toImmutableMap(Function.identity(),
+          component -> component.getComponentVersions()
+              .entrySet()
+              .stream()
+              .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey,
+                  entry -> entry.getValue().streamOrderedVersions().toList()))));
+
   private final CustomResourceScanner<StackGresConfig> configScanner;
 
   private final CustomResourceFinder<StackGresCluster> clusterFinder;
 
+  private final CustomResourceFinder<StackGresPostgresConfig> postgresConfigFinder;
+
   private final CustomResourceFinder<StackGresProfile> profileFinder;
 
   private final CustomResourceFinder<StackGresDbOps> dbOpsFinder;
@@ -51,11 +80,13 @@ public class DbOpsRequiredResourcesGenerator
   public DbOpsRequiredResourcesGenerator(
       CustomResourceScanner<StackGresConfig> configScanner,
       CustomResourceFinder<StackGresCluster> clusterFinder,
+      CustomResourceFinder<StackGresPostgresConfig> postgresConfigFinder,
       CustomResourceFinder<StackGresProfile> profileFinder,
       CustomResourceFinder<StackGresDbOps> dbOpsFinder,
       ResourceGenerationDiscoverer<StackGresDbOpsContext> discoverer) {
     this.configScanner = configScanner;
     this.clusterFinder = clusterFinder;
+    this.postgresConfigFinder = postgresConfigFinder;
     this.profileFinder = profileFinder;
     this.dbOpsFinder = dbOpsFinder;
     this.discoverer = discoverer;
@@ -74,15 +105,107 @@ public List<HasMetadata> getRequiredResources(StackGresDbOps dbOps) {
         .orElseThrow(() -> new IllegalArgumentException(
             "SGConfig not found or more than one exists. Aborting reoconciliation!"));
 
-    final StackGresDbOpsSpec spec = dbOps.getSpec();
-    final Optional<StackGresCluster> cluster = clusterFinder
-        .findByNameAndNamespace(spec.getSgCluster(), dbOpsNamespace);
+    final String clusterName = dbOps.getSpec().getSgCluster();
+    final Optional<StackGresCluster> foundCluster = clusterFinder
+        .findByNameAndNamespace(clusterName, dbOpsNamespace);
 
-    final Optional<StackGresProfile> profile = cluster
+    final Optional<StackGresProfile> foundProfile = foundCluster
         .map(StackGresCluster::getSpec)
         .map(StackGresClusterSpec::getSgInstanceProfile)
         .flatMap(profileName -> profileFinder
             .findByNameAndNamespace(profileName, dbOpsNamespace));
+    if (!DbOpsUtil.isAlreadyCompleted(dbOps)) {
+      if (foundCluster.isEmpty()) {
+        throw new IllegalArgumentException(
+            StackGresCluster.KIND + " " + clusterName + " was not found");
+      }
+      final StackGresCluster cluster = foundCluster.get();
+
+      if (foundProfile.isEmpty()) {
+        throw new IllegalArgumentException(
+            StackGresProfile.KIND + " " + foundCluster.get().getSpec().getSgInstanceProfile() + " was not found");
+      }
+
+      if (dbOps.getSpec().isOpMajorVersionUpgrade()) {
+        var foundOwnerReference = Optional.of(cluster)
+            .map(StackGresCluster::getMetadata)
+            .map(ObjectMeta::getOwnerReferences)
+            .stream()
+            .flatMap(List::stream)
+            .filter(ownerReference -> !Objects.equals(
+                ownerReference.getKind(),
+                HasMetadata.getKind(StackGresDistributedLogs.class)))
+            .filter(ownerReference -> ownerReference.getController() != null
+                && ownerReference.getController())
+            .findFirst();
+        if (foundOwnerReference.isPresent()) {
+          OwnerReference ownerReference = foundOwnerReference.get();
+          throw new IllegalArgumentException(
+              "Can not perform major version upgrade on " + StackGresCluster.KIND + " managed by "
+                  + ownerReference.getKind() + " " + ownerReference.getName());
+        }
+    
+        final String givenPgVersion = dbOps.getSpec().getMajorVersionUpgrade().getPostgresVersion();
+        if (givenPgVersion != null
+            && !isPostgresVersionSupported(cluster, givenPgVersion)) {
+          final String message = "Unsupported postgres version " + givenPgVersion
+              + ".  Supported postgres versions are: "
+              + Seq.seq(supportedPostgresVersions.get(getPostgresFlavorComponent(cluster))
+                  .get(StackGresVersion.getStackGresVersion(cluster))).toString(", ");
+          throw new IllegalArgumentException(message);
+        }
+    
+        String givenMajorVersion = getPostgresFlavorComponent(cluster)
+            .get(cluster).getMajorVersion(givenPgVersion);
+        long givenMajorVersionIndex = getPostgresFlavorComponent(cluster)
+            .get(cluster)
+            .streamOrderedMajorVersions()
+            .zipWithIndex()
+            .filter(t -> t.v1.equals(givenMajorVersion))
+            .map(Tuple2::v2)
+            .findAny()
+            .orElseThrow();
+        String oldPgVersion = Optional.ofNullable(cluster.getStatus())
+            .map(StackGresClusterStatus::getDbOps)
+            .map(StackGresClusterDbOpsStatus::getMajorVersionUpgrade)
+            .map(StackGresClusterDbOpsMajorVersionUpgradeStatus::getSourcePostgresVersion)
+            .orElse(cluster.getSpec().getPostgres().getVersion());
+        String oldMajorVersion = getPostgresFlavorComponent(cluster)
+            .get(cluster)
+            .getMajorVersion(oldPgVersion);
+        long oldMajorVersionIndex = getPostgresFlavorComponent(cluster)
+            .get(cluster)
+            .streamOrderedMajorVersions()
+            .zipWithIndex()
+            .filter(t -> t.v1.equals(oldMajorVersion))
+            .map(Tuple2::v2)
+            .findAny()
+            .orElseThrow();
+    
+        if (givenMajorVersionIndex >= oldMajorVersionIndex) {
+          throw new IllegalArgumentException(
+              "postgres version must be a newer major version than the current one ("
+                  + givenMajorVersion + " < " + oldMajorVersion + ")");
+        }
+  
+        Optional<StackGresPostgresConfig> postgresConfig = postgresConfigFinder
+            .findByNameAndNamespace(
+                dbOps.getSpec().getMajorVersionUpgrade().getSgPostgresConfig(),
+                dbOps.getMetadata().getNamespace());
+        if (postgresConfig.isPresent()) {
+          if (!postgresConfig.get().getSpec().getPostgresVersion().equals(givenMajorVersion)) {
+            throw new IllegalArgumentException(
+                StackGresPostgresConfig.KIND + " must be for postgres version "
+                    + givenMajorVersion + " but was for version "
+                    + postgresConfig.get().getSpec().getPostgresVersion());
+          }
+        } else {
+          throw new IllegalArgumentException(
+              StackGresPostgresConfig.KIND + " "
+                  + dbOps.getSpec().getMajorVersionUpgrade().getSgPostgresConfig() + " not found");
+        }
+      }
+    }
 
     final Optional<StackGresDbOpsSamplingStatus> samplingStatus = Optional.of(dbOps.getSpec())
         .map(StackGresDbOpsSpec::getBenchmark)
@@ -94,18 +217,24 @@ public List<HasMetadata> getRequiredResources(StackGresDbOps dbOps) {
             .map(StackGresDbOpsStatus::getBenchmark)
             .map(StackGresDbOpsBenchmarkStatus::getSampling)
             .orElseThrow(() -> new IllegalArgumentException(
-                "SGDbOps " + samplingDbOpsName
+                StackGresDbOps.KIND + " " + samplingDbOpsName
                 + " was not found or has no has no sampling status")));
 
     StackGresDbOpsContext context = ImmutableStackGresDbOpsContext.builder()
         .config(config)
         .source(dbOps)
-        .foundCluster(cluster)
-        .foundProfile(profile)
+        .foundCluster(foundCluster)
+        .foundProfile(foundProfile)
         .samplingStatus(samplingStatus)
         .build();
 
     return discoverer.generateResources(context);
   }
 
+  private boolean isPostgresVersionSupported(StackGresCluster cluster, String version) {
+    return supportedPostgresVersions.get(getPostgresFlavorComponent(cluster))
+        .get(StackGresVersion.getStackGresVersion(cluster))
+        .contains(version);
+  }
+
 }