Overriding the built-in Java HTTPServer under OSGi

2010-09-21T11:09:00.018-04:00

I've been using Java SE 6's 'containerless' javax.xml.ws.Endpoint
for some time now to build complete end-to-end JAX-WS testcases.

For example, a simple 'Provider' needs only a few Web Services annotations:


package test;
...
import javax.xml.soap.SOAPMessage;
import javax.xml.ws.Provider;
import javax.xml.ws.WebServiceProvider;
import javax.xml.ws.Service;
import javax.xml.ws.ServiceMode;
import static javax.xml.ws.Service.Mode.MESSAGE;
import static javax.xml.ws.soap.SOAPBinding.SOAP11HTTP_BINDING;

@WebServiceProvider(
 targetNamespace = "urn:testService",
 serviceName = "testService",
 portName = "testServicePort"
)
@ServiceMode(MESSAGE)
public class TestProvider implements Provider<SOAPMessage> {
...
  public SOAPMessage invoke(SOAPMessage request) {
      ... parse SOAPMessage request
      ... return SOAPMessage response
  }
...

EclipseLink DBWS can be used to parse the incoming SOAPMessage as well as generate the response.

JUnit annotations can be mixed-in along with the Web Services annotations:


  static final String ENDPOINT_ADDRESS =  "http://localhost:9999/test";

  //JUnit4 fixtures
  static Service testService = null;

  @BeforeClass
  public static void setup() throws Exception {
      Endpoint endpoint = Endpoint.create(new TestProvider());
      endpoint.publish(ENDPOINT_ADDRESS);
      WebServiceProvider testProvider =
          TestProvider.class.getAnnotation(WebServiceProvider.class);
      String serviceNamespace = testProvider.targetNamespace();
      String serviceName = testProvider.serviceName();
      String portName = testProvider.portName();
      QName serviceQName = new QName(serviceNamespace, serviceName);
      QName portQName = new QName(serviceNamespace, portName);
      Service testService = Service.create(serviceQName);
      testService.addPort(portQName, SOAP11HTTP_BINDING, ENDPOINT_ADDRESS);
  }

  @Test
  public void aTest() throws Exception {
      MessageFactory factory = MessageFactory.newInstance();
      SOAPMessage request = factory.createMessage();
      SOAPPart part = request.getSOAPPart();
      DOMSource domSource = new DOMSource(
          getDocumentBuilder().parse(new InputSource(new StringReader(
          "<SOAP-ENV:Envelope ... SOAP message content ...</SOAP-ENV:Envelope>"))));
      part.setContent(domSource);
      Dispatch<SOAPMessage> dispatch = testService.createDispatch(portQName, SOAPMessage.class,
          Service.Mode.MESSAGE);
      SOAPMessage response = dispatch.invoke(request);
      ...
  }

I find it very convenient to have server, client and tests all in a single class.

Behind-the-scenes, the javax.xml.ws.Service is backed by an internal class
com.sun.net.httpserver.HttpServer. Unfortunately, this class has some
issues (6675392, 6946825) that make it not my first choice for production work.

Wouldn't it be great if the simple and easy up-front API could be maintained
while behind-the-scenes the Server implementation could be swapped-out?

The answer of course is that you can! There is a SPI to override the Server
implementation, either via a 'services' file
META-INF/services/com.sun.net.httpserver.HttpServerProvider
or via a system property:

-Dcom.sun.net.httpserver.HttpServerProvider=org.eclipse.jetty.jaxws2spi.JettyHttpServerProvider

(the example above replaces the built-in HTTPServer with Jetty)

I've been helping a customer use EclipseLink DBWS under OSGi and discovered an issue with the above SPI. The implementation of the SPI class com.sun.net.httpserver.spi.HttpServerProvider only looks on the System classpath:


private static boolean loadProviderFromProperty() {
  String cn = System.getProperty("com.sun.net.httpserver.HttpServerProvider");
  if (cn == null)
      return false;
  try {
      Class c = Class.forName(cn, true, ClassLoader.getSystemClassLoader());
      provider = (HttpServerProvider)c.newInstance();
      return true;
  }
  ....

This will not work when running under OSGi as the System classpath cannot
find any user classes (only BundleClassLoaders can).
/*

 * Copyright 2005 Sun Microsystems, Inc.  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.  Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/

package com.sun.net.httpserver.spi;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Iterator;

import sun.misc.Service;
import sun.misc.ServiceConfigurationError;

import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpsServer;

/**
* Service provider class for HttpServer.
* Sub-classes of HttpServerProvider provide an implementation of {@link HttpServer} and
* associated classes. Applications do not normally use this class.
* See {@link #provider()} for how providers are found and loaded.
*/
@SuppressWarnings("restriction")
public abstract class HttpServerProvider {

  /**
   * creates a HttpServer from this provider
   * @param addr the address to bind to. May be <code>null</code>
   * @param backlog the socket backlog. A value of <code>zero</code> means the systems default
   */
  public abstract HttpServer createHttpServer (InetSocketAddress addr, int backlog) throws IOException;

  /**
   * creates a HttpsServer from this provider
   * @param addr the address to bind to. May be <code>null</code>
   * @param backlog the socket backlog. A value of <code>zero</code> means the systems default
   */
  public abstract HttpsServer createHttpsServer (InetSocketAddress addr, int backlog) throws IOException;



  private static final Object lock = new Object();
  private static HttpServerProvider provider = null;

  /**
   * Initializes a new instance of this class.  </p>
   *
   * @throws  SecurityException
   *          If a security manager has been installed and it denies
   *          {@link RuntimePermission}<tt>("httpServerProvider")</tt>
   */
  protected HttpServerProvider() {
      SecurityManager sm = System.getSecurityManager();
      if (sm != null)
          sm.checkPermission(new RuntimePermission("httpServerProvider"));
  }

  private static boolean loadProviderFromProperty() {
      String cn = System.getProperty("com.sun.net.httpserver.HttpServerProvider");
      if (cn == null)
          return false;
      try {
          ClassLoader cl = Thread.currentThread().getContextClassLoader();
          if (cl == null) {
              cl = ClassLoader.getSystemClassLoader();
          }
          Class<?> c = Class.forName(cn, true, cl);
          provider = (HttpServerProvider)c.newInstance();
          return true;
      } catch (ClassNotFoundException x) {
          throw new ServiceConfigurationError(x);
      } catch (IllegalAccessException x) {
          throw new ServiceConfigurationError(x);
      } catch (InstantiationException x) {
          throw new ServiceConfigurationError(x);
      } catch (SecurityException x) {
          throw new ServiceConfigurationError(x);
      }
  }

  private static boolean loadProviderAsService() {
      ClassLoader cl = Thread.currentThread().getContextClassLoader();
      if (cl == null) {
          cl = ClassLoader.getSystemClassLoader();
      }
      Iterator<?> i = Service.providers(HttpServerProvider.class, cl);
      for (;;) {
          try {
              if (!i.hasNext())
                  return false;
              provider = (HttpServerProvider)i.next();
              return true;
          } catch (ServiceConfigurationError sce) {
              if (sce.getCause() instanceof SecurityException) {
                  // Ignore the security exception, try the next provider
                  continue;
              }
              throw sce;
          }
      }
  }

  /**
   * Returns the system wide default HttpServerProvider for this invocation of
   * the Java virtual machine.
   *
   * <p> The first invocation of this method locates the default provider
   * object as follows: </p>
   *
   * <ol>
   *
   *   <li><p> If the system property
   *   <tt>com.sun.net.httpserver.HttpServerProvider</tt> is defined then it is
   *   taken to be the fully-qualified name of a concrete provider class.
   *   The class is loaded and instantiated; if this process fails then an
   *   unspecified unchecked error or exception is thrown.  </p></li>
   *
   *   <li><p> If a provider class has been installed in a jar file that is
   *   visible to the system class loader, and that jar file contains a
   *   provider-configuration file named
   *   <tt>com.sun.net.httpserver.HttpServerProvider</tt> in the resource
   *   directory <tt>META-INF/services</tt>, then the first class name
   *   specified in that file is taken.  The class is loaded and
   *   instantiated; if this process fails then an unspecified unchecked error or exception is
   *   thrown.  </p></li>
   *
   *   <li><p> Finally, if no provider has been specified by any of the above
   *   means then the system-default provider class is instantiated and the
   *   result is returned.  </p></li>
   *
   * </ol>
   *
   * <p> Subsequent invocations of this method return the provider that was
   * returned by the first invocation.  </p>
   *
   * @return  The system-wide default HttpServerProvider
   */
  public static HttpServerProvider provider () {
      synchronized (lock) {
          if (provider != null)
              return provider;
          return (HttpServerProvider)AccessController
              .doPrivileged(new PrivilegedAction<Object>() {
                      public Object run() {
                          if (loadProviderFromProperty())
                              return provider;
                          if (loadProviderAsService())
                              return provider;
                          provider = new sun.net.httpserver.DefaultHttpServerProvider();
                          return provider;
                      }
                  });
      }
  }

}

I have opened a bug against OpenJDK, but until this issue is addressed, the
built-in HttpServerProvider needs to be overridden. The replacement code
is packaged into a jar file (e.g. http_server_spi.jar) and pre-pended to the bootclassloader so as to override the built-in version:


-Xbootclasspath/p:/path/to/http_server_spi.jar
            ^^^^ /p means pre-pend

The 'foo' in 'foobar'

Overriding the built-in Java HTTPServer under OSGi