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