protected File[] getGwtUserJar() throws MojoExecutionException {
    checkGwtUserVersion();
    Artifact gwtUserArtifact = getArtifact("com.google.gwt", "gwt-user");

    Set<Artifact> artifacts = new HashSet<Artifact>();
    ArtifactResolutionResult result = null;
    try {
      result =
          resolver.resolveTransitively(
              artifacts,
              gwtUserArtifact,
              remoteRepositories,
              localRepository,
              artifactMetadataSource);
    } catch (ArtifactResolutionException e) {
      throw new MojoExecutionException("Failed to resolve artifact", e);
    } catch (ArtifactNotFoundException e) {
      throw new MojoExecutionException("Failed to resolve artifact", e);
    }

    Collection<Artifact> resolved = result.getArtifacts();
    int i = 0;
    // FIXME gwt 2.3.0 don't declare dependency on javax.validation, should be fix in next release
    File[] files = new File[resolved.size() + 1 + 2];
    files[i++] = gwtUserArtifact.getFile();
    for (Artifact artifact : resolved) {
      files[i++] = artifact.getFile();
    }

    files[i++] = getArtifact("javax.validation", "validation-api").getFile();
    files[i++] = getArtifact("javax.validation", "validation-api", "sources").getFile();
    return files;
  }
  /**
   * Detect if this artifact is already an osgi bundle. If it is, then we don't need to wrap it. The
   * best way to figure this out is to crack open the JAR and take a look at the manifest.
   *
   * @param artifact
   * @throws Exception
   */
  protected boolean isBundle(Artifact artifact) throws Exception {
    // Resolve the artifact.
    ArtifactResolutionRequest request = new ArtifactResolutionRequest().setArtifact(artifact);
    ArtifactResolutionResult result = repositorySystem.resolve(request);
    // If not found, then assume it's a reactor dependency and therefore should be a bundle.
    if (result.getArtifacts().isEmpty()) {
      getLog()
          .info(
              "Artifact "
                  + artifact.toString()
                  + " not found in local repository, assuming reactor dependency."); //$NON-NLS-1$
      // //$NON-NLS-2$
      return true;
    }
    artifact = result.getArtifacts().iterator().next();
    if (!artifact.getFile().isFile()) {
      throw new Exception(
          "Resolved artifact is not a file: "
              + artifact.getFile().getAbsolutePath()); // $NON-NLS-1$
    }

    // Crack open the dependency JAR, read the manifest, check for osgi attributes.
    JarFile jf = null;
    try {
      jf = new JarFile(artifact.getFile());
      Manifest manifest = jf.getManifest();
      if (manifest == null) {
        getLog()
            .info(
                "Artifact "
                    + artifact.toString()
                    + " missing a manifest!  Assuming not a bundle."); //$NON-NLS-1$ //$NON-NLS-2$
        return false;
      }
      Attributes attributes = manifest.getMainAttributes();
      if (attributes != null) {
        String value = attributes.getValue("Bundle-SymbolicName"); // $NON-NLS-1$
        if (value != null && value.trim().length() > 0) {
          return true;
        }
      }
    } finally {
      jf.close();
    }

    return false;
  }
  @SuppressWarnings("unchecked")
  private Collection<Artifact> getNonTransitivePlugins(Set<Artifact> projectArtifacts)
      throws MojoExecutionException {
    Collection<Artifact> deps = new LinkedHashSet<Artifact>();

    for (Artifact artifact : projectArtifacts) {
      Artifact pomArtifact =
          artifactFactory.createArtifact(
              artifact.getGroupId(),
              artifact.getArtifactId(),
              artifact.getVersion(),
              artifact.getClassifier(),
              "pom");
      Set<Artifact> result;
      try {
        MavenProject pomProject =
            mavenProjectBuilder.buildFromRepository(
                pomArtifact, remoteRepositories, localRepository);

        Set<Artifact> artifacts = pomProject.createArtifacts(artifactFactory, null, null);
        artifacts = filterOutSystemDependencies(artifacts);
        ArtifactResolutionResult arr =
            resolver.resolveTransitively(
                artifacts,
                pomArtifact,
                localRepository,
                remoteRepositories,
                artifactMetadataSource,
                null);
        result = arr.getArtifacts();
      } catch (Exception e) {
        throw new MojoExecutionException(
            "Failed to resolve non-transitive deps " + e.getMessage(), e);
      }

      LinkedHashSet<Artifact> plugins = new LinkedHashSet<Artifact>();
      plugins.addAll(filtterArtifacts(result, getFilters(null, null, "nexus-plugin", null)));
      plugins.addAll(filtterArtifacts(result, getFilters(null, null, "zip", "bundle")));

      plugins.addAll(getNonTransitivePlugins(plugins));

      if (!plugins.isEmpty()) {
        getLog()
            .debug(
                "Adding non-transitive dependencies for: "
                    + artifact
                    + " -\n"
                    + plugins.toString().replace(',', '\n'));
      }

      deps.addAll(plugins);
    }

    return deps;
  }
  Set<Artifact> getResolvedArtifactsFromUnresolvedDependencies(
      List<Dependency> unresolvedDependencies, boolean resolveTransitively)
      throws MojoExecutionException {
    final Set<Artifact> resolvedArtifacts = new HashSet<Artifact>();
    //    Artifact mojoArtifact = this.artifactFactory.createBuildArtifact(project.getGroupId(),
    // project.getArtifactId(), project.getVersion(), "pom");

    /*
     * Resolve each artifact.  This will get all transitive artifacts AND eliminate conflicts.
     */
    final Set<Artifact> unresolvedArtifacts;

    //    for (Dependency d : unresolvedDependencies)
    //      System.out.println("dependency: " + d.toString());

    try {
      unresolvedArtifacts =
          MavenMetadataSource.createArtifacts(
              this.artifactFactory, unresolvedDependencies, null, null, null);
      //      for (Artifact artifact : unresolvedArtifacts) {
      //        System.out.println("unresolved " + artifact.toString());
      //      }

      if (resolveTransitively) {
        ArtifactResolutionResult artifacts =
            artifactResolver.resolveTransitively(
                unresolvedArtifacts,
                project.getArtifact(),
                remoteRepositories,
                localRepository,
                artifactMetadataSource);
        resolvedArtifacts.addAll(artifacts.getArtifacts());
      } else {
        // resolve each artifact individually
        for (Artifact artifact : unresolvedArtifacts) {
          artifactResolver.resolve(artifact, remoteRepositories, localRepository);

          resolvedArtifacts.add(artifact);
        }
      }

    } catch (Exception e) {
      throw new MojoExecutionException("Unable to complete configuring the build settings", e);
    }

    for (Artifact artifact : resolvedArtifacts) {
      System.out.println("matched " + artifact.toString());
    }

    return resolvedArtifacts;
  }
  private void addArtifact(SurefireBooter surefireBooter, Artifact surefireArtifact)
      throws ArtifactNotFoundException, ArtifactResolutionException {
    ArtifactResolutionResult result = resolveArtifact(null, surefireArtifact);

    for (Iterator i = result.getArtifacts().iterator(); i.hasNext(); ) {
      Artifact artifact = (Artifact) i.next();

      getLog()
          .debug(
              "Adding to surefire booter test classpath: " + artifact.getFile().getAbsolutePath());

      surefireBooter.addSurefireBootClassPathUrl(artifact.getFile().getAbsolutePath());
    }
  }
  /** artifacts provided by bundles this project depends on */
  private Set<String> getImportedArtifactKeys() throws MojoExecutionException {
    HashSet<String> keys = new HashSet<String>();

    if (requireBundles != null) {
      for (int i = 0; i < requireBundles.length; i++) {
        MavenArtifactRef a = requireBundles[i];

        ArtifactResolutionResult result = resolve(a, true);

        for (Artifact b : result.getArtifacts()) {
          keys.add(getArtifactKey(b.getGroupId(), b.getArtifactId(), b.getClassifier()));
        }
      }
    }
    return keys;
  }
Exemple #7
0
  private Set<Artifact> resolveExecutableDependencies(Artifact executablePomArtifact)
      throws MojoExecutionException {

    Set<Artifact> executableDependencies;
    try {
      MavenProject executableProject =
          this.projectBuilder.buildFromRepository(
              executablePomArtifact, this.remoteRepositories, this.localRepository);

      // get all of the dependencies for the executable project
      List<Artifact> dependencies = CastUtils.cast(executableProject.getDependencies());

      // make Artifacts of all the dependencies
      Set<Artifact> dependencyArtifacts =
          CastUtils.cast(
              MavenMetadataSource.createArtifacts(
                  this.artifactFactory, dependencies, null, null, null));

      // not forgetting the Artifact of the project itself
      dependencyArtifacts.add(executableProject.getArtifact());

      // resolve all dependencies transitively to obtain a comprehensive
      // list of assemblies
      ArtifactResolutionResult result =
          artifactResolver.resolveTransitively(
              dependencyArtifacts,
              executablePomArtifact,
              Collections.EMPTY_MAP,
              this.localRepository,
              this.remoteRepositories,
              metadataSource,
              null,
              Collections.EMPTY_LIST);
      executableDependencies = CastUtils.cast(result.getArtifacts());

    } catch (Exception ex) {
      throw new MojoExecutionException(
          "Encountered problems resolving dependencies of the executable "
              + "in preparation for its execution.",
          ex);
    }

    return executableDependencies;
  }
  private void retrieveTransitiveDependencies(Set jarResourceArtifacts, List jarResources)
      throws ArtifactResolutionException, ArtifactNotFoundException {

    // this restricts to runtime and compile scope
    ScopeArtifactFilter artifactFilter = new ScopeArtifactFilter(Artifact.SCOPE_RUNTIME);

    ArtifactResolutionResult result =
        getArtifactResolver()
            .resolveTransitively(
                jarResourceArtifacts,
                getProject().getArtifact(),
                null, // managedVersions
                getLocalRepository(),
                getRemoteRepositories(),
                this.artifactMetadataSource,
                artifactFilter);

    Set transitiveResolvedArtifacts = result.getArtifacts();

    if (getLog().isDebugEnabled()) {
      getLog().debug("transitively resolved artifacts = " + transitiveResolvedArtifacts);
      getLog().debug("jarResources = " + jarResources);
      getLog().debug("jarResourceArtifacts = " + jarResourceArtifacts);
    }

    // for each transitive dependency, wrap it in a JarResource and add it to the collection of
    // existing jar resources
    for (Iterator itr = transitiveResolvedArtifacts.iterator(); itr.hasNext(); ) {
      Artifact resolvedArtifact = (Artifact) itr.next();

      // this whole double check is ugly as well as this method changing the input variable
      // we should really improve the way we collect the jarResources
      if (!jarResourceArtifacts.contains(resolvedArtifact)) {
        JarResource newJarResource = new JarResource(resolvedArtifact);
        if (!jarResources.contains(newJarResource)) {
          newJarResource.setOutputJarVersion(true);
          jarResources.add(newJarResource);
        }
      }
    }
  }
  private void addProvider(
      SurefireBooter surefireBooter, String provider, String version, Artifact filteredArtifact)
      throws ArtifactNotFoundException, ArtifactResolutionException {
    Artifact providerArtifact =
        artifactFactory.createDependencyArtifact(
            "org.apache.maven.surefire",
            provider,
            VersionRange.createFromVersion(version),
            "jar",
            null,
            Artifact.SCOPE_TEST);
    ArtifactResolutionResult result = resolveArtifact(filteredArtifact, providerArtifact);

    for (Iterator i = result.getArtifacts().iterator(); i.hasNext(); ) {
      Artifact artifact = (Artifact) i.next();

      getLog().debug("Adding to surefire test classpath: " + artifact.getFile().getAbsolutePath());

      surefireBooter.addSurefireClassPathUrl(artifact.getFile().getAbsolutePath());
    }
  }
 /**
  * Resolves the given artifact to a maven project.
  *
  * @param artifact
  * @throws Exception
  */
 protected MavenProject resolveProject(Artifact artifact) throws Exception {
   Artifact pomArtifact =
       repositorySystem.createArtifact(
           artifact.getGroupId(),
           artifact.getArtifactId(),
           artifact.getVersion(),
           "",
           "pom"); //$NON-NLS-1$ //$NON-NLS-2$
   ArtifactResolutionRequest request = new ArtifactResolutionRequest();
   request.setArtifact(pomArtifact);
   ArtifactResolutionResult resolved = repositorySystem.resolve(request);
   pomArtifact = resolved.getArtifacts().iterator().next();
   InputStream contentStream = null;
   MavenProject project = null;
   try {
     contentStream = new FileInputStream(pomArtifact.getFile());
     Model model = new MavenXpp3Reader().read(contentStream);
     project = new MavenProject(model);
   } finally {
     contentStream.close();
   }
   return project;
 }
Exemple #11
0
  protected void addMvn2CompatResults(
      MavenProject project,
      List<Exception> exceptions,
      List<ResolutionListener> listeners,
      ArtifactRepository localRepository,
      Collection<MavenExecutionResult> executionResults) {
    ArtifactResolutionRequest resolutionRequest = new ArtifactResolutionRequest();
    resolutionRequest.setArtifactDependencies(project.getDependencyArtifacts());
    resolutionRequest.setArtifact(project.getArtifact());
    resolutionRequest.setManagedVersionMap(project.getManagedVersionMap());
    resolutionRequest.setLocalRepository(localRepository);
    resolutionRequest.setRemoteRepositories(project.getRemoteArtifactRepositories());
    resolutionRequest.setListeners(listeners);

    resolutionRequest.setResolveRoot(false);
    resolutionRequest.setResolveTransitively(true);

    ArtifactResolver resolver = getComponent(ArtifactResolver.class);
    ArtifactResolutionResult result = resolver.resolve(resolutionRequest);

    project.setArtifacts(result.getArtifacts());
    executionResults.add(new MavenExecutionResult(project, exceptions));
  }
  /**
   * Create the transitive classpath.
   *
   * @return The dependent artifacts.
   * @throws MojoExecutionException If the classpath can't be found.
   */
  public Set transitivelyResolvePomDependencies() throws MojoExecutionException {
    // make Artifacts of all the dependencies
    Set dependencyArtifacts;
    try {
      dependencyArtifacts =
          MavenMetadataSource.createArtifacts(artifactFactory, dependencies, null, null, null);
    } catch (InvalidDependencyVersionException e) {
      throw new MojoExecutionException("Invalid dependency", e);
    }

    // not forgetting the Artifact of the project itself
    dependencyArtifacts.add(project.getArtifact());

    List listeners = Collections.EMPTY_LIST;

    // resolve all dependencies transitively to obtain a comprehensive list
    // of jars
    ArtifactResolutionResult result;
    try {
      result =
          artifactResolver.resolveTransitively(
              dependencyArtifacts,
              project.getArtifact(),
              Collections.EMPTY_MAP,
              localRepository,
              remoteRepositories,
              metadataSource,
              null,
              listeners);
    } catch (ArtifactResolutionException e) {
      throw new MojoExecutionException("Unable to resolve Artifact.", e);
    } catch (ArtifactNotFoundException e) {
      throw new MojoExecutionException("Unable to resolve Artifact.", e);
    }

    return result.getArtifacts();
  }
  /**
   * Returns the Set of APKLIB, AAR, APK (direct or transitive) dependencies of the supplied
   * artifact.
   *
   * <p>The project is searched until artifact is found and then the library dependencies are looked
   * for recursively.
   *
   * @param session MavenSession in which to resolve the artifacts.
   * @param repositorySystem RepositorySystem with which to resolve the artifacts.
   * @param artifact Artifact for whom to get the dependencies.
   * @return Set of APK, APKLIB and AAR dependencies.
   * @throws org.apache.maven.plugin.MojoExecutionException if it couldn't resolve any of the
   *     dependencies.
   */
  public Set<Artifact> getLibraryDependenciesFor(
      MavenSession session, RepositorySystem repositorySystem, Artifact artifact)
      throws MojoExecutionException {
    // Set a filter that should only return interesting artifacts.
    final ArtifactFilter filter =
        new ArtifactFilter() {
          @Override
          public boolean include(Artifact found) {
            final String type = found.getType();
            return (type.equals(APKLIB) || type.equals(AAR) || type.equals(APK));
          }
        };

    log.debug("MavenSession = " + session + "  repositorySystem = " + repositorySystem);

    final ArtifactResolutionRequest request = new ArtifactResolutionRequest();
    request.setArtifact(artifact);
    request.setResolveRoot(false); // Don't include source artifact in result
    request.setResolveTransitively(true); // Include direct plus transitive dependencies.
    request.setServers(session.getRequest().getServers());
    request.setMirrors(session.getRequest().getMirrors());
    request.setProxies(session.getRequest().getProxies());
    request.setLocalRepository(session.getLocalRepository());
    request.setRemoteRepositories(session.getCurrentProject().getRemoteArtifactRepositories());

    final ArtifactResolutionResult result = repositorySystem.resolve(request);

    final Set<Artifact> libraryDeps = new HashSet<Artifact>();
    for (final Artifact depArtifact : result.getArtifacts()) {
      if (filter.include(depArtifact)) {
        libraryDeps.add(depArtifact);
      }
    }

    return libraryDeps;
  }
  public ArtifactResolutionResult resolve(ArtifactResolutionRequest request) {
    Artifact rootArtifact = request.getArtifact();
    Set<Artifact> artifacts = request.getArtifactDependencies();
    Map<String, Artifact> managedVersions = request.getManagedVersionMap();
    List<ResolutionListener> listeners = request.getListeners();
    ArtifactFilter collectionFilter = request.getCollectionFilter();
    ArtifactFilter resolutionFilter = request.getResolutionFilter();
    RepositorySystemSession session = getSession(request.getLocalRepository());

    // TODO: hack because metadata isn't generated in m2e correctly and i want to run the maven i
    // have in the workspace
    if (source == null) {
      try {
        source = container.lookup(ArtifactMetadataSource.class);
      } catch (ComponentLookupException e) {
        // won't happen
      }
    }

    if (listeners == null) {
      listeners = new ArrayList<ResolutionListener>();

      if (logger.isDebugEnabled()) {
        listeners.add(new DebugResolutionListener(logger));
      }

      listeners.add(new WarningResolutionListener(logger));
    }

    ArtifactResolutionResult result = new ArtifactResolutionResult();

    // The root artifact may, or may not be resolved so we need to check before we attempt to
    // resolve.
    // This is often an artifact like a POM that is taken from disk and we already have hold of the
    // file reference. But this may be a Maven Plugin that we need to resolve from a remote
    // repository
    // as well as its dependencies.

    if (request.isResolveRoot() /* && rootArtifact.getFile() == null */) {
      try {
        resolve(rootArtifact, request.getRemoteRepositories(), session);
      } catch (ArtifactResolutionException e) {
        result.addErrorArtifactException(e);
        return result;
      } catch (ArtifactNotFoundException e) {
        result.addMissingArtifact(request.getArtifact());
        return result;
      }
    }

    ArtifactResolutionRequest collectionRequest = request;

    if (request.isResolveTransitively()) {
      MetadataResolutionRequest metadataRequest = new DefaultMetadataResolutionRequest(request);

      metadataRequest.setArtifact(rootArtifact);
      metadataRequest.setResolveManagedVersions(managedVersions == null);

      try {
        ResolutionGroup resolutionGroup = source.retrieve(metadataRequest);

        if (managedVersions == null) {
          managedVersions = resolutionGroup.getManagedVersions();
        }

        Set<Artifact> directArtifacts = resolutionGroup.getArtifacts();

        if (artifacts == null || artifacts.isEmpty()) {
          artifacts = directArtifacts;
        } else {
          List<Artifact> allArtifacts = new ArrayList<Artifact>();
          allArtifacts.addAll(artifacts);
          allArtifacts.addAll(directArtifacts);

          Map<String, Artifact> mergedArtifacts = new LinkedHashMap<String, Artifact>();
          for (Artifact artifact : allArtifacts) {
            String conflictId = artifact.getDependencyConflictId();
            if (!mergedArtifacts.containsKey(conflictId)) {
              mergedArtifacts.put(conflictId, artifact);
            }
          }

          artifacts = new LinkedHashSet<Artifact>(mergedArtifacts.values());
        }

        collectionRequest = new ArtifactResolutionRequest(request);
        collectionRequest.setServers(request.getServers());
        collectionRequest.setMirrors(request.getMirrors());
        collectionRequest.setProxies(request.getProxies());
        collectionRequest.setRemoteRepositories(resolutionGroup.getResolutionRepositories());
      } catch (ArtifactMetadataRetrievalException e) {
        ArtifactResolutionException are =
            new ArtifactResolutionException(
                "Unable to get dependency information for "
                    + rootArtifact.getId()
                    + ": "
                    + e.getMessage(),
                rootArtifact,
                metadataRequest.getRemoteRepositories(),
                e);
        result.addMetadataResolutionException(are);
        return result;
      }
    }

    if (artifacts == null || artifacts.isEmpty()) {
      if (request.isResolveRoot()) {
        result.addArtifact(rootArtifact);
      }
      return result;
    }

    // After the collection we will have the artifact object in the result but they will not be
    // resolved yet.
    result =
        artifactCollector.collect(
            artifacts,
            rootArtifact,
            managedVersions,
            collectionRequest,
            source,
            collectionFilter,
            listeners,
            null);

    // We have metadata retrieval problems, or there are cycles that have been detected
    // so we give this back to the calling code and let them deal with this information
    // appropriately.

    if (result.hasMetadataResolutionExceptions()
        || result.hasVersionRangeViolations()
        || result.hasCircularDependencyExceptions()) {
      return result;
    }

    if (result.getArtifactResolutionNodes() != null) {
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

      CountDownLatch latch = new CountDownLatch(result.getArtifactResolutionNodes().size());

      for (ResolutionNode node : result.getArtifactResolutionNodes()) {
        Artifact artifact = node.getArtifact();

        if (resolutionFilter == null || resolutionFilter.include(artifact)) {
          executor.execute(
              new ResolveTask(
                  classLoader, latch, artifact, session, node.getRemoteRepositories(), result));
        } else {
          latch.countDown();
        }
      }
      try {
        latch.await();
      } catch (InterruptedException e) {
        result.addErrorArtifactException(
            new ArtifactResolutionException("Resolution interrupted", rootArtifact, e));
      }
    }

    // We want to send the root artifact back in the result but we need to do this after the other
    // dependencies
    // have been resolved.
    if (request.isResolveRoot()) {
      // Add the root artifact (as the first artifact to retain logical order of class path!)
      Set<Artifact> allArtifacts = new LinkedHashSet<Artifact>();
      allArtifacts.add(rootArtifact);
      allArtifacts.addAll(result.getArtifacts());
      result.setArtifacts(allArtifacts);
    }

    return result;
  }