From 29107fc9cb51b8b0acc204903b6da36a16705795 Mon Sep 17 00:00:00 2001 From: Eric Hartmann Date: Wed, 18 Jul 2018 16:21:07 +0200 Subject: [PATCH] SONARCLOUD-103 Introduce the limit with largest long lived branch --- .../measure/PostMeasuresComputationCheck.java | 7 - .../PostMeasuresComputationChecksStep.java | 6 - .../org/sonar/db/measure/LiveMeasureDao.java | 6 +- .../sonar/db/measure/LiveMeasureMapper.java | 1 + .../org/sonar/db/measure/SumNclocDbQuery.java | 13 ++ .../db/organization/OrganizationDao.java | 13 ++ .../db/organization/OrganizationMapper.java | 9 ++ .../OrganizationWithNclocDto.java | 64 ++++++++++ .../sonar/db/measure/LiveMeasureMapper.xml | 3 + .../db/organization/OrganizationMapper.xml | 29 ++++- .../sonar/db/measure/LiveMeasureDaoTest.java | 14 +- .../db/organization/OrganizationDaoTest.java | 120 +++++++++++++++++- .../server/telemetry/TelemetryDataLoader.java | 7 +- .../sonar/server/ui/ws/MarketplaceAction.java | 7 +- 14 files changed, 273 insertions(+), 26 deletions(-) create mode 100644 server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationWithNclocDto.java diff --git a/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/PostMeasuresComputationCheck.java b/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/PostMeasuresComputationCheck.java index e25d30a600a..59fe7f720a5 100644 --- a/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/PostMeasuresComputationCheck.java +++ b/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/PostMeasuresComputationCheck.java @@ -22,7 +22,6 @@ package org.sonar.ce.task.projectanalysis.measure; import org.sonar.api.ExtensionPoint; import org.sonar.api.ce.ComputeEngineSide; import org.sonar.ce.task.projectanalysis.analysis.AnalysisMetadataHolder; -import org.sonar.ce.task.projectanalysis.analysis.Branch; /** * Extension point that is called during processing of a task @@ -64,11 +63,5 @@ public interface PostMeasuresComputationCheck { * Return the organization */ String getOrganizationKey(); - - /** - * Return the branch of the project - */ - Branch getBranch(); } - } diff --git a/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/PostMeasuresComputationChecksStep.java b/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/PostMeasuresComputationChecksStep.java index 2fb140e654d..f541b277a44 100644 --- a/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/PostMeasuresComputationChecksStep.java +++ b/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/PostMeasuresComputationChecksStep.java @@ -23,7 +23,6 @@ import com.google.common.base.Optional; import org.sonar.api.ce.ComputeEngineSide; import org.sonar.api.measures.CoreMetrics; import org.sonar.ce.task.projectanalysis.analysis.AnalysisMetadataHolder; -import org.sonar.ce.task.projectanalysis.analysis.Branch; import org.sonar.ce.task.projectanalysis.component.TreeRootHolder; import org.sonar.ce.task.projectanalysis.metric.Metric; import org.sonar.ce.task.projectanalysis.metric.MetricRepository; @@ -96,10 +95,5 @@ public class PostMeasuresComputationChecksStep implements ComputationStep { public String getOrganizationKey() { return analysisMetadataHolder.getOrganization().getKey(); } - - @Override - public Branch getBranch() { - return analysisMetadataHolder.getBranch(); - } } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/measure/LiveMeasureDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/measure/LiveMeasureDao.java index 4f76a3cf800..4e403f3a3aa 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/measure/LiveMeasureDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/measure/LiveMeasureDao.java @@ -87,13 +87,9 @@ public class LiveMeasureDao implements Dao { * If Main Branch = 100 LOCs and the "largest long-lived branch" is 120 LOCs, I'm expecting to consider the value 120. * If Main Branch = 100 LOCs and the "largest long-lived branch" is 80 LOCs, I'm expecting to consider the value 100. */ - public long sumNclocOfBiggestLongLivingBranch(DbSession dbSession, String organizationUuid) { - return sumNclocOfBiggestLongLivingBranch(dbSession, SumNclocDbQuery.builder().setOrganizationUuid(organizationUuid).build()); - } - public long sumNclocOfBiggestLongLivingBranch(DbSession dbSession, SumNclocDbQuery dbQuery) { Long ncloc = mapper(dbSession).sumNclocOfBiggestLongLivingBranch( - NCLOC_KEY, KeyType.BRANCH, BranchType.LONG, dbQuery.getOrganizationUuid(), dbQuery.getProjectUuidToExclude()); + NCLOC_KEY, KeyType.BRANCH, BranchType.LONG, dbQuery.getOrganizationUuid(), dbQuery.getOnlyPrivateProjects(), dbQuery.getProjectUuidToExclude()); return ncloc == null ? 0L : ncloc; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/measure/LiveMeasureMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/measure/LiveMeasureMapper.java index a8901407637..afd60719696 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/measure/LiveMeasureMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/measure/LiveMeasureMapper.java @@ -48,6 +48,7 @@ public interface LiveMeasureMapper { @Param("branch") KeyType branchOrPullRequest, @Param("branchType") BranchType branchType, @Param("organizationUuid") String organizationUuid, + @Param("private") Boolean privateProject, @Nullable @Param("projectUuidToExclude") String projectUuidToExclude); void insert( diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/measure/SumNclocDbQuery.java b/server/sonar-db-dao/src/main/java/org/sonar/db/measure/SumNclocDbQuery.java index 437ce88cee4..db88f5f22f4 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/measure/SumNclocDbQuery.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/measure/SumNclocDbQuery.java @@ -28,10 +28,12 @@ public class SumNclocDbQuery { private final String projectUuidToExclude; private final String organizationUuid; + private final Boolean onlyPrivateProjects; public SumNclocDbQuery(Builder builder) { projectUuidToExclude = builder.projectUuidToExclude; organizationUuid = builder.organizationUuid; + onlyPrivateProjects = builder.onlyPrivateProjects; } @CheckForNull @@ -43,6 +45,10 @@ public class SumNclocDbQuery { return organizationUuid; } + public Boolean getOnlyPrivateProjects() { + return onlyPrivateProjects; + } + public static Builder builder() { return new Builder(); } @@ -50,6 +56,7 @@ public class SumNclocDbQuery { public static class Builder { private String projectUuidToExclude; private String organizationUuid; + private Boolean onlyPrivateProjects; private Builder() { // to enforce use of builder() @@ -65,8 +72,14 @@ public class SumNclocDbQuery { return this; } + public Builder setOnlyPrivateProjects(Boolean onlyPrivateProjects) { + this.onlyPrivateProjects = onlyPrivateProjects; + return this; + } + public SumNclocDbQuery build() { checkNotNull(organizationUuid); + checkNotNull(onlyPrivateProjects); return new SumNclocDbQuery(this); } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDao.java index c7f3623f7fd..87e818e2d3f 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationDao.java @@ -19,6 +19,7 @@ */ package org.sonar.db.organization; +import java.util.ArrayList; import java.util.List; import java.util.Optional; import java.util.Set; @@ -27,11 +28,15 @@ import org.sonar.db.Dao; import org.sonar.db.DbSession; import org.sonar.db.KeyLongValue; import org.sonar.db.Pagination; +import org.sonar.db.component.BranchType; +import org.sonar.db.component.KeyType; import org.sonar.db.qualitygate.QGateWithOrgDto; import org.sonar.db.user.GroupDto; import static java.util.Objects.requireNonNull; +import static org.sonar.api.measures.CoreMetrics.NCLOC_KEY; import static org.sonar.db.DatabaseUtils.executeLargeInputs; +import static org.sonar.db.DatabaseUtils.executeLargeUpdates; public class OrganizationDao implements Dao { @@ -145,6 +150,14 @@ public class OrganizationDao implements Dao { return getMapper(dbSession).deleteByUuid(uuid); } + public List selectOrganizationsWithNcloc(DbSession dbSession, List organizationUuids) { + List result = new ArrayList<>(); + executeLargeUpdates(organizationUuids, chunk -> + result.addAll(getMapper(dbSession).selectOrganizationsWithNcloc(NCLOC_KEY, chunk, KeyType.BRANCH, BranchType.LONG)) + ); + return result; + } + private static void checkDto(OrganizationDto organization) { requireNonNull(organization, "OrganizationDto can't be null"); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationMapper.java index af95fabb58d..028d44376ef 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationMapper.java @@ -24,6 +24,8 @@ import javax.annotation.CheckForNull; import org.apache.ibatis.annotations.Param; import org.sonar.db.KeyLongValue; import org.sonar.db.Pagination; +import org.sonar.db.component.BranchType; +import org.sonar.db.component.KeyType; public interface OrganizationMapper { void insert(@Param("organization") OrganizationDto organization, @Param("newProjectPrivate") boolean newProjectPrivate); @@ -78,4 +80,11 @@ public interface OrganizationMapper { void updateNewProjectPrivate(@Param("organizationUuid") String organizationUuid, @Param("newProjectPrivate") boolean newProjectPrivate, @Param("now") long now); int deleteByUuid(@Param("uuid") String uuid); + + List selectOrganizationsWithNcloc( + @Param("ncloc") String ncloc, + @Param("organizationUuids") List organizationUuids, + @Param("branch") KeyType branchOrPullRequest, + @Param("branchType") BranchType branchType); + } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationWithNclocDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationWithNclocDto.java new file mode 100644 index 00000000000..5de8523fd51 --- /dev/null +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/organization/OrganizationWithNclocDto.java @@ -0,0 +1,64 @@ +/* + * SonarQube + * Copyright (C) 2009-2018 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.db.organization; + +public class OrganizationWithNclocDto { + private String id; + private String kee; + private String name; + private long ncloc; + + public String getId() { + return id; + } + + public OrganizationWithNclocDto setId(String id) { + this.id = id; + return this; + } + + public String getKee() { + return kee; + } + + public OrganizationWithNclocDto setKee(String kee) { + this.kee = kee; + return this; + } + + public String getName() { + return name; + } + + public OrganizationWithNclocDto setName(String name) { + this.name = name; + return this; + } + + public long getNcloc() { + return ncloc; + } + + public OrganizationWithNclocDto setNcloc(long ncloc) { + this.ncloc = ncloc; + return this; + } +} diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/measure/LiveMeasureMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/measure/LiveMeasureMapper.xml index fc89e3ac806..457c726881e 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/measure/LiveMeasureMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/measure/LiveMeasureMapper.xml @@ -43,6 +43,9 @@ inner join project_branches b on b.uuid = p.uuid m.name = #{ncloc, jdbcType=VARCHAR} + + and p.private=${_true} + and p.enabled = ${_true} and p.scope = 'PRJ' and p.qualifier = 'TRK' diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/organization/OrganizationMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/organization/OrganizationMapper.xml index 4f9e5674ea7..d9315630534 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/organization/OrganizationMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/organization/OrganizationMapper.xml @@ -339,6 +339,34 @@ org.uuid = #{uuid, jdbcType=VARCHAR} + + insert into organizations ( @@ -429,5 +457,4 @@ where uuid = #{uuid, jdbcType=VARCHAR} - diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/measure/LiveMeasureDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/measure/LiveMeasureDaoTest.java index 5100e6791be..83fb50719ab 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/measure/LiveMeasureDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/measure/LiveMeasureDaoTest.java @@ -219,7 +219,11 @@ public class LiveMeasureDaoTest { db.measures().insertLiveMeasure(projectWithLinesButNoLoc, lines, m -> m.setValue(365d)); db.measures().insertLiveMeasure(projectWithLinesButNoLoc, ncloc, m -> m.setValue(0d)); - long result = underTest.sumNclocOfBiggestLongLivingBranch(db.getSession(), organization.getUuid()); + SumNclocDbQuery query = SumNclocDbQuery.builder() + .setOnlyPrivateProjects(false) + .setOrganizationUuid(organization.getUuid()) + .build(); + long result = underTest.sumNclocOfBiggestLongLivingBranch(db.getSession(), query); assertThat(result).isEqualTo(10L + 200L); } @@ -228,8 +232,11 @@ public class LiveMeasureDaoTest { public void countNcloc_empty() { db.measures().insertMetric(m -> m.setKey("ncloc").setValueType(INT.toString())); db.measures().insertMetric(m -> m.setKey("lines").setValueType(INT.toString())); - - long result = underTest.sumNclocOfBiggestLongLivingBranch(db.getSession(), db.getDefaultOrganization().getUuid()); + SumNclocDbQuery query = SumNclocDbQuery.builder() + .setOnlyPrivateProjects(false) + .setOrganizationUuid(db.getDefaultOrganization().getUuid()) + .build(); + long result = underTest.sumNclocOfBiggestLongLivingBranch(db.getSession(), query); assertThat(result).isEqualTo(0L); } @@ -255,6 +262,7 @@ public class LiveMeasureDaoTest { SumNclocDbQuery query = SumNclocDbQuery.builder() .setOrganizationUuid(organization.getUuid()) .setProjectUuidToExclude(projectToExclude.uuid()) + .setOnlyPrivateProjects(false) .build(); long result = underTest.sumNclocOfBiggestLongLivingBranch(db.getSession(), query); diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/organization/OrganizationDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/organization/OrganizationDaoTest.java index df4af7ee970..385065ae96a 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/organization/OrganizationDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/organization/OrganizationDaoTest.java @@ -22,6 +22,7 @@ package org.sonar.db.organization; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; +import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; @@ -31,8 +32,10 @@ import java.util.Optional; import java.util.Random; import java.util.function.Consumer; import java.util.stream.Collectors; +import java.util.stream.IntStream; import javax.annotation.Nullable; import org.apache.ibatis.exceptions.PersistenceException; +import org.assertj.core.groups.Tuple; import org.assertj.core.util.Lists; import org.junit.Rule; import org.junit.Test; @@ -92,6 +95,7 @@ public class OrganizationDaoTest { .setDefaultQualityGateUuid("1"); private static final String PERMISSION_1 = "foo"; private static final String PERMISSION_2 = "bar"; + private static final Random RANDOM = new Random(); private System2 system2 = mock(System2.class); @@ -1118,6 +1122,84 @@ public class OrganizationDaoTest { tuple("+50M", 0L)); } + @Test + public void selectOrganizationsWithNcloc_on_zero_orgs() { + assertThat(underTest.selectOrganizationsWithNcloc(dbSession, new ArrayList<>())) + .isEmpty(); + } + + @Test + public void selectOrganizationsWithNcloc_with_not_existing_uuid() { + MetricDto ncloc = db.measures().insertMetric(m -> m.setKey(CoreMetrics.NCLOC_KEY)); + OrganizationDto org1 = db.organizations().insert(); + + assertThat(underTest.selectOrganizationsWithNcloc(dbSession, Lists.newArrayList("xxxx"))) + .isEmpty(); + } + + @Test + public void selectOrganizationsWithNcloc_with_organization_without_projects() { + MetricDto ncloc = db.measures().insertMetric(m -> m.setKey(CoreMetrics.NCLOC_KEY)); + OrganizationDto org1 = db.organizations().insert(); + + assertThat(underTest.selectOrganizationsWithNcloc(dbSession, Lists.newArrayList(org1.getUuid()))) + .extracting(OrganizationWithNclocDto::getId, OrganizationWithNclocDto::getKee, OrganizationWithNclocDto::getName, OrganizationWithNclocDto::getNcloc) + .containsExactlyInAnyOrder( + tuple(org1.getUuid(), org1.getKey(), org1.getName(), 0L) + ); + } + + @Test + public void selectOrganizationsWithNcloc_with_one_organization() { + MetricDto ncloc = db.measures().insertMetric(m -> m.setKey(CoreMetrics.NCLOC_KEY)); + OrganizationDto org1 = db.organizations().insert(); + + // private project with highest ncloc in non-main branch + ComponentDto project1 = db.components().insertMainBranch(org1); + ComponentDto project1Branch = db.components().insertProjectBranch(project1); + db.measures().insertLiveMeasure(project1, ncloc, m -> m.setValue(1_000.0)); + db.measures().insertLiveMeasure(project1Branch, ncloc, m -> m.setValue(110_000.0)); + + + // public project that must be ignored + ComponentDto project2 = db.components().insertPublicProject(org1); + ComponentDto project2Branch = db.components().insertProjectBranch(project2); + db.measures().insertLiveMeasure(project2, ncloc, m -> m.setValue(1_000_000_000.0)); + db.measures().insertLiveMeasure(project2Branch, ncloc, m -> m.setValue(1_000_000.0)); + + assertThat(underTest.selectOrganizationsWithNcloc(dbSession, Lists.newArrayList(org1.getUuid()))) + .extracting(OrganizationWithNclocDto::getId, OrganizationWithNclocDto::getKee, OrganizationWithNclocDto::getName, OrganizationWithNclocDto::getNcloc) + .containsExactlyInAnyOrder( + tuple(org1.getUuid(), org1.getKey(), org1.getName(), 110_000L) + ); + } + + @Test + public void selectOrganizationsWithNcloc_with_multiple_organizations() { + MetricDto ncloc = db.measures().insertMetric(m -> m.setKey(CoreMetrics.NCLOC_KEY)); + + Tuple[] expectedResults = new Tuple[9]; + List orgUuids = new ArrayList<>(); + IntStream.range(0, 9).forEach( + i -> { + OrganizationDto org = db.organizations().insert(); + orgUuids.add(org.getUuid()); + + int maxPrivate = insertPrivateProjectsWithBranches(org, ncloc); + // Now we are creating public project asking for maxPrivate as minimum ncloc + // because those projects *MUST* not be taken during the calculation of ncloc for a private + // organization + insertPublicProjectsWithBranches(org, ncloc, maxPrivate); + + expectedResults[i] = tuple(org.getUuid(), org.getKey(), org.getName(), (long) maxPrivate); + } + ); + + assertThat(underTest.selectOrganizationsWithNcloc(dbSession, orgUuids)) + .extracting(OrganizationWithNclocDto::getId, OrganizationWithNclocDto::getKee, OrganizationWithNclocDto::getName, OrganizationWithNclocDto::getNcloc) + .containsExactlyInAnyOrder(expectedResults); + } + private void expectDtoCanNotBeNull() { expectedException.expect(NullPointerException.class); expectedException.expectMessage("OrganizationDto can't be null"); @@ -1166,8 +1248,8 @@ public class OrganizationDaoTest { preparedStatement.setString(5, view); preparedStatement.setBoolean(6, false); preparedStatement.setBoolean(7, false); - preparedStatement.setString(8, "1"); // TODO check ok ? - preparedStatement.setString(9, FREE.name()); // TODO check ok ? + preparedStatement.setString(8, "1"); + preparedStatement.setString(9, FREE.name()); preparedStatement.setLong(10, 1000L); preparedStatement.setLong(11, 2000L); preparedStatement.execute(); @@ -1253,4 +1335,38 @@ public class OrganizationDaoTest { Map row = db.selectFirst(db.getSession(), String.format("select updated_at as \"updatedAt\" from organizations where uuid='%s'", organization)); assertThat(row.get("updatedAt")).isEqualTo(updatedAt); } + + private int insertPrivateProjectsWithBranches(OrganizationDto org, MetricDto ncloc) { + // private project + ComponentDto project1 = db.components().insertMainBranch(org); + + return Math.max( + // Create the ncloc on main branch + insertLiveMeasures(project1, ncloc, 0), + // Create 5 branches and set the ncloc on them + IntStream.range(1, 5) + .map(i -> insertLiveMeasures(db.components().insertProjectBranch(project1), ncloc, 0)) + .max().orElse(0) + ); + } + + private int insertPublicProjectsWithBranches(OrganizationDto org, MetricDto ncloc, int minimumNcloc) { + // private project + ComponentDto project1 = db.components().insertPublicProject(org); + + return Math.max( + // Create the ncloc on main branch + insertLiveMeasures(project1, ncloc, minimumNcloc), + // Create 5 branches and set the ncloc on them + IntStream.range(1, 5) + .map(i -> insertLiveMeasures(db.components().insertProjectBranch(project1), ncloc, minimumNcloc)) + .max().orElse(0) + ); + } + + private int insertLiveMeasures(ComponentDto componentDto, MetricDto ncloc, int minimum) { + int nclocValue = minimum + RANDOM.nextInt(1_000_000); + db.measures().insertLiveMeasure(componentDto, ncloc, m -> m.setValue((double) nclocValue)); + return nclocValue; + } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/telemetry/TelemetryDataLoader.java b/server/sonar-server/src/main/java/org/sonar/server/telemetry/TelemetryDataLoader.java index b0b9d3a4e56..915bfb2afcd 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/telemetry/TelemetryDataLoader.java +++ b/server/sonar-server/src/main/java/org/sonar/server/telemetry/TelemetryDataLoader.java @@ -31,6 +31,7 @@ import org.sonar.core.platform.PluginRepository; import org.sonar.core.util.stream.MoreCollectors; import org.sonar.db.DbClient; import org.sonar.db.DbSession; +import org.sonar.db.measure.SumNclocDbQuery; import org.sonar.server.es.SearchOptions; import org.sonar.server.measure.index.ProjectMeasuresIndex; import org.sonar.server.measure.index.ProjectMeasuresStatistics; @@ -76,7 +77,11 @@ public class TelemetryDataLoader { try (DbSession dbSession = dbClient.openSession(false)) { data.setDatabase(loadDatabaseMetadata(dbSession)); data.setUsingBranches(dbClient.branchDao().hasNonMainBranches(dbSession)); - data.setNcloc(dbClient.liveMeasureDao().sumNclocOfBiggestLongLivingBranch(dbSession, defaultOrganizationProvider.get().getUuid())); + SumNclocDbQuery query = SumNclocDbQuery.builder() + .setOnlyPrivateProjects(false) + .setOrganizationUuid(defaultOrganizationProvider.get().getUuid()) + .build(); + data.setNcloc(dbClient.liveMeasureDao().sumNclocOfBiggestLongLivingBranch(dbSession, query)); } return data.build(); diff --git a/server/sonar-server/src/main/java/org/sonar/server/ui/ws/MarketplaceAction.java b/server/sonar-server/src/main/java/org/sonar/server/ui/ws/MarketplaceAction.java index da0b55884aa..bf0a15b5922 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/ui/ws/MarketplaceAction.java +++ b/server/sonar-server/src/main/java/org/sonar/server/ui/ws/MarketplaceAction.java @@ -25,6 +25,7 @@ import org.sonar.api.server.ws.Response; import org.sonar.api.server.ws.WebService; import org.sonar.db.DbClient; import org.sonar.db.DbSession; +import org.sonar.db.measure.SumNclocDbQuery; import org.sonar.server.organization.DefaultOrganizationProvider; import org.sonar.server.user.UserSession; import org.sonarqube.ws.Navigation; @@ -70,7 +71,11 @@ public class MarketplaceAction implements NavigationWsAction { private long computeNcloc() { try (DbSession dbSession = dbClient.openSession(false)) { - return dbClient.liveMeasureDao().sumNclocOfBiggestLongLivingBranch(dbSession, defaultOrganizationProvider.get().getUuid()); + SumNclocDbQuery query = SumNclocDbQuery.builder() + .setOnlyPrivateProjects(false) + .setOrganizationUuid(defaultOrganizationProvider.get().getUuid()) + .build(); + return dbClient.liveMeasureDao().sumNclocOfBiggestLongLivingBranch(dbSession, query); } } } -- 2.39.5