+/*
+ * Copyright (C) 2007-2012 Argeo GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
package org.argeo.slc.repo.maven;
import java.io.ByteArrayOutputStream;
import java.io.File;
-import java.io.FileInputStream;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;
-import javax.jcr.Binary;
import javax.jcr.Node;
-import javax.jcr.Property;
+import javax.jcr.NodeIterator;
+import javax.jcr.Repository;
import javax.jcr.Session;
import javax.jcr.nodetype.NodeType;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
+import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.jcr.JcrUtils;
+import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
import org.argeo.slc.aether.AetherTemplate;
+import org.argeo.slc.aether.ArtifactIdComparator;
+import org.argeo.slc.repo.ArtifactIndexer;
+import org.argeo.slc.repo.JarFileIndexer;
+import org.argeo.slc.repo.RepoConstants;
+import org.argeo.slc.repo.RepoUtils;
import org.sonatype.aether.artifact.Artifact;
import org.sonatype.aether.graph.DependencyNode;
import org.sonatype.aether.util.artifact.DefaultArtifact;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-import org.w3c.dom.NodeList;
+/**
+ * Import all the dependencies listed in a POM and their dependency graphs to a
+ * workspace.
+ */
public class ImportMavenDependencies implements Runnable {
private final static Log log = LogFactory
.getLog(ImportMavenDependencies.class);
private AetherTemplate aetherTemplate;
- private String rootCoordinates;
+ private String rootCoordinates = "org.argeo.dep:versions-all:pom:1.2.0";
+ private String distCoordinates = "org.argeo.tp:dist:pom:1.3.0";
+ private String parentPomCoordinates = "org.argeo:parent:1.2.0";
private Set<String> excludedArtifacts = new HashSet<String>();
- private Session jcrSession;
- private String artifactBasePath = "/slc/repo/artifacts";
+ private Repository repository;
+ private String workspace;
+
+ private String artifactBasePath = RepoConstants.DEFAULT_ARTIFACTS_BASE_PATH;
+
+ private ArtifactIndexer artifactIndexer = new ArtifactIndexer();
+ private JarFileIndexer jarFileIndexer = new JarFileIndexer();
+ private Comparator<Artifact> artifactComparator = new ArtifactIdComparator();
public void run() {
+ // resolve
Set<Artifact> artifacts = resolveDistribution();
- syncDistribution(artifacts);
+
+ // sync
+ sync(artifacts);
+ }
+
+ void sync(Set<Artifact> artifacts) {
+ Session session = null;
+ try {
+ session = JcrUtils.loginOrCreateWorkspace(repository, workspace);
+ // clear
+ NodeIterator nit = session.getNode(artifactBasePath).getNodes();
+ while (nit.hasNext()) {
+ Node node = nit.nextNode();
+ if (node.isNodeType(NodeType.NT_FOLDER)
+ || node.isNodeType(NodeType.NT_UNSTRUCTURED))
+ node.remove();
+ }
+ session.save();
+
+ // sync
+ syncDistribution(session, artifacts);
+ } catch (Exception e) {
+ throw new SlcException("Cannot import distribution", e);
+ } finally {
+ JcrUtils.logoutQuietly(session);
+ }
}
- public Set<Artifact> resolveDistribution() {
+ /**
+ * Generate a POM with all the artifacts declared in root coordinates as
+ * dependencies AND in dependency management.
+ */
+ void createDistPom() {
try {
Artifact pomArtifact = new DefaultArtifact(rootCoordinates);
- 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);
+ MavenConventionsUtils.gatherPomDependencies(aetherTemplate,
+ registeredArtifacts, pomArtifact);
+ Artifact sdkArtifact = new DefaultArtifact(distCoordinates);
+ String sdkPom = MavenConventionsUtils.artifactsAsDependencyPom(
+ sdkArtifact, registeredArtifacts, new DefaultArtifact(
+ parentPomCoordinates));
if (log.isDebugEnabled())
log.debug("Gathered " + registeredArtifacts.size()
- + " artifacts");
+ + " artifacts:\n" + sdkPom);
+ } catch (Exception e) {
+ throw new SlcException("Cannot resolve distribution", e);
+ }
+ }
- // Resolve and add non-optional dependencies
+ /** Returns all transitive dependencies of dist POM */
+ private Set<Artifact> resolveDistribution() {
+ try {
+ Artifact distArtifact = new DefaultArtifact(distCoordinates);
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());
- }
- }
+ DependencyNode node = aetherTemplate
+ .resolveDependencies(distArtifact);
+ addDependencies(artifacts, node, null);
- if (log.isDebugEnabled())
+ 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();
+ // Properties distributionDescriptor =
+ // generateDistributionDescriptor(artifacts);
+ // ByteArrayOutputStream out = new ByteArrayOutputStream();
+ // distributionDescriptor.store(out, "");
+ // log.debug(new String(out.toByteArray()));
+ // out.close();
+ }
+ /*
+ * for (Artifact artifact : registeredArtifacts) { try { Boolean
+ * wasAdded = addArtifact(artifacts, artifact); if (wasAdded) {
+ * DependencyNode node = aetherTemplate
+ * .resolveDependencies(artifact); addDependencies(artifacts, node,
+ * null); } } catch (Exception e) {
+ * log.error("Could not resolve dependencies of " + artifact + ": "
+ * + e.getCause().getMessage()); }
+ *
+ * }
+ *
+ * if (log.isDebugEnabled()) log.debug("Resolved " +
+ * artifacts.size() + " artifacts");
+ *
+ * // distribution descriptor // Properties distributionDescriptor =
+ * // generateDistributionDescriptor(artifacts); //
+ * ByteArrayOutputStream out = new ByteArrayOutputStream(); //
+ * distributionDescriptor.store(out, ""); // log.debug(new
+ * String(out.toByteArray())); // out.close();
+ */
return artifacts;
} catch (Exception e) {
throw new SlcException("Cannot resolve distribution", e);
}
}
- protected void syncDistribution(Set<Artifact> artifacts) {
+ protected Properties generateDistributionDescriptor(Set<Artifact> 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());
+ }
+ return distributionDescriptor;
+ }
+
+ /** Write artifacts to the target workspace, skipping excluded ones */
+ protected void syncDistribution(Session jcrSession, Set<Artifact> artifacts) {
+ Set<Artifact> artifactsWithoutSources = new TreeSet<Artifact>(
+ artifactComparator);
Long begin = System.currentTimeMillis();
try {
- JcrUtils.mkdirs(jcrSession, artifactBasePath);
- for (Artifact artifact : artifacts) {
- String parentPath = artifactBasePath + '/'
- + artifactParentPath(artifact);
- Node parentNode;
- if (!jcrSession.itemExists(parentPath)) {
- parentNode = JcrUtils.mkdirs(jcrSession, parentPath,
- NodeType.NT_FOLDER, false);
- } else {
- parentNode = jcrSession.getNode(parentPath);
+ JcrUtils.mkfolders(jcrSession, artifactBasePath);
+ artifacts: for (Artifact artifact : artifacts) {
+ // skip excluded
+ if (excludedArtifacts.contains(artifact.getGroupId() + ":"
+ + artifact.getArtifactId())) {
+ if (log.isDebugEnabled())
+ log.debug("Exclude " + artifact);
+ continue artifacts;
}
- File file = artifact.getFile();
- Node fileNode;
- if (!parentNode.hasNode(file.getName())) {
- fileNode = createFileNode(parentNode, file);
- } else {
- fileNode = parentNode.getNode(file.getName());
+ File jarFile = MavenConventionsUtils.artifactToFile(artifact);
+ if (!jarFile.exists()) {
+ log.warn("Generated file " + jarFile + " for " + artifact
+ + " does not exist");
+ continue artifacts;
+ }
+ artifact.setFile(jarFile);
+
+ try {
+ String parentPath = MavenConventionsUtils
+ .artifactParentPath(artifactBasePath, artifact);
+ Node parentNode;
+ if (!jcrSession.itemExists(parentPath))
+ parentNode = JcrUtils.mkfolders(jcrSession, parentPath);
+ else
+ parentNode = jcrSession.getNode(parentPath);
+
+ Node fileNode;
+ if (!parentNode.hasNode(jarFile.getName())) {
+ fileNode = createFileNode(parentNode, jarFile);
+ } else {
+ fileNode = parentNode.getNode(jarFile.getName());
+ }
+
+ if (artifactIndexer.support(fileNode.getPath()))
+ artifactIndexer.index(fileNode);
+ if (jarFileIndexer.support(fileNode.getPath()))
+ jarFileIndexer.index(fileNode);
+ jcrSession.save();
+
+ addPdeSource(jcrSession, artifact, jarFile,
+ artifactsWithoutSources);
+ jcrSession.save();
+
+ if (log.isDebugEnabled())
+ log.debug("Synchronized " + fileNode);
+ } catch (Exception e) {
+ log.error("Could not synchronize " + artifact, e);
+ jcrSession.refresh(false);
+ throw e;
}
}
Long duration = (System.currentTimeMillis() - begin) / 1000;
- if (log.isDebugEnabled())
+ if (log.isDebugEnabled()) {
log.debug("Synchronized distribution in " + duration + "s");
+ log.debug("The following artifacts have no sources:");
+ for (Artifact artifact : artifactsWithoutSources) {
+ log.debug(artifact);
+ }
+ }
} catch (Exception e) {
throw new SlcException("Cannot synchronize distribution", e);
}
}
- protected String artifactParentPath(Artifact artifact) {
- return artifact.getGroupId().replace('.', '/') + '/'
- + artifact.getArtifactId() + '/' + artifact.getVersion();
- }
-
- protected Node createFileNode(Node parentNode, File file) {
+ /** Try to add PDE sources */
+ private void addPdeSource(Session session, Artifact artifact,
+ File artifactFile, Set<Artifact> artifactsWithoutSources) {
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
- Node fileNode = parentNode
- .addNode(file.getName(), NodeType.NT_FILE);
- Node contentNode = fileNode.addNode(Node.JCR_CONTENT,
- NodeType.NT_RESOURCE);
- Binary binary = jcrSession.getValueFactory().createBinary(
- new FileInputStream(file));
- contentNode.setProperty(Property.JCR_DATA, binary);
- binary.dispose();
- return fileNode;
+ File origSourceFile = null;
+ Artifact origSourceArtifact = new DefaultArtifact(
+ artifact.getGroupId(), artifact.getArtifactId(), "sources",
+ artifact.getExtension(), artifact.getVersion());
+ Artifact newSourceArtifact = new DefaultArtifact(
+ artifact.getGroupId(),
+ artifact.getArtifactId() + ".source",
+ artifact.getExtension(), artifact.getVersion());
+ try {
+ origSourceFile = aetherTemplate
+ .getResolvedFile(origSourceArtifact);
+ } catch (Exception e) {
+ // also try artifact following the conventions
+ origSourceArtifact = newSourceArtifact;
+ origSourceFile = aetherTemplate
+ .getResolvedFile(origSourceArtifact);
+ }
+
+ String newSourceParentPath = MavenConventionsUtils
+ .artifactParentPath(artifactBasePath, newSourceArtifact);
+ Node newSourceParentNode = JcrUtils.mkfolders(session,
+ newSourceParentPath);
+ NameVersion bundleNameVersion = RepoUtils
+ .readNameVersion(artifactFile);
+ RepoUtils.packagesAsPdeSource(origSourceFile, bundleNameVersion,
+ out);
+ String newSourceFileName = MavenConventionsUtils
+ .artifactFileName(newSourceArtifact);
+ JcrUtils.copyBytesAsFile(newSourceParentNode, newSourceFileName,
+ out.toByteArray());
} catch (Exception e) {
- throw new SlcException("Cannot create file node based on " + file
- + " under " + parentNode, e);
+ log.error("Cannot add PDE source for " + artifact + ": " + e);
+ artifactsWithoutSources.add(artifact);
+ } finally {
+ IOUtils.closeQuietly(out);
}
}
+ private Node createFileNode(Node parentNode, File file) {
+ return JcrUtils.copyFile(parentNode, file);
+ }
+
/** Recursively adds non optional dependencies */
- private void addDependencies(Set<Artifact> artifacts, DependencyNode node) {
+ private void addDependencies(Set<Artifact> artifacts, DependencyNode node,
+ String ancestors) {
+ // if (artifacts.contains(node.getDependency().getArtifact()))
+ // return;
+ String currentArtifactId = node.getDependency().getArtifact()
+ .getArtifactId();
+ if (log.isDebugEnabled()) {
+ log.debug("# Add dependency for " + currentArtifactId);
+ if (ancestors != null)
+ log.debug(ancestors);
+ }
for (DependencyNode child : node.getChildren()) {
if (!child.getDependency().isOptional()) {
- addArtifact(artifacts, child.getDependency().getArtifact());
- addDependencies(artifacts, child);
+ if (willAdd(child.getDependency().getArtifact())) {
+ addArtifact(artifacts, child.getDependency().getArtifact());
+ addDependencies(artifacts, child, currentArtifactId + "\n"
+ + (ancestors != null ? ancestors : ""));
+ }
}
}
}
- private void addArtifact(Set<Artifact> artifacts, Artifact artifact) {
- if (!excludedArtifacts.contains(artifact.getGroupId() + ":"
- + artifact.getArtifactId()))
+ /** @return whether it was added */
+ private Boolean addArtifact(Set<Artifact> artifacts, Artifact artifact) {
+ Boolean willAdd = willAdd(artifact);
+ if (willAdd)
artifacts.add(artifact);
+ else
+ log.info("Skip " + artifact);
+ return willAdd;
}
- /**
- * 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);
- }
+ private Boolean willAdd(Artifact artifact) {
+ Boolean willAdd = true;
+ if (excludedArtifacts.contains(artifact.getGroupId() + ":"
+ + artifact.getArtifactId()))
+ willAdd = false;
+ else if (excludedArtifacts.contains(artifact.getGroupId() + ":*"))
+ willAdd = false;
+ return willAdd;
}
public void setAetherTemplate(AetherTemplate aetherTemplate) {
this.rootCoordinates = rootCoordinates;
}
- public void setJcrSession(Session jcrSession) {
- this.jcrSession = jcrSession;
+ public void setRepository(Repository repository) {
+ this.repository = repository;
+ }
+
+ public void setWorkspace(String workspace) {
+ this.workspace = workspace;
+ }
+
+ public void setDistCoordinates(String distCoordinates) {
+ this.distCoordinates = distCoordinates;
+ }
+
+ public void setArtifactBasePath(String artifactBasePath) {
+ this.artifactBasePath = artifactBasePath;
}
}