package org.argeo.slc.build;
+import static org.argeo.slc.ManifestConstants.BUNDLE_LICENSE;
+import static org.argeo.slc.ManifestConstants.SLC_ORIGIN_M2;
+
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
+import java.io.Writer;
import java.lang.System.Logger;
import java.lang.System.Logger.Level;
import java.net.URL;
+import java.nio.file.DirectoryStream;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitResult;
import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.ManifestConstants;
import org.argeo.slc.NameVersion;
+import org.argeo.slc.build.m2.DefaultArtifact;
+import org.argeo.slc.build.m2.MavenConventionsUtils;
public class A2Factory {
private final static Logger logger = System.getLogger(A2Factory.class.getName());
+ private final static String COMMON_BND = "common.bnd";
+
private Path originBase;
private Path factoryBase;
mirrors.put("http://www.eclipse.org/downloads", eclipseMirrors);
}
+ public void processM2BasedDistributionUnit(Path duDir) {
+ try {
+ String category = duDir.getParent().getFileName().toString();
+ Path targetCategoryBase = factoryBase.resolve(category);
+ Path commonBnd = duDir.resolve(COMMON_BND);
+ Properties commonProps = new Properties();
+ try (InputStream in = Files.newInputStream(commonBnd)) {
+ commonProps.load(in);
+ }
+
+ String m2Version = commonProps.getProperty(SLC_ORIGIN_M2.toString());
+ if (!m2Version.startsWith(":")) {
+ throw new IllegalStateException("Only the M2 version can be specified: " + m2Version);
+ }
+ m2Version = m2Version.substring(1);
+
+ // String license = commonProps.getProperty(BUNDLE_LICENSE.toString());
+
+ DirectoryStream<Path> ds = Files.newDirectoryStream(duDir,
+ (p) -> p.getFileName().toString().endsWith(".bnd")
+ && !p.getFileName().toString().equals(COMMON_BND));
+ for (Path p : ds) {
+ Properties fileProps = new Properties();
+ try (InputStream in = Files.newInputStream(p)) {
+ fileProps.load(in);
+ }
+ String m2Coordinates = fileProps.getProperty(SLC_ORIGIN_M2.toString());
+ DefaultArtifact artifact = new DefaultArtifact(m2Coordinates);
+
+ // temporary rewrite, for migration
+ String localLicense = fileProps.getProperty(BUNDLE_LICENSE.toString());
+ if (localLicense != null || artifact.getVersion() != null) {
+ fileProps.remove(BUNDLE_LICENSE.toString());
+ fileProps.put(SLC_ORIGIN_M2.toString(), artifact.getGroupId() + ":" + artifact.getArtifactId());
+ try (Writer writer = Files.newBufferedWriter(p)) {
+ for (Object key : fileProps.keySet()) {
+ String value = fileProps.getProperty(key.toString());
+ writer.write(key + ": " + value + '\n');
+ }
+ logger.log(Level.DEBUG, () -> "Migrated " + p);
+ }
+ }
+
+ artifact.setVersion(m2Version);
+ URL url = MavenConventionsUtils.mavenCentralUrl(artifact);
+ Path downloaded = download(url, originBase, artifact.toM2Coordinates() + ".jar");
+
+ // prepare manifest entries
+ Map<String, String> entries = new HashMap<>();
+ for (Object key : commonProps.keySet()) {
+ entries.put(key.toString(), commonProps.getProperty(key.toString()));
+ }
+ fileEntries: for (Object key : fileProps.keySet()) {
+ if (ManifestConstants.SLC_ORIGIN_M2.toString().equals(key))
+ continue fileEntries;
+ String value = fileProps.getProperty(key.toString());
+ String previousValue = entries.put(key.toString(), value);
+ if (previousValue != null) {
+ logger.log(Level.WARNING,
+ downloaded + ": " + key + " was " + previousValue + ", overridden with " + value);
+ }
+ }
+ entries.put(ManifestConstants.SLC_ORIGIN_M2.toString(), artifact.toM2Coordinates());
+ Path targetBundleDir = processBundleJar(downloaded, targetCategoryBase, entries);
+ logger.log(Level.DEBUG, () -> "Processed " + downloaded);
+
+ // sources
+ DefaultArtifact sourcesArtifact = new DefaultArtifact(artifact.toM2Coordinates(), "sources");
+ URL sourcesUrl = MavenConventionsUtils.mavenCentralUrl(sourcesArtifact);
+ Path sourcesDownloaded = download(sourcesUrl, originBase, artifact.toM2Coordinates() + ".sources.jar");
+ processM2SourceJar(sourcesDownloaded, targetBundleDir);
+ logger.log(Level.DEBUG, () -> "Processed " + sourcesDownloaded);
+ }
+ } catch (IOException e) {
+ throw new RuntimeException("Cannot process " + duDir, e);
+ }
+
+ }
+
+ protected void processM2SourceJar(Path file, Path targetBundleDir) throws IOException {
+ try (JarInputStream jarIn = new JarInputStream(Files.newInputStream(file), false)) {
+ Path targetSourceDir = targetBundleDir.resolve("OSGI-OPT/src");
+
+ // TODO make it less dangerous?
+ if (Files.exists(targetSourceDir)) {
+ deleteDirectory(targetSourceDir);
+ } else {
+ Files.createDirectories(targetSourceDir);
+ }
+
+ // copy entries
+ JarEntry entry;
+ entries: while ((entry = jarIn.getNextJarEntry()) != null) {
+ if (entry.isDirectory())
+ continue entries;
+ if (entry.getName().startsWith("META-INF"))// skip META-INF entries
+ continue entries;
+ Path target = targetSourceDir.resolve(entry.getName());
+ Files.createDirectories(target.getParent());
+ Files.copy(jarIn, target);
+ logger.log(Level.TRACE, () -> "Copied source " + target);
+ }
+ }
+
+ }
+
public void processEclipseArchive(Path duDir) {
try {
String category = duDir.getParent().getFileName().toString();
Files.createDirectories(targetCategoryBase);
Files.createDirectories(originBase);
- Path commonBnd = duDir.resolve("common.bnd");
+ Path commonBnd = duDir.resolve(COMMON_BND);
Properties commonProps = new Properties();
try (InputStream in = Files.newInputStream(commonBnd)) {
commonProps.load(in);
logger.log(Level.DEBUG, () -> "Processed source " + file);
} else {
- processBundleJar(file, targetCategoryBase);
+ processBundleJar(file, targetCategoryBase, new HashMap<>());
logger.log(Level.DEBUG, () -> "Processed " + file);
}
continue pathMatchers;
}
- protected void processBundleJar(Path file, Path targetBase) throws IOException {
+ protected Path processBundleJar(Path file, Path targetBase, Map<String, String> additionalManifestEntries)
+ throws IOException {
NameVersion nameVersion;
Path targetBundleDir;
try (JarInputStream jarIn = new JarInputStream(Files.newInputStream(file), false)) {
// copy MANIFEST
Path manifestPath = targetBundleDir.resolve("META-INF/MANIFEST.MF");
Files.createDirectories(manifestPath.getParent());
+ for (String key : additionalManifestEntries.keySet()) {
+ String value = additionalManifestEntries.get(key);
+ Object previousValue = manifest.getMainAttributes().putValue(key, value);
+ if (previousValue != null && !previousValue.equals(value)) {
+ logger.log(Level.WARNING,
+ file.getFileName() + ": " + key + " was " + previousValue + ", overridden with " + value);
+ }
+ }
try (OutputStream out = Files.newOutputStream(manifestPath)) {
manifest.write(out);
}
}
-
+ return targetBundleDir;
}
protected void processEclipseSourceJar(Path file, Path targetBase) throws IOException {
}
if (urlBases == null)
try {
- return download(uri, dir, null);
+ return download(new URL(uri), dir, null);
} catch (FileNotFoundException e) {
throw new FileNotFoundException("Cannot find " + uri);
}
// try to download
for (String urlBase : urlBases) {
String relativePath = uri.substring(uriPrefix.length());
- String url = urlBase + relativePath;
+ URL url = new URL(urlBase + relativePath);
try {
return download(url, dir, null);
} catch (FileNotFoundException e) {
//
// }
- public Path download(String url, Path dir, String name) throws IOException {
+ protected Path download(URL url, Path dir, String name) throws IOException {
Path dest;
- URL u = new URL(url);
if (name == null) {
- name = u.getPath().substring(u.getPath().lastIndexOf('/') + 1);
+ name = url.getPath().substring(url.getPath().lastIndexOf('/') + 1);
}
dest = dir.resolve(name);
if (Files.exists(dest)) {
- logger.log(Level.DEBUG, () -> "File " + dest + " already exists for " + url + ", not downloading again.");
+ logger.log(Level.TRACE, () -> "File " + dest + " already exists for " + url + ", not downloading again");
return dest;
}
- try (InputStream in = u.openStream()) {
+ try (InputStream in = url.openStream()) {
Files.copy(in, dest);
+ logger.log(Level.DEBUG, () -> "Downloaded " + dest + " from " + url);
}
return dest;
}
public static void main(String[] args) {
- Path originBase = Paths.get("../output/origin").toAbsolutePath();
- Path factoryBase = Paths.get("../output/a2").toAbsolutePath();
+ Path originBase = Paths.get("../output/origin").toAbsolutePath().normalize();
+ Path factoryBase = Paths.get("../output/a2").toAbsolutePath().normalize();
A2Factory factory = new A2Factory(originBase, factoryBase);
- Path descriptorsBase = Paths.get("../tp").toAbsolutePath();
+ Path descriptorsBase = Paths.get("../tp").toAbsolutePath().normalize();
+
+// factory.processEclipseArchive(
+// descriptorsBase.resolve("org.argeo.tp.eclipse.equinox").resolve("eclipse-equinox"));
+// factory.processEclipseArchive(descriptorsBase.resolve("org.argeo.tp.eclipse.rap").resolve("eclipse-rap"));
+// factory.processEclipseArchive(descriptorsBase.resolve("org.argeo.tp.eclipse.rcp").resolve("eclipse-rcp"));
- factory.processEclipseArchive(
- descriptorsBase.resolve("org.argeo.tp.eclipse.equinox").resolve("eclipse-equinox"));
- factory.processEclipseArchive(descriptorsBase.resolve("org.argeo.tp.eclipse.rap").resolve("eclipse-rap"));
- factory.processEclipseArchive(descriptorsBase.resolve("org.argeo.tp.eclipse.rcp").resolve("eclipse-rcp"));
+ factory.processM2BasedDistributionUnit(descriptorsBase.resolve("org.argeo.tp").resolve("jetty"));
}
}
package org.argeo.slc.build.m2;
import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
import java.util.Set;
/**
* based).
*/
public class MavenConventionsUtils {
+ public final static String MAVEN_CENTRAL_BASE_URL = "https://repo1.maven.org/maven2/";
+
/**
- * Path to the file identified by this artifact <b>without</b> using Maven
- * APIs (convention based). Default location of repository
- * (~/.m2/repository) is used here.
+ * Path to the file identified by this artifact <b>without</b> using Maven APIs
+ * (convention based). Default location of repository (~/.m2/repository) is used
+ * here.
*
* @see MavenConventionsUtils#artifactToFile(String, Artifact)
*/
}
/**
- * Path to the file identified by this artifact <b>without</b> using Maven
- * APIs (convention based).
+ * Path to the file identified by this artifact <b>without</b> using Maven APIs
+ * (convention based).
*
- * @param repositoryPath
- * path to the related local repository location
- * @param artifact
- * the artifact
+ * @param repositoryPath path to the related local repository location
+ * @param artifact the artifact
*/
public static File artifactToFile(String repositoryPath, Artifact artifact) {
return new File(repositoryPath + File.separator + artifact.getGroupId().replace('.', File.separatorChar)
return repoUrl + artifactPath("/", artifact);
}
+ /** Absolute path to the file */
+ public static URL mavenCentralUrl(Artifact artifact) {
+ String url = artifactUrl(MAVEN_CENTRAL_BASE_URL, artifact);
+ try {
+ return new URL(url);
+ } catch (MalformedURLException e) {
+ // it should not happen
+ throw new IllegalStateException(e);
+ }
+ }
+
/** Absolute path to the directories where the files will be stored */
public static String artifactParentPath(String artifactBasePath, Artifact artifact) {
return artifactBasePath + (artifactBasePath.endsWith("/") ? "" : "/") + artifactParentPath(artifact);
return p.toString();
}
-// /**
-// * Directly parses Maven POM XML format in order to find all artifacts
-// * references under the dependency and dependencyManagement tags. This is
-// * meant to migrate existing pom registering a lot of artifacts, not to
-// * replace Maven resolving.
-// */
-// public static void gatherPomDependencies(AetherTemplate aetherTemplate, Set<Artifact> artifacts,
-// Artifact pomArtifact) {
-// if (log.isDebugEnabled())
-// log.debug("Gather dependencies for " + pomArtifact);
-//
-// try {
-// File file = aetherTemplate.getResolvedFile(pomArtifact);
-// DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
-// Document doc = documentBuilder.parse(file);
-//
-// // properties
-// Properties props = new Properties();
-// props.setProperty("project.version", pomArtifact.getBaseVersion());
-// NodeList properties = doc.getElementsByTagName("properties");
-// if (properties.getLength() > 0) {
-// NodeList propertiesElems = properties.item(0).getChildNodes();
-// for (int i = 0; i < propertiesElems.getLength(); i++) {
-// if (propertiesElems.item(i) instanceof Element) {
-// Element property = (Element) propertiesElems.item(i);
-// props.put(property.getNodeName(), property.getTextContent());
-// }
-// }
-// }
-//
-// // dependencies (direct and dependencyManagement)
-// NodeList dependencies = doc.getElementsByTagName("dependency");
-// for (int i = 0; i < dependencies.getLength(); i++) {
-// Element dependency = (Element) dependencies.item(i);
-// String groupId = dependency.getElementsByTagName("groupId").item(0).getTextContent().trim();
-// String artifactId = dependency.getElementsByTagName("artifactId").item(0).getTextContent().trim();
-// String version = dependency.getElementsByTagName("version").item(0).getTextContent().trim();
-// if (version.startsWith("${")) {
-// String versionKey = version.substring(0, version.length() - 1).substring(2);
-// if (!props.containsKey(versionKey))
-// throw new SlcException("Cannot interpret version " + version);
-// version = props.getProperty(versionKey);
-// }
-// NodeList scopes = dependency.getElementsByTagName("scope");
-// if (scopes.getLength() > 0 && scopes.item(0).getTextContent().equals("import")) {
-// // recurse
-// gatherPomDependencies(aetherTemplate, artifacts,
-// new DefaultArtifact(groupId, artifactId, "pom", version));
-// } else {
-// // TODO: deal with scope?
-// // TODO: deal with type
-// String type = "jar";
-// Artifact artifact = new DefaultArtifact(groupId, artifactId, type, version);
-// artifacts.add(artifact);
-// }
-// }
-// } catch (Exception e) {
-// throw new SlcException("Cannot process " + pomArtifact, e);
-// }
-// }
-
- /** Prevent instantiation */
+ /** Singleton */
private MavenConventionsUtils() {
}
}
projects / gpl / argeo-slc.git / commitdiff