runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/maven/Migration_01_03.java

   1 package org.argeo.slc.repo.maven;
   2
   3 import java.io.IOException;
   4 import java.util.Arrays;
   5 import java.util.List;
   6 import java.util.jar.Manifest;
   7
   8 import javax.jcr.Binary;
   9 import javax.jcr.Node;
  10 import javax.jcr.NodeIterator;
  11 import javax.jcr.Repository;
  12 import javax.jcr.RepositoryException;
  13 import javax.jcr.Session;
  14 import javax.jcr.query.QueryManager;
  15 import javax.jcr.query.QueryResult;
  16 import javax.jcr.query.qom.Ordering;
  17 import javax.jcr.query.qom.QueryObjectModel;
  18 import javax.jcr.query.qom.QueryObjectModelFactory;
  19 import javax.jcr.query.qom.Selector;
  20
  21 import org.apache.commons.logging.Log;
  22 import org.apache.commons.logging.LogFactory;
  23 import org.argeo.jcr.JcrUtils;
  24 import org.argeo.slc.SlcException;
  25 import org.argeo.slc.jcr.SlcNames;
  26 import org.argeo.slc.jcr.SlcTypes;
  27 import org.osgi.framework.Constants;
  28
  29 /**
  30  * Migrate the distribution from 1.2 to 1.4 by cleaning naming and dependencies.
  31  * The dependency to the SpringSource Enterprise Bundle repository is removed as
  32  * well as theire naming convention. All third party are move to org.argeo.tp
  33  * group IDs. Maven dependency for Eclipse artifacts don't use version ranges
  34  * anymore. Verison constraints on javax.* packages are removed (since they lead
  35  * to "use package conflicts" when Eclipse and Spring Security are used
  36  * together).
  37  */
  38 public class Migration_01_03 implements Runnable, SlcNames {
  39         private final static Log log = LogFactory.getLog(Migration_01_03.class);
  40
  41         private Repository repository;
  42         private String sourceWorkspace;
  43         private String targetWorkspace;
  44
  45         private Session sourceSession;
  46         private Session targetSession;
  47
  48         private List<String> systemPackages;
  49
  50         public void init() throws RepositoryException {
  51                 sourceSession = JcrUtils.loginOrCreateWorkspace(repository,
  52                                 sourceWorkspace);
  53                 targetSession = JcrUtils.loginOrCreateWorkspace(repository,
  54                                 targetWorkspace);
  55
  56                 // works only in OSGi!!
  57                 systemPackages = Arrays.asList(System.getProperty(
  58                                 "org.osgi.framework.system.packages").split(","));
  59         }
  60
  61         public void destroy() {
  62                 JcrUtils.logoutQuietly(sourceSession);
  63                 JcrUtils.logoutQuietly(targetSession);
  64         }
  65
  66         public void run() {
  67                 log.debug(System.getProperty("org.osgi.framework.system.packages"));
  68                 try {
  69                         NodeIterator sourceArtifacts = listArtifactVersions(sourceSession);
  70                         while (sourceArtifacts.hasNext()) {
  71                                 Node sourceArtifactNode = sourceArtifacts.nextNode();
  72                                 if (log.isTraceEnabled())
  73                                         log.trace(sourceArtifactNode);
  74
  75                                 processSourceArtifactVersion(sourceArtifactNode);
  76                         }
  77                 } catch (Exception e) {
  78                         throw new SlcException("Cannot perform v1.3 migration from "
  79                                         + sourceWorkspace + " to " + targetWorkspace, e);
  80                 }
  81         }
  82
  83         protected void processSourceArtifactVersion(Node sourceArtifactNode)
  84                         throws RepositoryException, IOException {
  85                 // find jar node
  86                 String sourceJarNodeName = sourceArtifactNode.getProperty(
  87                                 SLC_ARTIFACT_ID).getString()
  88                                 + "-"
  89                                 + sourceArtifactNode.getProperty(SLC_ARTIFACT_VERSION)
  90                                                 .getString() + ".jar";
  91                 if (!sourceArtifactNode.hasNode(sourceJarNodeName))
  92                         throw new SlcException("Cannot find jar node for "
  93                                         + sourceArtifactNode);
  94                 Node sourceJarNode = sourceArtifactNode.getNode(sourceJarNodeName);
  95
  96                 // read MANIFEST
  97                 Binary manifestBinary = sourceJarNode.getProperty(SLC_MANIFEST)
  98                                 .getBinary();
  99                 Manifest sourceManifest = new Manifest(manifestBinary.getStream());
 100                 JcrUtils.closeQuietly(manifestBinary);
 101
 102                 Boolean manifestModified = false;
 103                 Manifest targetManifest = new Manifest(sourceManifest);
 104
 105                 // transform symbolic name
 106                 String sourceSymbolicName = sourceManifest.getMainAttributes()
 107                                 .getValue(Constants.BUNDLE_SYMBOLICNAME);
 108                 final String SPRING_SOURCE_PREFIX = "com.springsource";
 109                 if (sourceSymbolicName.startsWith(SPRING_SOURCE_PREFIX)
 110                                 && !sourceSymbolicName.equals(SPRING_SOURCE_PREFIX + ".json")) {
 111                         String targetSymbolicName = sourceSymbolicName
 112                                         .substring(SPRING_SOURCE_PREFIX.length() + 1);
 113                         if (log.isDebugEnabled())
 114                                 log.debug("Renamed " + Constants.BUNDLE_SYMBOLICNAME + " to "
 115                                                 + targetSymbolicName + " \t\tfrom "
 116                                                 + sourceSymbolicName);
 117                         targetManifest.getMainAttributes().putValue(
 118                                         Constants.BUNDLE_SYMBOLICNAME, targetSymbolicName);
 119                         manifestModified = true;
 120                 }
 121
 122                 // check fragment host
 123                 if (sourceManifest.getMainAttributes().containsKey(
 124                                 Constants.FRAGMENT_HOST)) {
 125                         String fragmentHost = sourceManifest.getMainAttributes().getValue(
 126                                         Constants.FRAGMENT_HOST);
 127                         if (fragmentHost.startsWith(SPRING_SOURCE_PREFIX)
 128                                         && !fragmentHost.equals(SPRING_SOURCE_PREFIX + ".json")) {
 129                                 String targetFragmentHost = sourceSymbolicName
 130                                                 .substring(SPRING_SOURCE_PREFIX.length() + 1);
 131                                 if (log.isDebugEnabled())
 132                                         log.debug("Renamed " + Constants.FRAGMENT_HOST + " to "
 133                                                         + targetFragmentHost + " from " + fragmentHost);
 134                                 targetManifest.getMainAttributes().putValue(
 135                                                 Constants.FRAGMENT_HOST, targetFragmentHost);
 136                                 manifestModified = true;
 137                         }
 138                 }
 139
 140                 // javax with versions
 141                 StringBuffer targetImportPackages = new StringBuffer("");
 142                 NodeIterator sourceImportPackages = sourceJarNode.getNodes(SLC_
 143                                 + Constants.IMPORT_PACKAGE);
 144                 Boolean importPackagesModified = false;
 145                 while (sourceImportPackages.hasNext()) {
 146                         Node importPackage = sourceImportPackages.nextNode();
 147                         String pkg = importPackage.getProperty(SLC_NAME).getString();
 148                         targetImportPackages.append(pkg);
 149                         if (importPackage.hasProperty(SLC_VERSION)) {
 150                                 String sourceVersion = importPackage.getProperty(SLC_VERSION)
 151                                                 .getString();
 152                                 String targetVersion = sourceVersion;
 153                                 if (systemPackages.contains(pkg)) {
 154                                         if (!(sourceVersion.trim().equals("0") || sourceVersion
 155                                                         .trim().equals("0.0.0"))) {
 156                                                 targetVersion = "0";
 157                                                 importPackagesModified = true;
 158                                                 if (log.isDebugEnabled())
 159                                                         log.debug(sourceSymbolicName
 160                                                                         + ": Nullify version of " + pkg + " from "
 161                                                                         + sourceVersion);
 162                                         }
 163                                 }
 164                                 targetImportPackages.append(";version=\"")
 165                                                 .append(targetVersion).append("\"");
 166                         }
 167                         if (importPackage.hasProperty(SLC_OPTIONAL)) {
 168                                 Boolean optional = importPackage.getProperty(SLC_OPTIONAL)
 169                                                 .getBoolean();
 170                                 if (optional)
 171                                         targetImportPackages.append(";resolution:=\"optional\"");
 172
 173                         }
 174                         if (sourceImportPackages.hasNext())
 175                                 targetImportPackages.append(",");
 176                 }
 177
 178                 if (importPackagesModified) {
 179                         targetManifest.getMainAttributes().putValue(
 180                                         Constants.IMPORT_PACKAGE, targetImportPackages.toString());
 181                         manifestModified = true;
 182                 }
 183
 184                 if (!manifestModified && log.isTraceEnabled()) {
 185                         log.trace("MANIFEST of " + sourceSymbolicName + " was not modified");
 186                 }
 187         }
 188
 189         /*
 190          * UTILITIES
 191          */
 192
 193         static NodeIterator listArtifactVersions(Session session)
 194                         throws RepositoryException {
 195                 QueryManager queryManager = session.getWorkspace().getQueryManager();
 196                 QueryObjectModelFactory factory = queryManager.getQOMFactory();
 197
 198                 final String artifactVersionsSelector = "artifactVersions";
 199                 Selector source = factory.selector(SlcTypes.SLC_ARTIFACT_VERSION_BASE,
 200                                 artifactVersionsSelector);
 201
 202                 Ordering orderByArtifactId = factory.ascending(factory.propertyValue(
 203                                 artifactVersionsSelector, SlcNames.SLC_ARTIFACT_ID));
 204                 Ordering[] orderings = { orderByArtifactId };
 205
 206                 QueryObjectModel query = factory.createQuery(source, null, orderings,
 207                                 null);
 208
 209                 QueryResult result = query.execute();
 210                 return result.getNodes();
 211         }
 212
 213         public void setRepository(Repository repository) {
 214                 this.repository = repository;
 215         }
 216
 217         public void setSourceWorkspace(String sourceWorkspace) {
 218                 this.sourceWorkspace = sourceWorkspace;
 219         }
 220
 221         public void setTargetWorkspace(String targetWorkspace) {
 222                 this.targetWorkspace = targetWorkspace;
 223         }
 224 }