import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@VisibleForTesting
static PluginInfo create(Path jarPath, PluginManifest manifest) {
  if (StringUtils.isBlank(manifest.getKey())) {
    throw MessageException.of(String.format("File is not a plugin. Please delete it and restart: %s", jarPath.toAbsolutePath()));
  }
  PluginInfo info = new PluginInfo(manifest.getKey());

  info.setJarFile(jarPath.toFile());
  info.setName(manifest.getName());
  info.setMainClass(manifest.getMainClass());
  info.setVersion(Version.create(manifest.getVersion()));

  // optional fields
  info.setUseChildFirstClassLoader(manifest.isUseChildFirstClassLoader());
  info.setBasePlugin(manifest.getBasePlugin());
  info.setImplementationBuild(manifest.getImplementationBuild());
  info.setSonarLintSupported(manifest.isSonarLintSupported());
  String[] requiredPlugins = manifest.getRequirePlugins();
  if (requiredPlugins != null) {
    for (String s : requiredPlugins) {
      info.addRequiredPlugin(RequiredPlugin.parse(s));
    }
  }
  return info;
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@CheckForNull
String language(InputFile inputFile) {
  String detectedLanguage = null;
  for (String languageKey : languagesToConsider) {
    if (isCandidateForLanguage(inputFile, languageKey)) {
      if (detectedLanguage == null) {
        detectedLanguage = languageKey;
      } else {
        // Language was already forced by another pattern
        throw MessageException.of(MessageFormat.format("Language of file ''{0}'' can not be decided as the file matches patterns of both {1} and {2}",
          inputFile.relativePath(), getDetails(detectedLanguage), getDetails(languageKey)));
      }
    }
  }
  if (detectedLanguage != null) {
    LOG.debug("Language of file '{}' is detected to be '{}'", inputFile.absolutePath(), detectedLanguage);
    return detectedLanguage;
  }
  return null;
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
private void defineRulesForLanguage(Context context, String repositoryKey, String repositoryName,
        String languageKey) {
    NewRepository repository = context.createRepository(repositoryKey, languageKey).setName(repositoryName);

    try(InputStream rulesXml = this.getClass().getResourceAsStream(rulesDefinitionFilePath())) {
        if (rulesXml != null) {
            RulesDefinitionXmlLoader rulesLoader = new RulesDefinitionXmlLoader();
            rulesLoader.load(repository, rulesXml, StandardCharsets.UTF_8.name());
            addRemediationCost(repository.rules());
        }
    } catch (IOException e) {
        throw MessageException.of("Unable to load rules defintion", e);
    }

    repository.done();
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
public void init(int pullRequestNumber, File projectBaseDir) {
  initGitBaseDir(projectBaseDir);
  try {
    GitHub github;
    if (config.isProxyConnectionEnabled()) {
      github = new GitHubBuilder().withProxy(config.getHttpProxy()).withEndpoint(config.endpoint()).withOAuthToken(config.oauth()).build();
    } else {
      github = new GitHubBuilder().withEndpoint(config.endpoint()).withOAuthToken(config.oauth()).build();
    }
    setGhRepo(github.getRepository(config.repository()));
    setPr(ghRepo.getPullRequest(pullRequestNumber));
    LOG.info("Starting analysis of pull request: " + pr.getHtmlUrl());
    myself = github.getMyself().getLogin();
    loadExistingReviewComments();
    patchPositionMappingByFile = mapPatchPositionsToLines(pr);
  } catch (IOException e) {
    LOG.debug("Unable to perform GitHub WS operation", e);
    throw MessageException.of("Unable to perform GitHub WS operation: " + e.getMessage());
  }
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@Test
public void properFailureIfNotAGitProject() throws IOException {
  File projectDir = temp.newFolder();
  javaUnzip(new File("test-repos/dummy-git.zip"), projectDir);

  JGitBlameCommand jGitBlameCommand = new JGitBlameCommand(new PathResolver());

  File baseDir = new File(projectDir, "dummy-git");

  // Delete .git
  FileUtils.forceDelete(new File(baseDir, ".git"));

  DefaultFileSystem fs = new DefaultFileSystem(baseDir);
  when(input.fileSystem()).thenReturn(fs);
  DefaultInputFile inputFile = new TestInputFileBuilder("foo", DUMMY_JAVA).build();
  fs.add(inputFile);

  BlameOutput blameResult = mock(BlameOutput.class);
  when(input.filesToBlame()).thenReturn(Arrays.<InputFile>asList(inputFile));

  thrown.expect(MessageException.class);
  thrown.expectMessage("Not inside a Git work tree: ");

  jGitBlameCommand.blame(input, blameResult);
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
private DefaultRule validateRule(Issue issue) {
  RuleKey ruleKey = issue.ruleKey();
  Rule rule = rules.find(ruleKey);
  if (rule == null) {
    throw MessageException.of(String.format("The rule '%s' does not exist.", ruleKey));
  }
  if (Strings.isNullOrEmpty(rule.name()) && Strings.isNullOrEmpty(issue.primaryLocation().message())) {
    throw MessageException.of(String.format("The rule '%s' has no name and the related issue has no message.", ruleKey));
  }
  return (DefaultRule) rule;
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@Test
public void fail_when_jar_is_not_a_plugin() throws IOException {
  // this JAR has a manifest but is not a plugin
  File jarRootDir = temp.newFolder();
  FileUtils.write(new File(jarRootDir, "META-INF/MANIFEST.MF"), "Build-Jdk: 1.6.0_15");
  Path jar = temp.newFile().toPath();
  ZipUtils.zipDir(jarRootDir, jar.toFile());

  expectedException.expect(MessageException.class);
  expectedException.expectMessage("File is not a plugin. Please delete it and restart: " + jar.toAbsolutePath());

  PluginInfo.create(jar);
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@Test
public void fail_if_conflicting_language_suffix() throws Exception {
  LanguagesRepository languages = new DefaultLanguagesRepository(new Languages(new MockLanguage("xml", "xhtml"), new MockLanguage("web", "xhtml")));
  LanguageDetection detection = new LanguageDetection(languages);
  try {
    detection.language(newInputFile("abc.xhtml"));
    fail();
  } catch (MessageException e) {
    assertThat(e.getMessage())
      .contains("Language of file 'abc.xhtml' can not be decided as the file matches patterns of both ")
      .contains("web: file:**/*.xhtml")
      .contains("xml: file:**/*.xhtml");
  }
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
private static Map<String, String> getCostByRule() {
    Map<String, String> result = new HashMap<>();

    try (InputStream stream = PerlCriticRulesDefinition.class.getResourceAsStream(COST_FILE_CSV);
            Stream< String>lines = new BufferedReader(new InputStreamReader(stream)).lines()) {
        lines //
                .skip(1) // header line
                .forEach(line -> PerlCriticRulesDefinition.completeCost(line, result));
    } catch (IOException e) {
        throw MessageException.of("Unable to load rules remediation function/factor", e);
    }
    return result;
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
private void notificationCommitStatus(String status, String message) {
    if ("failed".equals(status)) {
        throw MessageException.of(message);
    } else {
        LOG.info(message);
    }
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
private String buildFreemarkerComment() {
    Configuration cfg = new Configuration(Configuration.getVersion());
    cfg.setDefaultEncoding("UTF-8");
    cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);
    cfg.setLogTemplateExceptions(false);

    try (StringWriter sw = new StringWriter()) {
        new Template(templateName, template, cfg).process(createContext(), sw);
        return StringEscapeUtils.unescapeHtml4(sw.toString());
    } catch (IOException | TemplateException e) {
        LOG.error("Failed to create template {}", templateName, e);
        throw MessageException.of("Failed to create template " + templateName);
    }
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@Test
public void testCommitAnalysisWithNewIssues2() {
    settings.setProperty(GitLabPlugin.GITLAB_ONLY_ISSUE_FROM_COMMIT_FILE, false);
    settings.setProperty(GitLabPlugin.GITLAB_STATUS_NOTIFICATION_MODE, StatusNotificationsMode.EXIT_CODE.getMeaning());
    settings.setProperty(GitLabPlugin.GITLAB_DISABLE_GLOBAL_COMMENT, true);

    DefaultInputFile inputFile1 = new DefaultInputFile("foo", "src/Foo.php");
    PostJobIssue newIssue = Utils.newMockedIssue("foo:src/Foo.php", inputFile1, 1, Severity.BLOCKER, true, "msg1");
    Mockito.when(commitFacade.getGitLabUrl(null, inputFile1, 1)).thenReturn("http://gitlab/blob/abc123/src/Foo.php#L1");

    PostJobIssue lineNotVisible = Utils.newMockedIssue("foo:src/Foo.php", inputFile1, 2, Severity.BLOCKER, true, "msg2");
    Mockito.when(commitFacade.getGitLabUrl(null, inputFile1, 2)).thenReturn("http://gitlab/blob/abc123/src/Foo.php#L2");

    DefaultInputFile inputFile2 = new DefaultInputFile("foo", "src/Foo2.php");
    PostJobIssue fileNotInPR = Utils.newMockedIssue("foo:src/Foo2.php", inputFile2, 1, Severity.BLOCKER, true, "msg3");

    PostJobIssue notNewIssue = Utils.newMockedIssue("foo:src/Foo.php", inputFile1, 1, Severity.BLOCKER, false, "msg");

    PostJobIssue issueOnDir = Utils.newMockedIssue("foo:src", Severity.BLOCKER, true, "msg4");

    PostJobIssue issueOnProject = Utils.newMockedIssue("foo", Severity.BLOCKER, true, "msg");

    PostJobIssue globalIssue = Utils.newMockedIssue("foo:src/Foo.php", inputFile1, null, Severity.BLOCKER, true, "msg5");

    Mockito.when(context.issues()).thenReturn(Arrays.asList(newIssue, globalIssue, issueOnProject, issueOnDir, fileNotInPR, lineNotVisible, notNewIssue));
    Mockito.when(commitFacade.hasFile(inputFile1)).thenReturn(true);
    Mockito.when(commitFacade.getRevisionForLine(inputFile1, 1)).thenReturn(null);

    Assertions.assertThatThrownBy(() -> commitIssuePostJob.execute(context)).isInstanceOf(MessageException.class);

    Mockito.verify(commitFacade, Mockito.never()).addGlobalComment(Mockito.contains("SonarQube analysis reported 6 issues"));
    Mockito.verify(commitFacade, Mockito.never()).createOrUpdateSonarQubeStatus("failed", "SonarQube reported 6 issues, with 6 blocker");
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@Test
public void shouldFailIfNotPreview() {
    settings.setProperty(GitLabPlugin.GITLAB_COMMIT_SHA, "1");

    thrown.expect(MessageException.class);
    thrown.expectMessage("The GitLab plugin is only intended to be used in preview or issues mode. Please set 'sonar.analysis.mode'.");

    commitProjectBuilder.build(null);
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
public String repository() {
  if (settings.hasKey(GitHubPlugin.GITHUB_REPO)) {
    return repoFromProp();
  }
  if (isNotBlank(settings.getString(CoreProperties.LINKS_SOURCES_DEV)) || isNotBlank(settings.getString(CoreProperties.LINKS_SOURCES))) {
    return repoFromScmProps();
  }
  throw MessageException.of("Unable to determine GitHub repository name for this project. Please provide it using property '" + GitHubPlugin.GITHUB_REPO
    + "' or configure property '" + CoreProperties.LINKS_SOURCES + "'.");
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@Test
public void shouldFailIfNotPreview() {
  settings.setProperty(GitHubPlugin.GITHUB_PULL_REQUEST, "1");

  thrown.expect(MessageException.class);
  thrown.expectMessage("The GitHub plugin is only intended to be used in preview or issues mode. Please set 'sonar.analysis.mode'.");

  pullRequestProjectBuilder.build(null);
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
static RepositoryBuilder getVerifiedRepositoryBuilder(Path basedir) {
  RepositoryBuilder builder = new RepositoryBuilder()
    .findGitDir(basedir.toFile())
    .setMustExist(true);

  if (builder.getGitDir() == null) {
    throw MessageException.of("Not inside a Git work tree: " + basedir);
  }
  return builder;
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@CheckForNull
public File privateKey() {
  if (settings.hasKey(PRIVATE_KEY_PATH_PROP_KEY)) {
    File privateKeyFile = new File(settings.getString(PRIVATE_KEY_PATH_PROP_KEY));
    if (!privateKeyFile.exists() || !privateKeyFile.isFile() || !privateKeyFile.canRead()) {
      throw MessageException.of("Unable to read private key from '" + privateKeyFile + "'");
    }
    return privateKeyFile;
  }
  return null;
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
public IssuesChecker(Settings settings, RulesProfile profile) {
  oldDumpFile = getFile(settings, LITSPlugin.OLD_DUMP_PROPERTY);
  newDumpFile = getFile(settings, LITSPlugin.NEW_DUMP_PROPERTY);
  differencesFile = getFile(settings, LITSPlugin.DIFFERENCES_PROPERTY);
  for (ActiveRule activeRule : profile.getActiveRules()) {
    if (!activeRule.getSeverity().toString().equals(Severity.INFO)) {
      throw MessageException.of("Rule '" + activeRule.getRepositoryKey() + ":" + activeRule.getRuleKey() + "' must be declared with severity INFO");
    }
  }
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
private static File getFile(Settings settings, String property) {
  String path = settings.getString(property);
  if (path == null) {
    throw MessageException.of("Missing property '" + property + "'");
  }
  File file = new File(path);
  if (!file.isAbsolute()) {
    throw MessageException.of("Path must be absolute - check property '" + property + "'" );
  }
  return file;
}
 

import org.sonar.api.utils.MessageException; //导入依赖的package包/类
@Test
public void path_must_be_specified() {
  Settings settings = new Settings();
  thrown.expect(MessageException.class);
  thrown.expectMessage("Missing property 'dump.old'");
  new IssuesChecker(settings, profile);
}