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=baf6ec723e0f852b4370e79c5921552de3391533;hb=e70fb767d8ff5972d88ab436762e71ea622a0f72;hp=27207118dfc1ff49498544041f629e23ced05fab;hpb=496f697b423f25a732d7d2e5b0405cfed0c31393;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 27207118d..baf6ec723 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 @@ -1,16 +1,36 @@ +/* + * 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.IOException; -import java.util.Arrays; +import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; +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,129 +41,202 @@ 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.argeo.slc.repo.osgi.OsgiProfile; 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 List excludedBundles = new ArrayList(); + private Map symbolicNamesMapping = new HashMap(); + + private Session origSession; private Session targetSession; - private List systemPackages; + private List systemPackages = OsgiProfile.PROFILE_JAVA_SE_1_6 + .getSystemPackages(); + + 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); // works only in OSGi!! - systemPackages = Arrays.asList(System.getProperty( - "org.osgi.framework.system.packages").split(",")); + // systemPackages = Arrays.asList(System.getProperty( + // "org.osgi.framework.system.packages").split(",")); } 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(); + // 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(); + node.getSession().save(); + if (log.isDebugEnabled()) + log.debug("Cleared " + node); + } + } + + NodeIterator origArtifacts = listArtifactVersions(origSession); + // 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); + + // skip eclipse artifacts + if ((origArtifact.getGroupId().startsWith("org.eclipse") && !(origArtifact + .getArtifactId().equals("org.eclipse.osgi") + || origArtifact.getArtifactId().equals( + "org.eclipse.osgi.source") || origArtifact + .getArtifactId().startsWith("org.eclipse.rwt.widgets.upload"))) + || origArtifact.getArtifactId().startsWith("com.ibm.icu")) { + if (log.isDebugEnabled()) + log.debug("Skip " + origArtifact); + return; + } + + // skip SpringSource ActiveMQ + if (origArtifact.getArtifactId().startsWith( + "com.springsource.org.apache.activemq")) + return; + + 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 (symbolicNamesMapping.containsKey(origSymbolicName)) { + targetSymbolicName = symbolicNamesMapping.get(origSymbolicName); + } else 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(Constants.BUNDLE_SYMBOLICNAME + " to " - + targetSymbolicName + " \t\tfrom " - + sourceSymbolicName); + } else { + targetSymbolicName = origSymbolicName; + } + + if (!targetSymbolicName.equals(origSymbolicName)) { targetManifest.getMainAttributes().putValue( Constants.BUNDLE_SYMBOLICNAME, targetSymbolicName); manifestModified = true; + if (log.isDebugEnabled()) + log.debug(Constants.BUNDLE_SYMBOLICNAME + " to " + + targetSymbolicName + " \t\tfrom " + origSymbolicName); } + // skip excluded bundles + if (excludedBundles.contains(targetSymbolicName)) + return; + // 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 = fragmentHost + if (origManifest.getMainAttributes().containsKey( + new Name(Constants.FRAGMENT_HOST))) { + String origFragmentHost = origManifest.getMainAttributes() + .getValue(Constants.FRAGMENT_HOST); + String targetFragmentHost; + if (symbolicNamesMapping.containsKey(origFragmentHost)) { + targetFragmentHost = symbolicNamesMapping.get(origFragmentHost); + } else if (origFragmentHost.startsWith(SPRING_SOURCE_PREFIX) + && !origFragmentHost.equals(SPRING_SOURCE_PREFIX + ".json")) { + targetFragmentHost = origFragmentHost .substring(SPRING_SOURCE_PREFIX.length() + 1); - if (log.isDebugEnabled()) - log.debug(Constants.FRAGMENT_HOST + " to " - + targetFragmentHost + " from " + fragmentHost); + } else if (origFragmentHost + .equals("org.argeo.dep.jacob;bundle-version=\"[1.14.3,1.14.4)\"")) { + // this one for those who think I cannot be pragmatic - mbaudier + targetFragmentHost = "com.jacob;bundle-version=\"[1.14.3,1.14.4)\""; + } else { + targetFragmentHost = origFragmentHost; + } + + if (!targetFragmentHost.equals(origFragmentHost)) { targetManifest.getMainAttributes().putValue( Constants.FRAGMENT_HOST, targetFragmentHost); manifestModified = true; + if (log.isDebugEnabled()) + log.debug(Constants.FRAGMENT_HOST + " to " + + targetFragmentHost + " from " + origFragmentHost); } } + // 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)) { @@ -153,16 +246,17 @@ public class Migration_01_03 implements Runnable, SlcNames { if (systemPackages.contains(pkg)) { if (!(sourceVersion.trim().equals("0") || sourceVersion .trim().equals("0.0.0"))) { - targetVersion = "0"; + targetVersion = null; importPackagesModified = true; if (log.isDebugEnabled()) - log.debug(sourceSymbolicName + log.debug(origSymbolicName + ": Nullify version of " + pkg + " from " + sourceVersion); } } - targetImportPackages.append(";version=\"") - .append(targetVersion).append("\""); + if (targetVersion != null) + targetImportPackages.append(";version=\"") + .append(targetVersion).append("\""); } if (importPackage.hasProperty(SLC_OPTIONAL)) { Boolean optional = importPackage.getProperty(SLC_OPTIONAL) @@ -171,7 +265,7 @@ public class Migration_01_03 implements Runnable, SlcNames { targetImportPackages.append(";resolution:=\"optional\""); } - if (sourceImportPackages.hasNext()) + if (origImportPackages.hasNext()) targetImportPackages.append(","); } @@ -182,7 +276,104 @@ 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.getArtifactId().startsWith( + "org.eclipse.rwt.widgets.upload")) + targetGroupId = "org.argeo.tp.rap"; + else if (origArtifact.getArtifactId().startsWith("org.polymap")) + targetGroupId = "org.argeo.tp.rap"; + else if (origArtifact.getGroupId().startsWith("org.eclipse") + && !origArtifact.getArtifactId().equals("org.eclipse.osgi")) + throw new SlcException(origArtifact + " should have been excluded");// 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(); } } @@ -221,4 +412,13 @@ public class Migration_01_03 implements Runnable, SlcNames { public void setTargetWorkspace(String targetWorkspace) { this.targetWorkspace = targetWorkspace; } + + public void setExcludedBundles(List excludedBundles) { + this.excludedBundles = excludedBundles; + } + + public void setSymbolicNamesMapping(Map symbolicNamesMapping) { + this.symbolicNamesMapping = symbolicNamesMapping; + } + }