runtime/org.argeo.slc.support.maven/src/main/java/org/argeo/slc/maven/MavenManager.java

   1 /*
   2  * Copyright (C) 2010 Mathieu Baudier <mbaudier@argeo.org>
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.argeo.slc.maven;
  18
  19 import org.apache.commons.logging.Log;
  20 import org.apache.commons.logging.LogFactory;
  21 import org.apache.maven.cli.MavenCli;
  22 import org.apache.maven.repository.internal.DefaultServiceLocator;
  23 import org.apache.maven.repository.internal.MavenRepositorySystemSession;
  24 import org.argeo.slc.SlcException;
  25 import org.codehaus.plexus.PlexusContainer;
  26 import org.sonatype.aether.RepositorySystem;
  27 import org.sonatype.aether.RepositorySystemSession;
  28 import org.sonatype.aether.artifact.Artifact;
  29 import org.sonatype.aether.collection.CollectRequest;
  30 import org.sonatype.aether.connector.wagon.WagonProvider;
  31 import org.sonatype.aether.connector.wagon.WagonRepositoryConnectorFactory;
  32 import org.sonatype.aether.graph.Dependency;
  33 import org.sonatype.aether.graph.DependencyNode;
  34 import org.sonatype.aether.repository.LocalRepository;
  35 import org.sonatype.aether.repository.RemoteRepository;
  36 import org.sonatype.aether.spi.connector.RepositoryConnectorFactory;
  37 import org.sonatype.aether.util.artifact.DefaultArtifact;
  38 import org.sonatype.aether.util.graph.PreorderNodeListGenerator;
  39
  40 public class MavenManager {
  41         private final static Log log = LogFactory.getLog(MavenManager.class);
  42
  43         public void init() {
  44                 try {
  45                         testMaven();
  46                         testAether();
  47                         // List<ComponentDescriptor<?>> lst = plexusContainer
  48                         // .discoverComponents(plexusContainer.getContainerRealm());
  49                         // for (ComponentDescriptor<?> cd : lst) {
  50                         // log.debug(cd);
  51                         // }
  52                         // ArtifactHandler artifactHandler = plexusContainer
  53                         // .lookup(ArtifactHandler.class);
  54                         // ArtifactRepository localRepository = new
  55                         // DefaultArtifactRepositoryFactory().createArtifactRepository("local",
  56                         // , layoutId, snapshots, releases);
  57                         // Maven maven = mavenCli.getContainer().lookup(Maven.class);
  58                         // Artifact artifact = new DefaultArtifact("org.argeo.slc.dist",
  59                         // "org.argeo.slc.sdk", "0.13.1-SNAPSHOT", "compile", "pom",
  60                         // null, artifactHandler);
  61                         // ArtifactResolutionRequest req = new ArtifactResolutionRequest();
  62                         // req.setLocalRepository(localRepository);
  63                         // req.setResolveTransitively(true);
  64                         // req.setArtifact(artifact);
  65                         // ArtifactResolver artifactResolver = plexusContainer
  66                         // .lookup(ArtifactResolver.class);
  67                         // ArtifactResolutionResult res = artifactResolver.resolve(req);
  68                         // Set<Artifact> artifacts = res.getArtifacts();
  69                         // for (Artifact art : artifacts) {
  70                         // log.debug(art);
  71                         // }
  72                 } catch (Exception e) {
  73                         // TODO Auto-generated catch block
  74                         e.printStackTrace();
  75                 }
  76         }
  77
  78         public void testMaven() {
  79                 Thread.currentThread().setContextClassLoader(
  80                                 getClass().getClassLoader());
  81                 String[] goals = { "-o", "-e", "-f",
  82                                 "/home/mbaudier/dev/src/slc/dist/org.argeo.slc.sdk/pom.xml",
  83                                 "dependency:tree" };
  84
  85                 // String m2Home = "/opt/apache-maven-3.0.1";
  86                 // System.setProperty("classworlds.conf", m2Home + "/bin/m2.conf");
  87                 // System.setProperty("maven.home", m2Home);
  88                 //
  89                 // Launcher.main(goals);
  90
  91                 CustomCli mavenCli = new CustomCli();
  92                 mavenCli.doMain(goals,
  93                                 "/home/mbaudier/dev/src/slc/dist/org.argeo.slc.sdk",
  94                                 System.out, System.err);
  95
  96                 PlexusContainer plexusContainer = mavenCli.getContainer();
  97                 log.debug(plexusContainer.getContext().getContextData());
  98                 plexusContainer.dispose();
  99         }
 100
 101         public void testAether() {
 102                 try {
 103                         RepositorySystem repoSystem = newRepositorySystem();
 104
 105                         RepositorySystemSession session = newSession(repoSystem);
 106
 107                         Dependency dependency = new Dependency(new DefaultArtifact(
 108                                         "org.argeo.slc.dep:org.argeo.slc.dep.sdk:0.13.1-SNAPSHOT"),
 109                                         "compile");
 110                         RemoteRepository argeo = new RemoteRepository("argeo", "default",
 111                                         "http://maven.argeo.org/argeo/");
 112                         RemoteRepository argeoSnapshots = new RemoteRepository(
 113                                         "argeo-snapshots", "default",
 114                                         "http://dev.argeo.org/maven/argeo-snapshots/");
 115
 116                         CollectRequest collectRequest = new CollectRequest();
 117                         collectRequest.setRoot(dependency);
 118                         collectRequest.addRepository(argeo);
 119                         collectRequest.addRepository(argeoSnapshots);
 120                         DependencyNode node = repoSystem.collectDependencies(session,
 121                                         collectRequest).getRoot();
 122
 123                         repoSystem.resolveDependencies(session, node, null);
 124
 125                         PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
 126                         node.accept(nlg);
 127
 128                         for (Artifact artifact : nlg.getArtifacts(true)) {
 129                                 log.debug(artifact);
 130                         }
 131
 132                         logDependencyNode(0, node);
 133                         // System.out.println(nlg.getClassPath());
 134
 135                 } catch (Exception e) {
 136                         throw new SlcException("Cannot resolve", e);
 137                 }
 138
 139         }
 140
 141         private void logDependencyNode(int depth, DependencyNode dependencyNode) {
 142                 StringBuffer prefix = new StringBuffer(depth * 2 + 2);
 143                 // prefix.append("|-");
 144                 for (int i = 0; i < depth * 2; i++) {
 145                         prefix.append(' ');
 146                 }
 147                 Artifact artifact = dependencyNode.getDependency().getArtifact();
 148                 log.debug(prefix + "|-> " + artifact.getArtifactId() + " ["
 149                                 + artifact.getVersion() + "]");
 150                 for (DependencyNode child : dependencyNode.getChildren())
 151                         logDependencyNode(depth + 1, child);
 152         }
 153
 154         private RepositorySystem newRepositorySystem() {
 155                 try {
 156                         // return new
 157                         // DefaultPlexusContainer().lookup(RepositorySystem.class);
 158
 159                         DefaultServiceLocator locator = new DefaultServiceLocator();
 160
 161                         locator.setServices(WagonProvider.class, new ManualWagonProvider());
 162                         locator.addService(RepositoryConnectorFactory.class,
 163                                         WagonRepositoryConnectorFactory.class);
 164
 165                         return locator.getService(RepositorySystem.class);
 166                 } catch (Exception e) {
 167                         throw new SlcException("Cannot lookup repository system", e);
 168                 }
 169         }
 170
 171         private RepositorySystemSession newSession(RepositorySystem system) {
 172                 MavenRepositorySystemSession session = new MavenRepositorySystemSession();
 173
 174                 LocalRepository localRepo = new LocalRepository(
 175                                 System.getProperty("user.home") + "/.m2/repository");
 176                 session.setLocalRepositoryManager(system
 177                                 .newLocalRepositoryManager(localRepo));
 178                 session.setTransferListener(new ConsoleTransferListener(System.out));
 179                 session.setRepositoryListener(new ConsoleRepositoryListener());
 180
 181                 return session;
 182         }
 183
 184         public static void main(String[] args) {
 185                 new MavenManager().init();
 186         }
 187
 188         static class CustomCli extends MavenCli {
 189                 private PlexusContainer container;
 190
 191                 @Override
 192                 protected void customizeContainer(PlexusContainer container) {
 193                         this.container = container;
 194                 }
 195
 196                 public PlexusContainer getContainer() {
 197                         return container;
 198                 }
 199
 200         }
 201         /*
 202          * private final Log log = LogFactory.getLog(getClass());
 203          *
 204          * private String localRepositoryPath = System.getProperty("user.home") +
 205          * File.separator + ".m2" + File.separator + "repository";
 206          *
 207          * private ArtifactRepository localRepository; private
 208          * List<ArtifactRepository> remoteRepositoriesInternal; private
 209          * List<RemoteRepository> remoteRepositories = new
 210          * Vector<RemoteRepository>();
 211          *
 212          * private MavenEmbedder mavenEmbedder; private ClassLoader classLoader;
 213          * private Boolean offline = false;
 214          *
 215          * public void init() { try { mavenEmbedder = new SlcMavenEmbedder();
 216          * mavenEmbedder.setOffline(offline); //
 217          * mavenEmbedder.setAlignWithUserInstallation(true); if (classLoader !=
 218          * null) mavenEmbedder.setClassLoader(classLoader); else
 219          * mavenEmbedder.setClassLoader(getClass().getClassLoader()); // else //
 220          * mavenEmbedder.setClassLoader(Thread.currentThread() //
 221          * .getContextClassLoader()); mavenEmbedder.start();
 222          *
 223          * mavenEmbedder.setLocalRepositoryDirectory(new File(
 224          * localRepositoryPath));
 225          *
 226          * localRepository = mavenEmbedder.getLocalRepository();
 227          *
 228          * remoteRepositoriesInternal = new Vector<ArtifactRepository>(); for
 229          * (RemoteRepository remoteRepository : remoteRepositories) {
 230          *
 231          * ArtifactRepository repository = mavenEmbedder.createRepository(
 232          * remoteRepository.getUrl(), remoteRepository.getId());
 233          * remoteRepositoriesInternal.add(repository); }
 234          *
 235          * MavenFile mavenFile = new MavenFile();
 236          * mavenFile.setGroupId("org.argeo.slc.dist");
 237          * mavenFile.setArtifactId("org.argeo.slc.sdk");
 238          * mavenFile.setVersion("0.12.2-SNAPSHOT"); mavenFile.setType("pom");
 239          * Artifact artifact = resolve(mavenFile); log.debug("Location of " +
 240          * artifact + " : " + artifact.getFile()); // log.debug("Dependencies of " +
 241          * artifact); // for (Object obj : artifact.getDependencyTrail()) { //
 242          * log.debug("  " + obj); // }
 243          *
 244          * File pomFile = new File(
 245          * "/home/mbaudier/dev/src/slc/dist/org.argeo.slc.sdk/pom.xml");
 246          * MavenProject project = mavenEmbedder
 247          * .readProjectWithDependencies(pomFile); // MavenProject project =
 248          * mavenEmbedder // .readProjectWithDependencies(artifact.getFile());
 249          *
 250          * // EventMonitor eventMonitor = new EventMonitor() { // // public void
 251          * startEvent(String eventName, String target, // long timestamp) { //
 252          * log.debug(eventName + ", " + target + ", " + timestamp); // } // //
 253          * public void errorEvent(String eventName, String target, // long
 254          * timestamp, Throwable cause) { // log.debug(eventName + ", " + target +
 255          * ", " + timestamp); // } // // public void endEvent(String eventName,
 256          * String target, // long timestamp) { // log.debug(eventName + ", " +
 257          * target + ", " + timestamp); // } // }; // // String[] goals = { "clean",
 258          * "install" }; // mavenEmbedder.execute(project, Arrays.asList(goals), //
 259          * eventMonitor, // null, null, pomFile.getParentFile());
 260          *
 261          * Set<Artifact> transitDeps = getTransitiveProjectDependencies( project,
 262          * remoteRepositoriesInternal, localRepository);
 263          * log.debug(transitDeps.size() + " dependencies for " + artifact); for
 264          * (Object obj : transitDeps) { log.debug("  " + obj); }
 265          *
 266          * } catch (Exception e) { throw new
 267          * SlcException("Cannot initialize Maven manager", e); } }
 268          *
 269          * @SuppressWarnings("unchecked") public Set<Artifact>
 270          * getTransitiveProjectDependencies(MavenProject project,
 271          * List<ArtifactRepository> remoteRepos, ArtifactRepository local) {
 272          * Embedder embedder = mavenEmbedder.getEmbedder(); try { ArtifactFactory
 273          * artifactFactory = (ArtifactFactory) embedder
 274          * .lookup(ArtifactFactory.ROLE);
 275          *
 276          * ArtifactResolver artifactResolver = (ArtifactResolver) embedder
 277          * .lookup(ArtifactResolver.ROLE);
 278          *
 279          * ArtifactMetadataSource artifactMetadataSource = (ArtifactMetadataSource)
 280          * embedder .lookup(ArtifactMetadataSource.ROLE);
 281          *
 282          * Set<Artifact> artifacts = project.createArtifacts(artifactFactory, null,
 283          * null);
 284          *
 285          * ArtifactResolutionResult arr = artifactResolver
 286          * .resolveTransitively(artifacts, project.getArtifact(), local,
 287          * remoteRepos, artifactMetadataSource, null);
 288          *
 289          * return arr.getArtifacts(); } catch (Exception e) { throw new
 290          * SlcException("Cannot resolve dependency for " + project, e); } // Order,
 291          * just for display // Set dependencies = new TreeSet(new
 292          * ArtifactComparator()); // dependencies.addAll(arr.getArtifacts()); //
 293          * return dependencies; }
 294          *
 295          * private Artifact resolve(MavenFile mavenDistribution) { try { Artifact
 296          * artifact; if (mavenDistribution.getClassifier() == null) { artifact =
 297          * mavenEmbedder.createArtifact(mavenDistribution .getGroupId(),
 298          * mavenDistribution.getArtifactId(), mavenDistribution.getVersion(),
 299          * Artifact.SCOPE_PROVIDED, mavenDistribution.getType()); } else { artifact
 300          * = mavenEmbedder.createArtifactWithClassifier(
 301          * mavenDistribution.getGroupId(), mavenDistribution .getArtifactId(),
 302          * mavenDistribution .getVersion(), mavenDistribution.getType(),
 303          * mavenDistribution.getClassifier()); }
 304          *
 305          * mavenEmbedder.resolve(artifact, remoteRepositoriesInternal,
 306          * localRepository);
 307          *
 308          * return artifact; } catch (Exception e) { throw new
 309          * SlcException("Cannot resolve artifact.", e); } }
 310          *
 311          * public File getPackageLocation(MavenFile mavenDistribution) { return
 312          * resolve(mavenDistribution).getFile(); }
 313          *
 314          * public void destroy() { try { if (mavenEmbedder != null) {
 315          * mavenEmbedder.stop(); } } catch (MavenEmbedderException e) {
 316          * log.error("Cannot destroy Maven manager", e); } }
 317          *
 318          * public void setLocalRepositoryPath(String localRepositoryPath) {
 319          * this.localRepositoryPath = localRepositoryPath; }
 320          *
 321          * public List<RemoteRepository> getRemoteRepositories() { return
 322          * remoteRepositories; }
 323          *
 324          * public void setRemoteRepositories(List<RemoteRepository>
 325          * remoteRepositories) { this.remoteRepositories = remoteRepositories; }
 326          *
 327          * public void setClassLoader(ClassLoader classLoader) { this.classLoader =
 328          * classLoader; }
 329          *
 330          * public void setOffline(Boolean offline) { this.offline = offline; }
 331          */
 332 }