SONAR-23213 'api/system/migrate_measures' endpoint

21 files changed, 1411 insertions, 56 deletions

diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/component/BranchDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/component/BranchDao.java
index 9bc71dc3534..402e09abe5f 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/component/BranchDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/component/BranchDao.java
@@ -19,6 +19,7 @@
  */
 package org.sonar.db.component;
 
+import com.google.common.annotations.VisibleForTesting;
 import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
@@ -136,6 +137,24 @@ public class BranchDao implements Dao {
     return mapper(session).countByNeedIssueSync(needIssueSync);
   }
 
+  public List<String> selectUuidsWithMeasuresMigratedFalse(DbSession session, int limit) {
+    return mapper(session).selectUuidsWithMeasuresMigratedFalse(limit);
+  }
+
+  public int countByMeasuresMigratedFalse(DbSession session) {
+    return mapper(session).countByMeasuresMigratedFalse();
+  }
+
+  public long updateMeasuresMigrated(DbSession dbSession, String branchUuid, boolean measuresMigrated) {
+    long now = system2.now();
+    return mapper(dbSession).updateMeasuresMigrated(branchUuid, measuresMigrated, now);
+  }
+
+  @VisibleForTesting
+  boolean isMeasuresMigrated(DbSession dbSession, String uuid) {
+    return mapper(dbSession).isMeasuresMigrated(uuid);
+  }
+
   public int countAll(DbSession session) {
     return mapper(session).countAll();
   }
@@ -178,8 +197,4 @@ public class BranchDao implements Dao {
     return false;
   }
 
-  public long updateMeasuresMigrated(DbSession dbSession, String branchUuid, boolean measuresMigrated) {
-    long now = system2.now();
-    return mapper(dbSession).updateMeasuresMigrated(branchUuid, measuresMigrated, now);
-  }
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/component/BranchMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/component/BranchMapper.java
index 24cdbacc68c..95adbb62244 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/component/BranchMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/component/BranchMapper.java
@@ -73,4 +73,10 @@ public interface BranchMapper {
   short doAnyOfComponentsNeedIssueSync(@Param("componentKeys") List<String> components);
 
   int updateMeasuresMigrated(@Param("uuid") String uuid, @Param("measuresMigrated") boolean measuresMigrated, @Param("now") long now);
+
+  boolean isMeasuresMigrated(String uuid);
+
+  List<String> selectUuidsWithMeasuresMigratedFalse(int limit);
+
+  int countByMeasuresMigratedFalse();
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/portfolio/PortfolioDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/portfolio/PortfolioDao.java
index cbcfd25b3c6..0a6863b6fe6 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/portfolio/PortfolioDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/portfolio/PortfolioDao.java
@@ -19,6 +19,7 @@
  */
 package org.sonar.db.portfolio;
 
+import com.google.common.annotations.VisibleForTesting;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -253,6 +254,24 @@ public class PortfolioDao implements Dao {
     mapper(dbSession).deleteBranch(portfolioUuid, projectUuid, branchUuid);
   }
 
+  public long updateMeasuresMigrated(DbSession dbSession, String branchUuid, boolean measuresMigrated) {
+    long now = system2.now();
+    return mapper(dbSession).updateMeasuresMigrated(branchUuid, measuresMigrated, now);
+  }
+
+  public List<String> selectUuidsWithMeasuresMigratedFalse(DbSession session, int limit) {
+    return mapper(session).selectUuidsWithMeasuresMigratedFalse(limit);
+  }
+
+  public int countByMeasuresMigratedFalse(DbSession session) {
+    return mapper(session).countByMeasuresMigratedFalse();
+  }
+
+  @VisibleForTesting
+  boolean isMeasuresMigrated(DbSession dbSession, String uuid) {
+    return mapper(dbSession).isMeasuresMigrated(uuid);
+  }
+
   /*
    * Utils
    */
@@ -268,8 +287,4 @@ public class PortfolioDao implements Dao {
     return portfolioDto.isRoot() ? Qualifiers.VIEW : Qualifiers.SUBVIEW;
   }
 
-  public long updateMeasuresMigrated(DbSession dbSession, String branchUuid, boolean measuresMigrated) {
-    long now = system2.now();
-    return mapper(dbSession).updateMeasuresMigrated(branchUuid, measuresMigrated, now);
-  }
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/portfolio/PortfolioMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/portfolio/PortfolioMapper.java
index 2e273acc6d7..1dbb66749bb 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/portfolio/PortfolioMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/portfolio/PortfolioMapper.java
@@ -113,4 +113,10 @@ public interface PortfolioMapper {
   List<PortfolioDto> selectRootOfReferencersToAppBranch(@Param("appUuid") String appUuid, @Param("appBranchKey") String appBranchKey);
 
   int updateMeasuresMigrated(@Param("uuid") String uuid, @Param("measuresMigrated") boolean measuresMigrated, @Param("now") long now);
+
+  List<String> selectUuidsWithMeasuresMigratedFalse(int limit);
+
+  int countByMeasuresMigratedFalse();
+
+  boolean isMeasuresMigrated(@Param("uuid") String branchUuid);
 }
diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/component/BranchMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/component/BranchMapper.xml
index eafb0b008cb..238da88d1bd 100644
--- a/server/sonar-db-dao/src/main/resources/org/sonar/db/component/BranchMapper.xml
+++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/component/BranchMapper.xml
@@ -256,4 +256,45 @@
     where
     uuid = #{uuid, jdbcType=VARCHAR}
   </update>
+
+  <select id="isMeasuresMigrated" resultType="boolean">
+    select
+    pb.measures_migrated
+    from project_branches pb
+    where
+    pb.uuid = #{uuid, jdbcType=VARCHAR}
+  </select>
+
+    <select id="selectUuidsWithMeasuresMigratedFalse" resultType="java.lang.String" parameterType="int">
+    SELECT pb.uuid
+    FROM project_branches pb
+    WHERE pb.measures_migrated = ${_false}
+    ORDER BY pb.uuid ASC
+    LIMIT #{limit}
+  </select>
+
+  <select id="selectUuidsWithMeasuresMigratedFalse" resultType="java.lang.String" parameterType="int" databaseId="oracle">
+    SELECT * FROM (
+      SELECT pb.uuid
+      FROM project_branches pb
+      WHERE pb.measures_migrated = ${_false}
+      ORDER BY pb.uuid ASC
+    ) WHERE rownum &lt;= #{limit}
+  </select>
+
+  <select id="selectUuidsWithMeasuresMigratedFalse" resultType="java.lang.String" parameterType="int" databaseId="mssql">
+    SELECT top(#{limit, jdbcType=INTEGER}) pb.uuid
+    FROM project_branches pb
+    WHERE pb.measures_migrated = ${_false}
+    ORDER BY pb.uuid ASC
+  </select>
+
+  <select id="countByMeasuresMigratedFalse" resultType="int">
+    select
+    count(pb.uuid)
+    from project_branches pb
+    where
+    pb.measures_migrated = ${_false}
+  </select>
+
 </mapper>
diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/portfolio/PortfolioMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/portfolio/PortfolioMapper.xml
index 832fc96bb4a..db973bc0b50 100644
--- a/server/sonar-db-dao/src/main/resources/org/sonar/db/portfolio/PortfolioMapper.xml
+++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/portfolio/PortfolioMapper.xml
@@ -544,6 +544,50 @@
     measures_migrated = #{measuresMigrated, jdbcType=BOOLEAN},
     updated_at = #{now, jdbcType=BIGINT}
     where
-    uuid = #{uuid, jdbcType=VARCHAR}
+    root_uuid = #{uuid, jdbcType=VARCHAR}
   </update>
+
+  <select id="selectUuidsWithMeasuresMigratedFalse" resultType="java.lang.String" parameterType="int">
+    SELECT p.uuid
+    FROM portfolios p
+    WHERE p.measures_migrated = ${_false}
+    AND p.parent_uuid is null
+    ORDER BY p.uuid ASC
+    LIMIT #{limit}
+  </select>
+
+  <select id="selectUuidsWithMeasuresMigratedFalse" resultType="java.lang.String" parameterType="int" databaseId="oracle">
+    SELECT * FROM (
+      SELECT p.uuid
+      FROM portfolios p
+      WHERE p.measures_migrated = ${_false}
+      AND p.parent_uuid is null
+      ORDER BY p.uuid ASC
+    ) WHERE rownum &lt;= #{limit}
+  </select>
+
+  <select id="selectUuidsWithMeasuresMigratedFalse" resultType="java.lang.String" parameterType="int" databaseId="mssql">
+    SELECT top(#{limit, jdbcType=INTEGER}) p.uuid
+    FROM portfolios p
+    WHERE p.measures_migrated = ${_false}
+    AND p.parent_uuid is null
+    ORDER BY p.uuid ASC
+  </select>
+
+  <select id="countByMeasuresMigratedFalse" resultType="int">
+    select
+    count(p.uuid)
+    from portfolios p
+    where
+    p.measures_migrated = ${_false}
+    and p.parent_uuid is null
+  </select>
+
+  <select id="isMeasuresMigrated" resultType="boolean">
+    select
+    p.measures_migrated
+    from portfolios p
+    where
+    p.uuid = #{uuid, jdbcType=VARCHAR}
+  </select>
 </mapper>
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/component/BranchDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/component/BranchDaoTest.java
index 8f42fc67056..f11f90f271c 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/component/BranchDaoTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/component/BranchDaoTest.java
@@ -39,13 +39,11 @@ import org.sonar.api.impl.utils.TestSystem2;
 import org.sonar.api.utils.System2;
 import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
-import org.sonar.db.dialect.Oracle;
 import org.sonar.db.metric.MetricDto;
 import org.sonar.db.project.ProjectDto;
 import org.sonar.db.protobuf.DbProjectBranches;
 import org.sonar.server.platform.db.migration.adhoc.AddMeasuresMigratedColumnToProjectBranchesTable;
 
-import static java.lang.String.format;
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
@@ -656,6 +654,70 @@ public class BranchDaoTest {
   }
 
   @Test
+  public void selectUuidsWithMeasuresMigratedFalse() throws SQLException {
+    createMeasuresMigratedColumn();
+
+    // master branch with flag set to false
+    ComponentDto notMigratedProject = db.components().insertPrivateProject();
+    // branches & PRs
+    ComponentDto migratedBranch = db.components().insertProjectBranch(notMigratedProject, b -> b.setBranchType(BRANCH));
+    ComponentDto notMigratedBranch = db.components().insertProjectBranch(notMigratedProject, b -> b.setBranchType(BranchType.BRANCH));
+    ComponentDto migratedPR = db.components().insertProjectBranch(notMigratedProject, b -> b.setBranchType(BranchType.PULL_REQUEST));
+    ComponentDto notMigratedPR = db.components().insertProjectBranch(notMigratedProject, b -> b.setBranchType(PULL_REQUEST));
+
+    db.getDbClient().branchDao().updateMeasuresMigrated(dbSession, migratedBranch.branchUuid(), true);
+    db.getDbClient().branchDao().updateMeasuresMigrated(dbSession, notMigratedBranch.branchUuid(), false);
+    db.getDbClient().branchDao().updateMeasuresMigrated(dbSession, migratedPR.branchUuid(), true);
+
+    assertThat(underTest.selectUuidsWithMeasuresMigratedFalse(dbSession, 10))
+      .hasSize(3)
+      .containsOnly(notMigratedProject.branchUuid(), notMigratedBranch.branchUuid(), notMigratedPR.branchUuid());
+
+    assertThat(underTest.selectUuidsWithMeasuresMigratedFalse(dbSession, 1))
+      .hasSize(1)
+      .containsOnly(notMigratedProject.branchUuid());
+  }
+
+  @Test
+  public void countByMeasuresMigratedFalse() throws SQLException {
+    createMeasuresMigratedColumn();
+
+    // master branch with flag set to false
+    ComponentDto project = db.components().insertPrivateProject();
+    // branches & PRs
+    ComponentDto branch1 = db.components().insertProjectBranch(project, b -> b.setBranchType(BRANCH));
+    ComponentDto branch2 = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.BRANCH));
+    ComponentDto branch3 = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.PULL_REQUEST));
+    db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.PULL_REQUEST));
+
+    db.getDbClient().branchDao().updateMeasuresMigrated(dbSession, branch1.branchUuid(), true);
+    db.getDbClient().branchDao().updateMeasuresMigrated(dbSession, branch2.branchUuid(), false);
+    db.getDbClient().branchDao().updateMeasuresMigrated(dbSession, branch3.branchUuid(), true);
+
+    assertThat(underTest.countByMeasuresMigratedFalse(dbSession)).isEqualTo(3);
+  }
+
+  @Test
+  public void updateMeasuresMigrated() throws SQLException {
+    createMeasuresMigratedColumn();
+
+    ComponentDto project = db.components().insertPrivateProject();
+    String uuid1 = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.BRANCH)).uuid();
+    String uuid2 = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.BRANCH)).uuid();
+
+    underTest.updateMeasuresMigrated(dbSession, uuid1, true);
+    underTest.updateMeasuresMigrated(dbSession, uuid2, false);
+
+    assertThat(underTest.isMeasuresMigrated(dbSession, uuid1)).isTrue();
+    assertThat(underTest.isMeasuresMigrated(dbSession, uuid2)).isFalse();
+  }
+
+  private void createMeasuresMigratedColumn() throws SQLException {
+    AddMeasuresMigratedColumnToProjectBranchesTable migration = new AddMeasuresMigratedColumnToProjectBranchesTable(db.getDbClient().getDatabase());
+    migration.execute();
+  }
+
+  @Test
   public void countAll() {
     assertThat(underTest.countAll(dbSession)).isZero();
 
@@ -780,31 +842,4 @@ public class BranchDaoTest {
 
     assertThat(underTest.doAnyOfComponentsNeedIssueSync(dbSession, componentKeys)).isTrue();
   }
-
-  @Test
-  public void updateMeasuresMigrated() throws SQLException {
-    new AddMeasuresMigratedColumnToProjectBranchesTable(db.getDbClient().getDatabase()).execute();
-
-    ComponentDto project = db.components().insertPrivateProject();
-    String uuid1 = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.BRANCH)).uuid();
-    String uuid2 = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.BRANCH)).uuid();
-
-    underTest.updateMeasuresMigrated(dbSession, uuid1, true);
-    underTest.updateMeasuresMigrated(dbSession, uuid2, false);
-
-    assertThat(getMeasuresMigrated(uuid1)).isTrue();
-    assertThat(getMeasuresMigrated(uuid2)).isFalse();
-  }
-
-  private boolean getMeasuresMigrated(String uuid1) {
-    List<Map<String, Object>> select = db.select(dbSession,
-      format("select measures_migrated as \"MIGRATED\" from project_branches where uuid = '%s'", uuid1));
-
-    assertThat(select).hasSize(1);
-    Object value = select.get(0).get("MIGRATED");
-    if (db.getDbClient().getDatabase().getDialect().getId().equals(Oracle.ID)) {
-      return (long) value == 1;
-    }
-    return (boolean) value;
-  }
 }
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/portfolio/PortfolioDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/portfolio/PortfolioDaoTest.java
index ae12b1b059d..9ea18c73c0e 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/portfolio/PortfolioDaoTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/portfolio/PortfolioDaoTest.java
@@ -20,8 +20,6 @@
 package org.sonar.db.portfolio;
 
 import java.sql.SQLException;
-import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import org.junit.Rule;
 import org.junit.Test;
@@ -32,12 +30,10 @@ import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
 import org.sonar.db.audit.AuditPersister;
 import org.sonar.db.component.BranchDto;
-import org.sonar.db.dialect.Oracle;
 import org.sonar.db.project.ApplicationProjectDto;
 import org.sonar.db.project.ProjectDto;
 import org.sonar.server.platform.db.migration.adhoc.AddMeasuresMigratedColumnToPortfoliosTable;
 
-import static java.lang.String.format;
 import static java.util.Collections.emptySet;
 import static java.util.Collections.singleton;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -715,20 +711,76 @@ public class PortfolioDaoTest {
     portfolioDao.updateMeasuresMigrated(session, portfolio1.getUuid(), true);
     portfolioDao.updateMeasuresMigrated(session, portfolio2.getUuid(), false);
 
-    assertThat(getMeasuresMigrated(portfolio1.getUuid())).isTrue();
-    assertThat(getMeasuresMigrated(portfolio2.getUuid())).isFalse();
+    assertThat(portfolioDao.isMeasuresMigrated(session, portfolio1.getUuid())).isTrue();
+    assertThat(portfolioDao.isMeasuresMigrated(session, portfolio2.getUuid())).isFalse();
   }
 
-  private boolean getMeasuresMigrated(String uuid1) {
-    List<Map<String, Object>> select = db.select(session,
-      format("select measures_migrated as \"MIGRATED\" from portfolios where uuid = '%s'", uuid1));
+  @Test
+  public void selectUuidsWithMeasuresMigratedFalse() throws SQLException {
+    createMeasuresMigratedColumn();
+
+    PortfolioDto migratedRoot = db.components().insertPrivatePortfolioDto();
+    PortfolioDto migratedChild1 = addPortfolio(migratedRoot);
+    PortfolioDto notMigratedRoot = db.components().insertPrivatePortfolioDto();
+    PortfolioDto notMigratedChild = addPortfolio(notMigratedRoot);
+    PortfolioDto notMigratedRoot2 = db.components().insertPrivatePortfolioDto();
+
+    // a parent portfolio and its children are expected to have the same migration status
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, migratedRoot.getUuid(), true);
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, migratedChild1.getUuid(), true);
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, notMigratedRoot.getUuid(), false);
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, notMigratedChild.getUuid(), false);
+
+    assertThat(portfolioDao.selectUuidsWithMeasuresMigratedFalse(session, 10))
+      .hasSize(2)
+      .containsOnly(notMigratedRoot.getUuid(), notMigratedRoot2.getUuid());
+
+    assertThat(portfolioDao.selectUuidsWithMeasuresMigratedFalse(session, 1))
+      .hasSize(1)
+      .containsOnly(notMigratedRoot.getUuid());
+  }
+
+  @Test
+  public void countByMeasuresMigratedFalse() throws SQLException {
+    createMeasuresMigratedColumn();
+
+    PortfolioDto root = db.components().insertPrivatePortfolioDto();
+    PortfolioDto child1 = addPortfolio(root);
+    PortfolioDto root2 = db.components().insertPrivatePortfolioDto();
+    PortfolioDto child2 = addPortfolio(root2);
+    PortfolioDto root3 = db.components().insertPrivatePortfolioDto();
+    db.components().insertPrivatePortfolioDto();
+
+    // a parent portfolio and its children are expected to have the same migration status
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, root.getUuid(), true);
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, child1.getUuid(), true);
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, root2.getUuid(), false);
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, child2.getUuid(), false);
+    db.getDbClient().portfolioDao().updateMeasuresMigrated(session, root3.getUuid(), false);
+
+    assertThat(portfolioDao.countByMeasuresMigratedFalse(session)).isEqualTo(3);
+  }
+
+  @Test
+  public void updateMeasuresMigrated() throws SQLException {
+    createMeasuresMigratedColumn();
+
+    PortfolioDto portfolio1 = db.components().insertPrivatePortfolioDto("name1");
+    PortfolioDto portfolio2 = db.components().insertPrivatePortfolioDto("name2");
+    PortfolioDto portfolio3 = db.components().insertPrivatePortfolioDto("name3",
+      p -> p.setRootUuid(portfolio1.getUuid()).setParentUuid(portfolio1.getUuid()));
+
+    portfolioDao.updateMeasuresMigrated(session, portfolio1.getUuid(), true);
+    portfolioDao.updateMeasuresMigrated(session, portfolio2.getUuid(), false);
+
+    assertThat(portfolioDao.isMeasuresMigrated(session, portfolio1.getUuid())).isTrue();
+    assertThat(portfolioDao.isMeasuresMigrated(session, portfolio2.getUuid())).isFalse();
+    assertThat(portfolioDao.isMeasuresMigrated(session, portfolio3.getUuid())).isTrue();
+  }
 
-    assertThat(select).hasSize(1);
-    Object value = select.get(0).get("MIGRATED");
-    if (db.getDbClient().getDatabase().getDialect().getId().equals(Oracle.ID)) {
-      return (long) value == 1;
-    }
-    return (boolean) value;
+  private void createMeasuresMigratedColumn() throws SQLException {
+    AddMeasuresMigratedColumnToPortfoliosTable migration = new AddMeasuresMigratedColumnToPortfoliosTable(db.getDbClient().getDatabase());
+    migration.execute();
   }
 
   private PortfolioDto addPortfolio(PortfolioDto parent) {
diff --git a/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/AbstractMigrateLiveMeasuresToMeasures.java b/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/AbstractMigrateLiveMeasuresToMeasures.java
new file mode 100644
index 00000000000..5135d7aa859
--- /dev/null
+++ b/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/AbstractMigrateLiveMeasuresToMeasures.java
@@ -0,0 +1,196 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.adhoc;
+
+import com.google.gson.Gson;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+import org.apache.commons.codec.digest.MurmurHash3;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sonar.api.utils.System2;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.step.DataChange;
+import org.sonar.server.platform.db.migration.step.MassUpdate;
+import org.sonar.server.platform.db.migration.step.Select;
+import org.sonar.server.platform.db.migration.step.SqlStatement;
+import org.sonar.server.platform.db.migration.step.Upsert;
+
+import static java.lang.String.format;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+public abstract class AbstractMigrateLiveMeasuresToMeasures extends DataChange {
+  private static final Logger LOGGER = LoggerFactory.getLogger(AbstractMigrateLiveMeasuresToMeasures.class);
+
+  private static final Set<String> TEXT_VALUE_TYPES = Set.of("STRING", "LEVEL", "DATA", "DISTRIB");
+  private static final Gson GSON = new Gson();
+
+  private static final String SELECT_QUERY = """
+    SELECT lm.component_uuid,
+      m.name,
+      m.val_type,
+      lm.value,
+      lm.text_value,
+      lm.measure_data
+    FROM live_measures lm
+    INNER JOIN metrics m ON m.uuid = lm.metric_uuid
+    WHERE lm.project_uuid = ?
+    ORDER BY lm.component_uuid
+    """;
+
+  private static final String INSERT_QUERY = """
+    insert into measures (component_uuid, branch_uuid, json_value, json_value_hash, created_at, updated_at)
+    values ( ?, ?, ?, ?, ?, ?)
+    """;
+
+  private final String tableName;
+  private final String item;
+  private final System2 system2;
+  private List<String> uuids = List.of();
+  private int migrated = 0;
+
+  protected AbstractMigrateLiveMeasuresToMeasures(Database db, System2 system2, String tableName, String item) {
+    super(db);
+    this.system2 = system2;
+    this.tableName = tableName;
+    this.item = item;
+  }
+
+  private String getUpdateFlagQuery() {
+    return format("""
+    UPDATE %s
+    SET measures_migrated = ?
+    WHERE uuid = ?
+    """, tableName);
+  }
+
+  // This is a special entry point for the case of a configurable migration
+  public final void migrate(List<String> uuids) throws SQLException {
+    try (Connection readConnection = createDdlConnection();
+         Connection writeConnection = createDdlConnection()) {
+      Context context = new Context(db, readConnection, writeConnection);
+      this.uuids = uuids;
+      execute(context);
+    }
+  }
+
+  @Override
+  protected void execute(Context context) throws SQLException {
+    LOGGER.info("Starting the migration of {} {}s", uuids.size(), item);
+
+    for (String uuid : uuids) {
+      migrateItem(uuid, context);
+
+      migrated++;
+      if (migrated % 100 == 0) {
+        LOGGER.info("{} {}s migrated", migrated, item);
+      }
+    }
+    LOGGER.info("Finished migration of {} {}s", uuids.size(), item);
+  }
+
+  private void migrateItem(String uuid, Context context) throws SQLException {
+    LOGGER.debug("Migrating {} {}...", item, uuid);
+
+    Map<String, Object> measureValues = new HashMap<>();
+    AtomicReference<String> componentUuid = new AtomicReference<>(null);
+
+    MassUpdate massUpdate = context.prepareMassUpdate();
+    massUpdate.select(SELECT_QUERY).setString(1, uuid);
+    massUpdate.update(INSERT_QUERY);
+    massUpdate.execute((row, update) -> {
+      boolean shouldUpdate = false;
+      String rowComponentUuid = row.getString(1);
+      if (componentUuid.get() == null || !rowComponentUuid.equals(componentUuid.get())) {
+        if (!measureValues.isEmpty()) {
+          preparePersistMeasure(uuid, update, componentUuid, measureValues);
+          shouldUpdate = true;
+        }
+
+        LOGGER.debug("Starting processing of component {}...", rowComponentUuid);
+        componentUuid.set(rowComponentUuid);
+        measureValues.clear();
+        readMeasureValue(row, measureValues);
+      } else {
+        readMeasureValue(row, measureValues);
+      }
+      return shouldUpdate;
+    });
+    // insert the last component
+    if (!measureValues.isEmpty()) {
+      Upsert measureInsert = context.prepareUpsert(INSERT_QUERY);
+      preparePersistMeasure(uuid, measureInsert, componentUuid, measureValues);
+      measureInsert
+        .execute()
+        .commit();
+    }
+
+    LOGGER.debug("Flagging migration done for {} {}...", item, uuid);
+
+    context.prepareUpsert(getUpdateFlagQuery())
+      .setBoolean(1, true)
+      .setString(2, uuid)
+      .execute()
+      .commit();
+
+    LOGGER.debug("Migration finished for {} {}", item, uuid);
+  }
+
+  private void preparePersistMeasure(String uuid, SqlStatement<?> update, AtomicReference<String> componentUuid, Map<String, Object> measureValues) throws SQLException {
+    LOGGER.debug("Persisting measures for component {}...", componentUuid.get());
+    String jsonValue = GSON.toJson(measureValues);
+
+    long jsonHash = MurmurHash3.hash128(jsonValue.getBytes(UTF_8))[0];
+
+    update.setString(1, componentUuid.get());
+    update.setString(2, uuid);
+    update.setString(3, jsonValue);
+    update.setLong(4, jsonHash);
+    update.setLong(5, system2.now());
+    update.setLong(6, system2.now());
+  }
+
+  private static void readMeasureValue(Select.Row row, Map<String, Object> measureValues) throws SQLException {
+    String metricName = row.getString(2);
+    String valueType = row.getString(3);
+    Double numericValue = row.getDouble(4);
+    String textValue = row.getString(5);
+    byte[] data = row.getBytes(6);
+
+    Object metricValue = getMetricValue(data, textValue, valueType, numericValue);
+    if (metricValue != null) {
+      measureValues.put(metricName, metricValue);
+    }
+  }
+
+  private static Object getMetricValue(@Nullable byte[] data, @Nullable String textValue, String valueType, Double numericValue) {
+    return TEXT_VALUE_TYPES.contains(valueType) ? getTextValue(data, textValue) : numericValue;
+  }
+
+  private static String getTextValue(@Nullable byte[] data, @Nullable String textValue) {
+    return data != null ? new String(data, UTF_8) : textValue;
+  }
+}
diff --git a/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasures.java b/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasures.java
new file mode 100644
index 00000000000..3138470dcb2
--- /dev/null
+++ b/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasures.java
@@ -0,0 +1,30 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.adhoc;
+
+import org.sonar.api.utils.System2;
+import org.sonar.db.Database;
+
+public class MigrateBranchesLiveMeasuresToMeasures extends AbstractMigrateLiveMeasuresToMeasures {
+
+  public MigrateBranchesLiveMeasuresToMeasures(Database db, System2 system2) {
+    super(db, system2, "project_branches", "branch");
+  }
+}
diff --git a/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasures.java b/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasures.java
new file mode 100644
index 00000000000..7ce171755f2
--- /dev/null
+++ b/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasures.java
@@ -0,0 +1,30 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.adhoc;
+
+import org.sonar.api.utils.System2;
+import org.sonar.db.Database;
+
+public class MigratePortfoliosLiveMeasuresToMeasures extends AbstractMigrateLiveMeasuresToMeasures {
+
+  protected MigratePortfoliosLiveMeasuresToMeasures(Database db, System2 system2) {
+    super(db, system2, "portfolios", "portfolio");
+  }
+}
diff --git a/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/step/DataChange.java b/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/step/DataChange.java
index 01380acffc0..216ba7a2cb0 100644
--- a/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/step/DataChange.java
+++ b/server/sonar-db-migration/src/main/java/org/sonar/server/platform/db/migration/step/DataChange.java
@@ -26,7 +26,7 @@ import org.sonar.db.dialect.Dialect;
 
 public abstract class DataChange implements MigrationStep {
 
-  private final Database db;
+  protected final Database db;
 
   public DataChange(Database db) {
     this.db = db;
@@ -56,7 +56,7 @@ public abstract class DataChange implements MigrationStep {
     return connection;
   }
 
-  private Connection createDdlConnection() throws SQLException {
+  protected Connection createDdlConnection() throws SQLException {
     Connection res = db.getDataSource().getConnection();
     res.setAutoCommit(false);
     return res;
diff --git a/server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasuresTest.java b/server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasuresTest.java
new file mode 100644
index 00000000000..b7a251c6ce6
--- /dev/null
+++ b/server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasuresTest.java
@@ -0,0 +1,180 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.adhoc;
+
+import java.nio.charset.StandardCharsets;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.api.utils.System2;
+import org.sonar.core.util.SequenceUuidFactory;
+import org.sonar.db.CoreDbTester;
+
+import static java.lang.String.format;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.mockito.Mockito.mock;
+
+public class MigrateBranchesLiveMeasuresToMeasuresTest {
+
+  private static final String MEASURES_MIGRATED_COLUMN = "measures_migrated";
+  public static final String SELECT_MEASURE = """
+    select component_uuid as "COMPONENT_UUID",
+    branch_uuid as "BRANCH_UUID",
+    json_value as "JSON_VALUE",
+    json_value_hash as "JSON_VALUE_HASH",
+    created_at as "CREATED_AT",
+    updated_at as "UPDATED_AT",
+    from measures
+    where component_uuid = '%s'""";
+
+  @Rule
+  public final CoreDbTester db = CoreDbTester.createForSchema(MigrateBranchesLiveMeasuresToMeasuresTest.class, "schema.sql");
+
+  private final SequenceUuidFactory uuidFactory = new SequenceUuidFactory();
+  private final System2 system2 = mock();
+  private final MigrateBranchesLiveMeasuresToMeasures underTest = new MigrateBranchesLiveMeasuresToMeasures(db.database(), system2);
+
+  @Test
+  public void shall_do_nothing_when_called_by_execute() {
+    assertThatCode(underTest::execute)
+      .doesNotThrowAnyException();
+
+    assertThat(db.countRowsOfTable("measures")).isZero();
+  }
+
+  @Test
+  public void shall_complete_when_tables_are_empty() throws SQLException {
+    underTest.migrate(List.of("unused"));
+
+    assertThat(db.countRowsOfTable("measures")).isZero();
+  }
+
+  @Test
+  public void should_flag_branch_with_no_measures() throws SQLException {
+    String branch = "branch_3";
+    insertNotMigratedBranch(branch);
+
+    underTest.migrate(List.of(branch));
+
+    assertBranchMigrated(branch);
+    assertThat(db.countRowsOfTable("measures")).isZero();
+  }
+
+  @Test
+  public void should_migrate_branch_with_measures() throws SQLException {
+    String nclocMetricUuid = insertMetric("ncloc", "INT");
+    String qgStatusMetricUuid = insertMetric("quality_gate_status", "STRING");
+    String metricWithDataUuid = insertMetric("metric_with_data", "DATA");
+
+    String branch1 = "branch_4";
+    insertNotMigratedBranch(branch1);
+    String component1 = uuidFactory.create();
+    String component2 = uuidFactory.create();
+    insertMeasure(branch1, component1, nclocMetricUuid, Map.of("value", 120));
+    insertMeasure(branch1, component1, qgStatusMetricUuid, Map.of("text_value", "ok"));
+    insertMeasure(branch1, component2, metricWithDataUuid, Map.of("measure_data", "some data".getBytes(StandardCharsets.UTF_8)));
+
+    String branch2 = "branch_5";
+    insertNotMigratedBranch(branch2);
+    insertMeasure(branch2, nclocMetricUuid, Map.of("value", 64));
+
+    String unusedBranch = "branch_6";
+    insertNotMigratedBranch(unusedBranch);
+    insertMeasure(unusedBranch, nclocMetricUuid, Map.of("value", 3684));
+
+    underTest.migrate(List.of(branch1, branch2));
+
+    assertBranchMigrated(branch1);
+    assertBranchMigrated(branch2);
+    assertBranchNotMigrated(unusedBranch);
+    assertThat(db.countRowsOfTable("measures")).isEqualTo(3);
+
+    assertThat(db.select(format(SELECT_MEASURE, component1)))
+      .hasSize(1)
+      .extracting(t -> t.get("COMPONENT_UUID"), t -> t.get("BRANCH_UUID"), t -> t.get("JSON_VALUE"), t -> t.get("JSON_VALUE_HASH"))
+      .containsOnly(tuple(component1, branch1, "{\"ncloc\":120.0,\"quality_gate_status\":\"ok\"}", 6033012287291512746L));
+
+    assertThat(db.select(format(SELECT_MEASURE, component2)))
+      .hasSize(1)
+      .extracting(t -> t.get("COMPONENT_UUID"), t -> t.get("BRANCH_UUID"), t -> t.get("JSON_VALUE"), t -> t.get("JSON_VALUE_HASH"))
+      .containsOnly(tuple(component2, branch1, "{\"metric_with_data\":\"some data\"}", -4524184678167636687L));
+  }
+
+  private void assertBranchMigrated(String branch) {
+    assertMigrationStatus(branch, true);
+  }
+
+  private void assertBranchNotMigrated(String branch) {
+    assertMigrationStatus(branch, false);
+  }
+
+  private void assertMigrationStatus(String branch, boolean expected) {
+    List<Map<String, Object>> result = db.select(format("select %s as \"MIGRATED\" from project_branches where uuid = '%s'", MEASURES_MIGRATED_COLUMN, branch));
+    assertThat(result)
+      .hasSize(1)
+      .extracting(t -> t.get("MIGRATED"))
+      .containsOnly(expected);
+  }
+
+  private String insertMetric(String metricName, String valueType) {
+    String metricUuid = uuidFactory.create();
+    db.executeInsert("metrics",
+      "uuid", metricUuid,
+      "name", metricName,
+      "val_type", valueType);
+    return metricUuid;
+  }
+
+  private void insertMeasure(String branchUuid, String metricUuid, Map<String, Object> data) {
+    insertMeasure(branchUuid, uuidFactory.create(), metricUuid, data);
+  }
+
+  private void insertMeasure(String branchUuid, String componentUuid, String metricUuid, Map<String, Object> data) {
+    Map<String, Object> dataMap = new HashMap<>(data);
+    dataMap.put("uuid", uuidFactory.create());
+    dataMap.put("component_uuid", componentUuid);
+    dataMap.put("project_uuid", branchUuid);
+    dataMap.put("metric_uuid", metricUuid);
+    dataMap.put("created_at", 12L);
+    dataMap.put("updated_at", 12L);
+
+    db.executeInsert("live_measures", dataMap);
+  }
+
+  private void insertNotMigratedBranch(String branchUuid) {
+    db.executeInsert("project_branches",
+      "uuid", branchUuid,
+      "kee", branchUuid,
+      "branch_type", "LONG",
+      "project_uuid", uuidFactory.create(),
+      MEASURES_MIGRATED_COLUMN, false,
+      "need_issue_sync", false,
+      "created_at", 12L,
+      "updated_at", 12L
+    );
+  }
+
+
+}
diff --git a/server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasuresTest.java b/server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasuresTest.java
new file mode 100644
index 00000000000..dd76bd3d735
--- /dev/null
+++ b/server/sonar-db-migration/src/test/java/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasuresTest.java
@@ -0,0 +1,178 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.db.migration.adhoc;
+
+import java.nio.charset.StandardCharsets;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.api.utils.System2;
+import org.sonar.core.util.SequenceUuidFactory;
+import org.sonar.db.CoreDbTester;
+
+import static java.lang.String.format;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.mockito.Mockito.mock;
+
+public class MigratePortfoliosLiveMeasuresToMeasuresTest {
+
+  private static final String MEASURES_MIGRATED_COLUMN = "measures_migrated";
+  public static final String SELECT_MEASURE = """
+    select component_uuid as "COMPONENT_UUID",
+    branch_uuid as "BRANCH_UUID",
+    json_value as "JSON_VALUE",
+    json_value_hash as "JSON_VALUE_HASH",
+    created_at as "CREATED_AT",
+    updated_at as "UPDATED_AT",
+    from measures where component_uuid = '%s'""";
+
+  @Rule
+  public final CoreDbTester db = CoreDbTester.createForSchema(MigratePortfoliosLiveMeasuresToMeasuresTest.class, "schema.sql");
+
+  private final SequenceUuidFactory uuidFactory = new SequenceUuidFactory();
+  private final System2 system2 = mock();
+  private final MigratePortfoliosLiveMeasuresToMeasures underTest = new MigratePortfoliosLiveMeasuresToMeasures(db.database(), system2);
+
+  @Test
+  public void shall_do_nothing_when_called_by_execute() {
+    assertThatCode(underTest::execute)
+      .doesNotThrowAnyException();
+
+    assertThat(db.countRowsOfTable("measures")).isZero();
+  }
+
+  @Test
+  public void shall_complete_when_tables_are_empty() throws SQLException {
+    underTest.migrate(List.of("unused"));
+
+    assertThat(db.countRowsOfTable("measures")).isZero();
+  }
+
+  @Test
+  public void should_flag_portfolio_with_no_measures() throws SQLException {
+    String portfolio = "portfolio_3";
+    insertNotMigratedPortfolio(portfolio);
+
+    underTest.migrate(List.of(portfolio));
+
+    assertPortfolioMigrated(portfolio);
+    assertThat(db.countRowsOfTable("measures")).isZero();
+  }
+
+  @Test
+  public void should_migrate_portfolio_with_measures() throws SQLException {
+    String nclocMetricUuid = insertMetric("ncloc", "INT");
+    String qgStatusMetricUuid = insertMetric("quality_gate_status", "STRING");
+    String metricWithDataUuid = insertMetric("metric_with_data", "DATA");
+
+    String portfolio1 = "portfolio_4";
+    insertNotMigratedPortfolio(portfolio1);
+    String component1 = uuidFactory.create();
+    String component2 = uuidFactory.create();
+    insertMeasure(portfolio1, component1, nclocMetricUuid, Map.of("value", 120));
+    insertMeasure(portfolio1, component1, qgStatusMetricUuid, Map.of("text_value", "ok"));
+    insertMeasure(portfolio1, component2, metricWithDataUuid, Map.of("measure_data", "some data".getBytes(StandardCharsets.UTF_8)));
+
+    String portfolio2 = "portfolio_5";
+    insertNotMigratedPortfolio(portfolio2);
+    insertMeasure(portfolio2, nclocMetricUuid, Map.of("value", 64));
+
+    String unusedPortfolio = "portfolio_6";
+    insertNotMigratedPortfolio(unusedPortfolio);
+    insertMeasure(unusedPortfolio, nclocMetricUuid, Map.of("value", 3684));
+
+    underTest.migrate(List.of(portfolio1, portfolio2));
+
+    assertPortfolioMigrated(portfolio1);
+    assertPortfolioMigrated(portfolio2);
+    assertPortfolioNotMigrated(unusedPortfolio);
+    assertThat(db.countRowsOfTable("measures")).isEqualTo(3);
+
+    assertThat(db.select(format(SELECT_MEASURE, component1)))
+      .hasSize(1)
+      .extracting(t -> t.get("COMPONENT_UUID"), t -> t.get("BRANCH_UUID"), t -> t.get("JSON_VALUE"), t -> t.get("JSON_VALUE_HASH"))
+      .containsOnly(tuple(component1, portfolio1, "{\"ncloc\":120.0,\"quality_gate_status\":\"ok\"}", 6033012287291512746L));
+
+    assertThat(db.select(format(SELECT_MEASURE, component2)))
+      .hasSize(1)
+      .extracting(t -> t.get("COMPONENT_UUID"), t -> t.get("BRANCH_UUID"), t -> t.get("JSON_VALUE"), t -> t.get("JSON_VALUE_HASH"))
+      .containsOnly(tuple(component2, portfolio1, "{\"metric_with_data\":\"some data\"}", -4524184678167636687L));
+  }
+
+  private void assertPortfolioMigrated(String portfolio) {
+    assertMigrationStatus(portfolio, true);
+  }
+
+  private void assertPortfolioNotMigrated(String portfolio) {
+    assertMigrationStatus(portfolio, false);
+  }
+
+  private void assertMigrationStatus(String portfolio, boolean expected) {
+    List<Map<String, Object>> result = db.select(format("select %s as \"MIGRATED\" from portfolios where uuid = '%s'", MEASURES_MIGRATED_COLUMN, portfolio));
+    assertThat(result)
+      .hasSize(1)
+      .extracting(t -> t.get("MIGRATED"))
+      .containsOnly(expected);
+  }
+
+  private String insertMetric(String metricName, String valueType) {
+    String metricUuid = uuidFactory.create();
+    db.executeInsert("metrics",
+      "uuid", metricUuid,
+      "name", metricName,
+      "val_type", valueType);
+    return metricUuid;
+  }
+
+  private void insertMeasure(String portfolioUuid, String metricUuid, Map<String, Object> data) {
+    insertMeasure(portfolioUuid, uuidFactory.create(), metricUuid, data);
+  }
+
+  private void insertMeasure(String portfolioUuid, String componentUuid, String metricUuid, Map<String, Object> data) {
+    Map<String, Object> dataMap = new HashMap<>(data);
+    dataMap.put("uuid", uuidFactory.create());
+    dataMap.put("component_uuid", componentUuid);
+    dataMap.put("project_uuid", portfolioUuid);
+    dataMap.put("metric_uuid", metricUuid);
+    dataMap.put("created_at", 12L);
+    dataMap.put("updated_at", 12L);
+
+    db.executeInsert("live_measures", dataMap);
+  }
+
+  private void insertNotMigratedPortfolio(String portfolioUuid) {
+    db.executeInsert("portfolios",
+      "uuid", portfolioUuid,
+      "kee", portfolioUuid,
+      "name", portfolioUuid,
+      "private", true,
+      "root_uuid", portfolioUuid,
+      "selection_mode", "MANUAL",
+      MEASURES_MIGRATED_COLUMN, false,
+      "created_at", 12L,
+      "updated_at", 12L
+    );
+  }
+}
diff --git a/server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasuresTest/schema.sql b/server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasuresTest/schema.sql
new file mode 100644
index 00000000000..4d3f9e76ad5
--- /dev/null
+++ b/server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/adhoc/MigrateBranchesLiveMeasuresToMeasuresTest/schema.sql
@@ -0,0 +1,63 @@
+CREATE TABLE "PROJECT_BRANCHES"(
+    "UUID" CHARACTER VARYING(50) NOT NULL,
+    "PROJECT_UUID" CHARACTER VARYING(50) NOT NULL,
+    "KEE" CHARACTER VARYING(255) NOT NULL,
+    "BRANCH_TYPE" CHARACTER VARYING(12) NOT NULL,
+    "MERGE_BRANCH_UUID" CHARACTER VARYING(50),
+    "PULL_REQUEST_BINARY" BINARY LARGE OBJECT,
+    "MANUAL_BASELINE_ANALYSIS_UUID" CHARACTER VARYING(40),
+    "CREATED_AT" BIGINT NOT NULL,
+    "UPDATED_AT" BIGINT NOT NULL,
+    "EXCLUDE_FROM_PURGE" BOOLEAN DEFAULT FALSE NOT NULL,
+    "NEED_ISSUE_SYNC" BOOLEAN NOT NULL,
+    "MEASURES_MIGRATED" BOOLEAN DEFAULT FALSE NOT NULL
+);
+ALTER TABLE "PROJECT_BRANCHES" ADD CONSTRAINT "PK_PROJECT_BRANCHES" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "UNIQ_PROJECT_BRANCHES" ON "PROJECT_BRANCHES"("BRANCH_TYPE" NULLS FIRST, "PROJECT_UUID" NULLS FIRST, "KEE" NULLS FIRST);
+
+CREATE TABLE "METRICS"(
+    "UUID" CHARACTER VARYING(40) NOT NULL,
+    "NAME" CHARACTER VARYING(64) NOT NULL,
+    "DESCRIPTION" CHARACTER VARYING(255),
+    "DIRECTION" INTEGER DEFAULT 0 NOT NULL,
+    "DOMAIN" CHARACTER VARYING(64),
+    "SHORT_NAME" CHARACTER VARYING(64),
+    "QUALITATIVE" BOOLEAN DEFAULT FALSE NOT NULL,
+    "VAL_TYPE" CHARACTER VARYING(8),
+    "ENABLED" BOOLEAN DEFAULT TRUE,
+    "WORST_VALUE" DOUBLE PRECISION,
+    "BEST_VALUE" DOUBLE PRECISION,
+    "OPTIMIZED_BEST_VALUE" BOOLEAN,
+    "HIDDEN" BOOLEAN,
+    "DELETE_HISTORICAL_DATA" BOOLEAN,
+    "DECIMAL_SCALE" INTEGER
+);
+ALTER TABLE "METRICS" ADD CONSTRAINT "PK_METRICS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "METRICS_UNIQUE_NAME" ON "METRICS"("NAME" NULLS FIRST);
+
+CREATE TABLE "LIVE_MEASURES"(
+    "UUID" CHARACTER VARYING(40) NOT NULL,
+    "PROJECT_UUID" CHARACTER VARYING(50) NOT NULL,
+    "COMPONENT_UUID" CHARACTER VARYING(50) NOT NULL,
+    "METRIC_UUID" CHARACTER VARYING(40) NOT NULL,
+    "VALUE" DOUBLE PRECISION,
+    "TEXT_VALUE" CHARACTER VARYING(4000),
+    "MEASURE_DATA" BINARY LARGE OBJECT,
+    "UPDATE_MARKER" CHARACTER VARYING(40),
+    "CREATED_AT" BIGINT NOT NULL,
+    "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "LIVE_MEASURES" ADD CONSTRAINT "PK_LIVE_MEASURES" PRIMARY KEY("UUID");
+CREATE INDEX "LIVE_MEASURES_PROJECT" ON "LIVE_MEASURES"("PROJECT_UUID" NULLS FIRST);
+CREATE UNIQUE INDEX "LIVE_MEASURES_COMPONENT" ON "LIVE_MEASURES"("COMPONENT_UUID" NULLS FIRST, "METRIC_UUID" NULLS FIRST);
+
+CREATE TABLE "MEASURES"(
+    "COMPONENT_UUID" CHARACTER VARYING(40) NOT NULL,
+    "BRANCH_UUID" CHARACTER VARYING(40) NOT NULL,
+    "JSON_VALUE" CHARACTER LARGE OBJECT NOT NULL,
+    "JSON_VALUE_HASH" BIGINT NOT NULL,
+    "CREATED_AT" BIGINT NOT NULL,
+    "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "MEASURES" ADD CONSTRAINT "PK_MEASURES" PRIMARY KEY("COMPONENT_UUID");
+CREATE INDEX "MEASURES_BRANCH_UUID" ON "MEASURES"("BRANCH_UUID" NULLS FIRST);
diff --git a/server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasuresTest/schema.sql b/server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasuresTest/schema.sql
new file mode 100644
index 00000000000..2b4deb7f118
--- /dev/null
+++ b/server/sonar-db-migration/src/test/resources/org/sonar/server/platform/db/migration/adhoc/MigratePortfoliosLiveMeasuresToMeasuresTest/schema.sql
@@ -0,0 +1,64 @@
+CREATE TABLE "PORTFOLIOS"(
+    "UUID" CHARACTER VARYING(40) NOT NULL,
+    "KEE" CHARACTER VARYING(400) NOT NULL,
+    "NAME" CHARACTER VARYING(2000) NOT NULL,
+    "DESCRIPTION" CHARACTER VARYING(2000),
+    "ROOT_UUID" CHARACTER VARYING(40) NOT NULL,
+    "PARENT_UUID" CHARACTER VARYING(40),
+    "PRIVATE" BOOLEAN NOT NULL,
+    "SELECTION_MODE" CHARACTER VARYING(50) NOT NULL,
+    "SELECTION_EXPRESSION" CHARACTER VARYING(4000),
+    "CREATED_AT" BIGINT NOT NULL,
+    "UPDATED_AT" BIGINT NOT NULL,
+    "BRANCH_KEY" CHARACTER VARYING(255),
+    "MEASURES_MIGRATED" BOOLEAN DEFAULT FALSE NOT NULL
+);
+ALTER TABLE "PORTFOLIOS" ADD CONSTRAINT "PK_PORTFOLIOS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "UNIQ_PORTFOLIOS_KEE" ON "PORTFOLIOS"("KEE" NULLS FIRST);
+
+CREATE TABLE "METRICS"(
+    "UUID" CHARACTER VARYING(40) NOT NULL,
+    "NAME" CHARACTER VARYING(64) NOT NULL,
+    "DESCRIPTION" CHARACTER VARYING(255),
+    "DIRECTION" INTEGER DEFAULT 0 NOT NULL,
+    "DOMAIN" CHARACTER VARYING(64),
+    "SHORT_NAME" CHARACTER VARYING(64),
+    "QUALITATIVE" BOOLEAN DEFAULT FALSE NOT NULL,
+    "VAL_TYPE" CHARACTER VARYING(8),
+    "ENABLED" BOOLEAN DEFAULT TRUE,
+    "WORST_VALUE" DOUBLE PRECISION,
+    "BEST_VALUE" DOUBLE PRECISION,
+    "OPTIMIZED_BEST_VALUE" BOOLEAN,
+    "HIDDEN" BOOLEAN,
+    "DELETE_HISTORICAL_DATA" BOOLEAN,
+    "DECIMAL_SCALE" INTEGER
+);
+ALTER TABLE "METRICS" ADD CONSTRAINT "PK_METRICS" PRIMARY KEY("UUID");
+CREATE UNIQUE INDEX "METRICS_UNIQUE_NAME" ON "METRICS"("NAME" NULLS FIRST);
+
+CREATE TABLE "LIVE_MEASURES"(
+    "UUID" CHARACTER VARYING(40) NOT NULL,
+    "PROJECT_UUID" CHARACTER VARYING(50) NOT NULL,
+    "COMPONENT_UUID" CHARACTER VARYING(50) NOT NULL,
+    "METRIC_UUID" CHARACTER VARYING(40) NOT NULL,
+    "VALUE" DOUBLE PRECISION,
+    "TEXT_VALUE" CHARACTER VARYING(4000),
+    "MEASURE_DATA" BINARY LARGE OBJECT,
+    "UPDATE_MARKER" CHARACTER VARYING(40),
+    "CREATED_AT" BIGINT NOT NULL,
+    "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "LIVE_MEASURES" ADD CONSTRAINT "PK_LIVE_MEASURES" PRIMARY KEY("UUID");
+CREATE INDEX "LIVE_MEASURES_PROJECT" ON "LIVE_MEASURES"("PROJECT_UUID" NULLS FIRST);
+CREATE UNIQUE INDEX "LIVE_MEASURES_COMPONENT" ON "LIVE_MEASURES"("COMPONENT_UUID" NULLS FIRST, "METRIC_UUID" NULLS FIRST);
+
+CREATE TABLE "MEASURES"(
+    "COMPONENT_UUID" CHARACTER VARYING(40) NOT NULL,
+    "BRANCH_UUID" CHARACTER VARYING(40) NOT NULL,
+    "JSON_VALUE" CHARACTER LARGE OBJECT NOT NULL,
+    "JSON_VALUE_HASH" BIGINT NOT NULL,
+    "CREATED_AT" BIGINT NOT NULL,
+    "UPDATED_AT" BIGINT NOT NULL
+);
+ALTER TABLE "MEASURES" ADD CONSTRAINT "PK_MEASURES" PRIMARY KEY("COMPONENT_UUID");
+CREATE INDEX "MEASURES_BRANCH_UUID" ON "MEASURES"("BRANCH_UUID" NULLS FIRST);
diff --git a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/platform/ws/MigrateMeasuresAction.java b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/platform/ws/MigrateMeasuresAction.java
new file mode 100644
index 00000000000..fd7d6b35357
--- /dev/null
+++ b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/platform/ws/MigrateMeasuresAction.java
@@ -0,0 +1,153 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.ws;
+
+import com.google.common.io.Resources;
+import java.sql.SQLException;
+import java.util.List;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.Response;
+import org.sonar.api.server.ws.WebService;
+import org.sonar.api.utils.text.JsonWriter;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.server.platform.db.migration.adhoc.MigrateBranchesLiveMeasuresToMeasures;
+import org.sonar.server.platform.db.migration.adhoc.MigratePortfoliosLiveMeasuresToMeasures;
+import org.sonar.server.user.UserSession;
+
+import static java.lang.String.format;
+import static java.util.Optional.ofNullable;
+
+public class MigrateMeasuresAction implements SystemWsAction {
+  public static final String SYSTEM_MEASURES_MIGRATION_ENABLED = "system.measures.migration.enabled";
+  public static final String PARAM_SIZE = "size";
+
+  private final UserSession userSession;
+  private final DbClient dbClient;
+  private final MigrateBranchesLiveMeasuresToMeasures branchesMigration;
+  private final MigratePortfoliosLiveMeasuresToMeasures portfoliosMigration;
+
+  public MigrateMeasuresAction(UserSession userSession, DbClient dbClient,
+    MigrateBranchesLiveMeasuresToMeasures branchesMigration, MigratePortfoliosLiveMeasuresToMeasures portfoliosMigration) {
+    this.userSession = userSession;
+    this.dbClient = dbClient;
+    this.branchesMigration = branchesMigration;
+    this.portfoliosMigration = portfoliosMigration;
+  }
+
+  @Override
+  public void define(WebService.NewController controller) {
+    WebService.NewAction action = controller.createAction("migrate_measures")
+      .setDescription("Prepare the migration to the next major version of SonarQube." +
+        "<br/>" +
+        "Sending a POST request to this URL will migrate some rows from the 'live_measures' to the 'measures' table. " +
+        "Requires system administration permission.")
+      .setSince("9.9.8")
+      .setPost(true)
+      .setHandler(this)
+      .setInternal(true)
+      .setResponseExample(Resources.getResource(this.getClass(), "example-migrate_measures.json"));
+
+    action.createParam(PARAM_SIZE)
+      .setDescription("The number of branches or portfolios to migrate")
+      .setDefaultValue(10);
+  }
+
+  @Override
+  public void handle(Request request, Response response) throws Exception {
+    userSession.checkIsSystemAdministrator();
+
+    if (!isMigrationEnabled()) {
+      throw new IllegalStateException("Migration is not enabled. Please call the endpoint /api/system/prepare_migration?enable=true and retry.");
+    }
+
+    int size = request.mandatoryParamAsInt(PARAM_SIZE);
+    if (size <= 0) {
+      throw new IllegalArgumentException("Size must be greater than 0");
+    }
+
+    int migratedItems = migrateBranches(size);
+    if (migratedItems < size) {
+      int remainingSize = size - migratedItems;
+      migratedItems += migratePortfolios(remainingSize);
+    }
+
+    BranchStats statistics = getStatistics();
+    try (JsonWriter json = response.newJsonWriter()) {
+      json.beginObject()
+        .prop("status", "success")
+        .prop("message", format("%s branches or portfolios migrated", migratedItems))
+        .prop("remainingBranches", statistics.remainingBranches)
+        .prop("totalBranches", statistics.totalBranches)
+        .prop("remainingPortfolios", statistics.remainingPortfolios)
+        .prop("totalPortfolios", statistics.totalPortfolios)
+        .endObject();
+    }
+  }
+
+  private int migrateBranches(int size) throws SQLException {
+    List<String> branchesToMigrate = getBranchesToMigrate(size);
+    if (!branchesToMigrate.isEmpty()) {
+      branchesMigration.migrate(branchesToMigrate);
+    }
+    return branchesToMigrate.size();
+  }
+
+  private List<String> getBranchesToMigrate(int size) {
+    try (DbSession dbSession = dbClient.openSession(false)) {
+      return dbClient.branchDao().selectUuidsWithMeasuresMigratedFalse(dbSession, size);
+    }
+  }
+
+  private int migratePortfolios(int size) throws SQLException {
+    List<String> portfoliosToMigrate = getPortfoliosToMigrate(size);
+    if (!portfoliosToMigrate.isEmpty()) {
+      portfoliosMigration.migrate(portfoliosToMigrate);
+    }
+    return portfoliosToMigrate.size();
+  }
+
+  private List<String> getPortfoliosToMigrate(int size) {
+    try (DbSession dbSession = dbClient.openSession(false)) {
+      return dbClient.portfolioDao().selectUuidsWithMeasuresMigratedFalse(dbSession, size);
+    }
+  }
+
+  private boolean isMigrationEnabled() {
+    return ofNullable(dbClient.propertiesDao().selectGlobalProperty(SYSTEM_MEASURES_MIGRATION_ENABLED))
+      .map(p -> Boolean.parseBoolean(p.getValue()))
+      .orElse(false);
+  }
+
+  private BranchStats getStatistics() {
+    try (DbSession dbSession = dbClient.openSession(false)) {
+      int remainingBranches = dbClient.branchDao().countByMeasuresMigratedFalse(dbSession);
+      int totalBranches = dbClient.branchDao().countAll(dbSession);
+      int remainingPortfolios = dbClient.portfolioDao().countByMeasuresMigratedFalse(dbSession);
+      int totalPortfolios = dbClient.portfolioDao().selectAll(dbSession).size();
+
+      return new BranchStats(remainingBranches, totalBranches, remainingPortfolios, totalPortfolios);
+    }
+  }
+
+  private record BranchStats(int remainingBranches, int totalBranches, int remainingPortfolios, int totalPortfolios) {
+  }
+
+}
diff --git a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/platform/ws/SystemWsModule.java b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/platform/ws/SystemWsModule.java
index 5807d697a88..41c21b03174 100644
--- a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/platform/ws/SystemWsModule.java
+++ b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/platform/ws/SystemWsModule.java
@@ -25,6 +25,8 @@ import org.sonar.server.platform.db.migration.adhoc.AddMeasuresMigratedColumnToP
 import org.sonar.server.platform.db.migration.adhoc.CreateIndexOnPortfoliosMeasuresMigrated;
 import org.sonar.server.platform.db.migration.adhoc.CreateIndexOnProjectBranchesMeasuresMigrated;
 import org.sonar.server.platform.db.migration.adhoc.CreateMeasuresTable;
+import org.sonar.server.platform.db.migration.adhoc.MigrateBranchesLiveMeasuresToMeasures;
+import org.sonar.server.platform.db.migration.adhoc.MigratePortfoliosLiveMeasuresToMeasures;
 
 public class SystemWsModule extends Module {
 
@@ -47,6 +49,10 @@ public class SystemWsModule extends Module {
       CreateIndexOnPortfoliosMeasuresMigrated.class,
       PrepareMigrationAction.class,
 
+      MigrateBranchesLiveMeasuresToMeasures.class,
+      MigratePortfoliosLiveMeasuresToMeasures.class,
+      MigrateMeasuresAction.class,
+
       InfoAction.class,
       LogsAction.class,
       MigrateDbAction.class,
diff --git a/server/sonar-webserver-webapi/src/main/resources/org/sonar/server/platform/ws/example-migrate_measures.json b/server/sonar-webserver-webapi/src/main/resources/org/sonar/server/platform/ws/example-migrate_measures.json
new file mode 100644
index 00000000000..60fb3154d7a
--- /dev/null
+++ b/server/sonar-webserver-webapi/src/main/resources/org/sonar/server/platform/ws/example-migrate_measures.json
@@ -0,0 +1,8 @@
+{
+  "status": "success",
+  "message": "2 branches or portfolios migrated",
+  "remainingBranches": 1,
+  "totalBranches": 3,
+  "remainingPortfolios": 1,
+  "totalPortfolios": 2
+}
diff --git a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/platform/ws/MigrateMeasuresActionTest.java b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/platform/ws/MigrateMeasuresActionTest.java
new file mode 100644
index 00000000000..a4b92076fca
--- /dev/null
+++ b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/platform/ws/MigrateMeasuresActionTest.java
@@ -0,0 +1,233 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.platform.ws;
+
+import com.google.gson.Gson;
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import java.sql.SQLException;
+import java.util.List;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.sonar.db.Database;
+import org.sonar.db.DbTester;
+import org.sonar.db.component.BranchType;
+import org.sonar.db.component.ComponentDto;
+import org.sonar.db.portfolio.PortfolioDto;
+import org.sonar.db.property.PropertyDto;
+import org.sonar.server.exceptions.ForbiddenException;
+import org.sonar.server.platform.db.migration.adhoc.AddMeasuresMigratedColumnToPortfoliosTable;
+import org.sonar.server.platform.db.migration.adhoc.AddMeasuresMigratedColumnToProjectBranchesTable;
+import org.sonar.server.platform.db.migration.adhoc.MigrateBranchesLiveMeasuresToMeasures;
+import org.sonar.server.platform.db.migration.adhoc.MigratePortfoliosLiveMeasuresToMeasures;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.ws.TestRequest;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.sonar.db.component.BranchType.BRANCH;
+import static org.sonar.server.platform.ws.MigrateMeasuresAction.SYSTEM_MEASURES_MIGRATION_ENABLED;
+import static org.sonar.test.JsonAssert.assertJson;
+
+@RunWith(DataProviderRunner.class)
+public class MigrateMeasuresActionTest {
+  private static final Gson GSON = new Gson();
+
+  public static final String PARAM_SIZE = "size";
+  @Rule
+  public UserSessionRule userSessionRule = UserSessionRule.standalone().logIn().setSystemAdministrator();
+
+  @Rule
+  public DbTester dbTester = DbTester.create();
+
+  private final MigrateBranchesLiveMeasuresToMeasures measuresMigration = mock();
+  private final MigratePortfoliosLiveMeasuresToMeasures portfoliosMigration = mock();
+  private final MigrateMeasuresAction underTest = new MigrateMeasuresAction(userSessionRule, dbTester.getDbClient(), measuresMigration, portfoliosMigration);
+  private final WsActionTester tester = new WsActionTester(underTest);
+
+  @Test
+  public void should_throw_if_migration_is_not_enabled() {
+    TestRequest request = tester.newRequest();
+
+    assertThatIllegalStateException()
+      .isThrownBy(request::execute)
+      .withMessage("Migration is not enabled. Please call the endpoint /api/system/prepare_migration?enable=true and retry.");
+  }
+
+  @Test
+  @DataProvider(value = {"0", "-1", "-100"})
+  public void should_throws_IAE_if_size_in_invalid(int size) throws SQLException {
+    enableMigration();
+
+    TestRequest request = tester
+      .newRequest()
+      .setParam(PARAM_SIZE, Integer.toString(size));
+
+    assertThatIllegalArgumentException()
+      .isThrownBy(request::execute)
+      .withMessage("Size must be greater than 0");
+  }
+
+  @Test
+  public void verify_example() throws SQLException {
+    enableMigration();
+    // 3 branches, 2 migrated
+    ComponentDto project = dbTester.components().insertPrivateProject();
+    ComponentDto branch1 = dbTester.components().insertProjectBranch(project, b -> b.setBranchType(BRANCH));
+    dbTester.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.BRANCH));
+    dbTester.getDbClient().branchDao().updateMeasuresMigrated(dbTester.getSession(), project.branchUuid(), true);
+    dbTester.getDbClient().branchDao().updateMeasuresMigrated(dbTester.getSession(), branch1.branchUuid(), true);
+    // 2 portfolios, 1 migrated
+    PortfolioDto portfolio1 = dbTester.components().insertPrivatePortfolioDto("name1");
+    dbTester.components().insertPrivatePortfolioDto("name2");
+    dbTester.getDbClient().portfolioDao().updateMeasuresMigrated(dbTester.getSession(), portfolio1.getUuid(), true);
+    dbTester.getSession().commit();
+
+    TestResponse response = tester.newRequest()
+      .execute();
+
+    assertJson(response.getInput()).isSimilarTo(getClass().getResource("example-migrate_measures.json"));
+  }
+
+  @Test
+  public void does_not_migrate_portfolios_if_measures_are_not_finished() throws SQLException {
+    enableMigration();
+    // 2 branches
+    ComponentDto project = dbTester.components().insertPrivateProject();
+    ComponentDto branch = dbTester.components().insertProjectBranch(project, b -> b.setBranchType(BRANCH));
+    dbTester.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.BRANCH));
+
+    TestResponse response = tester.newRequest()
+      .setParam(PARAM_SIZE, "2")
+      .execute();
+
+    assertThat(GSON.fromJson(response.getInput(), ActionResponse.class))
+      .isEqualTo(new ActionResponse("success", "2 branches or portfolios migrated", 3, 3, 0, 0));
+    verify(measuresMigration).migrate(List.of(project.uuid(), branch.uuid()));
+    verifyNoInteractions(portfoliosMigration);
+  }
+
+  @Test
+  public void migrate_portfolios_to_reach_the_requested_size() throws SQLException {
+    enableMigration();
+
+    // 1 branch
+    ComponentDto project = dbTester.components().insertPrivateProject();
+    // 2 portfolios
+    PortfolioDto portfolio1 = dbTester.components().insertPrivatePortfolioDto("name1");
+    dbTester.components().insertPrivatePortfolioDto("name2");
+
+    TestResponse response = tester.newRequest()
+      .setParam(PARAM_SIZE, "2")
+      .execute();
+
+    assertThat(GSON.fromJson(response.getInput(), ActionResponse.class))
+      .isEqualTo(new ActionResponse("success", "2 branches or portfolios migrated", 1, 1, 2, 2));
+    verify(measuresMigration).migrate(List.of(project.uuid()));
+    verify(portfoliosMigration).migrate(List.of(portfolio1.getUuid()));
+  }
+
+  @Test
+  public void migrate_portfolios_only_if_measures_are_done() throws SQLException {
+    enableMigration();
+    // 2 branches, all migrated
+    ComponentDto project = dbTester.components().insertPrivateProject();
+    ComponentDto branch1 = dbTester.components().insertProjectBranch(project, b -> b.setBranchType(BRANCH));
+    dbTester.getDbClient().branchDao().updateMeasuresMigrated(dbTester.getSession(), project.branchUuid(), true);
+    dbTester.getDbClient().branchDao().updateMeasuresMigrated(dbTester.getSession(), branch1.branchUuid(), true);
+    // 2 portfolios, 1 migrated
+    PortfolioDto portfolio1 = dbTester.components().insertPrivatePortfolioDto("name1");
+    PortfolioDto portfolio2 = dbTester.components().insertPrivatePortfolioDto("name2");
+    dbTester.getDbClient().portfolioDao().updateMeasuresMigrated(dbTester.getSession(), portfolio1.getUuid(), true);
+    dbTester.commit();
+
+    TestResponse response = tester.newRequest()
+      .setParam(PARAM_SIZE, "2")
+      .execute();
+
+    assertThat(GSON.fromJson(response.getInput(), ActionResponse.class))
+      .isEqualTo(new ActionResponse("success", "1 branches or portfolios migrated", 0, 2, 1, 2));
+    verifyNoInteractions(measuresMigration);
+    verify(portfoliosMigration).migrate(List.of(portfolio2.getUuid()));
+  }
+
+  @Test
+  public void does_nothing_if_migration_is_finished() throws SQLException {
+    enableMigration();
+    // 2 branches, all migrated
+    ComponentDto project = dbTester.components().insertPrivateProject();
+    ComponentDto branch1 = dbTester.components().insertProjectBranch(project, b -> b.setBranchType(BRANCH));
+    dbTester.getDbClient().branchDao().updateMeasuresMigrated(dbTester.getSession(), project.branchUuid(), true);
+    dbTester.getDbClient().branchDao().updateMeasuresMigrated(dbTester.getSession(), branch1.branchUuid(), true);
+    // 2 portfolios, all migrated
+    PortfolioDto portfolio1 = dbTester.components().insertPrivatePortfolioDto("name1");
+    PortfolioDto portfolio2 = dbTester.components().insertPrivatePortfolioDto("name2");
+    dbTester.getDbClient().portfolioDao().updateMeasuresMigrated(dbTester.getSession(), portfolio1.getUuid(), true);
+    dbTester.getDbClient().portfolioDao().updateMeasuresMigrated(dbTester.getSession(), portfolio2.getUuid(), true);
+    dbTester.commit();
+
+    TestResponse response = tester.newRequest()
+      .setParam(PARAM_SIZE, "2")
+      .execute();
+
+    assertThat(GSON.fromJson(response.getInput(), ActionResponse.class))
+      .isEqualTo(new ActionResponse("success", "0 branches or portfolios migrated", 0, 2, 0, 2));
+    verifyNoInteractions(measuresMigration, portfoliosMigration);
+  }
+
+  private void enableMigration() throws SQLException {
+    Database database = dbTester.getDbClient().getDatabase();
+    new AddMeasuresMigratedColumnToProjectBranchesTable(database).execute();
+    new AddMeasuresMigratedColumnToPortfoliosTable(database).execute();
+    dbTester.getDbClient().propertiesDao().saveProperty(new PropertyDto().setKey(SYSTEM_MEASURES_MIGRATION_ENABLED).setValue("true"));
+  }
+
+  @Test
+  public void throws_ForbiddenException_if_user_is_not_logged_in() {
+    userSessionRule.anonymous();
+
+    TestRequest request = tester.newRequest();
+
+    assertThatExceptionOfType(ForbiddenException.class)
+      .isThrownBy(request::execute);
+  }
+
+  @Test
+  public void throws_ForbiddenException_if_user_is_not_system_admin() {
+    userSessionRule.logIn();
+
+    TestRequest request = tester.newRequest();
+
+    assertThatExceptionOfType(ForbiddenException.class)
+      .isThrownBy(request::execute);
+  }
+
+  private record ActionResponse(String status, String message, int remainingBranches, int totalBranches, int remainingPortfolios,
+                                int totalPortfolios) {
+  }
+}
diff --git a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/platform/ws/SystemWsModuleTest.java b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/platform/ws/SystemWsModuleTest.java
index 1249de66c19..8c7a40815c2 100644
--- a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/platform/ws/SystemWsModuleTest.java
+++ b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/platform/ws/SystemWsModuleTest.java
@@ -29,6 +29,6 @@ public class SystemWsModuleTest {
   public void verify_count_of_added_components() {
     ListContainer container = new ListContainer();
     new SystemWsModule().configure(container);
-    assertThat(container.getAddedObjects()).hasSize(21);
+    assertThat(container.getAddedObjects()).hasSize(24);
   }
 }