import java.util.IdentityHashMap;
import java.util.Map;
-import javax.annotation.Nullable;
import org.sonar.db.ce.CeActivityDao;
import org.sonar.db.ce.CeQueueDao;
import org.sonar.db.ce.CeScannerContextDao;
return myBatis.openSession(batch);
}
- public void closeSession(@Nullable DbSession session) {
- MyBatis.closeQuietly(session);
- }
-
public Database getDatabase() {
return database;
}
import java.util.function.Function;
import java.util.stream.Collectors;
import org.apache.commons.lang.StringUtils;
-import org.apache.ibatis.session.SqlSession;
import org.sonar.api.resources.Qualifiers;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
}
public void updateKey(String projectUuid, String newKey) {
- DbSession session = mybatis.openSession(true);
- ComponentKeyUpdaterMapper mapper = session.getMapper(ComponentKeyUpdaterMapper.class);
- try {
+ try (DbSession session = mybatis.openSession(true)) {
+ ComponentKeyUpdaterMapper mapper = session.getMapper(ComponentKeyUpdaterMapper.class);
if (mapper.countResourceByKey(newKey) > 0) {
throw new IllegalArgumentException("Impossible to update key: a component with key \"" + newKey + "\" already exists.");
}
runBatchUpdateForAllResources(resources, projectOldKey, newKey, mapper);
session.commit();
- } finally {
- MyBatis.closeQuietly(session);
}
}
public Map<String, String> checkModuleKeysBeforeRenaming(String projectUuid, String stringToReplace, String replacementString) {
- SqlSession session = mybatis.openSession(false);
- ComponentKeyUpdaterMapper mapper = session.getMapper(ComponentKeyUpdaterMapper.class);
- Map<String, String> result = Maps.newHashMap();
- try {
+ try (DbSession session = mybatis.openSession(false)) {
+ ComponentKeyUpdaterMapper mapper = session.getMapper(ComponentKeyUpdaterMapper.class);
+ Map<String, String> result = Maps.newHashMap();
Set<ResourceDto> modules = collectAllModules(projectUuid, stringToReplace, mapper);
for (ResourceDto module : modules) {
String newKey = computeNewKey(module.getKey(), stringToReplace, replacementString);
result.put(module.getKey(), newKey);
}
}
- } finally {
- MyBatis.closeQuietly(session);
+ return result;
}
- return result;
}
public static void checkIsProjectOrModule(ComponentDto component) {
}
public List<IssueChangeDto> selectChangelogOfNonClosedIssuesByComponent(String componentUuid) {
- DbSession session = mybatis.openSession(false);
- try {
+ try (DbSession session = mybatis.openSession(false)) {
IssueChangeMapper mapper = mapper(session);
return mapper.selectChangelogOfNonClosedIssuesByComponent(componentUuid, IssueChangeDto.TYPE_FIELD_CHANGE);
-
- } finally {
- MyBatis.closeQuietly(session);
}
}
}
public int countByTypeAndKey(String type, String key) {
- SqlSession session = mybatis.openSession(false);
- try {
+ try (DbSession session = mybatis.openSession(false)) {
return countByTypeAndKey(type, key, session);
- } finally {
- MyBatis.closeQuietly(session);
}
}
}
public void insert(LoadedTemplateDto loadedTemplateDto) {
- SqlSession session = mybatis.openSession(false);
- try {
+ try (DbSession session = mybatis.openSession(false)) {
insert(loadedTemplateDto, session);
session.commit();
- } finally {
- MyBatis.closeQuietly(session);
}
}
import java.util.Collections;
import java.util.List;
-import org.apache.ibatis.session.SqlSession;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
import org.sonar.db.MyBatis;
}
public void insert(List<NotificationQueueDto> dtos) {
- DbSession session = mybatis.openSession(true);
- NotificationQueueMapper mapper = session.getMapper(NotificationQueueMapper.class);
- try {
+ try (DbSession session = mybatis.openSession(true)) {
+ NotificationQueueMapper mapper = session.getMapper(NotificationQueueMapper.class);
for (NotificationQueueDto dto : dtos) {
mapper.insert(dto);
}
session.commit();
- } finally {
- MyBatis.closeQuietly(session);
}
}
public void delete(List<NotificationQueueDto> dtos) {
- DbSession session = mybatis.openSession(true);
- NotificationQueueMapper mapper = session.getMapper(NotificationQueueMapper.class);
- try {
+ try (DbSession session = mybatis.openSession(true)) {
+ NotificationQueueMapper mapper = session.getMapper(NotificationQueueMapper.class);
for (NotificationQueueDto dto : dtos) {
mapper.delete(dto.getId());
}
session.commit();
- } finally {
- MyBatis.closeQuietly(session);
}
}
if (count < 1) {
return Collections.emptyList();
}
- SqlSession session = mybatis.openSession(false);
- try {
+ try (DbSession session = mybatis.openSession(false)) {
return session.getMapper(NotificationQueueMapper.class).findOldest(count);
- } finally {
- MyBatis.closeQuietly(session);
}
}
public long count() {
- SqlSession session = mybatis.openSession(false);
- try {
+ try (DbSession session = mybatis.openSession(false)) {
return session.getMapper(NotificationQueueMapper.class).count();
- } finally {
- MyBatis.closeQuietly(session);
}
}
}
public CeTask submit(CeTaskSubmit submission) {
checkState(!submitPaused.get(), "Compute Engine does not currently accept new tasks");
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
CeQueueDto dto = new CeTaskSubmitToInsertedCeQueueDto(dbSession, dbClient).apply(submission);
CeTask task = loadTask(dbSession, dto);
dbSession.commit();
return task;
-
- } finally {
- dbClient.closeSession(dbSession);
}
}
return Collections.emptyList();
}
- DbSession dbSession = dbClient.openSession(true);
- try {
+ try (DbSession dbSession = dbClient.openSession(true)) {
List<CeQueueDto> ceQueueDtos = from(submissions)
.transform(new CeTaskSubmitToInsertedCeQueueDto(dbSession, dbClient))
.toList();
List<CeTask> tasks = loadTasks(dbSession, ceQueueDtos);
dbSession.commit();
return tasks;
-
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public boolean cancel(String taskUuid) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Optional<CeQueueDto> queueDto = dbClient.ceQueueDao().selectByUuid(dbSession, taskUuid);
if (queueDto.isPresent()) {
checkState(CeQueueDto.Status.PENDING.equals(queueDto.get().getStatus()), "Task is in progress and can't be canceled [uuid=%s]", taskUuid);
return true;
}
return false;
- } finally {
- dbClient.closeSession(dbSession);
}
}
protected int cancelAll(boolean includeInProgress) {
int count = 0;
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
for (CeQueueDto queueDto : dbClient.ceQueueDao().selectAllInAscOrder(dbSession)) {
if (includeInProgress || !queueDto.getStatus().equals(CeQueueDto.Status.IN_PROGRESS)) {
cancelImpl(dbSession, queueDto);
}
}
return count;
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
public UserDto authenticate(String userLogin, String userPassword, HttpServletRequest request, Method method) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
return authenticate(dbSession, userLogin, userPassword, request, method);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private Optional<UserDto> selectUserFromDb(String userLogin) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
return Optional.ofNullable(dbClient.userDao().selectActiveUserByLogin(dbSession, userLogin));
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void handle(Request request, Response response) throws Exception {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
boolean isQueueEmpty = dbClient.ceQueueDao().selectAllInAscOrder(dbSession).isEmpty();
IOUtils.write(String.valueOf(isQueueEmpty), response.stream().output());
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
}
private ShowWsResponse doHandle(ShowWsRequest request) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto component = getComponentByUuidOrKey(dbSession, request);
Optional<SnapshotDto> lastAnalysis = dbClient.snapshotDao().selectLastAnalysisByComponentUuid(dbSession, component.projectUuid());
List<ComponentDto> ancestors = dbClient.componentDao().selectAncestors(dbSession, component);
OrganizationDto organizationDto = componentFinder.getOrganization(dbSession, component);
return buildResponse(component, organizationDto, ancestors, lastAnalysis);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private void initCe() {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
cleaner.clean(dbSession);
scheduler.startScheduling();
-
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
if (peekPaused.get()) {
return Optional.absent();
}
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Optional<CeQueueDto> dto = dbClient.ceQueueDao().peek(dbSession);
CeTask task = null;
if (dto.isPresent()) {
}
return Optional.fromNullable(task);
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void remove(CeTask task, CeActivityDto.Status status, @Nullable CeTaskResult taskResult, @Nullable Throwable error) {
checkArgument(error == null || status == CeActivityDto.Status.FAILED, "Error can be provided only when status is FAILED");
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Optional<CeQueueDto> queueDto = dbClient.ceQueueDao().selectByUuid(dbSession, task.getUuid());
checkState(queueDto.isPresent(), "Task does not exist anymore: %s", task);
CeActivityDto activityDto = new CeActivityDto(queueDto.get());
updateTaskResult(activityDto, taskResult);
updateError(activityDto, error);
remove(dbSession, queueDto.get(), activityDto);
- } finally {
- dbClient.closeSession(dbSession);
}
}
private final Map<String, String> uuidsByKey = new HashMap<>();
public UuidFactory(DbClient dbClient, String rootKey) {
- DbSession session = dbClient.openSession(false);
- try {
- List<ComponentDto> components = dbClient.componentDao().selectAllComponentsFromProjectKey(session, rootKey);
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ List<ComponentDto> components = dbClient.componentDao().selectAllComponentsFromProjectKey(dbSession, rootKey);
for (ComponentDto componentDto : components) {
uuidsByKey.put(componentDto.getKey(), componentDto.uuid());
}
- } finally {
- dbClient.closeSession(session);
}
}
private void ensureInitialized() {
if (rulesByKey == null) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
loadRulesFromDb(dbSession);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
}
LOGGER.trace("Reading SCM info from db for file '{}'", file.getKey());
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
FileSourceDto dto = dbClient.fileSourceDao().selectSourceByFileUuid(dbSession, file.getUuid());
if (dto == null || !sourceHashRepository.getRawSourceHash(file).equals(dto.getSrcHash())) {
return NoScmInfo.INSTANCE;
}
return DbScmInfo.create(file, dto.getSourceData().getLinesList()).or(NoScmInfo.INSTANCE);
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void execute() {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
List<Metric> metrics = StreamSupport.stream(metricRepository.getAll().spliterator(), false).filter(isNumeric()).collect(Collectors.toList());
new DepthTraversalTypeAwareCrawler(new VariationMeasuresVisitor(dbSession, metrics))
.visit(treeRootHolder.getRoot());
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private List<DuplicationUnitDto> selectDuplicates(Component file, Collection<String> hashes) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Analysis projectAnalysis = analysisMetadataHolder.getBaseAnalysis();
String analysisUuid = projectAnalysis == null ? null : projectAnalysis.getUuid();
return dbClient.duplicationDao().selectCandidates(dbSession, analysisUuid, file.getFileAttributes().getLanguageKey(), hashes);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
}
public void execute(Component projectOrView) {
- DbSession session = dbClient.openSession(false);
- try {
- periodsHolder.setPeriod(buildPeriod(projectOrView, session));
- } finally {
- dbClient.closeSession(session);
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ periodsHolder.setPeriod(buildPeriod(projectOrView, dbSession));
}
}
@Override
public void execute() {
- DbSession session = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
new DepthTraversalTypeAwareCrawler(
- new PersistSnapshotsPathAwareVisitor(session, analysisMetadataHolder.getAnalysisDate()))
+ new PersistSnapshotsPathAwareVisitor(dbSession, analysisMetadataHolder.getAnalysisDate()))
.visit(treeRootHolder.getRoot());
- session.commit();
- } finally {
- dbClient.closeSession(session);
+ dbSession.commit();
}
}
@Override
public void execute() {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
String projectUuid = treeRootHolder.getRoot().getUuid();
// safeguard, reset all rows to b-changed=false
disableRemainingComponents(dbSession, existingDtosByKeys.values());
dbSession.commit();
- } finally {
- dbClient.closeSession(dbSession);
}
}
return;
}
- DbSession session = dbClient.openSession(true);
- try {
+ try (DbSession dbSession = dbClient.openSession(true)) {
Component project = treeRootHolder.getRoot();
- new DepthTraversalTypeAwareCrawler(new DuplicationVisitor(session, analysisMetadataHolder.getUuid())).visit(project);
- session.commit();
- } finally {
- dbClient.closeSession(session);
+ new DepthTraversalTypeAwareCrawler(new DuplicationVisitor(dbSession, analysisMetadataHolder.getUuid())).visit(project);
+ dbSession.commit();
}
}
}
private void execute(Component root) {
- DbSession session = dbClient.openSession(true);
- try {
+ try (DbSession dbSession = dbClient.openSession(true)) {
IdUuidPair idUuidPair = new IdUuidPair(dbIdsRepository.getComponentId(root), root.getUuid());
- projectCleaner.purge(session, idUuidPair, settingsRepository.getSettings(root), disabledComponentsHolder.getUuids());
- session.commit();
- } finally {
- dbClient.closeSession(session);
+ projectCleaner.purge(dbSession, idUuidPair, settingsRepository.getSettings(root), disabledComponentsHolder.getUuids());
+ dbSession.commit();
}
}
@Override
public void execute() {
- DbSession dbSession = dbClient.openSession(true);
- try {
+ try (DbSession dbSession = dbClient.openSession(true)) {
Component root = treeRootHolder.getRoot();
Metric metric = metricRepository.getByKey(QUALITY_PROFILES_KEY);
Set<QualityProfile> qualityProfiles = parseQualityProfiles(measureRepository.getRawMeasure(root, metric));
});
dbSession.commit();
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void execute() {
- DbSession session = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Component root = treeRootHolder.getRoot();
- List<ComponentDto> baseModules = dbClient.componentDao().selectEnabledModulesFromProjectKey(session, root.getKey());
+ List<ComponentDto> baseModules = dbClient.componentDao().selectEnabledModulesFromProjectKey(dbSession, root.getKey());
Map<String, ComponentDto> baseModulesByKey = from(baseModules).uniqueIndex(ComponentDto::key);
- ValidateProjectsVisitor visitor = new ValidateProjectsVisitor(session, dbClient.componentDao(), baseModulesByKey);
+ ValidateProjectsVisitor visitor = new ValidateProjectsVisitor(dbSession, dbClient.componentDao(), baseModulesByKey);
new DepthTraversalTypeAwareCrawler(visitor).visit(root);
if (!visitor.validationMessages.isEmpty()) {
throw MessageException.of("Validation of project failed:\n o " + MESSAGES_JOINER.join(visitor.validationMessages));
}
- } finally {
- dbClient.closeSession(session);
}
}
* The issue keys are given by the multi-criteria search in Elasticsearch index.
*/
public SearchResponseData load(Collector collector, @Nullable Facets facets) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
SearchResponseData result = new SearchResponseData(dbClient.issueDao().selectByOrderedKeys(dbSession, collector.getIssueKeys()));
collector.collect(result.getIssues());
loadActionsAndTransitions(collector, result);
completeTotalEffortFromFacet(facets, result);
return result;
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void handle(Request request, Response response) throws Exception {
- DbSession dbSession = dbClient.openSession(false);
String valueAsString = request.mandatoryParam(PARAM_VALUE);
String description = request.param(PARAM_DESCRIPTION);
long now = system.now();
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto component = componentFinder.getByUuidOrKey(dbSession, request.param(PARAM_PROJECT_ID), request.param(PARAM_PROJECT_KEY), PROJECT_ID_AND_KEY);
MetricDto metric = searchMetric(dbSession, request);
checkPermissions(userSession, component);
JsonWriter json = response.newJsonWriter();
customMeasureJsonWriter.write(json, measure, metric, component, user, true, CustomMeasureJsonWriter.OPTIONAL_FIELDS);
json.close();
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private ComponentWsResponse doHandle(ComponentWsRequest request) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto component = componentFinder.getByUuidOrKey(dbSession, request.getComponentId(), request.getComponentKey(), COMPONENT_ID_AND_KEY);
Long developerId = searchDeveloperId(dbSession, request);
Optional<ComponentDto> refComponent = getReferenceComponent(dbSession, component);
List<MeasureDto> measures = searchMeasures(dbSession, component, analysis, metrics, developerId);
return buildResponse(request, component, refComponent, measures, metrics, periods);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
ComponentTreeData load(ComponentTreeWsRequest wsRequest) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto baseComponent = componentFinder.getByUuidOrKey(dbSession, wsRequest.getBaseComponentId(), wsRequest.getBaseComponentKey(), BASE_COMPONENT_ID_AND_KEY);
checkPermissions(baseComponent);
Optional<SnapshotDto> baseSnapshot = dbClient.snapshotDao().selectLastAnalysisByRootComponentUuid(dbSession, baseComponent.projectUuid());
.setPeriods(snapshotToWsPeriods(baseSnapshot.get()))
.setReferenceComponentsByUuid(searchReferenceComponentsById(dbSession, components))
.build();
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private BulkUpdateKeyWsResponse doHandle(BulkUpdateKeyWsRequest request) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto projectOrModule = componentFinder.getByUuidOrKey(dbSession, request.getId(), request.getKey(), ParamNames.ID_AND_KEY);
checkIsProjectOrModule(projectOrModule);
userSession.checkComponentPermission(UserRole.ADMIN, projectOrModule);
}
return buildResponse(newKeysByOldKeys, newKeysWithDuplicateMap);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private void doHandle(UpdateKeyWsRequest request) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto projectOrModule = componentFinder.getByUuidOrKey(dbSession, request.getId(), request.getKey(), ParamNames.PROJECT_ID_AND_FROM);
componentService.updateKey(dbSession, projectOrModule, request.getNewKey());
dbSession.commit();
- } finally {
- dbClient.closeSession(dbSession);
}
}
String name = createWsRequest.getName();
String url = createWsRequest.getUrl();
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto component = getComponentByUuidOrKey(dbSession, createWsRequest);
userSession.checkComponentPermission(UserRole.ADMIN, component);
dbSession.commit();
return buildResponse(link);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private void doHandle(DeleteWsRequest request) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
long id = request.getId();
ComponentLinkDto link = dbClient.componentLinkDao().selectById(dbSession, id);
dbClient.componentLinkDao().delete(dbSession, link.getId());
dbSession.commit();
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private SearchWsResponse doHandle(SearchWsRequest searchWsRequest) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto component = getComponentByUuidOrKey(dbSession, searchWsRequest);
List<ComponentLinkDto> links = dbClient.componentLinkDao()
.selectByComponentUuid(dbSession, component.uuid());
return buildResponse(links);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private void doHandle(JsonWriter json, Request request) {
- DbSession dbSession = dbClient.openSession(true);
- try {
+ try (DbSession dbSession = dbClient.openSession(true)) {
Optional<ComponentDto> component = loadComponent(dbSession, request);
String key = request.param(PARAM_ID);
List<PropertyDto> propertyDtos = loadProperties(dbSession, component, Optional.ofNullable(key));
new ResponseBuilder(propertyDtos).build(json);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
public Association find(ProjectQgateAssociationQuery query) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
getQualityGateId(dbSession, query.gateId());
List<ProjectQgateAssociationDto> projects = associationDao.selectProjects(dbSession, query);
List<ProjectQgateAssociationDto> authorizedProjects = keepAuthorizedProjects(dbSession, projects);
.withPageSize(query.pageSize())
.andTotal(authorizedProjects.size());
return new Association(toProjectAssociations(getPaginatedProjects(authorizedProjects, paging)), paging.hasNextPage());
- } finally {
- dbClient.closeSession(dbSession);
}
}
import org.sonar.db.DbSession;
import org.sonar.db.MyBatis;
import org.sonar.db.component.ComponentDto;
+import org.sonar.db.permission.OrganizationPermission;
import org.sonar.db.property.PropertiesDao;
import org.sonar.db.property.PropertyDto;
import org.sonar.db.qualitygate.QualityGateConditionDao;
import org.sonar.server.exceptions.Errors;
import org.sonar.server.exceptions.Message;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.db.permission.OrganizationPermission;
import org.sonar.server.user.UserSession;
import org.sonar.server.util.Validation;
}
public void setDefault(@Nullable Long idToUseAsDefault) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
setDefault(dbSession, idToUseAsDefault);
dbSession.commit();
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void start() {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
if (shouldRegisterBuiltinQualityGate(dbSession)) {
createBuiltinQualityGate(dbSession);
registerBuiltinQualityGate(dbSession);
dbSession.commit();
}
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private Collection<MetricDto> loadMetrics() {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
return dbClient.metricDao().selectEnabled(dbSession).stream()
.filter(metric -> !metric.isDataType() && !ALERT_STATUS_KEY.equals(metric.getKey()) &&
(!RATING.name().equals(metric.getValueType()) || isCoreRatingMetric(metric.getKey())))
.collect(Collectors.toList());
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void handle(Request request, Response response) throws Exception {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto project = getProject(dbSession, request.param(PARAM_PROJECT_ID), request.param(PARAM_PROJECT_KEY));
Optional<QualityGateData> data = qualityGateFinder.getQualityGate(dbSession, project.getId());
writeProtobuf(buildResponse(data), request, response);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private ProjectStatusWsResponse doHandle(ProjectStatusWsRequest request) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ProjectAndSnapshot projectAndSnapshot = getProjectAndSnapshot(dbSession, request);
checkPermission(projectAndSnapshot.project);
Optional<String> measureData = getQualityGateDetailsMeasureData(dbSession, projectAndSnapshot.project);
return ProjectStatusWsResponse.newBuilder()
.setProjectStatus(new QualityGateDetailsFormatter(measureData, projectAndSnapshot.snapshotDto).format())
.build();
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
public QProfileComparisonResult compare(String leftKey, String rightKey) {
- QProfileComparisonResult result = new QProfileComparisonResult();
-
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ QProfileComparisonResult result = new QProfileComparisonResult();
compare(dbSession, leftKey, rightKey, result);
- } finally {
- dbClient.closeSession(dbSession);
+ return result;
}
- return result;
}
private void compare(DbSession session, String leftKey, String rightKey, QProfileComparisonResult result) {
}
private RulesProfile wrap(QualityProfileDto profile) {
- DbSession dbSession = dbClient.openSession(false);
- RulesProfile target = new RulesProfile(profile.getName(), profile.getLanguage());
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ RulesProfile target = new RulesProfile(profile.getName(), profile.getLanguage());
List<ActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByProfileKey(dbSession, profile.getKey());
List<ActiveRuleParamDto> activeRuleParamDtos = dbClient.activeRuleDao().selectParamsByActiveRuleIds(dbSession, Lists.transform(activeRuleDtos, ActiveRuleDto::getId));
ListMultimap<Integer, ActiveRuleParamDto> activeRuleParamsByActiveRuleId = FluentIterable.from(activeRuleParamDtos).index(ActiveRuleParamDto::getActiveRuleId);
wrappedActiveRule.setParameter(activeRuleParamDto.getKey(), activeRuleParamDto.getValue());
}
}
- } finally {
- dbClient.closeSession(dbSession);
+ return target;
}
- return target;
}
private ProfileExporter findExporter(String exporterKey) {
QProfileComparisonResult result = comparator.compare(leftKey, rightKey);
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
List<RuleDto> referencedRules = dbClient.ruleDao().selectByKeys(dbSession, new ArrayList<>(result.collectRuleKeys()));
Map<RuleKey, RuleDto> rulesByKey = Maps.uniqueIndex(referencedRules, RuleDtoToRuleKey.INSTANCE);
Map<String, RuleRepositoryDto> repositoriesByKey = Maps.uniqueIndex(dbClient.ruleRepositoryDao().selectAll(dbSession), RuleRepositoryDto::getKey);
writeResult(response.newJsonWriter(), result, rulesByKey, repositoriesByKey);
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
@CheckForNull
public org.sonar.api.rules.Rule findById(int ruleId) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Optional<RuleDto> rule = ruleDao.selectById(ruleId, dbSession);
if (rule.isPresent() && rule.get().getStatus() != RuleStatus.REMOVED) {
return toRule(rule.get(), ruleDao.selectRuleParamsByRuleKey(dbSession, rule.get().getKey()));
}
return null;
- } finally {
- dbClient.closeSession(dbSession);
}
}
return rules;
}
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
List<RuleDto> ruleDtos = ruleDao.selectByIds(dbSession, new ArrayList<>(ruleIds));
return convertToRuleApi(dbSession, ruleDtos);
- } finally {
- dbClient.closeSession(dbSession);
}
}
return rules;
}
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
List<RuleDto> ruleDtos = ruleDao.selectByKeys(dbSession, new ArrayList<>(ruleKeys));
return convertToRuleApi(dbSession, ruleDtos);
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
@CheckForNull
public org.sonar.api.rules.Rule findByKey(RuleKey key) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Optional<RuleDto> rule = ruleDao.selectByKey(dbSession, key);
if (rule.isPresent() && rule.get().getStatus() != RuleStatus.REMOVED) {
return toRule(rule.get(), ruleDao.selectRuleParamsByRuleKey(dbSession, rule.get().getKey()));
} else {
return null;
}
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public final org.sonar.api.rules.Rule find(org.sonar.api.rules.RuleQuery query) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
List<RuleDto> rules = ruleDao.selectByQuery(dbSession, query);
if (!rules.isEmpty()) {
RuleDto rule = rules.get(0);
return toRule(rule, ruleDao.selectRuleParamsByRuleKey(dbSession, rule.getKey()));
}
return null;
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public final Collection<org.sonar.api.rules.Rule> findAll(org.sonar.api.rules.RuleQuery query) {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
List<RuleDto> rules = ruleDao.selectByQuery(dbSession, query);
if (rules.isEmpty()) {
return Collections.emptyList();
}
return convertToRuleApi(dbSession, rules);
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
private long doIndex(BulkIndexer bulk, long lastUpdatedAt) {
- DbSession dbSession = dbClient.openSession(false);
long maxDate;
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
RuleResultSetIterator rowIt = RuleResultSetIterator.create(dbClient, dbSession, lastUpdatedAt);
maxDate = doIndex(bulk, rowIt);
rowIt.close();
return maxDate;
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void handle(Request request, Response response) throws Exception {
String customKey = request.mandatoryParam(PARAM_CUSTOM_KEY);
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
try {
NewCustomRule newRule = NewCustomRule.createForCustomRule(customKey, RuleKey.parse(request.mandatoryParam(PARAM_TEMPLATE_KEY)))
.setName(request.mandatoryParam(PARAM_NAME))
} catch (ReactivationException e) {
write409(dbSession, request, response, e.ruleKey());
}
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void handle(Request wsRequest, Response wsResponse) throws Exception {
- DbSession dbSession = dbClient.openSession(false);
final ListResponse.Builder listResponseBuilder = ListResponse.newBuilder();
final ListResponse.Rule.Builder ruleBuilder = ListResponse.Rule.newBuilder();
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
dbClient.ruleDao().selectEnabled(dbSession, resultContext -> {
RuleDto dto = (RuleDto) resultContext.getResultObject();
ruleBuilder
.setInternalKey(nullToEmpty(dto.getConfigKey()));
listResponseBuilder.addRules(ruleBuilder.build());
});
- } finally {
- dbClient.closeSession(dbSession);
}
// JSON response is voluntarily not supported. This WS is for internal use.
@Override
public void handle(Request request, Response response) throws Exception {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
SearchWsRequest searchWsRequest = toSearchWsRequest(request);
SearchOptions context = buildSearchOptions(searchWsRequest);
RuleQuery query = ruleQueryFactory.createRuleQuery(request);
SearchResult searchResult = doSearch(dbSession, query, context);
SearchResponse responseBuilder = buildResponse(dbSession, searchWsRequest, context, searchResult, query);
writeProtobuf(responseBuilder, request, response);
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void handle(Request request, Response response) throws Exception {
RuleKey key = RuleKey.parse(request.mandatoryParam(PARAM_KEY));
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Optional<RuleDto> optionalRule = dbClient.ruleDao().selectByKey(dbSession, key);
checkFoundWithOptional(optionalRule, "Rule not found: " + key);
RuleDto rule = optionalRule.get();
.setRuleParameters(ruleParameters)
.setTotal(1L));
writeProtobuf(showResponse, request, response);
- } finally {
- dbClient.closeSession(dbSession);
}
}
int to = (Integer) ObjectUtils.defaultIfNull(request.paramAsInt("to"), Integer.MAX_VALUE);
boolean commitsByLine = request.mandatoryParamAsBoolean("commits_by_line");
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
ComponentDto file = componentFinder.getByKey(dbSession, fileKey);
userSession.checkComponentPermission(UserRole.CODEVIEWER, file);
Iterable<DbFileSources.Line> sourceLines = checkFoundWithOptional(sourceService.getLines(dbSession, file.uuid(), from, to), "File '%s' has no sources", fileKey);
JsonWriter json = response.newJsonWriter().beginObject();
writeSource(sourceLines, commitsByLine, json);
json.endObject().close();
- } finally {
- dbClient.closeSession(dbSession);
}
}
@Override
public void start() {
- DbSession session = dbClient.openSession(false);
- try {
- if (hasAlreadyBeenExecuted(session)) {
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ if (hasAlreadyBeenExecuted(dbSession)) {
return;
}
- if (!isSqalePluginInstalled(session)) {
- clearDebt(session);
+ if (!isSqalePluginInstalled(dbSession)) {
+ clearDebt(dbSession);
}
- markAsExecuted(session);
- session.commit();
+ markAsExecuted(dbSession);
+ dbSession.commit();
ruleIndexer.index();
- } finally {
- dbClient.closeSession(session);
}
}
@Override
public void start() {
- DbSession session = dbClient.openSession(false);
- try {
- if (!hasAlreadyBeenExecuted(session)) {
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ if (!hasAlreadyBeenExecuted(dbSession)) {
return;
}
- displayLogOnDeprecatedProjectKeys(session);
- registerTasks(session);
- session.commit();
- } finally {
- dbClient.closeSession(session);
+ displayLogOnDeprecatedProjectKeys(dbSession);
+ registerTasks(dbSession);
+ dbSession.commit();
}
}
private Map<String, ComponentDto> buildComponentsByUuid(List<CoveredFileDoc> coveredFiles) {
List<String> sourceFileUuids = Lists.transform(coveredFiles, new CoveredFileToFileUuidFunction());
- DbSession dbSession = dbClient.openSession(false);
List<ComponentDto> components;
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
components = dbClient.componentDao().selectByUuids(dbSession, sourceFileUuids);
- } finally {
- dbClient.closeSession(dbSession);
}
return Maps.uniqueIndex(components, ComponentDto::uuid);
}
request.mandatoryParamAsInt(WebService.Param.PAGE),
request.mandatoryParamAsInt(WebService.Param.PAGE_SIZE));
- DbSession dbSession = dbClient.openSession(false);
SearchResult<TestDoc> tests;
Map<String, ComponentDto> componentsByTestFileUuid;
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
tests = searchTests(dbSession, testUuid, testFileUuid, testFileKey, sourceFileUuid, sourceFileKey, sourceFileLineNumber, searchOptions);
componentsByTestFileUuid = buildComponentsByTestFileUuid(dbSession, tests.getDocs());
- } finally {
- dbClient.closeSession(dbSession);
}
WsTests.ListResponse.Builder responseBuilder = WsTests.ListResponse.newBuilder();
@Override
public void handle(Request request, Response response) throws Exception {
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Optional<UserDto> user = Optional.empty();
Collection<String> groups = emptyList();
if (userSession.isLoggedIn()) {
groups = selectGroups(dbSession);
}
writeResponse(response, user, groups);
- } finally {
- dbClient.closeSession(dbSession);
}
}
List<String> fields = request.paramAsStrings(Param.FIELDS);
SearchResult<UserDoc> result = userIndex.search(request.param(Param.TEXT_QUERY), options);
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
List<String> logins = Lists.transform(result.getDocs(), UserDocToLogin.INSTANCE);
Multimap<String, String> groupsByLogin = dbClient.groupMembershipDao().selectGroupsByLogins(dbSession, logins);
Map<String, Integer> tokenCountsByLogin = dbClient.userTokenDao().countTokensByLogins(dbSession, logins);
List<UserDto> userDtos = dbClient.userDao().selectByOrderedLogins(dbSession, logins);
writeUsers(json, userDtos, groupsByLogin, tokenCountsByLogin, fields);
json.endObject().close();
- } finally {
- dbClient.closeSession(dbSession);
}
}
*/
public java.util.Optional<String> authenticate(String token) {
String tokenHash = tokenGenerator.hash(token);
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
Optional<UserTokenDto> userToken = dbClient.userTokenDao().selectByTokenHash(dbSession, tokenHash);
if (userToken.isPresent()) {
return java.util.Optional.of(userToken.get().getLogin());
}
return java.util.Optional.empty();
- } finally {
- dbClient.closeSession(dbSession);
}
}
}
projects / sonarqube.git / commitdiff