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