| // Copyright (C) 2019 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.googlesource.gerrit.plugins.copyright; |
| |
| import static java.nio.charset.StandardCharsets.UTF_8; |
| |
| import com.google.common.base.Strings; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.flogger.FluentLogger; |
| import com.google.gerrit.common.Nullable; |
| import com.google.gerrit.extensions.annotations.PluginName; |
| import com.google.gerrit.extensions.api.changes.AddReviewerResult; |
| import com.google.gerrit.extensions.api.changes.ReviewResult; |
| import com.google.gerrit.extensions.events.GitReferenceUpdatedListener; |
| import com.google.gerrit.extensions.events.LifecycleListener; |
| import com.google.gerrit.extensions.events.RevisionCreatedListener; |
| import com.google.gerrit.extensions.registration.DynamicSet; |
| import com.google.gerrit.extensions.restapi.RestApiException; |
| import com.google.gerrit.metrics.Timer0; |
| import com.google.gerrit.reviewdb.client.Project; |
| import com.google.gerrit.reviewdb.client.RefNames; |
| import com.google.gerrit.server.config.AllProjectsName; |
| import com.google.gerrit.server.config.PluginConfig; |
| import com.google.gerrit.server.config.PluginConfigFactory; |
| import com.google.gerrit.server.events.CommitReceivedEvent; |
| import com.google.gerrit.server.git.GitRepositoryManager; |
| import com.google.gerrit.server.git.validators.CommitValidationException; |
| import com.google.gerrit.server.git.validators.CommitValidationListener; |
| import com.google.gerrit.server.git.validators.CommitValidationMessage; |
| import com.google.gerrit.server.project.ProjectCache; |
| import com.google.gerrit.server.project.ProjectConfig; |
| import com.google.gerrit.server.project.ProjectState; |
| import com.google.inject.AbstractModule; |
| import com.google.inject.Singleton; |
| import java.io.IOException; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import javax.inject.Inject; |
| import org.eclipse.jgit.errors.ConfigInvalidException; |
| import org.eclipse.jgit.lib.Constants; |
| import org.eclipse.jgit.lib.ObjectId; |
| import org.eclipse.jgit.lib.ObjectLoader; |
| import org.eclipse.jgit.lib.Repository; |
| import org.eclipse.jgit.revwalk.RevTree; |
| import org.eclipse.jgit.revwalk.RevWalk; |
| import org.eclipse.jgit.treewalk.TreeWalk; |
| |
| /** Listener to manage configuration for enforcing review of copyright declarations and licenses. */ |
| @Singleton |
| class CopyrightConfig |
| implements CommitValidationListener, |
| RevisionCreatedListener, |
| GitReferenceUpdatedListener, |
| LifecycleListener { |
| private static final FluentLogger logger = FluentLogger.forEnclosingClass(); |
| |
| /** Default value of timeTestMax configuration parameter for avoiding excessive backtracking. */ |
| private final long DEFAULT_MAX_ELAPSED_SECONDS = 8; |
| |
| private final Metrics metrics; |
| private final AllProjectsName allProjectsName; |
| private final String pluginName; |
| private final GitRepositoryManager repoManager; |
| private final ProjectCache projectCache; |
| private final PluginConfigFactory pluginConfigFactory; |
| private final CopyrightReviewApi reviewApi; |
| |
| @Nullable private PluginConfig gerritConfig; |
| @Nullable private CheckConfig checkConfig; |
| |
| static AbstractModule module() { |
| return new AbstractModule() { |
| @Override |
| protected void configure() { |
| DynamicSet.bind(binder(), CommitValidationListener.class).to(CopyrightConfig.class); |
| DynamicSet.bind(binder(), LifecycleListener.class).to(CopyrightConfig.class); |
| DynamicSet.bind(binder(), RevisionCreatedListener.class).to(CopyrightConfig.class); |
| DynamicSet.bind(binder(), GitReferenceUpdatedListener.class).to(CopyrightConfig.class); |
| } |
| }; |
| } |
| |
| @Inject |
| CopyrightConfig( |
| Metrics metrics, |
| AllProjectsName allProjectsName, |
| @PluginName String pluginName, |
| GitRepositoryManager repoManager, |
| ProjectCache projectCache, |
| PluginConfigFactory pluginConfigFactory, |
| CopyrightReviewApi reviewApi) { |
| this.metrics = metrics; |
| this.allProjectsName = allProjectsName; |
| this.pluginName = pluginName; |
| this.repoManager = repoManager; |
| this.projectCache = projectCache; |
| this.pluginConfigFactory = pluginConfigFactory; |
| this.reviewApi = reviewApi; |
| this.checkConfig = null; |
| } |
| |
| ScannerConfig getScannerConfig() { |
| return checkConfig == null ? null : checkConfig.scannerConfig; |
| } |
| |
| @Override |
| public void start() { |
| try (Timer0.Context ctx = metrics.readConfigTimer.start()) { |
| checkConfig = readConfig(projectCache.getAllProjects().getProject().getConfigRefState()); |
| } catch (IOException | ConfigInvalidException e) { |
| logger.atSevere().withCause(e).log("unable to load configuration"); |
| metrics.configurationErrors.increment(allProjectsName.get()); |
| metrics.errors.increment(); |
| return; |
| } |
| } |
| |
| @Override |
| public void stop() {} |
| |
| /** Listens for merges to /refs/meta/config on All-Projects to reload plugin configuration. */ |
| @Override |
| public void onGitReferenceUpdated(GitReferenceUpdatedListener.Event event) { |
| if (!event.getRefName().equals(RefNames.REFS_CONFIG)) { |
| return; |
| } |
| if (!event.getProjectName().equals(allProjectsName.get())) { |
| return; |
| } |
| try (Timer0.Context ctx = metrics.readConfigTimer.start()) { |
| checkConfig = readConfig(event.getNewObjectId()); |
| } catch (IOException | ConfigInvalidException e) { |
| logger.atSevere().withCause(e).log("unable to load configuration"); |
| metrics.configurationErrors.increment(allProjectsName.get()); |
| metrics.errors.increment(); |
| return; |
| } |
| } |
| |
| /** Blocks upload of bad plugin configurations to /refs/meta/config on All-Projects. */ |
| @Override |
| public List<CommitValidationMessage> onCommitReceived(CommitReceivedEvent event) |
| throws CommitValidationException { |
| if (!event.getRefName().equals(RefNames.REFS_CONFIG)) { |
| return Collections.emptyList(); |
| } |
| if (!event.getProjectNameKey().equals(allProjectsName)) { |
| return Collections.emptyList(); |
| } |
| CheckConfig trialConfig = null; |
| try { |
| try (Timer0.Context ctx = metrics.readConfigTimer.start()) { |
| trialConfig = readConfig(event.commit.getName()); |
| } |
| if (Objects.equals( |
| trialConfig.scannerConfig, checkConfig == null ? null : checkConfig.scannerConfig)) { |
| return Collections.emptyList(); |
| } |
| try (Timer0.Context ctx = metrics.checkConfigTimer.start()) { |
| long maxElapsedSeconds = |
| gerritConfig == null |
| ? DEFAULT_MAX_ELAPSED_SECONDS |
| : gerritConfig.getLong( |
| ScannerConfig.KEY_TIME_TEST_MAX, DEFAULT_MAX_ELAPSED_SECONDS); |
| if (maxElapsedSeconds > 0 |
| && CheckConfig.hasScanner(trialConfig) |
| && !CheckConfig.scannersEqual(trialConfig, checkConfig)) { |
| String commitMessage = event.commit.getFullMessage(); |
| ImmutableList<CopyrightReviewApi.CommitMessageFinding> findings = |
| trialConfig.checkCommitMessage(commitMessage); |
| if (CheckConfig.mustReportFindings(findings, maxElapsedSeconds)) { |
| throw reviewApi.getCommitMessageException(pluginName, findings, maxElapsedSeconds); |
| } |
| } |
| boolean pluginEnabled = |
| gerritConfig != null && gerritConfig.getBoolean(ScannerConfig.KEY_ENABLE, false); |
| CheckConfig.checkProjectConfig(reviewApi, pluginEnabled, trialConfig); |
| List<CommitValidationMessage> messages = |
| trialConfig == null || trialConfig.scannerConfig == null |
| ? Collections.emptyList() |
| : trialConfig.scannerConfig.messages; |
| checkForConfigErrors(trialConfig); |
| return messages; |
| } |
| } catch (IOException e) { |
| logger.atSevere().withCause(e).log("failed to read new project.config"); |
| throw new CommitValidationException( |
| pluginName + "plugin failed to read new project.config", e); |
| } catch (ConfigInvalidException e) { |
| logger.atSevere().withCause(e).log("unable to parse plugin config"); |
| if (trialConfig != null && trialConfig.scannerConfig != null) { |
| trialConfig.scannerConfig.messages.add(ScannerConfig.errorMessage(e.getMessage())); |
| metrics.configurationErrors.increment(allProjectsName.get()); |
| metrics.errors.increment(); |
| checkForConfigErrors(trialConfig); |
| return trialConfig.scannerConfig.messages; |
| } else { |
| throw new CommitValidationException( |
| pluginName + "plugin unable to parse new project.config", e); |
| } |
| } |
| } |
| |
| /** Warns on review thread about suspect plugin configurations. */ |
| @Override |
| public void onRevisionCreated(RevisionCreatedListener.Event event) { |
| String project = event.getChange().project; |
| String branch = event.getChange().branch; |
| |
| if (!branch.equals(RefNames.REFS_CONFIG)) { |
| return; |
| } |
| if (!project.equals(allProjectsName.get())) { |
| return; |
| } |
| if (!event.getRevision().files.keySet().contains(ProjectConfig.PROJECT_CONFIG)) { |
| return; |
| } |
| // passed onCommitReceived so expect at worst only warnings here |
| CheckConfig trialConfig = null; |
| try { |
| try (Timer0.Context ctx = metrics.readConfigTimer.start()) { |
| trialConfig = readConfig(event.getChange().currentRevision); |
| } |
| if (Objects.equals( |
| trialConfig.scannerConfig, checkConfig == null ? null : checkConfig.scannerConfig)) { |
| return; |
| } |
| |
| try (Timer0.Context ctx = metrics.checkConfigTimer.start()) { |
| if (CheckConfig.hasScanner(trialConfig) |
| && !CheckConfig.scannersEqual(trialConfig, checkConfig)) { |
| long maxElapsedSeconds = |
| gerritConfig == null |
| ? DEFAULT_MAX_ELAPSED_SECONDS |
| : gerritConfig.getLong( |
| ScannerConfig.KEY_TIME_TEST_MAX, DEFAULT_MAX_ELAPSED_SECONDS); |
| if (maxElapsedSeconds > 0) { |
| String commitMessage = event.getRevision().commitWithFooters; |
| ImmutableList<CopyrightReviewApi.CommitMessageFinding> findings = |
| trialConfig.checkCommitMessage(commitMessage); |
| ReviewResult result = |
| reviewApi.reportCommitMessageFindings( |
| pluginName, |
| allProjectsName.get(), |
| checkConfig == null ? null : checkConfig.scannerConfig, |
| trialConfig.scannerConfig, |
| event, |
| findings, |
| maxElapsedSeconds); |
| logReviewResultErrors(event, result); |
| } |
| } |
| boolean pluginEnabled = |
| gerritConfig != null && gerritConfig.getBoolean(ScannerConfig.KEY_ENABLE, false); |
| CheckConfig.checkProjectConfig(reviewApi, pluginEnabled, trialConfig); |
| return; |
| } |
| } catch (RestApiException | ConfigInvalidException | IOException e) { |
| logger.atSevere().withCause(e).log("unable to read new configuration"); |
| metrics.configurationErrors.increment(project); |
| metrics.errors.increment(); |
| return; |
| } finally { |
| if (trialConfig != null |
| && trialConfig.scannerConfig != null |
| && !trialConfig.scannerConfig.messages.isEmpty() |
| && !trialConfig.scannerConfig.hasErrors()) { |
| try { |
| ReviewResult result = |
| reviewApi.reportConfigMessages( |
| pluginName, |
| project, |
| ProjectConfig.PROJECT_CONFIG, |
| checkConfig == null ? null : checkConfig.scannerConfig, |
| trialConfig.scannerConfig, |
| event); |
| logReviewResultErrors(event, result); |
| } catch (RestApiException e) { |
| logger.atSevere().withCause(e).log("unable to report configuration findings"); |
| metrics.postReviewErrors.increment(project); |
| metrics.errors.increment(); |
| return; |
| } |
| } |
| } |
| } |
| |
| /** Returns true if copyright validation enabled for {@code project}. */ |
| boolean isProjectEnabled(ScannerConfig scannerConfig, String project) { |
| // scan all projects when missing |
| if (!scannerConfig.matchProjects.isEmpty() |
| && !ScannerConfig.matchesAny(project, scannerConfig.matchProjects)) { |
| // doesn't match == isn't checked |
| return false; |
| } |
| // exclude no projects when missing |
| if (!scannerConfig.excludeProjects.isEmpty() |
| && ScannerConfig.matchesAny(project, scannerConfig.excludeProjects)) { |
| // does match == isn't checked |
| return false; |
| } |
| ProjectState projectState; |
| try { |
| projectState = projectCache.checkedGet(Project.nameKey(project)); |
| } catch (IOException e) { |
| logger.atSevere().withCause(e).log("error getting project state of %s", project); |
| metrics.projectStateErrors.increment(project); |
| metrics.errors.increment(); |
| return scannerConfig.defaultEnable; |
| } |
| if (projectState == null) { |
| logger.atSevere().log("error getting project state of %s", project); |
| metrics.projectStateErrors.increment(project); |
| metrics.errors.increment(); |
| return scannerConfig.defaultEnable; |
| } |
| ProjectConfig projectConfig = projectState.getConfig(); |
| if (projectConfig == null) { |
| logger.atWarning().log("error getting project config of %s", project); |
| metrics.projectConfigErrors.increment(project); |
| metrics.errors.increment(); |
| return scannerConfig.defaultEnable; |
| } |
| PluginConfig pluginConfig = projectConfig.getPluginConfig(pluginName); |
| if (pluginConfig == null) { |
| // no plugin config section in project so use default |
| return scannerConfig.defaultEnable; |
| } |
| return pluginConfig.getBoolean(ScannerConfig.KEY_ENABLE, scannerConfig.defaultEnable); |
| } |
| |
| private void checkForConfigErrors(CheckConfig trialConfig) throws CommitValidationException { |
| if (trialConfig != null |
| && trialConfig.scannerConfig != null |
| && trialConfig.scannerConfig.hasErrors()) { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("\nerror in "); |
| sb.append(pluginName); |
| sb.append(" plugin configuration"); |
| trialConfig.scannerConfig.appendMessages(sb); |
| throw new CommitValidationException(sb.toString()); |
| } |
| } |
| |
| /** |
| * Loads and compiles configured patterns from {@code ref/meta/All-Projects/project.config} and |
| * {@code gerrit.config}. |
| * |
| * @param projectConfigObjectId identifies the version of project.config to load and to compile |
| * @return the new scanner configuration to check |
| * @throws IOException if accessing the repository fails |
| */ |
| @Nullable |
| private CheckConfig readConfig(String projectConfigObjectId) |
| throws IOException, ConfigInvalidException { |
| CheckConfig checkConfig = null; |
| // new All-Projects project.config not yet in cache -- read from repository |
| ObjectId id = ObjectId.fromString(projectConfigObjectId); |
| if (ObjectId.zeroId().equals(id)) { |
| return checkConfig; |
| } |
| try (Repository repo = repoManager.openRepository(allProjectsName)) { |
| checkConfig = |
| new CheckConfig(pluginName, readFileContents(repo, id, ProjectConfig.PROJECT_CONFIG)); |
| } |
| gerritConfig = pluginConfigFactory.getFromGerritConfig(pluginName, true); |
| if (gerritConfig == null) { |
| checkConfig.scannerConfig.messages.add( |
| ScannerConfig.hintMessage( |
| "missing [plugin \"" + pluginName + "\"] section in gerrit.config")); |
| } else { |
| checkConfig.scannerConfig.defaultEnable = |
| gerritConfig.getBoolean(ScannerConfig.KEY_ENABLE, false); |
| } |
| return checkConfig; |
| } |
| |
| private void logReviewResultErrors(RevisionCreatedListener.Event event, ReviewResult result) { |
| if (!Strings.isNullOrEmpty(result.error)) { |
| logger.atSevere().log( |
| "revision %s: error posting review: %s", event.getChange().currentRevision, result.error); |
| metrics.postReviewErrors.increment(event.getChange().project); |
| metrics.errors.increment(); |
| } |
| if (result.reviewers != null) { |
| for (Map.Entry<String, AddReviewerResult> entry : result.reviewers.entrySet()) { |
| AddReviewerResult arr = entry.getValue(); |
| if (!Strings.isNullOrEmpty(arr.error)) { |
| logger.atSevere().log( |
| "revision %s: error adding reviewer %s: %s", |
| event.getChange().currentRevision, entry.getKey(), arr.error); |
| metrics.addReviewerErrors.increment(event.getChange().project); |
| metrics.errors.increment(); |
| } |
| } |
| } |
| } |
| |
| private String readFileContents(Repository repo, ObjectId objectId, String filename) |
| throws IOException { |
| try (RevWalk rw = new RevWalk(repo); |
| TreeWalk tw = TreeWalk.forPath(rw.getObjectReader(), filename, rw.parseTree(objectId))) { |
| ObjectLoader loader = repo.open(tw.getObjectId(0), Constants.OBJ_BLOB); |
| return new String(loader.getCachedBytes(), UTF_8); |
| } |
| } |
| } |
