--- /dev/null
+package org.argeo.slc.repo;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.TreeSet;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarInputStream;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+import java.util.zip.ZipInputStream;
+
+import javax.jcr.Credentials;
+import javax.jcr.GuestCredentials;
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.Property;
+import javax.jcr.PropertyIterator;
+import javax.jcr.Repository;
+import javax.jcr.RepositoryException;
+import javax.jcr.RepositoryFactory;
+import javax.jcr.Session;
+import javax.jcr.SimpleCredentials;
+import javax.jcr.nodetype.NodeType;
+
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.io.IOUtils;
+import org.argeo.api.cms.CmsLog;
+import org.argeo.api.cms.keyring.Keyring;
+import org.argeo.cms.ArgeoNames;
+import org.argeo.cms.ArgeoTypes;
+import org.argeo.cms.jcr.CmsJcrUtils;
+import org.argeo.jcr.JcrMonitor;
+import org.argeo.jcr.JcrUtils;
+import org.argeo.slc.DefaultNameVersion;
+import org.argeo.slc.NameVersion;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.SlcNames;
+import org.argeo.slc.SlcTypes;
+import org.argeo.slc.repo.maven.ArtifactIdComparator;
+import org.argeo.slc.repo.maven.MavenConventionsUtils;
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.DefaultArtifact;
+import org.osgi.framework.Constants;
+
+/** Utilities around repo */
+public class RepoUtils implements ArgeoNames, SlcNames {
+ private final static CmsLog log = CmsLog.getLog(RepoUtils.class);
+
+ /** Packages a regular sources jar as PDE source. */
+ public static void packagesAsPdeSource(File sourceFile,
+ NameVersion nameVersion, OutputStream out) throws IOException {
+ if (isAlreadyPdeSource(sourceFile)) {
+ FileInputStream in = new FileInputStream(sourceFile);
+ IOUtils.copy(in, out);
+ IOUtils.closeQuietly(in);
+ } else {
+ String sourceSymbolicName = nameVersion.getName() + ".source";
+
+ Manifest sourceManifest = null;
+ sourceManifest = new Manifest();
+ sourceManifest.getMainAttributes().put(
+ Attributes.Name.MANIFEST_VERSION, "1.0");
+ sourceManifest.getMainAttributes().putValue("Bundle-SymbolicName",
+ sourceSymbolicName);
+ sourceManifest.getMainAttributes().putValue("Bundle-Version",
+ nameVersion.getVersion());
+ sourceManifest.getMainAttributes().putValue(
+ "Eclipse-SourceBundle",
+ nameVersion.getName() + ";version="
+ + nameVersion.getVersion());
+ copyJar(sourceFile, out, sourceManifest);
+ }
+ }
+
+ public static byte[] packageAsPdeSource(InputStream sourceJar,
+ NameVersion nameVersion) {
+ String sourceSymbolicName = nameVersion.getName() + ".source";
+
+ Manifest sourceManifest = null;
+ sourceManifest = new Manifest();
+ sourceManifest.getMainAttributes().put(
+ Attributes.Name.MANIFEST_VERSION, "1.0");
+ sourceManifest.getMainAttributes().putValue("Bundle-SymbolicName",
+ sourceSymbolicName);
+ sourceManifest.getMainAttributes().putValue("Bundle-Version",
+ nameVersion.getVersion());
+ sourceManifest.getMainAttributes().putValue("Eclipse-SourceBundle",
+ nameVersion.getName() + ";version=" + nameVersion.getVersion());
+
+ return modifyManifest(sourceJar, sourceManifest);
+ }
+
+ /**
+ * Check whether the file as already been packaged as PDE source, in order
+ * not to mess with Jar signing
+ */
+ private static boolean isAlreadyPdeSource(File sourceFile) {
+ JarInputStream jarInputStream = null;
+
+ try {
+ jarInputStream = new JarInputStream(new FileInputStream(sourceFile));
+
+ Manifest manifest = jarInputStream.getManifest();
+ Iterator<?> it = manifest.getMainAttributes().keySet().iterator();
+ boolean res = false;
+ // containsKey() does not work, iterating...
+ while (it.hasNext())
+ if (it.next().toString().equals("Eclipse-SourceBundle")) {
+ res = true;
+ break;
+ }
+ // boolean res = manifest.getMainAttributes().get(
+ // "Eclipse-SourceBundle") != null;
+ if (res)
+ log.info(sourceFile + " is already a PDE source");
+ return res;
+ } catch (Exception e) {
+ // probably not a jar, skipping
+ if (log.isDebugEnabled())
+ log.debug("Skipping " + sourceFile + " because of "
+ + e.getMessage());
+ return false;
+ } finally {
+ IOUtils.closeQuietly(jarInputStream);
+ }
+ }
+
+ /**
+ * Copy a jar, replacing its manifest with the provided one
+ *
+ * @param manifest
+ * can be null
+ */
+ private static void copyJar(File source, OutputStream out, Manifest manifest)
+ throws IOException {
+ JarFile sourceJar = null;
+ JarOutputStream output = null;
+ try {
+ output = manifest != null ? new JarOutputStream(out, manifest)
+ : new JarOutputStream(out);
+ sourceJar = new JarFile(source);
+
+ entries: for (Enumeration<?> entries = sourceJar.entries(); entries
+ .hasMoreElements();) {
+ JarEntry entry = (JarEntry) entries.nextElement();
+ if (manifest != null
+ && entry.getName().equals("META-INF/MANIFEST.MF"))
+ continue entries;
+
+ InputStream entryStream = sourceJar.getInputStream(entry);
+ JarEntry newEntry = new JarEntry(entry.getName());
+ // newEntry.setMethod(JarEntry.DEFLATED);
+ output.putNextEntry(newEntry);
+ IOUtils.copy(entryStream, output);
+ }
+ } finally {
+ IOUtils.closeQuietly(output);
+ try {
+ if (sourceJar != null)
+ sourceJar.close();
+ } catch (IOException e) {
+ // silent
+ }
+ }
+ }
+
+ /** Copy a jar changing onlythe manifest */
+ public static void copyJar(InputStream in, OutputStream out,
+ Manifest manifest) {
+ JarInputStream jarIn = null;
+ JarOutputStream jarOut = null;
+ try {
+ jarIn = new JarInputStream(in);
+ jarOut = new JarOutputStream(out, manifest);
+ JarEntry jarEntry = null;
+ while ((jarEntry = jarIn.getNextJarEntry()) != null) {
+ if (!jarEntry.getName().equals("META-INF/MANIFEST.MF")) {
+ JarEntry newJarEntry = new JarEntry(jarEntry.getName());
+ jarOut.putNextEntry(newJarEntry);
+ IOUtils.copy(jarIn, jarOut);
+ jarIn.closeEntry();
+ jarOut.closeEntry();
+ }
+ }
+ } catch (IOException e) {
+ throw new SlcException("Could not copy jar with MANIFEST "
+ + manifest.getMainAttributes(), e);
+ } finally {
+ if (!(in instanceof ZipInputStream))
+ IOUtils.closeQuietly(jarIn);
+ IOUtils.closeQuietly(jarOut);
+ }
+ }
+
+ /** Reads a jar file, modify its manifest */
+ public static byte[] modifyManifest(InputStream in, Manifest manifest) {
+ ByteArrayOutputStream out = new ByteArrayOutputStream(200 * 1024);
+ try {
+ copyJar(in, out, manifest);
+ return out.toByteArray();
+ } finally {
+ IOUtils.closeQuietly(out);
+ }
+ }
+
+ /** Read the OSGi {@link NameVersion} */
+ public static NameVersion readNameVersion(Artifact artifact) {
+ File artifactFile = artifact.getFile();
+ if (artifact.getExtension().equals("pom")) {
+ // hack to process jars which weirdly appear as POMs
+ File jarFile = new File(artifactFile.getParentFile(),
+ FilenameUtils.getBaseName(artifactFile.getPath()) + ".jar");
+ if (jarFile.exists()) {
+ log.warn("Use " + jarFile + " instead of " + artifactFile
+ + " for " + artifact);
+ artifactFile = jarFile;
+ }
+ }
+ return readNameVersion(artifactFile);
+ }
+
+ /** Read the OSGi {@link NameVersion} */
+ public static NameVersion readNameVersion(File artifactFile) {
+ try {
+ return readNameVersion(new FileInputStream(artifactFile));
+ } catch (Exception e) {
+ // probably not a jar, skipping
+ if (log.isDebugEnabled()) {
+ log.debug("Skipping " + artifactFile + " because of " + e);
+ // e.printStackTrace();
+ }
+ }
+ return null;
+ }
+
+ /** Read the OSGi {@link NameVersion} */
+ public static NameVersion readNameVersion(InputStream in) {
+ JarInputStream jarInputStream = null;
+ try {
+ jarInputStream = new JarInputStream(in);
+ return readNameVersion(jarInputStream.getManifest());
+ } catch (Exception e) {
+ // probably not a jar, skipping
+ if (log.isDebugEnabled()) {
+ log.debug("Skipping because of " + e);
+ }
+ } finally {
+ IOUtils.closeQuietly(jarInputStream);
+ }
+ return null;
+ }
+
+ /** Read the OSGi {@link NameVersion} */
+ public static NameVersion readNameVersion(Manifest manifest) {
+ DefaultNameVersion nameVersion = new DefaultNameVersion();
+ nameVersion.setName(manifest.getMainAttributes().getValue(
+ Constants.BUNDLE_SYMBOLICNAME));
+
+ // Skip additional specs such as
+ // ; singleton:=true
+ if (nameVersion.getName().indexOf(';') > -1) {
+ nameVersion
+ .setName(new StringTokenizer(nameVersion.getName(), " ;")
+ .nextToken());
+ }
+
+ nameVersion.setVersion(manifest.getMainAttributes().getValue(
+ Constants.BUNDLE_VERSION));
+
+ return nameVersion;
+ }
+
+ /*
+ * DATA MODEL
+ */
+ /** The artifact described by this node */
+ public static Artifact asArtifact(Node node) throws RepositoryException {
+ if (node.isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE)) {
+ // FIXME update data model to store packaging at this level
+ String extension = "jar";
+ return new DefaultArtifact(node.getProperty(SLC_GROUP_ID)
+ .getString(),
+ node.getProperty(SLC_ARTIFACT_ID).getString(), extension,
+ node.getProperty(SLC_ARTIFACT_VERSION).getString());
+ } else if (node.isNodeType(SlcTypes.SLC_ARTIFACT)) {
+ return new DefaultArtifact(node.getProperty(SLC_GROUP_ID)
+ .getString(),
+ node.getProperty(SLC_ARTIFACT_ID).getString(), node
+ .getProperty(SLC_ARTIFACT_CLASSIFIER).getString(),
+ node.getProperty(SLC_ARTIFACT_EXTENSION).getString(), node
+ .getProperty(SLC_ARTIFACT_VERSION).getString());
+ } else if (node.isNodeType(SlcTypes.SLC_MODULE_COORDINATES)) {
+ return new DefaultArtifact(node.getProperty(SLC_CATEGORY)
+ .getString(), node.getProperty(SLC_NAME).getString(),
+ "jar", node.getProperty(SLC_VERSION).getString());
+ } else {
+ throw new SlcException("Unsupported node type for " + node);
+ }
+ }
+
+ /**
+ * The path to the PDE source related to this artifact (or artifact version
+ * base). There may or there may not be a node at this location (the
+ * returned path will typically be used to test whether PDE sources are
+ * attached to this artifact).
+ */
+ public static String relatedPdeSourcePath(String artifactBasePath,
+ Node artifactNode) throws RepositoryException {
+ Artifact artifact = asArtifact(artifactNode);
+ Artifact pdeSourceArtifact = new DefaultArtifact(artifact.getGroupId(),
+ artifact.getArtifactId() + ".source", artifact.getExtension(),
+ artifact.getVersion());
+ return MavenConventionsUtils.artifactPath(artifactBasePath,
+ pdeSourceArtifact);
+ }
+
+ /**
+ * Copy this bytes array as an artifact, relative to the root of the
+ * repository (typically the workspace root node)
+ */
+ public static Node copyBytesAsArtifact(Node artifactsBase,
+ Artifact artifact, byte[] bytes) throws RepositoryException {
+ String parentPath = MavenConventionsUtils.artifactParentPath(
+ artifactsBase.getPath(), artifact);
+ Node folderNode = JcrUtils.mkfolders(artifactsBase.getSession(),
+ parentPath);
+ return JcrUtils.copyBytesAsFile(folderNode,
+ MavenConventionsUtils.artifactFileName(artifact), bytes);
+ }
+
+ private RepoUtils() {
+ }
+
+ /** If a source return the base bundle name, does not change otherwise */
+ public static String extractBundleNameFromSourceName(String sourceBundleName) {
+ if (sourceBundleName.endsWith(".source"))
+ return sourceBundleName.substring(0, sourceBundleName.length()
+ - ".source".length());
+ else
+ return sourceBundleName;
+ }
+
+ /*
+ * SOFTWARE REPOSITORIES
+ */
+
+ /** Retrieve repository based on information in the repo node */
+ public static Repository getRepository(RepositoryFactory repositoryFactory,
+ Keyring keyring, Node repoNode) {
+ try {
+ Repository repository;
+ if (repoNode.isNodeType(ArgeoTypes.ARGEO_REMOTE_REPOSITORY)) {
+ String uri = repoNode.getProperty(ARGEO_URI).getString();
+ if (uri.startsWith("http")) {// http, https
+ repository = CmsJcrUtils.getRepositoryByUri(
+ repositoryFactory, uri);
+ } else if (uri.startsWith("vm:")) {// alias
+ repository = CmsJcrUtils.getRepositoryByUri(
+ repositoryFactory, uri);
+ } else {
+ throw new SlcException("Unsupported repository uri " + uri);
+ }
+ return repository;
+ } else {
+ throw new SlcException("Unsupported node type " + repoNode);
+ }
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot connect to repository " + repoNode,
+ e);
+ }
+ }
+
+ /**
+ * Reads credentials from node, using keyring if there is a password. Can
+ * return null if no credentials needed (local repo) at all, but returns
+ * {@link GuestCredentials} if user id is 'anonymous' .
+ */
+ public static Credentials getRepositoryCredentials(Keyring keyring,
+ Node repoNode) {
+ try {
+ if (repoNode.isNodeType(ArgeoTypes.ARGEO_REMOTE_REPOSITORY)) {
+ if (!repoNode.hasProperty(ARGEO_USER_ID))
+ return null;
+
+ String userId = repoNode.getProperty(ARGEO_USER_ID).getString();
+ if (userId.equals("anonymous"))// FIXME hardcoded userId
+ return new GuestCredentials();
+ char[] password = keyring.getAsChars(repoNode.getPath() + '/'
+ + ARGEO_PASSWORD);
+ Credentials credentials = new SimpleCredentials(userId,
+ password);
+ return credentials;
+ } else {
+ throw new SlcException("Unsupported node type " + repoNode);
+ }
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot connect to repository " + repoNode,
+ e);
+ }
+ }
+
+ /**
+ * Shortcut to retrieve a session given variable information: Handle the
+ * case where we only have an URI of the repository, that we want to connect
+ * as anonymous or the case of a identified connection to a local or remote
+ * repository.
+ *
+ * Callers must close the session once it has been used
+ */
+ public static Session getRemoteSession(RepositoryFactory repositoryFactory,
+ Keyring keyring, Node repoNode, String uri, String workspaceName) {
+ try {
+ if (repoNode == null && uri == null)
+ throw new SlcException(
+ "At least one of repoNode and uri must be defined");
+ Repository currRepo = null;
+ Credentials credentials = null;
+ // Anonymous URI only workspace
+ if (repoNode == null)
+ // Anonymous
+ currRepo = CmsJcrUtils.getRepositoryByUri(repositoryFactory, uri);
+ else {
+ currRepo = RepoUtils.getRepository(repositoryFactory, keyring,
+ repoNode);
+ credentials = RepoUtils.getRepositoryCredentials(keyring,
+ repoNode);
+ }
+ return currRepo.login(credentials, workspaceName);
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot connect to workspace "
+ + workspaceName + " of repository " + repoNode
+ + " with URI " + uri, e);
+ }
+ }
+
+ /**
+ * Shortcut to retrieve a session on a remote Jrc Repository from
+ * information stored in a local argeo node or from an URI: Handle the case
+ * where we only have an URI of the repository, that we want to connect as
+ * anonymous or the case of a identified connection to a local or remote
+ * repository.
+ *
+ * Callers must close the session once it has been used
+ */
+ public static Session getRemoteSession(RepositoryFactory repositoryFactory,
+ Keyring keyring, Repository localRepository, String repoNodePath,
+ String uri, String workspaceName) {
+ Session localSession = null;
+ Node repoNode = null;
+ try {
+ localSession = localRepository.login();
+ if (repoNodePath != null && localSession.nodeExists(repoNodePath))
+ repoNode = localSession.getNode(repoNodePath);
+
+ return RepoUtils.getRemoteSession(repositoryFactory, keyring,
+ repoNode, uri, workspaceName);
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot log to workspace " + workspaceName
+ + " for repo defined in " + repoNodePath, e);
+ } finally {
+ JcrUtils.logoutQuietly(localSession);
+ }
+ }
+
+ /**
+ * Write group indexes: 'binaries' lists all bundles and their versions,
+ * 'sources' list their sources, and 'sdk' aggregates both.
+ */
+ public static void writeGroupIndexes(Session session,
+ String artifactBasePath, String groupId, String version,
+ Set<Artifact> binaries, Set<Artifact> sources) {
+ try {
+ Set<Artifact> indexes = new TreeSet<Artifact>(
+ new ArtifactIdComparator());
+ Artifact binariesArtifact = writeIndex(session, artifactBasePath,
+ groupId, RepoConstants.BINARIES_ARTIFACT_ID, version,
+ binaries);
+ indexes.add(binariesArtifact);
+ if (sources != null) {
+ Artifact sourcesArtifact = writeIndex(session,
+ artifactBasePath, groupId,
+ RepoConstants.SOURCES_ARTIFACT_ID, version, sources);
+ indexes.add(sourcesArtifact);
+ }
+ // sdk
+ writeIndex(session, artifactBasePath, groupId,
+ RepoConstants.SDK_ARTIFACT_ID, version, indexes);
+ session.save();
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot write indexes for group " + groupId,
+ e);
+ }
+ }
+
+ /** Write a group index. */
+ private static Artifact writeIndex(Session session,
+ String artifactBasePath, String groupId, String artifactId,
+ String version, Set<Artifact> artifacts) throws RepositoryException {
+ Artifact artifact = new DefaultArtifact(groupId, artifactId, "pom",
+ version);
+ String pom = MavenConventionsUtils.artifactsAsDependencyPom(artifact,
+ artifacts, null);
+ Node node = RepoUtils.copyBytesAsArtifact(
+ session.getNode(artifactBasePath), artifact, pom.getBytes());
+ addMavenChecksums(node);
+ return artifact;
+ }
+
+ /** Add files containing the SHA-1 and MD5 checksums. */
+ public static void addMavenChecksums(Node node) throws RepositoryException {
+ // TODO optimize
+ String sha = JcrUtils.checksumFile(node, "SHA-1");
+ JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".sha1",
+ sha.getBytes());
+ String md5 = JcrUtils.checksumFile(node, "MD5");
+ JcrUtils.copyBytesAsFile(node.getParent(), node.getName() + ".md5",
+ md5.getBytes());
+ }
+
+ /**
+ * Custom copy since the one in commons does not fit the needs when copying
+ * a workspace completely.
+ */
+ public static void copy(Node fromNode, Node toNode) {
+ copy(fromNode, toNode, null);
+ }
+
+ public static void copy(Node fromNode, Node toNode, JcrMonitor monitor) {
+ try {
+ String fromPath = fromNode.getPath();
+ if (monitor != null)
+ monitor.subTask("copying node :" + fromPath);
+ if (log.isDebugEnabled())
+ log.debug("copy node :" + fromPath);
+
+ // FIXME : small hack to enable specific workspace copy
+ if (fromNode.isNodeType("rep:ACL")
+ || fromNode.isNodeType("rep:system")) {
+ if (log.isTraceEnabled())
+ log.trace("node " + fromNode + " skipped");
+ return;
+ }
+
+ // add mixins
+ for (NodeType mixinType : fromNode.getMixinNodeTypes()) {
+ toNode.addMixin(mixinType.getName());
+ }
+
+ // Double check
+ for (NodeType mixinType : toNode.getMixinNodeTypes()) {
+ if (log.isDebugEnabled())
+ log.debug(mixinType.getName());
+ }
+
+ // process properties
+ PropertyIterator pit = fromNode.getProperties();
+ properties: while (pit.hasNext()) {
+ Property fromProperty = pit.nextProperty();
+ String propName = fromProperty.getName();
+ try {
+ String propertyName = fromProperty.getName();
+ if (toNode.hasProperty(propertyName)
+ && toNode.getProperty(propertyName).getDefinition()
+ .isProtected())
+ continue properties;
+
+ if (fromProperty.getDefinition().isProtected())
+ continue properties;
+
+ if (propertyName.equals("jcr:created")
+ || propertyName.equals("jcr:createdBy")
+ || propertyName.equals("jcr:lastModified")
+ || propertyName.equals("jcr:lastModifiedBy"))
+ continue properties;
+
+ if (fromProperty.isMultiple()) {
+ toNode.setProperty(propertyName,
+ fromProperty.getValues());
+ } else {
+ toNode.setProperty(propertyName,
+ fromProperty.getValue());
+ }
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot property " + propName, e);
+ }
+ }
+
+ // recursively process children nodes
+ NodeIterator nit = fromNode.getNodes();
+ while (nit.hasNext()) {
+ Node fromChild = nit.nextNode();
+ Integer index = fromChild.getIndex();
+ String nodeRelPath = fromChild.getName() + "[" + index + "]";
+ Node toChild;
+ if (toNode.hasNode(nodeRelPath))
+ toChild = toNode.getNode(nodeRelPath);
+ else
+ toChild = toNode.addNode(fromChild.getName(), fromChild
+ .getPrimaryNodeType().getName());
+ copy(fromChild, toChild);
+ }
+
+ // update jcr:lastModified and jcr:lastModifiedBy in toNode in
+ // case
+ // they existed
+ if (!toNode.getDefinition().isProtected()
+ && toNode.isNodeType(NodeType.MIX_LAST_MODIFIED))
+ JcrUtils.updateLastModified(toNode);
+
+ // Workaround to reduce session size: artifact is a saveable
+ // unity
+ if (toNode.isNodeType(SlcTypes.SLC_ARTIFACT))
+ toNode.getSession().save();
+
+ if (monitor != null)
+ monitor.worked(1);
+
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot copy " + fromNode + " to " + toNode, e);
+ }
+ }
+
+}
projects / gpl / argeo-jcr.git / blobdiff