private List<URL> generateExecutionClasspath(
      Set<Artifact> resolvedArtifacts, String... excludeGroups) throws MojoExecutionException {
    /*
     * Convert each resolved artifact into a URL/classpath element.
     */
    final ArrayList<URL> classpath = new ArrayList<URL>();

    final List<String> excludes = Arrays.asList(excludeGroups);

    try {

      for (Artifact resolvedArtifact : resolvedArtifacts) {
        if (excludes.contains(resolvedArtifact.getGroupId())) continue;
        final File file = resolvedArtifact.getFile();
        //        System.out.println("artifact " + resolvedArtifact.toString());
        if (file != null) {
          if (artifactIdsToInsertAtStartOfClasspath.contains(resolvedArtifact.getArtifactId())) {
            getLog().info("adding at the start" + file.getAbsolutePath());
            // a patch? grails is full of them, insert it at the start
            classpath.add(0, file.toURI().toURL());
          } else { // insert it at the end
            classpath.add(file.toURI().toURL());
          }
        }
      }
    } catch (MalformedURLException murle) {
      throw new MojoExecutionException("Unable to find files", murle);
    }

    return classpath;
  }
  String getBundleClasspath() throws MojoExecutionException {
    StringBuffer sb = new StringBuffer();

    File outputDirectory = new File(project.getBuild().getOutputDirectory());
    if (outputDirectory.exists()) {
      if (classifier != null) {
        for (Iterator i = project.getAttachedArtifacts().iterator(); i.hasNext(); ) {
          Artifact a = (Artifact) i.next();
          if (classifier.equals(a.getClassifier())) {
            sb.append(jars + "/" + a.getFile().getName());
          }
        }
      } else if (projectJar != null) {
        sb.append(jars + "/" + projectJar);
      }
    }

    if (bundleClasspath != null) {
      for (int i = 0; i < bundleClasspath.length; i++) {
        if (sb.length() > 0) sb.append(',');
        sb.append(bundleClasspath[i]);
      }
    }
    for (Iterator i = getIncludedArtifacts().iterator(); i.hasNext(); ) {
      Artifact a = (Artifact) i.next();
      if (sb.length() > 0) sb.append(',');
      sb.append(jars + "/" + a.getFile().getName());
    }
    return sb.toString();
  }
  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);
  }
예제 #4
0
  private void copyNativeLibraryArtifactFileToDirectory(
      Artifact artifact, File destinationDirectory, String ndkArchitecture)
      throws MojoExecutionException {

    final File artifactFile = getArtifactResolverHelper().resolveArtifactToFile(artifact);
    try {
      final String artifactId = artifact.getArtifactId();
      String filename =
          artifactId.startsWith("lib") ? artifactId + ".so" : "lib" + artifactId + ".so";
      if (ndkFinalLibraryName != null
          && artifact.getFile().getName().startsWith("lib" + ndkFinalLibraryName)) {
        // The artifact looks like one we built with the NDK in this module
        // preserve the name from the NDK build
        filename = artifact.getFile().getName();
      }

      final File finalDestinationDirectory =
          getFinalDestinationDirectoryFor(artifact, destinationDirectory, ndkArchitecture);
      final File file = new File(finalDestinationDirectory, filename);
      getLog()
          .debug(
              "Copying native dependency "
                  + artifactId
                  + " ("
                  + artifact.getGroupId()
                  + ") to "
                  + file);
      FileUtils.copyFile(artifactFile, file);
    } catch (Exception e) {
      throw new MojoExecutionException("Could not copy native dependency.", e);
    }
  }
 private void createClasspathJarFile(File lib) throws Exception {
   getLog().info("[WarSync] Create warsync-classpath.jar in " + lib.getAbsolutePath());
   List<String> jarFiles = new ArrayList<String>();
   if (artifacts != null && !artifacts.isEmpty()) {
     for (Artifact artifact : artifacts) {
       if (getLog().isDebugEnabled()) {
         getLog().debug("[WarSync] Found dependency: " + artifact.getId());
       }
       if (isLib(artifact)) {
         if (getLog().isDebugEnabled()) {
           getLog()
               .debug(
                   "[WarSync] Add "
                       + artifact.getFile().toURI().getPath()
                       + " to Class-Path entry of MANIFEST.MF");
         }
         jarFiles.add(artifact.getFile().toURI().getPath());
       }
     }
   }
   JarArchiver jar = new JarArchiver();
   jar.setDestFile(new File(lib, "warsync-classpath.jar"));
   Manifest manifest = Manifest.getDefaultManifest();
   manifest.addConfiguredAttribute(new Manifest.Attribute("Created-By", "maven-warsync-plugin"));
   manifest.addConfiguredAttribute(
       new Manifest.Attribute("Built-By", System.getProperty("user.name")));
   manifest.addConfiguredAttribute(
       new Manifest.Attribute("Build-Jdk", System.getProperty("java.version")));
   if (!jarFiles.isEmpty()) {
     manifest.addConfiguredAttribute(
         new Manifest.Attribute("Class-Path", StringUtils.join(jarFiles.iterator(), " ")));
   }
   jar.addConfiguredManifest(manifest);
   jar.createArchive();
 }
  @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;
  }
예제 #7
0
  /** @return */
  private List<File> getDependencyFiles() {
    List<File> dependencyFiles = new ArrayList<File>();
    for (Iterator<Artifact> iter = projectArtifacts.iterator(); iter.hasNext(); ) {
      Artifact artifact = (Artifact) iter.next();

      // Include runtime and compile time libraries, and possibly test libs too
      if (artifact.getType().equals("war")) {
        continue;
      }

      if (Artifact.SCOPE_PROVIDED.equals(artifact.getScope()))
        continue; // never add dependencies of scope=provided to the webapp's classpath (see also
                  // <useProvidedScope> param)

      if (Artifact.SCOPE_TEST.equals(artifact.getScope()) && !useTestScope)
        continue; // only add dependencies of scope=test if explicitly required

      dependencyFiles.add(artifact.getFile());
      getLog()
          .debug(
              "Adding artifact "
                  + artifact.getFile().getName()
                  + " with scope "
                  + artifact.getScope()
                  + " for WEB-INF/lib ");
    }

    return dependencyFiles;
  }
  /**
   * Main entry into mojo. This method gets the dependencies and iterates through each one passing
   * it to DependencyUtil.unpackFile().
   *
   * @throws MojoExecutionException with a message if an error occurs.
   * @see #getDependencies
   * @see DependencyUtil#unpackFile(Artifact, File, File, ArchiverManager, Log)
   */
  public void execute() throws MojoExecutionException {
    DependencyStatusSets dss = getDependencySets(this.failOnMissingClassifierArtifact);
    Set artifacts = dss.getResolvedDependencies();

    for (Iterator i = artifacts.iterator(); i.hasNext(); ) {
      Artifact artifact = (Artifact) i.next();
      File destDir;
      destDir =
          DependencyUtil.getFormattedOutputDirectory(
              useSubDirectoryPerType,
              useSubDirectoryPerArtifact,
              useRepositoryLayout,
              stripVersion,
              outputDirectory,
              artifact);
      unpack(artifact.getFile(), destDir, getIncludes(), getExcludes());
      DefaultFileMarkerHandler handler =
          new DefaultFileMarkerHandler(artifact, this.markersDirectory);
      handler.setMarker();
    }

    artifacts = dss.getSkippedDependencies();
    for (Iterator i = artifacts.iterator(); i.hasNext(); ) {
      Artifact artifact = (Artifact) i.next();
      getLog().info(artifact.getFile().getName() + " already exists in destination.");
    }
  }
  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;
  }
  /**
   * @return
   * @throws Exception
   */
  public String getClassPath() throws Exception {
    StringBuilder classPath = new StringBuilder();
    for (Object obj : pluginArtifacts) {
      Artifact artifact = (Artifact) obj;
      if ("jar".equals(artifact.getType())) {
        if (classPath.length() > 0) {
          classPath.append(File.pathSeparator);
        }
        classPath.append(artifact.getFile().getAbsolutePath());
      }
    }

    // Any jars that we need from the plugin environment (like the ones containing Starter class)
    Set<Artifact> extraJars = getExtraJars();
    for (Artifact a : extraJars) {
      classPath.append(File.pathSeparator);
      classPath.append(a.getFile().getAbsolutePath());
    }

    // Any jars that we need from the project's dependencies because we're useProvided
    List<String> providedJars = getProvidedJars();
    if (providedJars != null && !providedJars.isEmpty()) {
      for (String jar : providedJars) {
        classPath.append(File.pathSeparator);
        classPath.append(jar);
        if (getLog().isDebugEnabled()) getLog().debug("Adding provided jar: " + jar);
      }
    }

    return classPath.toString();
  }
예제 #11
0
  /**
   * 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;
  }
  public void test005_snapshotAvailableFromLocalRepoAndWorkspace() throws Exception {
    IProject p1 = createExisting("t005-p3");
    waitForJobsToComplete();

    {
      IMavenProjectFacade f = manager.create(p1, monitor);
      Set<Artifact> artifacts = getMavenProjectArtifacts(f);
      assertEquals(1, artifacts.size());
      Artifact a = artifacts.iterator().next();
      assertEquals(true, a.isResolved());
      // assertTrue(a.getFile().getAbsolutePath().startsWith(repo.getAbsolutePath()));
      assertStartWith(repo.getAbsolutePath(), a.getFile().getAbsolutePath());
    }

    IProject p2 = createExisting("t005-p4");
    waitForJobsToComplete();

    {
      IMavenProjectFacade f = manager.create(p1, monitor);
      Set<Artifact> artifacts = getMavenProjectArtifacts(f);
      assertEquals(1, artifacts.size());
      Artifact a = artifacts.iterator().next();
      assertEquals(true, a.isResolved());
      assertEquals(p2.getFile(IMavenConstants.POM_FILE_NAME).getLocation().toFile(), a.getFile());
    }
  }
예제 #13
0
  /**
   * Resolve source artifacts and download them if <code>downloadSources</code> is <code>true</code>
   * . Source and javadocs artifacts will be attached to the <code>IdeDependency</code>
   *
   * @param deps resolved dependencies
   */
  private void resolveSourceArtifacts(IdeDependency[] deps) {

    ArtifactRepository localRepository = getLocalRepository();
    ArtifactResolver artifactResolver = getArtifactResolver();
    ArtifactFactory artifactFactory = getArtifactFactory();

    // if downloadSources is off, just check local repository for reporting missing jars
    List remoteRepos =
        getDownloadSources() ? getRemoteArtifactRepositories() : Collections.EMPTY_LIST;

    for (int j = 0; j < deps.length; j++) {
      IdeDependency dependency = deps[j];

      if (dependency.isReferencedProject() || dependency.isSystemScoped()) {
        // source artifact not needed
        continue;
      }

      // source artifact: use the "sources" classifier added by the source plugin
      Artifact sourceArtifact =
          IdeUtils.resolveArtifactWithClassifier(
              dependency.getGroupId(),
              dependency.getArtifactId(),
              dependency.getVersion(),
              "sources",
              localRepository,
              artifactResolver, //$NON-NLS-1$
              artifactFactory,
              remoteRepos,
              getLog());

      if (sourceArtifact.isResolved()) {
        dependency.setSourceAttachment(sourceArtifact.getFile());
      } else {
        // try using a plain javadoc jar if the source jar is not available
        Artifact javadocArtifact =
            IdeUtils.resolveArtifactWithClassifier(
                dependency.getGroupId(),
                dependency.getArtifactId(),
                dependency.getVersion(),
                "javadoc",
                localRepository,
                artifactResolver, //$NON-NLS-1$
                artifactFactory,
                remoteRepos,
                getLog());

        if (javadocArtifact.isResolved()) {
          dependency.setJavadocAttachment(javadocArtifact.getFile());
        }

        // @todo also report deps without a source attachment but with a javadoc one?
        missingSourceDependencies.add(dependency);
      }
    }
  }
예제 #14
0
 /**
  * Returns a map from classifiers to artifact files of the given project. The classifier <code>
  * null</code> is mapped to the project's main artifact.
  */
 private static Map<String, File> getAllProjectArtifacts(MavenProject project) {
   Map<String, File> artifacts = new HashMap<String, File>();
   Artifact mainArtifact = project.getArtifact();
   if (mainArtifact != null) {
     artifacts.put(null, mainArtifact.getFile());
   }
   for (Artifact attachedArtifact : project.getAttachedArtifacts()) {
     artifacts.put(attachedArtifact.getClassifier(), attachedArtifact.getFile());
   }
   return artifacts;
 }
 /**
  * @param artifactKey
  * @return
  * @throws ArtifactNotFoundException
  */
 private FileResource resolveFile(String artifactKey) throws ArtifactNotFoundException {
   ArtifactDescriptor ad = new ArtifactDescriptor(artifactKey);
   if (classifier != null) {
     ad.classifier = classifier;
   }
   Artifact artifact = ad.getArtifact();
   MavenClientFactory.getInstance().resolve(artifact);
   FileResource fr = new FileResource(artifact.getFile());
   fr.setBaseDir(artifact.getFile().getParentFile());
   return fr;
 }
 private void addDependencies(List<URL> urls)
     throws MalformedURLException, MojoExecutionException {
   FilterArtifacts filters =
       this.useTestClasspath ? getFilters() : getFilters(new TestArtifactFilter());
   Set<Artifact> artifacts = filterDependencies(this.project.getArtifacts(), filters);
   for (Artifact artifact : artifacts) {
     if (artifact.getFile() != null) {
       urls.add(artifact.getFile().toURI().toURL());
     }
   }
 }
  /**
   * Converts a collection of Maven artifacts to files. For this method to function properly, the
   * artifacts MUST be resolved first.
   *
   * @param artifacts A collection of artifacts.
   * @return The list of files pointed to by the artifacts.
   */
  private List<File> artifactsToFiles(final Collection<Artifact> artifacts) {
    final List<File> files = new ArrayList<File>(artifacts.size());
    StringBuilder sb = new StringBuilder();
    for (Artifact artifact : artifacts) {
      sb.append("\natof " + artifact.getFile().getAbsolutePath());
      files.add(artifact.getFile());
    }

    if (logDependencies) getLog().info(sb.toString());

    return files;
  }
  /**
   * Resolve the artifacts represented by the given collection of JarResources and copy them to the
   * working directory if a newer copy of the file doesn't already exist there. Transitive
   * dependencies will also be retrieved.
   *
   * <p>Transitive dependencies are added to the list specified as parameter. TODO fix that.
   *
   * @throws MojoExecutionException
   */
  private void retrieveJarResources(List jarResources) throws MojoExecutionException {

    Set jarResourceArtifacts = new HashSet();

    try {
      // for each configured JarResource, create and resolve the corresponding artifact and
      // check it for the mainClass if specified
      for (Iterator itr = jarResources.iterator(); itr.hasNext(); ) {
        JarResource jarResource = (JarResource) itr.next();
        Artifact artifact = createArtifact(jarResource);
        getArtifactResolver().resolve(artifact, getRemoteRepositories(), getLocalRepository());
        jarResource.setArtifact(artifact);
        checkForMainClass(jarResource);
        jarResourceArtifacts.add(artifact);
      }

      if (!isExcludeTransitive()) {

        retrieveTransitiveDependencies(jarResourceArtifacts, jarResources);
      }

      // for each JarResource, copy its artifact to the lib directory if necessary
      for (Iterator itr = jarResources.iterator(); itr.hasNext(); ) {
        JarResource jarResource = (JarResource) itr.next();
        Artifact artifact = jarResource.getArtifact();
        boolean copied =
            copyJarAsUnprocessedToDirectoryIfNecessary(artifact.getFile(), getLibDirectory());

        if (copied) {
          String name = artifact.getFile().getName();
          if (getLog().isDebugEnabled()) {
            getLog().debug("Adding " + name + " to modifiedJnlpArtifacts list.");
          }
          getModifiedJnlpArtifacts().add(name.substring(0, name.lastIndexOf('.')));
        }

        if (jarResource.isOutputJarVersion()) {
          // Create and set a version-less href for this jarResource
          String hrefValue = buildHrefValue(artifact);
          jarResource.setHrefValue(hrefValue);
        }
      }

    } catch (ArtifactResolutionException e) {
      throw new MojoExecutionException("Unable to resolve an artifact", e);
    } catch (ArtifactNotFoundException e) {
      throw new MojoExecutionException("Unable to find an artifact", e);
    } catch (IOException e) {
      throw new MojoExecutionException("Unable to copy an artifact to the working directory", e);
    }
  }
  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());
    }
  }
 public void testWorkspaceResolutionApi() throws Exception {
   IProject[] projects =
       importProjects(
           "projects/simple-pom", new String[] {"pom.xml"}, new ResolverConfiguration());
   assertEquals(1, projects.length);
   assertNotNull(projects[0]);
   Artifact artifact =
       new DefaultArtifact(
           "org.eclipse.m2e.projects", "simple-pom", "1.0.0", null, "pom", "", null);
   artifact = manager.getWorkspaceLocalRepository().find(artifact);
   assertTrue(artifact.isResolved());
   assertNotNull(artifact.getFile());
   assertEquals(projects[0].getFile("pom.xml").getLocation().toFile(), artifact.getFile());
 }
  public void testUnpackOverWriteIfNewer() throws Exception {
    final long now = System.currentTimeMillis();

    setSilent(mojo, false);
    stubFactory.setCreateFiles(true);
    Artifact artifact = stubFactory.getSnapshotArtifact();
    assertTrue(artifact.getFile().setLastModified(now - 20000));

    ArtifactItem item = new ArtifactItem(artifact);

    List<ArtifactItem> list = Collections.singletonList(item);
    mojo.setArtifactItems(list);
    mojo.setOverWriteIfNewer(true);
    mojo.execute();
    File unpackedFile = getUnpackedFile(item);

    // round down to the last second
    long time = now;
    time = time - (time % 1000);
    // go back 10 more seconds for linux
    time -= 10000;
    // set to known value
    assertTrue(unpackedFile.setLastModified(time));
    // set source to be newer was 4s but test is brittle on MacOS if less than 5s
    assertTrue(artifact.getFile().setLastModified(time + 5000));

    // manually set markerfile (must match getMarkerFile in DefaultMarkerFileHandler)
    File marker =
        new File(mojo.getMarkersDirectory(), artifact.getId().replace(':', '-') + ".marker");
    assertTrue(marker.setLastModified(time));

    displayFile("unpackedFile", unpackedFile);
    displayFile("artifact    ", artifact.getFile());
    displayFile("marker      ", marker);
    System.out.println("mojo.execute()");
    mojo.execute();
    displayFile("unpackedFile", unpackedFile);
    displayFile("artifact    ", artifact.getFile());
    displayFile("marker      ", marker);
    System.out.println("marker.lastModified() = " + marker.lastModified());
    System.out.println("unpackedFile.lastModified() = " + unpackedFile.lastModified());
    assertTrue(
        "unpackedFile '"
            + unpackedFile
            + "' lastModified() == "
            + marker.lastModified()
            + ": should be different",
        marker.lastModified() != unpackedFile.lastModified());
  }
  /**
   * Returns the fully qualified path to an war file in the artifact list.
   *
   * @param inArtifacts - the set of artifacts
   * @param fileName - the file name we are looking for in the aftifact list
   * @return the fully qualified path to an war file in the artifact list.
   */
  public static File getWarFileName(final Set inArtifacts, String fileName) {
    if (inArtifacts == null || inArtifacts.isEmpty()) {
      throw new IllegalArgumentException("WAR not found in artifact list.");
    }

    final Iterator iter = inArtifacts.iterator();
    while (iter.hasNext()) {
      Artifact artifact = (Artifact) iter.next();

      if ("war".equals(artifact.getType()) && artifact.getFile().getName().contains(fileName)) {
        return artifact.getFile();
      }
    }
    throw new IllegalArgumentException("WAR not found in artifact list.");
  }
예제 #23
0
  /**
   * Add any relevant project dependencies to the classpath. Indirectly takes
   * includePluginDependencies and ExecutableDependency into consideration.
   *
   * @param path classpath of {@link java.net.URL} objects
   * @throws MojoExecutionException
   */
  private void addExtraPluginDependenciesToClasspath(Set<URL> path) throws MojoExecutionException {
    if (extraPluginDependencyArtifactId == null) {
      return;
    }

    try {
      Set<Artifact> artifacts = new HashSet<Artifact>(this.pluginDependencies);
      for (Artifact artifact : artifacts) {
        // must
        if (artifact.getArtifactId().equals(extraPluginDependencyArtifactId)) {
          getLog()
              .debug(
                  "Adding extra plugin dependency artifact: "
                      + artifact.getArtifactId()
                      + " to classpath");
          path.add(artifact.getFile().toURI().toURL());

          // add the transient dependencies of this artifact
          Set<Artifact> deps = resolveExecutableDependencies(artifact);
          for (Artifact dep : deps) {

            // we must skip org.apache.aries.blueprint.core:, otherwise we get duplicate blueprint
            // extenders
            if (dep.getArtifactId().equals("org.apache.aries.blueprint.core")) {
              getLog()
                  .debug(
                      "Skipping org.apache.aries.blueprint.core -> "
                          + dep.getGroupId()
                          + "/"
                          + dep.getArtifactId()
                          + "/"
                          + dep.getVersion());
              continue;
            }

            getLog()
                .debug(
                    "Adding extra plugin dependency artifact: "
                        + dep.getArtifactId()
                        + " to classpath");
            path.add(dep.getFile().toURI().toURL());
          }
        }
      }
    } catch (MalformedURLException e) {
      throw new MojoExecutionException("Error during setting up classpath", e);
    }
  }
  private void packageBundle() throws Exception {
    File jar = null;
    File outputDirectory = new File(project.getBuild().getOutputDirectory());
    if (projectJar != null && outputDirectory.exists()) {
      JarArchiver jarer = (JarArchiver) plexus.lookup(JarArchiver.ROLE, "jar");
      jar = new File(project.getBasedir(), jars + "/" + projectJar);
      jarer.setDestFile(jar);
      jarer.addDirectory(outputDirectory);
      jarer.createArchive();
    }

    // what is the right way of doing this?
    File file;
    //		if (PACKAGING_DIRECTORY_PLUGIN.equals(project.getPackaging())) {
    file = new File(buildTarget, project.getBuild().getFinalName() + ".jar");
    //		} else {
    //			file = new File(buildTarget, project.getArtifact().getArtifactId() + "-" +
    // project.getArtifact().getVersion());
    //		}

    JarArchiver archiver = (JarArchiver) plexus.lookup(JarArchiver.ROLE, "jar");
    archiver.setDestFile(file);

    File mfile = expandVersion(new File(project.getBasedir(), "META-INF/MANIFEST.MF"));

    archiver.setManifest(mfile);
    if (jar != null) {
      archiver.addFile(jar, jars + "/" + jar.getName());
    }
    for (Iterator i = getIncludedArtifacts().iterator(); i.hasNext(); ) {
      Artifact d = (Artifact) i.next();
      archiver.addFile(d.getFile(), jars + "/" + d.getFile().getName());
    }
    if (bundleClasspath != null) {
      for (int i = 0; i < bundleClasspath.length; i++) {
        archiver.addFile(new File(project.getBasedir(), bundleClasspath[i]), bundleClasspath[i]);
      }
    }
    archiver.createArchive();

    //    	if (PACKAGING_DIRECTORY_PLUGIN.equals(project.getArtifact().getType())) {
    project.getArtifact().setFile(file);
    //    	} else {
    //    		projectHelper.attachArtifact(project, TYPE_DIRECTORY_PLUGIN,
    // CLASSIFIER_DIRECTORY_PLUGIN, file);
    //    	}

  }
  /**
   * 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());
        }
      }
    }
  }
 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());
 }
  /**
   * Creates a string containing the classpath for running this Cassandra node as a CassandraDaemon
   * in a separate JVM process.
   *
   * <p>Uses the dependencies for the plugin to form the classpath, since the plugin is dependent
   * upon Cassandra.
   *
   * @return the classpath, as a colon-separated String.
   */
  private String getClasspath() {
    // Copied mostly from the Codehaus Cassandra plugin.

    StringBuilder cp = new StringBuilder();
    try {
      // We can't use StringUtils.join here since we need to add a '/' to
      // the end of directory entries - otherwise the jvm will ignore them.
      cp.append(new URL(mConfDir.toURI().toASCIIString()).toExternalForm());
      cp.append(CLASSPATH_SEPARATOR);

      for (Artifact artifact : mCassandraConfiguration.getPluginDependencies()) {
        getLog()
            .debug(
                "Adding plugin dependency artifact: "
                    + ArtifactUtils.versionlessKey(artifact)
                    + " to the classpath");
        // NOTE: if File points to a directory, this entry MUST end in '/'.
        cp.append(new URL(artifact.getFile().toURI().toASCIIString()).toExternalForm());
        cp.append(CLASSPATH_SEPARATOR);
      }
    } catch (MalformedURLException mue) {
      getLog().error("Could not create URL for conf dir " + mConfDir + "?!");
    }
    return cp.toString();
  }
  static String getDependenciesText(AbstractJnlpMojo config) {
    String dependenciesText = "";
    List artifacts = config.getPackagedJnlpArtifacts();
    if (artifacts.size() != 0) {
      StringBuffer buffer = new StringBuffer(100 * artifacts.size());
      buffer.append("\n");

      String jarLibPath = null;
      if (config.getLibPath() != null) {
        jarLibPath = config.getLibPath();
        jarLibPath =
            (jarLibPath != null && jarLibPath.trim().length() != 0) ? jarLibPath.trim() : null;
      }

      for (int i = 0; i < artifacts.size(); i++) {
        Artifact artifact = (Artifact) artifacts.get(i);
        buffer.append("<jar href=\"");
        if (jarLibPath != null) {
          buffer.append(jarLibPath).append("/");
        }
        buffer.append(artifact.getFile().getName()).append("\"");

        if (config.isOutputJarVersions()) {
          buffer.append(" version=\"").append(artifact.getVersion()).append("\"");
        }

        if (config.isArtifactWithMainClass(artifact)) {
          buffer.append(" main=\"true\"");
        }
        buffer.append("/>\n");
      }
      dependenciesText = buffer.toString();
    }
    return dependenciesText;
  }
  public void execute() throws MojoExecutionException {
    try {
      File out = new File(project.getBasedir(), jars);
      for (Iterator i = getIncludedArtifacts().iterator(); i.hasNext(); ) {
        Artifact a = (Artifact) i.next();
        FileUtils.copyFileToDirectory(a.getFile(), out);
      }

      if (packageSources) {
        packageSources(getIncludedArtifacts());
      }

      Manifest manifest = getManifest();
      File metaInf = new File(project.getBasedir(), "META-INF");
      metaInf.mkdirs();
      BufferedOutputStream os =
          new BufferedOutputStream(new FileOutputStream(new File(metaInf, "MANIFEST.MF")));
      manifest.write(os);
      os.close();

      //			packageBundle();
    } catch (Exception e) {
      throw new MojoExecutionException(e.getMessage(), e);
    }
  }
예제 #30
0
  protected void downloadRemoteDocs(List<WadlOption> effectiveOptions)
      throws MojoExecutionException {
    List<?> remoteRepos;
    try {
      remoteRepos =
          ProjectUtils.buildArtifactRepositories(
              repositories, artifactRepositoryFactory, mavenSession.getContainer());
    } catch (InvalidRepositoryException e) {
      throw new MojoExecutionException("Error build repositories for remote wsdls", e);
    }

    for (WadlOption option : effectiveOptions) {
      DocumentArtifact wsdlA = option.getWadlArtifact();
      if (wsdlA == null) {
        return;
      }
      Artifact wsdlArtifact =
          artifactFactory.createArtifact(
              wsdlA.getGroupId(),
              wsdlA.getArtifactId(),
              wsdlA.getVersion(),
              Artifact.SCOPE_COMPILE,
              wsdlA.getType());
      wsdlArtifact = resolveRemoteWsdlArtifact(remoteRepos, wsdlArtifact);
      if (wsdlArtifact != null) {
        String path = wsdlArtifact.getFile().getAbsolutePath();
        getLog().info("Resolved WSDL artifact to file " + path);
        option.setWadl(path);
      }
    }
  }