diff options
67 files changed, 715 insertions, 752 deletions
diff --git a/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/component/ProjectPersister.java b/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/component/ProjectPersister.java index 69ff271cd71..7b296daa4c4 100644 --- a/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/component/ProjectPersister.java +++ b/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/component/ProjectPersister.java @@ -20,6 +20,7 @@ package org.sonar.ce.task.projectanalysis.component; import org.apache.commons.lang.StringUtils; +import org.sonar.api.resources.Qualifiers; import org.sonar.api.utils.System2; import org.sonar.db.DbClient; import org.sonar.db.DbSession; @@ -69,6 +70,8 @@ public class ProjectPersister { projectDto.setName(root.getName()); projectDto.setDescription(root.getDescription()); projectDto.setUpdatedAt(system2.now()); + projectDto.setKey(root.getKey()); + projectDto.setQualifier(root.getType().equals(Component.Type.PROJECT) ? Qualifiers.PROJECT : Qualifiers.APP); return projectDto; } } diff --git a/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/step/PersistComponentsStep.java b/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/step/PersistComponentsStep.java index 734a9ff75b0..881fad42933 100644 --- a/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/step/PersistComponentsStep.java +++ b/server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/step/PersistComponentsStep.java @@ -52,7 +52,6 @@ import org.sonar.db.component.ComponentUpdateDto; import static java.util.Optional.ofNullable; import static org.sonar.api.resources.Qualifiers.PROJECT; -import static org.sonar.api.resources.Qualifiers.VIEW; import static org.sonar.ce.task.projectanalysis.component.ComponentVisitor.Order.PRE_ORDER; import static org.sonar.db.component.ComponentDto.UUID_PATH_OF_ROOT; import static org.sonar.db.component.ComponentDto.UUID_PATH_SEPARATOR; @@ -108,8 +107,7 @@ public class PersistComponentsStep implements ComputationStep { .visit(treeRootHolder.getRoot()); disableRemainingComponents(dbSession, existingDtosByUuids.values()); - ensureConsistentVisibility(dbSession, projectUuid, isRootPrivate, treeRootHolder.getRoot().getType(), treeRootHolder.getRoot().getName()); - + dbClient.componentDao().setPrivateForRootComponentUuidWithoutAudit(dbSession, projectUuid, isRootPrivate); dbSession.commit(); } } @@ -135,18 +133,6 @@ public class PersistComponentsStep implements ComputationStep { disabledComponentsHolder.setUuids(uuids); } - private void ensureConsistentVisibility(DbSession dbSession, String projectUuid, boolean isRootPrivate, - Component.Type type, String componentName) { - String qualifier = null; - if (type == Component.Type.PROJECT) { - qualifier = PROJECT; - } else if (type == Component.Type.VIEW) { - qualifier = VIEW; - } - dbClient.componentDao().setPrivateForRootComponentUuid(dbSession, projectUuid, isRootPrivate, - "", qualifier, componentName, false); - } - private static boolean isRootPrivate(Component root, Map<String, ComponentDto> existingDtosByUuids) { ComponentDto rootDto = existingDtosByUuids.get(root.getUuid()); if (rootDto == null) { diff --git a/server/sonar-ce/src/main/java/org/sonar/ce/container/ComputeEngineContainerImpl.java b/server/sonar-ce/src/main/java/org/sonar/ce/container/ComputeEngineContainerImpl.java index e8204854e61..23fd2289ce2 100644 --- a/server/sonar-ce/src/main/java/org/sonar/ce/container/ComputeEngineContainerImpl.java +++ b/server/sonar-ce/src/main/java/org/sonar/ce/container/ComputeEngineContainerImpl.java @@ -83,6 +83,8 @@ import org.sonar.db.DaoModule; import org.sonar.db.DbClient; import org.sonar.db.DefaultDatabase; import org.sonar.db.MyBatis; +import org.sonar.db.audit.AuditPersister; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.purge.PurgeProfiler; import org.sonar.process.NetworkUtilsImpl; import org.sonar.process.Props; @@ -203,6 +205,9 @@ public class ComputeEngineContainerImpl implements ComputeEngineContainer { level1.getComponentByType(CECoreExtensionsInstaller.class) .install(level1, hasPlatformLevel(1), noAdditionalSideFilter()); + if (level1.getComponentByType(AuditPersister.class) == null) { + level1.add(NoOpAuditPersister.class); + } level1.startComponents(); } diff --git a/server/sonar-ce/src/main/java/org/sonar/ce/db/ReadOnlyPropertiesDao.java b/server/sonar-ce/src/main/java/org/sonar/ce/db/ReadOnlyPropertiesDao.java index ea1c3b3475c..ab6511fc7b3 100644 --- a/server/sonar-ce/src/main/java/org/sonar/ce/db/ReadOnlyPropertiesDao.java +++ b/server/sonar-ce/src/main/java/org/sonar/ce/db/ReadOnlyPropertiesDao.java @@ -25,6 +25,7 @@ import org.sonar.api.utils.System2; import org.sonar.core.util.UuidFactory; import org.sonar.db.DbSession; import org.sonar.db.MyBatis; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.property.PropertiesDao; import org.sonar.db.property.PropertyDto; @@ -39,7 +40,7 @@ import org.sonar.db.property.PropertyDto; */ public class ReadOnlyPropertiesDao extends PropertiesDao { public ReadOnlyPropertiesDao(MyBatis mybatis, System2 system2, UuidFactory uuidFactory) { - super(mybatis, system2, uuidFactory); + super(mybatis, system2, uuidFactory, new NoOpAuditPersister()); } @Override diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatDao.java index e8ec8d446dc..9462dce5e7f 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatDao.java @@ -34,12 +34,7 @@ public class AlmPatDao implements Dao { private final System2 system2; private final UuidFactory uuidFactory; - private AuditPersister auditPersister; - - public AlmPatDao(System2 system2, UuidFactory uuidFactory) { - this.system2 = system2; - this.uuidFactory = uuidFactory; - } + private final AuditPersister auditPersister; public AlmPatDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { this.system2 = system2; @@ -67,37 +62,33 @@ public class AlmPatDao implements Dao { almPatDto.setUpdatedAt(now); getMapper(dbSession).insert(almPatDto); - if (auditPersister != null) { - auditPersister.addPersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); - } + auditPersister.addPersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); } public void update(DbSession dbSession, AlmPatDto almPatDto, @Nullable String userLogin, @Nullable String almSettingKey) { long now = system2.now(); almPatDto.setUpdatedAt(now); getMapper(dbSession).update(almPatDto); - if (auditPersister != null) { - auditPersister.updatePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); - } + auditPersister.updatePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); } public void delete(DbSession dbSession, AlmPatDto almPatDto, @Nullable String userLogin, @Nullable String almSettingKey) { int deletedRows = getMapper(dbSession).deleteByUuid(almPatDto.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); } } public void deleteByUser(DbSession dbSession, UserDto user) { int deletedRows = getMapper(dbSession).deleteByUser(user.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(user)); } } public void deleteByAlmSetting(DbSession dbSession, AlmSettingDto almSetting) { int deletedRows = getMapper(dbSession).deleteByAlmSetting(almSetting.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almSetting)); } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingDao.java index e623b6407eb..ef7fb4798d2 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingDao.java @@ -33,16 +33,11 @@ public class AlmSettingDao implements Dao { private final System2 system2; private final UuidFactory uuidFactory; + private final AuditPersister auditPersister; - private AuditPersister auditPersister; - - public AlmSettingDao(System2 system2, UuidFactory uuidFactory) { + public AlmSettingDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { this.system2 = system2; this.uuidFactory = uuidFactory; - } - - public AlmSettingDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { - this(system2, uuidFactory); this.auditPersister = auditPersister; } @@ -58,9 +53,7 @@ public class AlmSettingDao implements Dao { almSettingDto.setUpdatedAt(now); getMapper(dbSession).insert(almSettingDto); - if (auditPersister != null) { - auditPersister.addDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto)); - } + auditPersister.addDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto)); } public Optional<AlmSettingDto> selectByUuid(DbSession dbSession, String uuid) { @@ -82,7 +75,7 @@ public class AlmSettingDao implements Dao { public void delete(DbSession dbSession, AlmSettingDto almSettingDto) { int deletedRows = getMapper(dbSession).deleteByKey(almSettingDto.getKey()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto.getUuid(), almSettingDto.getKey())); } } @@ -91,12 +84,9 @@ public class AlmSettingDao implements Dao { long now = system2.now(); almSettingDto.setUpdatedAt(now); getMapper(dbSession).update(almSettingDto); - - if (auditPersister != null) { - if (updateSecret) { - auditPersister.updateDevOpsPlatformSecret(dbSession, new SecretNewValue("DevOpsPlatform", almSettingDto.getRawAlm())); - } - auditPersister.updateDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto)); + if (updateSecret) { + auditPersister.updateDevOpsPlatformSecret(dbSession, new SecretNewValue("DevOpsPlatform", almSettingDto.getRawAlm())); } + auditPersister.updateDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto)); } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingDao.java index 4f4965e56b9..637381f350c 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingDao.java @@ -36,20 +36,15 @@ public class ProjectAlmSettingDao implements Dao { private final System2 system2; private final UuidFactory uuidFactory; - private AuditPersister auditPersister; + private final AuditPersister auditPersister; - public ProjectAlmSettingDao(System2 system2, UuidFactory uuidFactory) { + public ProjectAlmSettingDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { this.system2 = system2; this.uuidFactory = uuidFactory; - } - - public ProjectAlmSettingDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { - this(system2, uuidFactory); this.auditPersister = auditPersister; } - public void insertOrUpdate(DbSession dbSession, ProjectAlmSettingDto projectAlmSettingDto, String key, - String projectName, String projectKey) { + public void insertOrUpdate(DbSession dbSession, ProjectAlmSettingDto projectAlmSettingDto, String key, String projectName, String projectKey) { String uuid = uuidFactory.create(); long now = system2.now(); ProjectAlmSettingMapper mapper = getMapper(dbSession); @@ -63,21 +58,18 @@ public class ProjectAlmSettingDao implements Dao { } projectAlmSettingDto.setUpdatedAt(now); - if (auditPersister != null) { - DevOpsPlatformSettingNewValue value = new DevOpsPlatformSettingNewValue(projectAlmSettingDto, key, - projectName, projectKey); - if (isUpdate) { - auditPersister.updateDevOpsPlatformSetting(dbSession, value); - } else { - auditPersister.addDevOpsPlatformSetting(dbSession, value); - } + DevOpsPlatformSettingNewValue value = new DevOpsPlatformSettingNewValue(projectAlmSettingDto, key, projectName, projectKey); + if (isUpdate) { + auditPersister.updateDevOpsPlatformSetting(dbSession, value); + } else { + auditPersister.addDevOpsPlatformSetting(dbSession, value); } } public void deleteByProject(DbSession dbSession, ProjectDto project) { int deletedRows = getMapper(dbSession).deleteByProjectUuid(project.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(project)); } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/AuditPersister.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/AuditPersister.java index ef4b852a6f5..66b351a4720 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/AuditPersister.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/AuditPersister.java @@ -21,111 +21,123 @@ package org.sonar.db.audit; import org.sonar.core.extension.PlatformLevel; import org.sonar.db.DbSession; -import org.sonar.db.audit.model.NewValue; - -import javax.annotation.Nullable; +import org.sonar.db.audit.model.ComponentKeyNewValue; +import org.sonar.db.audit.model.ComponentNewValue; +import org.sonar.db.audit.model.DevOpsPlatformSettingNewValue; +import org.sonar.db.audit.model.GroupPermissionNewValue; +import org.sonar.db.audit.model.LicenseNewValue; +import org.sonar.db.audit.model.PermissionTemplateNewValue; +import org.sonar.db.audit.model.PersonalAccessTokenNewValue; +import org.sonar.db.audit.model.PluginNewValue; +import org.sonar.db.audit.model.PropertyNewValue; +import org.sonar.db.audit.model.SecretNewValue; +import org.sonar.db.audit.model.UserGroupNewValue; +import org.sonar.db.audit.model.UserNewValue; +import org.sonar.db.audit.model.UserPermissionNewValue; +import org.sonar.db.audit.model.UserTokenNewValue; +import org.sonar.db.audit.model.WebhookNewValue; @PlatformLevel(1) public interface AuditPersister { - void addUserGroup(DbSession dbSession, NewValue newValue); + void addUserGroup(DbSession dbSession, UserGroupNewValue newValue); - void updateUserGroup(DbSession dbSession, NewValue newValue); + void updateUserGroup(DbSession dbSession, UserGroupNewValue newValue); - void deleteUserGroup(DbSession dbSession, NewValue newValue); + void deleteUserGroup(DbSession dbSession, UserGroupNewValue newValue); - void addUser(DbSession dbSession, NewValue newValue); + void addUser(DbSession dbSession, UserNewValue newValue); - void updateUser(DbSession dbSession, NewValue newValue); + void updateUser(DbSession dbSession, UserNewValue newValue); - void updateUserPassword(DbSession dbSession, NewValue newValue); + void updateUserPassword(DbSession dbSession, SecretNewValue newValue); - void updateWebhookSecret(DbSession dbSession, NewValue newValue); + void updateWebhookSecret(DbSession dbSession, SecretNewValue newValue); - void updateDevOpsPlatformSecret(DbSession dbSession, NewValue newValue); + void updateDevOpsPlatformSecret(DbSession dbSession, SecretNewValue newValue); - void deactivateUser(DbSession dbSession, NewValue newValue); + void deactivateUser(DbSession dbSession, UserNewValue newValue); - void addUserToGroup(DbSession dbSession, NewValue newValue); + void addUserToGroup(DbSession dbSession, UserGroupNewValue newValue); - void deleteUserFromGroup(DbSession dbSession, NewValue newValue); + void deleteUserFromGroup(DbSession dbSession, UserGroupNewValue newValue); - void addProperty(DbSession dbSession, NewValue newValue, boolean isUserProperty); + void addProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty); - void updateProperty(DbSession dbSession, NewValue newValue, boolean isUserProperty); + void updateProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty); - void deleteProperty(DbSession dbSession, NewValue newValue, boolean isUserProperty); + void deleteProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty); - void addUserToken(DbSession dbSession, NewValue newValue); + void addUserToken(DbSession dbSession, UserTokenNewValue newValue); - void updateUserToken(DbSession dbSession, NewValue newValue); + void updateUserToken(DbSession dbSession, UserTokenNewValue newValue); - void deleteUserToken(DbSession dbSession, NewValue newValue); + void deleteUserToken(DbSession dbSession, UserTokenNewValue newValue); - void addGroupPermission(DbSession dbSession, NewValue newValue); + void addGroupPermission(DbSession dbSession, GroupPermissionNewValue newValue); - void deleteGroupPermission(DbSession dbSession, NewValue newValue); + void deleteGroupPermission(DbSession dbSession, GroupPermissionNewValue newValue); - void addUserPermission(DbSession dbSession, NewValue newValue); + void addUserPermission(DbSession dbSession, UserPermissionNewValue newValue); - void deleteUserPermission(DbSession dbSession, NewValue newValue); + void deleteUserPermission(DbSession dbSession, UserPermissionNewValue newValue); - void addPermissionTemplate(DbSession dbSession, NewValue newValue); + void addPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void updatePermissionTemplate(DbSession dbSession, NewValue newValue); + void updatePermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void deletePermissionTemplate(DbSession dbSession, NewValue newValue); + void deletePermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void addUserToPermissionTemplate(DbSession dbSession, NewValue newValue); + void addUserToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void deleteUserFromPermissionTemplate(DbSession dbSession, NewValue newValue); + void deleteUserFromPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void addGroupToPermissionTemplate(DbSession dbSession, NewValue newValue); + void addGroupToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void deleteGroupFromPermissionTemplate(DbSession dbSession, NewValue newValue); + void deleteGroupFromPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void addCharacteristicToPermissionTemplate(DbSession dbSession, NewValue newValue); + void addCharacteristicToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void updateCharacteristicInPermissionTemplate(DbSession dbSession, NewValue newValue); + void updateCharacteristicInPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); - void addPlugin(DbSession dbSession, NewValue newValue); + void addPlugin(DbSession dbSession, PluginNewValue newValue); - void updatePlugin(DbSession dbSession, NewValue newValue); + void updatePlugin(DbSession dbSession, PluginNewValue newValue); void generateSecretKey(DbSession dbSession); - void setLicense(DbSession dbSession, boolean isSet, NewValue newValue); + void setLicense(DbSession dbSession, boolean isSet, LicenseNewValue newValue); - void addWebhook(DbSession dbSession, NewValue newValue); + void addWebhook(DbSession dbSession, WebhookNewValue newValue); - void updateWebhook(DbSession dbSession, NewValue newValue); + void updateWebhook(DbSession dbSession, WebhookNewValue newValue); - void deleteWebhook(DbSession dbSession, NewValue newValue); + void deleteWebhook(DbSession dbSession, WebhookNewValue newValue); - void addDevOpsPlatformSetting(DbSession dbSession, NewValue newValue); + void addDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue); - void updateDevOpsPlatformSetting(DbSession dbSession, NewValue newValue); + void updateDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue); - void deleteDevOpsPlatformSetting(DbSession dbSession, NewValue newValue); + void deleteDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue); - void addPersonalAccessToken(DbSession dbSession, NewValue newValue); + void addPersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue); - void updatePersonalAccessToken(DbSession dbSession, NewValue newValue); + void updatePersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue); - void deletePersonalAccessToken(DbSession dbSession, NewValue newValue); + void deletePersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue); boolean isTrackedProperty(String propertyKey); - void addComponent(DbSession dbSession, NewValue newValue, String qualifier); + void addComponent(DbSession dbSession, ComponentNewValue newValue); - void deleteComponent(DbSession dbSession, NewValue newValue, @Nullable String qualifier); + void deleteComponent(DbSession dbSession, ComponentNewValue newValue); - void updateComponent(DbSession dbSession, NewValue newValue, String qualifier); + void updateComponent(DbSession dbSession, ComponentNewValue newValue); - void updateComponentVisibility(DbSession session, NewValue componentNewValue, @Nullable String qualifier); + void updateComponentVisibility(DbSession session, ComponentNewValue componentNewValue); - void componentKeyUpdate(DbSession session, NewValue componentKeyNewValue, String qualifier); + void componentKeyUpdate(DbSession session, ComponentKeyNewValue componentKeyNewValue, String qualifier); - void componentKeyBranchUpdate(DbSession session, NewValue componentKeyNewValue, String qualifier); + void componentKeyBranchUpdate(DbSession session, ComponentKeyNewValue componentKeyNewValue, String qualifier); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/NoOpAuditPersister.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/NoOpAuditPersister.java new file mode 100644 index 00000000000..d2de8d4d9e5 --- /dev/null +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/NoOpAuditPersister.java @@ -0,0 +1,289 @@ +/* + * SonarQube + * Copyright (C) 2009-2021 SonarSource SA + * mailto:info AT sonarsource DOT com + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.db.audit; + +import org.sonar.db.DbSession; +import org.sonar.db.audit.model.ComponentKeyNewValue; +import org.sonar.db.audit.model.ComponentNewValue; +import org.sonar.db.audit.model.DevOpsPlatformSettingNewValue; +import org.sonar.db.audit.model.GroupPermissionNewValue; +import org.sonar.db.audit.model.LicenseNewValue; +import org.sonar.db.audit.model.PermissionTemplateNewValue; +import org.sonar.db.audit.model.PersonalAccessTokenNewValue; +import org.sonar.db.audit.model.PluginNewValue; +import org.sonar.db.audit.model.PropertyNewValue; +import org.sonar.db.audit.model.SecretNewValue; +import org.sonar.db.audit.model.UserGroupNewValue; +import org.sonar.db.audit.model.UserNewValue; +import org.sonar.db.audit.model.UserPermissionNewValue; +import org.sonar.db.audit.model.UserTokenNewValue; +import org.sonar.db.audit.model.WebhookNewValue; + +public class NoOpAuditPersister implements AuditPersister { + @Override + public void addUserGroup(DbSession dbSession, UserGroupNewValue newValue) { + // no op + } + + @Override + public void updateUserGroup(DbSession dbSession, UserGroupNewValue newValue) { + // no op + } + + @Override + public void deleteUserGroup(DbSession dbSession, UserGroupNewValue newValue) { + // no op + } + + @Override + public void addUser(DbSession dbSession, UserNewValue newValue) { + // no op + } + + @Override + public void updateUser(DbSession dbSession, UserNewValue newValue) { + // no op + } + + @Override + public void updateUserPassword(DbSession dbSession, SecretNewValue newValue) { + // no op + } + + @Override + public void updateWebhookSecret(DbSession dbSession, SecretNewValue newValue) { + // no op + } + + @Override + public void updateDevOpsPlatformSecret(DbSession dbSession, SecretNewValue newValue) { + // no op + } + + @Override + public void deactivateUser(DbSession dbSession, UserNewValue newValue) { + // no op + } + + @Override + public void addUserToGroup(DbSession dbSession, UserGroupNewValue newValue) { + // no op + } + + @Override + public void deleteUserFromGroup(DbSession dbSession, UserGroupNewValue newValue) { + // no op + } + + @Override + public void addProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty) { + // no op + } + + @Override + public void updateProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty) { + // no op + } + + @Override + public void deleteProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty) { + // no op + } + + @Override + public void addUserToken(DbSession dbSession, UserTokenNewValue newValue) { + // no op + } + + @Override + public void updateUserToken(DbSession dbSession, UserTokenNewValue newValue) { + // no op + } + + @Override + public void deleteUserToken(DbSession dbSession, UserTokenNewValue newValue) { + // no op + } + + @Override + public void addGroupPermission(DbSession dbSession, GroupPermissionNewValue newValue) { + // no op + } + + @Override + public void deleteGroupPermission(DbSession dbSession, GroupPermissionNewValue newValue) { + // no op + } + + @Override + public void addUserPermission(DbSession dbSession, UserPermissionNewValue newValue) { + // no op + } + + @Override + public void deleteUserPermission(DbSession dbSession, UserPermissionNewValue newValue) { + // no op + } + + @Override + public void addPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void updatePermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void deletePermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void addUserToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void deleteUserFromPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void addGroupToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void deleteGroupFromPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void addCharacteristicToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void updateCharacteristicInPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { + // no op + } + + @Override + public void addPlugin(DbSession dbSession, PluginNewValue newValue) { + // no op + } + + @Override + public void updatePlugin(DbSession dbSession, PluginNewValue newValue) { + // no op + } + + @Override + public void generateSecretKey(DbSession dbSession) { + // no op + } + + @Override + public void setLicense(DbSession dbSession, boolean isSet, LicenseNewValue newValue) { + // no op + } + + @Override + public void addWebhook(DbSession dbSession, WebhookNewValue newValue) { + // no op + } + + @Override + public void updateWebhook(DbSession dbSession, WebhookNewValue newValue) { + // no op + } + + @Override + public void deleteWebhook(DbSession dbSession, WebhookNewValue newValue) { + // no op + } + + @Override + public void addDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue) { + // no op + } + + @Override + public void updateDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue) { + // no op + } + + @Override + public void deleteDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue) { + // no op + } + + @Override + public void addPersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue) { + // no op + } + + @Override + public void updatePersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue) { + // no op + } + + @Override + public void deletePersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue) { + // no op + } + + @Override + public boolean isTrackedProperty(String propertyKey) { + return false; + } + + @Override + public void addComponent(DbSession dbSession, ComponentNewValue newValue) { + // no op + } + + @Override + public void deleteComponent(DbSession dbSession, ComponentNewValue newValue) { + // no op + } + + @Override + public void updateComponent(DbSession dbSession, ComponentNewValue newValue) { + // no op + } + + @Override + public void updateComponentVisibility(DbSession session, ComponentNewValue componentNewValue) { + // no op + } + + @Override + public void componentKeyUpdate(DbSession session, ComponentKeyNewValue componentKeyNewValue, String qualifier) { + // no op + } + + @Override + public void componentKeyBranchUpdate(DbSession session, ComponentKeyNewValue componentKeyNewValue, String qualifier) { + // no op + } +} diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ComponentKeyNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ComponentKeyNewValue.java index 500771ddef8..a44e19ef433 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ComponentKeyNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ComponentKeyNewValue.java @@ -19,13 +19,16 @@ */ package org.sonar.db.audit.model; -public class ComponentKeyNewValue extends NewValue{ +import static com.google.common.base.Preconditions.checkNotNull; + +public class ComponentKeyNewValue extends NewValue { private final String componentUuid; private final String oldKey; private final String newKey; public ComponentKeyNewValue(String componentUuid, String oldKey, String newKey) { + checkNotNull(componentUuid, oldKey, newKey); this.componentUuid = componentUuid; this.oldKey = oldKey; this.newKey = newKey; diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ComponentNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ComponentNewValue.java index b3c359b04be..75b64af6947 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ComponentNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ComponentNewValue.java @@ -22,51 +22,54 @@ package org.sonar.db.audit.model; import javax.annotation.CheckForNull; import javax.annotation.Nullable; import org.apache.commons.lang.ObjectUtils; +import org.sonar.db.component.ComponentDto; +import org.sonar.db.project.ProjectDto; -public class ComponentNewValue extends NewValue { +import static java.util.Objects.requireNonNull; - private String componentUuid; - private String componentName; - @Nullable - private String description; - private String rootComponentUuid; - private String path; - private String componentKey; - private Boolean isPrivate; +public class ComponentNewValue extends NewValue { + private final String componentUuid; + private final String componentKey; + private final String componentName; + private final String description; + private final Boolean isPrivate; + private final String qualifier; private Boolean isEnabled; - private String qualifier; + private String path; - public ComponentNewValue(String componentUuid, String name, String componentKey, @Nullable String qualifier) { - this.componentUuid = componentUuid; - this.componentName = name; - this.componentKey = componentKey; - this.qualifier = getQualifier(qualifier); + public ComponentNewValue(ProjectDto project) { + this(project.getUuid(), project.getName(), project.getKey(), project.isPrivate(), project.getDescription(), project.getQualifier()); } - public ComponentNewValue(String componentUuid, String name, String componentKey, boolean isPrivate, String qualifier) { - this.componentUuid = componentUuid; - this.componentName = name; - this.componentKey = componentKey; - this.isPrivate = isPrivate; - this.qualifier = getQualifier(qualifier); + public ComponentNewValue(ComponentDto component) { + this(component.uuid(), component.name(), component.getKey(), component.isPrivate(), component.description(), component.qualifier()); } - public ComponentNewValue(String uuid, String name, String componentKey, boolean enabled, String path, @Nullable String qualifier) { - this.componentUuid = uuid; - this.componentName = name; + public ComponentNewValue(String componentUuid, String componentName, String componentKey, String qualifier) { + this(componentUuid, componentName, componentKey, null, null, qualifier); + } + + public ComponentNewValue(String componentUuid, String componentName, String componentKey, boolean isPrivate, String qualifier) { + this(componentUuid, isPrivate, componentName, componentKey, null, qualifier); + } + + public ComponentNewValue(String uuid, String name, String key, boolean enabled, String path, String qualifier) { + this(uuid, name, key, null, null, qualifier); this.isEnabled = enabled; this.path = path; - this.componentKey = componentKey; - this.qualifier = getQualifier(qualifier); } - public ComponentNewValue(String uuid, boolean isPrivate, String name, String componentKey, @Nullable String description, @Nullable String qualifier) { - this.componentUuid = uuid; - this.isPrivate = isPrivate; + public ComponentNewValue(String uuid, @Nullable Boolean isPrivate, String name, String key, @Nullable String description, String qualifier) { + this(uuid, name, key, isPrivate, description, qualifier); + } + + private ComponentNewValue(String uuid, String name, String key, @Nullable Boolean isPrivate, @Nullable String description, String qualifier) { + this.componentUuid = requireNonNull(uuid); this.componentName = name; - this.componentKey = componentKey; + this.componentKey = key; + this.isPrivate = isPrivate; this.description = description; - this.qualifier = getQualifier(qualifier); + this.qualifier = qualifier; } public String getComponentUuid() { @@ -86,6 +89,7 @@ public class ComponentNewValue extends NewValue { return componentKey; } + @CheckForNull public boolean isPrivate() { return isPrivate; } @@ -98,10 +102,9 @@ public class ComponentNewValue extends NewValue { public String toString() { StringBuilder sb = new StringBuilder("{"); addField(sb, "\"componentUuid\": ", this.componentUuid, true); - addField(sb, "\"rootComponentUuid\": ", this.rootComponentUuid, true); addField(sb, "\"componentKey\": ", this.componentKey, true); addField(sb, "\"componentName\": ", this.componentName, true); - addField(sb, "\"qualifier\": ", this.qualifier, true); + addField(sb, "\"qualifier\": ", getQualifier(qualifier), true); addField(sb, "\"description\": ", this.description, true); addField(sb, "\"path\": ", this.path, true); addField(sb, "\"isPrivate\": ", ObjectUtils.toString(this.isPrivate), false); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/GroupPermissionNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/GroupPermissionNewValue.java index e18885ebc9b..1577998751b 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/GroupPermissionNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/GroupPermissionNewValue.java @@ -31,23 +31,18 @@ public class GroupPermissionNewValue extends PermissionNewValue { @Nullable private String groupName; - public GroupPermissionNewValue(String uuid, String rootComponentUuid, String componentKey, String componentName, - String role, String groupUuid, String groupName, String qualifier, - @Nullable PermissionTemplateDto permissionTemplateDto) { - super(uuid, rootComponentUuid, componentKey, componentName, role, qualifier, permissionTemplateDto); + public GroupPermissionNewValue(String uuid, String componentUuid, String componentKey, String componentName, String role, String groupUuid, String groupName, + String qualifier, @Nullable PermissionTemplateDto permissionTemplate) { + super(uuid, componentUuid, componentKey, componentName, role, qualifier, permissionTemplate); this.groupUuid = groupUuid; this.groupName = groupName; } - - public GroupPermissionNewValue(String rootComponentUuid, String componentKey, String componentName, String role, - String groupUuid, String groupName, String qualifier) { - this(null, rootComponentUuid, componentKey, componentName, role, groupUuid, groupName, qualifier, null); + public GroupPermissionNewValue(String componentUuid, String componentKey, String componentName, String role, String groupUuid, String groupName, String qualifier) { + this(null, componentUuid, componentKey, componentName, role, groupUuid, groupName, qualifier, null); } - public GroupPermissionNewValue(GroupPermissionDto dto, @Nullable String componentKey, @Nullable String qualifier, - @Nullable PermissionTemplateDto permissionTemplateDto) { - this(dto.getUuid(), dto.getComponentUuid(), componentKey, dto.getComponentName(), dto.getRole(), dto.getGroupUuid(), - dto.getGroupName(), qualifier, permissionTemplateDto); + public GroupPermissionNewValue(GroupPermissionDto dto, String componentKey, String qualifier, PermissionTemplateDto permissionTemplate) { + this(dto.getUuid(), dto.getComponentUuid(), componentKey, dto.getComponentName(), dto.getRole(), dto.getGroupUuid(), dto.getGroupName(), qualifier, permissionTemplate); } @Nullable @@ -72,7 +67,7 @@ public class GroupPermissionNewValue extends PermissionNewValue { addField(sb, "\"componentName\": ", this.componentName, true); addField(sb, "\"permissionTemplateUuid\": ", this.permissionTemplateId, true); addField(sb, "\"permissionTemplateName\": ", this.permissionTemplateName, true); - addField(sb, "\"qualifier\": ", this.qualifier, true); + addField(sb, "\"qualifier\": ", getQualifier(this.qualifier), true); endString(sb); return sb.toString(); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/LicenseNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/LicenseNewValue.java index c03b67b8514..ff9824a8ee5 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/LicenseNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/LicenseNewValue.java @@ -24,7 +24,7 @@ import javax.annotation.Nullable; public class LicenseNewValue extends NewValue { @Nullable - private String edition; + private final String edition; public LicenseNewValue(@Nullable String edition) { this.edition = edition; diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/NewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/NewValue.java index 1969fe7777f..629f1d7c06b 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/NewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/NewValue.java @@ -19,6 +19,7 @@ */ package org.sonar.db.audit.model; +import javax.annotation.CheckForNull; import javax.annotation.Nullable; import static com.google.common.base.Strings.isNullOrEmpty; @@ -28,7 +29,7 @@ import static org.sonar.api.resources.Qualifiers.VIEW; public abstract class NewValue { - protected void addField(StringBuilder sb, String field, String value, boolean isString) { + protected void addField(StringBuilder sb, String field, @Nullable String value, boolean isString) { if (!isNullOrEmpty(value)) { sb.append(field); addQuote(sb, isString); @@ -52,6 +53,7 @@ public abstract class NewValue { } } + @CheckForNull protected static String getQualifier(@Nullable String qualifier) { if (qualifier == null) { return null; diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PermissionNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PermissionNewValue.java index ad2e0badcb7..1034832d3f8 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PermissionNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PermissionNewValue.java @@ -54,7 +54,7 @@ public abstract class PermissionNewValue extends NewValue { this.componentUuid = componentUuid; this.componentKey = componentKey; this.componentName = componentName; - this.qualifier = getQualifier(qualifier); + this.qualifier = qualifier; this.permission = permission; this.permissionTemplateId = permissionTemplateDto == null ? null : permissionTemplateDto.getUuid(); this.permissionTemplateName = permissionTemplateDto == null ? null : permissionTemplateDto.getName(); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PluginNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PluginNewValue.java index faff2a7521a..5bdbf439f20 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PluginNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PluginNewValue.java @@ -22,10 +22,10 @@ package org.sonar.db.audit.model; import org.sonar.db.plugin.PluginDto; public class PluginNewValue extends NewValue { - private String pluginUuid; - private String kee; - private String basePluginKey; - private String type; + private final String pluginUuid; + private final String kee; + private final String basePluginKey; + private final String type; public PluginNewValue(PluginDto pluginDto) { this.pluginUuid = pluginDto.getUuid(); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PropertyNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PropertyNewValue.java index 2de53c1714a..1ab794efc6f 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PropertyNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/PropertyNewValue.java @@ -25,7 +25,6 @@ import org.sonar.db.property.PropertyDto; import org.sonar.db.user.UserPropertyDto; public class PropertyNewValue extends NewValue { - @Nullable private String propertyKey; @Nullable @@ -57,15 +56,14 @@ public class PropertyNewValue extends NewValue { setValue(propertyKey, userPropertyDto.getValue()); } - public PropertyNewValue(PropertyDto propertyDto, @Nullable String userLogin, @Nullable String componentKey, - @Nullable String componentName, @Nullable String qualifier) { + public PropertyNewValue(PropertyDto propertyDto, @Nullable String userLogin, @Nullable String componentKey, @Nullable String componentName, @Nullable String qualifier) { this.propertyKey = propertyDto.getKey(); this.userUuid = propertyDto.getUserUuid(); this.userLogin = userLogin; this.componentUuid = propertyDto.getComponentUuid(); this.componentKey = componentKey; this.componentName = componentName; - this.qualifier = getQualifier(qualifier); + this.qualifier = qualifier; setValue(propertyKey, propertyDto.getValue()); } @@ -86,17 +84,16 @@ public class PropertyNewValue extends NewValue { setValue(propertyKey, propertyValue); } - public PropertyNewValue(@Nullable String propertyKey, @Nullable String projectUuid, @Nullable String componentKey, + public PropertyNewValue(String propertyKey, @Nullable String projectUuid, @Nullable String componentKey, @Nullable String componentName, @Nullable String qualifier, @Nullable String userUuid) { this.propertyKey = propertyKey; this.componentUuid = projectUuid; this.componentKey = componentKey; this.componentName = componentName; this.userUuid = userUuid; - this.qualifier = getQualifier(qualifier); + this.qualifier = qualifier; } - @CheckForNull public String getPropertyKey() { return this.propertyKey; } @@ -146,7 +143,7 @@ public class PropertyNewValue extends NewValue { addField(sb, "\"componentUuid\": ", this.componentUuid, true); addField(sb, "\"componentKey\": ", this.componentKey, true); addField(sb, "\"componentName\": ", this.componentName, true); - addField(sb, "\"qualifier\": ", this.qualifier, true); + addField(sb, "\"qualifier\": ", getQualifier(this.qualifier), true); endString(sb); return sb.toString(); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserGroupNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserGroupNewValue.java index f908aac657b..75daabe328e 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserGroupNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserGroupNewValue.java @@ -25,51 +25,42 @@ import org.sonar.db.user.GroupDto; import org.sonar.db.user.UserDto; import org.sonar.db.user.UserGroupDto; -public class UserGroupNewValue extends NewValue { - - @Nullable - private String groupUuid; - - @Nullable - private String name; +import static com.google.common.base.Preconditions.checkState; - @Nullable - private String description; - - @Nullable - private String userUuid; - - @Nullable - private String userLogin; +public class UserGroupNewValue extends NewValue { + private final String groupUuid; + private final String name; + private final String userUuid; + private final String userLogin; + private final String description; public UserGroupNewValue(String groupUuid, String name) { - this.groupUuid = groupUuid; - this.name = name; + this(groupUuid, name, null, null, null); } public UserGroupNewValue(GroupDto groupDto) { - this.groupUuid = groupDto.getUuid(); - this.name = groupDto.getName(); - this.description = groupDto.getDescription(); + this(groupDto.getUuid(), groupDto.getName(), null, null, groupDto.getDescription()); } public UserGroupNewValue(GroupDto groupDto, UserDto userDto) { - this.groupUuid = groupDto.getUuid(); - this.name = groupDto.getName(); - this.userUuid = userDto.getUuid(); - this.userLogin = userDto.getLogin(); + this(groupDto.getUuid(), groupDto.getName(), userDto.getUuid(), userDto.getLogin(), null); } public UserGroupNewValue(UserDto userDto) { - this.userUuid = userDto.getUuid(); - this.userLogin = userDto.getLogin(); + this(null, null, userDto.getUuid(), userDto.getLogin(), null); } public UserGroupNewValue(UserGroupDto userGroupDto, String groupName, String userLogin) { - this.groupUuid = userGroupDto.getGroupUuid(); - this.userUuid = userGroupDto.getUserUuid(); - this.name = groupName; + this(userGroupDto.getGroupUuid(), groupName, userGroupDto.getUserUuid(), userLogin, null); + } + + private UserGroupNewValue(@Nullable String groupUuid, @Nullable String name, @Nullable String userUuid, @Nullable String userLogin, @Nullable String description) { + checkState((groupUuid != null && name != null) || (userUuid != null && userLogin != null)); + this.groupUuid = groupUuid; + this.name = name; + this.userUuid = userUuid; this.userLogin = userLogin; + this.description = description; } @CheckForNull diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserNewValue.java index 62bd6e87bb1..a63af8f8571 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserNewValue.java @@ -24,6 +24,8 @@ import javax.annotation.Nullable; import org.apache.commons.lang.ObjectUtils; import org.sonar.db.user.UserDto; +import static java.util.Objects.requireNonNull; + public class UserNewValue extends NewValue { private String userUuid; private String userLogin; @@ -62,8 +64,8 @@ public class UserNewValue extends NewValue { private Long lastConnectionDate; public UserNewValue(String userUuid, String userLogin) { - this.userUuid = userUuid; - this.userLogin = userLogin; + this.userUuid = requireNonNull(userUuid); + this.userLogin = requireNonNull(userLogin); } public UserNewValue(UserDto userDto) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserPermissionNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserPermissionNewValue.java index cd441d1cfeb..83941d59fd0 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserPermissionNewValue.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/UserPermissionNewValue.java @@ -34,8 +34,7 @@ public class UserPermissionNewValue extends PermissionNewValue { public UserPermissionNewValue(UserPermissionDto permissionDto, @Nullable String componentKey, @Nullable String componentName, @Nullable UserId userId, String qualifier, @Nullable PermissionTemplateDto templateDto) { - super(permissionDto.getUuid(), permissionDto.getComponentUuid(), componentKey, componentName, permissionDto.getPermission(), - qualifier, templateDto); + super(permissionDto.getUuid(), permissionDto.getComponentUuid(), componentKey, componentName, permissionDto.getPermission(), qualifier, templateDto); this.userUuid = userId != null ? userId.getUuid() : null; this.userLogin = userId != null ? userId.getLogin() : null; } @@ -73,7 +72,7 @@ public class UserPermissionNewValue extends PermissionNewValue { addField(sb, "\"permissionTemplateName\": ", this.permissionTemplateName, true); addField(sb, "\"userUuid\": ", this.userUuid, true); addField(sb, "\"userLogin\": ", this.userLogin, true); - addField(sb, "\"qualifier\": ", this.qualifier, true); + addField(sb, "\"qualifier\": ", getQualifier(this.qualifier), true); endString(sb); return sb.toString(); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentDao.java index 40888a9a045..cf48ef999f3 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentDao.java @@ -53,11 +53,7 @@ import static org.sonar.db.component.ComponentDto.generateBranchKey; import static org.sonar.db.component.ComponentDto.generatePullRequestKey; public class ComponentDao implements Dao { - private AuditPersister auditPersister; - - public ComponentDao() { - //intentionally empty - } + private final AuditPersister auditPersister; public ComponentDao(AuditPersister auditPersister) { this.auditPersister = auditPersister; @@ -338,10 +334,8 @@ public class ComponentDao implements Dao { } public void insert(DbSession session, ComponentDto item) { - if (auditPersister != null) { - auditPersister.addComponent(session, new ComponentNewValue(item.uuid(), item.name(), item.getKey(), item.qualifier()), item.qualifier()); - } mapper(session).insert(item); + auditPersister.addComponent(session, new ComponentNewValue(item)); } public void insert(DbSession session, Collection<ComponentDto> items) { @@ -357,10 +351,8 @@ public class ComponentDao implements Dao { } public void update(DbSession session, ComponentUpdateDto component, String qualifier) { - if (auditPersister != null) { - auditPersister.updateComponent(session, new ComponentNewValue(component.getUuid(), component.getBName(), - component.getBKey(), component.isBEnabled(), component.getBPath(), qualifier), qualifier); - } + auditPersister.updateComponent(session, new ComponentNewValue(component.getUuid(), component.getBName(), + component.getBKey(), component.isBEnabled(), component.getBPath(), qualifier)); mapper(session).update(component); } @@ -376,12 +368,14 @@ public class ComponentDao implements Dao { mapper(session).resetBChangedForRootComponentUuid(projectUuid); } + public void setPrivateForRootComponentUuidWithoutAudit(DbSession session, String projectUuid, boolean isPrivate) { + mapper(session).setPrivateForRootComponentUuid(projectUuid, isPrivate); + } + public void setPrivateForRootComponentUuid(DbSession session, String projectUuid, boolean isPrivate, - String key, @Nullable String qualifier, String componentName, boolean track) { - if (track && auditPersister != null) { - ComponentNewValue componentNewValue = new ComponentNewValue(projectUuid, componentName, key, isPrivate, qualifier); - auditPersister.updateComponentVisibility(session, componentNewValue, qualifier); - } + @Nullable String qualifier, String componentKey, String componentName) { + ComponentNewValue componentNewValue = new ComponentNewValue(projectUuid, componentName, componentKey, isPrivate, qualifier); + auditPersister.updateComponentVisibility(session, componentNewValue); mapper(session).setPrivateForRootComponentUuid(projectUuid, isPrivate); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentKeyUpdaterDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentKeyUpdaterDao.java index d08b963b2eb..80638b887e6 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentKeyUpdaterDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentKeyUpdaterDao.java @@ -42,11 +42,7 @@ import static org.sonar.db.component.ComponentDto.generateBranchKey; * @since 3.2 */ public class ComponentKeyUpdaterDao implements Dao { - - private AuditPersister auditPersister; - - public ComponentKeyUpdaterDao() { - } + private final AuditPersister auditPersister; public ComponentKeyUpdaterDao(AuditPersister auditPersister) { this.auditPersister = auditPersister; @@ -86,9 +82,7 @@ public class ComponentKeyUpdaterDao implements Dao { appBranch.setKey(newAppBranchKey); mapper.updateComponent(appBranch); - if(auditPersister != null) { - auditPersister.componentKeyBranchUpdate(dbSession, new ComponentKeyNewValue(appBranchUuid, appBranchOldKey, newAppBranchKey), Qualifiers.APP); - } + auditPersister.componentKeyBranchUpdate(dbSession, new ComponentKeyNewValue(appBranchUuid, appBranchOldKey, newAppBranchKey), Qualifiers.APP); String oldAppBranchFragment = appBranchOldKey.replace(BRANCH_KEY_SEPARATOR, ""); String newAppBranchFragment = appKey + newBranchName; @@ -117,10 +111,7 @@ public class ComponentKeyUpdaterDao implements Dao { } mapper.updateComponent(resource); if (resource.getScope().equals(Scopes.PROJECT) && (resource.getQualifier().equals(Qualifiers.PROJECT) || resource.getQualifier().equals(Qualifiers.APP))) { - if(auditPersister != null) { - auditPersister.componentKeyUpdate(dbSession, - new ComponentKeyNewValue(resource.getUuid(), oldResourceKey, newResourceKey), resource.getQualifier()); - } + auditPersister.componentKeyUpdate(dbSession, new ComponentKeyNewValue(resource.getUuid(), oldResourceKey, newResourceKey), resource.getQualifier()); mapper.updateProject(oldResourceKey, newResourceKey); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java index 31c8e799749..3b53d056f72 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java @@ -41,10 +41,7 @@ public class GroupPermissionDao implements Dao { private static final String ANYONE_GROUP_PARAMETER = "anyoneGroup"; - private AuditPersister auditPersister; - - public GroupPermissionDao() { - } + private final AuditPersister auditPersister; public GroupPermissionDao(AuditPersister auditPersister) { this.auditPersister = auditPersister; @@ -124,15 +121,12 @@ public class GroupPermissionDao implements Dao { return mapper(session).selectGroupUuidsWithPermissionOnProjectBut(projectUuid, permission); } - public void insert(DbSession dbSession, GroupPermissionDto groupPermissionDto, @Nullable ComponentDto componentDto, - @Nullable PermissionTemplateDto permissionTemplateDto) { + public void insert(DbSession dbSession, GroupPermissionDto groupPermissionDto, @Nullable ComponentDto componentDto, @Nullable PermissionTemplateDto permissionTemplateDto) { mapper(dbSession).insert(groupPermissionDto); - if (auditPersister != null) { - String componentKey = (componentDto != null) ? componentDto.getKey() : null; - String qualifier = (componentDto != null) ? componentDto.qualifier() : null; - auditPersister.addGroupPermission(dbSession, new GroupPermissionNewValue(groupPermissionDto, componentKey, qualifier, permissionTemplateDto)); - } + String componentKey = (componentDto != null) ? componentDto.getKey() : null; + String qualifier = (componentDto != null) ? componentDto.qualifier() : null; + auditPersister.addGroupPermission(dbSession, new GroupPermissionNewValue(groupPermissionDto, componentKey, qualifier, permissionTemplateDto)); } /** @@ -141,7 +135,7 @@ public class GroupPermissionDao implements Dao { public void deleteByRootComponentUuid(DbSession dbSession, ComponentDto component) { int deletedRecords = mapper(dbSession).deleteByRootComponentUuid(component.uuid()); - if (deletedRecords > 0 && auditPersister != null) { + if (deletedRecords > 0) { auditPersister.deleteGroupPermission(dbSession, new GroupPermissionNewValue(component.uuid(), component.getKey(), component.name(), null, null, null, component.qualifier())); } @@ -154,7 +148,7 @@ public class GroupPermissionDao implements Dao { public int deleteByRootComponentUuidAndGroupUuid(DbSession dbSession, @Nullable String groupUuid, ComponentDto component) { int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(component.uuid(), groupUuid); - if (deletedRecords > 0 && auditPersister != null) { + if (deletedRecords > 0) { auditPersister.deleteGroupPermission(dbSession, new GroupPermissionNewValue(component.uuid(), component.getKey(), component.name(), null, groupUuid, "", component.qualifier())); } @@ -164,7 +158,7 @@ public class GroupPermissionDao implements Dao { public int deleteByRootComponentUuidForAnyOne(DbSession dbSession, ComponentDto component) { int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(component.uuid(), null); - if (deletedRecords > 0 && auditPersister != null) { + if (deletedRecords > 0) { auditPersister.deleteGroupPermission(dbSession, new GroupPermissionNewValue(component.uuid(), component.getKey(), component.name(), null, null, null, component.qualifier())); } @@ -178,7 +172,7 @@ public class GroupPermissionDao implements Dao { public int deleteByRootComponentUuidAndPermission(DbSession dbSession, String permission, ComponentDto component) { int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndPermission(component.uuid(), permission); - if (deletedRecords > 0 && auditPersister != null) { + if (deletedRecords > 0) { auditPersister.deleteGroupPermission(dbSession, new GroupPermissionNewValue(component.uuid(), component.getKey(), component.name(), permission, null, null, component.qualifier())); } @@ -205,7 +199,7 @@ public class GroupPermissionDao implements Dao { int deletedRecords = mapper(dbSession).delete(permission, groupUuid, rootComponentUuid); - if (deletedRecords > 0 && auditPersister != null) { + if (deletedRecords > 0) { String qualifier = (componentDto != null) ? componentDto.qualifier() : null; String componentKey = (componentDto != null) ? componentDto.getKey() : null; String componentName = (componentDto != null) ? componentDto.name() : null; diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionDao.java index f269ee5acad..c1857fe9c06 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionDao.java @@ -39,10 +39,7 @@ import static java.util.Collections.emptyList; import static org.sonar.db.DatabaseUtils.executeLargeInputs; public class UserPermissionDao implements Dao { - private AuditPersister auditPersister; - - public UserPermissionDao() { - } + private final AuditPersister auditPersister; public UserPermissionDao(AuditPersister auditPersister) { this.auditPersister = auditPersister; @@ -120,13 +117,11 @@ public class UserPermissionDao implements Dao { @Nullable UserId userId, @Nullable PermissionTemplateDto templateDto) { mapper(dbSession).insert(dto); - if (auditPersister != null) { - String componentName = (componentDto != null) ? componentDto.name() : null; - String componentKey = (componentDto != null) ? componentDto.getKey() : null; - String qualifier = (componentDto != null) ? componentDto.qualifier() : null; - auditPersister.addUserPermission(dbSession, new UserPermissionNewValue(dto, componentKey, componentName, userId, qualifier, - templateDto)); - } + String componentName = (componentDto != null) ? componentDto.name() : null; + String componentKey = (componentDto != null) ? componentDto.getKey() : null; + String qualifier = (componentDto != null) ? componentDto.qualifier() : null; + auditPersister.addUserPermission(dbSession, new UserPermissionNewValue(dto, componentKey, componentName, userId, qualifier, + templateDto)); } /** @@ -135,7 +130,7 @@ public class UserPermissionDao implements Dao { public void deleteGlobalPermission(DbSession dbSession, UserId user, String permission) { int deletedRows = mapper(dbSession).deleteGlobalPermission(user.getUuid(), permission); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, null, null, null, user, null)); } } @@ -146,9 +141,8 @@ public class UserPermissionDao implements Dao { public void deleteProjectPermission(DbSession dbSession, UserId user, String permission, ComponentDto component) { int deletedRows = mapper(dbSession).deleteProjectPermission(user.getUuid(), permission, component.uuid()); - if (deletedRows > 0 && auditPersister != null) { - auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, component.uuid(), component.getKey(), - component.name(), user, component.qualifier())); + if (deletedRows > 0) { + auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, component.uuid(), component.getKey(), component.name(), user, component.qualifier())); } } @@ -158,7 +152,7 @@ public class UserPermissionDao implements Dao { public void deleteProjectPermissions(DbSession dbSession, ComponentDto component) { int deletedRows = mapper(dbSession).deleteProjectPermissions(component.uuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(null, component.uuid(), component.getKey(), component.name(), null, component.qualifier())); } @@ -170,9 +164,8 @@ public class UserPermissionDao implements Dao { public int deleteProjectPermissionOfAnyUser(DbSession dbSession, String permission, ComponentDto project) { int deletedRows = mapper(dbSession).deleteProjectPermissionOfAnyUser(project.uuid(), permission); - if (deletedRows > 0 && auditPersister != null) { - auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, project.uuid(), project.getKey(), - project.name(), null, project.qualifier())); + if (deletedRows > 0) { + auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, project.uuid(), project.getKey(), project.name(), null, project.qualifier())); } return deletedRows; @@ -181,7 +174,7 @@ public class UserPermissionDao implements Dao { public void deleteByUserUuid(DbSession dbSession, UserId userId) { int deletedRows = mapper(dbSession).deleteByUserUuid(userId.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(userId, null)); } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDao.java index ab4cede2f87..b63d9570163 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDao.java @@ -31,10 +31,7 @@ import static java.util.Objects.requireNonNull; import static org.sonar.db.DatabaseUtils.executeLargeInputs; public class PermissionTemplateCharacteristicDao implements Dao { - private AuditPersister auditPersister; - - public PermissionTemplateCharacteristicDao() { - } + private final AuditPersister auditPersister; public PermissionTemplateCharacteristicDao(AuditPersister auditPersister) { this.auditPersister = auditPersister; @@ -53,10 +50,8 @@ public class PermissionTemplateCharacteristicDao implements Dao { checkArgument(dto.getCreatedAt() != 0L && dto.getUpdatedAt() != 0L); mapper(dbSession).insert(dto); - if (auditPersister != null) { - auditPersister.addCharacteristicToPermissionTemplate(dbSession, new PermissionTemplateNewValue(dto.getTemplateUuid(), - dto.getPermission(), templateName, dto.getWithProjectCreator())); - } + auditPersister.addCharacteristicToPermissionTemplate(dbSession, new PermissionTemplateNewValue(dto.getTemplateUuid(), + dto.getPermission(), templateName, dto.getWithProjectCreator())); return dto; } @@ -66,10 +61,8 @@ public class PermissionTemplateCharacteristicDao implements Dao { requireNonNull(templatePermissionDto.getUuid()); mapper(dbSession).update(templatePermissionDto); - if (auditPersister != null) { - auditPersister.updateCharacteristicInPermissionTemplate(dbSession, new PermissionTemplateNewValue(templatePermissionDto.getTemplateUuid(), - templatePermissionDto.getPermission(), templateName, templatePermissionDto.getWithProjectCreator())); - } + auditPersister.updateCharacteristicInPermissionTemplate(dbSession, new PermissionTemplateNewValue(templatePermissionDto.getTemplateUuid(), + templatePermissionDto.getPermission(), templateName, templatePermissionDto.getWithProjectCreator())); return templatePermissionDto; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java index 4aa396f4456..32a2d05328a 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java @@ -49,16 +49,11 @@ public class PermissionTemplateDao implements Dao { private final System2 system; private final UuidFactory uuidFactory; + private final AuditPersister auditPersister; - private AuditPersister auditPersister; - - public PermissionTemplateDao(UuidFactory uuidFactory, System2 system) { + public PermissionTemplateDao(UuidFactory uuidFactory, System2 system, AuditPersister auditPersister) { this.uuidFactory = uuidFactory; this.system = system; - } - - public PermissionTemplateDao(UuidFactory uuidFactory, System2 system, AuditPersister auditPersister) { - this(uuidFactory, system); this.auditPersister = auditPersister; } @@ -124,10 +119,7 @@ public class PermissionTemplateDao implements Dao { dto.setUuid(uuidFactory.create()); } mapper(session).insert(dto); - - if (auditPersister != null) { - auditPersister.addPermissionTemplate(session, new PermissionTemplateNewValue(dto.getUuid(), dto.getName())); - } + auditPersister.addPermissionTemplate(session, new PermissionTemplateNewValue(dto.getUuid(), dto.getName())); return dto; } @@ -172,16 +164,14 @@ public class PermissionTemplateDao implements Dao { session.getMapper(PermissionTemplateCharacteristicMapper.class).deleteByTemplateUuid(templateUuid); int deletedRows = mapper.deleteByUuid(templateUuid); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deletePermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName)); } } public PermissionTemplateDto update(DbSession session, PermissionTemplateDto permissionTemplate) { mapper(session).update(permissionTemplate); - if (auditPersister != null) { - auditPersister.updatePermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplate)); - } + auditPersister.updatePermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplate)); return permissionTemplate; } @@ -197,10 +187,7 @@ public class PermissionTemplateDao implements Dao { mapper(session).insertUserPermission(permissionTemplateUser); - if (auditPersister != null) { - auditPersister.addUserToPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, - permission, userUuid, userLogin, null, null)); - } + auditPersister.addUserToPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, permission, userUuid, userLogin, null, null)); session.commit(); } @@ -213,9 +200,8 @@ public class PermissionTemplateDao implements Dao { .setUserUuid(userUuid); int deletedRows = mapper(session).deleteUserPermission(permissionTemplateUser); - if (deletedRows > 0 && auditPersister != null) { - auditPersister.deleteUserFromPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, - permission, userUuid, userLogin, null, null)); + if (deletedRows > 0) { + auditPersister.deleteUserFromPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, permission, userUuid, userLogin, null, null)); } session.commit(); @@ -224,9 +210,8 @@ public class PermissionTemplateDao implements Dao { public void deleteUserPermissionsByUserUuid(DbSession dbSession, String userUuid, String userLogin) { int deletedRows = mapper(dbSession).deleteUserPermissionsByUserUuid(userUuid); - if (deletedRows > 0 && auditPersister != null) { - auditPersister.deleteUserFromPermissionTemplate(dbSession, new PermissionTemplateNewValue(null, null, - null, userUuid, userLogin, null, null)); + if (deletedRows > 0) { + auditPersister.deleteUserFromPermissionTemplate(dbSession, new PermissionTemplateNewValue(null, null, null, userUuid, userLogin, null, null)); } } @@ -241,19 +226,14 @@ public class PermissionTemplateDao implements Dao { .setUpdatedAt(now()); mapper(session).insertGroupPermission(permissionTemplateGroup); - if (auditPersister != null) { - auditPersister.addGroupToPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, - permission, null, null, groupUuid, groupName)); - } + auditPersister.addGroupToPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, permission, null, null, groupUuid, groupName)); } public void insertGroupPermission(DbSession session, PermissionTemplateGroupDto permissionTemplateGroup, String templateName) { mapper(session).insertGroupPermission(permissionTemplateGroup); - if (auditPersister != null) { - auditPersister.addGroupToPermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplateGroup.getTemplateUuid(), templateName, - permissionTemplateGroup.getPermission(), null, null, permissionTemplateGroup.getGroupUuid(), permissionTemplateGroup.getGroupName())); - } + auditPersister.addGroupToPermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplateGroup.getTemplateUuid(), templateName, + permissionTemplateGroup.getPermission(), null, null, permissionTemplateGroup.getGroupUuid(), permissionTemplateGroup.getGroupName())); } public void deleteGroupPermission(DbSession session, String templateUuid, @Nullable String groupUuid, String permission, String templateName, @@ -264,7 +244,7 @@ public class PermissionTemplateDao implements Dao { .setGroupUuid(groupUuid); int deletedRows = mapper(session).deleteGroupPermission(permissionTemplateGroup); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteGroupFromPermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplateGroup.getTemplateUuid(), templateName, permissionTemplateGroup.getPermission(), null, null, permissionTemplateGroup.getGroupUuid(), groupName)); } @@ -286,9 +266,8 @@ public class PermissionTemplateDao implements Dao { public void deleteByGroup(DbSession session, String groupUuid, String groupName) { int deletedRows = session.getMapper(PermissionTemplateMapper.class).deleteByGroupUuid(groupUuid); - if (deletedRows > 0 && auditPersister != null) { - auditPersister.deleteGroupFromPermissionTemplate(session, new PermissionTemplateNewValue(null, null, - null, null, null, groupUuid, groupName)); + if (deletedRows > 0) { + auditPersister.deleteGroupFromPermissionTemplate(session, new PermissionTemplateNewValue(null, null, null, null, null, groupUuid, groupName)); } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/plugin/PluginDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/plugin/PluginDao.java index 489e22bc694..740be6bbaf0 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/plugin/PluginDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/plugin/PluginDao.java @@ -27,11 +27,7 @@ import org.sonar.db.audit.AuditPersister; import org.sonar.db.audit.model.PluginNewValue; public class PluginDao implements Dao { - - private AuditPersister auditPersister; - - public PluginDao() { - } + private final AuditPersister auditPersister; public PluginDao(AuditPersister auditPersister) { this.auditPersister = auditPersister; @@ -53,18 +49,12 @@ public class PluginDao implements Dao { public void insert(DbSession dbSession, PluginDto dto) { mapper(dbSession).insert(dto); - - if (auditPersister != null) { - auditPersister.addPlugin(dbSession, new PluginNewValue(dto)); - } + auditPersister.addPlugin(dbSession, new PluginNewValue(dto)); } public void update(DbSession dbSession, PluginDto dto) { mapper(dbSession).update(dto); - - if (auditPersister != null) { - auditPersister.updatePlugin(dbSession, new PluginNewValue(dto)); - } + auditPersister.updatePlugin(dbSession, new PluginNewValue(dto)); } private static PluginMapper mapper(DbSession dbSession) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/project/ProjectDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/project/ProjectDao.java index 45a32cc1906..4167cead120 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/project/ProjectDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/project/ProjectDao.java @@ -31,11 +31,7 @@ import org.sonar.db.audit.model.ComponentNewValue; public class ProjectDao implements Dao { private final System2 system2; - private AuditPersister auditPersister; - - public ProjectDao(System2 system2) { - this.system2 = system2; - } + private final AuditPersister auditPersister; public ProjectDao(System2 system2, AuditPersister auditPersister) { this.system2 = system2; @@ -47,9 +43,8 @@ public class ProjectDao implements Dao { } public void insert(DbSession session, ProjectDto project, boolean track) { - if (track && auditPersister != null) { - auditPersister.addComponent(session, new ComponentNewValue(project.getUuid(), project.getName(), project.getKey(), project.getQualifier()), - project.getQualifier()); + if (track) { + auditPersister.addComponent(session, new ComponentNewValue(project)); } mapper(session).insert(project); } @@ -112,11 +107,7 @@ public class ProjectDao implements Dao { } public void update(DbSession session, ProjectDto project) { - if (auditPersister != null) { - auditPersister.updateComponent(session, new ComponentNewValue(project.getUuid(), project.isPrivate(), - project.getName(), project.getKey(), project.getDescription(), project.getQualifier()), project.getQualifier()); - } - + auditPersister.updateComponent(session, new ComponentNewValue(project)); mapper(session).update(project); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesDao.java index 522d7cdbf33..45089251dcb 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesDao.java @@ -55,16 +55,12 @@ public class PropertiesDao implements Dao { private final MyBatis mybatis; private final System2 system2; private final UuidFactory uuidFactory; - private AuditPersister auditPersister; + private final AuditPersister auditPersister; - public PropertiesDao(MyBatis mybatis, System2 system2, UuidFactory uuidFactory) { + public PropertiesDao(MyBatis mybatis, System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { this.mybatis = mybatis; this.system2 = system2; this.uuidFactory = uuidFactory; - } - - public PropertiesDao(MyBatis mybatis, System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { - this(mybatis, system2, uuidFactory); this.auditPersister = auditPersister; } @@ -109,9 +105,9 @@ public class PropertiesDao implements Dao { } try (DbSession session = mybatis.openSession(false); - Connection connection = session.getConnection(); - PreparedStatement pstmt = createStatement(projectUuid, dispatcherKeys, connection); - ResultSet rs = pstmt.executeQuery()) { + Connection connection = session.getConnection(); + PreparedStatement pstmt = createStatement(projectUuid, dispatcherKeys, connection); + ResultSet rs = pstmt.executeQuery()) { return rs.next() && rs.getInt(1) > 0; } catch (SQLException e) { throw new IllegalStateException("Fail to execute SQL for hasProjectNotificationSubscribersForDispatchers", e); @@ -214,16 +210,14 @@ public class PropertiesDao implements Dao { saveProperty(session, property, null, null, null, null); } - public void saveProperty(DbSession session, PropertyDto property, @Nullable String userLogin, @Nullable String projectKey, - @Nullable String projectName, @Nullable String qualifier) { + public void saveProperty(DbSession session, PropertyDto property, @Nullable String userLogin, @Nullable String projectKey, @Nullable String projectName, + @Nullable String qualifier) { int affectedRows = save(getMapper(session), property.getKey(), property.getUserUuid(), property.getComponentUuid(), property.getValue()); - if (auditPersister != null && auditPersister.isTrackedProperty(property.getKey())) { - if (affectedRows > 0) { - auditPersister.updateProperty(session, new PropertyNewValue(property, userLogin, projectKey, projectName, qualifier), false); - } else { - auditPersister.addProperty(session, new PropertyNewValue(property, userLogin, projectKey, projectName, qualifier), false); - } + if (affectedRows > 0) { + auditPersister.updateProperty(session, new PropertyNewValue(property, userLogin, projectKey, projectName, qualifier), false); + } else { + auditPersister.addProperty(session, new PropertyNewValue(property, userLogin, projectKey, projectName, qualifier), false); } } @@ -272,7 +266,7 @@ public class PropertiesDao implements Dao { public int deleteByQuery(DbSession dbSession, PropertyQuery query) { int deletedRows = getMapper(dbSession).deleteByQuery(query); - if (deletedRows > 0 && auditPersister != null && query.key() != null && auditPersister.isTrackedProperty(query.key())) { + if (deletedRows > 0 && query.key() != null) { auditPersister.deleteProperty(dbSession, new PropertyNewValue(query.key(), query.componentUuid(), null, null, null, query.userUuid()), false); } @@ -284,7 +278,7 @@ public class PropertiesDao implements Dao { @Nullable String projectName, @Nullable String qualifier) { int deletedRows = getMapper(dbSession).delete(dto.getKey(), dto.getUserUuid(), dto.getComponentUuid()); - if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(dto.getKey())) { + if (deletedRows > 0) { auditPersister.deleteProperty(dbSession, new PropertyNewValue(dto, userLogin, projectKey, projectName, qualifier), false); } @@ -302,7 +296,7 @@ public class PropertiesDao implements Dao { String projectName, String qualifier) { int deletedRows = getMapper(session).deleteProjectProperty(key, projectUuid); - if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) { + if (deletedRows > 0) { auditPersister.deleteProperty(session, new PropertyNewValue(key, projectUuid, projectKey, projectName, qualifier, null), false); } @@ -311,7 +305,7 @@ public class PropertiesDao implements Dao { public void deleteProjectProperties(String key, String value, DbSession session) { int deletedRows = getMapper(session).deleteProjectProperties(key, value); - if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) { + if (deletedRows > 0) { auditPersister.deleteProperty(session, new PropertyNewValue(key, value), false); } } @@ -326,7 +320,7 @@ public class PropertiesDao implements Dao { public void deleteGlobalProperty(String key, DbSession session) { int deletedRows = getMapper(session).deleteGlobalProperty(key); - if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) { + if (deletedRows > 0) { auditPersister.deleteProperty(session, new PropertyNewValue(key), false); } } @@ -357,7 +351,7 @@ public class PropertiesDao implements Dao { public void deleteByKeyAndValue(DbSession dbSession, String key, String value) { int deletedRows = getMapper(dbSession).deleteByKeyAndValue(key, value); - if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) { + if (deletedRows > 0) { auditPersister.deleteProperty(dbSession, new PropertyNewValue(key, value), false); } } @@ -368,7 +362,7 @@ public class PropertiesDao implements Dao { properties.forEach((key, value) -> { int affectedRows = save(mapper, key, null, null, value); - if (auditPersister != null && auditPersister.isTrackedProperty(key)) { + if (auditPersister.isTrackedProperty(key)) { if (affectedRows > 0) { auditPersister.updateProperty(session, new PropertyNewValue(key, value), false); } else { @@ -397,7 +391,7 @@ public class PropertiesDao implements Dao { } private void persistDeletedProperties(DbSession dbSession, @Nullable String userUuid, String userLogin, List<String> uuids) { - if (!uuids.isEmpty() && auditPersister != null) { + if (!uuids.isEmpty()) { List<PropertyDto> properties = executeLargeInputs(uuids, subList -> getMapper(dbSession).selectByUuids(subList)); properties diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/purge/PurgeDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/purge/PurgeDao.java index cf36fb63216..46b3d523ac4 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/purge/PurgeDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/purge/PurgeDao.java @@ -54,11 +54,7 @@ public class PurgeDao implements Dao { private static final String SCOPE_PROJECT = "PRJ"; private final System2 system2; - private AuditPersister auditPersister; - - public PurgeDao(System2 system2) { - this.system2 = system2; - } + private final AuditPersister auditPersister; public PurgeDao(System2 system2, AuditPersister auditPersister) { this.system2 = system2; @@ -195,19 +191,14 @@ public class PurgeDao implements Dao { long start = System2.INSTANCE.now(); List<String> branchUuids = session.getMapper(BranchMapper.class).selectByProjectUuid(uuid).stream() - .filter(branch -> !uuid.equals(branch.getUuid())) .map(BranchDto::getUuid) + .filter(branchUuid -> !uuid.equals(branchUuid)) .collect(Collectors.toList()); - branchUuids.stream() - .forEach(id -> deleteRootComponent(id, purgeMapper, purgeCommands)); + branchUuids.forEach(id -> deleteRootComponent(id, purgeMapper, purgeCommands)); deleteRootComponent(uuid, purgeMapper, purgeCommands); - - if (auditPersister != null) { - auditPersister.deleteComponent(session, new ComponentNewValue(uuid, name, key, qualifier), qualifier); - } - + auditPersister.deleteComponent(session, new ComponentNewValue(uuid, name, key, qualifier)); logProfiling(profiler, start); } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java index 20e39b9357c..b4ece4dd8e6 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java @@ -41,14 +41,10 @@ import static org.sonar.db.DatabaseUtils.executeLargeInputs; public class GroupDao implements Dao { private final System2 system; - private AuditPersister auditPersister; - - public GroupDao(System2 system) { - this.system = system; - } + private final AuditPersister auditPersister; public GroupDao(System2 system, AuditPersister auditPersister) { - this(system); + this.system = system; this.auditPersister = auditPersister; } @@ -77,7 +73,7 @@ public class GroupDao implements Dao { public void deleteByUuid(DbSession dbSession, String groupUuid, String groupName) { int deletedRows = mapper(dbSession).deleteByUuid(groupUuid); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserGroup(dbSession, new UserGroupNewValue(groupUuid, groupName)); } } @@ -95,22 +91,14 @@ public class GroupDao implements Dao { item.setCreatedAt(createdAt) .setUpdatedAt(createdAt); mapper(session).insert(item); - - if (auditPersister != null) { - auditPersister.addUserGroup(session, new UserGroupNewValue(item.getUuid(), item.getName())); - } - + auditPersister.addUserGroup(session, new UserGroupNewValue(item.getUuid(), item.getName())); return item; } public GroupDto update(DbSession session, GroupDto item) { item.setUpdatedAt(new Date(system.now())); mapper(session).update(item); - - if (auditPersister != null) { - auditPersister.updateUserGroup(session, new UserGroupNewValue(item)); - } - + auditPersister.updateUserGroup(session, new UserGroupNewValue(item)); return item; } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserDao.java index fda3d03005d..56e53fe8bb0 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserDao.java @@ -49,16 +49,11 @@ public class UserDao implements Dao { private static final long WEEK_IN_MS = DAYS.toMillis(7L); private final System2 system2; private final UuidFactory uuidFactory; + private final AuditPersister auditPersister; - private AuditPersister auditPersister; - - public UserDao(System2 system2, UuidFactory uuidFactory) { + public UserDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { this.system2 = system2; this.uuidFactory = uuidFactory; - } - - public UserDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { - this(system2, uuidFactory); this.auditPersister = auditPersister; } @@ -114,11 +109,7 @@ public class UserDao implements Dao { public UserDto insert(DbSession session, UserDto dto) { long now = system2.now(); mapper(session).insert(dto.setUuid(uuidFactory.create()).setCreatedAt(now).setUpdatedAt(now)); - - if (auditPersister != null) { - auditPersister.addUser(session, new UserNewValue(dto.getUuid(), dto.getLogin())); - } - + auditPersister.addUser(session, new UserNewValue(dto.getUuid(), dto.getLogin())); return dto; } @@ -128,7 +119,7 @@ public class UserDao implements Dao { public UserDto update(DbSession session, UserDto dto, boolean track) { mapper(session).update(dto.setUpdatedAt(system2.now())); - if (track && auditPersister != null) { + if (track) { auditPersister.updateUser(session, new UserNewValue(dto)); } return dto; @@ -144,10 +135,7 @@ public class UserDao implements Dao { public void deactivateUser(DbSession dbSession, UserDto user) { mapper(dbSession).deactivateUser(user.getLogin(), system2.now()); - - if (auditPersister != null) { - auditPersister.deactivateUser(dbSession, new UserNewValue(user.getUuid(), user.getLogin())); - } + auditPersister.deactivateUser(dbSession, new UserNewValue(user.getUuid(), user.getLogin())); } public void cleanHomepage(DbSession dbSession, ProjectDto project) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java index 7c7bf915947..a90ff80a41a 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java @@ -26,11 +26,7 @@ import org.sonar.db.audit.AuditPersister; import org.sonar.db.audit.model.UserGroupNewValue; public class UserGroupDao implements Dao { - - private AuditPersister auditPersister; - - public UserGroupDao() { - } + private final AuditPersister auditPersister; public UserGroupDao(AuditPersister auditPersister) { this.auditPersister = auditPersister; @@ -38,11 +34,7 @@ public class UserGroupDao implements Dao { public UserGroupDto insert(DbSession session, UserGroupDto dto, String groupName, String login) { mapper(session).insert(dto); - - if (auditPersister != null) { - auditPersister.addUserToGroup(session, new UserGroupNewValue(dto, groupName, login)); - } - + auditPersister.addUserToGroup(session, new UserGroupNewValue(dto, groupName, login)); return dto; } @@ -53,7 +45,7 @@ public class UserGroupDao implements Dao { public void delete(DbSession session, GroupDto group, UserDto user) { int deletedRows = mapper(session).delete(group.getUuid(), user.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserFromGroup(session, new UserGroupNewValue(group, user)); } } @@ -61,7 +53,7 @@ public class UserGroupDao implements Dao { public void deleteByGroupUuid(DbSession session, String groupUuid, String groupName) { int deletedRows = mapper(session).deleteByGroupUuid(groupUuid); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserFromGroup(session, new UserGroupNewValue(groupUuid, groupName)); } } @@ -69,7 +61,7 @@ public class UserGroupDao implements Dao { public void deleteByUserUuid(DbSession dbSession, UserDto userDto) { int deletedRows = mapper(dbSession).deleteByUserUuid(userDto.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserFromGroup(dbSession, new UserGroupNewValue(userDto)); } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesDao.java index 01080f163be..cca3809c127 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesDao.java @@ -32,16 +32,11 @@ public class UserPropertiesDao implements Dao { private final System2 system2; private final UuidFactory uuidFactory; + private final AuditPersister auditPersister; - private AuditPersister auditPersister; - - public UserPropertiesDao(System2 system2, UuidFactory uuidFactory) { + public UserPropertiesDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { this.system2 = system2; this.uuidFactory = uuidFactory; - } - - public UserPropertiesDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { - this(system2, uuidFactory); this.auditPersister = auditPersister; } @@ -57,12 +52,10 @@ public class UserPropertiesDao implements Dao { isUpdate = false; } - if (auditPersister != null && auditPersister.isTrackedProperty(dto.getKey())) { - if (isUpdate) { - auditPersister.updateProperty(session, new PropertyNewValue(dto, login), true); - } else { - auditPersister.addProperty(session, new PropertyNewValue(dto, login), true); - } + if (isUpdate) { + auditPersister.updateProperty(session, new PropertyNewValue(dto, login), true); + } else { + auditPersister.addProperty(session, new PropertyNewValue(dto, login), true); } return dto; @@ -72,7 +65,7 @@ public class UserPropertiesDao implements Dao { List<UserPropertyDto> userProperties = selectByUser(session, user); int deletedRows = mapper(session).deleteByUserUuid(user.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { userProperties.stream() .filter(p -> auditPersister.isTrackedProperty(p.getKey())) .forEach(p -> auditPersister.deleteProperty(session, new PropertyNewValue(p, user.getLogin()), true)); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenDao.java index 11165f9fd55..21e129d4fd8 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenDao.java @@ -35,38 +35,27 @@ import static org.sonar.core.util.stream.MoreCollectors.toList; import static org.sonar.db.DatabaseUtils.executeLargeInputs; public class UserTokenDao implements Dao { - - private UuidFactory uuidFactory; - private AuditPersister auditPersister; - - public UserTokenDao(UuidFactory uuidFactory) { - this.uuidFactory = uuidFactory; - } + private final UuidFactory uuidFactory; + private final AuditPersister auditPersister; public UserTokenDao(UuidFactory uuidFactory, AuditPersister auditPersister) { - this(uuidFactory); + this.uuidFactory = uuidFactory; this.auditPersister = auditPersister; } public void insert(DbSession dbSession, UserTokenDto userTokenDto, String userLogin) { userTokenDto.setUuid(uuidFactory.create()); mapper(dbSession).insert(userTokenDto); - - if (auditPersister != null) { - auditPersister.addUserToken(dbSession, new UserTokenNewValue(userTokenDto, userLogin)); - } + auditPersister.addUserToken(dbSession, new UserTokenNewValue(userTokenDto, userLogin)); } - public void update(DbSession session, UserTokenDto userTokenDto, @Nullable String userLogin) { - update(session, userTokenDto, true, userLogin); + public void update(DbSession dbSession, UserTokenDto userTokenDto, @Nullable String userLogin) { + mapper(dbSession).update(userTokenDto); + auditPersister.updateUserToken(dbSession, new UserTokenNewValue(userTokenDto, userLogin)); } - public void update(DbSession dbSession, UserTokenDto userTokenDto, boolean track, @Nullable String userLogin) { + public void updateWithoutAudit(DbSession dbSession, UserTokenDto userTokenDto) { mapper(dbSession).update(userTokenDto); - - if (track && auditPersister != null) { - auditPersister.updateUserToken(dbSession, new UserTokenNewValue(userTokenDto, userLogin)); - } } @CheckForNull @@ -101,7 +90,7 @@ public class UserTokenDao implements Dao { public void deleteByUser(DbSession dbSession, UserDto user) { int deletedRows = mapper(dbSession).deleteByUserUuid(user.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserToken(dbSession, new UserTokenNewValue(user)); } } @@ -109,7 +98,7 @@ public class UserTokenDao implements Dao { public void deleteByUserAndName(DbSession dbSession, UserDto user, String name) { int deletedRows = mapper(dbSession).deleteByUserUuidAndName(user.getUuid(), name); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteUserToken(dbSession, new UserTokenNewValue(user, name)); } } diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookDao.java index 38c6be76329..8e619c28a5f 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookDao.java @@ -33,11 +33,7 @@ import org.sonar.db.project.ProjectDto; public class WebhookDao implements Dao { private final System2 system2; - private AuditPersister auditPersister; - - public WebhookDao(System2 system2) { - this.system2 = system2; - } + private final AuditPersister auditPersister; public WebhookDao(System2 system2, AuditPersister auditPersister) { this.system2 = system2; @@ -58,27 +54,21 @@ public class WebhookDao implements Dao { public void insert(DbSession dbSession, WebhookDto dto, @Nullable String projectKey, @Nullable String projectName) { mapper(dbSession).insert(dto.setCreatedAt(system2.now()).setUpdatedAt(system2.now())); - - if (auditPersister != null) { - auditPersister.addWebhook(dbSession, new WebhookNewValue(dto, projectKey, projectName)); - } + auditPersister.addWebhook(dbSession, new WebhookNewValue(dto, projectKey, projectName)); } public void update(DbSession dbSession, WebhookDto dto, @Nullable String projectKey, @Nullable String projectName) { mapper(dbSession).update(dto.setUpdatedAt(system2.now())); - - if (auditPersister != null) { - if (dto.getSecret() != null) { - auditPersister.updateWebhookSecret(dbSession, new SecretNewValue("webhook_name", dto.getName())); - } - auditPersister.updateWebhook(dbSession, new WebhookNewValue(dto, projectKey, projectName)); + if (dto.getSecret() != null) { + auditPersister.updateWebhookSecret(dbSession, new SecretNewValue("webhook_name", dto.getName())); } + auditPersister.updateWebhook(dbSession, new WebhookNewValue(dto, projectKey, projectName)); } public void delete(DbSession dbSession, String uuid, String webhookName) { int deletedRows = mapper(dbSession).delete(uuid); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteWebhook(dbSession, new WebhookNewValue(uuid, webhookName)); } } @@ -86,7 +76,7 @@ public class WebhookDao implements Dao { public void deleteByProject(DbSession dbSession, ProjectDto projectDto) { int deletedRows = mapper(dbSession).deleteForProjectUuid(projectDto.getUuid()); - if (deletedRows > 0 && auditPersister != null) { + if (deletedRows > 0) { auditPersister.deleteWebhook(dbSession, new WebhookNewValue(projectDto)); } } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoTest.java index 5b4ac5b94e8..365fdeeb26f 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoTest.java @@ -27,6 +27,7 @@ import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.alm.setting.AlmSettingDao; import org.sonar.db.alm.setting.AlmSettingDto; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.user.UserDto; import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric; @@ -46,9 +47,9 @@ public class AlmPatDaoTest { private DbSession dbSession = db.getSession(); private UuidFactory uuidFactory = mock(UuidFactory.class); - private AlmSettingDao almSettingDao = new AlmSettingDao(system2, uuidFactory); + private AlmSettingDao almSettingDao = new AlmSettingDao(system2, uuidFactory, new NoOpAuditPersister()); - private AlmPatDao underTest = new AlmPatDao(system2, uuidFactory); + private AlmPatDao underTest = new AlmPatDao(system2, uuidFactory, new NoOpAuditPersister()); @Test public void selectByUuid() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoWithPersisterTest.java index 73a736e5e3d..44433fd239e 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoWithPersisterTest.java @@ -34,6 +34,7 @@ import org.sonar.db.user.UserDto; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.clearInvocations; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; @@ -45,16 +46,17 @@ public class AlmPatDaoWithPersisterTest { private static final long NOW = 1000000L; private static final String A_UUID = "SOME_UUID"; + private final AuditPersister auditPersister = mock(AuditPersister.class); private final ArgumentCaptor<PersonalAccessTokenNewValue> newValueCaptor = ArgumentCaptor.forClass(PersonalAccessTokenNewValue.class); - private TestSystem2 system2 = new TestSystem2().setNow(NOW); + private final TestSystem2 system2 = new TestSystem2().setNow(NOW); @Rule public DbTester db = DbTester.create(system2, auditPersister); - private DbSession dbSession = db.getSession(); - private UuidFactory uuidFactory = mock(UuidFactory.class); + private final DbSession dbSession = db.getSession(); + private final UuidFactory uuidFactory = mock(UuidFactory.class); - private AlmPatDao underTest = db.getDbClient().almPatDao(); + private final AlmPatDao underTest = db.getDbClient().almPatDao(); @Test public void insertAndUpdateArePersisted() { @@ -164,7 +166,7 @@ public class AlmPatDaoWithPersisterTest { @Test public void deleteByAlmSettingWithoutAffectedRowsIsNotPersisted() { AlmSettingDto almSettingDto = db.almSettings().insertBitbucketAlmSetting(); - + clearInvocations(auditPersister); underTest.deleteByAlmSetting(dbSession, almSettingDto); verifyNoInteractions(auditPersister); diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/AlmSettingDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/AlmSettingDaoTest.java index b2b3a20797b..acebd2bc6c5 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/AlmSettingDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/AlmSettingDaoTest.java @@ -27,6 +27,7 @@ import org.sonar.core.util.UuidFactory; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.almsettings.AlmSettingsTesting; +import org.sonar.db.audit.NoOpAuditPersister; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; @@ -44,7 +45,7 @@ public class AlmSettingDaoTest { private DbSession dbSession = db.getSession(); private UuidFactory uuidFactory = mock(UuidFactory.class); - private AlmSettingDao underTest = new AlmSettingDao(system2, uuidFactory); + private AlmSettingDao underTest = new AlmSettingDao(system2, uuidFactory, new NoOpAuditPersister()); @Test public void selectByUuid() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoTest.java index 6824adb0734..c972d2d6ab6 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoTest.java @@ -27,6 +27,7 @@ import org.sonar.api.impl.utils.TestSystem2; import org.sonar.core.util.UuidFactory; import org.sonar.db.DbSession; import org.sonar.db.DbTester; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.project.ProjectDto; import static org.assertj.core.api.Assertions.assertThat; @@ -48,7 +49,7 @@ public class ProjectAlmSettingDaoTest { private DbSession dbSession = db.getSession(); private UuidFactory uuidFactory = mock(UuidFactory.class); - private ProjectAlmSettingDao underTest = new ProjectAlmSettingDao(system2, uuidFactory); + private ProjectAlmSettingDao underTest = new ProjectAlmSettingDao(system2, uuidFactory, new NoOpAuditPersister()); @Test public void select_by_project() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoWithPersisterTest.java index 018bda5d50e..e1ce9095f12 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoWithPersisterTest.java @@ -24,6 +24,7 @@ import org.junit.Test; import org.mockito.ArgumentCaptor; import org.sonar.api.impl.utils.TestSystem2; import org.sonar.core.util.UuidFactory; +import org.sonar.core.util.UuidFactoryFast; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.audit.AuditPersister; @@ -38,6 +39,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; +import static org.sonar.db.almsettings.AlmSettingsTesting.newGithubAlmSettingDto; import static org.sonar.db.almsettings.AlmSettingsTesting.newGithubProjectAlmSettingDto; public class ProjectAlmSettingDaoWithPersisterTest { @@ -53,13 +55,12 @@ public class ProjectAlmSettingDaoWithPersisterTest { public final DbTester db = DbTester.create(system2, auditPersister); private final DbSession dbSession = db.getSession(); - private final UuidFactory uuidFactory = mock(UuidFactory.class); + private final UuidFactory uuidFactory = UuidFactoryFast.getInstance(); private final ProjectAlmSettingDao underTest = db.getDbClient().projectAlmSettingDao(); @Test public void insertAndUpdateExistingBindingArePersisted() { - when(uuidFactory.create()).thenReturn(A_UUID); - AlmSettingDto githubAlmSetting = db.almSettings().insertGitHubAlmSetting(); + AlmSettingDto githubAlmSetting = newGithubAlmSettingDto().setUuid(uuidFactory.create()); ProjectDto project = db.components().insertPrivateProjectDto(); ProjectAlmSettingDto projectAlmSettingDto = newGithubProjectAlmSettingDto(githubAlmSetting, project) .setSummaryCommentEnabled(false); @@ -95,8 +96,7 @@ public class ProjectAlmSettingDaoWithPersisterTest { @Test public void deleteByProjectIsPersisted() { - when(uuidFactory.create()).thenReturn(A_UUID); - AlmSettingDto githubAlmSetting = db.almSettings().insertGitHubAlmSetting(); + AlmSettingDto githubAlmSetting = newGithubAlmSettingDto().setUuid(uuidFactory.create()); ProjectDto project = db.components().insertPrivateProjectDto(); ProjectAlmSettingDto projectAlmSettingDto = newGithubProjectAlmSettingDto(githubAlmSetting, project) .setSummaryCommentEnabled(false); @@ -118,15 +118,7 @@ public class ProjectAlmSettingDaoWithPersisterTest { underTest.deleteByProject(dbSession, project); - verify(auditPersister).addComponent(any(), any(), any()); + verify(auditPersister).addComponent(any(), any()); verifyNoMoreInteractions(auditPersister); } - - @Test - public void deleteByAlmSettingNotTrackedIsNotPersisted() { - AlmSettingDto githubAlmSetting = db.almSettings().insertGitHubAlmSetting(); - underTest.deleteByAlmSetting(dbSession, githubAlmSetting); - - verifyNoInteractions(auditPersister); - } } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentDaoTest.java index dde9a0beda0..56054397785 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentDaoTest.java @@ -42,7 +42,6 @@ import org.assertj.core.api.ListAssert; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; -import org.mockito.Mockito; import org.sonar.api.impl.utils.AlwaysIncreasingSystem2; import org.sonar.api.resources.Qualifiers; import org.sonar.api.resources.Scopes; @@ -51,6 +50,7 @@ import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.RowNotFoundException; import org.sonar.db.audit.AuditPersister; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.audit.model.ComponentNewValue; import org.sonar.db.issue.IssueDto; import org.sonar.db.metric.MetricDto; @@ -72,7 +72,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.entry; import static org.assertj.core.api.Assertions.tuple; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; @@ -118,7 +117,7 @@ public class ComponentDaoTest { private final Random random = new Random(); private final DbSession dbSession = db.getSession(); - private final ComponentDao underTest = new ComponentDao(); + private final ComponentDao underTest = new ComponentDao(new NoOpAuditPersister()); private final ComponentDao underTestWithAuditPersister = new ComponentDao(auditPersister); private static ComponentTreeQuery.Builder newTreeQuery(String baseUuid) { @@ -1772,7 +1771,7 @@ public class ComponentDaoTest { db.components().insertComponent(newPrivateProjectDto().setRootUuid(uuid1).setProjectUuid("foo").setPrivate(false)).uuid(), }; - underTest.setPrivateForRootComponentUuid(db.getSession(), uuid1, true, "key", null, "name", true); + underTest.setPrivateForRootComponentUuidWithoutAudit(db.getSession(), uuid1, true); assertThat(privateFlagOfUuid(uuids[0])).isTrue(); assertThat(privateFlagOfUuid(uuids[1])).isTrue(); @@ -1780,7 +1779,7 @@ public class ComponentDaoTest { assertThat(privateFlagOfUuid(uuids[3])).isFalse(); assertThat(privateFlagOfUuid(uuids[4])).isFalse(); - underTest.setPrivateForRootComponentUuid(db.getSession(), uuid1, false, "key", null, "name", true); + underTest.setPrivateForRootComponentUuidWithoutAudit(db.getSession(), uuid1, false); assertThat(privateFlagOfUuid(uuids[0])).isFalse(); assertThat(privateFlagOfUuid(uuids[1])).isFalse(); @@ -1788,7 +1787,7 @@ public class ComponentDaoTest { assertThat(privateFlagOfUuid(uuids[3])).isFalse(); assertThat(privateFlagOfUuid(uuids[4])).isFalse(); - underTest.setPrivateForRootComponentUuid(db.getSession(), uuid2, false, "key", null, "name", true); + underTest.setPrivateForRootComponentUuidWithoutAudit(db.getSession(), uuid2, false); assertThat(privateFlagOfUuid(uuids[0])).isFalse(); assertThat(privateFlagOfUuid(uuids[1])).isFalse(); @@ -1796,7 +1795,7 @@ public class ComponentDaoTest { assertThat(privateFlagOfUuid(uuids[3])).isFalse(); assertThat(privateFlagOfUuid(uuids[4])).isFalse(); - underTest.setPrivateForRootComponentUuid(db.getSession(), uuid2, true, "key", null, "name", true); + underTest.setPrivateForRootComponentUuidWithoutAudit(db.getSession(), uuid2, true); assertThat(privateFlagOfUuid(uuids[0])).isFalse(); assertThat(privateFlagOfUuid(uuids[1])).isFalse(); @@ -1884,28 +1883,26 @@ public class ComponentDaoTest { @Test public void setPrivateForRootComponentUuid_auditPersisterIsCalled() { - underTestWithAuditPersister.setPrivateForRootComponentUuid(dbSession, "anyUuid", false, "key", APP, "appName", true); + underTestWithAuditPersister.setPrivateForRootComponentUuid(dbSession, "anyUuid", false, "key", APP, "appName"); - verify(auditPersister, Mockito.times(1)) - .updateComponentVisibility(any(DbSession.class), any(ComponentNewValue.class), anyString()); + verify(auditPersister).updateComponentVisibility(any(DbSession.class), any(ComponentNewValue.class)); } @Test - public void setPrivateForRootComponentUuid_withoutTrack_auditPersisterIsNotCalled() { - underTestWithAuditPersister.setPrivateForRootComponentUuid(dbSession, "anyUuid", false, "key", APP, "appName", false); + public void setPrivateForRootComponentUuidWithoutAudit_auditPersisterIsNotCalled() { + underTestWithAuditPersister.setPrivateForRootComponentUuidWithoutAudit(dbSession, "anyUuid", false); verifyNoInteractions(auditPersister); } @Test public void update_auditPersisterIsCalled() { - ComponentUpdateDto app = new ComponentUpdateDto(); + ComponentUpdateDto app = new ComponentUpdateDto().setUuid("uuid"); app.setBQualifier(APP); underTestWithAuditPersister.update(dbSession, app, APP); - verify(auditPersister, Mockito.times(1)) - .updateComponent(any(DbSession.class), any(ComponentNewValue.class), anyString()); + verify(auditPersister).updateComponent(any(DbSession.class), any(ComponentNewValue.class)); } @Test @@ -1914,8 +1911,7 @@ public class ComponentDaoTest { underTestWithAuditPersister.insert(dbSession, app); - verify(auditPersister, Mockito.times(1)) - .addComponent(any(DbSession.class), any(ComponentNewValue.class), anyString()); + verify(auditPersister).addComponent(any(DbSession.class), any(ComponentNewValue.class)); } private boolean privateFlagOfUuid(String uuid) { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/component/ScrollForFileMoveComponentDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/component/ScrollForFileMoveComponentDaoTest.java index 78f42bb40fd..7650e3a64a8 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/component/ScrollForFileMoveComponentDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/component/ScrollForFileMoveComponentDaoTest.java @@ -35,6 +35,7 @@ import org.junit.runner.RunWith; import org.sonar.api.utils.System2; import org.sonar.db.DbSession; import org.sonar.db.DbTester; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.source.FileSourceDto; import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic; @@ -50,7 +51,7 @@ public class ScrollForFileMoveComponentDaoTest { private Random random = new Random(); private DbSession dbSession = db.getSession(); - private ComponentDao underTest = new ComponentDao(); + private ComponentDao underTest = new ComponentDao(new NoOpAuditPersister()); @Test public void scrollAllFilesForFileMove_has_no_effect_if_project_does_not_exist() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java index 24d8075b28e..77aeec19786 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java @@ -33,6 +33,7 @@ import org.sonar.api.web.UserRole; import org.sonar.core.util.stream.MoreCollectors; import org.sonar.db.DbSession; import org.sonar.db.DbTester; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.component.ComponentDto; import org.sonar.db.user.GroupDto; @@ -59,7 +60,7 @@ public class GroupPermissionDaoTest { public DbTester db = DbTester.create(System2.INSTANCE); private final DbSession dbSession = db.getSession(); - private final GroupPermissionDao underTest = new GroupPermissionDao(); + private final GroupPermissionDao underTest = new GroupPermissionDao(new NoOpAuditPersister()); @Test public void group_count_by_permission_and_component_id_on_private_projects() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterTest.java index f633f63febd..78c4a49eb26 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterTest.java @@ -33,24 +33,22 @@ import org.sonar.db.component.ComponentDto; import org.sonar.db.user.GroupDto; import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; -import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.sonar.api.web.UserRole.ADMIN; public class GroupPermissionDaoWithPersisterTest { private final AuditPersister auditPersister = mock(AuditPersister.class); @Rule - public DbTester db = DbTester.create(System2.INSTANCE, auditPersister); + public DbTester db = DbTester.create(System2.INSTANCE); private final SequenceUuidFactory uuidFactory = new SequenceUuidFactory(); private final ArgumentCaptor<GroupPermissionNewValue> newValueCaptor = ArgumentCaptor.forClass(GroupPermissionNewValue.class); private final DbSession dbSession = db.getSession(); - private final GroupPermissionDao underTest = db.getDbClient().groupPermissionDao(); + private final GroupPermissionDao underTest = new GroupPermissionDao(auditPersister); private GroupDto group; private ComponentDto project; @@ -87,7 +85,7 @@ public class GroupPermissionDaoWithPersisterTest { verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture()); GroupPermissionNewValue newValue = newValueCaptor.getValue(); assertNewValue(newValue, dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.getKey(), - project.name(), "project"); + project.name(), "TRK"); assertThat(newValue).hasToString("{\"permissionUuid\": \"1\", \"permission\": \"admin\", \"groupUuid\": \"guuid\", \"groupName\": \"gname\"," + " \"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\", \"componentName\": \"cname\", \"qualifier\": \"project\" }"); @@ -95,7 +93,7 @@ public class GroupPermissionDaoWithPersisterTest { verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture()); newValue = newValueCaptor.getValue(); - assertNewValue(newValue, null, null, null, project.uuid(), null, project.getKey(), project.name(), "project"); + assertNewValue(newValue, null, null, null, project.uuid(), null, project.getKey(), project.name(), "TRK"); assertThat(newValue).hasToString("{\"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\", \"componentName\": \"cname\", \"qualifier\": \"project\" }"); } @@ -105,8 +103,7 @@ public class GroupPermissionDaoWithPersisterTest { underTest.deleteByRootComponentUuid(dbSession, project); - verify(auditPersister).addComponent(any(), any(), any()); - verifyNoMoreInteractions(auditPersister); + verifyNoInteractions(auditPersister); } @Test @@ -115,7 +112,7 @@ public class GroupPermissionDaoWithPersisterTest { verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture()); GroupPermissionNewValue newValue = newValueCaptor.getValue(); - assertNewValue(newValue, dto.getUuid(), null, null, project.uuid(), dto.getRole(), project.getKey(), project.name(), "project"); + assertNewValue(newValue, dto.getUuid(), null, null, project.uuid(), dto.getRole(), project.getKey(), project.name(), "TRK"); assertThat(newValue).hasToString("{\"permissionUuid\": \"1\", \"permission\": \"admin\", \"componentUuid\": \"cuuid\", " + "\"componentKey\": \"cKey\", \"componentName\": \"cname\", \"qualifier\": \"project\" }"); @@ -123,7 +120,7 @@ public class GroupPermissionDaoWithPersisterTest { verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture()); newValue = newValueCaptor.getValue(); - assertNewValue(newValue, null, null, null, project.uuid(), null, project.getKey(), project.name(), "project"); + assertNewValue(newValue, null, null, null, project.uuid(), null, project.getKey(), project.name(), "TRK"); assertThat(newValue).hasToString("{\"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\", " + "\"componentName\": \"cname\", \"qualifier\": \"project\" }"); } @@ -134,8 +131,7 @@ public class GroupPermissionDaoWithPersisterTest { underTest.deleteByRootComponentUuidForAnyOne(dbSession, project); - verify(auditPersister).addComponent(any(), any(), any()); - verifyNoMoreInteractions(auditPersister); + verifyNoInteractions(auditPersister); } @Test @@ -144,7 +140,7 @@ public class GroupPermissionDaoWithPersisterTest { verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture()); GroupPermissionNewValue newValue = newValueCaptor.getValue(); - assertNewValue(newValue, dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.getKey(), project.name(), "project"); + assertNewValue(newValue, dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.getKey(), project.name(), "TRK"); assertThat(newValue).hasToString("{\"permissionUuid\": \"1\", \"permission\": \"admin\", \"groupUuid\": \"guuid\", \"groupName\": \"gname\", " + "\"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\", \"componentName\": \"cname\", \"qualifier\": \"project\" }"); @@ -152,7 +148,7 @@ public class GroupPermissionDaoWithPersisterTest { verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture()); newValue = newValueCaptor.getValue(); - assertNewValue(newValue, null, null, null, project.uuid(), ADMIN, project.getKey(), project.name(), "project"); + assertNewValue(newValue, null, null, null, project.uuid(), ADMIN, project.getKey(), project.name(), "TRK"); assertThat(newValue).hasToString("{\"permission\": \"admin\", \"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\"," + " \"componentName\": \"cname\", \"qualifier\": \"project\" }"); } @@ -165,17 +161,14 @@ public class GroupPermissionDaoWithPersisterTest { underTest.deleteByRootComponentUuidAndPermission(dbSession, dto.getRole(), project); - verify(auditPersister).addComponent(any(), any(), any()); - verifyNoMoreInteractions(auditPersister); + verifyNoInteractions(auditPersister); } private void assertNewValue(GroupPermissionNewValue newValue, String uuid, String groupUuid, String groupName, String cUuid, String permission, String componentKey, String cName, String qualifier) { assertThat(newValue) - .extracting("permissionUuid", "groupUuid", "groupName", "componentUuid", "permission", - "componentKey", "componentName", "qualifier") - .containsExactly(uuid, groupUuid, groupName, cUuid, permission, componentKey, - cName, qualifier); + .extracting("permissionUuid", "groupUuid", "groupName", "componentUuid", "permission", "componentKey", "componentName", "qualifier") + .containsExactly(uuid, groupUuid, groupName, cUuid, permission, componentKey, cName, qualifier); } private void addGroupPermission() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java index 97b28dbf552..3fa1803a26b 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java @@ -34,6 +34,7 @@ import org.sonar.api.web.UserRole; import org.sonar.core.util.Uuids; import org.sonar.db.DbSession; import org.sonar.db.DbTester; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.component.ComponentDto; import org.sonar.db.user.UserDto; @@ -62,7 +63,7 @@ public class UserPermissionDaoTest { public DbTester db = DbTester.create(System2.INSTANCE); private DbSession dbSession = db.getSession(); - private UserPermissionDao underTest = new UserPermissionDao(); + private UserPermissionDao underTest = new UserPermissionDao(new NoOpAuditPersister()); @Test public void select_global_permissions() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoWithPersisterTest.java index b1c8f862f50..a8b767d942b 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoWithPersisterTest.java @@ -93,16 +93,6 @@ public class UserPermissionDaoWithPersisterTest { } @Test - public void userGlobalPermissionDeleteWithoutAffectedRowsIsNotPersisted() { - UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com")); - - underTest.deleteGlobalPermission(dbSession, user, SYSTEM_ADMIN); - - verify(auditPersister).addUser(any(), any()); - verifyNoMoreInteractions(auditPersister); - } - - @Test public void userProjectPermissionInsertAndDeleteArePersisted() { UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com")); ComponentDto project = db.components().insertPrivateProject(); @@ -112,7 +102,7 @@ public class UserPermissionDaoWithPersisterTest { verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture()); UserPermissionNewValue newValue = newValueCaptor.getValue(); assertNewValue(newValue, dto.getUuid(), user.getUuid(), user.getLogin(), project.uuid(), dto.getPermission(), - project.getKey(), project.name(), "project"); + project.getKey(), project.name(), "TRK"); assertThat(newValue.toString()).contains("componentUuid"); underTest.deleteProjectPermission(dbSession, user, SYSTEM_ADMIN, project); @@ -120,7 +110,7 @@ public class UserPermissionDaoWithPersisterTest { verify(auditPersister).deleteUserPermission(eq(dbSession), newValueCaptor.capture()); newValue = newValueCaptor.getValue(); assertNewValue(newValue, null, user.getUuid(), user.getLogin(), project.uuid(), dto.getPermission(), - project.getKey(), project.name(), "project"); + project.getKey(), project.name(), "TRK"); assertThat(newValue.toString()).doesNotContain("permissionUuid"); } @@ -132,7 +122,7 @@ public class UserPermissionDaoWithPersisterTest { underTest.deleteProjectPermission(dbSession, user, SYSTEM_ADMIN, project); verify(auditPersister).addUser(any(), any()); - verify(auditPersister).addComponent(any(), any(), any()); + verify(auditPersister).addComponent(any(), any()); verifyNoMoreInteractions(auditPersister); } @@ -146,7 +136,7 @@ public class UserPermissionDaoWithPersisterTest { verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture()); UserPermissionNewValue newValue = newValueCaptor.getValue(); assertNewValue(newValue, dto.getUuid(), user.getUuid(), user.getLogin(), portfolio.uuid(), dto.getPermission(), - portfolio.getKey(), portfolio.name(), "portfolio"); + portfolio.getKey(), portfolio.name(), "VW"); assertThat(newValue.toString()).contains("componentUuid"); } @@ -160,7 +150,7 @@ public class UserPermissionDaoWithPersisterTest { verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture()); UserPermissionNewValue newValue = newValueCaptor.getValue(); assertNewValue(newValue, dto.getUuid(), user.getUuid(), user.getLogin(), application.uuid(), dto.getPermission(), - application.getKey(), application.name(), "application"); + application.getKey(), application.name(), "APP"); assertThat(newValue.toString()).contains("componentUuid"); } @@ -175,7 +165,7 @@ public class UserPermissionDaoWithPersisterTest { verify(auditPersister).deleteUserPermission(eq(dbSession), newValueCaptor.capture()); UserPermissionNewValue newValue = newValueCaptor.getValue(); assertNewValue(newValue, null, null, null, project.uuid(), dto.getPermission(), - project.getKey(), project.name(), "project"); + project.getKey(), project.name(), "TRK"); assertThat(newValue.toString()).doesNotContain("userUuid"); } @@ -185,7 +175,7 @@ public class UserPermissionDaoWithPersisterTest { underTest.deleteProjectPermissionOfAnyUser(dbSession, SCAN_EXECUTION, project); - verify(auditPersister).addComponent(any(), any(), any()); + verify(auditPersister).addComponent(any(), any()); verifyNoMoreInteractions(auditPersister); } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoTest.java index 8cdf7c6d698..4a399f69880 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoTest.java @@ -27,6 +27,7 @@ import org.sonar.api.utils.System2; import org.sonar.api.web.UserRole; import org.sonar.db.DbSession; import org.sonar.db.DbTester; +import org.sonar.db.audit.NoOpAuditPersister; import static com.google.common.collect.Lists.newArrayList; import static java.util.Arrays.asList; @@ -39,7 +40,7 @@ public class PermissionTemplateCharacteristicDaoTest { @Rule public DbTester db = DbTester.create(System2.INSTANCE); private final DbSession dbSession = db.getSession(); - private final PermissionTemplateCharacteristicDao underTest = new PermissionTemplateCharacteristicDao(); + private final PermissionTemplateCharacteristicDao underTest = new PermissionTemplateCharacteristicDao(new NoOpAuditPersister()); @Test public void selectByTemplateId_filter_by_template_uuid() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java index 980a2f32087..3cfe40e6d75 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoTest.java @@ -32,6 +32,7 @@ import org.sonar.core.util.UuidFactory; import org.sonar.core.util.UuidFactoryFast; import org.sonar.db.DbSession; import org.sonar.db.DbTester; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.user.GroupDto; import org.sonar.db.user.UserDto; @@ -63,7 +64,7 @@ public class PermissionTemplateDaoTest { private PermissionTemplateDbTester templateDb = db.permissionTemplates(); private UuidFactory uuidFactory = UuidFactoryFast.getInstance(); - private PermissionTemplateDao underTest = new PermissionTemplateDao(uuidFactory, system2); + private PermissionTemplateDao underTest = new PermissionTemplateDao(uuidFactory, system2, new NoOpAuditPersister()); @Before public void setUp() { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/project/ProjectDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/project/ProjectDaoTest.java index 62a3d921d5b..9bb9a1e00c8 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/project/ProjectDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/project/ProjectDaoTest.java @@ -32,6 +32,7 @@ import org.sonar.api.resources.Qualifiers; import org.sonar.api.utils.System2; import org.sonar.db.DbTester; import org.sonar.db.audit.AuditPersister; +import org.sonar.db.audit.NoOpAuditPersister; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.tuple; @@ -50,7 +51,7 @@ public class ProjectDaoTest { private final AuditPersister auditPersister = mock(AuditPersister.class); - private final ProjectDao projectDao = new ProjectDao(system2); + private final ProjectDao projectDao = new ProjectDao(system2, new NoOpAuditPersister()); private final ProjectDao projectDaoWithAuditPersister = new ProjectDao(system2, auditPersister); @Test @@ -201,7 +202,7 @@ public class ProjectDaoTest { projectDaoWithAuditPersister.insert(db.getSession(), dto1, true); - verify(auditPersister, times(1)).addComponent(any(), any(), any()); + verify(auditPersister, times(1)).addComponent(any(), any()); } @Test @@ -210,7 +211,7 @@ public class ProjectDaoTest { projectDaoWithAuditPersister.update(db.getSession(), dto1); - verify(auditPersister, times(1)).updateComponent(any(), any(), any()); + verify(auditPersister, times(1)).updateComponent(any(), any()); } private void assertProject(ProjectDto dto, String name, String kee, String uuid, String desc, @Nullable String tags, boolean isPrivate) { diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/property/PropertiesDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/property/PropertiesDaoWithPersisterTest.java index 7e83aa2bdc2..1ba0912b70b 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/property/PropertiesDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/property/PropertiesDaoWithPersisterTest.java @@ -45,7 +45,6 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; -import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; @RunWith(DataProviderRunner.class) @@ -81,7 +80,6 @@ public class PropertiesDaoWithPersisterTest { when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); underTest.saveProperty(new PropertyDto().setKey(KEY).setValue(VALUE)); - verify(auditPersister).isTrackedProperty(KEY); verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); @@ -94,22 +92,11 @@ public class PropertiesDaoWithPersisterTest { } @Test - public void saveGlobalNotTrackedPropertyIsNotPersisted() { - when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); - - underTest.saveProperty(new PropertyDto().setKey(KEY).setValue(VALUE)); - - verify(auditPersister).isTrackedProperty(KEY); - verifyNoMoreInteractions(auditPersister); - } - - @Test public void saveGlobalTrackedAndSecuredPropertyIsPersisted() { when(auditPersister.isTrackedProperty(SECURED_KEY)).thenReturn(true); underTest.saveProperty(new PropertyDto().setKey(SECURED_KEY).setValue(VALUE)); - verify(auditPersister).isTrackedProperty(SECURED_KEY); verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -120,13 +107,12 @@ public class PropertiesDaoWithPersisterTest { } @Test - public void saveProjectTrackedPropertyIsPersisted() { + public void saveProjectPropertyIsPersisted() { when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - verify(auditPersister).isTrackedProperty(KEY); verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -135,7 +121,7 @@ public class PropertiesDaoWithPersisterTest { PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentKey, PropertyNewValue::getComponentName, PropertyNewValue::getQualifier) .containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(), - USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_KEY, PROJECT_NAME, "project"); + USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_KEY, PROJECT_NAME, "TRK"); assertThat(newValue.toString()).contains("componentUuid"); } @@ -146,7 +132,6 @@ public class PropertiesDaoWithPersisterTest { PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); underTest.saveProperty(session, propertyDto, USER_LOGIN, "app-key", "app-name", Qualifiers.APP); - verify(auditPersister).isTrackedProperty(KEY); verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -155,7 +140,7 @@ public class PropertiesDaoWithPersisterTest { PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentKey, PropertyNewValue::getComponentName, PropertyNewValue::getQualifier) .containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(), - USER_LOGIN, propertyDto.getComponentUuid(), "app-key", "app-name", "application"); + USER_LOGIN, propertyDto.getComponentUuid(), "app-key", "app-name", "APP"); assertThat(newValue.toString()) .contains("componentUuid"); } @@ -167,7 +152,6 @@ public class PropertiesDaoWithPersisterTest { PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); underTest.saveProperty(session, propertyDto, USER_LOGIN, "portfolio-key", "portfolio-name", Qualifiers.VIEW); - verify(auditPersister).isTrackedProperty(KEY); verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -176,7 +160,7 @@ public class PropertiesDaoWithPersisterTest { PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentKey, PropertyNewValue::getComponentName, PropertyNewValue::getQualifier) .containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(), - USER_LOGIN, propertyDto.getComponentUuid(), "portfolio-key", "portfolio-name", "portfolio"); + USER_LOGIN, propertyDto.getComponentUuid(), "portfolio-key", "portfolio-name", "VW"); assertThat(newValue.toString()) .contains("componentUuid"); } @@ -188,7 +172,6 @@ public class PropertiesDaoWithPersisterTest { PropertyDto propertyDto = getPropertyDto(SECURED_KEY, PROJECT_UUID, USER_UUID); underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - verify(auditPersister).isTrackedProperty(SECURED_KEY); verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -197,7 +180,7 @@ public class PropertiesDaoWithPersisterTest { PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentKey, PropertyNewValue::getComponentName, PropertyNewValue::getQualifier) .containsExactly(propertyDto.getKey(), null, propertyDto.getUserUuid(), - USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_KEY, PROJECT_NAME, "project"); + USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_KEY, PROJECT_NAME, "TRK"); assertThat(newValue.toString()).contains("componentUuid"); } @@ -210,7 +193,6 @@ public class PropertiesDaoWithPersisterTest { underTest.deleteByQuery(session, query); - verify(auditPersister, times(2)).isTrackedProperty(KEY); verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -233,19 +215,6 @@ public class PropertiesDaoWithPersisterTest { } @Test - public void deleteNotTrackedPropertyByQueryIsNotPersisted() { - when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); - PropertyQuery query = getPropertyQuery(KEY); - PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); - underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - - underTest.deleteByQuery(session, query); - - verify(auditPersister, times(2)).isTrackedProperty(KEY); - verifyNoMoreInteractions(auditPersister); - } - - @Test public void deleteTrackedPropertyIsPersisted() { when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); @@ -253,7 +222,6 @@ public class PropertiesDaoWithPersisterTest { underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - verify(auditPersister, times(2)).isTrackedProperty(KEY); verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -276,18 +244,6 @@ public class PropertiesDaoWithPersisterTest { } @Test - public void deleteNotTrackedPropertyIsNotPersisted() { - when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); - PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); - underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - - underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - - verify(auditPersister, times(2)).isTrackedProperty(KEY); - verifyNoMoreInteractions(auditPersister); - } - - @Test public void deleteTrackedProjectPropertyIsPersisted() { when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, null); @@ -295,7 +251,6 @@ public class PropertiesDaoWithPersisterTest { underTest.deleteProjectProperty(KEY, PROJECT_UUID, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - verify(auditPersister, times(2)).isTrackedProperty(KEY); verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -316,18 +271,6 @@ public class PropertiesDaoWithPersisterTest { } @Test - public void deleteNotTrackedProjectPropertyIsNotPersisted() { - when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); - PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); - underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - - underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); - - verify(auditPersister, times(2)).isTrackedProperty(KEY); - verifyNoMoreInteractions(auditPersister); - } - - @Test public void deleteTrackedProjectPropertiesIsPersisted() { when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, null); @@ -335,7 +278,6 @@ public class PropertiesDaoWithPersisterTest { underTest.deleteProjectProperties(KEY, VALUE); - verify(auditPersister, times(2)).isTrackedProperty(KEY); verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -356,18 +298,6 @@ public class PropertiesDaoWithPersisterTest { } @Test - public void deleteNotTrackedProjectPropertiesIsNotPersisted() { - when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); - PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, null); - underTest.saveProperty(propertyDto); - - underTest.deleteProjectProperties(KEY, VALUE); - - verify(auditPersister, times(2)).isTrackedProperty(KEY); - verifyNoMoreInteractions(auditPersister); - } - - @Test public void deleteTrackedGlobalPropertyIsPersisted() { when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); PropertyDto propertyDto = getPropertyDto(KEY, null, null); @@ -375,7 +305,6 @@ public class PropertiesDaoWithPersisterTest { underTest.deleteGlobalProperty(KEY, session); - verify(auditPersister, times(2)).isTrackedProperty(KEY); verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -396,25 +325,10 @@ public class PropertiesDaoWithPersisterTest { } @Test - public void deleteNotTrackedGlobalPropertyIsNotPersisted() { - when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); - PropertyDto propertyDto = getPropertyDto(KEY, null, null); - underTest.saveProperty(session, propertyDto, null, null, null, null); - - underTest.deleteGlobalProperty(KEY, session); - - verify(auditPersister, times(2)).isTrackedProperty(KEY); - verifyNoMoreInteractions(auditPersister); - } - - @Test public void deletePropertyByUserIsPersisted() { UserDto user = setUserProperties(VALUE); underTest.deleteByUser(session, user.getUuid(), user.getLogin()); - verify(auditPersister, times(2)).isTrackedProperty(KEY); - verify(auditPersister, times(2)).isTrackedProperty(ANOTHER_KEY); - verify(auditPersister, times(2)).isTrackedProperty(SECURED_KEY); verify(auditPersister, times(2)).deleteProperty(any(), newValueCaptor.capture(), eq(false)); List<PropertyNewValue> newValues = newValueCaptor.getAllValues(); assertThat(newValues.get(0)) @@ -446,9 +360,6 @@ public class PropertiesDaoWithPersisterTest { UserDto user = setUserProperties(null); underTest.deleteByMatchingLogin(session, user.getLogin(), newArrayList(KEY, ANOTHER_KEY, SECURED_KEY)); - verify(auditPersister, times(2)).isTrackedProperty(KEY); - verify(auditPersister, times(2)).isTrackedProperty(ANOTHER_KEY); - verify(auditPersister, times(2)).isTrackedProperty(SECURED_KEY); verify(auditPersister, times(2)).deleteProperty(any(), newValueCaptor.capture(), eq(false)); List<PropertyNewValue> newValues = newValueCaptor.getAllValues(); assertThat(newValues.get(0)) @@ -484,7 +395,6 @@ public class PropertiesDaoWithPersisterTest { underTest.saveProperty(session, propertyDto, USER_LOGIN, null, null, null); underTest.deleteByKeyAndValue(session, KEY, VALUE); - verify(auditPersister, times(2)).isTrackedProperty(KEY); verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -504,18 +414,6 @@ public class PropertiesDaoWithPersisterTest { verifyNoInteractions(auditPersister); } - @Test - public void deleteNotTrackedPropertyByKeyAndValueIsNotPersisted() { - when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); - PropertyDto propertyDto = getPropertyDto(KEY, null, USER_UUID); - underTest.saveProperty(session, propertyDto, USER_LOGIN, null, null, null); - - underTest.deleteByKeyAndValue(session, KEY, VALUE); - - verify(auditPersister, times(2)).isTrackedProperty(KEY); - verifyNoMoreInteractions(auditPersister); - } - private PropertyDto getPropertyDto(String key, @Nullable String projectUuid, @Nullable String userUuid) { return new PropertyDto() .setKey(key) diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/purge/PurgeDaoWithAuditTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/purge/PurgeDaoWithAuditTest.java index 0b37df85ebc..70c27f914ea 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/purge/PurgeDaoWithAuditTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/purge/PurgeDaoWithAuditTest.java @@ -59,12 +59,11 @@ public class PurgeDaoWithAuditTest { underTestWithPersister.deleteProject(dbSession, project.uuid(), project.qualifier(), project.name(), project.getKey()); - verify(auditPersister).deleteComponent(any(DbSession.class), newValueCaptor.capture(), eq(project.qualifier())); + verify(auditPersister).deleteComponent(any(DbSession.class), newValueCaptor.capture()); ComponentNewValue componentNewValue = newValueCaptor.getValue(); assertThat(componentNewValue) - .extracting(ComponentNewValue::getComponentUuid, ComponentNewValue::getComponentName, ComponentNewValue::getComponentKey, - ComponentNewValue::getQualifier) - .containsExactly(project.uuid(), project.name(), project.getKey(), "project"); + .extracting(ComponentNewValue::getComponentUuid, ComponentNewValue::getComponentName, ComponentNewValue::getComponentKey, ComponentNewValue::getQualifier) + .containsExactly(project.uuid(), project.name(), project.getKey(), "TRK"); } } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoWithPersisterTest.java index e18a167d6ad..fdcda4f0ad3 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoWithPersisterTest.java @@ -92,7 +92,8 @@ public class UserGroupDaoWithPersisterTest { underTest.deleteByGroupUuid(db.getSession(), group1.getUuid(), group1.getName()); db.getSession().commit(); - verifyNoInteractions(auditPersister); + verify(auditPersister).addUserGroup(any(), any()); + verifyNoMoreInteractions(auditPersister); } @Test @@ -145,13 +146,14 @@ public class UserGroupDaoWithPersisterTest { } @Test - public void deletByUserAndGroupWithoutAffectedRowsIsNotPersisted() { + public void deleteByUserAndGroupWithoutAffectedRowsIsNotPersisted() { UserDto user1 = db.users().insertUser(); GroupDto group1 = db.users().insertGroup(); underTest.delete(db.getSession(), group1, user1); db.getSession().commit(); verify(auditPersister).addUser(any(), any()); + verify(auditPersister).addUserGroup(any(), any()); verifyNoMoreInteractions(auditPersister); } } diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserPropertiesDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserPropertiesDaoWithPersisterTest.java index 5992048b027..86bc3f1941d 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserPropertiesDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserPropertiesDaoWithPersisterTest.java @@ -53,8 +53,6 @@ public class UserPropertiesDaoWithPersisterTest { @Test public void insertTrackedUserPropertyIsPersisted() { - when(auditPersister.isTrackedProperty(PROPERTY_KEY)).thenReturn(true); - UserDto user = db.users().insertUser(); verify(auditPersister).addUser(eq(db.getSession()), any()); @@ -66,7 +64,6 @@ public class UserPropertiesDaoWithPersisterTest { user.getLogin()); verify(auditPersister).addProperty(eq(db.getSession()), newValueCaptor.capture(), eq(true)); - verify(auditPersister).isTrackedProperty(PROPERTY_KEY); assertThat(newValueCaptor.getValue()) .extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue, PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin) @@ -76,8 +73,6 @@ public class UserPropertiesDaoWithPersisterTest { @Test public void insertTrackedAndSecuredUserPropertyIsPersisted() { - when(auditPersister.isTrackedProperty(SECURED_PROPERTY_KEY)).thenReturn(true); - UserDto user = db.users().insertUser(); verify(auditPersister).addUser(eq(db.getSession()), any()); @@ -88,7 +83,6 @@ public class UserPropertiesDaoWithPersisterTest { .setValue("a_value"), user.getLogin()); - verify(auditPersister).isTrackedProperty(SECURED_PROPERTY_KEY); verify(auditPersister).addProperty(eq(db.getSession()), newValueCaptor.capture(), eq(true)); PropertyNewValue newValue = newValueCaptor.getValue(); assertThat(newValue) @@ -99,25 +93,7 @@ public class UserPropertiesDaoWithPersisterTest { } @Test - public void insertNotTrackedUserPropertyIsNotPersisted() { - when(auditPersister.isTrackedProperty(PROPERTY_KEY)).thenReturn(false); - - UserDto user = db.users().insertUser(); - underTest.insertOrUpdate(db.getSession(), new UserPropertyDto() - .setUserUuid(user.getUuid()) - .setKey(PROPERTY_KEY) - .setValue("a_value"), - user.getLogin()); - - verify(auditPersister).addUser(eq(db.getSession()), any()); - verify(auditPersister).isTrackedProperty(PROPERTY_KEY); - verifyNoMoreInteractions(auditPersister); - } - - @Test public void updateTrackedUserPropertyIsPersisted() { - when(auditPersister.isTrackedProperty(PROPERTY_KEY)).thenReturn(true); - UserDto user = db.users().insertUser(); underTest.insertOrUpdate(db.getSession(), new UserPropertyDto() .setUserUuid(user.getUuid()) @@ -159,10 +135,9 @@ public class UserPropertiesDaoWithPersisterTest { underTest.deleteByUser(db.getSession(), user); verify(auditPersister).addUser(eq(db.getSession()), any()); - verify(auditPersister).addProperty(eq(db.getSession()), any(), eq(true)); - verify(auditPersister).addProperty(eq(db.getSession()), any(), eq(true)); - verify(auditPersister, times(2)).isTrackedProperty(PROPERTY_KEY); - verify(auditPersister, times(2)).isTrackedProperty(SECURED_PROPERTY_KEY); + verify(auditPersister, times(2)).addProperty(eq(db.getSession()), any(), eq(true)); + verify(auditPersister).isTrackedProperty(PROPERTY_KEY); + verify(auditPersister).isTrackedProperty(SECURED_PROPERTY_KEY); verify(auditPersister).deleteProperty(eq(db.getSession()), newValueCaptor.capture(), eq(true)); verifyNoMoreInteractions(auditPersister); assertThat(newValueCaptor.getValue()) diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoTest.java index e258b5e55ca..8d640e17fd0 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoTest.java @@ -63,7 +63,7 @@ public class UserTokenDaoTest { UserTokenDto userToken2 = db.users().insertToken(user1); assertThat(underTest.selectByTokenHash(dbSession, userToken1.getTokenHash()).getLastConnectionDate()).isNull(); - underTest.update(dbSession, userToken1.setLastConnectionDate(10_000_000_000L), false, null); + underTest.updateWithoutAudit(dbSession, userToken1.setLastConnectionDate(10_000_000_000L)); UserTokenDto userTokenReloaded = underTest.selectByTokenHash(dbSession, userToken1.getTokenHash()); assertThat(userTokenReloaded.getLastConnectionDate()).isEqualTo(10_000_000_000L); diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoWithPersisterTest.java index 79940eeaf34..4aca0d5f93e 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoWithPersisterTest.java @@ -78,7 +78,7 @@ public class UserTokenDaoWithPersisterTest { assertThat(underTest.selectByTokenHash(dbSession, userToken1.getTokenHash()).getLastConnectionDate()).isNull(); - underTest.update(dbSession, userToken1.setLastConnectionDate(10_000_000_000L), false, null); + underTest.updateWithoutAudit(dbSession, userToken1.setLastConnectionDate(10_000_000_000L)); underTest.update(dbSession, userToken1.setName("new_name"), user1.getLogin()); verify(auditPersister).updateUserToken(eq(db.getSession()), newValueCaptor.capture()); diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/webhook/WebhookDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/webhook/WebhookDaoWithPersisterTest.java index cb3429d319f..dd178be2cd5 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/webhook/WebhookDaoWithPersisterTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/webhook/WebhookDaoWithPersisterTest.java @@ -37,7 +37,6 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; @@ -180,7 +179,7 @@ public class WebhookDaoWithPersisterTest { underTest.deleteByProject(dbSession, projectDto); - verify(auditPersister).addComponent(any(), any(), any()); + verify(auditPersister).addComponent(any(), any()); verifyNoMoreInteractions(auditPersister); } diff --git a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/DbTester.java b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/DbTester.java index 5c2a73191e3..e4b05ec5585 100644 --- a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/DbTester.java +++ b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/DbTester.java @@ -36,6 +36,7 @@ import org.sonar.db.alm.integration.pat.AlmPatsDbTester; import org.sonar.db.almsettings.AlmSettingsDbTester; import org.sonar.db.audit.AuditDbTester; import org.sonar.db.audit.AuditPersister; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.component.ComponentDbTester; import org.sonar.db.component.ProjectLinkDbTester; import org.sonar.db.event.EventDbTester; @@ -65,6 +66,7 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { private final UuidFactory uuidFactory = new SequenceUuidFactory(); private final System2 system2; + private final AuditPersister auditPersister; private DbClient client; private DbSession session = null; private final UserDbTester userTester; @@ -94,8 +96,9 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { private DbTester(System2 system2, @Nullable String schemaPath, AuditPersister auditPersister, MyBatisConfExtension... confExtensions) { super(TestDbImpl.create(schemaPath, confExtensions)); this.system2 = system2; + this.auditPersister = auditPersister; - initDbClient(auditPersister); + initDbClient(); this.userTester = new UserDbTester(this); this.componentTester = new ComponentDbTester(this); this.componentLinkTester = new ProjectLinkDbTester(this); @@ -122,7 +125,7 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { } public static DbTester create() { - return new DbTester(System2.INSTANCE, null, null); + return new DbTester(System2.INSTANCE, null, new NoOpAuditPersister()); } public static DbTester create(AuditPersister auditPersister) { @@ -134,18 +137,16 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { } public static DbTester create(System2 system2) { - return new DbTester(system2, null, null); + return new DbTester(system2, null, new NoOpAuditPersister()); } public static DbTester createWithExtensionMappers(System2 system2, Class<?> firstMapperClass, Class<?>... otherMapperClasses) { - return new DbTester(system2, null, null, new DbTesterMyBatisConfExtension(firstMapperClass, otherMapperClasses)); + return new DbTester(system2, null, new NoOpAuditPersister(), new DbTesterMyBatisConfExtension(firstMapperClass, otherMapperClasses)); } - private void initDbClient(AuditPersister auditPersister) { + private void initDbClient() { TransientPicoContainer ioc = new TransientPicoContainer(); - if (auditPersister != null) { - ioc.addComponent(auditPersister); - } + ioc.addComponent(auditPersister); ioc.addComponent(db.getMyBatis()); ioc.addComponent(system2); ioc.addComponent(uuidFactory); @@ -160,7 +161,7 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { protected void before() { db.start(); db.truncateTables(); - initDbClient(null); + initDbClient(); } public UserDbTester users() { diff --git a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/component/ComponentTesting.java b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/component/ComponentTesting.java index 33e3b98d273..cc555763c2a 100644 --- a/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/component/ComponentTesting.java +++ b/server/sonar-db-dao/src/testFixtures/java/org/sonar/db/component/ComponentTesting.java @@ -194,6 +194,7 @@ public class ComponentTesting { return new ComponentDto() .setUuid(uuid) .setUuidPath(formatUuidPathFromParent(parent)) + .setDbKey(uuid) .setProjectUuid(moduleOrProject.projectUuid()) .setRootUuid(moduleOrProject.uuid()) .setModuleUuid(moduleOrProject.uuid()) diff --git a/server/sonar-webserver-auth/src/main/java/org/sonar/server/authentication/UserLastConnectionDatesUpdaterImpl.java b/server/sonar-webserver-auth/src/main/java/org/sonar/server/authentication/UserLastConnectionDatesUpdaterImpl.java index 20b0e23ead8..77373951147 100644 --- a/server/sonar-webserver-auth/src/main/java/org/sonar/server/authentication/UserLastConnectionDatesUpdaterImpl.java +++ b/server/sonar-webserver-auth/src/main/java/org/sonar/server/authentication/UserLastConnectionDatesUpdaterImpl.java @@ -59,7 +59,7 @@ public class UserLastConnectionDatesUpdaterImpl implements UserLastConnectionDat return; } try (DbSession dbSession = dbClient.openSession(false)) { - dbClient.userTokenDao().update(dbSession, userToken.setLastConnectionDate(now), false, null); + dbClient.userTokenDao().updateWithoutAudit(dbSession, userToken.setLastConnectionDate(now)); userToken.setLastConnectionDate(now); dbSession.commit(); } diff --git a/server/sonar-webserver-auth/src/test/java/org/sonar/server/authentication/UserLastConnectionDatesUpdaterImplTest.java b/server/sonar-webserver-auth/src/test/java/org/sonar/server/authentication/UserLastConnectionDatesUpdaterImplTest.java index e6bb550e9ae..8d5f0f4edab 100644 --- a/server/sonar-webserver-auth/src/test/java/org/sonar/server/authentication/UserLastConnectionDatesUpdaterImplTest.java +++ b/server/sonar-webserver-auth/src/test/java/org/sonar/server/authentication/UserLastConnectionDatesUpdaterImplTest.java @@ -21,8 +21,8 @@ package org.sonar.server.authentication; import org.junit.Rule; import org.junit.Test; -import org.sonar.api.utils.System2; import org.sonar.api.impl.utils.TestSystem2; +import org.sonar.api.utils.System2; import org.sonar.db.DbTester; import org.sonar.db.user.UserDto; import org.sonar.db.user.UserTokenDto; @@ -79,7 +79,7 @@ public class UserLastConnectionDatesUpdaterImplTest { public void update_last_connection_date_from_user_token_when_last_connection_was_more_than_one_hour() { UserDto user = db.users().insertUser(); UserTokenDto userToken = db.users().insertToken(user); - db.getDbClient().userTokenDao().update(db.getSession(), userToken.setLastConnectionDate(NOW - TWO_HOUR), false, null); + db.getDbClient().userTokenDao().updateWithoutAudit(db.getSession(), userToken.setLastConnectionDate(NOW - TWO_HOUR)); db.commit(); underTest.updateLastConnectionDateIfNeeded(userToken); @@ -103,7 +103,7 @@ public class UserLastConnectionDatesUpdaterImplTest { public void do_not_update_when_last_connection_from_user_token_was_less_than_one_hour() { UserDto user = db.users().insertUser(); UserTokenDto userToken = db.users().insertToken(user); - db.getDbClient().userTokenDao().update(db.getSession(), userToken.setLastConnectionDate(NOW - ONE_MINUTE), false, null); + db.getDbClient().userTokenDao().updateWithoutAudit(db.getSession(), userToken.setLastConnectionDate(NOW - ONE_MINUTE)); db.commit(); underTest.updateLastConnectionDateIfNeeded(userToken); diff --git a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/project/ws/UpdateVisibilityAction.java b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/project/ws/UpdateVisibilityAction.java index 12dad7b7e1a..7011f0ad668 100644 --- a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/project/ws/UpdateVisibilityAction.java +++ b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/project/ws/UpdateVisibilityAction.java @@ -26,8 +26,6 @@ import org.sonar.api.resources.Qualifiers; import org.sonar.api.server.ws.Request; import org.sonar.api.server.ws.Response; import org.sonar.api.server.ws.WebService; -import org.sonar.api.utils.log.Logger; -import org.sonar.api.utils.log.Loggers; import org.sonar.core.util.UuidFactory; import org.sonar.core.util.Uuids; import org.sonar.db.DbClient; @@ -135,8 +133,7 @@ public class UpdateVisibilityAction implements ProjectsWsAction { private void setPrivateForRootComponentUuid(DbSession dbSession, ComponentDto component, boolean isPrivate) { String uuid = component.uuid(); - dbClient.componentDao().setPrivateForRootComponentUuid(dbSession, uuid, isPrivate, component.getKey(), - component.qualifier(), component.name(), true); + dbClient.componentDao().setPrivateForRootComponentUuid(dbSession, uuid, isPrivate, component.getKey(), component.qualifier(), component.name()); if (component.qualifier().equals(Qualifiers.PROJECT) || component.qualifier().equals(Qualifiers.APP)) { dbClient.projectDao().updateVisibility(dbSession, uuid, isPrivate); @@ -165,7 +162,6 @@ public class UpdateVisibilityAction implements ProjectsWsAction { }); } - private void insertProjectPermissionOnUser(DbSession dbSession, ComponentDto component, String permission, UserId userId) { dbClient.userPermissionDao().insert(dbSession, new UserPermissionDto(Uuids.create(), permission, userId.getUuid(), component.uuid()), component, userId, null); diff --git a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/setting/ws/GenerateSecretKeyAction.java b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/setting/ws/GenerateSecretKeyAction.java index 9bd81ab4219..2b56d343548 100644 --- a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/setting/ws/GenerateSecretKeyAction.java +++ b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/setting/ws/GenerateSecretKeyAction.java @@ -35,13 +35,7 @@ public class GenerateSecretKeyAction implements SettingsWsAction { private final DbClient dbClient; private final Settings settings; private final UserSession userSession; - private AuditPersister auditPersister; - - public GenerateSecretKeyAction(DbClient dbClient, Settings settings, UserSession userSession) { - this.dbClient = dbClient; - this.settings = settings; - this.userSession = userSession; - } + private final AuditPersister auditPersister; public GenerateSecretKeyAction(DbClient dbClient, Settings settings, UserSession userSession, AuditPersister auditPersister) { this.dbClient = dbClient; @@ -67,11 +61,9 @@ public class GenerateSecretKeyAction implements SettingsWsAction { writeProtobuf(GenerateSecretKeyWsResponse.newBuilder().setSecretKey(settings.getEncryption().generateRandomSecretKey()).build(), request, response); - if (auditPersister != null) { - try (DbSession dbSession = dbClient.openSession(false)) { - auditPersister.generateSecretKey(dbSession); - dbSession.commit(); - } + try (DbSession dbSession = dbClient.openSession(false)) { + auditPersister.generateSecretKey(dbSession); + dbSession.commit(); } } } diff --git a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/setting/ws/GenerateSecretKeyActionTest.java b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/setting/ws/GenerateSecretKeyActionTest.java index 4f41d85c399..fdcd9597c1a 100644 --- a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/setting/ws/GenerateSecretKeyActionTest.java +++ b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/setting/ws/GenerateSecretKeyActionTest.java @@ -33,6 +33,7 @@ import org.sonar.api.server.ws.WebService; import org.sonar.api.utils.System2; import org.sonar.db.DbClient; import org.sonar.db.DbTester; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.server.exceptions.ForbiddenException; import org.sonar.server.tester.UserSessionRule; import org.sonar.server.ws.WsActionTester; @@ -53,7 +54,7 @@ public class GenerateSecretKeyActionTest { private DbClient dbClient = db.getDbClient(); private MapSettings settings = new MapSettings(); private Encryption encryption = settings.getEncryption(); - private GenerateSecretKeyAction underTest = new GenerateSecretKeyAction(dbClient, settings, userSession); + private GenerateSecretKeyAction underTest = new GenerateSecretKeyAction(dbClient, settings, userSession, new NoOpAuditPersister()); private WsActionTester ws = new WsActionTester(underTest); @Test diff --git a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/source/ws/LinesActionTest.java b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/source/ws/LinesActionTest.java index 09dc785b3f2..2cbec0cee39 100644 --- a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/source/ws/LinesActionTest.java +++ b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/source/ws/LinesActionTest.java @@ -28,6 +28,7 @@ import org.sonar.api.utils.System2; import org.sonar.api.web.UserRole; import org.sonar.core.util.Uuids; import org.sonar.db.DbTester; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.component.ComponentDao; import org.sonar.db.component.ComponentDto; import org.sonar.db.component.SnapshotDao; @@ -62,7 +63,7 @@ public class LinesActionTest { @Rule public UserSessionRule userSession = UserSessionRule.standalone(); - private final ComponentDao componentDao = new ComponentDao(); + private final ComponentDao componentDao = new ComponentDao(new NoOpAuditPersister()); private final SnapshotDao snapshotDao = new SnapshotDao(); private final HtmlSourceDecorator htmlSourceDecorator = mock(HtmlSourceDecorator.class); private final SourceService sourceService = new SourceService(db.getDbClient(), htmlSourceDecorator); diff --git a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/usertoken/ws/SearchActionTest.java b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/usertoken/ws/SearchActionTest.java index 861523e4e21..98da7f5ea21 100644 --- a/server/sonar-webserver-webapi/src/test/java/org/sonar/server/usertoken/ws/SearchActionTest.java +++ b/server/sonar-webserver-webapi/src/test/java/org/sonar/server/usertoken/ws/SearchActionTest.java @@ -100,7 +100,7 @@ public class SearchActionTest { UserDto user = db.users().insertUser(); UserTokenDto token1 = db.users().insertToken(user); UserTokenDto token2 = db.users().insertToken(user); - db.getDbClient().userTokenDao().update(db.getSession(), token1.setLastConnectionDate(10_000_000_000L), false, user.getLogin()); + db.getDbClient().userTokenDao().updateWithoutAudit(db.getSession(), token1.setLastConnectionDate(10_000_000_000L)); db.commit(); logInAsSystemAdministrator(); diff --git a/server/sonar-webserver/src/main/java/org/sonar/server/platform/platformlevel/PlatformLevel1.java b/server/sonar-webserver/src/main/java/org/sonar/server/platform/platformlevel/PlatformLevel1.java index d16a642d366..4bd1c1d4c69 100644 --- a/server/sonar-webserver/src/main/java/org/sonar/server/platform/platformlevel/PlatformLevel1.java +++ b/server/sonar-webserver/src/main/java/org/sonar/server/platform/platformlevel/PlatformLevel1.java @@ -29,6 +29,8 @@ import org.sonar.api.internal.MetadataLoader; import org.sonar.api.internal.SonarRuntimeImpl; import org.sonar.api.utils.System2; import org.sonar.api.utils.Version; +import org.sonar.db.audit.AuditPersister; +import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.server.issue.index.IssueIndexSyncProgressChecker; import org.sonar.server.platform.DockerSupportImpl; import org.sonar.server.util.GlobalLockManagerImpl; @@ -162,6 +164,9 @@ public class PlatformLevel1 extends PlatformLevel { .load(); get(WebCoreExtensionsInstaller.class) .install(getContainer(), hasPlatformLevel(1), noAdditionalSideFilter()); + if (getOptional(AuditPersister.class).isEmpty()) { + add(NoOpAuditPersister.class); + } return super.start(); } |