/*
* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 6887710
* @summary Verify the impact of sun.misc.JarIndex.metaInfFilenames on ServiceLoader
* @modules jdk.jartool/sun.tools.jar
* jdk.httpserver
* jdk.compiler
* jdk.zipfs
* @run main/othervm Basic
*/
import java.io.IOException;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Arrays;
import java.util.Iterator;
import java.util.ServiceLoader;
import com.sun.net.httpserver.Headers;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
/**
* Verifies the impact of sun.misc.JarIndex.metaInfFilenames on ServiceLoader
* and on finding resources via Class.getResource.
*
* 1) Compile the test sources:
* jarA:
* META-INF/services/my.happy.land
* com/message/spi/MessageService.java
* a/A.java
* jarB:
* META-INF/JAVA2.DS
* META-INF/services/no.name.service
* b/B.java
* jarC:
* META-INF/fonts.mf
* META-INF/fonts/Company-corporate.ttf
* META-INF/fonts/kidpr.ttf
* META-INF/services/com.message.spi.MessageService
* my/impl/StandardMessageService.java
*
* 2) Build three jar files a.jar, b.jar, c.jar
*
* 3) Create an index in a.jar (jar -i a.jar b.jar c.jar)
* with sun.misc.JarIndex.metaInfFilenames=true
*
* 4) Start a HTTP server serving out the three jars.
*
* The test then tries to locate services/resources within the jars using
* URLClassLoader. Each request to the HTTP server is recorded to ensure
* only the correct amount of requests are being made.
*
*/
public class Basic {
static final String slash = File.separator;
static final String[] testSources = {
"jarA" + slash + "a" + slash + "A.java",
"jarA" + slash + "com" + slash + "message" + slash + "spi" + slash + "MessageService.java",
"jarB" + slash + "b" + slash + "B.java",
"jarC" + slash + "my" + slash + "impl" + slash + "StandardMessageService.java"};
static final String testSrc = System.getProperty("test.src");
static final String testSrcDir = testSrc != null ? testSrc : ".";
static final String testClasses = System.getProperty("test.classes");
static final String testClassesDir = testClasses != null ? testClasses : ".";
static JarHttpServer httpServer;
public static void main(String[] args) throws Exception {
// Set global url cache to false so that we can track every jar request.
(new URL("http://localhost/")).openConnection().setDefaultUseCaches(false);
buildTest();
try {
httpServer = new JarHttpServer(testClassesDir);
httpServer.start();
doTest(httpServer.getAddress());
} catch (IOException ioe) {
ioe.printStackTrace();
} finally {
if (httpServer != null) { httpServer.stop(2); }
}
}
static void buildTest() {
/* compile the source that will be used to generate the jars */
for (int i=0; i<testSources.length; i++)
testSources[i] = testSrcDir + slash + testSources[i];
compile("-d" , testClassesDir,
"-sourcepath", testSrcDir,
testSources[0], testSources[1], testSources[2], testSources[3]);
/* build the 3 jar files */
jar("-cf", testClassesDir + slash + "a.jar",
"-C", testClassesDir, "a",
"-C", testClassesDir, "com",
"-C", testSrcDir + slash + "jarA", "META-INF");
jar("-cf", testClassesDir + slash + "b.jar",
"-C", testClassesDir, "b",
"-C", testSrcDir + slash + "jarB", "META-INF");
jar("-cf", testClassesDir + slash + "c.jar",
"-C", testClassesDir, "my",
"-C", testSrcDir + slash + "jarC", "META-INF");
/* Create an index in a.jar for b.jar and c.jar */
createIndex(testClassesDir);
}
/* run jar <args> */
static void jar(String... args) {
debug("Running: jar " + Arrays.toString(args));
sun.tools.jar.Main jar = new sun.tools.jar.Main(System.out, System.err, "jar");
if (!jar.run(args)) {
throw new RuntimeException("jar failed: args=" + Arrays.toString(args));
}
}
/* run javac <args> */
static void compile(String... args) {
debug("Running: javac " + Arrays.toString(args));
if (com.sun.tools.javac.Main.compile(args) != 0) {
throw new RuntimeException("javac failed: args=" + Arrays.toString(args));
}
}
static String jar;
static {
jar = System.getProperty("java.home") + slash+ "bin" + slash + "jar";
}
/* create the index */
static void createIndex(String workingDir) {
// ProcessBuilder is used so that the current directory can be set
// to the directory that directly contains the jars.
debug("Running jar to create the index");
ProcessBuilder pb = new ProcessBuilder(
jar, "-J-Dsun.misc.JarIndex.metaInfFilenames=true", "-i", "a.jar", "b.jar", "c.jar");
pb.directory(new File(workingDir));
//pd.inheritIO();
try {
Process p = pb.start();
if(p.waitFor() != 0)
throw new RuntimeException("jar indexing failed");
if(debug && p != null) {
String line = null;
BufferedReader reader =
new BufferedReader(new InputStreamReader(p.getInputStream()));
while((line = reader.readLine()) != null)
debug(line);
reader = new BufferedReader(new InputStreamReader(p.getErrorStream()));
while((line = reader.readLine()) != null)
debug(line);
}
} catch(InterruptedException ie) { throw new RuntimeException(ie);
} catch(IOException e) { throw new RuntimeException(e); }
}
static final boolean debug = true;
static void debug(Object message) { if (debug) System.out.println(message); }
/* service define in c.jar */
static final String messageService = "com.message.spi.MessageService";
/* a service that is not defined in any of the jars */
static final String unknownService = "java.lang.Object";
static void doTest(InetSocketAddress serverAddress) throws IOException {
URL baseURL = new URL("http://localhost:" + serverAddress.getPort() + "/");
int failed = 0;
// Tests using java.util.SerivceLoader
if (!javaUtilServiceLoaderTest(baseURL, messageService, true, false, true)) {
System.out.println("Test: ServiceLoader looking for " + messageService + ", failed");
failed++;
}
if (!javaUtilServiceLoaderTest(baseURL, unknownService, false, false, false)) {
System.out.println("Test: ServiceLoader looking for " + unknownService + " failed");
failed++;
}
// Tests using java.lang.Class (similar to the FontManager in javafx)
if (!klassLoader(baseURL, "/META-INF/fonts.mf", true, false, true)) {
System.out.println("Test: klassLoader looking for /META-INF/fonts.mf failed");
failed++;
}
if (!klassLoader(baseURL, "/META-INF/unknown.mf", false, false, false)) {
System.out.println("Test: klassLoader looking for /META-INF/unknown.mf failed");
failed++;
}
if (failed > 0)
throw new RuntimeException("Failed: " + failed + " tests");
}
static boolean javaUtilServiceLoaderTest(URL baseURL,
String serviceClass,
boolean expectToFind,
boolean expectbDotJar,
boolean expectcDotJar) throws IOException {
debug("----------------------------------");
debug("Running test with java.util.ServiceLoader looking for " + serviceClass);
URLClassLoader loader = getLoader(baseURL);
httpServer.reset();
Class<?> messageServiceClass = null;
try {
messageServiceClass = loader.loadClass(serviceClass);
} catch (ClassNotFoundException cnfe) {
System.err.println(cnfe);
throw new RuntimeException("Error in test: " + cnfe);
}
Iterator<?> iterator = (ServiceLoader.load(messageServiceClass, loader)).iterator();
if (expectToFind && !iterator.hasNext()) {
debug(messageServiceClass + " NOT found.");
return false;
}
while (iterator.hasNext()) {
debug("found " + iterator.next() + " " + messageService);
}
debug("HttpServer: " + httpServer);
if (!expectbDotJar && httpServer.bDotJar > 0) {
debug("Unexpeced request sent to the httpserver for b.jar");
return false;
}
if (!expectcDotJar && httpServer.cDotJar > 0) {
debug("Unexpeced request sent to the httpserver for c.jar");
return false;
}
return true;
}
/* Tries to find a resource in a similar way to the font manager in javafx
* com.sun.javafx.scene.text.FontManager */
static boolean klassLoader(URL baseURL,
String resource,
boolean expectToFind,
boolean expectbDotJar,
boolean expectcDotJar) throws IOException {
debug("----------------------------------");
debug("Running test looking for " + resource);
URLClassLoader loader = getLoader(baseURL);
httpServer.reset();
Class<?> ADotAKlass = null;
try {
ADotAKlass = loader.loadClass("a.A");
} catch (ClassNotFoundException cnfe) {
System.err.println(cnfe);
throw new RuntimeException("Error in test: " + cnfe);
}
URL u = ADotAKlass.getResource(resource);
if (expectToFind && u == null) {
System.out.println("Expected to find " + resource + " but didn't");
return false;
}
debug("HttpServer: " + httpServer);
if (!expectbDotJar && httpServer.bDotJar > 0) {
debug("Unexpeced request sent to the httpserver for b.jar");
return false;
}
if (!expectcDotJar && httpServer.cDotJar > 0) {
debug("Unexpeced request sent to the httpserver for c.jar");
return false;
}
return true;
}
static URLClassLoader getLoader(URL baseURL) throws IOException {
ClassLoader loader = Basic.class.getClassLoader();
while (loader.getParent() != null)
loader = loader.getParent();
return new URLClassLoader( new URL[]{
new URL(baseURL, "a.jar"),
new URL(baseURL, "b.jar"),
new URL(baseURL, "c.jar")}, loader );
}
/**
* HTTP Server to server the jar files.
*/
static class JarHttpServer implements HttpHandler {
final String docsDir;
final HttpServer httpServer;
int aDotJar, bDotJar, cDotJar;
JarHttpServer(String docsDir) throws IOException {
this.docsDir = docsDir;
httpServer = HttpServer.create(new InetSocketAddress(0), 0);
httpServer.createContext("/", this);
}
void start() throws IOException {
httpServer.start();
}
void stop(int delay) {
httpServer.stop(delay);
}
InetSocketAddress getAddress() {
return httpServer.getAddress();
}
void reset() {
aDotJar = bDotJar = cDotJar = 0;
}
@Override
public String toString() {
return "aDotJar=" + aDotJar + ", bDotJar=" + bDotJar + ", cDotJar=" + cDotJar;
}
public void handle(HttpExchange t) throws IOException {
InputStream is = t.getRequestBody();
Headers map = t.getRequestHeaders();
Headers rmap = t.getResponseHeaders();
URI uri = t.getRequestURI();
debug("Server: received request for " + uri);
String path = uri.getPath();
if (path.endsWith("a.jar"))
aDotJar++;
else if (path.endsWith("b.jar"))
bDotJar++;
else if (path.endsWith("c.jar"))
cDotJar++;
else
System.out.println("Unexpected resource request" + path);
while (is.read() != -1);
is.close();
File file = new File(docsDir, path);
if (!file.exists())
throw new RuntimeException("Error: request for " + file);
long clen = file.length();
t.sendResponseHeaders (200, clen);
OutputStream os = t.getResponseBody();
FileInputStream fis = new FileInputStream(file);
try {
byte[] buf = new byte [16 * 1024];
int len;
while ((len=fis.read(buf)) != -1) {
os.write (buf, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
fis.close();
os.close();
}
}
}