private void parseLifecyclePhaseDefinitions(
      Map<Plugin, Plugin> plugins, String phase, LifecyclePhase goals) {
    List<LifecycleMojo> mojos = goals.getMojos();
    if (mojos != null) {

      for (int i = 0; i < mojos.size(); i++) {
        LifecycleMojo mojo = mojos.get(i);

        GoalSpec gs = parseGoalSpec(mojo.getGoal());

        if (gs == null) {
          logger.warn(
              "Ignored invalid goal specification '"
                  + mojo.getGoal()
                  + "' from lifecycle mapping for phase "
                  + phase);
          continue;
        }

        Plugin plugin = new Plugin();
        plugin.setGroupId(gs.groupId);
        plugin.setArtifactId(gs.artifactId);
        plugin.setVersion(gs.version);

        Plugin existing = plugins.get(plugin);
        if (existing != null) {
          if (existing.getVersion() == null) {
            existing.setVersion(plugin.getVersion());
          }
          plugin = existing;
        } else {
          plugins.put(plugin, plugin);
        }

        PluginExecution execution = new PluginExecution();
        execution.setId(getExecutionId(plugin, gs.goal));
        execution.setPhase(phase);
        execution.setPriority(i - mojos.size());
        execution.getGoals().add(gs.goal);
        execution.setConfiguration(mojo.getConfiguration());

        plugin.setDependencies(mojo.getDependencies());
        plugin.getExecutions().add(execution);
      }
    }
  }
 /**
  * Set the versions of any plugins which match the contents of the list of plugin overrides
  *
  * @param plugins The list of plugins to modify
  * @param pluginVersionOverrides The list of version overrides to apply to the plugins
  */
 private static void applyOverrides(
     List<Plugin> plugins, Map<String, String> pluginVersionOverrides) {
   for (Plugin plugin : plugins) {
     String groupIdArtifactId = plugin.getGroupId() + GAV_SEPERATOR + plugin.getArtifactId();
     if (pluginVersionOverrides.containsKey(groupIdArtifactId)) {
       String overrideVersion = pluginVersionOverrides.get(groupIdArtifactId);
       plugin.setVersion(overrideVersion);
       Log.getLog().debug("Altered plugin: " + groupIdArtifactId + "=" + overrideVersion);
     }
   }
 }
  @Override
  public boolean install() {
    if (!this.isInstalled()) {
      for (DirectoryResource folder : this.getSourceFolders()) {
        folder.mkdirs();
      }

      // FIXME WOW this needs to be simplified somehow...
      MavenCoreFacet maven = project.getFacet(MavenCoreFacet.class);
      Model pom = maven.getPOM();
      Build build = pom.getBuild();
      if (build == null) {
        build = new Build();
      }
      List<Plugin> plugins = build.getPlugins();
      Plugin javaSourcePlugin = null;
      for (Plugin plugin : plugins) {
        if ("org.apache.maven.plugins".equals(plugin.getGroupId())
            && "maven-compiler-plugin".equals(plugin.getArtifactId())) {
          javaSourcePlugin = plugin;
        }
      }

      if (javaSourcePlugin == null) {
        javaSourcePlugin = new Plugin();
        // FIXME this should find the most recent version using DependencyResolver
        javaSourcePlugin.setGroupId("org.apache.maven.plugins");
        javaSourcePlugin.setArtifactId("maven-compiler-plugin");
        javaSourcePlugin.setVersion("2.3.2");

        try {
          Xpp3Dom dom =
              Xpp3DomBuilder.build(
                  new ByteArrayInputStream(
                      "<configuration><source>1.6</source><target>1.6</target></configuration>"
                          .getBytes()),
                  "UTF-8");

          javaSourcePlugin.setConfiguration(dom);
        } catch (Exception e) {
          throw new ProjectModelException(e);
        }
      }

      build.addPlugin(javaSourcePlugin);
      pom.setBuild(build);
      maven.setPOM(pom);
    }
    return true;
  }
  @Command
  public void custom(
      PipeOut out,
      @Option(name = "artifact", required = true) String artifact,
      @Option(name = "group", required = true) String group,
      @Option(name = "version", required = true) String version) {
    final MavenCoreFacet mvnFacet = project.getFacet(MavenCoreFacet.class);

    Model pom = mvnFacet.getPOM();

    org.apache.maven.model.Plugin plugin = new org.apache.maven.model.Plugin();

    plugin.setGroupId(group);
    plugin.setArtifactId(artifact);
    plugin.setVersion(version);

    if (pom.getBuild().getPlugins().contains(plugin)) {
      return;
    }

    pom.getBuild().getPlugins().add(plugin);

    mvnFacet.setPOM(pom);
  }
Esempio n. 5
0
 /**
  * Find and configure a mojor.
  *
  * @param coords Maven coordinates, e.g. "com.qulice:maven-qulice-plugin:1.0"
  * @param goal Maven plugin goal to execute
  * @param config The configuration to set
  * @throws ValidationException If something is wrong inside
  */
 public void execute(final String coords, final String goal, final Properties config)
     throws ValidationException {
   final Plugin plugin = new Plugin();
   final String[] sectors = StringUtils.split(coords, ':');
   plugin.setGroupId(sectors[0]);
   plugin.setArtifactId(sectors[1]);
   plugin.setVersion(sectors[2]);
   final MojoDescriptor descriptor = this.descriptor(plugin, goal);
   try {
     this.helper.setupPluginRealm(
         descriptor.getPluginDescriptor(),
         this.session,
         Thread.currentThread().getContextClassLoader(),
         new LinkedList<String>(),
         new LinkedList<String>());
   } catch (final PluginResolutionException ex) {
     throw new IllegalStateException("Plugin resolution problem", ex);
   } catch (final PluginContainerException ex) {
     throw new IllegalStateException("Can't setup realm", ex);
   }
   final Xpp3Dom xpp =
       Xpp3Dom.mergeXpp3Dom(
           this.toXppDom(config, "configuration"),
           this.toXppDom(descriptor.getMojoConfiguration()));
   final MojoExecution execution = new MojoExecution(descriptor, xpp);
   final Mojo mojo = this.mojo(execution);
   Logger.info(this, "Calling %s:%s...", coords, goal);
   try {
     mojo.execute();
   } catch (final MojoExecutionException ex) {
     throw new IllegalArgumentException(ex);
   } catch (final MojoFailureException ex) {
     throw new ValidationException(ex);
   }
   this.manager.releaseMojo(mojo, execution);
 }
Esempio n. 6
0
  public MojoExecution createMojoExecution(Plugin plugin, String goal, MavenProject project)
      throws Exception {
    if (plugin.getVersion() == null) {
      plugin.setVersion(
          plexusContainer
              .lookup(PluginVersionResolver.class)
              .resolve(new DefaultPluginVersionRequest(plugin, session))
              .getVersion());
    }

    MojoDescriptor mojoDescriptor =
        pluginManager.getMojoDescriptor(
            plugin, goal, project.getRemotePluginRepositories(), session.getRepositorySession());
    List<PluginExecution> executions = plugin.getExecutions();
    MojoExecution mojoExecution =
        new MojoExecution(
            mojoDescriptor,
            executions.isEmpty() ? null : executions.get(executions.size() - 1).getId(),
            MojoExecution.Source.CLI);
    plexusContainer
        .lookup(LifecycleExecutionPlanCalculator.class)
        .setupMojoExecution(session, project, mojoExecution);
    return mojoExecution;
  }
Esempio n. 7
0
  private MavenPlugin install(Project project, final MavenPlugin plugin, boolean managed) {
    MavenPluginFacet plugins = project.getFacet(MavenPluginFacet.class);
    DependencyFacet deps = project.getFacet(DependencyFacet.class);
    Coordinate pluginCoordinates =
        CoordinateBuilder.create()
            .setGroupId(plugin.getCoordinate().getGroupId())
            .setArtifactId(plugin.getCoordinate().getArtifactId());
    MavenPlugin managedPlugin = null;
    if (plugins.hasManagedPlugin(pluginCoordinates)) {
      managedPlugin = plugins.getManagedPlugin(pluginCoordinates);
    }

    MavenPlugin existing = null;
    // existing represents the plugin(management) as it exists currently throughout the entire
    // hierarchy
    if (managed && plugins.hasEffectiveManagedPlugin(pluginCoordinates)) {
      existing = plugins.getEffectiveManagedPlugin(pluginCoordinates);
    } else if (plugins.hasEffectivePlugin(pluginCoordinates)) {
      existing = plugins.getEffectivePlugin(pluginCoordinates);
    }

    MavenPlugin filteredPlugin = plugin;
    // The filtered plugin preserve the hierarchy, by preventing installing properties already
    // defined with the same
    // values
    if (existing != null && preserveHierarchyPrecedence) {
      filteredPlugin = diff(plugin, existing);
    }
    // Preserve direct plugin-management inheritance
    if (!managed && managedPlugin != null) {
      // The plugin section does not exists but a plugin management section in the direct pom does
      filteredPlugin = diff(filteredPlugin, managedPlugin);
    }

    MavenPlugin mergedPlugin = filteredPlugin;
    // merged plugin is a merge with the direct plugin(management)
    if (managed && managedPlugin != null) {
      mergedPlugin = plugins.merge(mergedPlugin, managedPlugin);
    } else if (!managed && plugins.hasPlugin(pluginCoordinates)) {
      mergedPlugin = plugins.merge(mergedPlugin, plugins.getPlugin(pluginCoordinates));
    }

    // Resolve version
    String versionToInstall = plugin.getCoordinate().getVersion();
    if (mergedPlugin.getCoordinate().getVersion() == null) {
      // null version means no version was specified or already defined in the hierarchy
      if (versionToInstall == null) {
        versionToInstall = promptVersion(deps, pluginCoordinates, null).getVersion();
      }
    }

    // Install the plugin
    MavenPluginAdapter pluginToInstall = new MavenPluginAdapter(mergedPlugin);
    pluginToInstall.setVersion(versionToInstall);
    if (!managed) {
      // In case of a direct plugin install
      // We want it's version being managed in the plugin management section
      MavenPluginAdapter mavenManagedPlugin = null;
      if (managedPlugin != null) {
        // A plugin managemement section already exists, update version
        mavenManagedPlugin = new MavenPluginAdapter(managedPlugin);
        mavenManagedPlugin.setVersion(pluginToInstall.getVersion());
      } else {
        // Create a new plugin management, that will handle the minimal configuration: groupId,
        // artifactId and
        // version
        Plugin newManagedPlugin = new Plugin();
        newManagedPlugin.setGroupId(pluginToInstall.getGroupId());
        newManagedPlugin.setArtifactId(pluginToInstall.getArtifactId());
        newManagedPlugin.setVersion(pluginToInstall.getVersion());
        mavenManagedPlugin = new MavenPluginAdapter(newManagedPlugin);
      }

      // Install the plugin management, if needed
      addOrUpdatePlugin(deps, plugins, mavenManagedPlugin, true);
      pluginToInstall.setVersion(null); // handled by the plugin management section
    } else {
      if (existing != null
          && Strings.compare(versionToInstall, existing.getCoordinate().getVersion())) {
        // Same version in the hierarchy, no need to specify the version
        pluginToInstall.setVersion(null);
      }
    }

    return addOrUpdatePlugin(deps, plugins, pluginToInstall, managed);
  }
  @Override
  public Collection<MavenArtifact> resolvePlugin(
      @NotNull MavenPlugin plugin,
      @NotNull List<MavenRemoteRepository> repositories,
      int nativeMavenProjectId,
      boolean transitive)
      throws RemoteException, MavenServerProcessCanceledException {
    try {
      Plugin mavenPlugin = new Plugin();
      mavenPlugin.setGroupId(plugin.getGroupId());
      mavenPlugin.setArtifactId(plugin.getArtifactId());
      mavenPlugin.setVersion(plugin.getVersion());
      MavenProject project = RemoteNativeMavenProjectHolder.findProjectById(nativeMavenProjectId);

      MavenExecutionRequest request =
          createRequest(
              null,
              Collections.<String>emptyList(),
              Collections.<String>emptyList(),
              Collections.<String>emptyList());

      DefaultMaven maven = (DefaultMaven) getComponent(Maven.class);
      RepositorySystemSession repositorySystemSession = maven.newRepositorySession(request);

      if (plugin.getVersion() == null) {
        PluginVersionRequest versionRequest =
            new DefaultPluginVersionRequest(
                mavenPlugin, repositorySystemSession, project.getRemotePluginRepositories());
        mavenPlugin.setVersion(
            getComponent(PluginVersionResolver.class).resolve(versionRequest).getVersion());
      }

      PluginDescriptor result =
          getComponent(MavenPluginManager.class)
              .getPluginDescriptor(
                  mavenPlugin, project.getRemotePluginRepositories(), repositorySystemSession);

      Map<MavenArtifactInfo, MavenArtifact> resolvedArtifacts =
          new THashMap<MavenArtifactInfo, MavenArtifact>();

      Artifact pluginArtifact = result.getPluginArtifact();

      MavenArtifactInfo artifactInfo =
          new MavenArtifactInfo(
              pluginArtifact.getGroupId(),
              pluginArtifact.getArtifactId(),
              pluginArtifact.getVersion(),
              pluginArtifact.getType(),
              null);

      resolveIfNecessary(artifactInfo, repositories, resolvedArtifacts);

      if (transitive) {
        // todo try to use parallel downloading
        for (Artifact each : result.getIntroducedDependencyArtifacts()) {
          resolveIfNecessary(
              new MavenArtifactInfo(
                  each.getGroupId(), each.getArtifactId(), each.getVersion(), each.getType(), null),
              repositories,
              resolvedArtifacts);
        }
        for (ComponentDependency each : result.getDependencies()) {
          resolveIfNecessary(
              new MavenArtifactInfo(
                  each.getGroupId(), each.getArtifactId(), each.getVersion(), each.getType(), null),
              repositories,
              resolvedArtifacts);
        }
      }

      return new THashSet<MavenArtifact>(resolvedArtifacts.values());
    } catch (Exception e) {
      Maven3ServerGlobals.getLogger().info(e);
      return Collections.emptyList();
    }
  }
Esempio n. 9
0
  public void updateModel(
      Model model, String yangVersion, List<CodeGeneratorConfig> generators, String yangRoot) {
    // Model model = super.getModel();
    model.setBuild(new Build());
    Plugin plugin = new Plugin();
    plugin.setGroupId("org.opendaylight.yangtools");
    plugin.setArtifactId("yang-maven-plugin");
    plugin.setVersion(yangVersion);

    for (CodeGeneratorConfig genConf : generators) {
      Dependency dependency = new Dependency();
      dependency.setGroupId(genConf.getGroupId());
      dependency.setArtifactId(genConf.getArtifactId());
      dependency.setVersion(genConf.getVersion());
      dependency.setType("jar");
      plugin.addDependency(dependency);
    }

    PluginExecution pluginExecution = new PluginExecution();
    pluginExecution.setId("generate-sources");
    pluginExecution.addGoal("generate-sources");
    Xpp3Dom config = new Xpp3Dom("configuration");

    Xpp3Dom codeGenerators = new Xpp3Dom("codeGenerators");
    for (CodeGeneratorConfig genConf : generators) {
      Xpp3Dom generator = new Xpp3Dom("generator");
      generator.addChild(createSingleParameter("codeGeneratorClass", genConf.getGenClassName()));
      generator.addChild(createSingleParameter("outputBaseDir", genConf.getGenOutputDirectory()));
      codeGenerators.addChild(generator);
    }
    config.addChild(createSingleParameter("yangFilesRootDir", yangRoot));
    config.addChild(codeGenerators);
    config.addChild(createSingleParameter("inspectDependencies", "false"));
    pluginExecution.setConfiguration(config);

    plugin.addExecution(pluginExecution);
    model.getBuild().addPlugin(plugin);
    model.addPluginRepository(
        createRepoParameter(
            "opendaylight-release",
            "http://nexus.opendaylight.org/content/repositories/opendaylight.release/"));
    model.addPluginRepository(
        createRepoParameter(
            "opendaylight-snapshot",
            "http://nexus.opendaylight.org/content/repositories/opendaylight.snapshot/"));
    model.addRepository(
        createRepoParameter(
            "opendaylight-release",
            "http://nexus.opendaylight.org/content/repositories/opendaylight.release/"));
    model.addRepository(
        createRepoParameter(
            "opendaylight-snapshot",
            "http://nexus.opendaylight.org/content/repositories/opendaylight.snapshot/"));

    model.getProperties().put("maven.compiler.source", "1.7");
    model.getProperties().put("maven.compiler.target", "1.7");

    Dependency dependency2 = new Dependency();
    dependency2.setGroupId("org.opendaylight.yangtools");
    dependency2.setArtifactId("yang-binding");
    dependency2.setVersion(yangVersion);
    dependency2.setType("jar");
    model.addDependency(dependency2);
  }
Esempio n. 10
0
  public static void mergePluginDefinitions(
      Plugin child, Plugin parent, boolean handleAsInheritance) {
    if ((child == null) || (parent == null)) {
      // nothing to do.
      return;
    }

    if (parent.isExtensions()) {
      child.setExtensions(true);
    }

    if ((child.getVersion() == null) && (parent.getVersion() != null)) {
      child.setVersion(parent.getVersion());
    }

    Xpp3Dom childConfiguration = (Xpp3Dom) child.getConfiguration();
    Xpp3Dom parentConfiguration = (Xpp3Dom) parent.getConfiguration();

    childConfiguration = Xpp3Dom.mergeXpp3Dom(childConfiguration, parentConfiguration);

    child.setConfiguration(childConfiguration);

    child.setDependencies(mergeDependencyList(child.getDependencies(), parent.getDependencies()));

    // from here to the end of the method is dealing with merging of the <executions/> section.
    String parentInherited = parent.getInherited();

    boolean parentIsInherited =
        (parentInherited == null) || Boolean.valueOf(parentInherited).booleanValue();

    List parentExecutions = parent.getExecutions();

    if ((parentExecutions != null) && !parentExecutions.isEmpty()) {
      List mergedExecutions = new ArrayList();

      Map assembledExecutions = new TreeMap();

      Map childExecutions = child.getExecutionsAsMap();

      for (Iterator it = parentExecutions.iterator(); it.hasNext(); ) {
        PluginExecution parentExecution = (PluginExecution) it.next();

        String inherited = parentExecution.getInherited();

        boolean parentExecInherited =
            parentIsInherited && ((inherited == null) || Boolean.valueOf(inherited).booleanValue());

        if (!handleAsInheritance || parentExecInherited) {
          PluginExecution assembled = parentExecution;

          PluginExecution childExecution =
              (PluginExecution) childExecutions.get(parentExecution.getId());

          if (childExecution != null) {
            mergePluginExecutionDefinitions(childExecution, parentExecution);

            assembled = childExecution;
          } else if (handleAsInheritance && (parentInherited == null)) {
            parentExecution.unsetInheritanceApplied();
          }

          assembledExecutions.put(assembled.getId(), assembled);
          mergedExecutions.add(assembled);
        }
      }

      for (Iterator it = child.getExecutions().iterator(); it.hasNext(); ) {
        PluginExecution childExecution = (PluginExecution) it.next();

        if (!assembledExecutions.containsKey(childExecution.getId())) {
          mergedExecutions.add(childExecution);
        }
      }

      child.setExecutions(mergedExecutions);

      child.flushExecutionMap();
    }
  }
  /**
   * If enabled, grab the execution root pom (which will be the topmost POM in terms of directory
   * structure). Check for the presence of the project-sources-maven-plugin in the base build
   * (/project/build/plugins/). Inject a new plugin execution for creating project sources if this
   * plugin has not already been declared in the base build section.
   */
  @Override
  public Set<Project> applyChanges(final List<Project> projects, final ManipulationSession session)
      throws ManipulationException {
    final ProjectSourcesInjectingState state = session.getState(ProjectSourcesInjectingState.class);

    // This manipulator will only run if its enabled *and* at least one other manipulator is
    // enabled.
    if (state.isEnabled() && session.anyStateEnabled(State.activeByDefault)) {
      for (final Project project : projects) {
        if (project.isExecutionRoot()) {
          logger.info("Examining {} to apply sources/metadata plugins.", project);

          final Model model = project.getModel();
          Build build = model.getBuild();
          if (build == null) {
            build = new Build();
            model.setBuild(build);
          }

          boolean changed = false;
          final Map<String, Plugin> pluginMap = build.getPluginsAsMap();
          if (state.isProjectSourcesPluginEnabled()
              && !pluginMap.containsKey(PROJECT_SOURCES_COORD)) {
            final PluginExecution execution = new PluginExecution();
            execution.setId(PROJECT_SOURCES_EXEC_ID);
            execution.setPhase(INITIALIZE_PHASE);
            execution.setGoals(Collections.singletonList(PROJECT_SOURCES_GOAL));

            final Plugin plugin = new Plugin();
            plugin.setGroupId(PROJECT_SOURCES_GID);
            plugin.setArtifactId(PROJECT_SOURCES_AID);
            plugin.setVersion(state.getProjectSourcesPluginVersion());
            plugin.addExecution(execution);

            build.addPlugin(plugin);

            changed = true;
          }

          if (state.isBuildMetadataPluginEnabled() && !pluginMap.containsKey(BMMP_COORD)) {
            final PluginExecution execution = new PluginExecution();
            execution.setId(BMMP_EXEC_ID);
            execution.setPhase(VALIDATE_PHASE);
            execution.setGoals(Collections.singletonList(BMMP_GOAL));

            final Xpp3Dom xml = new Xpp3Dom("configuration");

            final Map<String, Object> config = new HashMap<>();
            config.put("createPropertiesReport", true);
            config.put("hideCommandLineInfo", false);
            config.put("hideJavaOptsInfo", false);
            config.put("activateOutputFileMapping", true);
            config.put("addJavaRuntimeInfo", true);

            // Default name is build.properties but we currently prefer build.metadata.
            config.put("propertiesOutputFile", "build.metadata");
            // Deactivate features we don't want.
            config.put("createXmlReport", false);
            config.put("addLocallyModifiedTagToFullVersion", false);
            config.put("addToGeneratedSources", false);
            config.put("validateCheckout", false);
            config.put("forceNewProperties", true);
            config.put("addBuildDateToFullVersion", false);
            config.put("addHostInfo", false);
            config.put("addBuildDateInfo", false);
            config.put("addOsInfo", false);
            config.put("addMavenExecutionInfo", false);
            config.put("addToFilters", false);

            final Xpp3Dom additionalLocations = new Xpp3Dom("addToLocations");
            final Xpp3Dom additionalLocation = new Xpp3Dom("addToLocation");

            xml.addChild(additionalLocations);
            additionalLocations.addChild(additionalLocation);
            additionalLocation.setValue("${session.executionRootDirectory}");

            for (final Map.Entry<String, Object> entry : config.entrySet()) {
              final Xpp3Dom child = new Xpp3Dom(entry.getKey());
              if (entry.getValue() != null) {
                child.setValue(entry.getValue().toString());
              }

              xml.addChild(child);
            }

            execution.setConfiguration(xml);

            final Plugin plugin = new Plugin();
            plugin.setGroupId(BMMP_GID);
            plugin.setArtifactId(BMMP_AID);
            plugin.setVersion(state.getBuildMetadataPluginVersion());
            plugin.addExecution(execution);

            build.addPlugin(plugin);

            changed = true;
          }

          if (changed) {
            return Collections.singleton(project);
          }
        }
      }
    }

    return Collections.emptySet();
  }