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

   1 package org.argeo.slc.maven;
   2
   3 import java.io.File;
   4 import java.util.List;
   5 import java.util.Set;
   6 import java.util.Vector;
   7
   8 import org.apache.commons.logging.Log;
   9 import org.apache.commons.logging.LogFactory;
  10 import org.apache.maven.artifact.Artifact;
  11 import org.apache.maven.artifact.factory.ArtifactFactory;
  12 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
  13 import org.apache.maven.artifact.repository.ArtifactRepository;
  14 import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
  15 import org.apache.maven.artifact.resolver.ArtifactResolver;
  16 import org.apache.maven.project.MavenProject;
  17 import org.argeo.slc.SlcException;
  18 import org.argeo.slc.maven.embedder.MavenEmbedderException;
  19 import org.codehaus.plexus.embed.Embedder;
  20
  21 public class MavenManager {
  22
  23         private final Log log = LogFactory.getLog(getClass());
  24
  25         private String localRepositoryPath = System.getProperty("user.home")
  26                         + File.separator + ".m2" + File.separator + "repository";
  27
  28         private ArtifactRepository localRepository;
  29         private List<ArtifactRepository> remoteRepositoriesInternal;
  30         private List<RemoteRepository> remoteRepositories = new Vector<RemoteRepository>();
  31
  32         private SlcMavenEmbedder mavenEmbedder;
  33         private ClassLoader classLoader;
  34         private Boolean offline = false;
  35
  36         public void init() {
  37                 try {
  38                         mavenEmbedder = new SlcMavenEmbedder();
  39                         mavenEmbedder.setOffline(offline);
  40                         // mavenEmbedder.setAlignWithUserInstallation(true);
  41                         if (classLoader != null)
  42                                 mavenEmbedder.setClassLoader(classLoader);
  43                         else
  44                                 mavenEmbedder.setClassLoader(getClass().getClassLoader());
  45                         // else
  46                         // mavenEmbedder.setClassLoader(Thread.currentThread()
  47                         // .getContextClassLoader());
  48                         mavenEmbedder.start();
  49
  50                         mavenEmbedder.setLocalRepositoryDirectory(new File(
  51                                         localRepositoryPath));
  52
  53                         localRepository = mavenEmbedder.getLocalRepository();
  54
  55                         remoteRepositoriesInternal = new Vector<ArtifactRepository>();
  56                         for (RemoteRepository remoteRepository : remoteRepositories) {
  57
  58                                 ArtifactRepository repository = mavenEmbedder.createRepository(
  59                                                 remoteRepository.getUrl(), remoteRepository.getId());
  60                                 remoteRepositoriesInternal.add(repository);
  61                         }
  62
  63                         MavenFile mavenFile = new MavenFile();
  64                         mavenFile.setGroupId("org.argeo.slc.dist");
  65                         mavenFile.setArtifactId("org.argeo.slc.sdk");
  66                         mavenFile.setVersion("0.12.2-SNAPSHOT");
  67                         mavenFile.setType("pom");
  68                         Artifact artifact = resolve(mavenFile);
  69                         log.debug("Location of " + artifact + " : " + artifact.getFile());
  70                         // log.debug("Dependencies of " + artifact);
  71                         // for (Object obj : artifact.getDependencyTrail()) {
  72                         // log.debug("  " + obj);
  73                         // }
  74
  75                         File pomFile = new File(
  76                                         "/home/mbaudier/dev/src/slc/dist/org.argeo.slc.sdk/pom.xml");
  77                         MavenProject project = mavenEmbedder
  78                                         .readProjectWithDependencies(pomFile);
  79                         // MavenProject project = mavenEmbedder
  80                         // .readProjectWithDependencies(artifact.getFile());
  81
  82                         // EventMonitor eventMonitor = new EventMonitor() {
  83                         //
  84                         // public void startEvent(String eventName, String target,
  85                         // long timestamp) {
  86                         // log.debug(eventName + ", " + target + ", " + timestamp);
  87                         // }
  88                         //
  89                         // public void errorEvent(String eventName, String target,
  90                         // long timestamp, Throwable cause) {
  91                         // log.debug(eventName + ", " + target + ", " + timestamp);
  92                         // }
  93                         //
  94                         // public void endEvent(String eventName, String target,
  95                         // long timestamp) {
  96                         // log.debug(eventName + ", " + target + ", " + timestamp);
  97                         // }
  98                         // };
  99                         //
 100                         // String[] goals = { "clean", "install" };
 101                         // mavenEmbedder.execute(project, Arrays.asList(goals),
 102                         // eventMonitor,
 103                         // null, null, pomFile.getParentFile());
 104
 105                         Set<Artifact> transitDeps = getTransitiveProjectDependencies(
 106                                         project, remoteRepositoriesInternal, localRepository);
 107                         log.debug(transitDeps.size() + " dependencies for " + artifact);
 108                         for (Object obj : transitDeps) {
 109                                 log.debug("  " + obj);
 110                         }
 111
 112                 } catch (Exception e) {
 113                         throw new SlcException("Cannot initialize Maven manager", e);
 114                 }
 115         }
 116
 117         @SuppressWarnings("unchecked")
 118         public Set<Artifact> getTransitiveProjectDependencies(MavenProject project,
 119                         List<ArtifactRepository> remoteRepos, ArtifactRepository local) {
 120                 Embedder embedder = mavenEmbedder.getEmbedder();
 121                 try {
 122                         ArtifactFactory artifactFactory = (ArtifactFactory) embedder
 123                                         .lookup(ArtifactFactory.ROLE);
 124
 125                         ArtifactResolver artifactResolver = (ArtifactResolver) embedder
 126                                         .lookup(ArtifactResolver.ROLE);
 127
 128                         ArtifactMetadataSource artifactMetadataSource = (ArtifactMetadataSource) embedder
 129                                         .lookup(ArtifactMetadataSource.ROLE);
 130
 131                         Set<Artifact> artifacts = project.createArtifacts(artifactFactory,
 132                                         null, null);
 133
 134                         ArtifactResolutionResult arr = artifactResolver
 135                                         .resolveTransitively(artifacts, project.getArtifact(),
 136                                                         local, remoteRepos, artifactMetadataSource, null);
 137
 138                         return arr.getArtifacts();
 139                 } catch (Exception e) {
 140                         throw new SlcException("Cannot resolve dependency for " + project,
 141                                         e);
 142                 }
 143                 // Order, just for display
 144                 // Set dependencies = new TreeSet(new ArtifactComparator());
 145                 // dependencies.addAll(arr.getArtifacts());
 146                 // return dependencies;
 147         }
 148
 149         private Artifact resolve(MavenFile mavenDistribution) {
 150                 try {
 151                         Artifact artifact;
 152                         if (mavenDistribution.getClassifier() == null) {
 153                                 artifact = mavenEmbedder.createArtifact(mavenDistribution
 154                                                 .getGroupId(), mavenDistribution.getArtifactId(),
 155                                                 mavenDistribution.getVersion(),
 156                                                 Artifact.SCOPE_PROVIDED, mavenDistribution.getType());
 157                         } else {
 158                                 artifact = mavenEmbedder.createArtifactWithClassifier(
 159                                                 mavenDistribution.getGroupId(), mavenDistribution
 160                                                                 .getArtifactId(), mavenDistribution
 161                                                                 .getVersion(), mavenDistribution.getType(),
 162                                                 mavenDistribution.getClassifier());
 163                         }
 164
 165                         mavenEmbedder.resolve(artifact, remoteRepositoriesInternal,
 166                                         localRepository);
 167
 168                         return artifact;
 169                 } catch (Exception e) {
 170                         throw new SlcException("Cannot resolve artifact.", e);
 171                 }
 172         }
 173
 174         public File getPackageLocation(MavenFile mavenDistribution) {
 175                 return resolve(mavenDistribution).getFile();
 176         }
 177
 178         public void destroy() {
 179                 try {
 180                         if (mavenEmbedder != null) {
 181                                 mavenEmbedder.stop();
 182                         }
 183                 } catch (MavenEmbedderException e) {
 184                         log.error("Cannot destroy Maven manager", e);
 185                 }
 186         }
 187
 188         public void setLocalRepositoryPath(String localRepositoryPath) {
 189                 this.localRepositoryPath = localRepositoryPath;
 190         }
 191
 192         public List<RemoteRepository> getRemoteRepositories() {
 193                 return remoteRepositories;
 194         }
 195
 196         public void setRemoteRepositories(List<RemoteRepository> remoteRepositories) {
 197                 this.remoteRepositories = remoteRepositories;
 198         }
 199
 200         public void setClassLoader(ClassLoader classLoader) {
 201                 this.classLoader = classLoader;
 202         }
 203
 204         public void setOffline(Boolean offline) {
 205                 this.offline = offline;
 206         }
 207
 208 }