X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=runtime%2Forg.argeo.slc.repo%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fslc%2Frepo%2Fmaven%2FImportMavenDependencies.java;h=f0fd220d83258ef835a4ab0fd9fbc2202d3f3cfb;hb=a49b28f9f972f303961d40948b28604140ae3a83;hp=c4020d92f344c522d8227cc244e8f5718ff3f5ee;hpb=f37b0f6cc0e1fe7b284c079e9dc20c34be1acd14;p=gpl%2Fargeo-slc.git

diff --git a/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/ImportMavenDependencies.java b/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/ImportMavenDependencies.java
index c4020d92f..f0fd220d8 100644
--- a/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/ImportMavenDependencies.java
+++ b/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/ImportMavenDependencies.java
@@ -1,27 +1,43 @@
 package org.argeo.slc.repo.maven;
 
+import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.InputStream;
+import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Properties;
 import java.util.Set;
 import java.util.TreeSet;
+import java.util.jar.Attributes;
+import java.util.jar.Attributes.Name;
+import java.util.jar.JarInputStream;
+import java.util.jar.Manifest;
 
 import javax.jcr.Binary;
 import javax.jcr.Node;
+import javax.jcr.NodeIterator;
 import javax.jcr.Property;
+import javax.jcr.RepositoryException;
 import javax.jcr.Session;
 import javax.jcr.nodetype.NodeType;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 
+import org.apache.commons.io.FilenameUtils;
+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.SlcException;
 import org.argeo.slc.aether.AetherTemplate;
+import org.argeo.slc.repo.RepoNames;
+import org.argeo.slc.repo.RepoTypes;
+import org.osgi.framework.Constants;
+import org.osgi.framework.Version;
 import org.sonatype.aether.artifact.Artifact;
 import org.sonatype.aether.graph.DependencyNode;
 import org.sonatype.aether.util.artifact.DefaultArtifact;
@@ -41,6 +57,7 @@ public class ImportMavenDependencies implements Runnable {
 	private String artifactBasePath = "/slc/repo/artifacts";
 
 	public void run() {
+		log.debug(jcrSession.getUserID());
 		Set<Artifact> artifacts = resolveDistribution();
 		syncDistribution(artifacts);
 	}
@@ -101,23 +118,66 @@ public class ImportMavenDependencies implements Runnable {
 		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);
+			artifacts: for (Artifact artifact : artifacts) {
+				File file = artifact.getFile();
+				if (file == null) {
+					log.warn("File not found for " + artifact);
+
+					file = new File(System.getProperty("user.home")
+							+ File.separator
+							+ ".m2"
+							+ File.separator
+							+ "repository"
+							+ File.separator
+							+ artifact.getGroupId().replace('.',
+									File.separatorChar)
+							+ File.separator
+							+ artifact.getArtifactId()
+							+ File.separator
+							+ artifact.getVersion()
+							+ File.separator
+							+ artifact.getArtifactId()
+							+ '-'
+							+ artifact.getVersion()
+							+ (artifact.getClassifier().equals("") ? ""
+									: '-' + artifact.getClassifier()) + '.'
+							+ artifact.getExtension());
+
+					if (!file.exists()) {
+						log.warn("Generated file " + file + " for " + artifact
+								+ " does not exist");
+						continue artifacts;
+					}
 				}
 
-				File file = artifact.getFile();
-				Node fileNode;
-				if (!parentNode.hasNode(file.getName())) {
-					fileNode = createFileNode(parentNode, file);
-				} else {
-					fileNode = parentNode.getNode(file.getName());
+				try {
+					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);
+					}
+
+					Node fileNode;
+					if (!parentNode.hasNode(file.getName())) {
+						fileNode = createFileNode(parentNode, file);
+					} else {
+						fileNode = parentNode.getNode(file.getName());
+					}
+					processArtifact(fileNode, artifact);
+					if (fileNode.isNodeType(RepoTypes.SLC_JAR_FILE)) {
+						processOsgiBundle(fileNode);
+					}
+					jcrSession.save();
+					if (log.isDebugEnabled())
+						log.debug("Synchronized " + fileNode);
+				} catch (Exception e) {
+					log.error("Could not synchronize " + artifact, e);
+					jcrSession.refresh(false);
+					throw e;
 				}
 			}
 
@@ -134,20 +194,356 @@ public class ImportMavenDependencies implements Runnable {
 				+ artifact.getArtifactId() + '/' + artifact.getVersion();
 	}
 
+	protected void processArtifact(Node fileNode, Artifact artifact) {
+		try {
+			fileNode.addMixin(RepoTypes.SLC_ARTIFACT);
+			fileNode.setProperty(RepoNames.SLC_ARTIFACT_ID,
+					artifact.getArtifactId());
+			fileNode.setProperty(RepoNames.SLC_GROUP_ID, artifact.getGroupId());
+			fileNode.setProperty(RepoNames.SLC_ARTIFACT_VERSION,
+					artifact.getVersion());
+			fileNode.setProperty(RepoNames.SLC_ARTIFACT_EXTENSION,
+					artifact.getExtension());
+			fileNode.setProperty(RepoNames.SLC_ARTIFACT_CLASSIFIER,
+					artifact.getClassifier());
+		} catch (RepositoryException e) {
+			throw new SlcException("Cannot process artifact " + artifact
+					+ " on node " + fileNode, e);
+		}
+
+	}
+
+	protected void processOsgiBundle(Node fileNode) {
+		Binary manifestBinary = null;
+		InputStream manifestIn = null;
+		try {
+			manifestBinary = fileNode.getProperty(RepoNames.SLC_MANIFEST)
+					.getBinary();
+			manifestIn = manifestBinary.getStream();
+			Manifest manifest = new Manifest(manifestIn);
+			Attributes attrs = manifest.getMainAttributes();
+
+			if (log.isTraceEnabled())
+				for (Object key : attrs.keySet())
+					log.trace(key + ": " + attrs.getValue(key.toString()));
+
+			if (!attrs.containsKey(new Name(Constants.BUNDLE_SYMBOLICNAME))) {
+				log.warn(fileNode + " is not an OSGi bundle");
+				return;// not an osgi bundle
+			}
+
+			fileNode.addMixin(RepoTypes.SLC_BUNDLE_ARTIFACT);
+			addAttr(Constants.BUNDLE_SYMBOLICNAME, fileNode, attrs);
+			addAttr(Constants.BUNDLE_NAME, fileNode, attrs);
+			addAttr(Constants.BUNDLE_DESCRIPTION, fileNode, attrs);
+			addAttr(Constants.BUNDLE_MANIFESTVERSION, fileNode, attrs);
+			addAttr(Constants.BUNDLE_CATEGORY, fileNode, attrs);
+			addAttr(Constants.BUNDLE_ACTIVATIONPOLICY, fileNode, attrs);
+			addAttr(Constants.BUNDLE_COPYRIGHT, fileNode, attrs);
+			addAttr(Constants.BUNDLE_VENDOR, fileNode, attrs);
+			addAttr("Bundle-License", fileNode, attrs);
+			addAttr(Constants.BUNDLE_DOCURL, fileNode, attrs);
+			addAttr(Constants.BUNDLE_CONTACTADDRESS, fileNode, attrs);
+			addAttr(Constants.BUNDLE_ACTIVATOR, fileNode, attrs);
+			addAttr(Constants.BUNDLE_UPDATELOCATION, fileNode, attrs);
+			addAttr(Constants.BUNDLE_LOCALIZATION, fileNode, attrs);
+
+			// required execution environment
+			if (attrs.containsKey(new Name(
+					Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT)))
+				fileNode.setProperty(
+						RepoNames.SLC_
+								+ Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT,
+						attrs.getValue(
+								Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT)
+								.split(","));
+
+			// bundle classpath
+			if (attrs.containsKey(new Name(Constants.BUNDLE_CLASSPATH)))
+				fileNode.setProperty(RepoNames.SLC_
+						+ Constants.BUNDLE_CLASSPATH,
+						attrs.getValue(Constants.BUNDLE_CLASSPATH).split(","));
+
+			// version
+			Version version = new Version(
+					attrs.getValue(Constants.BUNDLE_VERSION));
+			cleanSubNodes(fileNode, RepoNames.SLC_ + Constants.BUNDLE_VERSION);
+			Node bundleVersionNode = fileNode.addNode(RepoNames.SLC_
+					+ Constants.BUNDLE_VERSION, RepoTypes.SLC_OSGI_VERSION);
+			mapOsgiVersion(version, bundleVersionNode);
+
+			// fragment
+			cleanSubNodes(fileNode, RepoNames.SLC_ + Constants.FRAGMENT_HOST);
+			if (attrs.containsKey(new Name(Constants.FRAGMENT_HOST))) {
+				String fragmentHost = attrs.getValue(Constants.FRAGMENT_HOST);
+				String[] tokens = fragmentHost.split(";");
+				Node node = fileNode.addNode(RepoNames.SLC_
+						+ Constants.FRAGMENT_HOST, RepoTypes.SLC_FRAGMENT_HOST);
+				node.setProperty(RepoNames.SLC_SYMBOLIC_NAME, tokens[0]);
+				for (int i = 1; i < tokens.length; i++) {
+					if (tokens[i]
+							.startsWith(Constants.BUNDLE_VERSION_ATTRIBUTE)) {
+						node.setProperty(RepoNames.SLC_BUNDLE_VERSION,
+								attributeValue(tokens[i]));
+					}
+				}
+			}
+
+			// imported packages
+			cleanSubNodes(fileNode, RepoNames.SLC_ + Constants.IMPORT_PACKAGE);
+			if (attrs.containsKey(new Name(Constants.IMPORT_PACKAGE))) {
+				String importPackages = attrs
+						.getValue(Constants.IMPORT_PACKAGE);
+				String[] packages = importPackages.split(",");
+				for (String pkg : packages) {
+					String[] tokens = pkg.split(";");
+					Node node = fileNode.addNode(RepoNames.SLC_
+							+ Constants.IMPORT_PACKAGE,
+							RepoTypes.SLC_IMPORTED_PACKAGE);
+					node.setProperty(RepoNames.SLC_NAME, tokens[0]);
+					for (int i = 1; i < tokens.length; i++) {
+						if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
+							node.setProperty(RepoNames.SLC_VERSION,
+									attributeValue(tokens[i]));
+						} else if (tokens[i]
+								.startsWith(Constants.RESOLUTION_DIRECTIVE)) {
+							node.setProperty(
+									RepoNames.SLC_OPTIONAL,
+									directiveValue(tokens[i]).equals(
+											Constants.RESOLUTION_OPTIONAL));
+						}
+					}
+				}
+			}
+
+			// dynamic import package
+			cleanSubNodes(fileNode, RepoNames.SLC_
+					+ Constants.DYNAMICIMPORT_PACKAGE);
+			if (attrs.containsKey(new Name(Constants.DYNAMICIMPORT_PACKAGE))) {
+				String importPackages = attrs
+						.getValue(Constants.DYNAMICIMPORT_PACKAGE);
+				String[] packages = importPackages.split(",");
+				for (String pkg : packages) {
+					String[] tokens = pkg.split(";");
+					Node node = fileNode.addNode(RepoNames.SLC_
+							+ Constants.DYNAMICIMPORT_PACKAGE,
+							RepoTypes.SLC_DYNAMIC_IMPORTED_PACKAGE);
+					node.setProperty(RepoNames.SLC_NAME, tokens[0]);
+					for (int i = 1; i < tokens.length; i++) {
+						if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
+							node.setProperty(RepoNames.SLC_VERSION,
+									attributeValue(tokens[i]));
+						}
+					}
+				}
+			}
+
+			// exported packages
+			cleanSubNodes(fileNode, RepoNames.SLC_ + Constants.EXPORT_PACKAGE);
+			if (attrs.containsKey(new Name(Constants.EXPORT_PACKAGE))) {
+				String exportPackages = attrs
+						.getValue(Constants.EXPORT_PACKAGE);
+				List<String> packages = parseExportPackage(exportPackages);
+				for (String pkg : packages) {
+					String[] tokens = pkg.split(";");
+					Node node = fileNode.addNode(RepoNames.SLC_
+							+ Constants.EXPORT_PACKAGE,
+							RepoTypes.SLC_EXPORTED_PACKAGE);
+					node.setProperty(RepoNames.SLC_NAME, tokens[0]);
+					// TODO: are these cleans really necessary?
+					cleanSubNodes(node, RepoNames.SLC_USES);
+					cleanSubNodes(node, RepoNames.SLC_VERSION);
+					for (int i = 1; i < tokens.length; i++) {
+						if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
+							String versionStr = attributeValue(tokens[i]);
+							Node versionNode = node.addNode(
+									RepoNames.SLC_VERSION,
+									RepoTypes.SLC_OSGI_VERSION);
+							mapOsgiVersion(new Version(versionStr), versionNode);
+						} else if (tokens[i]
+								.startsWith(Constants.USES_DIRECTIVE)) {
+							String usedPackages = directiveValue(tokens[i]);
+							// log.debug("uses='" + usedPackages + "'");
+							for (String usedPackage : usedPackages.split(",")) {
+								// log.debug("usedPackage='" + usedPackage +
+								// "'");
+								Node usesNode = node.addNode(
+										RepoNames.SLC_USES,
+										RepoTypes.SLC_JAVA_PACKAGE);
+								usesNode.setProperty(RepoNames.SLC_NAME,
+										usedPackage);
+							}
+						}
+					}
+				}
+			}
+
+			// required bundle
+			cleanSubNodes(fileNode, RepoNames.SLC_ + Constants.REQUIRE_BUNDLE);
+			if (attrs.containsKey(new Name(Constants.REQUIRE_BUNDLE))) {
+				String requireBundle = attrs.getValue(Constants.REQUIRE_BUNDLE);
+				String[] bundles = requireBundle.split(",");
+				for (String bundle : bundles) {
+					String[] tokens = bundle.split(";");
+					Node node = fileNode.addNode(RepoNames.SLC_
+							+ Constants.REQUIRE_BUNDLE,
+							RepoTypes.SLC_REQUIRED_BUNDLE);
+					node.setProperty(RepoNames.SLC_SYMBOLIC_NAME, tokens[0]);
+					for (int i = 1; i < tokens.length; i++) {
+						if (tokens[i]
+								.startsWith(Constants.BUNDLE_VERSION_ATTRIBUTE)) {
+							node.setProperty(RepoNames.SLC_BUNDLE_VERSION,
+									attributeValue(tokens[i]));
+						} else if (tokens[i]
+								.startsWith(Constants.RESOLUTION_DIRECTIVE)) {
+							node.setProperty(
+									RepoNames.SLC_OPTIONAL,
+									directiveValue(tokens[i]).equals(
+											Constants.RESOLUTION_OPTIONAL));
+						}
+					}
+				}
+			}
+		} catch (Exception e) {
+			throw new SlcException("Cannot process OSGi bundle " + fileNode, e);
+		} finally {
+			if (manifestBinary != null)
+				manifestBinary.dispose();
+			IOUtils.closeQuietly(manifestIn);
+		}
+	}
+
+	private List<String> parseExportPackage(String str) {
+		List<String> res = new ArrayList<String>();
+		StringBuffer curr = new StringBuffer("");
+		boolean in = false;
+		for (char c : str.toCharArray()) {
+			if (c == ',') {
+				if (!in) {
+					res.add(curr.toString());
+					curr = new StringBuffer("");
+				}
+			} else if (c == '\"') {
+				in = !in;
+				curr.append(c);
+			} else {
+				curr.append(c);
+			}
+		}
+		res.add(curr.toString());
+		return res;
+	}
+
+	private void addAttr(String key, Node node, Attributes attrs)
+			throws RepositoryException {
+		addAttr(new Name(key), node, attrs);
+	}
+
+	private void addAttr(Name key, Node node, Attributes attrs)
+			throws RepositoryException {
+		if (attrs.containsKey(key))
+			node.setProperty(RepoNames.SLC_ + key, attrs.getValue(key));
+	}
+
+	private void cleanSubNodes(Node node, String name)
+			throws RepositoryException {
+		if (node.hasNode(name)) {
+			NodeIterator nit = node.getNodes(name);
+			while (nit.hasNext())
+				nit.nextNode().remove();
+		}
+	}
+
+	protected void mapOsgiVersion(Version version, Node versionNode)
+			throws RepositoryException {
+		versionNode.setProperty(RepoNames.SLC_MAJOR, version.getMajor());
+		versionNode.setProperty(RepoNames.SLC_MINOR, version.getMinor());
+		versionNode.setProperty(RepoNames.SLC_MICRO, version.getMicro());
+		if (!version.getQualifier().equals(""))
+			versionNode.setProperty(RepoNames.SLC_QUALIFIER,
+					version.getQualifier());
+	}
+
+	private String attributeValue(String str) {
+		return extractValue(str, "=");
+	}
+
+	private String directiveValue(String str) {
+		return extractValue(str, ":=");
+	}
+
+	private String extractValue(String str, String eq) {
+		String[] tokens = str.split(eq);
+		// String key = tokens[0];
+		String value = tokens[1].trim();
+		// TODO: optimize?
+		if (value.startsWith("\""))
+			value = value.substring(1);
+		if (value.endsWith("\""))
+			value = value.substring(0, value.length() - 1);
+		return value;
+	}
+
 	protected Node createFileNode(Node parentNode, File file) {
+		Binary binary = null;
 		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(
+			binary = jcrSession.getValueFactory().createBinary(
 					new FileInputStream(file));
 			contentNode.setProperty(Property.JCR_DATA, binary);
-			binary.dispose();
+			// jar file
+			if (FilenameUtils.isExtension(file.getName(), "jar")) {
+				JarInputStream jarIn = null;
+				ByteArrayOutputStream bo = null;
+				ByteArrayInputStream bi = null;
+				Binary manifestBinary = null;
+				try {
+					jarIn = new JarInputStream(binary.getStream());
+					Manifest manifest = jarIn.getManifest();
+					bo = new ByteArrayOutputStream();
+					manifest.write(bo);
+					bi = new ByteArrayInputStream(bo.toByteArray());
+					manifestBinary = jcrSession.getValueFactory().createBinary(
+							bi);
+					fileNode.addMixin(RepoTypes.SLC_JAR_FILE);
+					fileNode.setProperty(RepoNames.SLC_MANIFEST, manifestBinary);
+					Attributes attrs = manifest.getMainAttributes();
+					addAttr(Attributes.Name.MANIFEST_VERSION, fileNode, attrs);
+					addAttr(Attributes.Name.SIGNATURE_VERSION, fileNode, attrs);
+					addAttr(Attributes.Name.CLASS_PATH, fileNode, attrs);
+					addAttr(Attributes.Name.MAIN_CLASS, fileNode, attrs);
+					addAttr(Attributes.Name.EXTENSION_NAME, fileNode, attrs);
+					addAttr(Attributes.Name.IMPLEMENTATION_VERSION, fileNode,
+							attrs);
+					addAttr(Attributes.Name.IMPLEMENTATION_VENDOR, fileNode,
+							attrs);
+					addAttr(Attributes.Name.IMPLEMENTATION_VENDOR_ID, fileNode,
+							attrs);
+					addAttr(Attributes.Name.SPECIFICATION_TITLE, fileNode,
+							attrs);
+					addAttr(Attributes.Name.SPECIFICATION_VERSION, fileNode,
+							attrs);
+					addAttr(Attributes.Name.SPECIFICATION_VENDOR, fileNode,
+							attrs);
+					addAttr(Attributes.Name.SEALED, fileNode, attrs);
+				} finally {
+					if (manifestBinary != null)
+						manifestBinary.dispose();
+					IOUtils.closeQuietly(bi);
+					IOUtils.closeQuietly(bo);
+					IOUtils.closeQuietly(jarIn);
+				}
+			}
 			return fileNode;
 		} catch (Exception e) {
 			throw new SlcException("Cannot create file node based on " + file
 					+ " under " + parentNode, e);
+		} finally {
+			if (binary != null)
+				binary.dispose();
 		}
 	}