verifyCeTask(taskSubmit, task, null);
}
- @Test
- public void submit_fails_with_ISE_if_paused() {
- underTest.pauseSubmit();
-
- expectedException.expect(IllegalStateException.class);
- expectedException.expectMessage("Compute Engine does not currently accept new tasks");
-
- submit(CeTaskTypes.REPORT, "PROJECT_1");
- }
-
@Test
public void massSubmit_returns_tasks_for_each_CeTaskSubmit_populated_from_CeTaskSubmit_and_creates_CeQueue_row_for_each() {
CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, "PROJECT_1", "rob");
return dto;
}
- @Test
- public void pause_and_resume_submits() {
- assertThat(underTest.isSubmitPaused()).isFalse();
- underTest.pauseSubmit();
- assertThat(underTest.isSubmitPaused()).isTrue();
- underTest.resumeSubmit();
- assertThat(underTest.isSubmitPaused()).isFalse();
- }
-
private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto) {
if (componentDto == null) {
assertThat(task.getOrganizationUuid()).isEqualTo(defaultOrganizationProvider.get().getUuid());
+++ /dev/null
-/*
- * 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;
-
-public class DaoDatabaseUtils extends DatabaseUtils {
-
- /**
- * Returns an escaped value in parameter, with the desired wildcards. Suitable to be used in a like sql query<br />
- * Escapes the "/", "%" and "_" characters.<br/>
- *
- * You <strong>must</strong> add "ESCAPE '/'" after your like query. It defines '/' as the escape character.
- */
- public static String buildLikeValue(String value, WildcardPosition wildcardPosition) {
- String escapedValue = escapePercentAndUnderscore(value);
- String wildcard = "%";
- switch (wildcardPosition) {
- case BEFORE:
- escapedValue = wildcard + escapedValue;
- break;
- case AFTER:
- escapedValue += wildcard;
- break;
- case BEFORE_AND_AFTER:
- escapedValue = wildcard + escapedValue + wildcard;
- break;
- default:
- throw new UnsupportedOperationException("Unhandled WildcardPosition: " + wildcardPosition);
- }
-
- return escapedValue;
- }
-
- /**
- * Replace escape percent and underscore by adding a slash just before
- */
- private static String escapePercentAndUnderscore(String value) {
- return value
- .replaceAll("/", "//")
- .replaceAll("%", "/%")
- .replaceAll("_", "/_");
- }
-}
--- /dev/null
+/*
+ * 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;
+
+public class DaoUtils {
+
+ private DaoUtils() {
+ // prevent new instances
+ }
+
+ /**
+ * Returns an escaped value in parameter, with the desired wildcards. Suitable to be used in a like sql query<br />
+ * Escapes the "/", "%" and "_" characters.<br/>
+ *
+ * You <strong>must</strong> add "ESCAPE '/'" after your like query. It defines '/' as the escape character.
+ */
+ public static String buildLikeValue(String value, WildcardPosition wildcardPosition) {
+ String escapedValue = escapePercentAndUnderscore(value);
+ String wildcard = "%";
+ switch (wildcardPosition) {
+ case BEFORE:
+ escapedValue = wildcard + escapedValue;
+ break;
+ case AFTER:
+ escapedValue += wildcard;
+ break;
+ case BEFORE_AND_AFTER:
+ escapedValue = wildcard + escapedValue + wildcard;
+ break;
+ default:
+ throw new UnsupportedOperationException("Unhandled WildcardPosition: " + wildcardPosition);
+ }
+
+ return escapedValue;
+ }
+
+ /**
+ * Replace escape percent and underscore by adding a slash just before
+ */
+ private static String escapePercentAndUnderscore(String value) {
+ return value
+ .replaceAll("/", "//")
+ .replaceAll("%", "/%")
+ .replaceAll("_", "/_");
+ }
+}
mapper(session).deleteByUuid(uuid);
}
- /**
- * Update all rows with: STATUS='PENDING', STARTED_AT=NULL, UPDATED_AT={now}
- */
- public void resetAllToPendingStatus(DbSession session) {
- mapper(session).resetAllToPendingStatus(system2.now());
- }
-
/**
* Update all tasks for the specified worker uuid which are not PENDING to:
* STATUS='PENDING', STARTED_AT=NULL, UPDATED_AT={now}.
CeQueueDto result = mapper(session).selectByUuid(eligible.getUuid());
session.commit();
- return Optional.of(result);
+ return Optional.ofNullable(result);
}
private static CeQueueMapper mapper(DbSession session) {
void insert(CeQueueDto dto);
- void resetAllToPendingStatus(@Param("updatedAt") long updatedAt);
-
int resetToPendingForWorker(@Param("workerUuid") String workerUuid, @Param("updatedAt") long updatedAt);
int updateIf(@Param("uuid") String uuid,
import java.io.IOException;
import java.io.InputStream;
-import java.nio.charset.Charset;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import org.sonar.db.DbSession;
import static com.google.common.base.Preconditions.checkArgument;
+import static java.nio.charset.StandardCharsets.UTF_8;
public class CeScannerContextDao implements Dao {
- private static final Charset UTF_8 = Charset.forName("UTF-8");
-
private final System2 system;
public CeScannerContextDao(System2 system) {
}
}
- public List<CeTaskCharacteristicDto> selectByTaskUuid(DbSession dbSession, String taskUuid) {
- return mapper(dbSession).selectByTaskUuid(taskUuid);
- }
-
public List<CeTaskCharacteristicDto> selectByTaskUuids(DbSession dbSession, List<String> taskUuids) {
return executeLargeInputs(taskUuids, uuid -> mapper(dbSession).selectByTaskUuids(uuid));
}
public interface CeTaskCharacteristicMapper {
- List<CeTaskCharacteristicDto> selectByTaskUuid(@Param("taskUuid") String taskUuid);
-
List<CeTaskCharacteristicDto> selectByTaskUuids(@Param("taskUuids") List<String> taskUuids);
void insert(CeTaskCharacteristicDto taskCharacteristic);
import static java.util.Objects.requireNonNull;
import static org.apache.commons.lang.StringUtils.isBlank;
import static org.sonar.core.util.stream.MoreCollectors.toList;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
import static org.sonar.db.DatabaseUtils.checkThatNotTooManyConditions;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
import static org.sonar.db.DatabaseUtils.executeLargeInputsIntoSet;
import static com.google.common.base.Preconditions.checkArgument;
import static java.lang.String.format;
import static org.apache.commons.lang.StringUtils.substringBeforeLast;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
import static org.sonar.db.component.ComponentValidator.checkComponentKey;
import static org.sonar.db.component.ComponentValidator.checkComponentLongName;
import static org.sonar.db.component.ComponentValidator.checkComponentName;
import org.sonar.db.WildcardPosition;
import static com.google.common.base.Preconditions.checkArgument;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
public class ComponentQuery {
private final String nameOrKeyQuery;
import static com.google.common.collect.Lists.newArrayList;
import static java.util.Objects.requireNonNull;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
import static org.sonar.db.WildcardPosition.BEFORE_AND_AFTER;
public class ComponentTreeQuery {
import org.sonar.db.WildcardPosition;
import org.sonar.db.component.ComponentDto;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
public class IssueDao implements Dao {
import static com.google.common.collect.Lists.newArrayList;
import static java.util.Objects.requireNonNull;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
import static org.sonar.db.WildcardPosition.BEFORE_AND_AFTER;
public class MeasureTreeQuery {
import static java.util.Objects.requireNonNull;
import static org.apache.commons.lang.StringUtils.defaultIfBlank;
import static org.sonar.api.utils.Paging.offset;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
/**
* Query used to get users and groups permissions
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.apache.commons.lang.StringUtils;
-import org.sonar.db.DaoDatabaseUtils;
+import org.sonar.db.DaoUtils;
import org.sonar.db.WildcardPosition;
public class ProjectQgateAssociationQuery {
if (this.projectSearch == null) {
this.projectSearchUpperLikeSql = null;
} else {
- this.projectSearchUpperLikeSql = DaoDatabaseUtils.buildLikeValue(projectSearch.toUpperCase(Locale.ENGLISH), WildcardPosition.BEFORE_AND_AFTER);
+ this.projectSearchUpperLikeSql = DaoUtils.buildLikeValue(projectSearch.toUpperCase(Locale.ENGLISH), WildcardPosition.BEFORE_AND_AFTER);
}
this.pageSize = builder.pageSize;
import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.common.base.Preconditions.checkArgument;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
import static org.sonar.db.WildcardPosition.BEFORE_AND_AFTER;
public class SearchGroupsQuery {
import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
import static org.sonar.db.WildcardPosition.BEFORE_AND_AFTER;
public class SearchUsersQuery {
import org.apache.ibatis.session.RowBounds;
import org.sonar.api.utils.System2;
import org.sonar.db.Dao;
-import org.sonar.db.DaoDatabaseUtils;
+import org.sonar.db.DaoUtils;
import org.sonar.db.DbSession;
import org.sonar.db.WildcardPosition;
}
String upperCasedNameQuery = StringUtils.upperCase(query, Locale.ENGLISH);
- return DaoDatabaseUtils.buildLikeValue(upperCasedNameQuery, WildcardPosition.BEFORE_AND_AFTER);
+ return DaoUtils.buildLikeValue(upperCasedNameQuery, WildcardPosition.BEFORE_AND_AFTER);
}
public List<GroupDto> selectByOrganizationUuid(DbSession dbSession, String organizationUuid) {
import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
+import static org.sonar.db.DaoUtils.buildLikeValue;
import static org.sonar.db.WildcardPosition.BEFORE_AND_AFTER;
public class UserMembershipQuery {
)
</insert>
- <update id="resetAllToPendingStatus" parameterType="map">
- update ce_queue set
- status='PENDING',
- started_at=NULL,
- updated_at=#{updatedAt,jdbcType=BIGINT}
- where
- status <> 'PENDING'
- </update>
-
<update id="resetToPendingForWorker">
update ce_queue set
status='PENDING',
c.text_value as "value"
</sql>
- <select id="selectByTaskUuid" parameterType="map" resultType="CeTaskCharacteristic">
- SELECT
- <include refid="columns"/>
- FROM
- ce_task_characteristics c
- WHERE
- c.task_uuid = #{taskUuid,jdbcType=VARCHAR}
- </select>
-
<select id="selectByTaskUuids" parameterType="map" resultType="CeTaskCharacteristic">
SELECT
<include refid="columns"/>
+++ /dev/null
-/*
- * 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;
-
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.db.DaoDatabaseUtils.buildLikeValue;
-import static org.sonar.db.WildcardPosition.AFTER;
-import static org.sonar.db.WildcardPosition.BEFORE;
-import static org.sonar.db.WildcardPosition.BEFORE_AND_AFTER;
-
-public class DaoDatabaseUtilsTest {
-
- @Test
- public void buildLikeValue_with_special_characters() {
- String escapedValue = "like-\\/_/%//-value";
- String wildcard = "%";
-
- assertThat(buildLikeValue("like-\\_%/-value", BEFORE)).isEqualTo(wildcard + escapedValue);
- assertThat(buildLikeValue("like-\\_%/-value", AFTER)).isEqualTo(escapedValue + wildcard);
- assertThat(buildLikeValue("like-\\_%/-value", BEFORE_AND_AFTER)).isEqualTo(wildcard + escapedValue + wildcard);
- }
-
-
-}
--- /dev/null
+/*
+ * 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;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.db.DaoUtils.buildLikeValue;
+import static org.sonar.db.WildcardPosition.AFTER;
+import static org.sonar.db.WildcardPosition.BEFORE;
+import static org.sonar.db.WildcardPosition.BEFORE_AND_AFTER;
+
+public class DaoUtilsTest {
+
+ @Test
+ public void buildLikeValue_with_special_characters() {
+ String escapedValue = "like-\\/_/%//-value";
+ String wildcard = "%";
+
+ assertThat(buildLikeValue("like-\\_%/-value", BEFORE)).isEqualTo(wildcard + escapedValue);
+ assertThat(buildLikeValue("like-\\_%/-value", AFTER)).isEqualTo(escapedValue + wildcard);
+ assertThat(buildLikeValue("like-\\_%/-value", BEFORE_AND_AFTER)).isEqualTo(wildcard + escapedValue + wildcard);
+ }
+
+
+}
assertThat(underTest.selectByUuid(db.getSession(), TASK_UUID_1).isPresent()).isFalse();
}
- @Test
- public void test_resetAllToPendingStatus() {
- insert(TASK_UUID_1, COMPONENT_UUID_1, PENDING);
- insert(TASK_UUID_2, COMPONENT_UUID_1, IN_PROGRESS);
- insert(TASK_UUID_3, COMPONENT_UUID_1, IN_PROGRESS);
- verifyCeQueueStatuses(TASK_UUID_1, PENDING, TASK_UUID_2, IN_PROGRESS, TASK_UUID_3, IN_PROGRESS);
-
- underTest.resetAllToPendingStatus(db.getSession());
- db.getSession().commit();
-
- verifyCeQueueStatuses(TASK_UUID_1, PENDING, TASK_UUID_2, PENDING, TASK_UUID_3, PENDING);
- }
-
- @Test
- public void resetAllToPendingStatus_updates_updatedAt() {
- long now = 1_334_333L;
- insert(TASK_UUID_1, COMPONENT_UUID_1, IN_PROGRESS);
- insert(TASK_UUID_2, COMPONENT_UUID_1, IN_PROGRESS);
- mockSystem2ForSingleCall(now);
-
- underTestWithSystem2Mock.resetAllToPendingStatus(db.getSession());
-
- assertThat(underTest.selectByUuid(db.getSession(), TASK_UUID_1).get().getUpdatedAt()).isEqualTo(now);
- assertThat(underTest.selectByUuid(db.getSession(), TASK_UUID_2).get().getUpdatedAt()).isEqualTo(now);
- }
-
- @Test
- public void resetAllToPendingStatus_resets_startedAt() {
- assertThat(insert(TASK_UUID_1, COMPONENT_UUID_1, PENDING).getStartedAt()).isNull();
- assertThat(underTest.peek(db.getSession(), WORKER_UUID_1, MAX_EXECUTION_COUNT).get().getUuid()).isEqualTo(TASK_UUID_1);
- assertThat(underTest.selectByUuid(db.getSession(), TASK_UUID_1).get().getStartedAt()).isNotNull();
-
- underTest.resetAllToPendingStatus(db.getSession());
-
- assertThat(underTest.selectByUuid(db.getSession(), TASK_UUID_1).get().getStartedAt()).isNull();
- }
-
- @Test
- public void resetAllToPendingStatus_does_not_reset_workerUuid_nor_executionCount() {
- CeQueueDto dto = new CeQueueDto()
- .setUuid(TASK_UUID_1)
- .setTaskType(CeTaskTypes.REPORT)
- .setComponentUuid(COMPONENT_UUID_1)
- .setStatus(IN_PROGRESS)
- .setSubmitterLogin(SUBMITTER_LOGIN)
- .setWorkerUuid(WORKER_UUID_1)
- .setExecutionCount(EXECUTION_COUNT);
- underTest.insert(db.getSession(), dto);
- db.commit();
-
- underTest.resetAllToPendingStatus(db.getSession());
-
- CeQueueDto saved = underTest.selectByUuid(db.getSession(), TASK_UUID_1).get();
- assertThat(saved.getWorkerUuid()).isEqualTo(WORKER_UUID_1);
- assertThat(saved.getExecutionCount()).isEqualTo(EXECUTION_COUNT);
- }
-
@Test
public void resetToPendingForWorker_resets_status_of_non_pending_tasks_only_for_specified_workerUuid() {
long startedAt = 2_099_888L;
private CeTaskCharacteristicDao underTest = new CeTaskCharacteristicDao();
- @Test
- public void selectByTaskUuid() {
- CeTaskCharacteristicDto dto1 = new CeTaskCharacteristicDto()
- .setKey("key1")
- .setValue("value1")
- .setUuid("uuid1")
- .setTaskUuid("task");
- CeTaskCharacteristicDto dto2 = new CeTaskCharacteristicDto()
- .setKey("key2")
- .setValue("value2")
- .setUuid("uuid2")
- .setTaskUuid("task");
- underTest.insert(dbTester.getSession(), asList(dto1, dto2));
- dbTester.getSession().commit();
-
- assertThat(underTest.selectByTaskUuid(dbTester.getSession(), "task"))
- .extracting(CeTaskCharacteristicDto::getTaskUuid, CeTaskCharacteristicDto::getUuid, CeTaskCharacteristicDto::getKey, CeTaskCharacteristicDto::getValue)
- .containsOnly(
- tuple("task", "uuid1", "key1", "value1"),
- tuple("task", "uuid2", "key2", "value2"));
- assertThat(underTest.selectByTaskUuid(dbTester.getSession(), "unknown")).isEmpty();
- }
-
@Test
public void selectByTaskUuids() {
CeTaskCharacteristicDto dto1 = new CeTaskCharacteristicDto()
* <p>
* This method is equivalent to calling {@link #massSubmit(Collection, SubmitOption...)} with a singleton list and no
* option.
- *
- * @throws IllegalStateException If submits are paused (see {@link #isSubmitPaused()})
*/
CeTask submit(CeTaskSubmit submission);
* <p>
* This method will perform significantly better that calling {@link #submit(CeTaskSubmit, SubmitOption...)} in a loop.
* </p>
- *
- * @throws IllegalStateException If submits are paused (see {@link #isSubmitPaused()})
*/
List<CeTask> massSubmit(Collection<CeTaskSubmit> submissions, SubmitOption... options);
*/
int cancelAll();
- void pauseSubmit();
-
- void resumeSubmit();
-
- boolean isSubmitPaused();
-
enum SubmitOption {
UNIQUE_QUEUE_PER_COMPONENT
}
import java.util.Map;
import java.util.Objects;
import java.util.Set;
-import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
private final UuidFactory uuidFactory;
private final DefaultOrganizationProvider defaultOrganizationProvider;
- // state
- private AtomicBoolean submitPaused = new AtomicBoolean(false);
-
public CeQueueImpl(DbClient dbClient, UuidFactory uuidFactory, DefaultOrganizationProvider defaultOrganizationProvider) {
this.dbClient = dbClient;
this.uuidFactory = uuidFactory;
}
private java.util.Optional<CeTask> submit(CeTaskSubmit submission, EnumSet<SubmitOption> submitOptions) {
- checkState(!submitPaused.get(), "Compute Engine does not currently accept new tasks");
try (DbSession dbSession = dbClient.openSession(false)) {
if (submitOptions.contains(UNIQUE_QUEUE_PER_COMPONENT)
&& submission.getComponentUuid() != null
@Override
public List<CeTask> massSubmit(Collection<CeTaskSubmit> submissions, SubmitOption... options) {
- checkState(!submitPaused.get(), "Compute Engine does not currently accept new tasks");
if (submissions.isEmpty()) {
return Collections.emptyList();
}
dbSession.commit();
}
- @Override
- public void pauseSubmit() {
- this.submitPaused.set(true);
- }
-
- @Override
- public void resumeSubmit() {
- this.submitPaused.set(false);
- }
-
- @Override
- public boolean isSubmitPaused() {
- return submitPaused.get();
- }
-
private static class CeQueueDtoToCeTask implements Function<CeQueueDto, CeTask> {
private final String defaultOrganizationUuid;
private final Map<String, ComponentDto> componentDtoByUuid;
.contains(task.getUuid());
}
- @Test
- public void submit_fails_with_ISE_if_paused() {
- underTest.pauseSubmit();
-
- expectedException.expect(IllegalStateException.class);
- expectedException.expectMessage("Compute Engine does not currently accept new tasks");
-
- submit(CeTaskTypes.REPORT, "PROJECT_1");
- }
-
@Test
public void massSubmit_returns_tasks_for_each_CeTaskSubmit_populated_from_CeTaskSubmit_and_creates_CeQueue_row_for_each() {
CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, "PROJECT_1", "rob");
assertThat(history.isPresent()).isFalse();
}
- @Test
- public void pause_and_resume_submits() {
- assertThat(underTest.isSubmitPaused()).isFalse();
- underTest.pauseSubmit();
- assertThat(underTest.isSubmitPaused()).isTrue();
- underTest.resumeSubmit();
- assertThat(underTest.isSubmitPaused()).isFalse();
- }
-
private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto) {
if (componentDto == null) {
assertThat(task.getOrganizationUuid()).isEqualTo(defaultOrganizationProvider.get().getUuid());
import org.sonar.server.tester.UserSessionRule;
import static java.lang.String.format;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.tuple;
import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
when(componentUpdater.create(any(), any(), any())).thenReturn(project);
when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(defaultOrganizationUuid), any(), eq(PROJECT_KEY),
eq(Qualifiers.PROJECT)))
- .thenReturn(true);
+ .thenReturn(true);
Map<String, String> taskCharacteristics = new HashMap<>();
taskCharacteristics.put("incremental", "true");
verify(queue).submit(submittedTask.capture());
String taskUuid = submittedTask.getValue().getUuid();
- List<CeTaskCharacteristicDto> insertedCharacteristics = db.getDbClient().ceTaskCharacteristicsDao().selectByTaskUuid(db.getSession(), taskUuid);
+ List<CeTaskCharacteristicDto> insertedCharacteristics = db.getDbClient().ceTaskCharacteristicsDao().selectByTaskUuids(db.getSession(), singletonList(taskUuid));
assertThat(insertedCharacteristics)
.extracting(CeTaskCharacteristicDto::getKey, CeTaskCharacteristicDto::getValue)
.containsOnly(tuple("incremental", "true"), tuple("pr", "mypr"));
when(componentUpdater.create(any(), any(), isNull())).thenReturn(createdProject);
when(
permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(organization.getUuid()), any(), eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
- .thenReturn(true);
+ .thenReturn(true);
when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(), eq(organization.getUuid()), any())).thenReturn(true);
underTest.submit(organization.getKey(), PROJECT_KEY, null, PROJECT_NAME, IOUtils.toInputStream("{binary}"));
when(componentUpdater.create(any(), any(), isNull())).thenReturn(createdProject);
when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(defaultOrganizationUuid), any(),
eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
- .thenReturn(true);
+ .thenReturn(true);
when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(), eq(defaultOrganizationUuid), any())).thenReturn(false);
underTest.submit(defaultOrganizationKey, PROJECT_KEY, null, PROJECT_NAME, IOUtils.toInputStream("{binary}"));
when(componentUpdater.create(any(), any(), any())).thenReturn(project);
when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(defaultOrganizationUuid), any(),
eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
- .thenReturn(true);
+ .thenReturn(true);
underTest.submit(defaultOrganizationKey, PROJECT_KEY, null, PROJECT_NAME, IOUtils.toInputStream("{binary}"));
} catch (BadRequestException e) {
assertThat(e.errors()).contains(
format("The project '%s' is already defined in SonarQube but as a module of project '%s'. " +
- "If you really want to stop directly analysing project '%s', please first delete it from SonarQube and then relaunch the analysis of project '%s'.",
+ "If you really want to stop directly analysing project '%s', please first delete it from SonarQube and then relaunch the analysis of project '%s'.",
module.getKey(), project.getKey(), project.getKey(), module.getKey()));
}
}
projects / sonarqube.git / commitdiff