import org.sonar.api.database.model.Snapshot;
import org.sonar.core.persistence.BatchSession;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.source.db.SnapshotDataDao;
import org.sonar.core.source.db.SnapshotDataDto;
@Override
public void persist() {
- BatchSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
for (Map.Entry<String, Snapshot> componentEntry : snapshots.snapshots()) {
String componentKey = componentEntry.getKey();
Snapshot snapshot = componentEntry.getValue();
}
private void insert(Iterable<MeasureModelAndDetails> values) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
MeasureMapper mapper = session.getMapper(MeasureMapper.class);
MeasureModel value = model(measure);
value.setSnapshotId(snapshot.getId());
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
MeasureMapper mapper = session.getMapper(MeasureMapper.class);
value.setId(measure.getId());
value.setSnapshotId(snapshot.getId());
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
MeasureMapper mapper = session.getMapper(MeasureMapper.class);
import org.sonar.core.graph.jdbc.GraphDto;
import org.sonar.core.graph.jdbc.GraphDtoMapper;
import org.sonar.core.persistence.BatchSession;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import java.io.StringWriter;
}
public void persist() {
- BatchSession session = myBatis.openBatchSession();
+ DbSession session = myBatis.openSession(true);
GraphDtoMapper mapper = session.getMapper(GraphDtoMapper.class);
try {
for (ComponentVertex component : projectGraph.getComponents()) {
*/
package org.sonar.core.cluster;
+import javax.annotation.CheckForNull;
public class NullQueue implements WorkQueue {
- public NullQueue(){
+ @Override
+ public void enqueue(IndexAction<?> action) {
}
@Override
- public Integer enqueue(IndexAction<?>... action) {
- // TODO Auto-generated method stub
- return null;
+ public void enqueue(Iterable<IndexAction<?>> actions) {
+
}
+ @CheckForNull
@Override
public IndexAction<?> dequeue() {
- // TODO Auto-generated method stub
return null;
}
}
*/
package org.sonar.core.cluster;
+import javax.annotation.CheckForNull;
public interface WorkQueue {
- Integer enqueue(IndexAction<?>... action);
+ void enqueue(IndexAction<?> action);
+ void enqueue(Iterable<IndexAction<?>> actions);
+
+ @CheckForNull
IndexAction<?> dequeue();
}
}
public Collection<ComponentDto> selectComponent(ComponentQuery query) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return select(query, session);
} finally {
}
public void insert(ActiveDashboardDto activeDashboardDto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
ActiveDashboardMapper mapper = session.getMapper(ActiveDashboardMapper.class);
try {
mapper.insert(activeDashboardDto);
}
public int selectMaxOrderIndexForNullUser() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
ActiveDashboardMapper mapper = session.getMapper(ActiveDashboardMapper.class);
try {
Integer max = mapper.selectMaxOrderIndexForNullUser();
}
public DashboardDto selectGlobalDashboard(String name) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
DashboardMapper mapper = session.getMapper(DashboardMapper.class);
return mapper.selectGlobalDashboard(name);
}
public void insert(DashboardDto dashboardDto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
DashboardMapper dashboardMapper = session.getMapper(DashboardMapper.class);
WidgetMapper widgetMapper = session.getMapper(WidgetMapper.class);
WidgetPropertyMapper widgetPropertyMapper = session.getMapper(WidgetPropertyMapper.class);
*/
package org.sonar.core.db;
-import org.sonar.core.cluster.IndexAction;
-
import org.apache.ibatis.session.SqlSession;
+import org.sonar.core.cluster.IndexAction;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import java.io.Serializable;
@Override
public E getByKey(K key) {
- SonarSession session = getMyBatis().openSession();
+ DbSession session = getMyBatis().openSession(false);
E item = this.doGetByKey(key, session);
MyBatis.closeQuietly(session);
return item;
}
@Override
- public E update(E item, SonarSession session) {
+ public E update(E item, DbSession session) {
session.enqueue(new IndexAction(this.getIndexName(),
IndexAction.Method.UPDATE, item.getKey()));
return this.doUpdate(item, session);
@Override
public E update(E item) {
- SonarSession session = getMyBatis().openSession();
+ DbSession session = getMyBatis().openSession(false);
try {
this.update(item, session);
session.commit();
}
@Override
- public E insert(E item, SonarSession session) {
+ public E insert(E item, DbSession session) {
session.enqueue(new IndexAction(this.getIndexName(),
IndexAction.Method.INSERT, item.getKey()));
return this.doInsert(item, session);
@Override
public E insert(E item) {
- SonarSession session = getMyBatis().openSession();
+ DbSession session = getMyBatis().openSession(false);
try {
this.insert(item, session);
session.commit();
}
@Override
- public void delete(E item, SonarSession session) {
+ public void delete(E item, DbSession session) {
session.enqueue(new IndexAction(this.getIndexName(),
IndexAction.Method.DELETE, item.getKey()));
this.doDelete(item, session);
@Override
public void delete(E item) {
- SonarSession session = getMyBatis().openSession();
+ DbSession session = getMyBatis().openSession(false);
try {
this.delete(item, session);
session.commit();
}
@Override
- public void deleteByKey(K key, SonarSession session) {
+ public void deleteByKey(K key, DbSession session) {
session.enqueue(new IndexAction(this.getIndexName(),
IndexAction.Method.DELETE, key));
this.doDeleteByKey(key, session);
@Override
public void deleteByKey(K key) {
- SonarSession session = getMyBatis().openSession();
+ DbSession session = getMyBatis().openSession(false);
try {
this.doDeleteByKey(key, session);
session.commit();
*/
package org.sonar.core.db;
-import org.sonar.core.persistence.SonarSession;
+import org.sonar.core.persistence.DbSession;
import java.io.Serializable;
E update(E item);
- E update(E item, SonarSession session);
+ E update(E item, DbSession session);
E insert(E item);
- E insert(E item, SonarSession session);
+ E insert(E item, DbSession session);
void delete(E item);
- void delete(E item, SonarSession session);
+ void delete(E item, DbSession session);
void deleteByKey(K key);
- void deleteByKey(K key, SonarSession session);
+ void deleteByKey(K key, DbSession session);
Iterable<K> keysOfRowsUpdatedAfter(long timestamp);
}
import org.apache.ibatis.session.SqlSession;
import org.sonar.api.BatchComponent;
import org.sonar.api.ServerComponent;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import java.util.Collection;
}
public List<DuplicationUnitDto> selectCandidates(int resourceSnapshotId, Integer lastSnapshotId, String language) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
DuplicationMapper mapper = session.getMapper(DuplicationMapper.class);
return mapper.selectCandidates(resourceSnapshotId, lastSnapshotId, language);
* Note that generated ids are not returned.
*/
public void insert(Collection<DuplicationUnitDto> units) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
DuplicationMapper mapper = session.getMapper(DuplicationMapper.class);
for (DuplicationUnitDto unit : units) {
*/
package org.sonar.core.graph.jdbc;
-import org.apache.ibatis.session.SqlSession;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
public class GraphDao {
}
public GraphDto selectBySnapshot(String perspectiveKey, long snapshotId) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
GraphDtoMapper mapper = session.getMapper(GraphDtoMapper.class);
return mapper.selectBySnapshot(perspectiveKey, snapshotId);
}
public GraphDto selectByComponent(String perspectiveKey, String componentKey) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
GraphDtoMapper mapper = session.getMapper(GraphDtoMapper.class);
return mapper.selectByComponent(perspectiveKey, componentKey);
}
public void save(ActionPlanDto actionPlanDto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
session.getMapper(ActionPlanMapper.class).insert(actionPlanDto);
session.commit();
}
public void update(ActionPlanDto actionPlanDto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
session.getMapper(ActionPlanMapper.class).update(actionPlanDto);
session.commit();
}
public void delete(String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
session.getMapper(ActionPlanMapper.class).delete(key);
session.commit();
}
public ActionPlanDto findByKey(String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ActionPlanMapper.class).findByKey(key);
} finally {
if (keys.isEmpty()) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
List<ActionPlanDto> dtosList = newArrayList();
List<List<String>> keysPartition = Lists.partition(newArrayList(keys), 1000);
}
public List<ActionPlanDto> findOpenByProjectId(Long projectId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ActionPlanMapper.class).findOpenByProjectId(projectId);
} finally {
}
public List<ActionPlanDto> findByNameAndProjectId(String name, Long projectId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ActionPlanMapper.class).findByNameAndProjectId(name, projectId);
} finally {
}
public List<ActionPlanStatsDto> findByProjectId(Long projectId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ActionPlanStatsMapper.class).findByProjectId(projectId);
} finally {
}
public List<FieldDiffs> selectChangelogByIssue(String issueKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
List<FieldDiffs> result = Lists.newArrayList();
for (IssueChangeDto dto : selectByIssuesAndType(session, Arrays.asList(issueKey), IssueChangeDto.TYPE_FIELD_CHANGE)) {
}
public void selectChangelogOnNonClosedIssuesByModuleAndType(Integer componentId, ResultHandler handler) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
Map<String, Object> params = newHashMap();
params.put("componentId", componentId);
@CheckForNull
public DefaultIssueComment selectCommentByKey(String commentKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
IssueChangeMapper mapper = session.getMapper(IssueChangeMapper.class);
IssueChangeDto dto = mapper.selectByKeyAndType(commentKey, IssueChangeDto.TYPE_COMMENT);
}
public boolean delete(String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
IssueChangeMapper mapper = session.getMapper(IssueChangeMapper.class);
int count = mapper.delete(key);
}
public boolean update(IssueChangeDto change) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
IssueChangeMapper mapper = session.getMapper(IssueChangeMapper.class);
int count = mapper.update(change);
@CheckForNull
public IssueDto selectByKey(String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
IssueMapper mapper = session.getMapper(IssueMapper.class);
return mapper.selectByKey(key);
}
public void selectNonClosedIssuesByModule(int componentId, ResultHandler handler) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
session.select("org.sonar.core.issue.db.IssueMapper.selectNonClosedIssuesByModule", componentId, handler);
@VisibleForTesting
List<IssueDto> selectIssueIds(IssueQuery query, @Nullable Integer userId, Integer maxResult) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectIssueIds(query, userId, maxResult, session);
} finally {
@VisibleForTesting
List<IssueDto> selectIssueIds(IssueQuery query) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectIssueIds(query, null, Integer.MAX_VALUE, session);
} finally {
}
public List<IssueDto> selectIssues(IssueQuery query) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectIssues(query, null, session);
} finally {
@VisibleForTesting
List<IssueDto> selectByIds(Collection<Long> ids) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByIds(ids, session);
} finally {
@CheckForNull
public IssueFilterDto selectById(Long id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
session.getMapper(IssueFilterMapper.class);
return getMapper(session).selectById(id);
}
public List<IssueFilterDto> selectByUser(String user) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getMapper(session).selectByUser(user);
} finally {
}
public List<IssueFilterDto> selectFavoriteFiltersByUser(String user) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getMapper(session).selectFavoriteFiltersByUser(user);
} finally {
}
public List<IssueFilterDto> selectSharedFilters() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getMapper(session).selectSharedFilters();
} finally {
}
public void insert(IssueFilterDto filter) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
getMapper(session).insert(filter);
session.commit();
}
public void update(IssueFilterDto filter) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
getMapper(session).update(filter);
session.commit();
}
public void delete(Long id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
getMapper(session).delete(id);
session.commit();
}
public IssueFilterFavouriteDto selectById(Long id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getMapper(session).selectById(id);
} finally {
}
public List<IssueFilterFavouriteDto> selectByFilterId(Long filterId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getMapper(session).selectByFilterId(filterId);
} finally {
}
public void insert(IssueFilterFavouriteDto filter) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
getMapper(session).insert(filter);
session.commit();
}
public void delete(Long id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
getMapper(session).delete(id);
session.commit();
}
public void deleteByFilterId(Long filterId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
getMapper(session).deleteByFilterId(filterId);
session.commit();
}
public List<Object> selectIssuesColumn(IssueQuery query, String column, @Nullable Integer userId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
IssueStatsMapper mapper = session.getMapper(IssueStatsMapper.class);
return mapper.selectIssuesColumn(query, column, query.componentRoots(), userId, query.requiredRole());
import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RuleFinder;
import org.sonar.core.persistence.BatchSession;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import java.util.Arrays;
private List<DefaultIssue> batchInsert(Iterable<DefaultIssue> issues, Date now) {
List<DefaultIssue> toBeUpdated = Lists.newArrayList();
- SqlSession batchSession = mybatis.openBatchSession();
+ DbSession batchSession = mybatis.openSession(true);
int count = 0;
IssueMapper issueMapper = batchSession.getMapper(IssueMapper.class);
IssueChangeMapper issueChangeMapper = batchSession.getMapper(IssueChangeMapper.class);
private void update(List<DefaultIssue> toBeUpdated, Date now) {
if (!toBeUpdated.isEmpty()) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
IssueMapper issueMapper = session.getMapper(IssueMapper.class);
IssueChangeMapper issueChangeMapper = session.getMapper(IssueChangeMapper.class);
SqlSession session = null;
Connection connection = null;
try {
- session = mybatis.openSession();
+ session = mybatis.openSession(false);
prepareContext(context, filter, session);
if (isValid(filter, context)) {
}
public MeasureDataDto findByComponentKeyAndMetricKey(String componentKey, String metricKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
MeasureDataMapper mapper = session.getMapper(MeasureDataMapper.class);
return mapper.findByComponentKeyAndMetricKey(componentKey, metricKey);
}
public MeasureFilterDto findSystemFilterByName(String name) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
MeasureFilterMapper mapper = session.getMapper(MeasureFilterMapper.class);
return mapper.findSystemFilterByName(name);
}
public void insert(MeasureFilterDto filter) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
MeasureFilterMapper mapper = session.getMapper(MeasureFilterMapper.class);
try {
mapper.insert(filter);
import org.apache.ibatis.session.SqlSession;
import org.sonar.api.BatchComponent;
import org.sonar.api.ServerComponent;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import java.util.Collections;
}
public void insert(List<NotificationQueueDto> dtos) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
for (NotificationQueueDto dto : dtos) {
session.getMapper(NotificationQueueMapper.class).insert(dto);
}
public void delete(List<NotificationQueueDto> dtos) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
for (NotificationQueueDto dto : dtos) {
session.getMapper(NotificationQueueMapper.class).delete(dto.getId());
if (count < 1) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(NotificationQueueMapper.class).findOldest(count);
} finally {
}
public long count() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(NotificationQueueMapper.class).count();
} finally {
* @return a paginated list of users.
*/
public List<UserWithPermissionDto> selectUsers(PermissionQuery query, @Nullable Long componentId, int offset, int limit) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
Map<String, Object> params = newHashMap();
params.put(QUERY_PARAMETER, query);
* @return a non paginated list of groups.
*/
public List<GroupWithPermissionDto> selectGroups(PermissionQuery query, @Nullable Long componentId) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
Map<String, Object> params = newHashMap();
params.put(QUERY_PARAMETER, query);
public void applyPermissionTemplate(String templateKey, Long resourceId) {
PermissionTemplateDto permissionTemplate = getPermissionTemplateWithPermissions(templateKey);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
removeAllPermissions(resourceId, session);
List<PermissionTemplateUserDto> usersPermissions = permissionTemplate.getUsersPermissions();
* @return a paginated list of users.
*/
public List<UserWithPermissionDto> selectUsers(PermissionQuery query, Long templateId, int offset, int limit) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
Map<String, Object> params = newHashMap();
params.put(QUERY_PARAMETER, query);
* @return a non paginated list of groups.
*/
public List<GroupWithPermissionDto> selectGroups(PermissionQuery query, Long templateId) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
Map<String, Object> params = newHashMap();
params.put(QUERY_PARAMETER, query);
@CheckForNull
public PermissionTemplateDto selectTemplateByKey(String templateKey) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
return mapper.selectByKey(templateKey);
@CheckForNull
public PermissionTemplateDto selectPermissionTemplate(String templateKey) {
PermissionTemplateDto permissionTemplate = null;
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
permissionTemplate = mapper.selectByKey(templateKey);
}
public List<PermissionTemplateDto> selectAllPermissionTemplates() {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return session.selectList("selectAllPermissionTemplates");
} finally {
.setKeyPattern(keyPattern)
.setCreatedAt(creationDate)
.setUpdatedAt(creationDate);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
mapper.insert(permissionTemplate);
}
public void deletePermissionTemplate(Long templateId) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
mapper.deleteUsersPermissions(templateId);
.setDescription(description)
.setKeyPattern(keyPattern)
.setUpdatedAt(now());
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
mapper.update(permissionTemplate);
.setPermission(permission)
.setCreatedAt(now())
.setUpdatedAt(now());
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
mapper.insertUserPermission(permissionTemplateUser);
.setTemplateId(templateId)
.setPermission(permission)
.setUserId(userId);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
mapper.deleteUserPermission(permissionTemplateUser);
.setGroupId(groupId)
.setCreatedAt(now())
.setUpdatedAt(now());
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
mapper.insertGroupPermission(permissionTemplateGroup);
.setTemplateId(templateId)
.setPermission(permission)
.setGroupId(groupId);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
PermissionTemplateMapper mapper = session.getMapper(PermissionTemplateMapper.class);
mapper.deleteGroupPermission(permissionTemplateGroup);
import java.util.List;
import java.util.Map;
-public class BatchSession extends SonarSession {
+public class BatchSession extends DbSession {
public static final int MAX_BATCH_SIZE = 250;
}
public Integer getVersion() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
List<Integer> versions = session.getMapper(SchemaMigrationMapper.class).selectVersions();
if (!versions.isEmpty()) {
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube 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.
+ *
+ * SonarQube 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.core.persistence;
+
+import org.apache.ibatis.session.SqlSession;
+
+import org.apache.ibatis.executor.BatchResult;
+import org.apache.ibatis.session.Configuration;
+import org.apache.ibatis.session.ResultHandler;
+import org.apache.ibatis.session.RowBounds;
+import org.sonar.core.cluster.IndexAction;
+import org.sonar.core.cluster.WorkQueue;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class DbSession implements SqlSession {
+
+ private List<IndexAction<?>> actions;
+
+ private WorkQueue queue;
+ private SqlSession session;
+
+ DbSession(WorkQueue queue, SqlSession session) {
+ this.session = session;
+ this.queue = queue;
+ this.actions = new ArrayList<IndexAction<?>>();
+ }
+
+ public void enqueue(IndexAction action) {
+ this.actions.add(action);
+ }
+
+ @Override
+ public void commit() {
+ session.commit();
+ queue.enqueue(actions);
+ }
+
+ @Override
+ public void commit(boolean force) {
+ session.commit(force);
+ queue.enqueue(actions);
+ }
+
+ /**
+ * We only care about the the commit section.
+ * The rest is simply passed to its parent.
+ */
+
+ @Override
+ public <T> T selectOne(String statement) {
+ return session.selectOne(statement);
+ }
+
+ @Override
+ public <T> T selectOne(String statement, Object parameter) {
+ return session.selectOne(statement, parameter);
+ }
+
+ @Override
+ public <E> List<E> selectList(String statement) {
+ return session.selectList(statement);
+ }
+
+ @Override
+ public <E> List<E> selectList(String statement, Object parameter) {
+ return session.selectList(statement, parameter);
+ }
+
+ @Override
+ public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
+ return session.selectList(statement, parameter, rowBounds);
+ }
+
+ @Override
+ public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
+ return session.selectMap(statement, mapKey);
+ }
+
+ @Override
+ public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
+ return session.selectMap(statement, parameter, mapKey);
+ }
+
+ @Override
+ public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
+ return session.selectMap(statement, parameter, mapKey, rowBounds);
+ }
+
+ @Override
+ public void select(String statement, Object parameter, ResultHandler handler) {
+ session.select(statement, parameter, handler);
+ }
+
+ @Override
+ public void select(String statement, ResultHandler handler) {
+ session.select(statement, handler);
+ }
+
+ @Override
+ public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
+ session.select(statement, parameter, rowBounds, handler);
+ }
+
+ @Override
+ public int insert(String statement) {
+ return session.insert(statement);
+ }
+
+ @Override
+ public int insert(String statement, Object parameter) {
+ return session.insert(statement, parameter);
+ }
+
+ @Override
+ public int update(String statement) {
+ return session.update(statement);
+ }
+
+ @Override
+ public int update(String statement, Object parameter) {
+ return session.update(statement, parameter);
+ }
+
+ @Override
+ public int delete(String statement) {
+ return session.delete(statement);
+ }
+
+ @Override
+ public int delete(String statement, Object parameter) {
+ return session.delete(statement, parameter);
+ }
+
+ @Override
+ public void rollback() {
+ session.rollback();
+ }
+
+ @Override
+ public void rollback(boolean force) {
+ session.rollback(force);
+ }
+
+ @Override
+ public List<BatchResult> flushStatements() {
+ return session.flushStatements();
+ }
+
+ @Override
+ public void close() {
+ session.close();
+ }
+
+ @Override
+ public void clearCache() {
+ session.clearCache();
+ }
+
+ @Override
+ public Configuration getConfiguration() {
+ return session.getConfiguration();
+ }
+
+ @Override
+ public <T> T getMapper(Class<T> type) {
+ return session.getMapper(type);
+ }
+
+ @Override
+ public Connection getConnection() {
+ return session.getConnection();
+ }
+}
return sessionFactory;
}
- public SonarSession openSession() {
- SqlSession session = sessionFactory.openSession(ExecutorType.REUSE);
- return new SonarSession(queue, session);
+ /**
+ * @deprecated since 4.4. Replaced by <code>openSession(false)</code>.
+ */
+ @Deprecated
+ public SqlSession openSession() {
+ return openSession(false);
}
+ /**
+ * @deprecated since 4.4. Replaced by <code>openSession(true)</code>.
+ */
+ @Deprecated
public BatchSession openBatchSession() {
- SqlSession session = sessionFactory.openSession(ExecutorType.BATCH);
- return new BatchSession(queue, session);
+ return (BatchSession) openSession(true);
+ }
+
+ /**
+ * @since 4.4
+ */
+ public DbSession openSession(boolean batch) {
+ if (batch) {
+ SqlSession session = sessionFactory.openSession(ExecutorType.BATCH);
+ return new BatchSession(queue, session);
+ }
+ SqlSession session = sessionFactory.openSession(ExecutorType.REUSE);
+ return new DbSession(queue, session);
}
public static void closeQuietly(SqlSession session) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(name), SEMAPHORE_NAME_MUST_NOT_BE_EMPTY);
Preconditions.checkArgument(maxAgeInSeconds >= 0, "Semaphore max age must be positive: " + maxAgeInSeconds);
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
SemaphoreMapper mapper = session.getMapper(SemaphoreMapper.class);
Date now = mapper.now();
public Semaphores.Semaphore acquire(String name) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(name), SEMAPHORE_NAME_MUST_NOT_BE_EMPTY);
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
SemaphoreMapper mapper = session.getMapper(SemaphoreMapper.class);
Date now = mapper.now();
public void update(Semaphores.Semaphore semaphore) {
Preconditions.checkArgument(semaphore != null, "Semaphore must not be null");
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
SemaphoreMapper mapper = session.getMapper(SemaphoreMapper.class);
mapper.update(semaphore.getName());
public void release(String name) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(name), SEMAPHORE_NAME_MUST_NOT_BE_EMPTY);
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
session.getMapper(SemaphoreMapper.class).release(name);
session.commit();
+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 SonarSource
- * mailto:contact AT sonarsource DOT com
- *
- * SonarQube 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.
- *
- * SonarQube 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.core.persistence;
-
-import org.apache.ibatis.session.SqlSession;
-
-import org.apache.ibatis.executor.BatchResult;
-import org.apache.ibatis.session.Configuration;
-import org.apache.ibatis.session.ResultHandler;
-import org.apache.ibatis.session.RowBounds;
-import org.sonar.core.cluster.IndexAction;
-import org.sonar.core.cluster.WorkQueue;
-
-import java.sql.Connection;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-public class SonarSession implements SqlSession {
-
- private List<IndexAction> actions;
-
- private WorkQueue queue;
- private SqlSession session;
-
- SonarSession(WorkQueue queue, SqlSession session) {
- this.session = session;
- this.queue = queue;
- this.actions = new ArrayList<IndexAction>();
- }
-
- public void enqueue(IndexAction action) {
- this.actions.add(action);
- }
-
- @Override
- public void commit() {
- session.commit();
- queue.enqueue(actions.toArray(new IndexAction[0]));
- }
-
- @Override
- public void commit(boolean force) {
- session.commit(force);
- queue.enqueue(actions.toArray(new IndexAction[0]));
- }
-
- /**
- * We only care about the the commit section.
- * The rest is simply passed to its parent.
- */
-
- @Override
- public <T> T selectOne(String statement) {
- return session.selectOne(statement);
- }
-
- @Override
- public <T> T selectOne(String statement, Object parameter) {
- return session.selectOne(statement, parameter);
- }
-
- @Override
- public <E> List<E> selectList(String statement) {
- return session.selectList(statement);
- }
-
- @Override
- public <E> List<E> selectList(String statement, Object parameter) {
- return session.selectList(statement, parameter);
- }
-
- @Override
- public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
- return session.selectList(statement, parameter, rowBounds);
- }
-
- @Override
- public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
- return session.selectMap(statement, mapKey);
- }
-
- @Override
- public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
- return session.selectMap(statement, parameter, mapKey);
- }
-
- @Override
- public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
- return session.selectMap(statement, parameter, mapKey, rowBounds);
- }
-
- @Override
- public void select(String statement, Object parameter, ResultHandler handler) {
- session.select(statement, parameter, handler);
- }
-
- @Override
- public void select(String statement, ResultHandler handler) {
- session.select(statement, handler);
- }
-
- @Override
- public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
- session.select(statement, parameter, rowBounds, handler);
- }
-
- @Override
- public int insert(String statement) {
- return session.insert(statement);
- }
-
- @Override
- public int insert(String statement, Object parameter) {
- return session.insert(statement, parameter);
- }
-
- @Override
- public int update(String statement) {
- return session.update(statement);
- }
-
- @Override
- public int update(String statement, Object parameter) {
- return session.update(statement, parameter);
- }
-
- @Override
- public int delete(String statement) {
- return session.delete(statement);
- }
-
- @Override
- public int delete(String statement, Object parameter) {
- return session.delete(statement, parameter);
- }
-
- @Override
- public void rollback() {
- session.rollback();
- }
-
- @Override
- public void rollback(boolean force) {
- session.rollback(force);
- }
-
- @Override
- public List<BatchResult> flushStatements() {
- return session.flushStatements();
- }
-
- @Override
- public void close() {
- session.close();
- }
-
- @Override
- public void clearCache() {
- session.clearCache();
- }
-
- @Override
- public Configuration getConfiguration() {
- return session.getConfiguration();
- }
-
- @Override
- public <T> T getMapper(Class<T> type) {
- return session.getMapper(type);
- }
-
- @Override
- public Connection getConnection() {
- return session.getConnection();
- }
-}
}
public void reportGlobalModification() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
reportGlobalModification(session);
session.commit();
import org.apache.ibatis.session.SqlSession;
import org.sonar.api.BatchComponent;
import org.sonar.api.ServerComponent;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import javax.annotation.Nullable;
* @return the list of logins (maybe be empty - obviously)
*/
public List<String> findUsersForNotification(String notificationDispatcherKey, String notificationChannelKey, @Nullable Long resourceId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
return mapper.findUsersForNotification(NOTIFICATION_PREFIX + notificationDispatcherKey + "." + notificationChannelKey, resourceId);
}
public List<String> findNotificationSubscribers(String notificationDispatcherKey, String notificationChannelKey, @Nullable String componentKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
return mapper.findNotificationSubscribers(NOTIFICATION_PREFIX + notificationDispatcherKey + "." + notificationChannelKey, componentKey);
}
public List<PropertyDto> selectGlobalProperties() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
return mapper.selectGlobalProperties();
}
public PropertyDto selectGlobalProperty(String propertyKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
return mapper.selectByKey(new PropertyDto().setKey(propertyKey));
}
public List<PropertyDto> selectProjectProperties(String resourceKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
return mapper.selectProjectProperties(resourceKey);
}
public PropertyDto selectProjectProperty(long resourceId, String propertyKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
return mapper.selectByKey(new PropertyDto().setKey(propertyKey).setResourceId(resourceId));
}
public void setProperty(PropertyDto property) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
setProperty(property, session);
session.commit();
}
public void deleteProjectProperty(String key, Long projectId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteProjectProperty(key, projectId, session);
session.commit();
}
public void deleteProjectProperties(String key, String value) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteProjectProperties(key, value, session);
session.commit();
}
public void deleteGlobalProperties() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
mapper.deleteGlobalProperties();
}
public void deleteGlobalProperty(String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteGlobalProperty(key, session);
session.commit();
}
public void deleteAllProperties(String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
mapper.deleteAllProperties(key);
}
public void saveGlobalProperties(Map<String, String> properties) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
for (Map.Entry<String, String> entry : properties.entrySet()) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(newKey), "New property key must not be empty");
if (!newKey.equals(oldKey)) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
mapper.renamePropertyKey(oldKey, newKey);
* Update all properties (global and projects ones) with a given key and value to a new value
*/
public void updateProperties(String key, String oldValue, String newValue) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
updateProperties(key, oldValue, newValue, session);
session.commit();
import org.apache.ibatis.session.SqlSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.resource.ResourceDao;
import org.sonar.core.resource.ResourceDto;
}
public PurgeDao purge(PurgeConfiguration conf) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
PurgeMapper mapper = session.getMapper(PurgeMapper.class);
PurgeCommands commands = new PurgeCommands(session, mapper, profiler);
try {
}
public List<PurgeableSnapshotDto> selectPurgeableSnapshots(long resourceId) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
PurgeMapper mapper = session.getMapper(PurgeMapper.class);
List<PurgeableSnapshotDto> result = Lists.newArrayList();
}
public PurgeDao deleteResourceTree(long rootProjectId) {
- final SqlSession session = mybatis.openBatchSession();
+ final DbSession session = mybatis.openSession(true);
final PurgeMapper mapper = session.getMapper(PurgeMapper.class);
try {
deleteProject(rootProjectId, mapper, new PurgeCommands(session, profiler));
}
public PurgeDao deleteSnapshots(PurgeSnapshotQuery query) {
- final SqlSession session = mybatis.openBatchSession();
+ final DbSession session = mybatis.openSession(true);
try {
new PurgeCommands(session, profiler).deleteSnapshots(query);
return this;
}
public List<ProjectQgateAssociationDto> selectProjects(ProjectQgateAssociationQuery query, Long gateId, int offset, int limit) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
Map<String, Object> params = ImmutableMap.of("query", query, "gateId", gateId.toString());
return session.selectList("org.sonar.core.qualitygate.db.ProjectQgateAssociationMapper.selectProjects", params, new RowBounds(offset, limit));
}
public void insert(QualityGateConditionDto newQualityGate) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
insert(newQualityGate, session);
session.commit();
}
public Collection<QualityGateConditionDto> selectForQualityGate(long qGateId) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return selectForQualityGate(qGateId, session);
} finally {
}
public QualityGateConditionDto selectById(long id) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return selectById(id, session);
} finally {
}
public void delete(QualityGateConditionDto qGate) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
delete(qGate, session);
session.commit();
}
public void update(QualityGateConditionDto qGate) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
update(qGate, session);
session.commit();
}
public void deleteConditionsWithInvalidMetrics() {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
deleteConditionsWithInvalidMetrics(session);
session.commit();
}
public void insert(QualityGateDto newQualityGate) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
insert(newQualityGate, session);
session.commit();
}
public Collection<QualityGateDto> selectAll() {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return selectAll(session);
} finally {
}
public QualityGateDto selectByName(String name) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return selectByName(name, session);
} finally {
}
public QualityGateDto selectById(long id) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return selectById(id, session);
} finally {
}
public void delete(QualityGateDto qGate) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
delete(qGate, session);
session.commit();
}
public void update(QualityGateDto qGate) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
update(qGate, session);
session.commit();
}
public void insert(ActiveRuleDto dto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insert(dto, session);
session.commit();
}
public void update(ActiveRuleDto dto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
update(dto, session);
session.commit();
}
public void delete(int activeRuleId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
delete(activeRuleId, session);
session.commit();
}
public void deleteFromRule(int ruleId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteFromRule(ruleId, session);
session.commit();
}
public void deleteFromProfile(int profileId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteFromProfile(profileId, session);
session.commit();
}
public List<ActiveRuleDto> selectByIds(List<Integer> ids) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByIds(ids, session);
} finally {
}
public List<ActiveRuleDto> selectAll() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectAll(session);
} finally {
}
public List<ActiveRuleDto> selectByRuleId(int ruleId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByRuleId(ruleId, session);
} finally {
}
public List<ActiveRuleDto> selectByProfileId(int profileId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByProfileId(profileId, session);
} finally {
@CheckForNull
public ActiveRuleDto selectById(int id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectById(id, session);
} finally {
@CheckForNull
public ActiveRuleDto selectByProfileAndRule(int profileId, int ruleId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByProfileAndRule(profileId, ruleId, session);
} finally {
}
public void insert(ActiveRuleParamDto dto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insert(dto, session);
session.commit();
}
public void update(ActiveRuleParamDto dto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
update(dto, session);
session.commit();
}
public void deleteParameter(int activeRuleParamId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteParameter(activeRuleParamId, session);
session.commit();
}
public void deleteParameters(int activeRuleId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteParameters(activeRuleId, session);
session.commit();
}
public void deleteParametersFromProfile(int profileId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteParametersFromProfile(profileId, session);
session.commit();
}
public ActiveRuleParamDto selectParamById(Integer activeRuleParamId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ActiveRuleMapper.class).selectParamById(activeRuleParamId);
} finally {
}
public ActiveRuleParamDto selectParamByActiveRuleAndKey(int activeRuleId, String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectParamByActiveRuleAndKey(activeRuleId, key, session);
} finally {
}
public List<ActiveRuleParamDto> selectParamsByActiveRuleId(int activeRuleId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectParamsByActiveRuleId(activeRuleId, session);
} finally {
}
public List<ActiveRuleParamDto> selectParamsByActiveRuleIds(List<Integer> activeRuleIds) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectParamsByActiveRuleIds(activeRuleIds, session);
} finally {
}
public List<ActiveRuleParamDto> selectAllParams() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectAllParams(session);
} finally {
}
public List<ActiveRuleParamDto> selectParamsByProfileId(int profileId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ActiveRuleMapper.class).selectParamsByProfileId(profileId);
} finally {
}
public void insert(QualityProfileDto dto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insert(dto, session);
session.commit();
}
public void update(QualityProfileDto dto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
update(dto, session);
session.commit();
}
public void delete(int id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
delete(id, session);
session.commit();
}
public List<QualityProfileDto> selectAll() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(QualityProfileMapper.class).selectAll();
} finally {
}
public QualityProfileDto selectDefaultProfile(String language, String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectDefaultProfile(language, key, session);
} finally {
}
public QualityProfileDto selectByProjectAndLanguage(long projectId, String language, String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(QualityProfileMapper.class).selectByProjectAndLanguage(projectId, language, key);
} finally {
}
public List<QualityProfileDto> selectByLanguage(String language) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(QualityProfileMapper.class).selectByLanguage(language);
} finally {
@CheckForNull
public QualityProfileDto selectById(int id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectById(id, session);
} finally {
@CheckForNull
public QualityProfileDto selectParent(int childId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectParent(childId, session);
} finally {
}
public List<QualityProfileDto> selectChildren(String name, String language) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectChildren(name, language, session);
} finally {
}
public int countChildren(String name, String language) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return countChildren(name, language, session);
} finally {
}
public QualityProfileDto selectByNameAndLanguage(String name, String language) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByNameAndLanguage(name, language, session);
} finally {
}
public List<ComponentDto> selectProjects(String propertyKey, String propertyValue) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectProjects(propertyKey, propertyValue, session);
} finally {
}
public int countProjects(String propertyKey, String propertyValue) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(QualityProfileMapper.class).countProjects(propertyKey, propertyValue);
} finally {
}
public void updateUsedColumn(int profileId, boolean used) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
session.getMapper(QualityProfileMapper.class).updatedUsedColumn(profileId, used);
session.commit();
public void grantUserRole(Resource resource, String login, String role) {
if (resource.getId() != null) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
UserDto user = session.getMapper(UserMapper.class).selectUserByLogin(login);
if (user != null) {
public void grantGroupRole(Resource resource, String groupName, String role) {
if (resource.getId() != null) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
permissionFacade.deleteGroupPermission(Long.valueOf(resource.getId()), groupName, role, session);
permissionFacade.insertGroupPermission(Long.valueOf(resource.getId()), groupName, role, session);
}
public List<ResourceDto> getResources(ResourceQuery query) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ResourceMapper.class).selectResources(query);
} finally {
*/
@CheckForNull
public ResourceDto getResource(ResourceQuery query) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getResource(query, session);
} finally {
}
public List<Long> getResourceIds(ResourceQuery query) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ResourceMapper.class).selectResourceIds(query);
} finally {
}
public ResourceDto getResource(long projectId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getResource(projectId, session);
} finally {
}
public List<ResourceDto> getDescendantProjects(long projectId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getDescendantProjects(projectId, session);
} finally {
}
public ResourceDao insertOrUpdate(ResourceDto... resources) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
ResourceMapper mapper = session.getMapper(ResourceMapper.class);
try {
for (ResourceDto resource : resources) {
if (ids.isEmpty()) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
List<ComponentDto> components = newArrayList();
List<List<Long>> partitionList = Lists.partition(newArrayList(ids), 1000);
@CheckForNull
public Component findById(Long id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return findById(id, session);
} finally {
if (componentRootKeys.isEmpty()) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ResourceMapper.class).selectAuthorizedChildrenComponentIds(componentRootKeys, userId, role);
} finally {
@CheckForNull
public ResourceDto getRootProjectByComponentKey(String componentKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ResourceMapper.class).selectRootProjectByComponentKey(componentKey);
} finally {
@CheckForNull
public ResourceDto getRootProjectByComponentId(Long componentId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ResourceMapper.class).selectRootProjectByComponentId(componentId);
} finally {
if (qualifiers.isEmpty()) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return toComponents(session.getMapper(ResourceMapper.class).selectProjectsByQualifiers(qualifiers));
} finally {
if (qualifiers.isEmpty()) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return toComponents(session.getMapper(ResourceMapper.class).selectProjectsIncludingNotCompletedOnesByQualifiers(qualifiers));
} finally {
if (qualifiers.isEmpty()) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return toComponents(session.getMapper(ResourceMapper.class).selectGhostsProjects(qualifiers));
} finally {
if (qualifiers.isEmpty()) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ResourceMapper.class).selectProvisionedProjects(qualifiers);
} finally {
* Return provisioned project with given key
*/
public ResourceDto selectProvisionedProject(String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return session.getMapper(ResourceMapper.class).selectProvisionedProject(key);
} finally {
import org.apache.ibatis.session.SqlSession;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.Scopes;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
public class ResourceIndexerDao {
* This method is reentrant. It can be executed even if the project is already indexed.
*/
public ResourceIndexerDao indexProject(final int rootProjectId) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
ResourceIndexerMapper mapper = session.getMapper(ResourceIndexerMapper.class);
doIndexProject(rootProjectId, session, mapper);
* This method is reentrant. It can be executed even if some projects are already indexed.
*/
public ResourceIndexerDao indexProjects() {
- final SqlSession session = mybatis.openBatchSession();
+ final DbSession session = mybatis.openSession(true);
try {
final ResourceIndexerMapper mapper = session.getMapper(ResourceIndexerMapper.class);
session.select("org.sonar.core.resource.ResourceIndexerMapper.selectRootProjectIds", /* workaround to get booleans */ResourceIndexerQuery.create(), new ResultHandler() {
public boolean indexResource(long id) {
boolean indexed = false;
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
ResourceIndexerMapper mapper = session.getMapper(ResourceIndexerMapper.class);
ResourceDto resource = mapper.selectResourceToIndex(id);
public boolean indexResource(int id, String name, String qualifier, int rootId) {
boolean indexed = false;
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
ResourceIndexerMapper mapper = session.getMapper(ResourceIndexerMapper.class);
try {
indexed = indexResource(id, name, qualifier, rootId, session, mapper);
import com.google.common.collect.Sets;
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.session.SqlSession;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import java.util.Collection;
}
public void updateKey(long projectId, String newKey) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
ResourceKeyUpdaterMapper mapper = session.getMapper(ResourceKeyUpdaterMapper.class);
try {
if (mapper.countResourceByKey(newKey) > 0) {
}
public Map<String, String> checkModuleKeysBeforeRenaming(long projectId, String stringToReplace, String replacementString) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
ResourceKeyUpdaterMapper mapper = session.getMapper(ResourceKeyUpdaterMapper.class);
Map<String, String> result = Maps.newHashMap();
try {
}
public void bulkUpdateKey(long projectId, String stringToReplace, String replacementString) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
ResourceKeyUpdaterMapper mapper = session.getMapper(ResourceKeyUpdaterMapper.class);
try {
// must SELECT first everything
import org.sonar.api.rule.RuleKey;
import org.sonar.core.db.BaseDao;
import org.sonar.core.db.UnsuportedException;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import javax.annotation.CheckForNull;
import java.sql.Timestamp;
}
public List<RuleDto> selectAll() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectAll(session);
} finally {
}
public List<RuleDto> selectEnablesAndNonManual() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectEnablesAndNonManual(session);
} finally {
}
public List<RuleDto> selectBySubCharacteristicId(Integer characteristicOrSubCharacteristicId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectBySubCharacteristicId(characteristicOrSubCharacteristicId, session);
} finally {
@CheckForNull
public RuleDto selectById(Integer id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectById(id, session);
} finally {
@CheckForNull
public RuleDto selectByKey(RuleKey ruleKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByKey(ruleKey, session);
} finally {
@CheckForNull
public RuleDto selectByName(String name) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getMapper(session).selectByName(name);
} finally {
}
public void insert(Collection<RuleDto> rules) {
- SqlSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
for (RuleDto rule : rules) {
getMapper(session).batchInsert(rule);
// ******************************
public List<RuleParamDto> selectParameters() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectParameters(session);
} finally {
}
public List<RuleParamDto> selectParametersByRuleId(Integer ruleId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectParametersByRuleId(ruleId, session);
} finally {
}
public List<RuleParamDto> selectParametersByRuleIds(List<Integer> ruleIds) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectParametersByRuleIds(ruleIds, session);
} finally {
}
public void insert(RuleParamDto param) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insert(param, session);
session.commit();
}
public void update(RuleParamDto param) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
update(param, session);
session.commit();
}
public List<RuleRuleTagDto> selectTagsByRuleId(Integer ruleId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectTagsByRuleIds(ruleId, session);
} finally {
}
public List<RuleRuleTagDto> selectTagsByRuleIds(List<Integer> ruleIds) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectTagsByRuleIds(ruleIds, session);
} finally {
@Override
public Collection<RuleKey> keysOfRowsUpdatedAfter(long timestamp) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
final List<RuleKey> keys = Lists.newArrayList();
session.select("selectKeysOfRulesUpdatedSince", new Timestamp(timestamp), new ResultHandler() {
}
public List<RuleTagDto> selectAll() {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return selectAll(session);
} finally {
}
public void insert(RuleTagDto newRuleTag) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
insert(newRuleTag, session);
session.commit();
}
public void delete(Long tagId) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
delete(tagId, session);
session.commit();
}
public Long selectId(String tag) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return selectId(tag, session);
} finally {
}
public List<RuleTagDto> selectUnused() {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return selectUnused(session);
} finally {
}
public Collection<SnapshotDataDto> selectSnapshotData(long snapshotId, List<String> dataTypes) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
SnapshotDataMapper mapper = session.getMapper(SnapshotDataMapper.class);
return mapper.selectSnapshotData(snapshotId, dataTypes);
public Collection<SnapshotDataDto> selectSnapshotDataByComponentKey(String componentKey, List<String> dataTypes) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectSnapshotDataByComponentKey(componentKey, dataTypes, session);
} finally {
}
void insert(SnapshotDataDto snapshotData) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insert(session, snapshotData);
session.commit();
@CheckForNull
public String selectSnapshotSource(long snapshotId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
SnapshotSourceMapper mapper = session.getMapper(SnapshotSourceMapper.class);
@CheckForNull
public String selectSnapshotSourceByComponentKey(String componentKey) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectSnapshotSourceByComponentKey(componentKey, session);
} finally {
* @return enabled root characteristics and characteristics
*/
public List<CharacteristicDto> selectEnabledCharacteristics() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectEnabledCharacteristics(session);
} finally {
* @return all characteristics
*/
public List<CharacteristicDto> selectCharacteristics() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectCharacteristics(session);
} finally {
* @return only enabled root characteristics, order by order
*/
public List<CharacteristicDto> selectEnabledRootCharacteristics() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectEnabledRootCharacteristics(session);
} finally {
}
public List<CharacteristicDto> selectCharacteristicsByParentId(int parentId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectCharacteristicsByParentId(parentId, session);
} finally {
}
public List<CharacteristicDto> selectCharacteristicsByIds(Collection<Integer> ids) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectCharacteristicsByIds(ids, session);
} finally {
@CheckForNull
public CharacteristicDto selectByKey(String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByKey(key, session);
} finally {
@CheckForNull
public CharacteristicDto selectById(int id) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectById(id, session);
} finally {
@CheckForNull
public CharacteristicDto selectByName(String name) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectByName(name, session);
} finally {
}
public int selectMaxCharacteristicOrder() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectMaxCharacteristicOrder(session);
} finally {
}
public void insert(CharacteristicDto dto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insert(dto, session);
session.commit();
}
public void update(CharacteristicDto dto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
update(dto, session);
session.commit();
}
public List<RequirementDto> selectRequirements() {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectRequirements(session);
} finally {
}
public int countByTypeAndKey(String type, String key) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return countByTypeAndKey(type, key, session);
} finally {
public void insert(LoadedTemplateDto loadedTemplateDto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insert(loadedTemplateDto, session);
session.commit();
}
public AuthorDto selectByLogin(String login) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
return mapper.selectByLogin(login);
}
public int countDeveloperLogins(long developerId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
return mapper.countDeveloperLogins(developerId);
}
public void insertAuthor(String login, long personId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insertAuthor(login, personId, session);
session.commit();
}
public void insertAuthorAndDeveloper(String login, ResourceDto resourceDto) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
resourceDao.insertUsingExistingSession(resourceDto, session);
insertAuthor(login, resourceDto.getId(), session);
}
public Set<String> keepAuthorizedComponentKeys(Set<String> componentKeys, @Nullable Integer userId, String role) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return keepAuthorizedComponentKeys(componentKeys, userId, role, session);
}
public Collection<String> selectAuthorizedRootProjectsKeys(@Nullable Integer userId, String role) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectAuthorizedRootProjectsKeys(userId, role, session);
}
public List<String> selectGlobalPermissions(@Nullable String userLogin) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
Map<String, Object> params = newHashMap();
params.put("userLogin", userLogin);
}
public List<GroupMembershipDto> selectGroups(GroupMembershipQuery query, Long userId, int offset, int limit) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
Map<String, Object> params = ImmutableMap.of("query", query, "userId", userId);
return session.selectList("org.sonar.core.user.GroupMembershipMapper.selectGroups", params, new RowBounds(offset, limit));
}
public List<String> selectUserPermissions(String userLogin, @Nullable Long resourceId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
RoleMapper mapper = session.getMapper(RoleMapper.class);
try {
return mapper.selectUserPermissions(userLogin, resourceId);
}
public List<String> selectGroupPermissions(String groupName, @Nullable Long resourceId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
RoleMapper mapper = session.getMapper(RoleMapper.class);
try {
return mapper.selectGroupPermissions(groupName, resourceId, DefaultGroups.isAnyone(groupName));
}
public void insertGroupRole(GroupRoleDto groupRole) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insertGroupRole(groupRole, session);
session.commit();
}
public void insertUserRole(UserRoleDto userRole) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
insertUserRole(userRole, session);
session.commit();
}
public void deleteUserRole(UserRoleDto userRole) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteUserRole(userRole, session);
session.commit();
}
public void deleteGroupRole(GroupRoleDto groupRole) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
deleteGroupRole(groupRole, session);
session.commit();
}
public int countResourceGroupRoles(Long resourceId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
RoleMapper mapper = session.getMapper(RoleMapper.class);
return mapper.countResourceGroupRoles(resourceId);
}
public int countResourceUserRoles(Long resourceId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
RoleMapper mapper = session.getMapper(RoleMapper.class);
return mapper.countResourceUserRoles(resourceId);
}
public UserDto getUser(long userId) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return getUser(userId, session);
} finally {
*/
@CheckForNull
public UserDto selectActiveUserByLogin(String login) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectActiveUserByLogin(login, session);
} finally {
public List<UserDto> selectUsersByLogins(List<String> logins) {
List<UserDto> users = Lists.newArrayList();
if (!logins.isEmpty()) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
UserMapper mapper = session.getMapper(UserMapper.class);
List<List<String>> partitions = Lists.partition(logins, 1000);
}
public List<UserDto> selectUsers(UserQuery query) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
UserMapper mapper = session.getMapper(UserMapper.class);
return mapper.selectUsers(query);
* @return false if the user does not exist, true if the existing user has been deactivated
*/
public boolean deactivateUserByLogin(String login) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
UserMapper mapper = session.getMapper(UserMapper.class);
UserDto dto = mapper.selectUserByLogin(login);
@CheckForNull
public GroupDto selectGroupByName(String name) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
return selectGroupByName(name, session);
} finally {
package org.sonar.core.permission;
-import org.apache.ibatis.session.SqlSession;
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.utils.System2;
import org.sonar.core.persistence.AbstractDaoTestCase;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import java.text.ParseException;
import java.text.SimpleDateFormat;
PermissionTemplateMapper mapper = mock(PermissionTemplateMapper.class);
- SonarSession session = mock(SonarSession.class);
+ DbSession session = mock(DbSession.class);
when(session.getMapper(PermissionTemplateMapper.class)).thenReturn(mapper);
MyBatis myBatis = mock(MyBatis.class);
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
permissionTemplateDao = new PermissionTemplateDao(myBatis, system);
PermissionTemplateDto permissionTemplate = permissionTemplateDao.createPermissionTemplate(PermissionTemplateDto.DEFAULT.getName(), null, null);
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.sonar.api.platform.ServerFileSystem;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.persistence.PreviewDatabaseFactory;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.properties.PropertyDto;
import org.sonar.core.resource.ResourceDao;
private MyBatis myBatis;
- private SonarSession session;
+ private DbSession session;
private PreviewCache dryRunCache;
private ServerFileSystem serverFileSystem;
@Before
public void prepare() throws IOException {
myBatis = mock(MyBatis.class);
- session = mock(SonarSession.class);
- when(myBatis.openSession()).thenReturn(session);
+ session = mock(DbSession.class);
+ when(myBatis.openSession(false)).thenReturn(session);
serverFileSystem = mock(ServerFileSystem.class);
propertiesDao = mock(PropertiesDao.class);
resourceDao = mock(ResourceDao.class);
*/
package org.sonar.server.cluster;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import org.sonar.core.cluster.IndexAction;
import org.sonar.core.cluster.WorkQueue;
+import javax.annotation.CheckForNull;
import java.util.concurrent.ConcurrentLinkedQueue;
public class LocalNonBlockingWorkQueue implements WorkQueue {
- private static final Logger LOG = LoggerFactory.getLogger(LocalNonBlockingWorkQueue.class);
+ private final ConcurrentLinkedQueue<IndexAction<?>> actions = new ConcurrentLinkedQueue<IndexAction<?>>();
- private final ConcurrentLinkedQueue<IndexAction<?>> actions;
-
- public LocalNonBlockingWorkQueue() {
- this.actions = new ConcurrentLinkedQueue<IndexAction<?>>();
+ @Override
+ public void enqueue(IndexAction<?> indexAction) {
+ actions.offer(indexAction);
}
@Override
- public Integer enqueue(IndexAction<?>... indexActions) {
+ public void enqueue(Iterable<IndexAction<?>> indexActions) {
for (IndexAction<?> action : indexActions) {
- actions.offer(action);
+ enqueue(action);
}
- return 0;
}
+ @CheckForNull
@Override
public IndexAction<?> dequeue() {
IndexAction<?> out = actions.poll();
SqlSession session = null;
Connection connection = null;
try {
- session = myBatis.openSession();
+ session = myBatis.openSession(false);
connection = session.getConnection();
createSchema(connection, database.getDialect().getId());
return true;
import org.sonar.api.utils.System2;
import org.sonar.api.utils.ValidationMessages;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
import org.sonar.core.technicaldebt.db.CharacteristicDao;
private String backupFromLanguage(@Nullable String languageKey) {
checkPermission();
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
DebtModel debtModel = new DebtModel();
List<CharacteristicDto> characteristicDtos = dao.selectEnabledCharacteristics(session);
checkPermission();
Date updateDate = new Date(system2.now());
- SonarSession session = mybatis.openSession();
+ DbSession session = mybatis.openSession(false);
try {
// Restore characteristics
List<CharacteristicDto> allCharacteristicDtos = restoreCharacteristics(loadModelFromPlugin(DebtModelPluginRepository.DEFAULT_MODEL), updateDate, session);
}
}
- private void resetRules(List<RuleDto> ruleDtos, List<RulesDefinition.Rule> rules, List<CharacteristicDto> allCharacteristicDtos, Date updateDate, SonarSession session){
+ private void resetRules(List<RuleDto> ruleDtos, List<RulesDefinition.Rule> rules, List<CharacteristicDto> allCharacteristicDtos, Date updateDate, DbSession session){
for (RuleDto rule : ruleDtos) {
// Restore default debt definitions
ValidationMessages validationMessages = ValidationMessages.create();
Date updateDate = new Date(system2.now());
- SonarSession session = mybatis.openSession();
+ DbSession session = mybatis.openSession(false);
try {
List<CharacteristicDto> allCharacteristicDtos = restoreCharacteristics(characteristicsXMLImporter.importXML(xml), updateDate, session);
restoreRules(allCharacteristicDtos, rules(languageKey, session), rulesXMLImporter.importXML(xml, validationMessages), validationMessages, updateDate, session);
}
private void restoreRules(List<CharacteristicDto> allCharacteristicDtos, List<RuleDto> rules, List<RuleDebt> ruleDebts,
- ValidationMessages validationMessages, Date updateDate, SonarSession session) {
+ ValidationMessages validationMessages, Date updateDate, DbSession session) {
for (RuleDto rule : rules) {
RuleDebt ruleDebt = ruleDebt(rule.getRepositoryKey(), rule.getRuleKey(), ruleDebts);
String subCharacteristicKey = ruleDebt != null ? ruleDebt.subCharacteristicKey() : null;
}
@VisibleForTesting
- List<CharacteristicDto> restoreCharacteristics(DebtModel targetModel, Date updateDate, SonarSession session) {
+ List<CharacteristicDto> restoreCharacteristics(DebtModel targetModel, Date updateDate, DbSession session) {
List<CharacteristicDto> sourceCharacteristics = dao.selectEnabledCharacteristics(session);
List<CharacteristicDto> result = newArrayList();
import org.sonar.api.server.debt.internal.DefaultDebtCharacteristic;
import org.sonar.api.utils.System2;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
import org.sonar.core.technicaldebt.db.CharacteristicDao;
public DebtCharacteristic create(String name, @Nullable Integer parentId) {
checkPermission();
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
checkNotAlreadyExists(name, session);
public DebtCharacteristic rename(int characteristicId, String newName) {
checkPermission();
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
checkNotAlreadyExists(newName, session);
private DebtCharacteristic move(int characteristicId, boolean moveUpOrDown) {
checkPermission();
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
final CharacteristicDto dto = findCharacteristic(characteristicId, session);
if (dto.getParentId() != null) {
checkPermission();
Date updateDate = new Date(system2.now());
- SonarSession session = mybatis.openBatchSession();
+ DbSession session = mybatis.openSession(true);
try {
delete(findCharacteristic(characteristicId, session), updateDate, session);
session.commit();
* Disabled a characteristic or a sub characteristic.
* If it has already been disabled, do nothing (for instance when call on a list of characteristics and sub-characteristics in random order)
*/
- public void delete(CharacteristicDto characteristicOrSubCharacteristic, Date updateDate, SonarSession session) {
+ public void delete(CharacteristicDto characteristicOrSubCharacteristic, Date updateDate, DbSession session) {
// Do nothing is the characteristic is already disabled
if (characteristicOrSubCharacteristic.isEnabled()) {
// When root characteristic, browse sub characteristics and disable rule debt on each sub characteristic then disable it
}
}
- private void disableSubCharacteristic(CharacteristicDto subCharacteristic, Date updateDate, SonarSession session) {
+ private void disableSubCharacteristic(CharacteristicDto subCharacteristic, Date updateDate, DbSession session) {
// Disable debt on all rules (even REMOVED ones, in order to have no issue if they are reactivated) linked to the sub characteristic
disableRulesDebt(ruleDao.selectBySubCharacteristicId(subCharacteristic.getId(), session), subCharacteristic.getId(), updateDate, session);
disableCharacteristic(subCharacteristic, updateDate, session);
dao.update(characteristic, session);
}
- private void disableRulesDebt(List<RuleDto> ruleDtos, Integer subCharacteristicId, Date updateDate, SonarSession session) {
+ private void disableRulesDebt(List<RuleDto> ruleDtos, Integer subCharacteristicId, Date updateDate, DbSession session) {
for (RuleDto ruleDto : ruleDtos) {
if (subCharacteristicId.equals(ruleDto.getSubCharacteristicId())) {
ruleDto.setSubCharacteristicId(RuleDto.DISABLED_CHARACTERISTIC_ID);
public IssueQueryResult find(IssueQuery query) {
LOG.debug("IssueQuery : {}", query);
long start = System.currentTimeMillis();
- SqlSession sqlSession = myBatis.openSession();
+ SqlSession sqlSession = myBatis.openSession(false);
try {
// 1. Select the authorized ids of all the issues that match the query
List<IssueDto> authorizedIssues = issueDao.selectIssueIds(query, UserSession.get().userId(), sqlSession);
getNonNullQgate(sourceId);
validateQualityGate(null, destinationName);
QualityGateDto destinationGate = new QualityGateDto().setName(destinationName);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
dao.insert(destinationGate, session);
for (QualityGateConditionDto sourceCondition : conditionDao.selectForQualityGate(sourceId, session)) {
public void delete(long idToDelete) {
checkPermission(UserSession.get());
QualityGateDto qGate = getNonNullQgate(idToDelete);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
if (isDefault(qGate)) {
propertiesDao.deleteGlobalProperty(SONAR_QUALITYGATE_PROPERTY, session);
}
public void bulkRegisterActiveRules() {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
StopWatch bulkWatch = startWatch();
}
public void bulkIndexProfile(int profileId) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
bulkIndexProfile(profileId, session);
} finally {
}
public void bulkIndexActiveRules(List<Integer> ids) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
bulkIndexActiveRuleIds(ids, session);
} finally {
validatePermission(userSession);
validateSeverity(severity);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QualityProfileDto profile = findProfileNotNull(profileId, session);
RuleDto rule = findRuleNotNull(ruleId, session);
public int activateRules(int profileId, ProfileRuleQuery query, UserSession userSession) {
validatePermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
List<Integer> ruleIdsToActivate = rules.searchInactiveProfileRuleIds(query);
for (Integer ruleId : ruleIdsToActivate) {
public boolean deactivateRule(int profileId, int ruleId, UserSession userSession) {
validatePermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ActiveRuleDto activeRule = findActiveRuleNotNull(profileId, ruleId, session);
return deactivateRule(activeRule, userSession, session);
public int deactivateRules(ProfileRuleQuery query, UserSession userSession) {
validatePermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
int numberOfDeactivatedRules = 0;
try {
List<Integer> activeRuleIdsToDeactivate = rules.searchProfileRuleIds(query);
public void updateActiveRuleParam(int activeRuleId, String key, @Nullable String value, UserSession userSession) {
validatePermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
String sanitizedValue = Strings.emptyToNull(value);
ActiveRuleParamDto activeRuleParam = findActiveRuleParam(activeRuleId, key, session);
public void revertActiveRule(int activeRuleId, UserSession userSession) {
validatePermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ActiveRuleDto activeRule = findActiveRuleNotNull(activeRuleId, session);
if (activeRule.doesOverride()) {
public void updateActiveRuleNote(int activeRuleId, String note, UserSession userSession) {
validatePermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ActiveRuleDto activeRule = findActiveRuleNotNull(activeRuleId, session);
public void deleteActiveRuleNote(int activeRuleId, UserSession userSession) {
validatePermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ActiveRuleDto activeRule = findActiveRuleNotNull(activeRuleId, session);
public QProfileResult restore(String xmlBackup, boolean deleteExisting) {
checkPermission(UserSession.get());
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
QProfileResult result = new QProfileResult();
try {
ValidationMessages messages = ValidationMessages.create();
checkPermission(UserSession.get());
QProfileResult result = new QProfileResult();
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ListMultimap<String, RulesProfile> profilesByName = profilesByName(language, result);
for (Map.Entry<String, Collection<RulesProfile>> entry : profilesByName.asMap().entrySet()) {
@CheckForNull
public QProfile profile(int id) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return profile(id, session);
} finally {
@CheckForNull
public QProfile profile(String name, String language) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return profile(name, language, session);
} finally {
@CheckForNull
public QProfile defaultProfile(String language) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return defaultProfile(language, session);
} finally {
@CheckForNull
public QProfile parent(QProfile profile) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
String parent = profile.parent();
if (parent != null) {
}
public List<QProfile> children(QProfile profile) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return children(profile, session);
} finally {
public List<QProfile> ancestors(QProfile profile) {
List<QProfile> ancestors = newArrayList();
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
incrementAncestors(profile, ancestors, session);
} finally {
}
public boolean isDeletable(QProfile profile) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return isDeletable(profile, session);
} finally {
}
public int countChildren(QProfile profile) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
return countChildren(profile, session);
} finally {
}
public QProfileResult newProfile(String name, String language, Map<String, String> xmlProfilesByPlugin, UserSession userSession) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QProfile profile = newProfile(name, language, true, userSession, session);
public void renameProfile(int profileId, String newName, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QualityProfileDto profileDto = findNotNull(profileId, session);
String oldName = profileDto.getName();
public void deleteProfile(int profileId, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QualityProfileDto profile = findNotNull(profileId, session);
QProfile qProfile = QProfile.from(profile);
public void setDefaultProfile(int profileId, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QualityProfileDto qualityProfile = findNotNull(profileId, session);
propertiesDao.setProperty(new PropertyDto().setKey(PROFILE_PROPERTY_PREFIX + qualityProfile.getLanguage()).setValue(qualityProfile.getName()));
public void updateParentProfile(int profileId, @Nullable Integer parentId, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QualityProfileDto profile = findNotNull(profileId, session);
QualityProfileDto parentProfile = null;
public void copyProfile(int profileId, String copyProfileName, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QualityProfileDto profileDto = findNotNull(profileId, session);
checkNotAlreadyExists(copyProfileName, profileDto.getLanguage(), session);
}
public List<Component> projects(int profileId) {
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QualityProfileDto qualityProfile = qualityProfileDao.selectById(profileId, session);
QProfileValidations.checkProfileIsNotNull(qualityProfile);
public void addProject(int profileId, long projectId, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ComponentDto project = (ComponentDto) findProjectNotNull(projectId, session);
QualityProfileDto qualityProfile = findNotNull(profileId, session);
public void removeProject(int profileId, long projectId, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ComponentDto project = (ComponentDto) findProjectNotNull(projectId, session);
QualityProfileDto qualityProfile = findNotNull(profileId, session);
public void removeProject(String language, long projectId, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ComponentDto project = (ComponentDto) findProjectNotNull(projectId, session);
public void removeAllProjects(int profileId, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
QualityProfileDto qualityProfile = findNotNull(profileId, session);
import org.sonar.api.utils.System2;
import org.sonar.api.utils.TimeProfiler;
import org.sonar.check.Cardinality;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.qualityprofile.db.ActiveRuleDao;
import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
@Override
public void start() {
TimeProfiler profiler = new TimeProfiler().start("Register rules");
- SonarSession sqlSession = myBatis.openSession();
+ DbSession sqlSession = myBatis.openSession(false);
try {
RulesDefinition.Context context = defLoader.load();
Buffer buffer = new Buffer(system.now());
}
}
- private void enableRuleDefinitions(RulesDefinition.Context context, Buffer buffer, SonarSession sqlSession) {
+ private void enableRuleDefinitions(RulesDefinition.Context context, Buffer buffer, DbSession sqlSession) {
for (RulesDefinition.Repository repoDef : context.repositories()) {
enableRepository(buffer, sqlSession, repoDef);
}
}
}
- private void enableRepository(Buffer buffer, SonarSession sqlSession, RulesDefinition.ExtendedRepository repoDef) {
+ private void enableRepository(Buffer buffer, DbSession sqlSession, RulesDefinition.ExtendedRepository repoDef) {
int count = 0;
for (RulesDefinition.Rule ruleDef : repoDef.rules()) {
RuleDto dto = buffer.rule(RuleKey.of(ruleDef.repository().key(), ruleDef.key()));
sqlSession.commit();
}
- private RuleDto enableAndInsert(Buffer buffer, SonarSession sqlSession, RulesDefinition.Rule ruleDef) {
+ private RuleDto enableAndInsert(Buffer buffer, DbSession sqlSession, RulesDefinition.Rule ruleDef) {
RuleDto ruleDto = new RuleDto()
.setCardinality(ruleDef.template() ? Cardinality.MULTIPLE : Cardinality.SINGLE)
.setConfigKey(ruleDef.internalKey())
return ruleDto;
}
- private void enableAndUpdate(Buffer buffer, SonarSession sqlSession, RulesDefinition.Rule ruleDef, RuleDto dto) {
+ private void enableAndUpdate(Buffer buffer, DbSession sqlSession, RulesDefinition.Rule ruleDef, RuleDto dto) {
if (mergeRule(buffer, ruleDef, dto)) {
ruleDao.update(dto, sqlSession);
}
return tagId;
}
- private List<RuleDto> processRemainingDbRules(Buffer buffer, SonarSession sqlSession) {
+ private List<RuleDto> processRemainingDbRules(Buffer buffer, DbSession sqlSession) {
List<RuleDto> removedRules = newArrayList();
for (Integer unprocessedRuleId : buffer.unprocessedRuleIds) {
RuleDto ruleDto = buffer.rulesById.get(unprocessedRuleId);
import org.sonar.api.utils.System2;
import org.sonar.check.Cardinality;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.qualityprofile.db.ActiveRuleDao;
import org.sonar.core.qualityprofile.db.ActiveRuleDto;
import org.sonar.core.rule.RuleDao;
checkPermission(userSession);
Date now = new Date(system.now());
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
if (rule.getNoteData() == null) {
rule.setNoteCreatedAt(now);
public void deleteRuleNote(RuleDto rule, UserSession userSession) {
checkPermission(userSession);
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
rule.setNoteData(null);
rule.setNoteUserLogin(null);
public RuleDto createCustomRule(RuleDto templateRule, String name, String severity, String description, Map<String, String> paramsByKey,
UserSession userSession) {
checkPermission(userSession);
- SonarSession session = myBatis.openSession();
+ DbSession session = myBatis.openSession(false);
try {
RuleDto rule = new RuleDto()
.setParentId(templateRule.getId())
public void updateCustomRule(RuleDto rule, String name, String severity, String description, Map<String, String> paramsByKey,
UserSession userSession) {
checkPermission(userSession);
- SonarSession session = myBatis.openSession();
+ DbSession session = myBatis.openSession(false);
try {
rule.setName(name)
.setDescription(description)
public void deleteCustomRule(RuleDto rule, UserSession userSession) {
checkPermission(userSession);
- SonarSession session = myBatis.openSession();
+ DbSession session = myBatis.openSession(false);
try {
// Set status REMOVED on rule
rule.setStatus(Rule.STATUS_REMOVED)
public void updateRuleTags(RuleDto rule, List<String> newTags, UserSession userSession) {
checkPermission(userSession);
- SonarSession session = myBatis.openSession();
+ DbSession session = myBatis.openSession(false);
try {
Map<String, Long> neededTagIds = validateAndGetTagIds(newTags, session);
public void updateRule(RuleChange ruleChange, UserSession userSession) {
checkPermission(userSession);
- SonarSession session = myBatis.openSession();
+ DbSession session = myBatis.openSession(false);
try {
RuleDto ruleDto = ruleDao.selectByKey(ruleChange.ruleKey(), session);
if (ruleDto == null) {
}
public boolean updateRule(RuleDto ruleDto, @Nullable CharacteristicDto newSubCharacteristic, @Nullable String newFunction,
- @Nullable String newCoefficient, @Nullable String newOffset, Date updateDate, SonarSession session) {
+ @Nullable String newCoefficient, @Nullable String newOffset, Date updateDate, DbSession session) {
boolean needUpdate = false;
// A sub-characteristic and a remediation function is given -> update rule debt
* Reindex all enabled and non manual rules
*/
public String[] reindex() {
- SqlSession sqlSession = myBatis.openSession();
+ SqlSession sqlSession = myBatis.openSession(false);
try {
return reindex(sqlSession);
} finally {
* Reindex one rule
*/
public void reindex(RuleDto rule) {
- SqlSession sqlSession = myBatis.openSession();
+ SqlSession sqlSession = myBatis.openSession(false);
try {
reindex(rule, sqlSession);
} finally {
@CheckForNull
public List<String> getSourceAsHtml(String componentKey, @Nullable Integer from, @Nullable Integer to) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
ResourceDto component = resourceDao.getResource(ResourceQuery.create().setKey(componentKey), session);
if (component == null) {
}
public List<String> getDecoratedSourceAsHtml(String componentKey, @Nullable Integer from, @Nullable Integer to) {
- SqlSession session = mybatis.openSession();
+ SqlSession session = mybatis.openSession(false);
try {
Collection<SnapshotDataDto> snapshotDataEntries = snapshotDataDao.selectSnapshotDataByComponentKey(componentKey, highlightingDataTypes(), session);
if (!snapshotDataEntries.isEmpty()) {
// As long ProfileDefinition API will be used, then we'll have to use this commit as Hibernate is used by plugin to load rules when creating their profiles.
sessionFactory.getSession().commit();
- SqlSession session = myBatis.openSession();
+ SqlSession session = myBatis.openSession(false);
try {
ListMultimap<String, RulesProfile> profilesByLanguage = profilesByLanguage();
for (String language : profilesByLanguage.keySet()) {
import org.sonar.api.platform.ServerUpgradeStatus;
import org.sonar.core.persistence.AbstractDaoTestCase;
import org.sonar.core.persistence.Database;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.persistence.dialect.Dialect;
import org.sonar.core.persistence.dialect.H2;
import org.sonar.core.persistence.dialect.MySql;
Dialect supportedDialect = new H2();
when(database.getDialect()).thenReturn(supportedDialect);
Connection connection = mock(Connection.class);
- SonarSession session = mock(SonarSession.class);
+ DbSession session = mock(DbSession.class);
when(session.getConnection()).thenReturn(connection);
- when(mybatis.openSession()).thenReturn(session);
+ when(mybatis.openSession(false)).thenReturn(session);
when(serverUpgradeStatus.isFreshInstall()).thenReturn(true);
DatabaseMigrator databaseMigrator = new DatabaseMigrator(mybatis, database, migrations, serverUpgradeStatus, null) {
package org.sonar.server.debt;
-import org.apache.ibatis.session.SqlSession;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.sonar.api.utils.System2;
import org.sonar.api.utils.ValidationMessages;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
import org.sonar.core.technicaldebt.db.CharacteristicDao;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
DebtModelPluginRepository debtModelPluginRepository;
dto.setId(currentId++);
return null;
}
- }).when(dao).insert(any(CharacteristicDto.class), any(SonarSession.class));
+ }).when(dao).insert(any(CharacteristicDto.class), any(DbSession.class));
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
Reader defaultModelReader = mock(Reader.class);
when(debtModelPluginRepository.createReaderForXMLFile("technical-debt")).thenReturn(defaultModelReader);
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.System2;
import org.sonar.core.permission.GlobalPermissions;
-import org.sonar.core.persistence.BatchSession;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
import org.sonar.core.technicaldebt.db.CharacteristicDao;
MyBatis mybatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
RuleRegistry ruleRegistry;
}
}).when(dao).insert(any(CharacteristicDto.class), any(SqlSession.class));
- when(mybatis.openSession()).thenReturn(session);
+ when(mybatis.openSession(false)).thenReturn(session);
service = new DebtModelOperations(mybatis, dao, ruleDao, ruleRegistry, system2);
}
@Test
public void delete_sub_characteristic() {
- BatchSession batchSession = mock(BatchSession.class);
- when(mybatis.openBatchSession()).thenReturn(batchSession);
+ DbSession batchSession = mock(DbSession.class);
+ when(mybatis.openSession(true)).thenReturn(batchSession);
when(ruleDao.selectBySubCharacteristicId(2, batchSession)).thenReturn(newArrayList(
new RuleDto()
@Test
public void delete_sub_characteristic_disable_default_rules_debt_if_default_characteristic_is_deleted() {
- BatchSession batchSession = mock(BatchSession.class);
- when(mybatis.openBatchSession()).thenReturn(batchSession);
+ DbSession batchSession = mock(DbSession.class);
+ when(mybatis.openSession(true)).thenReturn(batchSession);
when(ruleDao.selectBySubCharacteristicId(2, batchSession)).thenReturn(newArrayList(
new RuleDto()
@Test
public void delete_characteristic() {
- BatchSession batchSession = mock(BatchSession.class);
- when(mybatis.openBatchSession()).thenReturn(batchSession);
+ DbSession batchSession = mock(DbSession.class);
+ when(mybatis.openSession(true)).thenReturn(batchSession);
when(ruleDao.selectBySubCharacteristicId(subCharacteristicDto.getId(), batchSession)).thenReturn(newArrayList(
new RuleDto().setSubCharacteristicId(subCharacteristicDto.getId()).setRemediationFunction("LINEAR_OFFSET").setRemediationCoefficient("2h").setRemediationOffset("5min")
@Test
public void not_delete_already_disabled_characteristic() {
- BatchSession batchSession = mock(BatchSession.class);
- when(mybatis.openBatchSession()).thenReturn(batchSession);
+ DbSession batchSession = mock(DbSession.class);
+ when(mybatis.openSession(true)).thenReturn(batchSession);
when(dao.selectById(1, batchSession)).thenReturn(new CharacteristicDto()
.setId(1)
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
-import org.apache.ibatis.session.SqlSession;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.sonar.core.component.ComponentQuery;
import org.sonar.core.component.db.ComponentDao;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.properties.PropertyDto;
import org.sonar.core.qualitygate.db.QualityGateConditionDao;
String name = "To Delete";
QualityGateDto toDelete = new QualityGateDto().setId(idToDelete).setName(name);
when(dao.selectById(idToDelete)).thenReturn(toDelete);
- SonarSession session = mock(SonarSession.class);
- when(myBatis.openSession()).thenReturn(session);
+ DbSession session = mock(DbSession.class);
+ when(myBatis.openSession(false)).thenReturn(session);
qGates.delete(idToDelete);
verify(dao).selectById(idToDelete);
verify(propertiesDao).deleteProjectProperties("sonar.qualitygate", "42", session);
QualityGateDto toDelete = new QualityGateDto().setId(idToDelete).setName(name);
when(dao.selectById(idToDelete)).thenReturn(toDelete);
when(propertiesDao.selectGlobalProperty("sonar.qualitygate")).thenReturn(new PropertyDto().setValue("666"));
- SonarSession session = mock(SonarSession.class);
- when(myBatis.openSession()).thenReturn(session);
+ DbSession session = mock(DbSession.class);
+ when(myBatis.openSession(false)).thenReturn(session);
qGates.delete(idToDelete);
verify(dao).selectById(idToDelete);
verify(propertiesDao).deleteProjectProperties("sonar.qualitygate", "42", session);
QualityGateDto toDelete = new QualityGateDto().setId(idToDelete).setName(name);
when(dao.selectById(idToDelete)).thenReturn(toDelete);
when(propertiesDao.selectGlobalProperty("sonar.qualitygate")).thenReturn(new PropertyDto().setValue("42"));
- SonarSession session = mock(SonarSession.class);
- when(myBatis.openSession()).thenReturn(session);
+ DbSession session = mock(DbSession.class);
+ when(myBatis.openSession(false)).thenReturn(session);
qGates.delete(idToDelete);
verify(dao).selectById(idToDelete);
verify(propertiesDao).deleteGlobalProperty("sonar.qualitygate", session);
Collection<QualityGateConditionDto> conditions = ImmutableList.of(cond1, cond2);
when(dao.selectById(sourceId)).thenReturn(new QualityGateDto().setId(sourceId).setName("SG-1"));
- SonarSession session = mock(SonarSession.class);
- when(myBatis.openSession()).thenReturn(session);
+ DbSession session = mock(DbSession.class);
+ when(myBatis.openSession(false)).thenReturn(session);
Mockito.doAnswer(new Answer<Object>() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import com.google.common.io.Resources;
-import org.apache.ibatis.session.SqlSession;
import org.elasticsearch.client.Requests;
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.search.SearchHit;
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.api.config.Settings;
import org.sonar.api.rule.Severity;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.profiling.Profiling;
import org.sonar.core.qualityprofile.db.ActiveRuleDao;
import org.sonar.core.qualityprofile.db.ActiveRuleDto;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
ActiveRuleDao activeRuleDao;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
esSetup = new EsSetup(ImmutableSettings.builder().loadFromUrl(ESNode.class.getResource("config/elasticsearch.json")).build());
esSetup.execute(EsSetup.deleteAll());
@Test
public void bulk_index_active_rules_from_ids() throws IOException {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
List<Integer> ids = newArrayList(1);
when(activeRuleDao.selectByIds(ids, session)).thenReturn(
List<ActiveRuleDto> activeRules = newArrayList(new ActiveRuleDto().setId(1).setProfileId(10).setRuleId(1).setSeverity(Severity.MAJOR).setParentId(5)
.setNoteData("polop").setNoteCreatedAt(new Date()).setNoteUserLogin("godin"));
- SonarSession session = mock(SonarSession.class);
- when(myBatis.openSession()).thenReturn(session);
+ DbSession session = mock(DbSession.class);
+ when(myBatis.openSession(false)).thenReturn(session);
when(activeRuleDao.selectAll(session)).thenReturn(activeRules);
when(activeRuleDao.selectAllParams(session)).thenReturn(Lists.<ActiveRuleParamDto>newArrayList());
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.System2;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.qualityprofile.db.ActiveRuleDao;
import org.sonar.core.qualityprofile.db.ActiveRuleDto;
import org.sonar.core.qualityprofile.db.ActiveRuleParamDto;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
ActiveRuleDao activeRuleDao;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
// Associate an id when inserting an object to simulate the db id generator
doAnswer(new Answer() {
import org.sonar.api.rules.RulePriority;
import org.sonar.api.utils.ValidationMessages;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.preview.PreviewCache;
import org.sonar.core.qualityprofile.db.ActiveRuleDto;
import org.sonar.jpa.session.DatabaseSessionFactory;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
XMLProfileParser xmlProfileParser;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
when(sessionFactory.getSession()).thenReturn(hibernateSession);
definitions = newArrayList();
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.qualityprofile.db.QualityProfileDao;
import org.sonar.core.qualityprofile.db.QualityProfileDto;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
QualityProfileDao dao;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
search = new QProfileLookup(myBatis, dao);
}
import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.preview.PreviewCache;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.properties.PropertyDto;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
QualityProfileDao qualityProfileDao;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
// Associate an id when inserting an object to simulate the db id generator
doAnswer(new Answer() {
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.core.component.ComponentDto;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.qualityprofile.db.QualityProfileDao;
import org.sonar.core.qualityprofile.db.QualityProfileDto;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
QualityProfileDao qualityProfileDao;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
lookup = new QProfileProjectLookup(myBatis, qualityProfileDao);
}
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.properties.PropertyDto;
import org.sonar.core.qualityprofile.db.QualityProfileDao;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
QualityProfileDao qualityProfileDao;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
service = new QProfileProjectOperations(myBatis, qualityProfileDao, resourceDao, propertiesDao);
}
import org.sonar.api.utils.System2;
import org.sonar.check.Cardinality;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.qualityprofile.db.ActiveRuleDao;
import org.sonar.core.qualityprofile.db.ActiveRuleDto;
import org.sonar.core.rule.RuleDao;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
ActiveRuleDao activeRuleDao;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
when(system.now()).thenReturn(now.getTime());
import org.sonar.api.config.Settings;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.Severity;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.profiling.Profiling;
import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
CharacteristicDao characteristicDao;
@Mock
- SonarSession session;
+ DbSession session;
RuleRegistry registry;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
esSetup = new EsSetup(ImmutableSettings.builder().loadFromUrl(ESNode.class.getResource("config/elasticsearch.json"))
.build());
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.resource.ResourceDao;
import org.sonar.core.resource.ResourceDto;
import org.sonar.core.resource.ResourceQuery;
MyBatis mybatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
ResourceDao resourceDao;
@Before
public void setUp() throws Exception {
- when(mybatis.openSession()).thenReturn(session);
+ when(mybatis.openSession(false)).thenReturn(session);
sourceDecorator = new DeprecatedSourceDecorator(mybatis, resourceDao, codeColorizers, snapshotSourceDao);
}
import org.sonar.api.profiles.RulesProfile;
import org.sonar.api.utils.SonarException;
import org.sonar.api.utils.ValidationMessages;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.persistence.SonarSession;
import org.sonar.core.qualityprofile.db.QualityProfileDao;
import org.sonar.core.template.LoadedTemplateDao;
import org.sonar.core.template.LoadedTemplateDto;
MyBatis myBatis;
@Mock
- SonarSession session;
+ DbSession session;
@Mock
DatabaseSessionFactory sessionFactory;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession()).thenReturn(session);
+ when(myBatis.openSession(false)).thenReturn(session);
when(sessionFactory.getSession()).thenReturn(mock(DatabaseSession.class));
definitions = newArrayList();
projects / sonarqube.git / commitdiff