X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=runtime%2Forg.argeo.slc.repo%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fslc%2Frepo%2Fmaven%2FMigration_01_03.java;h=9e37f7592516e5de8b0aa099f7c57050516615b1;hb=44c43b9c874d7c6edd4327f180d5506b3e9c99e6;hp=e21dbc10c8efcef486fa04ead5a515996bf64d79;hpb=b91ff34d9c8c9f93f1f49f78b07ae626f0a99445;p=gpl%2Fargeo-slc.git diff --git a/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/Migration_01_03.java b/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/Migration_01_03.java index e21dbc10c..9e37f7592 100644 --- a/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/Migration_01_03.java +++ b/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/Migration_01_03.java @@ -3,14 +3,17 @@ package org.argeo.slc.repo.maven; import java.io.IOException; import java.util.Arrays; import java.util.List; +import java.util.jar.Attributes.Name; import java.util.jar.Manifest; import javax.jcr.Binary; import javax.jcr.Node; import javax.jcr.NodeIterator; +import javax.jcr.Property; import javax.jcr.Repository; import javax.jcr.RepositoryException; import javax.jcr.Session; +import javax.jcr.nodetype.NodeType; import javax.jcr.query.QueryManager; import javax.jcr.query.QueryResult; import javax.jcr.query.qom.Ordering; @@ -21,34 +24,46 @@ import javax.jcr.query.qom.Selector; 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.jcr.SlcNames; import org.argeo.slc.jcr.SlcTypes; +import org.argeo.slc.repo.ArtifactIndexer; +import org.argeo.slc.repo.JarFileIndexer; +import org.argeo.slc.repo.RepoUtils; import org.osgi.framework.Constants; +import org.sonatype.aether.artifact.Artifact; +import org.sonatype.aether.util.artifact.DefaultArtifact; /** * Migrate the distribution from 1.2 to 1.4 by cleaning naming and dependencies. * The dependency to the SpringSource Enterprise Bundle repository is removed as - * well as theire naming convention. All third party are move to org.argeo.tp + * well as their naming conventions. All third party are move to org.argeo.tp * group IDs. Maven dependency for Eclipse artifacts don't use version ranges * anymore. Verison constraints on javax.* packages are removed (since they lead * to "use package conflicts" when Eclipse and Spring Security are used * together). */ public class Migration_01_03 implements Runnable, SlcNames { + final String SPRING_SOURCE_PREFIX = "com.springsource"; private final static Log log = LogFactory.getLog(Migration_01_03.class); private Repository repository; private String sourceWorkspace; private String targetWorkspace; - private Session sourceSession; + private Session origSession; private Session targetSession; private List systemPackages; + private String artifactBasePath = "/"; + + private ArtifactIndexer artifactIndexer = new ArtifactIndexer(); + private JarFileIndexer jarFileIndexer = new JarFileIndexer(); + public void init() throws RepositoryException { - sourceSession = JcrUtils.loginOrCreateWorkspace(repository, + origSession = JcrUtils.loginOrCreateWorkspace(repository, sourceWorkspace); targetSession = JcrUtils.loginOrCreateWorkspace(repository, targetWorkspace); @@ -59,91 +74,106 @@ public class Migration_01_03 implements Runnable, SlcNames { } public void destroy() { - JcrUtils.logoutQuietly(sourceSession); + JcrUtils.logoutQuietly(origSession); JcrUtils.logoutQuietly(targetSession); } public void run() { - log.debug(System.getProperty("org.osgi.framework.system.packages")); + try { - NodeIterator sourceArtifacts = listArtifactVersions(sourceSession); - while (sourceArtifacts.hasNext()) { - Node sourceArtifactNode = sourceArtifacts.nextNode(); + NodeIterator origArtifacts = listArtifactVersions(origSession); + + // clear target + NodeIterator nit = targetSession.getNode(artifactBasePath) + .getNodes(); + while (nit.hasNext()) { + Node node = nit.nextNode(); + if (node.isNodeType(NodeType.NT_FOLDER) + || node.isNodeType(NodeType.NT_UNSTRUCTURED)) + node.remove(); + } + targetSession.save(); + + // process + while (origArtifacts.hasNext()) { + Node origArtifactNode = origArtifacts.nextNode(); if (log.isTraceEnabled()) - log.trace(sourceArtifactNode); + log.trace(origArtifactNode); - processSourceArtifactVersion(sourceArtifactNode); + processOrigArtifactVersion(origArtifactNode); } } catch (Exception e) { throw new SlcException("Cannot perform v1.3 migration from " + sourceWorkspace + " to " + targetWorkspace, e); + } finally { + JcrUtils.discardQuietly(targetSession); } } - protected void processSourceArtifactVersion(Node sourceArtifactNode) + protected void processOrigArtifactVersion(Node origArtifactNode) throws RepositoryException, IOException { - // find jar node - String sourceJarNodeName = sourceArtifactNode.getProperty( - SLC_ARTIFACT_ID).getString() - + "-" - + sourceArtifactNode.getProperty(SLC_ARTIFACT_VERSION) - .getString() + ".jar"; - if (!sourceArtifactNode.hasNode(sourceJarNodeName)) + Artifact origArtifact = RepoUtils.asArtifact(origArtifactNode); + String origJarNodeName = MavenConventionsUtils + .artifactFileName(origArtifact); + if (!origArtifactNode.hasNode(origJarNodeName)) throw new SlcException("Cannot find jar node for " - + sourceArtifactNode); - Node sourceJarNode = sourceArtifactNode.getNode(sourceJarNodeName); + + origArtifactNode); + Node origJarNode = origArtifactNode.getNode(origJarNodeName); // read MANIFEST - Binary manifestBinary = sourceJarNode.getProperty(SLC_MANIFEST) + Binary manifestBinary = origJarNode.getProperty(SLC_MANIFEST) .getBinary(); - Manifest sourceManifest = new Manifest(manifestBinary.getStream()); + Manifest origManifest = new Manifest(manifestBinary.getStream()); JcrUtils.closeQuietly(manifestBinary); Boolean manifestModified = false; - Manifest targetManifest = new Manifest(sourceManifest); + Manifest targetManifest = new Manifest(origManifest); // transform symbolic name - String sourceSymbolicName = sourceManifest.getMainAttributes() - .getValue(Constants.BUNDLE_SYMBOLICNAME); - final String SPRING_SOURCE_PREFIX = "com.springsource"; - if (sourceSymbolicName.startsWith(SPRING_SOURCE_PREFIX) - && !sourceSymbolicName.equals(SPRING_SOURCE_PREFIX + ".json")) { - String targetSymbolicName = sourceSymbolicName + String origSymbolicName = origManifest.getMainAttributes().getValue( + Constants.BUNDLE_SYMBOLICNAME); + final String targetSymbolicName; + if (origSymbolicName.startsWith(SPRING_SOURCE_PREFIX) + && !origSymbolicName.equals(SPRING_SOURCE_PREFIX + ".json")) { + targetSymbolicName = origSymbolicName .substring(SPRING_SOURCE_PREFIX.length() + 1); if (log.isDebugEnabled()) - log.debug("Renamed " + Constants.BUNDLE_SYMBOLICNAME + " to " - + targetSymbolicName + " \t\tfrom " - + sourceSymbolicName); + log.debug(Constants.BUNDLE_SYMBOLICNAME + " to " + + targetSymbolicName + " \t\tfrom " + origSymbolicName); targetManifest.getMainAttributes().putValue( Constants.BUNDLE_SYMBOLICNAME, targetSymbolicName); manifestModified = true; + } else { + targetSymbolicName = origSymbolicName; } // check fragment host - if (sourceManifest.getMainAttributes().containsKey( - Constants.FRAGMENT_HOST)) { - String fragmentHost = sourceManifest.getMainAttributes().getValue( - Constants.FRAGMENT_HOST); - if (fragmentHost.startsWith(SPRING_SOURCE_PREFIX) - && !fragmentHost.equals(SPRING_SOURCE_PREFIX + ".json")) { - String targetFragmentHost = sourceSymbolicName + if (origManifest.getMainAttributes().containsKey( + new Name(Constants.FRAGMENT_HOST))) { + String origFragmentHost = origManifest.getMainAttributes() + .getValue(Constants.FRAGMENT_HOST); + if (origFragmentHost.startsWith(SPRING_SOURCE_PREFIX) + && !origFragmentHost.equals(SPRING_SOURCE_PREFIX + ".json")) { + String targetFragmentHost = origFragmentHost .substring(SPRING_SOURCE_PREFIX.length() + 1); if (log.isDebugEnabled()) - log.debug("Renamed " + Constants.FRAGMENT_HOST + " to " - + targetFragmentHost + " from " + fragmentHost); + log.debug(Constants.FRAGMENT_HOST + " to " + + targetFragmentHost + " from " + origFragmentHost); targetManifest.getMainAttributes().putValue( Constants.FRAGMENT_HOST, targetFragmentHost); manifestModified = true; } } + // we assume there is no Require-Bundle in com.springsource.* bundles + // javax with versions StringBuffer targetImportPackages = new StringBuffer(""); - NodeIterator sourceImportPackages = sourceJarNode.getNodes(SLC_ + NodeIterator origImportPackages = origJarNode.getNodes(SLC_ + Constants.IMPORT_PACKAGE); Boolean importPackagesModified = false; - while (sourceImportPackages.hasNext()) { - Node importPackage = sourceImportPackages.nextNode(); + while (origImportPackages.hasNext()) { + Node importPackage = origImportPackages.nextNode(); String pkg = importPackage.getProperty(SLC_NAME).getString(); targetImportPackages.append(pkg); if (importPackage.hasProperty(SLC_VERSION)) { @@ -156,7 +186,7 @@ public class Migration_01_03 implements Runnable, SlcNames { targetVersion = "0"; importPackagesModified = true; if (log.isDebugEnabled()) - log.debug(sourceSymbolicName + log.debug(origSymbolicName + ": Nullify version of " + pkg + " from " + sourceVersion); } @@ -171,7 +201,7 @@ public class Migration_01_03 implements Runnable, SlcNames { targetImportPackages.append(";resolution:=\"optional\""); } - if (sourceImportPackages.hasNext()) + if (origImportPackages.hasNext()) targetImportPackages.append(","); } @@ -182,7 +212,96 @@ public class Migration_01_03 implements Runnable, SlcNames { } if (!manifestModified && log.isTraceEnabled()) { - log.trace("MANIFEST of " + sourceSymbolicName + " was not modified"); + log.trace("MANIFEST of " + origSymbolicName + " was not modified"); + } + + // target coordinates + final String targetGroupId; + if (origArtifact.getGroupId().startsWith("org.eclipse")) + targetGroupId = "org.argeo.tp.eclipse"; + else + targetGroupId = "org.argeo.tp"; + + String targetArtifactId = targetSymbolicName.split(";")[0]; + Artifact targetArtifact = new DefaultArtifact(targetGroupId, + targetArtifactId, "jar", origArtifact.getVersion()); + String targetParentPath = MavenConventionsUtils.artifactParentPath( + artifactBasePath, targetArtifact); + String targetFileName = MavenConventionsUtils + .artifactFileName(targetArtifact); + String targetJarPath = targetParentPath + '/' + targetFileName; + + // copy + Node targetParentNode = JcrUtils.mkfolders(targetSession, + targetParentPath); + targetSession.save(); + if (manifestModified) { + Binary origBinary = origJarNode.getNode(Node.JCR_CONTENT) + .getProperty(Property.JCR_DATA).getBinary(); + byte[] targetJarBytes = RepoUtils.modifyManifest( + origBinary.getStream(), targetManifest); + JcrUtils.copyBytesAsFile(targetParentNode, targetFileName, + targetJarBytes); + JcrUtils.closeQuietly(origBinary); + } else {// just copy + targetSession.getWorkspace().copy(sourceWorkspace, + origJarNode.getPath(), targetJarPath); + } + targetSession.save(); + + // reindex + Node targetJarNode = targetSession.getNode(targetJarPath); + artifactIndexer.index(targetJarNode); + jarFileIndexer.index(targetJarNode); + + targetSession.save(); + + // sources + Artifact origSourceArtifact = new DefaultArtifact( + origArtifact.getGroupId(), origArtifact.getArtifactId() + + ".source", "jar", origArtifact.getVersion()); + String origSourcePath = MavenConventionsUtils.artifactPath( + artifactBasePath, origSourceArtifact); + if (origSession.itemExists(origSourcePath)) { + Node origSourceJarNode = origSession.getNode(origSourcePath); + + Artifact targetSourceArtifact = new DefaultArtifact(targetGroupId, + targetArtifactId + ".source", "jar", + origArtifact.getVersion()); + String targetSourceParentPath = MavenConventionsUtils + .artifactParentPath(artifactBasePath, targetSourceArtifact); + String targetSourceFileName = MavenConventionsUtils + .artifactFileName(targetSourceArtifact); + String targetSourceJarPath = targetSourceParentPath + '/' + + targetSourceFileName; + + Node targetSourceParentNode = JcrUtils.mkfolders(targetSession, + targetSourceParentPath); + targetSession.save(); + + if (!targetSymbolicName.equals(origSymbolicName)) { + Binary origBinary = origSourceJarNode.getNode(Node.JCR_CONTENT) + .getProperty(Property.JCR_DATA).getBinary(); + NameVersion targetNameVersion = RepoUtils + .readNameVersion(targetManifest); + byte[] targetJarBytes = RepoUtils.packageAsPdeSource( + origBinary.getStream(), targetNameVersion); + JcrUtils.copyBytesAsFile(targetSourceParentNode, + targetSourceFileName, targetJarBytes); + JcrUtils.closeQuietly(origBinary); + } else {// just copy + targetSession.getWorkspace().copy(sourceWorkspace, + origSourceJarNode.getPath(), targetSourceJarPath); + } + targetSession.save(); + + // reindex + Node targetSourceJarNode = targetSession + .getNode(targetSourceJarPath); + artifactIndexer.index(targetSourceJarNode); + jarFileIndexer.index(targetSourceJarNode); + + targetSession.save(); } }