org.argeo.slc.server.h2,\
org.argeo.slc.server.hibernate,\
org.argeo.slc.server.services,\
-
-#org.argeo.server.ads.server,\
-#org.argeo.security.manager.ldap,\
-#org.argeo.security.services,\
-#org.argeo.security.manager.ldap,\
+org.argeo.server.ads.server,\
+org.argeo.security.manager.ldap,\
+org.argeo.security.services,\
#org.argeo.security.ui.initialPerspective=com.agfa.sebi.client.ui.consultEbiPerspective
--- /dev/null
+argeo.osgi.start=\
+org.springframework.osgi.extender,\
+org.argeo.slc.support.maven,\
+org.argeo.slc.server.repo,\
+
+log4j.configuration=file:../../log4j.properties
<artifactId>org.argeo.slc.support.ws.client</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.argeo.slc.runtime</groupId>
+ <artifactId>org.argeo.slc.repo</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<!-- Commons -->
<dependency>
<goal>pde-sources</goal>
</goals>
<phase>generate-resources</phase>
- <configuration>
- <copyArtifacts>false</copyArtifacts>
- </configuration>
</execution>
<execution>
<id>generate-descriptors</id>
Bundle-SymbolicName: org.argeo.slc.it.webapp
Bundle-Version: 0.13.1.SNAPSHOT
Import-Package: junit.framework;version="3.8.2",
- org.argeo.slc;version="0.13.0.SNAPSHOT-r3650",
- org.argeo.slc.msg;version="0.13.0.SNAPSHOT-r3653",
- org.argeo.slc.runtime;version="0.13.0.SNAPSHOT-r3650",
- org.argeo.slc.server;version="0.13.0.SNAPSHOT-r3650",
- org.argeo.slc.server.client;version="0.13.0.SNAPSHOT-r3641",
- org.argeo.slc.server.unit;version="0.13.0.SNAPSHOT-r3641"
+ org.argeo.slc,
+ org.argeo.slc.msg,
+ org.argeo.slc.runtime,
+ org.argeo.slc.server,
+ org.argeo.slc.server.client,
+ org.argeo.slc.server.unit
Bundle-RequiredExecutionEnvironment: J2SE-1.5
org.argeo.slc.demo.ant
</argeo.osgi.start>
<argeo.server.port.http>7080</argeo.server.port.http>
- <!-- <argeo.osgi.start> org.springframework.osgi.extender, org.argeo.server.ads.server,
- org.argeo.slc.server.jackrabbit.derby, org.argeo.slc.server.jcr, org.argeo.slc.server.main,
- org.argeo.slc.ria, org.argeo.slc.agent, org.argeo.slc.agent.jms, org.argeo.slc.demo.minimal,
- org.argeo.slc.demo.basic, org.argeo.slc.demo.ant </argeo.osgi.start> -->
</systemProperties>
</configuration>
<executions>
<dependencies>
<dependency>
<groupId>org.argeo.slc.dep</groupId>
- <artifactId>org.argeo.slc.dep.sdk</artifactId>
+ <artifactId>org.argeo.slc.dep.sdk.rcp</artifactId>
<version>${project.version}</version>
</dependency>
<!-- Unit Tests -->
Bundle-Name: Repo
Bundle-SymbolicName: org.argeo.slc.server.repo
Bundle-Version: 1.0.0.qualifier
+Import-Package: org.argeo.slc.aether,
+ org.argeo.slc.aether.spring,
+ org.argeo.slc.repo.maven,
+ org.sonatype.aether;version="1.9.0"
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
+ xmlns:util="http://www.springframework.org/schema/util"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
+ http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd
+ ">
+
+
+ <bean class="org.argeo.slc.repo.maven.ImportMavenDependencies"
+ init-method="run">
+ <property name="rootCoordinates"
+ value="org.argeo.dep:versions-all:pom:1.1.3-SNAPSHOT" />
+ <property name="aetherTemplate" ref="mavenAetherTemplate" />
+ <property name="excludedArtifacts">
+ <set>
+ <value>org.apache.commons:com.springsource.org.apache.commons.logging
+ </value>
+ <value>org.osgi:org.osgi.core</value>
+ <value>org.easymock:easymock</value>
+ </set>
+ </property>
+ </bean>
+
+ <bean id="mavenAetherTemplate" class="org.argeo.slc.aether.AetherTemplate">
+ <property name="repositorySystem" ref="mavenRepositorySystem" />
+ <property name="repositorySystemSession" ref="mavenRepositorySystemSession" />
+ <property name="remoteRepositories" ref="defaultMavenRepositories" />
+ </bean>
+
+ <!-- Remote repositories -->
+ <util:list id="defaultMavenRepositories">
+ <ref local="central" />
+ <ref local="com.springsource.repository.bundles.external" />
+ <ref local="com.springsource.repository.bundles.release" />
+ <ref local="argeo" />
+ <ref local="argeo-snapshots" />
+ </util:list>
+
+ <bean id="central" class="org.argeo.slc.aether.spring.RemoteRepositoryFactory">
+ <property name="url" value="http://repo1.maven.org/maven2" />
+ </bean>
+ <bean id="com.springsource.repository.bundles.release" class="org.argeo.slc.aether.spring.RemoteRepositoryFactory">
+ <property name="url"
+ value="http://repository.springsource.com/maven/bundles/release" />
+ </bean>
+ <bean id="com.springsource.repository.bundles.external" class="org.argeo.slc.aether.spring.RemoteRepositoryFactory">
+ <property name="url"
+ value="http://repository.springsource.com/maven/bundles/external" />
+ </bean>
+ <bean id="argeo" class="org.argeo.slc.aether.spring.RemoteRepositoryFactory">
+ <property name="url" value="http://maven.argeo.org/argeo/" />
+ </bean>
+ <bean id="argeo-snapshots" class="org.argeo.slc.aether.spring.RemoteRepositoryFactory">
+ <property name="url" value="http://dev.argeo.org/maven/argeo-snapshots/" />
+ </bean>
+
+</beans>
\ No newline at end of file
http://www.springframework.org/schema/beans \r
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd\r
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.xsd">\r
+ <!-- <reference id="jcrRepository" interface="javax.jcr.Repository" /> -->\r
\r
- <reference id="jcrRepository" interface="javax.jcr.Repository" />\r
+ <!-- Maven -->\r
+ <reference id="mavenRepositorySystem" interface="org.sonatype.aether.RepositorySystem"\r
+ filter="(aether.repositorySystemType=maven)" />\r
+ <reference id="mavenRepositorySystemSession" interface="org.sonatype.aether.RepositorySystemSession"\r
+ filter="(aether.repositorySystemType=maven)" />\r
</beans:beans>
\ No newline at end of file
--- /dev/null
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.argeo.slc</groupId>
+ <artifactId>runtime</artifactId>
+ <version>0.13.1-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+ <groupId>org.argeo.slc.runtime</groupId>
+ <artifactId>org.argeo.slc.repo</artifactId>
+ <name>SLC Repository</name>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <version>${version.maven-bundle-plugin}</version>
+ <configuration>
+ <instructions>
+ <Export-Package>
+ org.argeo.slc.repo.*
+ </Export-Package>
+ </instructions>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ <dependencies>
+ <dependency>
+ <groupId>org.argeo.slc.runtime</groupId>
+ <artifactId>org.argeo.slc.support.aether</artifactId>
+ <version>0.13.1-SNAPSHOT</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>com.springsource.slf4j.org.apache.commons.logging</artifactId>
+ </dependency>
+
+ </dependencies>
+</project>
--- /dev/null
+package org.argeo.slc.repo.maven;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Properties;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.aether.AetherTemplate;
+import org.argeo.slc.aether.AetherUtils;
+import org.sonatype.aether.artifact.Artifact;
+import org.sonatype.aether.graph.DependencyNode;
+import org.sonatype.aether.util.artifact.DefaultArtifact;
+import org.sonatype.aether.util.graph.PreorderNodeListGenerator;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+public class ImportMavenDependencies implements Runnable {
+ private final static Log log = LogFactory
+ .getLog(ImportMavenDependencies.class);
+
+ private AetherTemplate aetherTemplate;
+ private String rootCoordinates;
+ private Set<String> excludedArtifacts = new HashSet<String>();
+
+ public void run() {
+ try {
+ Artifact pomArtifact = new DefaultArtifact(rootCoordinates);
+
+ // {
+ // DependencyNode node = aetherTemplate
+ // .resolveDependencies(pomArtifact);
+ //
+ // PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
+ // node.accept(nlg);
+ //
+ // for (Artifact artifact : nlg.getArtifacts(true)) {
+ // log.debug(artifact);
+ // }
+ // AetherUtils.logDependencyNode(0, node);
+ // }
+
+ Comparator<Artifact> artifactComparator = new Comparator<Artifact>() {
+ public int compare(Artifact o1, Artifact o2) {
+ return o1.getArtifactId().compareTo(o2.getArtifactId());
+ }
+ };
+
+ Set<Artifact> registeredArtifacts = new TreeSet<Artifact>(
+ artifactComparator);
+ parsePom(aetherTemplate, registeredArtifacts, pomArtifact);
+ if (log.isDebugEnabled())
+ log.debug("Gathered " + registeredArtifacts.size()
+ + " artifacts");
+
+ // Resolve and add non-optional dependencies
+ Set<Artifact> artifacts = new TreeSet<Artifact>(artifactComparator);
+ for (Artifact artifact : registeredArtifacts) {
+ try {
+ addArtifact(artifacts, artifact);
+ DependencyNode node = aetherTemplate
+ .resolveDependencies(artifact);
+ addDependencies(artifacts, node);
+ } catch (Exception e) {
+ log.error("Could not resolve dependencies of " + artifact
+ + ": " + e.getCause().getMessage());
+ }
+
+ }
+
+ if (log.isDebugEnabled())
+ log.debug("Resolved " + artifacts.size() + " artifacts");
+ Properties distributionDescriptor = new Properties();
+ for (Artifact artifact : artifacts) {
+ log.debug(artifact.getArtifactId() + " ["
+ + artifact.getVersion() + "]\t(" + artifact + ")");
+ distributionDescriptor.setProperty(artifact.getArtifactId()
+ + ":" + artifact.getVersion(), artifact.toString());
+ }
+
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ distributionDescriptor.store(out, "");
+ log.debug(new String(out.toByteArray()));
+ out.close();
+ } catch (Exception e) {
+ throw new SlcException("Cannot resolve", e);
+ }
+ }
+
+ /** Recursively adds non optional dependencies */
+ private void addDependencies(Set<Artifact> artifacts, DependencyNode node) {
+ for (DependencyNode child : node.getChildren()) {
+ if (!child.getDependency().isOptional()) {
+ addArtifact(artifacts, child.getDependency().getArtifact());
+ addDependencies(artifacts, child);
+ }
+ }
+ }
+
+ private void addArtifact(Set<Artifact> artifacts, Artifact artifact) {
+ if (!excludedArtifacts.contains(artifact.getGroupId() + ":"
+ + artifact.getArtifactId()))
+ artifacts.add(artifact);
+ }
+
+ /**
+ * Directly parses Maven POM XML format in order to find all artifacts
+ * references under the dependency and dependencyManagement tags. This is
+ * meant to migrate existing pom registering a lot of artifacts, not to
+ * replace Maven resolving.
+ */
+ protected void parsePom(AetherTemplate aetherTemplate,
+ Set<Artifact> artifacts, Artifact pomArtifact) {
+ if (log.isDebugEnabled())
+ log.debug("Gather dependencies for " + pomArtifact);
+
+ try {
+ File file = aetherTemplate.getResolvedFile(pomArtifact);
+ DocumentBuilder documentBuilder = DocumentBuilderFactory
+ .newInstance().newDocumentBuilder();
+ Document doc = documentBuilder.parse(file);
+
+ // properties
+ Properties props = new Properties();
+ props.setProperty("project.version", pomArtifact.getBaseVersion());
+ NodeList properties = doc.getElementsByTagName("properties");
+ if (properties.getLength() > 0) {
+ NodeList propertiesElems = properties.item(0).getChildNodes();
+ for (int i = 0; i < propertiesElems.getLength(); i++) {
+ if (propertiesElems.item(i) instanceof Element) {
+ Element property = (Element) propertiesElems.item(i);
+ props.put(property.getNodeName(),
+ property.getTextContent());
+ }
+ }
+ }
+
+ // dependencies (direct and dependencyManagement)
+ NodeList dependencies = doc.getElementsByTagName("dependency");
+ for (int i = 0; i < dependencies.getLength(); i++) {
+ Element dependency = (Element) dependencies.item(i);
+ String groupId = dependency.getElementsByTagName("groupId")
+ .item(0).getTextContent().trim();
+ String artifactId = dependency
+ .getElementsByTagName("artifactId").item(0)
+ .getTextContent().trim();
+ String version = dependency.getElementsByTagName("version")
+ .item(0).getTextContent().trim();
+ if (version.startsWith("${")) {
+ String versionKey = version.substring(0,
+ version.length() - 1).substring(2);
+ if (!props.containsKey(versionKey))
+ throw new SlcException("Cannot interpret version "
+ + version);
+ version = props.getProperty(versionKey);
+ }
+ NodeList scopes = dependency.getElementsByTagName("scope");
+ if (scopes.getLength() > 0
+ && scopes.item(0).getTextContent().equals("import")) {
+ // recurse
+ parsePom(aetherTemplate, artifacts, new DefaultArtifact(
+ groupId, artifactId, "pom", version));
+ } else {
+ // TODO: deal with scope?
+ // TODO: deal with type
+ String type = "jar";
+ Artifact artifact = new DefaultArtifact(groupId,
+ artifactId, type, version);
+ artifacts.add(artifact);
+ }
+ }
+ } catch (Exception e) {
+ throw new SlcException("Cannot process " + pomArtifact, e);
+ }
+ }
+
+ public void setAetherTemplate(AetherTemplate aetherTemplate) {
+ this.aetherTemplate = aetherTemplate;
+ }
+
+ public void setExcludedArtifacts(Set<String> excludedArtifactIds) {
+ this.excludedArtifacts = excludedArtifactIds;
+ }
+
+ public void setRootCoordinates(String rootCoordinates) {
+ this.rootCoordinates = rootCoordinates;
+ }
+
+}
\r
/** Basis for all SLC exceptions. This is an unchecked exception. */\r
public class SlcException extends RuntimeException {\r
- static final long serialVersionUID = 1l;\r
+ private static final long serialVersionUID = 6373738619304106445L;\r
\r
/** Constructor. */\r
public SlcException(String message) {\r
}\r
\r
/** Constructor. */\r
- public SlcException(String message, Throwable cause) {\r
- super(message, cause);\r
+ public SlcException(String message, Throwable e) {\r
+ super(message, e);\r
}\r
\r
}\r
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+ <classpathentry kind="src" path="src/main/java"/>
+ <classpathentry kind="output" path="target/classes"/>
+</classpath>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.argeo.slc.support.aether</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.ManifestBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.SchemaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
--- /dev/null
+#Sun Feb 13 11:00:00 CET 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.5
--- /dev/null
+#Sun Feb 13 11:00:00 CET 2011
+eclipse.preferences.version=1
+pluginProject.extensions=false
+resolve.requirebundle=false
--- /dev/null
+source.. = src/main/java/
+output.. = target/classes/
+bin.includes = META-INF/,\
+ .
--- /dev/null
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.argeo.slc</groupId>
+ <artifactId>runtime</artifactId>
+ <version>0.13.1-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+ <groupId>org.argeo.slc.runtime</groupId>
+ <artifactId>org.argeo.slc.support.aether</artifactId>
+ <name>SLC Support Aether</name>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <version>${version.maven-bundle-plugin}</version>
+ <configuration>
+ <instructions>
+ <Export-Package>
+ org.argeo.slc.aether.*
+ </Export-Package>
+ </instructions>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ <dependencies>
+ <dependency>
+ <groupId>org.argeo.slc.runtime</groupId>
+ <artifactId>org.argeo.slc.core</artifactId>
+ <version>0.13.1-SNAPSHOT</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.argeo.dep.osgi</groupId>
+ <artifactId>org.argeo.dep.osgi.aether</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>org.springframework.beans</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>com.springsource.slf4j.org.apache.commons.logging</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>org.eclipse.osgi</groupId>
+ <artifactId>org.eclipse.osgi</artifactId>
+ <scope>provided</scope>
+ </dependency>
+ </dependencies>
+</project>
--- /dev/null
+package org.argeo.slc.aether;
+
+import java.io.File;
+import java.util.List;
+
+import org.argeo.slc.SlcException;
+import org.sonatype.aether.RepositorySystem;
+import org.sonatype.aether.RepositorySystemSession;
+import org.sonatype.aether.artifact.Artifact;
+import org.sonatype.aether.collection.CollectRequest;
+import org.sonatype.aether.graph.Dependency;
+import org.sonatype.aether.graph.DependencyNode;
+import org.sonatype.aether.repository.RemoteRepository;
+import org.sonatype.aether.resolution.ArtifactRequest;
+import org.sonatype.aether.resolution.ArtifactResolutionException;
+import org.sonatype.aether.resolution.ArtifactResult;
+
+/** Simplifies access to Aether. */
+public class AetherTemplate {
+ private RepositorySystem repositorySystem;
+ private RepositorySystemSession repositorySystemSession;
+ private List<RemoteRepository> remoteRepositories;
+
+ /** Resolves the artifact in order to give access to its file. */
+ public File getResolvedFile(Artifact artifact) {
+ try {
+ ArtifactRequest artifactRequest = new ArtifactRequest(artifact,
+ remoteRepositories, null);
+ ArtifactResult result = repositorySystem.resolveArtifact(
+ repositorySystemSession, artifactRequest);
+ return result.getArtifact().getFile();
+ } catch (ArtifactResolutionException e) {
+ throw new SlcException("Cannot resolve " + artifact, e);
+ }
+ }
+
+ /**
+ * Transitively resolves the dependencies of this artifact (with scope
+ * 'compile')
+ *
+ * @param artifact
+ * the artifact to resolve
+ */
+ public DependencyNode resolveDependencies(Artifact artifact) {
+ return resolveDependencies(artifact, "compile");
+ }
+
+ /**
+ * Transitively resolves the dependencies of this artifact.
+ *
+ * @param artifact
+ * the artifact to resolve
+ * @param scope
+ * the scope
+ */
+ public DependencyNode resolveDependencies(Artifact artifact, String scope) {
+ try {
+ Dependency dependency = new Dependency(artifact, scope);
+ CollectRequest collectRequest = new CollectRequest();
+ collectRequest.setRoot(dependency);
+ for (RemoteRepository remoteRepository : remoteRepositories)
+ collectRequest.addRepository(remoteRepository);
+ DependencyNode node = repositorySystem.collectDependencies(
+ repositorySystemSession, collectRequest).getRoot();
+
+ repositorySystem.resolveDependencies(repositorySystemSession, node,
+ null);
+ return node;
+ } catch (Exception e) {
+ throw new SlcException("Cannot resolve dependencies of " + artifact
+ + " (scope: " + scope + ")", e);
+ }
+ }
+
+ public RepositorySystem getRepositorySystem() {
+ return repositorySystem;
+ }
+
+ public void setRepositorySystem(RepositorySystem repositorySystem) {
+ this.repositorySystem = repositorySystem;
+ }
+
+ public RepositorySystemSession getRepositorySystemSession() {
+ return repositorySystemSession;
+ }
+
+ public void setRepositorySystemSession(
+ RepositorySystemSession repositorySystemSession) {
+ this.repositorySystemSession = repositorySystemSession;
+ }
+
+ public List<RemoteRepository> getRemoteRepositories() {
+ return remoteRepositories;
+ }
+
+ public void setRemoteRepositories(List<RemoteRepository> remoteRepositories) {
+ this.remoteRepositories = remoteRepositories;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.aether;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.sonatype.aether.artifact.Artifact;
+import org.sonatype.aether.graph.DependencyNode;
+
+/** Utilities related to Aether */
+public class AetherUtils {
+ private final static Log log = LogFactory.getLog(AetherUtils.class);
+
+ /** Logs a dependency node and its transitive dependencies as a tree. */
+ public static void logDependencyNode(int depth,
+ DependencyNode dependencyNode) {
+ if (!log.isDebugEnabled())
+ return;
+
+ StringBuffer prefix = new StringBuffer(depth * 2 + 2);
+ // prefix.append("|-");
+ for (int i = 0; i < depth * 2; i++) {
+ prefix.append(' ');
+ }
+ Artifact artifact = dependencyNode.getDependency().getArtifact();
+ log.debug(prefix + "|-> " + artifact.getArtifactId() + " ["
+ + artifact.getVersion() + "]"
+ + (dependencyNode.getDependency().isOptional() ? " ?" : ""));
+ for (DependencyNode child : dependencyNode.getChildren()) {
+ logDependencyNode(depth + 1, child);
+ }
+ }
+
+}
--- /dev/null
+package org.argeo.slc.aether;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.sonatype.aether.AbstractRepositoryListener;
+import org.sonatype.aether.RepositoryEvent;
+
+public class ConsoleRepositoryListener extends AbstractRepositoryListener {
+
+ private final static Log log = LogFactory
+ .getLog(ConsoleRepositoryListener.class);
+
+ public void artifactDeployed(RepositoryEvent event) {
+ if (log.isDebugEnabled())
+ log.debug("Deployed " + event.getArtifact() + " to "
+ + event.getRepository());
+ }
+
+ public void artifactDeploying(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Deploying " + event.getArtifact() + " to "
+ + event.getRepository());
+ }
+
+ public void artifactDescriptorInvalid(RepositoryEvent event) {
+ if (log.isDebugEnabled())
+ log.warn("Invalid artifact descriptor for " + event.getArtifact()
+ + ": " + event.getException().getMessage());
+ }
+
+ public void artifactDescriptorMissing(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.warn("Missing artifact descriptor for " + event.getArtifact());
+ }
+
+ public void artifactInstalled(RepositoryEvent event) {
+ if (log.isDebugEnabled())
+ log.debug("Installed " + event.getArtifact() + " to "
+ + event.getFile());
+ }
+
+ public void artifactInstalling(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Installing " + event.getArtifact() + " to "
+ + event.getFile());
+ }
+
+ public void artifactResolved(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Resolved artifact " + event.getArtifact() + " from "
+ + event.getRepository());
+ }
+
+ public void artifactDownloading(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Downloading artifact " + event.getArtifact() + " from "
+ + event.getRepository());
+ }
+
+ public void artifactDownloaded(RepositoryEvent event) {
+ if (log.isDebugEnabled())
+ log.debug("Downloaded artifact " + event.getArtifact() + " from "
+ + event.getRepository());
+ }
+
+ public void artifactResolving(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Resolving artifact " + event.getArtifact());
+ }
+
+ public void metadataDeployed(RepositoryEvent event) {
+ if (log.isDebugEnabled())
+ log.debug("Deployed " + event.getMetadata() + " to "
+ + event.getRepository());
+ }
+
+ public void metadataDeploying(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Deploying " + event.getMetadata() + " to "
+ + event.getRepository());
+ }
+
+ public void metadataInstalled(RepositoryEvent event) {
+ if (log.isDebugEnabled())
+ log.debug("Installed " + event.getMetadata() + " to "
+ + event.getFile());
+ }
+
+ public void metadataInstalling(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Installing " + event.getMetadata() + " to "
+ + event.getFile());
+ }
+
+ public void metadataInvalid(RepositoryEvent event) {
+ if (log.isDebugEnabled())
+ log.debug("Invalid metadata " + event.getMetadata());
+ }
+
+ public void metadataResolved(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Resolved metadata " + event.getMetadata() + " from "
+ + event.getRepository());
+ }
+
+ public void metadataResolving(RepositoryEvent event) {
+ if (log.isTraceEnabled())
+ log.trace("Resolving metadata " + event.getMetadata() + " from "
+ + event.getRepository());
+ }
+
+}
--- /dev/null
+package org.argeo.slc.aether;
+
+import java.io.PrintStream;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.sonatype.aether.transfer.AbstractTransferListener;
+import org.sonatype.aether.transfer.TransferEvent;
+import org.sonatype.aether.transfer.TransferResource;
+
+public class ConsoleTransferListener extends AbstractTransferListener {
+ private final static Log log = LogFactory
+ .getLog(ConsoleTransferListener.class);
+
+ private PrintStream out;
+
+ private Map<TransferResource, Long> downloads = new ConcurrentHashMap<TransferResource, Long>();
+
+ private int lastLength;
+
+ public ConsoleTransferListener(PrintStream out) {
+ this.out = (out != null) ? out : System.out;
+ }
+
+ @Override
+ public void transferInitiated(TransferEvent event) {
+ String message = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploading"
+ : "Downloading";
+
+ if (log.isDebugEnabled())
+ log.debug(message + ": " + event.getResource().getRepositoryUrl()
+ + event.getResource().getResourceName());
+ }
+
+ @Override
+ public void transferProgressed(TransferEvent event) {
+ TransferResource resource = event.getResource();
+ downloads.put(resource, Long.valueOf(event.getTransferredBytes()));
+
+ StringBuilder buffer = new StringBuilder(64);
+
+ for (Map.Entry<TransferResource, Long> entry : downloads.entrySet()) {
+ long total = entry.getKey().getContentLength();
+ long complete = entry.getValue().longValue();
+
+ buffer.append(getStatus(complete, total)).append(" ");
+ }
+
+ int pad = lastLength - buffer.length();
+ lastLength = buffer.length();
+ pad(buffer, pad);
+ buffer.append('\r');
+
+ out.print(buffer);
+ }
+
+ private String getStatus(long complete, long total) {
+ if (total >= 1024) {
+ return toKB(complete) + "/" + toKB(total) + " KB ";
+ } else if (total >= 0) {
+ return complete + "/" + total + " B ";
+ } else if (complete >= 1024) {
+ return toKB(complete) + " KB ";
+ } else {
+ return complete + " B ";
+ }
+ }
+
+ private void pad(StringBuilder buffer, int spaces) {
+ String block = " ";
+ while (spaces > 0) {
+ int n = Math.min(spaces, block.length());
+ buffer.append(block, 0, n);
+ spaces -= n;
+ }
+ }
+
+ @Override
+ public void transferSucceeded(TransferEvent event) {
+ transferCompleted(event);
+
+ TransferResource resource = event.getResource();
+ long contentLength = event.getTransferredBytes();
+ if (contentLength >= 0) {
+ String type = (event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploaded"
+ : "Downloaded");
+ String len = contentLength >= 1024 ? toKB(contentLength) + " KB"
+ : contentLength + " B";
+
+ String throughput = "";
+ long duration = System.currentTimeMillis()
+ - resource.getTransferStartTime();
+ if (duration > 0) {
+ DecimalFormat format = new DecimalFormat("0.0",
+ new DecimalFormatSymbols(Locale.ENGLISH));
+ double kbPerSec = (contentLength / 1024.0)
+ / (duration / 1000.0);
+ throughput = " at " + format.format(kbPerSec) + " KB/sec";
+ }
+
+ out.println(type + ": " + resource.getRepositoryUrl()
+ + resource.getResourceName() + " (" + len + throughput
+ + ")");
+ }
+ }
+
+ @Override
+ public void transferFailed(TransferEvent event) {
+ transferCompleted(event);
+
+ log.error(event.getException().getMessage()
+ + (event.getException().getCause() != null ? " : "
+ + event.getException().getCause().getMessage() : ""));
+ // event.getException().printStackTrace( out );
+ }
+
+ private void transferCompleted(TransferEvent event) {
+ downloads.remove(event.getResource());
+
+ StringBuilder buffer = new StringBuilder(64);
+ pad(buffer, lastLength);
+ buffer.append('\r');
+ out.print(buffer);
+ }
+
+ public void transferCorrupted(TransferEvent event) {
+ event.getException().printStackTrace(out);
+ }
+
+ protected long toKB(long bytes) {
+ return (bytes + 1023) / 1024;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.aether;
+
+import org.sonatype.aether.RepositorySystemSession;
+import org.sonatype.aether.impl.ArtifactDescriptorReader;
+import org.sonatype.aether.resolution.ArtifactDescriptorException;
+import org.sonatype.aether.resolution.ArtifactDescriptorRequest;
+import org.sonatype.aether.resolution.ArtifactDescriptorResult;
+
+public class SimpleArtifactDescriptorReader implements ArtifactDescriptorReader {
+
+ public ArtifactDescriptorResult readArtifactDescriptor(
+ RepositorySystemSession session, ArtifactDescriptorRequest request)
+ throws ArtifactDescriptorException {
+ ArtifactDescriptorResult result = new ArtifactDescriptorResult(request);
+ return result;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.aether;
+
+import org.argeo.slc.aether.osgi.OsgiVersion;
+import org.sonatype.aether.RepositorySystemSession;
+import org.sonatype.aether.impl.VersionRangeResolver;
+import org.sonatype.aether.resolution.VersionRangeRequest;
+import org.sonatype.aether.resolution.VersionRangeResolutionException;
+import org.sonatype.aether.resolution.VersionRangeResult;
+import org.sonatype.aether.version.Version;
+
+public class SimpleVersionRangeResolver implements VersionRangeResolver {
+
+ public VersionRangeResult resolveVersionRange(
+ RepositorySystemSession session, VersionRangeRequest request)
+ throws VersionRangeResolutionException {
+ VersionRangeResult versionRangeResult = new VersionRangeResult(request);
+ Version version = new OsgiVersion(request.getArtifact()
+ .getBaseVersion());
+ versionRangeResult.addVersion(version);
+ return null;
+ }
+}
--- /dev/null
+package org.argeo.slc.aether;
+
+import org.sonatype.aether.RepositorySystemSession;
+import org.sonatype.aether.impl.VersionResolver;
+import org.sonatype.aether.resolution.VersionRequest;
+import org.sonatype.aether.resolution.VersionResolutionException;
+import org.sonatype.aether.resolution.VersionResult;
+
+public class SimpleVersionResolver implements VersionResolver {
+
+ public VersionResult resolveVersion(RepositorySystemSession session,
+ VersionRequest request) throws VersionResolutionException {
+ VersionResult versionResult = new VersionResult(request);
+ versionResult.setVersion(request.getArtifact().getBaseVersion());
+ return versionResult;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.aether.osgi;
+
+import org.osgi.framework.Version;
+
+/**
+ * Wraps an OSGi {@link Version} as an Aether
+ * {@link org.sonatype.aether.version.Version}.
+ */
+public class OsgiVersion implements org.sonatype.aether.version.Version {
+ final private Version version;
+
+ public OsgiVersion(String str) {
+ version = Version.parseVersion(str);
+ }
+
+ public Version getVersion() {
+ return version;
+ }
+
+ public int compareTo(org.sonatype.aether.version.Version v) {
+ if (!(v instanceof OsgiVersion))
+ return 0;
+ OsgiVersion ov = (OsgiVersion) v;
+ return version.compareTo(ov.version);
+ }
+}
--- /dev/null
+package org.argeo.slc.aether.spring;
+
+import org.sonatype.aether.repository.RemoteRepository;
+import org.springframework.beans.factory.BeanNameAware;
+import org.springframework.beans.factory.FactoryBean;
+
+/** Simplifies the definition of a remote factory using Spring */
+public class RemoteRepositoryFactory implements BeanNameAware, FactoryBean {
+ private String beanName;
+ private String id;
+ private String url;
+ private String type = "default";
+
+ public Object getObject() throws Exception {
+ return new RemoteRepository(id != null ? id : beanName, type, url);
+ }
+
+ public Class<?> getObjectType() {
+ return RemoteRepository.class;
+ }
+
+ public boolean isSingleton() {
+ return true;
+ }
+
+ public void setBeanName(String name) {
+ this.beanName = name;
+
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public void setUrl(String url) {
+ this.url = url;
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<beans:beans xmlns="http://www.springframework.org/schema/osgi"\r
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans"\r
+ xsi:schemaLocation="http://www.springframework.org/schema/osgi \r
+ http://www.springframework.org/schema/osgi/spring-osgi-1.1.xsd\r
+ http://www.springframework.org/schema/beans \r
+ http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">\r
+\r
+ <service ref="mavenRepositorySystem" interface="org.sonatype.aether.RepositorySystem">\r
+ <service-properties>\r
+ <beans:entry key="aether.repositorySystemType" value="maven" />\r
+ </service-properties>\r
+ </service>\r
+\r
+ <service ref="defaultMavenRepositorySystemSession" interface="org.sonatype.aether.RepositorySystemSession">\r
+ <service-properties>\r
+ <beans:entry key="aether.repositorySystemType" value="maven" />\r
+ </service-properties>\r
+ </service>\r
+</beans:beans>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
+
+
+ <bean id="mavenRepositorySystem" class="org.argeo.slc.maven.MavenManager"
+ factory-method="createRepositorySystem">
+ </bean>
+
+ <bean id="defaultMavenRepositorySystemSession" class="org.argeo.slc.maven.MavenManager"
+ factory-method="createRepositorySystemSession">
+ <constructor-arg ref="mavenRepositorySystem" />
+ </bean>
+</beans>
\ No newline at end of file
<artifactId>org.argeo.slc.specs</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.argeo.slc.runtime</groupId>
+ <artifactId>org.argeo.slc.support.aether</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
<!-- <dependency> <groupId>org.argeo.dep.osgi</groupId> <artifactId>org.argeo.dep.osgi.maven.embedder</artifactId>
</dependency> -->
<dependency>
+++ /dev/null
-package org.argeo.slc.maven;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.sonatype.aether.AbstractRepositoryListener;
-import org.sonatype.aether.RepositoryEvent;
-
-public class ConsoleRepositoryListener extends AbstractRepositoryListener {
-
- private final static Log log = LogFactory
- .getLog(ConsoleRepositoryListener.class);
-
- public void artifactDeployed(RepositoryEvent event) {
- if (log.isDebugEnabled())
- log.debug("Deployed " + event.getArtifact() + " to "
- + event.getRepository());
- }
-
- public void artifactDeploying(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Deploying " + event.getArtifact() + " to "
- + event.getRepository());
- }
-
- public void artifactDescriptorInvalid(RepositoryEvent event) {
- if (log.isDebugEnabled())
- log.warn("Invalid artifact descriptor for " + event.getArtifact()
- + ": " + event.getException().getMessage());
- }
-
- public void artifactDescriptorMissing(RepositoryEvent event) {
- if (log.isDebugEnabled())
- log.warn("Missing artifact descriptor for " + event.getArtifact());
- }
-
- public void artifactInstalled(RepositoryEvent event) {
- if (log.isDebugEnabled())
- log.debug("Installed " + event.getArtifact() + " to "
- + event.getFile());
- }
-
- public void artifactInstalling(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Installing " + event.getArtifact() + " to "
- + event.getFile());
- }
-
- public void artifactResolved(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Resolved artifact " + event.getArtifact() + " from "
- + event.getRepository());
- }
-
- public void artifactDownloading(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Downloading artifact " + event.getArtifact() + " from "
- + event.getRepository());
- }
-
- public void artifactDownloaded(RepositoryEvent event) {
- if (log.isDebugEnabled())
- log.debug("Downloaded artifact " + event.getArtifact() + " from "
- + event.getRepository());
- }
-
- public void artifactResolving(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Resolving artifact " + event.getArtifact());
- }
-
- public void metadataDeployed(RepositoryEvent event) {
- if (log.isDebugEnabled())
- log.debug("Deployed " + event.getMetadata() + " to "
- + event.getRepository());
- }
-
- public void metadataDeploying(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Deploying " + event.getMetadata() + " to "
- + event.getRepository());
- }
-
- public void metadataInstalled(RepositoryEvent event) {
- if (log.isDebugEnabled())
- log.debug("Installed " + event.getMetadata() + " to "
- + event.getFile());
- }
-
- public void metadataInstalling(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Installing " + event.getMetadata() + " to "
- + event.getFile());
- }
-
- public void metadataInvalid(RepositoryEvent event) {
- if (log.isDebugEnabled())
- log.debug("Invalid metadata " + event.getMetadata());
- }
-
- public void metadataResolved(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Resolved metadata " + event.getMetadata() + " from "
- + event.getRepository());
- }
-
- public void metadataResolving(RepositoryEvent event) {
- if (log.isTraceEnabled())
- log.trace("Resolving metadata " + event.getMetadata() + " from "
- + event.getRepository());
- }
-
-}
+++ /dev/null
-package org.argeo.slc.maven;
-
-/*******************************************************************************
- * Copyright (c) 2010 Sonatype, Inc.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *******************************************************************************/
-
-import java.io.PrintStream;
-import java.text.DecimalFormat;
-import java.text.DecimalFormatSymbols;
-import java.util.Locale;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.sonatype.aether.transfer.AbstractTransferListener;
-import org.sonatype.aether.transfer.TransferEvent;
-import org.sonatype.aether.transfer.TransferResource;
-
-public class ConsoleTransferListener
- extends AbstractTransferListener
-{
-
- private PrintStream out;
-
- private Map<TransferResource, Long> downloads = new ConcurrentHashMap<TransferResource, Long>();
-
- private int lastLength;
-
- public ConsoleTransferListener( PrintStream out )
- {
- this.out = ( out != null ) ? out : System.out;
- }
-
- @Override
- public void transferInitiated( TransferEvent event )
- {
- String message = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploading" : "Downloading";
-
- out.println( message + ": " + event.getResource().getRepositoryUrl() + event.getResource().getResourceName() );
- }
-
- @Override
- public void transferProgressed( TransferEvent event )
- {
- TransferResource resource = event.getResource();
- downloads.put( resource, Long.valueOf( event.getTransferredBytes() ) );
-
- StringBuilder buffer = new StringBuilder( 64 );
-
- for ( Map.Entry<TransferResource, Long> entry : downloads.entrySet() )
- {
- long total = entry.getKey().getContentLength();
- long complete = entry.getValue().longValue();
-
- buffer.append( getStatus( complete, total ) ).append( " " );
- }
-
- int pad = lastLength - buffer.length();
- lastLength = buffer.length();
- pad( buffer, pad );
- buffer.append( '\r' );
-
- out.print( buffer );
- }
-
- private String getStatus( long complete, long total )
- {
- if ( total >= 1024 )
- {
- return toKB( complete ) + "/" + toKB( total ) + " KB ";
- }
- else if ( total >= 0 )
- {
- return complete + "/" + total + " B ";
- }
- else if ( complete >= 1024 )
- {
- return toKB( complete ) + " KB ";
- }
- else
- {
- return complete + " B ";
- }
- }
-
- private void pad( StringBuilder buffer, int spaces )
- {
- String block = " ";
- while ( spaces > 0 )
- {
- int n = Math.min( spaces, block.length() );
- buffer.append( block, 0, n );
- spaces -= n;
- }
- }
-
- @Override
- public void transferSucceeded( TransferEvent event )
- {
- transferCompleted( event );
-
- TransferResource resource = event.getResource();
- long contentLength = event.getTransferredBytes();
- if ( contentLength >= 0 )
- {
- String type = ( event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploaded" : "Downloaded" );
- String len = contentLength >= 1024 ? toKB( contentLength ) + " KB" : contentLength + " B";
-
- String throughput = "";
- long duration = System.currentTimeMillis() - resource.getTransferStartTime();
- if ( duration > 0 )
- {
- DecimalFormat format = new DecimalFormat( "0.0", new DecimalFormatSymbols( Locale.ENGLISH ) );
- double kbPerSec = ( contentLength / 1024.0 ) / ( duration / 1000.0 );
- throughput = " at " + format.format( kbPerSec ) + " KB/sec";
- }
-
- out.println( type + ": " + resource.getRepositoryUrl() + resource.getResourceName() + " (" + len
- + throughput + ")" );
- }
- }
-
- @Override
- public void transferFailed( TransferEvent event )
- {
- transferCompleted( event );
-
- event.getException().printStackTrace( out );
- }
-
- private void transferCompleted( TransferEvent event )
- {
- downloads.remove( event.getResource() );
-
- StringBuilder buffer = new StringBuilder( 64 );
- pad( buffer, lastLength );
- buffer.append( '\r' );
- out.print( buffer );
- }
-
- public void transferCorrupted( TransferEvent event )
- {
- event.getException().printStackTrace( out );
- }
-
- protected long toKB( long bytes )
- {
- return ( bytes + 1023 ) / 1024;
- }
-
-}
import org.apache.maven.repository.internal.DefaultServiceLocator;\r
import org.apache.maven.repository.internal.MavenRepositorySystemSession;\r
import org.argeo.slc.SlcException;\r
+import org.argeo.slc.aether.AetherUtils;\r
+import org.argeo.slc.aether.ConsoleRepositoryListener;\r
+import org.argeo.slc.aether.ConsoleTransferListener;\r
import org.codehaus.plexus.PlexusContainer;\r
import org.sonatype.aether.RepositorySystem;\r
import org.sonatype.aether.RepositorySystemSession;\r
import org.sonatype.aether.spi.connector.RepositoryConnectorFactory;\r
import org.sonatype.aether.util.artifact.DefaultArtifact;\r
import org.sonatype.aether.util.graph.PreorderNodeListGenerator;\r
+import org.sonatype.aether.util.graph.selector.OptionalDependencySelector;\r
\r
public class MavenManager {\r
private final static Log log = LogFactory.getLog(MavenManager.class);\r
\r
public void testAether() {\r
try {\r
- RepositorySystem repoSystem = newRepositorySystem();\r
+ RepositorySystem repoSystem = createRepositorySystem();\r
\r
- RepositorySystemSession session = newSession(repoSystem);\r
+ RepositorySystemSession session = createRepositorySystemSession(repoSystem);\r
\r
Dependency dependency = new Dependency(new DefaultArtifact(\r
"org.argeo.slc.dep:org.argeo.slc.dep.sdk:0.13.1-SNAPSHOT"),\r
log.debug(artifact);\r
}\r
\r
- logDependencyNode(0, node);\r
+ AetherUtils.logDependencyNode(0, node);\r
// System.out.println(nlg.getClassPath());\r
- \r
+\r
} catch (Exception e) {\r
throw new SlcException("Cannot resolve", e);\r
}\r
\r
}\r
\r
- private void logDependencyNode(int depth, DependencyNode dependencyNode) {\r
- StringBuffer prefix = new StringBuffer(depth * 2 + 2);\r
- // prefix.append("|-");\r
- for (int i = 0; i < depth * 2; i++) {\r
- prefix.append(' ');\r
- }\r
- Artifact artifact = dependencyNode.getDependency().getArtifact();\r
- log.debug(prefix + "|-> " + artifact.getArtifactId() + " ["\r
- + artifact.getVersion() + "]");\r
- for (DependencyNode child : dependencyNode.getChildren())\r
- logDependencyNode(depth + 1, child);\r
- }\r
-\r
- private RepositorySystem newRepositorySystem() {\r
+ /** Creates a Maven {@link RepositorySystem}. */\r
+ public static RepositorySystem createRepositorySystem() {\r
try {\r
// return new\r
// DefaultPlexusContainer().lookup(RepositorySystem.class);\r
}\r
}\r
\r
- private RepositorySystemSession newSession(RepositorySystem system) {\r
+ public static RepositorySystemSession createRepositorySystemSession(\r
+ RepositorySystem system) {\r
MavenRepositorySystemSession session = new MavenRepositorySystemSession();\r
\r
LocalRepository localRepo = new LocalRepository(\r
.newLocalRepositoryManager(localRepo));\r
session.setTransferListener(new ConsoleTransferListener(System.out));\r
session.setRepositoryListener(new ConsoleRepositoryListener());\r
-\r
return session;\r
}\r
\r
}\r
\r
}\r
- /*\r
- * private final Log log = LogFactory.getLog(getClass());\r
- * \r
- * private String localRepositoryPath = System.getProperty("user.home") +\r
- * File.separator + ".m2" + File.separator + "repository";\r
- * \r
- * private ArtifactRepository localRepository; private\r
- * List<ArtifactRepository> remoteRepositoriesInternal; private\r
- * List<RemoteRepository> remoteRepositories = new\r
- * Vector<RemoteRepository>();\r
- * \r
- * private MavenEmbedder mavenEmbedder; private ClassLoader classLoader;\r
- * private Boolean offline = false;\r
- * \r
- * public void init() { try { mavenEmbedder = new SlcMavenEmbedder();\r
- * mavenEmbedder.setOffline(offline); //\r
- * mavenEmbedder.setAlignWithUserInstallation(true); if (classLoader !=\r
- * null) mavenEmbedder.setClassLoader(classLoader); else\r
- * mavenEmbedder.setClassLoader(getClass().getClassLoader()); // else //\r
- * mavenEmbedder.setClassLoader(Thread.currentThread() //\r
- * .getContextClassLoader()); mavenEmbedder.start();\r
- * \r
- * mavenEmbedder.setLocalRepositoryDirectory(new File(\r
- * localRepositoryPath));\r
- * \r
- * localRepository = mavenEmbedder.getLocalRepository();\r
- * \r
- * remoteRepositoriesInternal = new Vector<ArtifactRepository>(); for\r
- * (RemoteRepository remoteRepository : remoteRepositories) {\r
- * \r
- * ArtifactRepository repository = mavenEmbedder.createRepository(\r
- * remoteRepository.getUrl(), remoteRepository.getId());\r
- * remoteRepositoriesInternal.add(repository); }\r
- * \r
- * MavenFile mavenFile = new MavenFile();\r
- * mavenFile.setGroupId("org.argeo.slc.dist");\r
- * mavenFile.setArtifactId("org.argeo.slc.sdk");\r
- * mavenFile.setVersion("0.12.2-SNAPSHOT"); mavenFile.setType("pom");\r
- * Artifact artifact = resolve(mavenFile); log.debug("Location of " +\r
- * artifact + " : " + artifact.getFile()); // log.debug("Dependencies of " +\r
- * artifact); // for (Object obj : artifact.getDependencyTrail()) { //\r
- * log.debug(" " + obj); // }\r
- * \r
- * File pomFile = new File(\r
- * "/home/mbaudier/dev/src/slc/dist/org.argeo.slc.sdk/pom.xml");\r
- * MavenProject project = mavenEmbedder\r
- * .readProjectWithDependencies(pomFile); // MavenProject project =\r
- * mavenEmbedder // .readProjectWithDependencies(artifact.getFile());\r
- * \r
- * // EventMonitor eventMonitor = new EventMonitor() { // // public void\r
- * startEvent(String eventName, String target, // long timestamp) { //\r
- * log.debug(eventName + ", " + target + ", " + timestamp); // } // //\r
- * public void errorEvent(String eventName, String target, // long\r
- * timestamp, Throwable cause) { // log.debug(eventName + ", " + target +\r
- * ", " + timestamp); // } // // public void endEvent(String eventName,\r
- * String target, // long timestamp) { // log.debug(eventName + ", " +\r
- * target + ", " + timestamp); // } // }; // // String[] goals = { "clean",\r
- * "install" }; // mavenEmbedder.execute(project, Arrays.asList(goals), //\r
- * eventMonitor, // null, null, pomFile.getParentFile());\r
- * \r
- * Set<Artifact> transitDeps = getTransitiveProjectDependencies( project,\r
- * remoteRepositoriesInternal, localRepository);\r
- * log.debug(transitDeps.size() + " dependencies for " + artifact); for\r
- * (Object obj : transitDeps) { log.debug(" " + obj); }\r
- * \r
- * } catch (Exception e) { throw new\r
- * SlcException("Cannot initialize Maven manager", e); } }\r
- * \r
- * @SuppressWarnings("unchecked") public Set<Artifact>\r
- * getTransitiveProjectDependencies(MavenProject project,\r
- * List<ArtifactRepository> remoteRepos, ArtifactRepository local) {\r
- * Embedder embedder = mavenEmbedder.getEmbedder(); try { ArtifactFactory\r
- * artifactFactory = (ArtifactFactory) embedder\r
- * .lookup(ArtifactFactory.ROLE);\r
- * \r
- * ArtifactResolver artifactResolver = (ArtifactResolver) embedder\r
- * .lookup(ArtifactResolver.ROLE);\r
- * \r
- * ArtifactMetadataSource artifactMetadataSource = (ArtifactMetadataSource)\r
- * embedder .lookup(ArtifactMetadataSource.ROLE);\r
- * \r
- * Set<Artifact> artifacts = project.createArtifacts(artifactFactory, null,\r
- * null);\r
- * \r
- * ArtifactResolutionResult arr = artifactResolver\r
- * .resolveTransitively(artifacts, project.getArtifact(), local,\r
- * remoteRepos, artifactMetadataSource, null);\r
- * \r
- * return arr.getArtifacts(); } catch (Exception e) { throw new\r
- * SlcException("Cannot resolve dependency for " + project, e); } // Order,\r
- * just for display // Set dependencies = new TreeSet(new\r
- * ArtifactComparator()); // dependencies.addAll(arr.getArtifacts()); //\r
- * return dependencies; }\r
- * \r
- * private Artifact resolve(MavenFile mavenDistribution) { try { Artifact\r
- * artifact; if (mavenDistribution.getClassifier() == null) { artifact =\r
- * mavenEmbedder.createArtifact(mavenDistribution .getGroupId(),\r
- * mavenDistribution.getArtifactId(), mavenDistribution.getVersion(),\r
- * Artifact.SCOPE_PROVIDED, mavenDistribution.getType()); } else { artifact\r
- * = mavenEmbedder.createArtifactWithClassifier(\r
- * mavenDistribution.getGroupId(), mavenDistribution .getArtifactId(),\r
- * mavenDistribution .getVersion(), mavenDistribution.getType(),\r
- * mavenDistribution.getClassifier()); }\r
- * \r
- * mavenEmbedder.resolve(artifact, remoteRepositoriesInternal,\r
- * localRepository);\r
- * \r
- * return artifact; } catch (Exception e) { throw new\r
- * SlcException("Cannot resolve artifact.", e); } }\r
- * \r
- * public File getPackageLocation(MavenFile mavenDistribution) { return\r
- * resolve(mavenDistribution).getFile(); }\r
- * \r
- * public void destroy() { try { if (mavenEmbedder != null) {\r
- * mavenEmbedder.stop(); } } catch (MavenEmbedderException e) {\r
- * log.error("Cannot destroy Maven manager", e); } }\r
- * \r
- * public void setLocalRepositoryPath(String localRepositoryPath) {\r
- * this.localRepositoryPath = localRepositoryPath; }\r
- * \r
- * public List<RemoteRepository> getRemoteRepositories() { return\r
- * remoteRepositories; }\r
- * \r
- * public void setRemoteRepositories(List<RemoteRepository>\r
- * remoteRepositories) { this.remoteRepositories = remoteRepositories; }\r
- * \r
- * public void setClassLoader(ClassLoader classLoader) { this.classLoader =\r
- * classLoader; }\r
- * \r
- * public void setOffline(Boolean offline) { this.offline = offline; }\r
- */\r
}\r
<module>org.argeo.slc.support.equinox</module>
<module>org.argeo.slc.support.hibernate</module>
<module>org.argeo.slc.support.ant</module>
+ <module>org.argeo.slc.support.aether</module>
<module>org.argeo.slc.support.maven</module>
<module>org.argeo.slc.support.jemmy</module>
<module>org.argeo.slc.support.jcr</module>
<module>org.argeo.slc.launcher</module>
<module>org.argeo.slc.lib.detached</module>
<module>org.argeo.slc.support.ws.client</module>
+ <module>org.argeo.slc.repo</module>
</modules>
<build>
<resources>
projects / gpl / argeo-slc.git / commitdiff