}
public boolean acquire(String name, int maxDurationInSeconds) {
- return dao.acquire(name, maxDurationInSeconds);
+ return dao.acquire(name, maxDurationInSeconds).isAcquired();
}
public void release(String name) {
package org.sonar.plugins.core;
import org.junit.Test;
+import org.sonar.core.persistence.Lock;
import org.sonar.core.persistence.SemaphoreDao;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class DatabaseSemaphoreImplTest {
@Test
public void should_be_a_bridge_over_dao() {
+ Lock lock = mock(Lock.class);
SemaphoreDao dao = mock(SemaphoreDao.class);
+ when(dao.acquire(anyString(), anyInt())).thenReturn(lock);
+
DatabaseSemaphoreImpl impl = new DatabaseSemaphoreImpl(dao);
impl.acquire("do-xxx", 50000);
container.addSingleton(DefaultUserFinder.class);
container.addSingleton(ResourceTypes.class);
container.addSingleton(MetricProvider.class);
+ container.addSingleton(CheckSemaphore.class);
}
private void registerDatabaseComponents() {
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar 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.
+ *
+ * Sonar 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 Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+package org.sonar.batch.bootstrap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sonar.api.CoreProperties;
+import org.sonar.api.config.Settings;
+import org.sonar.api.resources.Project;
+import org.sonar.api.utils.SonarException;
+import org.sonar.batch.ProjectTree;
+import org.sonar.core.persistence.Lock;
+import org.sonar.core.persistence.SemaphoreDao;
+
+public class CheckSemaphore {
+
+ private static final Logger LOG = LoggerFactory.getLogger(CheckSemaphore.class);
+
+ private final SemaphoreDao semaphoreDao;
+ private final ProjectTree projectTree;
+ private final Settings settings;
+
+ public CheckSemaphore(SemaphoreDao semaphoreDao, ProjectTree projectTree, Settings settings) {
+ this.semaphoreDao = semaphoreDao;
+ this.projectTree = projectTree;
+ this.settings = settings;
+ }
+
+ public void start() {
+ if (!isInDryRunMode()) {
+ Lock lock = acquire();
+ if (!lock.isAcquired()) {
+ LOG.error(getErrorMessage(lock));
+ throw new SonarException("The project is already been analysing.");
+ }
+ }
+ }
+
+ private String getErrorMessage(Lock lock) {
+ long duration = lock.getDurationSinceLocked();
+ DurationLabel durationLabel = new DurationLabel();
+ String durationDisplay = durationLabel.label(duration);
+
+ return "It looks like an analysis of '"+ getProject().getName() +"' is already running (started "+ durationDisplay +"). " +
+ "If this is not the case, it probably means that previous analysis was interrupted " +
+ "and you should then force a re-run by using the option '"+ CoreProperties.FORCE_ANALYSIS +"=true'.";
+ }
+
+ public void stop() {
+ if (!isInDryRunMode()) {
+ release();
+ }
+ }
+
+ private Lock acquire() {
+ LOG.debug("Acquire semaphore on project : {}", getProject());
+ if (!isForceAnalyseActivated()) {
+ return semaphoreDao.acquire(getSemaphoreKey());
+ } else {
+ return semaphoreDao.acquire(getSemaphoreKey(), 0);
+ }
+ }
+
+ private void release() {
+ LOG.debug("Release semaphore on project : {}", getProject());
+ semaphoreDao.release(getSemaphoreKey());
+ }
+
+ private String getSemaphoreKey() {
+ return "batch-" + getProject().getKey();
+ }
+
+ private Project getProject() {
+ return projectTree.getRootProject();
+ }
+
+ private boolean isInDryRunMode() {
+ return settings.getBoolean(CoreProperties.DRY_RUN);
+ }
+
+ private boolean isForceAnalyseActivated() {
+ return settings.getBoolean(CoreProperties.FORCE_ANALYSIS);
+ }
+}
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar 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.
+ *
+ * Sonar 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 Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+package org.sonar.batch.bootstrap;
+
+import java.text.MessageFormat;
+
+public class DurationLabel {
+
+ private String prefixAgo = null;
+ private String suffixAgo = "ago";
+ private String seconds = "less than a minute";
+ private String minute = "about a minute";
+ private String minutes = "{0} minutes";
+ private String hour = "about an hour";
+ private String hours = "{0} hours";
+ private String day = "a day";
+ private String days = "{0} days";
+ private String month = "about a month";
+ private String months = "{0} months";
+ private String year = "about a year";
+ private String years = "{0} years";
+
+ public String label(long durationInMillis) {
+ double seconds = durationInMillis / 1000;
+ double minutes = seconds / 60;
+ double hours = minutes / 60;
+ double days = hours / 24;
+ double years = days / 365;
+
+ final String time;
+ if (seconds < 45) {
+ time = this.seconds;
+ } else if (seconds < 90) {
+ time = this.minute;
+ } else if (minutes < 45) {
+ time = MessageFormat.format(this.minutes, Math.round(minutes));
+ } else if (minutes < 90) {
+ time = this.hour;
+ } else if (hours < 24) {
+ time = MessageFormat.format(this.hours, Math.round(hours));
+ } else if (hours < 48) {
+ time = this.day;
+ } else if (days < 30) {
+ time = MessageFormat.format(this.days, Math.floor(days));
+ } else if (days < 60) {
+ time = this.month;
+ } else if (days < 365) {
+ time = MessageFormat.format(this.months, Math.floor(days / 30));
+ } else if (years < 2) {
+ time = this.year;
+ } else {
+ time = MessageFormat.format(this.years, Math.floor(years));
+ }
+
+ return join(prefixAgo, time, suffixAgo);
+ }
+
+ public String join(String prefix, String time, String suffix) {
+ StringBuilder joined = new StringBuilder();
+ if (prefix != null && prefix.length() > 0) {
+ joined.append(prefix).append(' ');
+ }
+ joined.append(time);
+ if (suffix != null && suffix.length() > 0) {
+ joined.append(' ').append(suffix);
+ }
+ return joined.toString();
+ }
+
+ public String getPrefixAgo() {
+ return prefixAgo;
+ }
+
+ public String getSuffixAgo() {
+ return suffixAgo;
+ }
+
+ public String getSeconds() {
+ return seconds;
+ }
+
+ public String getMinute() {
+ return minute;
+ }
+
+ public String getMinutes() {
+ return minutes;
+ }
+
+ public String getHour() {
+ return hour;
+ }
+
+ public String getHours() {
+ return hours;
+ }
+
+ public String getDay() {
+ return day;
+ }
+
+ public String getDays() {
+ return days;
+ }
+
+ public String getMonth() {
+ return month;
+ }
+
+ public String getMonths() {
+ return months;
+ }
+
+ public String getYear() {
+ return year;
+ }
+
+ public String getYears() {
+ return years;
+ }
+
+}
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar 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.
+ *
+ * Sonar 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 Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+package org.sonar.batch.bootstrap;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.sonar.api.CoreProperties;
+import org.sonar.api.config.Settings;
+import org.sonar.api.resources.Project;
+import org.sonar.api.utils.SonarException;
+import org.sonar.batch.ProjectTree;
+import org.sonar.core.persistence.Lock;
+import org.sonar.core.persistence.SemaphoreDao;
+
+import java.util.Date;
+
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class CheckSemaphoreTest {
+
+ private CheckSemaphore checkSemaphore;
+
+ private SemaphoreDao semaphoreDao;
+ private ProjectTree projectTree;
+ private Settings settings;
+
+ private Project project;
+ private Lock lock;
+
+ @Before
+ public void setUp() {
+ lock = mock(Lock.class);
+
+ semaphoreDao = mock(SemaphoreDao.class);
+ when(semaphoreDao.acquire(anyString())).thenReturn(lock);
+ when(semaphoreDao.acquire(anyString(), anyInt())).thenReturn(lock);
+
+ projectTree = mock(ProjectTree.class);
+ settings = new Settings();
+ setDryRunMode(false);
+ setForceMode(false);
+
+ project = new Project("key", "branch", "name");
+ when(projectTree.getRootProject()).thenReturn(project);
+
+ checkSemaphore = new CheckSemaphore(semaphoreDao, projectTree, settings);
+ }
+
+ @Test
+ public void shouldAcquireSemaphore() {
+ when(lock.isAcquired()).thenReturn(true);
+ checkSemaphore.start();
+
+ verify(semaphoreDao).acquire(anyString());
+ }
+
+ @Test
+ public void shouldUseProjectKeyInTheKeyOfTheSemaphore() {
+ project = new Project("key");
+ when(projectTree.getRootProject()).thenReturn(project);
+
+ when(lock.isAcquired()).thenReturn(true);
+ checkSemaphore.start();
+
+ verify(semaphoreDao).acquire("batch-key");
+ }
+
+ @Test
+ public void shouldUseProjectKeyAndBranchIfExistingInTheKeyOfTheSemaphore() {
+ when(lock.isAcquired()).thenReturn(true);
+ checkSemaphore.start();
+
+ verify(semaphoreDao).acquire("batch-key:branch");
+ }
+
+ @Test
+ public void shouldAcquireSemaphoreIfForceAnalyseActivated() {
+ setForceMode(true);
+ when(lock.isAcquired()).thenReturn(true);
+ checkSemaphore.start();
+ verify(semaphoreDao).acquire(anyString(), anyInt());
+ }
+
+ @Test(expected = SonarException.class)
+ public void shouldNotAcquireSemaphoreIfTheProjectIsAlreadyBeenAnalysing() {
+ when(lock.getLocketAt()).thenReturn(new Date());
+ when(lock.isAcquired()).thenReturn(false);
+ checkSemaphore.start();
+ verify(semaphoreDao, never()).acquire(anyString());
+ }
+
+ @Test
+ public void shouldNotAcquireSemaphoreInDryRunMode() {
+ setDryRunMode(true);
+ settings = new Settings().setProperty(CoreProperties.DRY_RUN, true);
+ checkSemaphore.start();
+ verify(semaphoreDao, never()).acquire(anyString());
+ verify(semaphoreDao, never()).acquire(anyString(), anyInt());
+ }
+
+ @Test
+ public void shouldReleaseSemaphore() {
+ checkSemaphore.stop();
+ verify(semaphoreDao).release(anyString());
+ }
+
+ @Test
+ public void shouldNotReleaseSemaphoreInDryRunMode() {
+ setDryRunMode(true);
+ checkSemaphore.stop();
+ verify(semaphoreDao, never()).release(anyString());
+ }
+
+ private void setDryRunMode(boolean isInDryRunMode) {
+ settings.setProperty(CoreProperties.DRY_RUN, isInDryRunMode);
+ }
+
+ private void setForceMode(boolean isInForcedMode) {
+ settings.setProperty(CoreProperties.FORCE_ANALYSIS, isInForcedMode);
+ }
+
+}
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar 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.
+ *
+ * Sonar 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 Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+package org.sonar.batch.bootstrap;
+
+import org.junit.Test;
+
+import java.text.MessageFormat;
+
+import static org.fest.assertions.Assertions.assertThat;
+
+public class DurationLabelTest {
+
+ private static final long SECOND = 1000; // One second in milliseconds
+ private static final long MINUTE = 60 * SECOND; // One minute in milliseconds
+ private static final long HOUR = 60 * MINUTE; // One hour in milliseconds
+ private static final long DAY = 24 * HOUR; // One day in milliseconds
+ private static final long MONTH = 30 * DAY; // 30 days in milliseconds
+ private static final long YEAR = 365 * DAY; // 365 days in milliseconds
+
+ @Test
+ public void testAgoSeconds() {
+ DurationLabel durationLabel = new DurationLabel();
+ String label = durationLabel.label(now() - System.currentTimeMillis());
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), durationLabel.getSeconds(), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testAgoMinute() {
+ DurationLabel durationLabel = new DurationLabel();
+ String label = durationLabel.label(now() - ago(MINUTE));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), durationLabel.getMinute(), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testAgoMinutes() {
+ DurationLabel durationlabel = new DurationLabel();
+ int minutes = 2;
+ String label = durationlabel.label(now() - ago(minutes * MINUTE));
+ String expected = durationlabel.join(durationlabel.getPrefixAgo(),
+ MessageFormat.format(durationlabel.getMinutes(), minutes), durationlabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testAgoHour() {
+ DurationLabel durationLabel = new DurationLabel();
+ String label = durationLabel.label(now() - ago(HOUR));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), durationLabel.getHour(), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testAgoHours() {
+ DurationLabel durationLabel = new DurationLabel();
+ long hours = 3;
+ String label = durationLabel.label(now() - ago(hours * HOUR));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), MessageFormat.format(durationLabel.getHours(), hours), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testAgoDay() {
+ DurationLabel durationLabel = new DurationLabel();
+ String label = durationLabel.label(now() - ago(30 * HOUR));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), durationLabel.getDay(), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testAgoDays() {
+ DurationLabel durationLabel = new DurationLabel();
+ long days = 4;
+ String label = durationLabel.label(now() - ago(days * DAY));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), MessageFormat.format(durationLabel.getDays(), days), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testAgoMonth() {
+ DurationLabel durationLabel = new DurationLabel();
+ String label = durationLabel.label(now() - ago(35 * DAY));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), durationLabel.getMonth(), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testAgoMonths() {
+ DurationLabel durationLabel = new DurationLabel();
+ long months = 2;
+ String label = durationLabel.label(now() - ago(months * MONTH));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), MessageFormat.format(durationLabel.getMonths(), months), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testYearAgo() {
+ DurationLabel durationLabel = new DurationLabel();
+ String label = durationLabel.label(now() - ago(14 * MONTH));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), durationLabel.getYear(), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ @Test
+ public void testYearsAgo() {
+ DurationLabel durationLabel = new DurationLabel();
+ long years = 7;
+ String label = durationLabel.label(now() - ago(years * YEAR));
+ String expected = durationLabel.join(durationLabel.getPrefixAgo(), MessageFormat.format(durationLabel.getYears(), years), durationLabel.getSuffixAgo());
+ assertThat(label).isEqualTo(expected);
+ }
+
+ private long ago(long offset) {
+ return System.currentTimeMillis() - offset;
+ }
+
+ private long now() {
+ return System.currentTimeMillis();
+ }
+
+}
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar 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.
+ *
+ * Sonar 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 Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+
+package org.sonar.core.persistence;
+
+import java.util.Date;
+
+/**
+ * @since 3.4
+ */
+public class Lock {
+
+ private String name;
+ private boolean acquired;
+ private Date locketAt;
+ private Date createdAt;
+ private Date updatedAt;
+ private Long durationSinceLocked;
+
+ public Lock(String name, boolean acquired, Date locketAt, Date createdAt, Date updatedAt) {
+ this.name = name;
+ this.acquired = acquired;
+ this.locketAt = locketAt;
+ this.createdAt = createdAt;
+ this.updatedAt = updatedAt;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public Date getLocketAt() {
+ return locketAt;
+ }
+
+ public Date getCreatedAt() {
+ return createdAt;
+ }
+
+ public Date getUpdatedAt() {
+ return updatedAt;
+ }
+
+ public boolean isAcquired() {
+ return acquired;
+ }
+
+ public Long getDurationSinceLocked() {
+ return durationSinceLocked;
+ }
+
+ public void setDurationSinceLocked(Long durationSinceLocked) {
+ this.durationSinceLocked = durationSinceLocked;
+ }
+}
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.mapping.Environment;
-import org.apache.ibatis.session.*;
+import org.apache.ibatis.session.Configuration;
+import org.apache.ibatis.session.ExecutorType;
+import org.apache.ibatis.session.SqlSession;
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
import org.apache.ibatis.type.JdbcType;
import org.slf4j.LoggerFactory;
import org.sonar.api.database.model.MeasureMapper;
import org.sonar.api.database.model.MeasureModel;
import org.sonar.core.config.Logback;
-import org.sonar.core.dashboard.*;
+import org.sonar.core.dashboard.ActiveDashboardDto;
+import org.sonar.core.dashboard.ActiveDashboardMapper;
+import org.sonar.core.dashboard.DashboardDto;
+import org.sonar.core.dashboard.DashboardMapper;
+import org.sonar.core.dashboard.WidgetDto;
+import org.sonar.core.dashboard.WidgetMapper;
+import org.sonar.core.dashboard.WidgetPropertyDto;
+import org.sonar.core.dashboard.WidgetPropertyMapper;
import org.sonar.core.dependency.DependencyDto;
import org.sonar.core.dependency.DependencyMapper;
import org.sonar.core.dependency.ResourceSnapshotDto;
import org.sonar.core.dependency.ResourceSnapshotMapper;
import org.sonar.core.duplication.DuplicationMapper;
import org.sonar.core.duplication.DuplicationUnitDto;
-import org.sonar.core.filter.*;
+import org.sonar.core.filter.CriterionDto;
+import org.sonar.core.filter.CriterionMapper;
+import org.sonar.core.filter.FilterColumnDto;
+import org.sonar.core.filter.FilterColumnMapper;
+import org.sonar.core.filter.FilterDto;
+import org.sonar.core.filter.FilterMapper;
import org.sonar.core.properties.PropertiesMapper;
import org.sonar.core.properties.PropertyDto;
import org.sonar.core.purge.PurgeMapper;
import org.sonar.core.purge.PurgeableSnapshotDto;
-import org.sonar.core.resource.*;
+import org.sonar.core.resource.ResourceDto;
+import org.sonar.core.resource.ResourceIndexDto;
+import org.sonar.core.resource.ResourceIndexerMapper;
+import org.sonar.core.resource.ResourceKeyUpdaterMapper;
+import org.sonar.core.resource.ResourceMapper;
+import org.sonar.core.resource.SnapshotDto;
import org.sonar.core.review.ReviewCommentDto;
import org.sonar.core.review.ReviewCommentMapper;
import org.sonar.core.review.ReviewDto;
import org.sonar.core.rule.RuleMapper;
import org.sonar.core.template.LoadedTemplateDto;
import org.sonar.core.template.LoadedTemplateMapper;
-import org.sonar.core.user.*;
+import org.sonar.core.user.AuthorDto;
+import org.sonar.core.user.AuthorMapper;
+import org.sonar.core.user.GroupDto;
+import org.sonar.core.user.GroupRoleDto;
+import org.sonar.core.user.RoleMapper;
+import org.sonar.core.user.UserDto;
+import org.sonar.core.user.UserMapper;
+import org.sonar.core.user.UserRoleDto;
import java.io.InputStream;
loadAlias(conf, "ReviewComment", ReviewCommentDto.class);
loadAlias(conf, "Rule", RuleDto.class);
loadAlias(conf, "Snapshot", SnapshotDto.class);
+ loadAlias(conf, "Semaphore", SemaphoreDto.class);
loadAlias(conf, "SchemaMigration", SchemaMigrationDto.class);
loadAlias(conf, "User", UserDto.class);
loadAlias(conf, "UserRole", UserRoleDto.class);
this.mybatis = mybatis;
}
- public boolean acquire(String name, int maxDurationInSeconds) {
+ public Lock acquire(String name, int maxDurationInSeconds) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(name), "Semaphore name must not be empty");
- Preconditions.checkArgument(maxDurationInSeconds > 0, "Semaphore max duration must be positive: " + maxDurationInSeconds);
+ Preconditions.checkArgument(maxDurationInSeconds >= 0, "Semaphore max duration must be positive: " + maxDurationInSeconds);
SqlSession session = mybatis.openSession();
try {
SemaphoreMapper mapper = session.getMapper(SemaphoreMapper.class);
- initialize(name, session, mapper);
- return doAcquire(name, maxDurationInSeconds, session, mapper);
+ Date lockedAt = org.sonar.api.utils.DateUtils.parseDate("2001-01-01");
+ createSemaphore(name, lockedAt, session, mapper);
+ boolean isAcquired = doAcquire(name, maxDurationInSeconds, session, mapper);
+ SemaphoreDto semaphore = mapper.selectSemaphore(name);
+ return createLock(semaphore, mapper, isAcquired);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public Lock acquire(String name) {
+ Preconditions.checkArgument(!Strings.isNullOrEmpty(name), "Semaphore name must not be empty");
+
+ SqlSession session = mybatis.openSession();
+ try {
+ SemaphoreMapper mapper = session.getMapper(SemaphoreMapper.class);
+ SemaphoreDto semaphore = mapper.selectSemaphore(name);
+ Date now = mapper.now();
+ if (semaphore != null) {
+ return createLock(semaphore, mapper, false);
+ } else {
+ semaphore = createSemaphore(name, now, session, mapper);
+ return createLock(semaphore, mapper, true);
+ }
} finally {
MyBatis.closeQuietly(session);
}
return ok;
}
- private void initialize(String name, SqlSession session, SemaphoreMapper mapper) {
+ private SemaphoreDto createSemaphore(String name, Date lockedAt, SqlSession session, SemaphoreMapper mapper) {
try {
SemaphoreDto semaphore = new SemaphoreDto()
- .setName(name)
- .setLockedAt(org.sonar.api.utils.DateUtils.parseDate("2001-01-01"));
+ .setName(name)
+ .setLockedAt(lockedAt);
mapper.initialize(semaphore);
session.commit();
-
+ return semaphore;
} catch (Exception e) {
// probably because of the semaphore already exists
session.rollback();
+ return null;
+ }
+ }
+
+ private Lock createLock(SemaphoreDto semaphore, SemaphoreMapper mapper, boolean acquired) {
+ Lock lock = new Lock(semaphore.getName(), acquired, semaphore.getLockedAt(), semaphore.getCreatedAt(), semaphore.getUpdatedAt());
+ if (!acquired) {
+ lock.setDurationSinceLocked(getDurationSinceLocked(semaphore, mapper));
}
+ return lock;
+ }
+
+ private long getDurationSinceLocked(SemaphoreDto semaphore, SemaphoreMapper mapper) {
+ long now = mapper.now().getTime();
+ semaphore.getLockedAt();
+ long locketAt = semaphore.getLockedAt().getTime();
+ return now - locketAt;
}
}
private String name;
private String checksum;
private Date lockedAt;
+ private Date createdAt;
+ private Date updatedAt;
public String getName() {
return name;
this.id = id;
return this;
}
+
+ public Date getCreatedAt() {
+ return createdAt;
+ }
+
+ public SemaphoreDto setCreatedAt(Date createdAt) {
+ this.createdAt = createdAt;
+ return this;
+ }
+
+ public Date getUpdatedAt() {
+ return updatedAt;
+ }
+
+ public SemaphoreDto setUpdatedAt(Date updatedAt) {
+ this.updatedAt = updatedAt;
+ return this;
+ }
}
Date now();
void release(String name);
+
+ SemaphoreDto selectSemaphore(@Param("name") String name);
+
}
update semaphores
set updated_at = current_timestamp, locked_at = current_timestamp
where name=#{name}
- AND locked_at < #{lockedBefore}
+ <if test="lockedBefore != null">
+ AND locked_at < #{lockedBefore}
+ </if>
</update>
<delete id="release" parameterType="String">
delete from semaphores where name=#{id}
</delete>
+ <select id="selectSemaphore" parameterType="String" resultType="Semaphore">
+ select s.id, s.name as name, s.locked_at as lockedAt, s.created_at as createdAt, s.updated_at as updatedAt from semaphores s where s.name=#{name}
+ </select>
+
</mapper>
@Test
public void create_and_acquire_semaphore() throws Exception {
SemaphoreDao dao = new SemaphoreDao(getMyBatis());
- assertThat(dao.acquire("foo", 60)).isTrue();
+ Lock lock = dao.acquire("foo", 60);
+ assertThat(lock.isAcquired()).isTrue();
+ assertThat(lock.getDurationSinceLocked()).isNull();
+
+ Semaphore semaphore = selectSemaphore("foo");
+ assertThat(semaphore).isNotNull();
+ assertThat(semaphore.name).isEqualTo("foo");
+ assertThat(isRecent(semaphore.createdAt, 60)).isTrue();
+ assertThat(isRecent(semaphore.updatedAt, 60)).isTrue();
+ assertThat(isRecent(semaphore.lockedAt, 60)).isTrue();
+
+ dao.release("foo");
+ assertThat(selectSemaphore("foo")).isNull();
+ }
+
+ @Test
+ public void create_and_acquire_semaphore_when_timeout_is_zeo() throws Exception {
+ SemaphoreDao dao = new SemaphoreDao(getMyBatis());
+ Lock lock = dao.acquire("foo", 0);
+ assertThat(lock.isAcquired()).isTrue();
+ assertThat(lock.getDurationSinceLocked()).isNull();
+
+ Semaphore semaphore = selectSemaphore("foo");
+ assertThat(semaphore).isNotNull();
+ assertThat(semaphore.name).isEqualTo("foo");
+ assertThat(isRecent(semaphore.createdAt, 60)).isTrue();
+ assertThat(isRecent(semaphore.updatedAt, 60)).isTrue();
+ assertThat(isRecent(semaphore.lockedAt, 60)).isTrue();
+
+ dao.release("foo");
+ assertThat(selectSemaphore("foo")).isNull();
+ }
+
+ @Test
+ public void create_and_acquire_semaphore_when_no_timeout() throws Exception {
+ SemaphoreDao dao = new SemaphoreDao(getMyBatis());
+ Lock lock = dao.acquire("foo");
+ assertThat(lock.isAcquired()).isTrue();
+ assertThat(lock.getDurationSinceLocked()).isNull();
Semaphore semaphore = selectSemaphore("foo");
assertThat(semaphore).isNotNull();
public void fail_to_acquire_locked_semaphore() throws Exception {
setupData("old_semaphore");
SemaphoreDao dao = new SemaphoreDao(getMyBatis());
- assertThat(dao.acquire("foo", Integer.MAX_VALUE)).isFalse();
+ Lock lock = dao.acquire("foo", Integer.MAX_VALUE);
+ assertThat(lock.isAcquired()).isFalse();
+ assertThat(lock.getDurationSinceLocked()).isNotNull();
Semaphore semaphore = selectSemaphore("foo");
assertThat(semaphore).isNotNull();
public void acquire_long_locked_semaphore() throws Exception {
setupData("old_semaphore");
SemaphoreDao dao = new SemaphoreDao(getMyBatis());
- assertThat(dao.acquire("foo", 60)).isTrue();
+ Lock lock = dao.acquire("foo", 60);
+ assertThat(lock.isAcquired()).isTrue();
+ assertThat(lock.getDurationSinceLocked()).isNull();
Semaphore semaphore = selectSemaphore("foo");
assertThat(semaphore).isNotNull();
assertThat(isRecent(semaphore.lockedAt, 60)).isTrue();
}
+ @Test
+ public void acquire_locked_semaphore_when_timeout_is_zeo() throws Exception {
+ setupData("old_semaphore");
+ SemaphoreDao dao = new SemaphoreDao(getMyBatis());
+ Lock lock = dao.acquire("foo", 0);
+ assertThat(lock.isAcquired()).isTrue();
+ assertThat(lock.getDurationSinceLocked()).isNull();
+
+ Semaphore semaphore = selectSemaphore("foo");
+ assertThat(semaphore).isNotNull();
+ assertThat(semaphore.name).isEqualTo("foo");
+ assertThat(isRecent(semaphore.createdAt, 60)).isFalse();
+ assertThat(isRecent(semaphore.updatedAt, 60)).isTrue();
+ assertThat(isRecent(semaphore.lockedAt, 60)).isTrue();
+
+ dao.release("foo");
+ assertThat(selectSemaphore("foo")).isNull();
+ }
+
+ @Test
+ public void fail_to_acquire_locked_semaphore_when_no_timeout() throws Exception {
+ setupData("old_semaphore");
+ SemaphoreDao dao = new SemaphoreDao(getMyBatis());
+ Lock lock = dao.acquire("foo");
+ assertThat(lock.isAcquired()).isFalse();
+ assertThat(lock.getDurationSinceLocked()).isNotNull();
+
+ Semaphore semaphore = selectSemaphore("foo");
+ assertThat(semaphore).isNotNull();
+ assertThat(semaphore.name).isEqualTo("foo");
+ assertThat(isRecent(semaphore.createdAt, 60)).isFalse();
+ assertThat(isRecent(semaphore.updatedAt, 60)).isFalse();
+ assertThat(isRecent(semaphore.lockedAt, 60)).isFalse();
+ }
+
@Test
public void test_concurrent_locks() throws Exception {
SemaphoreDao dao = new SemaphoreDao(getMyBatis());
try {
barrier.await();
for (int i = 0; i < 100; i++) {
- if (dao.acquire("my-lock", 60 * 5)) {
+ if (dao.acquire("my-lock", 60 * 5).isAcquired()) {
locks.incrementAndGet();
}
}
* @since 3.4
*/
String DRY_RUN = "sonar.dryRun";
+
+ /**
+ * @since 3.4
+ */
+ String FORCE_ANALYSIS = "sonar.forceAnalysis";
}
projects / sonarqube.git / commitdiff