GenerateMojo.java

/*
 * #%L
 * wcm.io
 * %%
 * Copyright (C) 2015 wcm.io
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */
package io.wcm.devops.conga.tooling.maven.plugin;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import javax.inject.Inject;

import org.apache.maven.artifact.resolver.ResolutionErrorHandler;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.apache.maven.project.MavenProject;
import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.repository.RemoteRepository;
import org.sonatype.plexus.build.incremental.BuildContext;

import io.wcm.devops.conga.generator.Generator;
import io.wcm.devops.conga.generator.GeneratorOptions;
import io.wcm.devops.conga.generator.spi.context.PluginContextOptions;
import io.wcm.devops.conga.generator.util.PluginManager;
import io.wcm.devops.conga.generator.util.PluginManagerImpl;
import io.wcm.devops.conga.tooling.maven.plugin.util.ClassLoaderUtil;
import io.wcm.devops.conga.tooling.maven.plugin.util.MavenContext;
import io.wcm.devops.conga.tooling.maven.plugin.util.VersionInfoUtil;

/**
 * Generates configuration using CONGA generator.
 */
@Mojo(name = "generate", defaultPhase = LifecyclePhase.GENERATE_RESOURCES, requiresProject = true, threadSafe = true,
    requiresDependencyResolution = ResolutionScope.COMPILE)
public class GenerateMojo extends AbstractCongaMojo {

  /**
   * Selected environments to generate.
   */
  @Parameter(property = "conga.environments")
  private String[] environments;

  /**
   * Selected nodes to generate.
   */
  @Parameter(property = "conga.nodes")
  private String[] nodes;

  /**
   * Delete folders of environments before generating the new files.
   */
  @Parameter(defaultValue = "false")
  private boolean deleteBeforeGenerate;

  /**
   * Is it allowed to create symlinks instead of copying files if they are local files e.g. from Maven Repository.
   */
  @Parameter(defaultValue = "true")
  private boolean allowSymlinks;

  /**
   * Plugin keys (groupId:artifactId) of additional Maven plugins of the current project's POM
   * to be included in the model export version information.
   */
  @Parameter(defaultValue = "io.wcm.maven.plugins:wcmio-content-package-maven-plugin")
  private String[] versionInfoAdditionalPlugins;

  @Parameter(property = "project", required = true, readonly = true)
  private MavenProject project;

  @Inject
  private org.apache.maven.repository.RepositorySystem repositorySystem;
  @Inject
  private ResolutionErrorHandler resolutionErrorHandler;
  @Inject
  private RepositorySystem repoSystem;
  @Inject
  private BuildContext buildContext;
  @Parameter(defaultValue = "${repositorySystemSession}", readonly = true)
  private RepositorySystemSession repoSession;
  @Parameter(defaultValue = "${project.remoteProjectRepositories}", readonly = true)
  private List<RemoteRepository> remoteRepos;
  @Parameter(defaultValue = "${session}", readonly = true, required = false)
  private MavenSession session;

  @Override
  public void execute() throws MojoExecutionException, MojoFailureException {

    MavenContext mavenContext = new MavenContext()
        .project(project)
        .session(session)
        .setRepositorySystem(repositorySystem)
        .resolutionErrorHandler(resolutionErrorHandler)
        .buildContext(buildContext)
        .log(getLog())
        .repoSystem(repoSystem)
        .repoSession(repoSession)
        .remoteRepos(remoteRepos)
        .artifactTypeMappings(getArtifactTypeMappings());

    PluginManager pluginManager = new PluginManagerImpl();

    PluginContextOptions pluginContextOptions = new PluginContextOptions()
        .pluginManager(pluginManager)
        .valueProviderConfig(getValueProviderConfig())
        .genericPluginConfig(getPluginConfig())
        .containerContext(mavenContext)
        .logger(new MavenSlf4jLogFacade(getLog()));

    GeneratorOptions options = new GeneratorOptions()
        .baseDir(project.getBasedir())
        .roleDir(getRoleDir())
        .templateDir(getTemplateDir())
        .environmentDir(getEnvironmentDir())
        .destDir(getTargetDir())
        .deleteBeforeGenerate(deleteBeforeGenerate)
        .version(project.getVersion())
        .setAllowSymlinks(allowSymlinks)
        .modelExport(getModelExport())
        .valueProviderConfig(getValueProviderConfig())
        .genericPluginConfig(getPluginConfig())
        .containerContext(mavenContext)
        .containerClasspathUrls(ClassLoaderUtil.getMavenProjectClasspathUrls(project))
        .pluginManager(pluginManager)
        .dependencyVersionBuilder(new DependencyVersionBuilder(pluginContextOptions))
        .containerVersionInfo(buildContainerVersionInfo())
        .logger(new MavenSlf4jLogFacade(getLog()));

    Generator generator = new Generator(options);
    generator.generate(environments, nodes);
  }

  /**
   * Build version information about CONGA Maven plugin and CONGA plugins, plus
   * additional plugin versions as defined in plugin configuration. This version
   * information is included in the model export.
   * @return Version information
   */
  private Map<String, String> buildContainerVersionInfo() {
    Map<String, String> versionInfo = new HashMap<>();

    Properties pluginProps = VersionInfoUtil.getVersionInfoProperties(project);
    for (Map.Entry<Object, Object> entry : pluginProps.entrySet()) {
      versionInfo.put(entry.getKey().toString(), entry.getValue().toString());
    }

    for (String pluginKey : versionInfoAdditionalPlugins) {
      String pluginVersion = VersionInfoUtil.getPluginVersionFromPluginManagement(pluginKey, project);
      if (pluginVersion != null) {
        versionInfo.put(pluginKey, pluginVersion);
      }
    }

    return versionInfo;
  }

}