feat: remove reference validation

Author: teoincontatto

stackgres-k8s/src/common/src/main/java/io/stackgres/common/crd/sgcluster/StackGresClusterRestoreFromBackup.java

@@ -17,6 +17,7 @@
 import io.sundr.builder.annotations.Buildable;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotNull;
 
 @RegisterForReflection
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
@@ -28,6 +29,7 @@ public class StackGresClusterRestoreFromBackup {
 
   private String uid;
 
+  @NotNull(message = "name cannot be null")
   private String name;
 
   private String target;
@@ -45,8 +47,8 @@ public class StackGresClusterRestoreFromBackup {
   @Valid
   private StackGresClusterRestorePitr pointInTimeRecovery;
 
-  @ReferencedField("name")
-  interface Name extends FieldReference { }
+  @ReferencedField("uid")
+  interface Uid extends FieldReference { }
 
   @ReferencedField("targetName")
   interface TargetName extends FieldReference { }
@@ -61,11 +63,10 @@ interface TargetLsn extends FieldReference { }
   interface PointInTimeRecovery extends FieldReference { }
 
   @JsonIgnore
-  @AssertTrue(message = "name cannot be null",
-      payload = { Name.class })
-  public boolean isNameNotNullOrUidNotNull() {
-    return (name != null && uid == null) // NOPMD
-        || (name == null && uid != null); // NOPMD
+  @AssertTrue(message = "uid is deprecated, use name instead!",
+      payload = { Uid.class })
+  public boolean isUidNull() {
+    return uid == null;
   }
 
   @JsonIgnore

stackgres-k8s/src/operator/src/main/java/io/stackgres/operator/conciliation/cluster/ClusterRequiredResourcesGenerator.java

@@ -178,6 +178,18 @@ public List<HasMetadata> getRequiredResources(StackGresCluster cluster) {
         .orElseThrow(() -> new IllegalArgumentException(
             "SGCluster " + clusterNamespace + "." + clusterName
                 + " have a non existent SGPostgresConfig postgresconf"));
+    String givenPgVersion = Optional.of(cluster.getSpec())
+        .map(StackGresClusterSpec::getPostgres)
+        .map(StackGresClusterPostgres::getVersion)
+        .orElse(null);
+    String givenMajorVersion = getPostgresFlavorComponent(cluster).get(cluster)
+        .getMajorVersion(givenPgVersion);
+    String pgVersion = pgConfig.getSpec().getPostgresVersion();
+
+    if (!pgVersion.equals(givenMajorVersion)) {
+      throw new IllegalArgumentException("Invalid postgres version, must be "
+          + pgVersion + " to use SGPostgresConfig " + clusterConfiguration.getSgPostgresConfig());
+    }
 
     final StackGresProfile profile = profileFinder
         .findByNameAndNamespace(spec.getSgInstanceProfile(), clusterNamespace)
@@ -893,14 +905,47 @@ private Set<String> getClusterBackupNamespaces(final String clusterNamespace) {
         .keySet();
   }
 
-  private Optional<StackGresBackup> findRestoreBackup(StackGresCluster config,
+  private Optional<StackGresBackup> findRestoreBackup(
+      StackGresCluster cluster,
       final String clusterNamespace) {
-    return Optional
-        .ofNullable(config.getSpec().getInitialData())
+    Optional<StackGresBackup> restoreBackup = Optional
+        .ofNullable(cluster.getSpec().getInitialData())
         .map(StackGresClusterInitialData::getRestore)
         .map(StackGresClusterRestore::getFromBackup)
         .map(StackGresClusterRestoreFromBackup::getName)
         .flatMap(backupName -> backupFinder.findByNameAndNamespace(backupName, clusterNamespace));
+    if (restoreBackup.isPresent()) {
+      if (restoreBackup
+          .map(StackGresBackup::getStatus)
+          .map(StackGresBackupStatus::getProcess)
+          .map(StackGresBackupProcess::getStatus)
+          .map(BackupStatus.COMPLETED.status()::equals)
+          .map(completed -> !completed)
+          .orElse(true)) {
+        throw new IllegalArgumentException("Cannot restore from SGBackup "
+            + restoreBackup.get().getMetadata().getName()
+            + " because it's not Completed");
+      }
+
+      String backupMajorVersion = restoreBackup.get()
+          .getStatus()
+          .getBackupInformation()
+          .getPostgresMajorVersion();
+
+      String givenPgVersion = cluster.getSpec()
+          .getPostgres().getVersion();
+      String givenMajorVersion = getPostgresFlavorComponent(cluster)
+          .get(cluster)
+          .getMajorVersion(givenPgVersion);
+
+      if (!backupMajorVersion.equals(givenMajorVersion)) {
+        throw new IllegalArgumentException("Cannot restore from SGBackup "
+            + restoreBackup.get().getMetadata().getName()
+            + " because it has been created from a postgres instance"
+            + " with version " + backupMajorVersion);
+      }
+    }
+    return restoreBackup;
   }
 
 }

stackgres-k8s/src/operator/src/main/java/io/stackgres/operator/conciliation/shardedcluster/ShardedClusterRequiredResourcesGenerator.java

@@ -8,6 +8,7 @@
 import static io.stackgres.common.StackGresShardedClusterUtil.CERTIFICATE_KEY;
 import static io.stackgres.common.StackGresShardedClusterUtil.PRIVATE_KEY_KEY;
 import static io.stackgres.common.StackGresShardedClusterUtil.postgresSslSecretName;
+import static io.stackgres.common.StackGresUtil.getPostgresFlavorComponent;
 
 import java.util.List;
 import java.util.Optional;
@@ -36,7 +37,9 @@
 import io.stackgres.common.crd.sgcluster.StackGresClusterUsersCredentials;
 import io.stackgres.common.crd.sgconfig.StackGresConfig;
 import io.stackgres.common.crd.sgpgconfig.StackGresPostgresConfig;
+import io.stackgres.common.crd.sgshardedbackup.ShardedBackupStatus;
 import io.stackgres.common.crd.sgshardedbackup.StackGresShardedBackup;
+import io.stackgres.common.crd.sgshardedbackup.StackGresShardedBackupProcess;
 import io.stackgres.common.crd.sgshardedbackup.StackGresShardedBackupSpec;
 import io.stackgres.common.crd.sgshardedbackup.StackGresShardedBackupStatus;
 import io.stackgres.common.crd.sgshardedcluster.StackGresShardedCluster;
@@ -146,14 +149,53 @@ public List<HasMetadata> getRequiredResources(StackGresShardedCluster cluster) {
         .isPresent()) {
       String backupName = cluster.getSpec().getInitialData().getRestore()
           .getFromBackup().getName();
-      var sgBackups = backupFinder.findByNameAndNamespace(
-          backupName,
-          clusterNamespace)
+      StackGresShardedBackup restoreBackup = backupFinder
+          .findByNameAndNamespace(backupName, clusterNamespace)
+          .orElseThrow(() -> new IllegalArgumentException(
+              "SGShardedBackup " + backupName + " not found"));
+
+      if (Optional.of(restoreBackup)
+          .map(StackGresShardedBackup::getStatus)
+          .map(StackGresShardedBackupStatus::getProcess)
+          .map(StackGresShardedBackupProcess::getStatus)
+          .map(ShardedBackupStatus.COMPLETED.status()::equals)
+          .map(completed -> !completed)
+          .orElse(true)) {
+        throw new IllegalArgumentException("Cannot restore from SGShardedBackup "
+            + backupName + " because it's not Completed");
+      }
+
+      int clusters = 1 + cluster.getSpec().getShards().getClusters();
+      var sgBackups = Optional.of(restoreBackup)
           .map(StackGresShardedBackup::getStatus)
           .map(StackGresShardedBackupStatus::getSgBackups)
-          .orElseThrow(() -> new IllegalArgumentException(
-              "SGShardedBackup " + backupName + " not found"
-                  + " or SGBackup reference not found in it"));
+          .orElse(null);
+      if (!Optional.ofNullable(sgBackups)
+          .map(list -> list.size() == clusters)
+          .orElse(false)) {
+        throw new IllegalArgumentException(
+            "In SGShardedBackup " + backupName
+            + " sgBackups must be an array of size " + clusters
+            + " (the coordinator plus the number of shards)"
+            + " but was " + Optional.ofNullable(sgBackups)
+            .map(List::size)
+            .orElse(null));
+      }
+
+      String backupMajorVersion = restoreBackup.getStatus()
+          .getBackupInformation().getPostgresVersion().split("\\.")[0];
+      String givenPgVersion = cluster.getSpec()
+          .getPostgres().getVersion();
+      String givenMajorVersion = getPostgresFlavorComponent(cluster)
+          .get(cluster)
+          .getMajorVersion(givenPgVersion);
+
+      if (!backupMajorVersion.equals(givenMajorVersion)) {
+        throw new IllegalArgumentException(
+            "Cannot restore from SGShardedBackup " + backupName
+            + " because it has been created from a postgres instance"
+            + " with version " + backupMajorVersion);
+      }
       if (cluster.getStatus() == null) {
         cluster.setStatus(new StackGresShardedClusterStatus());
       }