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