예제 #1
0
  /*
   * Build Maven Project from Source using Out and Err PrintStreams for getting the output
   */
  private void buildMavenProject(Source source, PrintStream out, PrintStream err)
      throws org.uberfire.java.nio.IOException, InvalidPathException, SecurityException,
          UnsupportedOperationException, IllegalArgumentException {
    List<String> goals = new ArrayList<>();
    goals.add("package");
    Properties p = new Properties();
    p.setProperty("failIfNoTests", "false");

    final InputStream pomStream =
        org.uberfire.java.nio.file.Files.newInputStream(
            source.getPath().resolve("drools-webapp-example").resolve("pom.xml"));
    MavenProject project = MavenProjectLoader.parseMavenPom(pomStream);

    final String expectedBinary =
        project.getArtifact().getArtifactId()
            + "-"
            + project.getArtifact().getVersion()
            + "."
            + project.getArtifact().getType();
    final org.guvnor.ala.build.maven.model.MavenProject mavenProject =
        new MavenProjectImpl(
            project.getId(),
            project.getArtifact().getType(),
            project.getName(),
            expectedBinary,
            source.getPath(),
            source.getPath().resolve("drools-webapp-example"),
            source.getPath().resolve("target").resolve(expectedBinary).toAbsolutePath(),
            null,
            null);
    final File pom = new File(getRepositoryVisitor(mavenProject).getRoot(), "pom.xml");
    MavenBuildExecutor.executeMaven(pom, out, err, p, goals.toArray(new String[0]));
  }
 private Map<String, Artifact> createManagedVersionMap() throws MojoExecutionException {
   Map<String, Artifact> map = new HashMap<String, Artifact>();
   DependencyManagement dependencyManagement = project.getDependencyManagement();
   if (dependencyManagement != null && dependencyManagement.getDependencies() != null) {
     for (Dependency d : dependencyManagement.getDependencies()) {
       try {
         VersionRange versionRange = VersionRange.createFromVersionSpec(d.getVersion());
         Artifact artifact =
             artifactFactory.createDependencyArtifact(
                 d.getGroupId(),
                 d.getArtifactId(),
                 versionRange,
                 d.getType(),
                 d.getClassifier(),
                 d.getScope(),
                 d.isOptional());
         handleExclusions(artifact, d);
         map.put(d.getManagementKey(), artifact);
       } catch (InvalidVersionSpecificationException e) {
         throw new MojoExecutionException(
             String.format(
                 "%1s: unable to parse version '%2s' for dependency '%3s': %4s",
                 project.getId(), d.getVersion(), d.getManagementKey(), e.getMessage()),
             e);
       }
     }
   }
   return map;
 }
 private void process(
     MavenProject node,
     DirectedGraph graph,
     Map<Artifact, ArtifactVertex> processed,
     final MyArtifactFilter artifactFilter) {
   abstractMojo.getLog().debug("DependencyProcessor: Processing: " + node.getId());
   process(resolveProject(node, artifactFilter), graph, processed, artifactFilter);
 }
 private DependencyNode resolveProject(MavenProject project, final MyArtifactFilter filter) {
   try {
     abstractMojo.getLog().debug("DependencyProcessor: Resolving project: " + project.getId());
     return dependencyTreeBuilder.buildDependencyTree(
         project, localRepository, factory, artifactMetadataSource, filter, collector);
   } catch (DependencyTreeBuilderException e) {
     abstractMojo.getLog().error("DependencyProcessor: Unable to build dependency tree.", e);
     return null;
   }
 }
  private AgentProjectInfo processProject(MavenProject project) {
    long startTime = System.currentTimeMillis();

    log.info(WssUtils.logMsg(LOG_COMPONENT, "processing Maven project " + project.getId()));

    AgentProjectInfo projectInfo = new AgentProjectInfo();

    // project token
    if (project.equals(mavenParser.getMavenProject())) {
      projectInfo.setProjectToken(projectToken);
    } else {
      projectInfo.setProjectToken(moduleTokens.get(project.getArtifactId()));
    }

    // project coordinates
    projectInfo.setCoordinates(extractCoordinates(project));

    Parent parent = project.getModel().getParent();
    // parent coordinates
    if (parent != null) {
      projectInfo.setParentCoordinates(extractParentCoordinates(parent));
    }

    // dependencies
    Map<Dependency, Artifact> lut = createLookupTable(project);
    for (Dependency dependency : mavenParser.getDependencies(project)) {
      DependencyInfo dependencyInfo = getDependencyInfo(dependency);

      Artifact artifact = lut.get(dependency);
      if (artifact != null) {
        File artifactFile = artifact.getFile();
        if (artifactFile != null && artifactFile.exists()) {
          try {
            dependencyInfo.setSha1(ChecksumUtils.calculateSHA1(artifactFile));
          } catch (IOException e) {
            log.warn(WssUtils.logMsg(LOG_COMPONENT, ERROR_SHA1 + " for " + artifact.getId()));
          }
        }
      }

      projectInfo.getDependencies().add(dependencyInfo);
    }

    log.info(
        WssUtils.logMsg(
            LOG_COMPONENT,
            "Total Maven project processing time is "
                + (System.currentTimeMillis() - startTime)
                + " [msec]"));

    return projectInfo;
  }
  private void addTargetEnvironments(
      TargetPlatformConfiguration result, MavenProject project, Xpp3Dom configuration) {
    TargetEnvironment deprecatedTargetEnvironmentSpec =
        getDeprecatedTargetEnvironment(configuration);
    if (deprecatedTargetEnvironmentSpec != null) {
      result.addEnvironment(deprecatedTargetEnvironmentSpec);
    }

    Xpp3Dom environmentsDom = configuration.getChild("environments");
    if (environmentsDom != null) {
      if (deprecatedTargetEnvironmentSpec != null) {
        String message =
            "Deprecated target-platform-configuration <environment> element must not be combined with new <environments> element; check the (inherited) configuration of "
                + project.getId();
        throw new RuntimeException(message);
      }
      for (Xpp3Dom environmentDom : environmentsDom.getChildren("environment")) {
        result.addEnvironment(newTargetEnvironment(environmentDom));
      }
    }
  }
  public void execute(final Archiver archiver, final AssemblerConfigurationSource configSource)
      throws ArchiveCreationException, AssemblyFormattingException,
          InvalidAssemblerConfigurationException {
    if ((dependencySets == null) || dependencySets.isEmpty()) {
      logger.debug("No dependency sets specified.");
      return;
    }

    @SuppressWarnings("unchecked")
    final List<Dependency> deps = project.getDependencies();
    if ((deps == null) || deps.isEmpty()) {
      logger.debug(
          "Project " + project.getId() + " has no dependencies. Skipping dependency set addition.");
    }

    for (final Iterator<DependencySet> i = dependencySets.iterator(); i.hasNext(); ) {
      final DependencySet dependencySet = i.next();

      addDependencySet(dependencySet, archiver, configSource);
    }
  }
예제 #8
0
  public void testDependencyManagementOverridesTransitiveDependencyVersion() throws Exception {
    File localRepo = getLocalRepositoryPath();

    File pom0 = new File(localRepo, "p0/pom.xml");
    File pom0Basedir = pom0.getParentFile();
    File pom1 = new File(pom0Basedir, "p1/pom.xml");

    // load the child project, which inherits from p0...
    MavenProject project0 = getProjectWithDependencies(pom0);
    MavenProject project1 = getProjectWithDependencies(pom1);

    assertEquals(pom0Basedir, project1.getParent().getBasedir());
    System.out.println("Project " + project1.getId() + " " + project1);
    Map map = project1.getArtifactMap();
    assertNotNull("No artifacts", map);
    assertTrue("No Artifacts", map.size() > 0);
    assertTrue("Set size should be 3, is " + map.size(), map.size() == 3);

    Artifact a = (Artifact) map.get("maven-test:t10-a");
    Artifact b = (Artifact) map.get("maven-test:t10-b");
    Artifact c = (Artifact) map.get("maven-test:t10-c");

    assertNotNull(a);
    assertNotNull(b);
    assertNotNull(c);

    // inherited from depMgmt
    System.out.println(a.getScope());
    assertTrue("Incorrect scope for " + a.getDependencyConflictId(), a.getScope().equals("test"));

    // transitive dep, overridden b depMgmt
    assertTrue(
        "Incorrect scope for " + b.getDependencyConflictId(), b.getScope().equals("runtime"));

    // direct dep, overrides depMgmt
    assertTrue(
        "Incorrect scope for " + c.getDependencyConflictId(), c.getScope().equals("runtime"));
  }
  @Override
  public Collection<AgentProjectInfo> extract() {
    log.info(WssUtils.logMsg(LOG_COMPONENT, "Collection started"));

    mavenParser = configureMavenParser(checkoutDirectory);

    Collection<MavenProject> projects = new ArrayList<MavenProject>();
    MavenProject mavenProject = mavenParser.getMavenProject();
    projects.add(mavenProject);
    projects.addAll(mavenParser.getModules(mavenProject));

    Collection<AgentProjectInfo> projectInfos = new ArrayList<AgentProjectInfo>();
    // Collect OSS usage information
    for (MavenProject project : projects) {
      if (shouldProcess(project)) {
        projectInfos.add(processProject(project));
      } else {
        log.info(WssUtils.logMsg(LOG_COMPONENT, "skipping " + project.getId()));
      }
    }
    logAgentProjectInfos(projectInfos);

    return projectInfos;
  }
  @SuppressWarnings("unchecked")
  public void execute() throws MojoExecutionException {
    ArtifactVersion currentVersion = ri.getApplicationVersion();
    ArtifactVersion maxUsageVersion = new DefaultArtifactVersion("2.2.0");

    if (maxUsageVersion.compareTo(currentVersion) < 0) {
      getLog()
          .debug(
              "This version of Maven does not require injection of custom ArtifactHandlers using this code. Skipping.");
      return;
    }

    Map<String, ?> handlerDescriptors =
        session.getContainer().getComponentDescriptorMap(ArtifactHandler.ROLE);
    if (handlerDescriptors != null) {
      getLog().debug("Registering all unregistered ArtifactHandlers...");

      if (artifactHandlerManager instanceof DefaultArtifactHandlerManager) {
        Set<String> existingHints =
            ((DefaultArtifactHandlerManager) artifactHandlerManager).getHandlerTypes();
        if (existingHints != null) {
          for (String hint : existingHints) {
            handlerDescriptors.remove(hint);
          }
        }
      }

      if (handlerDescriptors.isEmpty()) {
        getLog().debug("All ArtifactHandlers are registered. Continuing...");
      } else {
        Map<String, ArtifactHandler> unregisteredHandlers =
            new HashMap<String, ArtifactHandler>(handlerDescriptors.size());

        for (String hint : handlerDescriptors.keySet()) {
          try {
            unregisteredHandlers.put(
                hint, (ArtifactHandler) session.lookup(ArtifactHandler.ROLE, hint));
            getLog().info("Adding ArtifactHandler for: " + hint);
          } catch (ComponentLookupException e) {
            getLog()
                .warn(
                    "Failed to lookup ArtifactHandler with hint: "
                        + hint
                        + ". Reason: "
                        + e.getMessage(),
                    e);
          }
        }

        artifactHandlerManager.addHandlers(unregisteredHandlers);
      }
    }

    getLog()
        .debug("...done.\nSetting ArtifactHandler on project-artifact: " + project.getId() + "...");

    Set<Artifact> artifacts = new HashSet<Artifact>();
    artifacts.add(project.getArtifact());

    Set<Artifact> dependencyArtifacts = project.getDependencyArtifacts();
    if (dependencyArtifacts != null && !dependencyArtifacts.isEmpty()) {
      artifacts.addAll(dependencyArtifacts);
    }

    for (Artifact artifact : artifacts) {
      String type = artifact.getType();
      ArtifactHandler handler = artifactHandlerManager.getArtifactHandler(type);

      getLog()
          .debug(
              "Artifact: "
                  + artifact.getId()
                  + "\nType: "
                  + type
                  + "\nArtifactHandler extension: "
                  + handler.getExtension());

      artifact.setArtifactHandler(handler);
    }

    getLog().debug("...done.");
  }
  protected Set<Artifact> resolveDependencyArtifacts(final DependencySet dependencySet)
      throws InvalidAssemblerConfigurationException {
    final Set<Artifact> dependencyArtifacts = new LinkedHashSet<Artifact>();
    if (resolvedArtifacts != null) {
      dependencyArtifacts.addAll(resolvedArtifacts);
    }

    if (dependencySet.isUseProjectArtifact()) {
      final Artifact projectArtifact = project.getArtifact();
      if ((projectArtifact != null) && (projectArtifact.getFile() != null)) {
        dependencyArtifacts.add(projectArtifact);
      } else {
        logger.warn(
            "Cannot include project artifact: "
                + projectArtifact
                + "; it doesn't have an associated file or directory.");
      }
    }

    if (dependencySet.isUseProjectAttachments()) {
      @SuppressWarnings("unchecked")
      final List<Artifact> attachments = project.getAttachedArtifacts();
      if (attachments != null) {
        for (final Iterator<Artifact> attachmentIt = attachments.iterator();
            attachmentIt.hasNext(); ) {
          final Artifact attachment = attachmentIt.next();

          if (attachment.getFile() != null) {
            dependencyArtifacts.add(attachment);
          } else {
            logger.warn(
                "Cannot include attached artifact: "
                    + project.getId()
                    + " for project: "
                    + project.getId()
                    + "; it doesn't have an associated file or directory.");
          }
        }
      }
    }

    if (dependencySet.isUseTransitiveFiltering()) {
      logger.debug("Filtering dependency artifacts USING transitive dependency path information.");
    } else {
      logger.debug(
          "Filtering dependency artifacts WITHOUT transitive dependency path information.");
    }

    final ScopeArtifactFilter filter = new ScopeArtifactFilter(dependencySet.getScope());

    FilterUtils.filterArtifacts(
        dependencyArtifacts,
        dependencySet.getIncludes(),
        dependencySet.getExcludes(),
        dependencySet.isUseStrictFiltering(),
        dependencySet.isUseTransitiveFiltering(),
        logger,
        filter);

    return dependencyArtifacts;
  }
예제 #12
0
  /**
   * Resolve project dependencies. Manual resolution is needed in order to avoid resoltion of
   * multiproject artifacts (if projects will be linked each other an installed jar is not needed)
   * and to avoid a failure when a jar is missing.
   *
   * @throws MojoExecutionException if dependencies can't be resolved
   * @return resoved IDE dependencies, with attached jars for non-reactor dependencies
   */
  protected IdeDependency[] doDependencyResolution() throws MojoExecutionException {
    MavenProject project = getProject();
    ArtifactRepository localRepo = getLocalRepository();

    List dependencies = getProject().getDependencies();

    // Collect the list of resolved IdeDependencies.
    List dependencyList = new ArrayList();

    if (dependencies != null) {
      Map managedVersions =
          createManagedVersionMap(
              getArtifactFactory(), project.getId(), project.getDependencyManagement());

      ArtifactResolutionResult artifactResolutionResult = null;

      try {

        List listeners = new ArrayList();

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

        listeners.add(new WarningResolutionListener(logger));

        artifactResolutionResult =
            artifactCollector.collect(
                getProjectArtifacts(),
                project.getArtifact(),
                managedVersions,
                localRepo,
                project.getRemoteArtifactRepositories(),
                getArtifactMetadataSource(),
                null,
                listeners);
      } catch (ArtifactResolutionException e) {
        getLog().debug(e.getMessage(), e);
        getLog()
            .error(
                Messages.getString(
                    "artifactresolution",
                    new Object[] { // $NON-NLS-1$
                      e.getGroupId(), e.getArtifactId(), e.getVersion(), e.getMessage()
                    }));

        // if we are here artifactResolutionResult is null, create a project without dependencies
        // but don't fail
        // (this could be a reactor projects, we don't want to fail everything)
        return new IdeDependency[0];
      }

      // keep track of added reactor projects in order to avoid duplicates
      Set emittedReactorProjectId = new HashSet();

      for (Iterator i = artifactResolutionResult.getArtifactResolutionNodes().iterator();
          i.hasNext(); ) {
        ResolutionNode node = (ResolutionNode) i.next();
        Artifact art = node.getArtifact();
        boolean isReactorProject = getUseProjectReferences() && isAvailableAsAReactorProject(art);

        // don't resolve jars for reactor projects
        if (!isReactorProject) {
          try {
            artifactResolver.resolve(art, node.getRemoteRepositories(), localRepository);
          } catch (ArtifactNotFoundException e) {
            getLog().debug(e.getMessage(), e);
            getLog()
                .warn(
                    Messages.getString(
                        "artifactdownload",
                        new Object[] { // $NON-NLS-1$
                          e.getGroupId(), e.getArtifactId(), e.getVersion(), e.getMessage()
                        }));
          } catch (ArtifactResolutionException e) {
            getLog().debug(e.getMessage(), e);
            getLog()
                .warn(
                    Messages.getString(
                        "artifactresolution",
                        new Object[] { // $NON-NLS-1$
                          e.getGroupId(), e.getArtifactId(), e.getVersion(), e.getMessage()
                        }));
          }
        }

        if (!isReactorProject
            || emittedReactorProjectId.add(art.getGroupId() + '-' + art.getArtifactId())) {

          IdeDependency dep =
              new IdeDependency(
                  art.getGroupId(),
                  art.getArtifactId(),
                  art.getVersion(),
                  isReactorProject,
                  Artifact.SCOPE_TEST.equals(art.getScope()),
                  Artifact.SCOPE_SYSTEM.equals(art.getScope()),
                  Artifact.SCOPE_PROVIDED.equals(art.getScope()),
                  art.getArtifactHandler().isAddedToClasspath(),
                  art.getFile(),
                  art.getType());

          dependencyList.add(dep);
        }
      }

      // @todo a final report with the list of missingArtifacts?

    }

    IdeDependency[] deps =
        (IdeDependency[]) dependencyList.toArray(new IdeDependency[dependencyList.size()]);

    return deps;
  }
예제 #13
0
 /** Validate Mojo parameters. */
 private void validateParameters() {
   if (artifact == null) {
     // using project if found or super-pom
     getLog().info("No artifact parameter specified, using '" + project.getId() + "' as project.");
   }
 }