Normalização de ofertas de backup criadas antes da 4.20.0.4-scclouds

Author: João Jandre

engine/schema/src/main/java/com/cloud/upgrade/dao/Upgrade42005to42006.java

@@ -20,9 +20,22 @@
 
 import java.io.InputStream;
 import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
 
 public class Upgrade42005to42006 extends DbUpgradeAbstractImpl {
 
+    private static final String SELECT_OFFERING = "SELECT `id` FROM `cloud`.`backup_offering` WHERE `external_id` IS NULL AND `provider`= \"knib\";";
+
+    private static final String SELECT_NATIVE_OFFERING = "SELECT `uuid` FROM `cloud`.`native_backup_offering` WHERE `name` = 'Standard' AND `removed` IS NULL;";
+
+    private static final String UPDATE_OFFERING = "UPDATE `cloud`.`backup_offering` SET `external_id`=\"%s\" WHERE `id` IN (%s);";
+
+    private static final String INSERT_OFFERING = "INSERT INTO `cloud`.`native_backup_offering` (uuid, name, compress, validate, allow_quick_restore, allow_extract_file, created) " +
+            "VALUES (uuid(), 'Standard', false, false, false, false, now());";
+
     @Override
     public String[] getUpgradableVersionRange() {
         return new String[] {"4.20.0.5", "4.20.0.6"};
@@ -51,6 +64,85 @@ public InputStream[] getPrepareScripts() {
 
     @Override
     public void performDataMigration(Connection conn) {
+        normalizeBackupOfferingsIfNeeded(conn);
+    }
+
+    private void normalizeBackupOfferingsIfNeeded(Connection conn) {
+        ArrayList<Long> ids = new ArrayList<>();
+        try (PreparedStatement pstmt = conn.prepareStatement(SELECT_OFFERING)) {
+            ResultSet result = pstmt.executeQuery();
+            while (result.next()) {
+                Long id = result.getLong("id");
+                logger.info("Got backup offering with ID [{}] that has no external_id. Will configure it with the standard offering.", id);
+                ids.add(id);
+            }
+            if (ids.isEmpty()) {
+                logger.debug("Found no backup offerings to normalize.");
+                return;
+            }
+        } catch (SQLException e) {
+            String message = String.format("Unable to retrieve backup offerings due to [%s].", e.getMessage());
+            logger.error(message, e);
+            throw new CloudRuntimeException(message, e);
+        }
+
+        String uuid;
+        try (PreparedStatement pstmt = conn.prepareStatement(SELECT_NATIVE_OFFERING)) {
+            ResultSet result = pstmt.executeQuery();
+            if (!result.next()) {
+                result = createStandardOffering(conn);
+            }
+            uuid = result.getString("uuid");
+        } catch (SQLException e) {
+            String message = String.format("Unable to retrieve Standard native backup offering due to [%s].", e.getMessage());
+            logger.error(message, e);
+            throw new CloudRuntimeException(message, e);
+        }
+
+        StringBuilder stringBuilder = new StringBuilder();
+        for (Long id : ids) {
+            stringBuilder.append(id);
+            stringBuilder.append(",");
+        }
+        stringBuilder.delete((stringBuilder.length() - 1), stringBuilder.length());
+        String update = String.format(UPDATE_OFFERING, uuid, stringBuilder);
+
+        logger.debug("Executing update [{}].", update);
+        try (PreparedStatement pstmt = conn.prepareStatement(update)) {
+            int rows = pstmt.executeUpdate();
+            if (rows != ids.size()) {
+                throw new CloudRuntimeException("We should have updated the same amount of rows as we informed in the id list. Rows:"+rows +"Ids:"+ids.size());
+            }
+        } catch (SQLException e) {
+            String message = String.format("Unable to update backup offerings due to [%s].", e.getMessage());
+            logger.error(message, e);
+            throw new CloudRuntimeException(message, e);
+        }
+    }
+
+    private ResultSet createStandardOffering(Connection conn) {
+        logger.warn("Found backup offerings that are inconsistent, but the Standard native backup offering does not exist. Will create it again.");
+        try (PreparedStatement pstmt = conn.prepareStatement(INSERT_OFFERING)) {
+            pstmt.executeUpdate();
+        } catch (SQLException e) {
+            String message = String.format("Unable to insert native backup offering due to [%s].", e.getMessage());
+            logger.error(message, e);
+            throw new CloudRuntimeException(message, e);
+        }
+
+        try (PreparedStatement pstmt = conn.prepareStatement(SELECT_NATIVE_OFFERING)) {
+            ResultSet resultSet = pstmt.executeQuery();
+            if (!resultSet.next()) {
+                String message = "Unable to find native backup offering that was just inserted.";
+                logger.error(message);
+                throw new CloudRuntimeException(message);
+            }
+            return resultSet;
+        } catch (SQLException e) {
+            String message = String.format("Unable to retrieve native backup offering due to [%s].", e.getMessage());
+            logger.error(message, e);
+            throw new CloudRuntimeException(message, e);
+        }
     }
 
     @Override