protected File getFile(String artifactName) {
   // artifactMap is a bit too simplistic
   for (Artifact artifact : project.getArtifacts())
     if (artifact.toString().startsWith(artifactName)) return artifact.getFile();
   throw new IllegalArgumentException(
       "could not find " + artifactName + " in " + project.getArtifacts());
 }
  /**
   * Log Projects and their resolved dependencies via MavenProject.getArtifacts().
   *
   * @param reactorProjects MavenProjects in the current reactor
   */
  private void checkReactor(final List<MavenProject> reactorProjects) {
    for (final MavenProject reactorProject : reactorProjects) {
      final String msg =
          "Check resolved Artifacts for: "
              + "\ngroudId:    "
              + reactorProject.getGroupId()
              + "\nartifactId: "
              + reactorProject.getArtifactId()
              + "\nversion:    "
              + reactorProject.getVersion();
      if (getLog().isDebugEnabled()) getLog().debug(msg);

      if (reactorProject.getArtifacts() == null || reactorProject.getArtifacts().isEmpty()) {
        if (getLog().isDebugEnabled())
          getLog().debug("+  Dependencies not resolved or Reactor-Project has no dependencies!");
      } else {
        for (final Artifact artifact : reactorProject.getArtifacts()) {
          if (getLog().isDebugEnabled())
            getLog()
                .debug(
                    "  + "
                        + artifact.getGroupId()
                        + " : "
                        + artifact.getArtifactId()
                        + " : "
                        + artifact.getVersion()
                        + " : "
                        + artifact.getType()
                        + " : "
                        + artifact.getFile());
        }
      }
    }
  }
  /**
   * Merge WsdlOptions that point to the same file by adding the extraargs to the first option and
   * deleting the second from the options list
   *
   * @param options
   */
  @SuppressWarnings("unchecked")
  private Artifact resolveRemoteWsdlArtifact(List<?> remoteRepos, Artifact artifact)
      throws MojoExecutionException {

    /**
     * First try to find the artifact in the reactor projects of the maven session. So an artifact
     * that is not yet built can be resolved
     */
    List<MavenProject> rProjects = mavenSession.getSortedProjects();
    for (MavenProject rProject : rProjects) {
      if (artifact.getGroupId().equals(rProject.getGroupId())
          && artifact.getArtifactId().equals(rProject.getArtifactId())
          && artifact.getVersion().equals(rProject.getVersion())) {
        Set<Artifact> artifacts = rProject.getArtifacts();
        for (Artifact pArtifact : artifacts) {
          if ("wadl".equals(pArtifact.getType())) {
            return pArtifact;
          }
        }
      }
    }

    /** If this did not work resolve the artifact using the artifactResolver */
    try {
      artifactResolver.resolve(artifact, remoteRepos, localRepository);
    } catch (ArtifactResolutionException e) {
      throw new MojoExecutionException("Error downloading wsdl artifact.", e);
    } catch (ArtifactNotFoundException e) {
      throw new MojoExecutionException("Resource can not be found.", e);
    }

    return artifact;
  }
  /**
   * Set up the execution classpath for Jasper.
   *
   * <p>Put everything in the classesDirectory and all of the dependencies on the classpath.
   *
   * @returns a list of the urls of the dependencies
   * @throws Exception
   */
  private List<URL> setUpWebAppClassPath() throws Exception {
    // add any classes from the webapp
    List<URL> urls = new ArrayList<URL>();
    String classesDir = classesDirectory.getCanonicalPath();
    classesDir = classesDir + (classesDir.endsWith(File.pathSeparator) ? "" : File.separator);
    urls.add(Resource.toURL(new File(classesDir)));

    if (getLog().isDebugEnabled()) getLog().debug("Adding to classpath classes dir: " + classesDir);

    // add the dependencies of the webapp (which will form WEB-INF/lib)
    for (Iterator<Artifact> iter = project.getArtifacts().iterator(); iter.hasNext(); ) {
      Artifact artifact = (Artifact) iter.next();

      // Include runtime and compile time libraries
      if (!Artifact.SCOPE_TEST.equals(artifact.getScope())
          && !Artifact.SCOPE_PROVIDED.equals(artifact.getScope())) {
        String filePath = artifact.getFile().getCanonicalPath();
        if (getLog().isDebugEnabled())
          getLog().debug("Adding to classpath dependency file: " + filePath);

        urls.add(Resource.toURL(artifact.getFile()));
      }
    }
    return urls;
  }
  private void addDependencies(final MavenProject project, final JettyWebAppContext webAppConfig)
      throws Exception {
    List<File> dependencyFiles = new ArrayList<File>();
    List<Resource> overlays = new ArrayList<Resource>();

    for (Artifact artifact : project.getArtifacts()) {
      if (artifact.getType().equals("war")) {
        overlays.add(Resource.newResource("jar:" + artifact.getFile().toURL().toString() + "!/"));
      } else if ((!Artifact.SCOPE_PROVIDED.equals(artifact.getScope()))
          && (!Artifact.SCOPE_TEST.equals(artifact.getScope()))) {
        File dependencyFile = artifact.getFile();

        if (dependencyFile == null || !dependencyFile.exists()) {
          String coordinates =
              String.format(
                  "%s:%s:%s",
                  artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion());

          LOG.log(
              Level.WARNING,
              "Dependency '" + coordinates + "' does not exist in repository. Skipping!");
          continue;
        }

        dependencyFiles.add(artifact.getFile());
      }
    }

    webAppConfig.setOverlays(overlays);
    webAppConfig.setWebInfLib(dependencyFiles);
  }
  // used by "initialize", "dist" and "war" mojos
  protected Artifact findFrameworkArtifact(boolean minVersionWins) {
    Artifact result = null;

    Set<?> artifacts = project.getArtifacts();
    for (Iterator<?> iter = artifacts.iterator(); iter.hasNext(); ) {
      Artifact artifact = (Artifact) iter.next();
      if ("zip".equals(artifact.getType())) {
        if ("framework".equals(artifact.getClassifier())) {
          result = artifact;
          if (!minVersionWins) {
            break;
          }
          // System.out.println( "added framework: " + artifact.getGroupId() + ":" +
          // artifact.getArtifactId()
          // );
          // don't break, maybe there is "framework-min" artifact too
        }
        // "module-min" overrides "module" (if present)
        else if ("framework-min".equals(artifact.getClassifier())) {
          result = artifact;
          // System.out.println( "added framework-min: " + artifact.getGroupId() + ":"
          // + artifact.getArtifactId() );
          if (minVersionWins) {
            break;
          }
        }
      }
    }
    return result;
  }
  public List<Artifact> getIncludedArtifacts() throws MojoExecutionException {

    if (inlcudedArtifacts == null) {
      inlcudedArtifacts = new ArrayList<Artifact>();

      Set<Artifact> artifacts = project.getArtifacts();

      if (includes != null) {
        if (exclusions != null) {
          throw new MojoExecutionException("Both inlcudes and exclusions are specified");
        }
        Set<String> inclusionKeys = getArtifactKeys(includes);

        for (Artifact a : artifacts) {
          if (inclusionKeys.contains(
              getArtifactKey(a.getGroupId(), a.getArtifactId(), a.getClassifier()))) {
            inlcudedArtifacts.add(a);
          }
        }
      } else {
        Set<String> exclusionKeys = new HashSet<String>(getArtifactKeys(exclusions));
        exclusionKeys.addAll(getImportedArtifactKeys());
        for (Artifact a : artifacts) {
          if (!exclusionKeys.contains(
              getArtifactKey(a.getGroupId(), a.getArtifactId(), a.getClassifier()))) {
            inlcudedArtifacts.add(a);
          }
        }
      }
    }

    return inlcudedArtifacts;
  }
  @Override
  protected List<File> getDependencies() {
    ArrayList<File> dependencies = new ArrayList<File>();

    @SuppressWarnings("unchecked")
    final Iterator<Artifact> it = project.getArtifacts().iterator();
    while (it.hasNext()) {
      final Artifact declared = it.next();
      this.log.debug("Checking artifact " + declared);
      if (this.isJavaArtifact(declared)) {
        if (Artifact.SCOPE_COMPILE.equals(declared.getScope())
            || Artifact.SCOPE_RUNTIME.equals(declared.getScope())
            || Artifact.SCOPE_PROVIDED.equals(declared.getScope())
            || Artifact.SCOPE_SYSTEM.equals(declared.getScope())) {
          this.log.debug("Resolving artifact " + declared);
          if (declared.getFile() != null) {
            dependencies.add(declared.getFile());
          } else {
            this.log.debug("Unable to resolve artifact " + declared);
          }
        } else {
          this.log.debug(
              "Artifact "
                  + declared
                  + " has not scope compile or runtime, but "
                  + declared.getScope());
        }
      } else {
        this.log.debug(
            "Artifact " + declared + " is not a java artifact, type is " + declared.getType());
      }
    }

    return dependencies;
  }
  private void generateMetadata(Archiver archiver)
      throws ArchiverException, MojoExecutionException {

    Log log = getLog();
    File tmpServicesDir = new File(new File(tmpDirectory, "META-INF"), "services");
    File buildServicesDir = new File(new File(buildOutputDirectory, "META-INF"), "services");
    if (!tmpServicesDir.mkdirs()) {
      throw new MojoExecutionException(
          "Error while creating the directory: " + tmpServicesDir.getPath());
    }

    log.debug("Initializing class scanner ...");
    ClassScanner scanner = new ClassScanner(buildOutputDirectory);
    for (Artifact artifact :
        filterArtifacts(
            (Set<Artifact>) project.getArtifacts(),
            new ScopeArtifactFilter(Artifact.SCOPE_COMPILE))) {
      scanner.addToClasspath(artifact.getFile());
    }
    List<ServiceLocator> serviceLocators = new ArrayList<ServiceLocator>(serviceClassNames.length);
    for (String serviceClassName : serviceClassNames) {
      // If the user provided its own service file, skip generation
      File file = new File(buildServicesDir, serviceClassName);
      if (file.exists()) {
        log.debug(file + " exists; don't scan for " + serviceClassName + " implementation");
      } else {
        ServiceLocator sl = new ServiceLocator(serviceClassName);
        serviceLocators.add(sl);
        scanner.addVisitor(sl);
      }
    }
    try {
      scanner.scan();
    } catch (ClassScannerException e) {
      throw new MojoExecutionException("Failed to scan classes for services", e);
    }
    for (ServiceLocator sl : serviceLocators) {
      File file = new File(tmpServicesDir, sl.getServiceClassName());
      if (!sl.getImplementations().isEmpty()) {
        String destFileName = "META-INF/services/" + sl.getServiceClassName();
        log.info("Generating " + destFileName);
        try {
          Writer out = new OutputStreamWriter(new FileOutputStream(file));
          try {
            for (String impl : sl.getImplementations()) {
              log.debug("  " + impl);
              out.write(impl);
              out.write("\n");
            }
          } finally {
            out.close();
          }
        } catch (IOException e) {
          throw new MojoExecutionException("Unable to create temporary file " + file, e);
        }
        archiver.addFile(file, destFileName);
      }
    }
  }
  /**
   * @return
   * @throws MalformedURLException
   * @throws IOException
   */
  private List<Artifact> getWarArtifacts() throws MalformedURLException, IOException {
    List<Artifact> warArtifacts = new ArrayList<Artifact>();
    for (Iterator<Artifact> iter = project.getArtifacts().iterator(); iter.hasNext(); ) {
      Artifact artifact = (Artifact) iter.next();

      if (artifact.getType().equals("war")) warArtifacts.add(artifact);
    }

    return warArtifacts;
  }
 @SuppressWarnings("unchecked")
 public Set<Artifact> getProjectRuntimeArtifacts() {
   Set<Artifact> artifacts = new HashSet<Artifact>();
   for (Artifact projectArtifact : (Collection<Artifact>) project.getArtifacts()) {
     String scope = projectArtifact.getScope();
     if (SCOPE_RUNTIME.equals(scope) || SCOPE_COMPILE.equals(scope)) {
       artifacts.add(projectArtifact);
     }
   }
   return artifacts;
 }
  public void test017_moduleRefresh() throws Exception {
    IProject p2 = createExisting("t017-p2");
    IProject p3 = createExisting("t017-p3");
    IProject p4 = createExisting("t017-p4");
    waitForJobsToComplete();

    IFile pom = p3.getFile("pom.xml");

    MavenProject mavenProject = manager.create(pom, false, null).getMavenProject(monitor);
    Artifact a = mavenProject.getArtifacts().iterator().next();
    assertTrue(a.isResolved());
    assertEquals(
        p4.getFile(IMavenConstants.POM_FILE_NAME).getLocation().toFile().getAbsoluteFile(),
        a.getFile().getAbsoluteFile());

    copyContent(p2, "pom_changed.xml", "pom.xml");

    mavenProject = manager.create(pom, false, null).getMavenProject(monitor);
    a = mavenProject.getArtifacts().iterator().next();
    assertFalse(a.isResolved());
  }
  @SuppressWarnings("unchecked")
  private Set<Artifact> getFilteredArtifacts(
      String groupId, String artifactId, String type, String classifier)
      throws MojoExecutionException {
    Set<Artifact> projectArtifacts = new LinkedHashSet<Artifact>();

    projectArtifacts.addAll(project.getAttachedArtifacts());
    projectArtifacts.addAll(project.getArtifacts());

    FilterArtifacts filter = getFilters(groupId, artifactId, type, classifier);

    return filtterArtifacts(projectArtifacts, filter);
  }
Example #14
0
  /**
   * Gets all dependency jars of the project specified by 'project' parameter from the local mirror
   * and copies them under targetFolder
   *
   * @param targetFolder The folder which the dependency jars will be copied to
   */
  public static void copyArtifactsTo(MavenProject project, String targetFolder)
      throws MojoExecutionException {
    File targetFolderFile = new File(targetFolder);
    for (Iterator it = project.getArtifacts().iterator(); it.hasNext(); ) {
      Artifact artifact = (Artifact) it.next();

      File f = artifact.getFile();

      LOG.info("Artifact {} found.", f.getAbsolutePath());

      if (f == null) {
        throw new MojoExecutionException(
            "Cannot locate artifact file of " + artifact.getArtifactId());
      }

      // Check already existing artifacts and replace them if they are of a lower version
      try {

        List<String> existing =
            FileUtils.getFileNames(
                targetFolderFile, artifact.getArtifactId() + "-*.jar", null, false);

        if (existing.size() != 0) {
          String version =
              existing.get(0).split("(" + artifact.getArtifactId() + "-)")[1].split("(.jar)")[0];
          DefaultArtifactVersion existingVersion = new DefaultArtifactVersion(version);
          DefaultArtifactVersion artifactVersion =
              new DefaultArtifactVersion(artifact.getVersion());

          if (existingVersion.compareTo(artifactVersion) < 0) { // Remove existing version
            FileUtils.forceDelete(targetFolder + existing.get(0));
          } else {
            LOG.info(
                "Artifact "
                    + artifact.getArtifactId()
                    + " with the same or higher "
                    + "version already exists in lib folder, skipping copy");
            continue;
          }
        }

        LOG.info("Copying {} to {}", f.getName(), targetFolder);
        FileUtils.copyFileToDirectory(f.getAbsolutePath(), targetFolder);
      } catch (IOException e) {
        throw new MojoExecutionException(
            "Error while copying artifact file of " + artifact.getArtifactId(), e);
      }
    }
  }
  public void testWorkspaceDependencyVersionRange() throws Exception {
    IProject[] projects =
        importProjects(
            "projects/versionrange",
            new String[] {"p001/pom.xml", "p002/pom.xml"},
            new ResolverConfiguration());
    waitForJobsToComplete();

    IMavenProjectFacade f1 = manager.create(projects[0], monitor);
    MavenProject p1 = f1.getMavenProject(monitor);
    ArrayList<Artifact> a1 = new ArrayList<Artifact>(p1.getArtifacts());
    assertEquals(1, a1.size());

    assertEquals(projects[1].getLocation().append("target/classes").toFile(), a1.get(0).getFile());
  }
Example #16
0
 @SuppressWarnings("unchecked")
 private ArrayList<String> getClasspath() throws MojoExecutionException {
   ArrayList<String> artifacts = new ArrayList<String>();
   try {
     artifacts.add(classesDirectory.getCanonicalPath());
     for (Artifact artifact : (Set<Artifact>) project.getArtifacts()) {
       File file = artifact.getFile();
       getLog().debug("Including: " + file);
       artifacts.add(file.getCanonicalPath());
     }
   } catch (IOException e) {
     throw new MojoExecutionException("Could not determine project classath.", e);
   }
   return artifacts;
 }
  /** @return */
  private List<File> getDependencyFiles() {
    List<File> dependencyFiles = new ArrayList<File>();

    for (Iterator<Artifact> iter = project.getArtifacts().iterator(); iter.hasNext(); ) {
      Artifact artifact = (Artifact) iter.next();

      if (((!Artifact.SCOPE_PROVIDED.equals(artifact.getScope()))
              && (!Artifact.SCOPE_TEST.equals(artifact.getScope())))
          || (useTestScope && Artifact.SCOPE_TEST.equals(artifact.getScope()))) {
        dependencyFiles.add(artifact.getFile());
        getLog().debug("Adding artifact " + artifact.getFile().getName() + " for WEB-INF/lib ");
      }
    }

    return dependencyFiles;
  }
  public void execute() throws MojoExecutionException, MojoFailureException {
    File testDir = new File(project.getBuild().getTestOutputDirectory(), "test-dependencies");
    testDir.mkdirs();

    try {
      Writer w = new OutputStreamWriter(new FileOutputStream(new File(testDir, "index")), "UTF-8");

      for (Artifact a : (Set<Artifact>) project.getArtifacts()) {
        if (!HpiUtil.isPlugin(a)) continue;

        getLog().debug("Copying " + a.getId() + " as a test dependency");
        File dst = new File(testDir, a.getArtifactId() + ".hpi");
        FileUtils.copyFile(a.getFile(), dst);
        w.write(a.getArtifactId() + "\n");
      }

      w.close();
    } catch (IOException e) {
      throw new MojoExecutionException("Failed to copy dependency plugins", e);
    }
  }
  public void testEnvironmentVariablesConsidered() throws Exception {
    String tmpDir = System.getenv("TEMP");
    assertTrue("This test requires the environment variable TEMP to be set", tmpDir != null);

    File systemJar = new File("projects/MNGECLIPSE-581/mngeclipse-581.jar");
    File tempJar = new File(tmpDir, "mngeclipse-581.jar");
    FileUtils.copyFile(systemJar, tempJar);
    tempJar.deleteOnExit();

    IProject[] projects =
        importProjects(
            "projects/MNGECLIPSE-581", new String[] {"pom.xml"}, new ResolverConfiguration());
    assertEquals(1, projects.length);
    assertNotNull(projects[0]);
    IMavenProjectFacade facade = manager.getProject(projects[0]);
    assertNotNull(facade);
    MavenProject project = facade.getMavenProject();
    assertNotNull(project);
    File file = project.getArtifacts().iterator().next().getFile();
    assertTrue(file.toString(), file.isFile());
  }
 protected ClassLoader getProjectClassloader() throws MojoExecutionException {
   try {
     if (projectClassloader == null) {
       Set<Artifact> artifacts = project.getArtifacts();
       List<URL> urls = new ArrayList<URL>();
       for (Artifact artifact : artifacts) {
         urls.add(artifact.getFile().toURI().toURL());
       }
       if (getLog().isDebugEnabled()) {
         for (URL url : urls) {
           getLog().debug("Project dependency URL: " + url.toString());
         }
       }
       projectClassloader =
           new URLClassLoader(urls.toArray(new URL[0]), this.getClass().getClassLoader());
     }
     return projectClassloader;
   } catch (MalformedURLException e) {
     throw new MojoExecutionException(e.getLocalizedMessage(), e);
   }
 }
  /**
   * @return
   * @throws MojoExecutionException
   */
  public List<String> getProvidedJars() throws MojoExecutionException {
    // if we are configured to include the provided dependencies on the plugin's classpath
    // (which mimics being on jetty's classpath vs being on the webapp's classpath), we first
    // try and filter out ones that will clash with jars that are plugin dependencies, then
    // create a new classloader that we setup in the parent chain.
    if (useProvidedScope) {

      List<String> provided = new ArrayList<String>();
      for (Iterator<Artifact> iter = project.getArtifacts().iterator(); iter.hasNext(); ) {
        Artifact artifact = iter.next();
        if (Artifact.SCOPE_PROVIDED.equals(artifact.getScope()) && !isPluginArtifact(artifact)) {
          provided.add(artifact.getFile().getAbsolutePath());
          if (getLog().isDebugEnabled()) {
            getLog().debug("Adding provided artifact: " + artifact);
          }
        }
      }
      return provided;

    } else return null;
  }
Example #22
0
  private void addMissingArtifactProblemInfos(
      MavenProject mavenProject, SourceLocation location, List<MavenProblemInfo> knownProblems) {
    Set<Artifact> artifacts = mavenProject.getArtifacts();
    all_artifacts_loop:
    for (Artifact mavenArtifact : artifacts) {
      if (!mavenArtifact.isResolved()) {
        org.eclipse.aether.artifact.Artifact artifact = RepositoryUtils.toArtifact(mavenArtifact);
        for (MavenProblemInfo problem : knownProblems) {
          if (problem instanceof ArtifactNotFoundProblemInfo) {
            ArtifactNotFoundProblemInfo artifactNotFoundProblemInfo =
                (ArtifactNotFoundProblemInfo) problem;
            if (equals(artifactNotFoundProblemInfo.getArtifact(), artifact)) {
              continue all_artifacts_loop;
            }
          }
        }

        knownProblems.add(
            new ArtifactNotFoundProblemInfo(artifact, mavenConfiguration.isOffline(), location));
      }
    }
  }
  protected List<IMavenProjectFacade> getWorkspaceDependencies(
      IProject project, MavenProject mavenProject) {
    Set<IProject> projects = new HashSet<IProject>();
    List<IMavenProjectFacade> dependencies = new ArrayList<IMavenProjectFacade>();
    Set<Artifact> artifacts = mavenProject.getArtifacts();
    for (Artifact artifact : artifacts) {
      IMavenProjectFacade dependency =
          projectManager.getMavenProject(
              artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion());

      if ((Artifact.SCOPE_COMPILE.equals(artifact.getScope())
              || Artifact.SCOPE_RUNTIME.equals(
                  artifact.getScope())) // MNGECLIPSE-1578 Runtime dependencies should be deployed
          && dependency != null
          && !dependency.getProject().equals(project)
          && dependency.getFullPath(artifact.getFile()) != null
          && projects.add(dependency.getProject())) {
        dependencies.add(dependency);
      }
    }
    return dependencies;
  }
  @NotNull
  private MavenServerExecutionResult createExecutionResult(
      File file, MavenExecutionResult result, DependencyNode rootNode) throws RemoteException {
    Collection<MavenProjectProblem> problems = MavenProjectProblem.createProblemsList();
    THashSet<MavenId> unresolvedArtifacts = new THashSet<MavenId>();

    validate(file, result.getExceptions(), problems, unresolvedArtifacts);

    MavenProject mavenProject = result.getMavenProject();
    if (mavenProject == null)
      return new MavenServerExecutionResult(null, problems, unresolvedArtifacts);

    MavenModel model =
        MavenModelConverter.convertModel(
            mavenProject.getModel(),
            mavenProject.getCompileSourceRoots(),
            mavenProject.getTestCompileSourceRoots(),
            mavenProject.getArtifacts(),
            (rootNode == null ? Collections.emptyList() : rootNode.getChildren()),
            mavenProject.getExtensionArtifacts(),
            getLocalRepositoryFile());

    RemoteNativeMavenProjectHolder holder = new RemoteNativeMavenProjectHolder(mavenProject);
    try {
      UnicastRemoteObject.exportObject(holder, 0);
    } catch (RemoteException e) {
      throw new RuntimeException(e);
    }

    Collection<String> activatedProfiles = collectActivatedProfiles(mavenProject);

    MavenServerExecutionResult.ProjectData data =
        new MavenServerExecutionResult.ProjectData(
            model,
            MavenModelConverter.convertToMap(mavenProject.getModel()),
            holder,
            activatedProfiles);
    return new MavenServerExecutionResult(data, problems, unresolvedArtifacts);
  }
  protected Map<String, Artifact> findAllModuleArtifacts(boolean minVersionWins) {
    Map<String, Artifact> result = new HashMap<String, Artifact>();

    Set<?> artifacts = project.getArtifacts();
    for (Iterator<?> iter = artifacts.iterator(); iter.hasNext(); ) {
      Artifact artifact = (Artifact) iter.next();
      if ("zip".equals(artifact.getType())) {
        if ("module".equals(artifact.getClassifier())
            || "module-min".equals(artifact.getClassifier())) {
          String moduleName = artifact.getArtifactId();
          if (moduleName.startsWith("play-")) {
            moduleName = moduleName.substring("play-".length());
          }

          if ("module".equals(artifact.getClassifier())) {
            if (!minVersionWins || result.get(moduleName) == null) {
              result.put(moduleName, artifact);
              // System.out.println("added module: " + artifact.getGroupId() + ":" +
              // artifact.getArtifactId());
            }
          } else
          // "module-min"
          {
            if (minVersionWins || result.get(moduleName) == null) {
              result.put(moduleName, artifact);
              // System.out.println("added module-min: " + artifact.getGroupId() + ":" +
              // artifact.getArtifactId());
            }
          }
        }
      } else if ("play".equals(artifact.getType())) {
        String moduleName = artifact.getArtifactId();
        result.put(moduleName, artifact);
      }
    }
    return result;
  }
Example #26
0
  /**
   * Add any relevant project dependencies to the classpath. Takes includeProjectDependencies into
   * consideration.
   *
   * @param path classpath of {@link java.net.URL} objects
   * @throws MojoExecutionException
   */
  private void addRelevantProjectDependenciesToClasspath(Set<URL> path)
      throws MojoExecutionException {
    if (this.includeProjectDependencies) {
      try {
        getLog().debug("Project Dependencies will be included.");

        URL mainClasses = new File(project.getBuild().getOutputDirectory()).toURI().toURL();
        getLog().debug("Adding to classpath : " + mainClasses);
        path.add(mainClasses);

        Set<Artifact> dependencies = CastUtils.cast(project.getArtifacts());

        // system scope dependencies are not returned by maven 2.0. See
        // MEXEC-17
        dependencies.addAll(getAllNonTestScopedDependencies());

        Iterator<Artifact> iter = dependencies.iterator();
        while (iter.hasNext()) {
          Artifact classPathElement = iter.next();
          getLog()
              .debug(
                  "Adding project dependency artifact: "
                      + classPathElement.getArtifactId()
                      + " to classpath");
          File file = classPathElement.getFile();
          if (file != null) {
            path.add(file.toURI().toURL());
          }
        }

      } catch (MalformedURLException e) {
        throw new MojoExecutionException("Error during setting up classpath", e);
      }
    } else {
      getLog().debug("Project Dependencies will be excluded.");
    }
  }
  private void addDependencies(Archiver archiver) throws ArchiverException, MojoExecutionException {

    Log log = getLog();
    AndArtifactFilter filter = new AndArtifactFilter();
    filter.add(new ScopeArtifactFilter(Artifact.SCOPE_RUNTIME));
    filter.add(
        new ArtifactFilter() {
          public boolean include(Artifact artifact) {
            return !artifact.isOptional();
          }
        });
    filter.add(new TypeArtifactFilter("jar"));
    filter.add(buildSynapseRuntimeArtifactFilter());
    for (Artifact artifact : filterArtifacts((Set<Artifact>) project.getArtifacts(), filter)) {
      String targetFileName =
          artifact.getArtifactId()
              + "-"
              + artifact.getVersion()
              + "."
              + artifact.getArtifactHandler().getExtension();
      log.info("Adding " + targetFileName + " (scope " + artifact.getScope() + ")");
      archiver.addFile(artifact.getFile(), "lib/" + targetFileName);
    }
  }
  /** Iterate through dependencies, find those specified in the whitelist */
  private Set<Artifact> findThriftDependencies(Set<String> whitelist) throws IOException {
    Set<Artifact> thriftDependencies = new HashSet<Artifact>();

    Set<Artifact> deps = new HashSet<Artifact>();
    deps.addAll(project.getArtifacts());
    deps.addAll(project.getDependencyArtifacts());

    Map<String, Artifact> depsMap = new HashMap<String, Artifact>();
    for (Artifact dep : deps) {
      depsMap.put(dep.getId(), dep);
    }

    for (Artifact artifact : deps) {
      // This artifact is on the whitelist directly.
      if (whitelist.contains(artifact.getArtifactId())) {
        thriftDependencies.add(artifact);

        // Check if this artifact is being pulled in by an idl jar that's been whitelisted
      } else {
        List<String> depTrail = artifact.getDependencyTrail();
        // depTrail can be null sometimes, which seems like a maven bug
        if (depTrail != null) {
          for (String name : depTrail) {
            Artifact dep = depsMap.get(name);
            if (dep != null
                && "idl".equals(dep.getClassifier())
                && whitelist.contains(dep.getArtifactId())) {
              thriftDependencies.add(artifact);
              break;
            }
          }
        }
      }
    }
    return thriftDependencies;
  }
 /**
  * Provides transitive dependency artifacts only defined types based on {@code types} argument or
  * all types if {@code types} argument is empty
  *
  * @param filteredScopes List of scopes to be removed (ie filtered out).
  * @param types Zero or more artifact types to be selected.
  * @return a {@code List} of all project dependencies. Never {@code null}. This should maintain
  *     dependency order to comply with library project resource precedence.
  */
 protected Set<Artifact> getTransitiveDependencyArtifacts(
     List<String> filteredScopes, String... types) {
   return getArtifactResolverHelper()
       .getFilteredArtifacts(filteredScopes, project.getArtifacts(), types);
 }
 /**
  * @return a {@code List} of all project dependencies. Never {@code null}. This excludes artifacts
  *     of the {@code EXCLUDED_DEPENDENCY_SCOPES} scopes. And This should maintain dependency order
  *     to comply with library project resource precedence.
  */
 protected Set<Artifact> getAllRelevantDependencyArtifacts() {
   final Set<Artifact> allArtifacts = (Set<Artifact>) project.getArtifacts();
   final Set<Artifact> results = filterOutIrrelevantArtifacts(allArtifacts);
   return results;
 }