| // Copyright (C) 2020 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package com.google.gerrit.plugins.codeowners.backend.config; |
| |
| import static com.google.common.collect.ImmutableSet.toImmutableSet; |
| import static com.google.gerrit.plugins.codeowners.backend.config.CodeOwnersPluginConfiguration.SECTION_CODE_OWNERS; |
| import static java.util.Objects.requireNonNull; |
| |
| import com.google.common.base.Strings; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Streams; |
| import com.google.common.flogger.FluentLogger; |
| import com.google.gerrit.entities.BranchNameKey; |
| import com.google.gerrit.entities.Project; |
| import com.google.gerrit.extensions.annotations.PluginName; |
| import com.google.gerrit.plugins.codeowners.backend.CodeOwnerReference; |
| import com.google.gerrit.plugins.codeowners.backend.EnableImplicitApprovals; |
| import com.google.gerrit.plugins.codeowners.backend.FallbackCodeOwners; |
| import com.google.gerrit.plugins.codeowners.common.CodeOwnerConfigValidationPolicy; |
| import com.google.gerrit.plugins.codeowners.common.MergeCommitStrategy; |
| import com.google.gerrit.server.config.PluginConfig; |
| import com.google.gerrit.server.config.PluginConfigFactory; |
| import com.google.gerrit.server.git.validators.CommitValidationMessage; |
| import com.google.gerrit.server.git.validators.ValidationMessage; |
| import com.google.gerrit.server.project.RefPatternMatcher; |
| import com.google.inject.Inject; |
| import com.google.inject.Singleton; |
| import java.util.Arrays; |
| import java.util.Objects; |
| import java.util.Optional; |
| import java.util.regex.PatternSyntaxException; |
| import java.util.stream.Stream; |
| import org.eclipse.jgit.lib.Config; |
| |
| /** |
| * Class to read the general code owners configuration from {@code gerrit.config} and from {@code |
| * code-owners.config} in {@code refs/meta/config}. |
| * |
| * <p>Default values are configured in {@code gerrit.config}. |
| * |
| * <p>The default values can be overridden on project-level in {@code code-owners.config} in {@code |
| * refs/meta/config}. |
| * |
| * <p>Projects that have no configuration inherit the configuration from their parent projects. |
| */ |
| @Singleton |
| public class GeneralConfig { |
| private static final FluentLogger logger = FluentLogger.forEnclosingClass(); |
| |
| public static final String SECTION_VALIDATION = "validation"; |
| |
| public static final String KEY_FILE_EXTENSION = "fileExtension"; |
| public static final String KEY_ENABLE_ASYNC_MESSAGE_ON_ADD_REVIEWER = |
| "enableAsyncMessageOnAddReviewer"; |
| public static final String KEY_ENABLE_CODE_OWNER_CONFIG_FILES_WITH_FILE_EXTENSIONS = |
| "enableCodeOwnerConfigFilesWithFileExtensions"; |
| public static final String KEY_READ_ONLY = "readOnly"; |
| public static final String KEY_EXEMPT_PURE_REVERTS = "exemptPureReverts"; |
| public static final String KEY_FALLBACK_CODE_OWNERS = "fallbackCodeOwners"; |
| public static final String KEY_ENABLE_VALIDATION_ON_BRANCH_CREATION = |
| "enableValidationOnBranchCreation"; |
| public static final String KEY_ENABLE_VALIDATION_ON_COMMIT_RECEIVED = |
| "enableValidationOnCommitReceived"; |
| public static final String KEY_ENABLE_VALIDATION_ON_SUBMIT = "enableValidationOnSubmit"; |
| public static final String KEY_MAX_PATHS_IN_CHANGE_MESSAGES = "maxPathsInChangeMessages"; |
| public static final String KEY_MERGE_COMMIT_STRATEGY = "mergeCommitStrategy"; |
| public static final String KEY_GLOBAL_CODE_OWNER = "globalCodeOwner"; |
| public static final String KEY_EXEMPTED_USER = "exemptedUser"; |
| public static final String KEY_ENABLE_IMPLICIT_APPROVALS = "enableImplicitApprovals"; |
| public static final String KEY_OVERRIDE_INFO_URL = "overrideInfoUrl"; |
| public static final String KEY_INVALID_CODE_OWNER_CONFIG_INFO_URL = |
| "invalidCodeOwnerConfigInfoUrl"; |
| public static final String KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS = |
| "rejectNonResolvableCodeOwners"; |
| public static final String KEY_REJECT_NON_RESOLVABLE_IMPORTS = "rejectNonResolvableImports"; |
| |
| public static final int DEFAULT_MAX_PATHS_IN_CHANGE_MESSAGES = 50; |
| |
| private static final String KEY_ALLOWED_EMAIL_DOMAIN = "allowedEmailDomain"; |
| |
| private final String pluginName; |
| private final PluginConfig pluginConfigFromGerritConfig; |
| |
| @Inject |
| GeneralConfig(@PluginName String pluginName, PluginConfigFactory pluginConfigFactory) { |
| this.pluginName = pluginName; |
| this.pluginConfigFromGerritConfig = pluginConfigFactory.getFromGerritConfig(pluginName); |
| } |
| |
| /** |
| * Validates the backend configuration in the given project level configuration. |
| * |
| * @param fileName the name of the config file |
| * @param projectLevelConfig the project level plugin configuration |
| * @return list of validation messages for validation errors, empty list if there are no |
| * validation errors |
| */ |
| ImmutableList<CommitValidationMessage> validateProjectLevelConfig( |
| String fileName, Config projectLevelConfig) { |
| requireNonNull(fileName, "fileName"); |
| requireNonNull(projectLevelConfig, "projectLevelConfig"); |
| |
| ImmutableList.Builder<CommitValidationMessage> validationMessages = ImmutableList.builder(); |
| |
| try { |
| projectLevelConfig.getEnum( |
| SECTION_CODE_OWNERS, |
| /* subsection= */ null, |
| KEY_MERGE_COMMIT_STRATEGY, |
| MergeCommitStrategy.ALL_CHANGED_FILES); |
| } catch (IllegalArgumentException e) { |
| validationMessages.add( |
| new CommitValidationMessage( |
| String.format( |
| "Merge commit strategy '%s' that is configured in %s (parameter %s.%s) is invalid.", |
| projectLevelConfig.getString( |
| SECTION_CODE_OWNERS, /* subsection= */ null, KEY_MERGE_COMMIT_STRATEGY), |
| fileName, |
| SECTION_CODE_OWNERS, |
| KEY_MERGE_COMMIT_STRATEGY), |
| ValidationMessage.Type.ERROR)); |
| } |
| |
| try { |
| projectLevelConfig.getEnum( |
| SECTION_CODE_OWNERS, |
| /* subsection= */ null, |
| KEY_FALLBACK_CODE_OWNERS, |
| FallbackCodeOwners.NONE); |
| } catch (IllegalArgumentException e) { |
| validationMessages.add( |
| new CommitValidationMessage( |
| String.format( |
| "The value for fallback code owners '%s' that is configured in %s (parameter %s.%s) is invalid.", |
| projectLevelConfig.getString( |
| SECTION_CODE_OWNERS, /* subsection= */ null, KEY_FALLBACK_CODE_OWNERS), |
| fileName, |
| SECTION_CODE_OWNERS, |
| KEY_FALLBACK_CODE_OWNERS), |
| ValidationMessage.Type.ERROR)); |
| } |
| |
| try { |
| projectLevelConfig.getInt( |
| SECTION_CODE_OWNERS, |
| /* subsection= */ null, |
| KEY_MAX_PATHS_IN_CHANGE_MESSAGES, |
| DEFAULT_MAX_PATHS_IN_CHANGE_MESSAGES); |
| } catch (IllegalArgumentException e) { |
| validationMessages.add( |
| new CommitValidationMessage( |
| String.format( |
| "The value for max paths in change messages '%s' that is configured in %s" |
| + " (parameter %s.%s) is invalid.", |
| projectLevelConfig.getString( |
| SECTION_CODE_OWNERS, |
| /* subsection= */ null, |
| KEY_MAX_PATHS_IN_CHANGE_MESSAGES), |
| fileName, |
| SECTION_CODE_OWNERS, |
| KEY_MAX_PATHS_IN_CHANGE_MESSAGES), |
| ValidationMessage.Type.ERROR)); |
| } |
| |
| return validationMessages.build(); |
| } |
| |
| /** |
| * Gets the file extension that should be used for code owner config files in the given project. |
| * |
| * @param pluginConfig the plugin config from which the file extension should be read. |
| * @return the file extension that should be used for code owner config files in the given |
| * project, {@link Optional#empty()} if no file extension should be used |
| */ |
| Optional<String> getFileExtension(Config pluginConfig) { |
| return getStringValue(pluginConfig, KEY_FILE_EXTENSION); |
| } |
| |
| /** |
| * Whether file extensions for code owner config files are enabled. |
| * |
| * <p>If enabled, code owner config files with file extensions are treated as regular code owner |
| * config files. This means they are validated on push/submit (if validation is enabled) and can |
| * be imported by other code owner config files (regardless of whether they have the same file |
| * extension or not). |
| * |
| * @param project the project for which the configuration should be read |
| * @param pluginConfig the plugin config from which the configuration should be read. |
| * @return whether file extensions for code owner config files are enabled |
| */ |
| boolean enableCodeOwnerConfigFilesWithFileExtensions( |
| Project.NameKey project, Config pluginConfig) { |
| return getBooleanConfig( |
| project, |
| pluginConfig, |
| KEY_ENABLE_CODE_OWNER_CONFIG_FILES_WITH_FILE_EXTENSIONS, |
| /* defaultValue= */ false); |
| } |
| |
| /** |
| * Returns the email domains that are allowed to be used for code owners. |
| * |
| * @return the email domains that are allowed to be used for code owners, an empty set if all |
| * email domains are allowed (if {@code plugin.code-owners.allowedEmailDomain} is not set or |
| * set to an empty value) |
| */ |
| ImmutableSet<String> getAllowedEmailDomains() { |
| return Arrays.stream(pluginConfigFromGerritConfig.getStringList(KEY_ALLOWED_EMAIL_DOMAIN)) |
| .filter(emailDomain -> !Strings.isNullOrEmpty(emailDomain)) |
| .distinct() |
| .collect(toImmutableSet()); |
| } |
| |
| /** |
| * Gets the read-only configuration from the given plugin config with fallback to {@code |
| * gerrit.config}. |
| * |
| * <p>The read-only configuration controls whether code owner config files are read-only and all |
| * modifications of code owner config files should be rejected. |
| * |
| * @param project the project for which the read-only configuration should be read |
| * @param pluginConfig the plugin config from which the read-only configuration should be read. |
| * @return whether code owner config files are read-only |
| */ |
| boolean getReadOnly(Project.NameKey project, Config pluginConfig) { |
| return getBooleanConfig(project, pluginConfig, KEY_READ_ONLY, /* defaultValue= */ false); |
| } |
| |
| /** |
| * Gets the exempt-pure-reverts configuration from the given plugin config with fallback to {@code |
| * gerrit.config}. |
| * |
| * <p>The exempt-pure-reverts configuration controls whether pure revert changes are exempted from |
| * needing code owner approvals for submit. |
| * |
| * @param project the project for which the exempt-pure-revert configuration should be read |
| * @param pluginConfig the plugin config from which the read-only configuration should be read. |
| * @return whether pure reverts are exempted from needing code owner approvals for submit |
| */ |
| boolean getExemptPureReverts(Project.NameKey project, Config pluginConfig) { |
| return getBooleanConfig( |
| project, pluginConfig, KEY_EXEMPT_PURE_REVERTS, /* defaultValue= */ false); |
| } |
| |
| /** |
| * Gets the reject-non-resolvable-code-owners configuration from the given plugin config for the |
| * specified project with fallback to {@code gerrit.config}. |
| * |
| * <p>The reject-non-resolvable-code-owners configuration controls whether code owner config files |
| * with newly added non-resolvable code owners should be rejected on commit received and on |
| * submit. |
| * |
| * @param project the project for which the reject-non-resolvable-code-owners configuration should |
| * be read |
| * @param pluginConfig the plugin config from which the reject-non-resolvable-code-owners |
| * configuration should be read. |
| * @return whether code owner config files with newly added non-resolvable code owners should be |
| * rejected on commit received and on submit |
| */ |
| boolean getRejectNonResolvableCodeOwners(Project.NameKey project, Config pluginConfig) { |
| return getBooleanConfig( |
| project, pluginConfig, KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS, /* defaultValue= */ true); |
| } |
| |
| /** |
| * Gets the reject-non-resolvable-code-owners configuration from the given plugin config for the |
| * specified branch with fallback to {@code gerrit.config}. |
| * |
| * <p>If multiple branch-specific configurations match the specified branch, it is undefined which |
| * of the matching branch configurations takes precedence. |
| * |
| * <p>The reject-non-resolvable-code-owners configuration controls whether code owner config files |
| * with newly added non-resolvable code owners should be rejected on commit received and on |
| * submit. |
| * |
| * @param branchNameKey the branch and project for which the reject-non-resolvable-code-owners |
| * configuration should be read |
| * @param pluginConfig the plugin config from which the reject-non-resolvable-code-owners |
| * configuration should be read. |
| * @return whether code owner config files with newly added non-resolvable code owners should be |
| * rejected on commit received and on submit |
| */ |
| Optional<Boolean> getRejectNonResolvableCodeOwnersForBranch( |
| BranchNameKey branchNameKey, Config pluginConfig) { |
| return getCodeOwnerConfigValidationFlagForBranch( |
| KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS, branchNameKey, pluginConfig); |
| } |
| |
| /** |
| * Gets the reject-non-resolvable-imports configuration from the given plugin config for the |
| * specified project with fallback to {@code gerrit.config}. |
| * |
| * <p>The reject-non-resolvable-imports configuration controls whether code owner config files |
| * with newly added non-resolvable imports should be rejected on commit received and on submit. |
| * |
| * @param project the project for which the reject-non-resolvable-imports configuration should be |
| * read |
| * @param pluginConfig the plugin config from which the reject-non-resolvable-imports |
| * configuration should be read. |
| * @return whether code owner config files with newly added non-resolvable imports should be |
| * rejected on commit received and on submit |
| */ |
| boolean getRejectNonResolvableImports(Project.NameKey project, Config pluginConfig) { |
| return getBooleanConfig( |
| project, pluginConfig, KEY_REJECT_NON_RESOLVABLE_IMPORTS, /* defaultValue= */ true); |
| } |
| |
| /** |
| * Gets the reject-non-resolvable-imports configuration from the given plugin config for the |
| * specified branch with fallback to {@code gerrit.config}. |
| * |
| * <p>The reject-non-resolvable-imports configuration controls whether code owner config files |
| * with newly added non-resolvable imports should be rejected on commit received and on submit. |
| * |
| * @param branchNameKey the branch and project for which the reject-non-resolvable-imports |
| * configuration should be read |
| * @param pluginConfig the plugin config from which the reject-non-resolvable-imports |
| * configuration should be read. |
| * @return whether code owner config files with newly added non-resolvable imports should be |
| * rejected on commit received and on submit |
| */ |
| Optional<Boolean> getRejectNonResolvableImportsForBranch( |
| BranchNameKey branchNameKey, Config pluginConfig) { |
| return getCodeOwnerConfigValidationFlagForBranch( |
| KEY_REJECT_NON_RESOLVABLE_IMPORTS, branchNameKey, pluginConfig); |
| } |
| |
| private boolean getBooleanConfig( |
| Project.NameKey project, Config pluginConfig, String key, boolean defaultValue) { |
| requireNonNull(project, "project"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| requireNonNull(key, "key"); |
| |
| String value = pluginConfig.getString(SECTION_CODE_OWNERS, /* subsection= */ null, key); |
| if (value != null) { |
| try { |
| return pluginConfig.getBoolean( |
| SECTION_CODE_OWNERS, /* subsection= */ null, key, defaultValue); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for %s in '%s.config' of project %s." |
| + " Falling back to global config.", |
| value, key, pluginName, project.get()); |
| } |
| } |
| |
| try { |
| return pluginConfigFromGerritConfig.getBoolean(key, defaultValue); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for %s in gerrit.config (parameter" |
| + " plugin.%s.%s). Falling back to default value %s.", |
| pluginConfigFromGerritConfig.getString(key), key, pluginName, key, defaultValue); |
| return defaultValue; |
| } |
| } |
| |
| /** |
| * Gets the fallback code owners that own paths that have no defined code owners. |
| * |
| * @param project the project for which the fallback code owners should be read |
| * @param pluginConfig the plugin config from which the fallback code owners should be read |
| * @return the fallback code owners that own paths that have no defined code owners |
| */ |
| FallbackCodeOwners getFallbackCodeOwners(Project.NameKey project, Config pluginConfig) { |
| requireNonNull(project, "project"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| String fallbackCodeOwnersString = |
| pluginConfig.getString( |
| SECTION_CODE_OWNERS, /* subsection= */ null, KEY_FALLBACK_CODE_OWNERS); |
| if (fallbackCodeOwnersString != null) { |
| try { |
| return pluginConfig.getEnum( |
| SECTION_CODE_OWNERS, |
| /* subsection= */ null, |
| KEY_FALLBACK_CODE_OWNERS, |
| FallbackCodeOwners.NONE); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for fallback code owners in '%s.config' of project %s." |
| + " Falling back to global config.", |
| fallbackCodeOwnersString, pluginName, project.get()); |
| } |
| } |
| |
| try { |
| return pluginConfigFromGerritConfig.getEnum( |
| KEY_FALLBACK_CODE_OWNERS, FallbackCodeOwners.NONE); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for fallback code owners in gerrit.config (parameter" |
| + " plugin.%s.%s). Falling back to default value %s.", |
| pluginConfigFromGerritConfig.getString(KEY_FALLBACK_CODE_OWNERS), |
| pluginName, |
| KEY_FALLBACK_CODE_OWNERS, |
| FallbackCodeOwners.NONE); |
| return FallbackCodeOwners.NONE; |
| } |
| } |
| |
| /** |
| * Gets the maximum number of paths that should be incuded in change messages. |
| * |
| * @param project the project for which the maximum number of paths in change messages should be |
| * read |
| * @param pluginConfig the plugin config from which the maximum number of paths in change messages |
| * should be read |
| * @return the maximum number of paths in change messages |
| */ |
| int getMaxPathsInChangeMessages(Project.NameKey project, Config pluginConfig) { |
| requireNonNull(project, "project"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| String maxPathInChangeMessagesString = |
| pluginConfig.getString( |
| SECTION_CODE_OWNERS, /* subsection= */ null, KEY_MAX_PATHS_IN_CHANGE_MESSAGES); |
| if (maxPathInChangeMessagesString != null) { |
| try { |
| return pluginConfig.getInt( |
| SECTION_CODE_OWNERS, |
| /* subsection= */ null, |
| KEY_MAX_PATHS_IN_CHANGE_MESSAGES, |
| DEFAULT_MAX_PATHS_IN_CHANGE_MESSAGES); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for max paths in change messages in '%s.config' of" |
| + " project %s. Falling back to global config.", |
| maxPathInChangeMessagesString, pluginName, project.get()); |
| } |
| } |
| |
| try { |
| return pluginConfigFromGerritConfig.getInt( |
| KEY_MAX_PATHS_IN_CHANGE_MESSAGES, DEFAULT_MAX_PATHS_IN_CHANGE_MESSAGES); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for max paths in change messages in gerrit.config (parameter" |
| + " plugin.%s.%s). Falling back to default value %s.", |
| pluginConfigFromGerritConfig.getString(KEY_MAX_PATHS_IN_CHANGE_MESSAGES), |
| pluginName, |
| KEY_MAX_PATHS_IN_CHANGE_MESSAGES, |
| DEFAULT_MAX_PATHS_IN_CHANGE_MESSAGES); |
| return DEFAULT_MAX_PATHS_IN_CHANGE_MESSAGES; |
| } |
| } |
| |
| /** |
| * Gets whether code owner change messages that are added when a code owner is added as a reviewer |
| * should be posted asynchronously. |
| * |
| * @param project the project for which the enable async message on add reviewer configuration |
| * should be read |
| * @param pluginConfig the plugin config from which the enable async message on add reviewer |
| * configuration should be read |
| * @return whether code owner change messages that are added when a code owner is added as a |
| * reviewer should be posted asynchronously |
| */ |
| boolean enableAsyncMessageOnAddReviewer(Project.NameKey project, Config pluginConfig) { |
| return getBooleanConfig( |
| project, pluginConfig, KEY_ENABLE_ASYNC_MESSAGE_ON_ADD_REVIEWER, /* defaultValue= */ true); |
| } |
| |
| /** |
| * Gets the enable validation on branch creation configuration from the given plugin config for |
| * the specified project with fallback to {@code gerrit.config} and default to {@code true}. |
| * |
| * <p>The enable validation on branch creation controls whether code owner config files should be |
| * validated when a branch is created. |
| * |
| * @param project the project for which the enable validation on branch creation configuration |
| * should be read |
| * @param pluginConfig the plugin config from which the enable validation on branch creation |
| * configuration should be read |
| * @return whether code owner config files should be validated when a branch is created |
| */ |
| CodeOwnerConfigValidationPolicy getCodeOwnerConfigValidationPolicyForBranchCreation( |
| Project.NameKey project, Config pluginConfig) { |
| return getCodeOwnerConfigValidationPolicy( |
| KEY_ENABLE_VALIDATION_ON_BRANCH_CREATION, |
| project, |
| pluginConfig, |
| CodeOwnerConfigValidationPolicy.FALSE); |
| } |
| |
| /** |
| * Gets the enable validation on branch creation configuration from the given plugin config for |
| * the specified branch. |
| * |
| * <p>If multiple branch-specific configurations match the specified branch, it is undefined which |
| * of the matching branch configurations takes precedence. |
| * |
| * <p>The enable validation on branch creation controls whether code owner config files should be |
| * validated when a branch is created. |
| * |
| * @param branchNameKey the branch and project for which the enable validation on branch creation |
| * configuration should be read |
| * @param pluginConfig the plugin config from which the enable validation on branch creation |
| * configuration should be read |
| * @return the enable validation on branch creation configuration that is configured for the |
| * branch, {@link Optional#empty()} if no branch specific configuration exists |
| */ |
| Optional<CodeOwnerConfigValidationPolicy> |
| getCodeOwnerConfigValidationPolicyForBranchCreationForBranch( |
| BranchNameKey branchNameKey, Config pluginConfig) { |
| return getCodeOwnerConfigValidationPolicyForBranch( |
| KEY_ENABLE_VALIDATION_ON_BRANCH_CREATION, branchNameKey, pluginConfig); |
| } |
| |
| /** |
| * Gets the enable validation on commit received configuration from the given plugin config for |
| * the specified project with fallback to {@code gerrit.config} and default to {@code true}. |
| * |
| * <p>The enable validation on commit received controls whether code owner config files should be |
| * validated when a commit is received. |
| * |
| * @param project the project for which the enable validation on commit received configuration |
| * should be read |
| * @param pluginConfig the plugin config from which the enable validation on commit received |
| * configuration should be read |
| * @return whether code owner config files should be validated when a commit is received |
| */ |
| CodeOwnerConfigValidationPolicy getCodeOwnerConfigValidationPolicyForCommitReceived( |
| Project.NameKey project, Config pluginConfig) { |
| return getCodeOwnerConfigValidationPolicy( |
| KEY_ENABLE_VALIDATION_ON_COMMIT_RECEIVED, |
| project, |
| pluginConfig, |
| CodeOwnerConfigValidationPolicy.TRUE); |
| } |
| |
| /** |
| * Gets the enable validation on commit received configuration from the given plugin config for |
| * the specified branch. |
| * |
| * <p>If multiple branch-specific configurations match the specified branch, it is undefined which |
| * of the matching branch configurations takes precedence. |
| * |
| * <p>The enable validation on commit received controls whether code owner config files should be |
| * validated when a commit is received. |
| * |
| * @param branchNameKey the branch and project for which the enable validation on commit received |
| * configuration should be read |
| * @param pluginConfig the plugin config from which the enable validation on commit received |
| * configuration should be read |
| * @return the enable validation on commit received configuration that is configured for the |
| * branch, {@link Optional#empty()} if no branch specific configuration exists |
| */ |
| Optional<CodeOwnerConfigValidationPolicy> |
| getCodeOwnerConfigValidationPolicyForCommitReceivedForBranch( |
| BranchNameKey branchNameKey, Config pluginConfig) { |
| return getCodeOwnerConfigValidationPolicyForBranch( |
| KEY_ENABLE_VALIDATION_ON_COMMIT_RECEIVED, branchNameKey, pluginConfig); |
| } |
| |
| /** |
| * Gets the enable validation on submit configuration from the given plugin config for the |
| * specified project with fallback to {@code gerrit.config} and default to {@code true}. |
| * |
| * <p>The enable validation on submit controls whether code owner config files should be validated |
| * when a change is submitted. |
| * |
| * @param project the project for which the enable validation on submit configuration should be |
| * read |
| * @param pluginConfig the plugin config from which the enable validation on submit configuration |
| * should be read |
| * @return whether code owner config files should be validated when a change is submitted |
| */ |
| CodeOwnerConfigValidationPolicy getCodeOwnerConfigValidationPolicyForSubmit( |
| Project.NameKey project, Config pluginConfig) { |
| return getCodeOwnerConfigValidationPolicy( |
| KEY_ENABLE_VALIDATION_ON_SUBMIT, |
| project, |
| pluginConfig, |
| CodeOwnerConfigValidationPolicy.FALSE); |
| } |
| |
| /** |
| * Gets the enable validation on submit configuration from the given plugin config for the |
| * specified branch. |
| * |
| * <p>If multiple branch-specific configurations match the specified branch, it is undefined which |
| * of the matching branch configurations takes precedence. |
| * |
| * <p>The enable validation on submit controls whether code owner config files should be validated |
| * when a change is submitted. |
| * |
| * @param branchNameKey the branch and project for which the enable validation on submit |
| * configuration should be read |
| * @param pluginConfig the plugin config from which the enable validation on submit configuration |
| * should be read |
| * @return the enable validation on submit configuration that is configured for the branch, {@link |
| * Optional#empty()} if no branch specific configuration exists |
| */ |
| Optional<CodeOwnerConfigValidationPolicy> getCodeOwnerConfigValidationPolicyForSubmitForBranch( |
| BranchNameKey branchNameKey, Config pluginConfig) { |
| return getCodeOwnerConfigValidationPolicyForBranch( |
| KEY_ENABLE_VALIDATION_ON_SUBMIT, branchNameKey, pluginConfig); |
| } |
| |
| private Optional<CodeOwnerConfigValidationPolicy> getCodeOwnerConfigValidationPolicyForBranch( |
| String key, BranchNameKey branchNameKey, Config pluginConfig) { |
| requireNonNull(key, "key"); |
| requireNonNull(branchNameKey, "branchNameKey"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| Optional<String> validationSectionForBranch = |
| getValidationSectionForBranch(branchNameKey, pluginConfig); |
| if (!validationSectionForBranch.isPresent()) { |
| return Optional.empty(); |
| } |
| |
| return getCodeOwnerConfigValidationPolicyForBranch( |
| validationSectionForBranch.get(), key, branchNameKey.project(), pluginConfig); |
| } |
| |
| private Optional<Boolean> getCodeOwnerConfigValidationFlagForBranch( |
| String key, BranchNameKey branchNameKey, Config pluginConfig) { |
| requireNonNull(key, "key"); |
| requireNonNull(branchNameKey, "branchNameKey"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| Optional<String> validationSectionForBranch = |
| getValidationSectionForBranch(branchNameKey, pluginConfig); |
| if (!validationSectionForBranch.isPresent()) { |
| return Optional.empty(); |
| } |
| |
| return getCodeOwnerConfigValidationFlagForBranch( |
| validationSectionForBranch.get(), key, branchNameKey.project(), pluginConfig); |
| } |
| |
| private CodeOwnerConfigValidationPolicy getCodeOwnerConfigValidationPolicy( |
| String key, |
| Project.NameKey project, |
| Config pluginConfig, |
| CodeOwnerConfigValidationPolicy defaultValue) { |
| requireNonNull(key, "key"); |
| requireNonNull(project, "project"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| String codeOwnerConfigValidationPolicyString = |
| pluginConfig.getString(SECTION_CODE_OWNERS, /* subsection= */ null, key); |
| if (codeOwnerConfigValidationPolicyString != null) { |
| try { |
| return pluginConfig.getEnum(SECTION_CODE_OWNERS, /* subsection= */ null, key, defaultValue); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for the code owner config validation policy in '%s.config'" |
| + " of project %s (parameter %s.%s). Falling back to global config.", |
| codeOwnerConfigValidationPolicyString, |
| pluginName, |
| project.get(), |
| SECTION_CODE_OWNERS, |
| key); |
| } |
| } |
| |
| try { |
| return pluginConfigFromGerritConfig.getEnum(key, defaultValue); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for the code owner config validation policy in gerrit.config" |
| + " (parameter plugin.%s.%s). Falling back to default value %s.", |
| pluginConfigFromGerritConfig.getString(key), pluginName, key, defaultValue); |
| return defaultValue; |
| } |
| } |
| |
| private Optional<String> getValidationSectionForBranch( |
| BranchNameKey branchNameKey, Config pluginConfig) { |
| ImmutableSet<String> matchingValidationSubsections = |
| pluginConfig.getSubsections(SECTION_VALIDATION).stream() |
| .filter( |
| refPattern -> { |
| try { |
| return RefPatternMatcher.getMatcher(refPattern) |
| .match(branchNameKey.branch(), /* user= */ null); |
| } catch (PatternSyntaxException e) { |
| logger.atWarning().withCause(e).log( |
| "invalid ref pattern %s for subsection %s.%s in %s.config of project %s", |
| refPattern, |
| SECTION_VALIDATION, |
| refPattern, |
| pluginName, |
| branchNameKey.project()); |
| return false; |
| } |
| }) |
| .collect(toImmutableSet()); |
| |
| if (matchingValidationSubsections.isEmpty()) { |
| return Optional.empty(); |
| } |
| |
| String matchingValidationSubsection = matchingValidationSubsections.asList().get(0); |
| if (matchingValidationSubsections.size() > 1) { |
| logger.atWarning().log( |
| "branch %s matches multiple %s subsections in %s.config of project %s: %s," |
| + " subsection %s takes precedence", |
| branchNameKey.branch(), |
| SECTION_VALIDATION, |
| pluginName, |
| branchNameKey.project(), |
| matchingValidationSubsections, |
| matchingValidationSubsection); |
| } |
| return Optional.of(matchingValidationSubsection); |
| } |
| |
| private Optional<CodeOwnerConfigValidationPolicy> getCodeOwnerConfigValidationPolicyForBranch( |
| String branchSubsection, String key, Project.NameKey project, Config pluginConfig) { |
| requireNonNull(branchSubsection, "branchSubsection"); |
| requireNonNull(key, "key"); |
| requireNonNull(project, "project"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| String codeOwnerConfigValidationPolicyString = |
| pluginConfig.getString(SECTION_VALIDATION, branchSubsection, key); |
| if (codeOwnerConfigValidationPolicyString != null) { |
| try { |
| return Optional.of( |
| pluginConfig.getEnum( |
| SECTION_VALIDATION, branchSubsection, key, CodeOwnerConfigValidationPolicy.TRUE)); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for the code owner config validation policy in '%s.config'" |
| + " of project %s (parameter %s.%s.%s). Falling back to project-level setting.", |
| codeOwnerConfigValidationPolicyString, |
| pluginName, |
| project.get(), |
| SECTION_VALIDATION, |
| branchSubsection, |
| key); |
| } |
| } |
| return Optional.empty(); |
| } |
| |
| private Optional<Boolean> getCodeOwnerConfigValidationFlagForBranch( |
| String branchSubsection, String key, Project.NameKey project, Config pluginConfig) { |
| requireNonNull(branchSubsection, "branchSubsection"); |
| requireNonNull(key, "key"); |
| requireNonNull(project, "project"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| String codeOwnerConfigValidationFlagString = |
| pluginConfig.getString(SECTION_VALIDATION, branchSubsection, key); |
| if (codeOwnerConfigValidationFlagString != null) { |
| try { |
| return Optional.of( |
| pluginConfig.getBoolean(SECTION_VALIDATION, branchSubsection, key, true)); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for %s.%s.%s in '%s.config' of project %s." |
| + " Falling back to project-level setting.", |
| codeOwnerConfigValidationFlagString, |
| SECTION_VALIDATION, |
| branchSubsection, |
| key, |
| pluginName, |
| project.get()); |
| } |
| } |
| return Optional.empty(); |
| } |
| |
| /** |
| * Gets the merge commit strategy from the given plugin config with fallback to {@code |
| * gerrit.config}. |
| * |
| * <p>The merge commit strategy defines for merge commits which files require code owner |
| * approvals. |
| * |
| * @param project the name of the project for which the merge commit strategy should be read |
| * @param pluginConfig the plugin config from which the merge commit strategy should be read |
| * @return the merge commit strategy that should be used |
| */ |
| MergeCommitStrategy getMergeCommitStrategy(Project.NameKey project, Config pluginConfig) { |
| requireNonNull(project, "project"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| String mergeCommitStrategyString = |
| pluginConfig.getString( |
| SECTION_CODE_OWNERS, /* subsection= */ null, KEY_MERGE_COMMIT_STRATEGY); |
| if (mergeCommitStrategyString != null) { |
| try { |
| return pluginConfig.getEnum( |
| SECTION_CODE_OWNERS, |
| /* subsection= */ null, |
| KEY_MERGE_COMMIT_STRATEGY, |
| MergeCommitStrategy.ALL_CHANGED_FILES); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for merge commit stategy in '%s.config' of project %s." |
| + " Falling back to global config or default value.", |
| mergeCommitStrategyString, pluginName, project.get()); |
| } |
| } |
| |
| try { |
| return pluginConfigFromGerritConfig.getEnum( |
| KEY_MERGE_COMMIT_STRATEGY, MergeCommitStrategy.ALL_CHANGED_FILES); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for merge commit stategy in gerrit.config (parameter plugin.%s.%s)." |
| + " Falling back to default value %s.", |
| pluginConfigFromGerritConfig.getString(KEY_MERGE_COMMIT_STRATEGY), |
| pluginName, |
| KEY_MERGE_COMMIT_STRATEGY, |
| MergeCommitStrategy.ALL_CHANGED_FILES); |
| return MergeCommitStrategy.ALL_CHANGED_FILES; |
| } |
| } |
| |
| /** |
| * Gets whether an implicit code owner approvals are enabled from the given plugin config with |
| * fallback to {@code gerrit.config}. |
| * |
| * <p>If enabled, an implict code owner approval from the change owner is assumed if the last |
| * patch set was uploaded by the change owner. |
| * |
| * @param project the name of the project for which the configuration should be read |
| * @param pluginConfig the plugin config from which the configuration should be read. |
| * @return whether an implicit code owner approval from the last uploader is assumed |
| */ |
| EnableImplicitApprovals getEnableImplicitApprovals(Project.NameKey project, Config pluginConfig) { |
| requireNonNull(project, "project"); |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| String enableImplicitApprovalsString = |
| pluginConfig.getString( |
| SECTION_CODE_OWNERS, /* subsection= */ null, KEY_ENABLE_IMPLICIT_APPROVALS); |
| if (enableImplicitApprovalsString != null) { |
| try { |
| return pluginConfig.getEnum( |
| SECTION_CODE_OWNERS, |
| /* subsection= */ null, |
| KEY_ENABLE_IMPLICIT_APPROVALS, |
| EnableImplicitApprovals.FALSE); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for enabling implicit approvals in '%s.config' of project" |
| + " %s. Falling back to global config or default value.", |
| enableImplicitApprovalsString, pluginName, project.get()); |
| } |
| } |
| |
| try { |
| return pluginConfigFromGerritConfig.getEnum( |
| KEY_ENABLE_IMPLICIT_APPROVALS, EnableImplicitApprovals.FALSE); |
| } catch (IllegalArgumentException e) { |
| logger.atWarning().withCause(e).log( |
| "Ignoring invalid value %s for enabling implict approvals in gerrit.config (parameter" |
| + " plugin.%s.%s). Falling back to default value %s.", |
| pluginConfigFromGerritConfig.getString(KEY_ENABLE_IMPLICIT_APPROVALS), |
| pluginName, |
| KEY_ENABLE_IMPLICIT_APPROVALS, |
| EnableImplicitApprovals.FALSE); |
| return EnableImplicitApprovals.FALSE; |
| } |
| } |
| |
| /** |
| * Gets the users which are configured as global code owners from the given plugin config with |
| * fallback to {@code gerrit.config}. |
| * |
| * @param pluginConfig the plugin config from which the global code owners should be read. |
| * @return the users which are configured as global code owners |
| */ |
| ImmutableSet<CodeOwnerReference> getGlobalCodeOwners(Config pluginConfig) { |
| requireNonNull(pluginConfig, "pluginConfig"); |
| return getMultiValue(pluginConfig, KEY_GLOBAL_CODE_OWNER) |
| .map(CodeOwnerReference::create) |
| .collect(toImmutableSet()); |
| } |
| |
| /** |
| * Gets the users which are exempted from requiring code owner approvals. |
| * |
| * <p>If a user is exempted from requiring code owner approvals changes that are uploaded by this |
| * user are automatically code-owner approved. |
| * |
| * @param pluginConfig the plugin config from which the exempted users should be read. |
| * @return the users which are exempted from requiring code owner approvals |
| */ |
| ImmutableSet<String> getExemptedUsers(Config pluginConfig) { |
| requireNonNull(pluginConfig, "pluginConfig"); |
| return getMultiValue(pluginConfig, KEY_EXEMPTED_USER).collect(toImmutableSet()); |
| } |
| |
| /** |
| * Gets an URL that leads to an information page about overrides. |
| * |
| * <p>The URL is retrieved from the given plugin config, with fallback to the {@code |
| * gerrit.config}. |
| * |
| * @param pluginConfig the plugin config from which the override info URL should be read. |
| * @return URL that leads to an information page about overrides, {@link Optional#empty()} if no |
| * such URL is configured |
| */ |
| Optional<String> getOverrideInfoUrl(Config pluginConfig) { |
| return getStringValue(pluginConfig, KEY_OVERRIDE_INFO_URL); |
| } |
| |
| /** |
| * Gets an URL that leads to an information page about invalid code owner config files. |
| * |
| * <p>The URL is retrieved from the given plugin config, with fallback to the {@code |
| * gerrit.config}. |
| * |
| * @param pluginConfig the plugin config from which the invalid code owner config info URL should |
| * be read. |
| * @return URL that leads to an information page about invalid code owner config files, {@link |
| * Optional#empty()} if no such URL is configured |
| */ |
| Optional<String> getInvalidCodeOwnerConfigInfoUrl(Config pluginConfig) { |
| return getStringValue(pluginConfig, KEY_INVALID_CODE_OWNER_CONFIG_INFO_URL); |
| } |
| |
| private Optional<String> getStringValue(Config pluginConfig, String key) { |
| requireNonNull(pluginConfig, "pluginConfig"); |
| |
| String value = pluginConfig.getString(SECTION_CODE_OWNERS, /* subsection= */ null, key); |
| if (value != null) { |
| return Optional.of(value); |
| } |
| |
| return Optional.ofNullable(pluginConfigFromGerritConfig.getString(key)); |
| } |
| |
| /** |
| * Gets the values for a parameter that can be set multiple times with taking inherited values |
| * from {@code gerrit.config} into account. |
| * |
| * <p>The inherited values from {@code gerrit.config} are included into the returned list at the |
| * first position. This matches the behavior in {@link Config#getStringList(String, String, |
| * String)} that includes inherited values from the base config into the result list at the first |
| * position too. |
| * |
| * <p>The returned stream contains duplicates if the exact same value is set for different |
| * projects in the line of parent projects. |
| */ |
| private Stream<String> getMultiValue(Config pluginConfig, String key) { |
| return Streams.concat( |
| Arrays.stream(pluginConfigFromGerritConfig.getStringList(key)), |
| Arrays.stream( |
| pluginConfig.getStringList(SECTION_CODE_OWNERS, /* subsection= */ null, key))) |
| .filter(Objects::nonNull) |
| .filter(value -> !value.trim().isEmpty()); |
| } |
| } |
