modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyServer.java - tuscany-sca-2.x - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.apache.tuscany.sca.http.jetty;

 import java.net.InetAddress;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URL;
 import java.net.UnknownHostException;
 import java.security.AccessController;
 import java.security.KeyStore;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.Map.Entry;
 import java.util.logging.Logger;

 import javax.servlet.RequestDispatcher;
 import javax.servlet.Servlet;
 import javax.servlet.ServletException;

 import org.apache.tuscany.sca.core.ExtensionPointRegistry;
 import org.apache.tuscany.sca.core.LifeCycleListener;
 import org.apache.tuscany.sca.core.UtilityExtensionPoint;
 import org.apache.tuscany.sca.host.http.DefaultResourceServlet;
 import org.apache.tuscany.sca.host.http.SecurityContext;
 import org.apache.tuscany.sca.host.http.ServletHost;
 import org.apache.tuscany.sca.host.http.ServletMappingException;
 import org.apache.tuscany.sca.work.WorkScheduler;
 import org.mortbay.jetty.Connector;
 import org.mortbay.jetty.Server;
 import org.mortbay.jetty.handler.ContextHandler;
 import org.mortbay.jetty.nio.SelectChannelConnector;
 import org.mortbay.jetty.security.SslSocketConnector;
 import org.mortbay.jetty.servlet.DefaultServlet;
 import org.mortbay.jetty.servlet.ServletHandler;
 import org.mortbay.jetty.servlet.ServletHolder;
 import org.mortbay.jetty.servlet.ServletMapping;
 import org.mortbay.jetty.servlet.SessionHandler;
 import org.mortbay.log.Log;
 import org.mortbay.thread.ThreadPool;

 /**
  * Implements an HTTP transport service using Jetty.
  *
  * @version $Rev$ $Date$
  */
 public class JettyServer implements ServletHost, LifeCycleListener {
     private static final Logger logger = Logger.getLogger(JettyServer.class.getName());

     private final Object joinLock = new Object();
     private String trustStore;
     private String trustStorePassword;
     private String keyStore;
     private String keyStorePassword;

     private String keyStoreType;
     private String trustStoreType;

     private boolean sendServerVersion;
     private WorkScheduler workScheduler;

     // TODO - this static seems to be set by the JSORPC binding unit test
     //        doesn't look to be a great way of doing things
     public static int portDefault = 8080;
     private int defaultPort = portDefault;
     private int defaultSSLPort = 8443;

     /**
      * Represents a port and the server that serves it.
      */
     private class Port {
         private Server server;
         private ServletHandler servletHandler;

         private Port(Server server, ServletHandler servletHandler) {
             this.server = server;
             this.servletHandler = servletHandler;
         }

         public Server getServer() {
             return server;
         }

         public ServletHandler getServletHandler() {
             return servletHandler;
         }
     }

     private Map<Integer, Port> ports = new HashMap<Integer, Port>();

     private String contextPath = "/";
     private org.mortbay.log.Logger jettyLogger;

     public JettyServer(ExtensionPointRegistry registry) {
         this(registry.getExtensionPoint(UtilityExtensionPoint.class).getUtility(WorkScheduler.class));
     }

     protected JettyServer(WorkScheduler workScheduler) {
         this.defaultPort = portDefault;
         this.workScheduler = workScheduler;
         AccessController.doPrivileged(new PrivilegedAction<Object>() {
             public Object run() {
                 trustStore = System.getProperty("javax.net.ssl.trustStore");
                 trustStorePassword = System.getProperty("javax.net.ssl.trustStorePassword");
                 keyStore = System.getProperty("javax.net.ssl.keyStore");
                 keyStorePassword = System.getProperty("javax.net.ssl.keyStorePassword");

                 keyStoreType = System.getProperty("javax.net.ssl.keyStoreType", KeyStore.getDefaultType());
                 trustStoreType = System.getProperty("javax.net.ssl.trustStoreType", KeyStore.getDefaultType());

                 System.setProperty("JETTY_NO_SHUTDOWN_HOOK", "true");
                 return null;
             }
         });
     }

     public String getName() {
         return "jetty";
     }

     public void setDefaultPort(int port) {
         defaultPort = port;
     }

     public int getDefaultPort() {
         return defaultPort;
     }

     public void setSendServerVersion(boolean sendServerVersion) {
         this.sendServerVersion = sendServerVersion;
     }

     /**
      * Stop all the started servers.
      */
     public void stop() {
         synchronized (joinLock) {
             joinLock.notifyAll();
         }
         try {
             Set<Entry<Integer, Port>> entries = new HashSet<Entry<Integer, Port>>(ports.entrySet());
             for (Entry<Integer, Port> entry : entries) {
                 Port port = entry.getValue();
                 Server server = port.getServer();
                 server.stop();
                 server.setStopAtShutdown(false);
                 ports.remove(entry.getKey());
             }
         } catch (Exception e) {
             throw new ServletMappingException(e);
         } finally {
             if (jettyLogger != null) {
                 Log.setLog(jettyLogger);
                 jettyLogger = null;
             }
         }
     }

     private void configureSSL(SslSocketConnector connector, SecurityContext securityContext) {
         connector.setProtocol("TLS");
         if (securityContext != null) {
             keyStoreType = securityContext.getSSLProperties().getProperty("javax.net.ssl.keyStoreType", KeyStore.getDefaultType());
             keyStore = securityContext.getSSLProperties().getProperty("javax.net.ssl.keyStore");
             keyStorePassword = securityContext.getSSLProperties().getProperty("javax.net.ssl.keyStorePassword");

             trustStoreType = securityContext.getSSLProperties().getProperty("javax.net.ssl.trustStoreType", KeyStore.getDefaultType());
             trustStore = securityContext.getSSLProperties().getProperty("javax.net.ssl.trustStore");
             trustStorePassword = securityContext.getSSLProperties().getProperty("javax.net.ssl.trustStorePassword");
         }
         connector.setKeystore(keyStore);
         connector.setKeyPassword(keyStorePassword);
         connector.setKeystoreType(keyStoreType);

         connector.setTruststore(trustStore);
         connector.setTrustPassword(trustStorePassword);
         connector.setTruststoreType(trustStoreType);

         connector.setPassword(keyStorePassword);
         if (trustStore != null) {
             connector.setNeedClientAuth(true);
         }

     }

     public String addServletMapping(String suri, Servlet servlet) throws ServletMappingException {
         return addServletMapping(suri, servlet, null);
     }

     public String addServletMapping(String suri, Servlet servlet, final SecurityContext securityContext) throws ServletMappingException {
         URI uri = URI.create(suri);

         // Get the URI scheme and port
         String scheme = null;
         if(securityContext != null && securityContext.isSSLEnabled()) {
             scheme = "https";
         } else {
             scheme = uri.getScheme();
             if (scheme == null) {
                 scheme = "http";
             }
         }

         String host = uri.getHost();
         if ("0.0.0.0".equals(host)) {
             host = null;
         }

         int portNumber = uri.getPort();
         if (portNumber == -1) {
             if ("http".equals(scheme)) {
                 portNumber = defaultPort;
             } else {
                 portNumber = defaultSSLPort;
             }
         }

         // Get the port object associated with the given port number
         Port port = ports.get(portNumber);
         if (port == null) {

             // Create and start a new server
             try {
                 Server server = new Server();
                 server.setThreadPool(new WorkSchedulerThreadPool());
                 if ("https".equals(scheme)) {
                     //                    Connector httpConnector = new SelectChannelConnector();
                     //                    httpConnector.setPort(portNumber);
                     SslSocketConnector sslConnector = new SslSocketConnector();
                     sslConnector.setPort(portNumber);
                     // FIXME: [rfeng] We should set the host to be bound but binding-ws-axis2 is passing
                     // in an absolute URI with host set to one of the ip addresses
                     sslConnector.setHost(host);
                     configureSSL(sslConnector, securityContext);
                     server.setConnectors(new Connector[] {sslConnector});
                 } else {
                     SelectChannelConnector selectConnector = new SelectChannelConnector();
                     selectConnector.setPort(portNumber);
                     // FIXME: [rfeng] We should set the host to be bound but binding-ws-axis2 is passing
                     // in an absolute URI with host set to one of the ip addresses
                     selectConnector.setHost(host);
                     server.setConnectors(new Connector[] {selectConnector});
                 }

                 ContextHandler contextHandler = new ContextHandler();
                 //contextHandler.setContextPath(contextPath);
                 contextHandler.setContextPath("/");
                 server.setHandler(contextHandler);

                 SessionHandler sessionHandler = new SessionHandler();
                 ServletHandler servletHandler = new ServletHandler();
                 sessionHandler.addHandler(servletHandler);

                 contextHandler.setHandler(sessionHandler);

                 server.setStopAtShutdown(true);
                 server.setSendServerVersion(sendServerVersion);
                 server.start();

                 // Keep track of the new server and Servlet handler
                 port = new Port(server, servletHandler);
                 ports.put(portNumber, port);

             } catch (Exception e) {
                 throw new ServletMappingException(e);
             }
         }

         // Register the Servlet mapping
         ServletHandler servletHandler = port.getServletHandler();
         ServletHolder holder;
         if (servlet instanceof DefaultResourceServlet) {

             // Optimize the handling of resource requests, use the Jetty default Servlet
             // instead of our default resource Servlet
             String servletPath = uri.getPath();
             if (servletPath.endsWith("*")) {
                 servletPath = servletPath.substring(0, servletPath.length() - 1);
             }
             if (servletPath.endsWith("/")) {
                 servletPath = servletPath.substring(0, servletPath.length() - 1);
             }
             if (!servletPath.startsWith("/")) {
                 servletPath = '/' + servletPath;
             }

             DefaultResourceServlet resourceServlet = (DefaultResourceServlet)servlet;
             DefaultServlet defaultServlet = new JettyDefaultServlet(servletPath, resourceServlet.getDocumentRoot());
             holder = new ServletHolder(defaultServlet);

         } else {
             holder = new ServletHolder(servlet);
         }
         servletHandler.addServlet(holder);

         ServletMapping mapping = new ServletMapping();
         mapping.setServletName(holder.getName());
         String path = uri.getPath();

         if (!path.startsWith("/")) {
             path = '/' + path;
         }

         if (!path.startsWith(contextPath)) {
             path = contextPath + path;
         }

         mapping.setPathSpec(path);
         servletHandler.addServletMapping(mapping);

         // Compute the complete URL
         if (host == null) {
             try {
                 host = InetAddress.getLocalHost().getHostAddress();
             } catch (UnknownHostException e) {
                 host = "localhost";
             }
         }
         URL addedURL;
         try {
             addedURL = new URL(scheme, host, portNumber, path);
         } catch (MalformedURLException e) {
             throw new ServletMappingException(e);
         }
         logger.info("Added Servlet mapping: " + addedURL);
         return addedURL.toString();
     }

     public URL getURLMapping(String suri, SecurityContext securityContext) throws ServletMappingException {
         return map(suri, securityContext, true);
     }

     private URL map(String suri, SecurityContext securityContext, boolean resolve) throws ServletMappingException {
         URI uri = URI.create(suri);

         // Get the URI scheme and port
         String scheme = null;
         if(securityContext != null && securityContext.isSSLEnabled()) {
             scheme = "https";
         } else {
             scheme = uri.getScheme();
             if (scheme == null) {
                 scheme = "http";
             }
         }

         int portNumber = uri.getPort();
         if (portNumber == -1) {
             if ("http".equals(scheme)) {
                 portNumber = defaultPort;
             } else {
                 portNumber = defaultSSLPort;
             }
         }

         // Get the host
         String host = uri.getHost();
         if (host == null) {
             host = "0.0.0.0";
             if (resolve) {
                 try {
                     host = InetAddress.getLocalHost().getHostAddress();
                 } catch (UnknownHostException e) {
                     host = "localhost";
                 }
             }
         }

         // Construct the URL
         String path = uri.getPath();

         if (!path.startsWith("/")) {
             path = '/' + path;
         }

         if (!path.startsWith(contextPath)) {
             path = contextPath + path;
         }

         URL url;
         try {
             url = new URL(scheme, host, portNumber, path);
         } catch (MalformedURLException e) {
             throw new ServletMappingException(e);
         }
         return url;
     }

     public Servlet getServletMapping(String suri) throws ServletMappingException {

         if (suri == null) {
             return null;
         }

         URI uri = URI.create(suri);

         // Get the URI port
         int portNumber = uri.getPort();
         if (portNumber == -1) {
             portNumber = defaultPort;
         }

         // Get the port object associated with the given port number
         Port port = ports.get(portNumber);
         if (port == null) {
             return null;
         }

         // Remove the Servlet mapping for the given Servlet
         ServletHandler servletHandler = port.getServletHandler();
         Servlet servlet = null;
         List<ServletMapping> mappings =
             new ArrayList<ServletMapping>(Arrays.asList(servletHandler.getServletMappings()));
         String path = uri.getPath();

         if (!path.startsWith("/")) {
             path = '/' + path;
         }

         if (!path.startsWith(contextPath)) {
             path = contextPath + path;
         }

         for (ServletMapping mapping : mappings) {
             if (Arrays.asList(mapping.getPathSpecs()).contains(path)) {
                 try {
                     servlet = servletHandler.getServlet(mapping.getServletName()).getServlet();
                 } catch (ServletException e) {
                     throw new IllegalStateException(e);
                 }
                 break;
             }
         }
         return servlet;
     }

     public Servlet removeServletMapping(String suri) {
         URI uri = URI.create(suri);

         // Get the URI port
         int portNumber = uri.getPort();
         if (portNumber == -1) {
             portNumber = defaultPort;
         }

         // Get the port object associated with the given port number
         Port port = ports.get(portNumber);
         if (port == null) {
             // TODO - EPR - SL commented out exception temporarily as the runtime is shared
             //              between multiple nodes in a VM and shutting down one node blows
             //              up any other nodes when they shut down.
             //throw new IllegalStateException("No servlet registered at this URI: " + suri);
             logger.warning("No servlet registered at this URI: " + suri);
             return null;
         }

         // Remove the Servlet mapping for the given Servlet
         ServletHandler servletHandler = port.getServletHandler();
         Servlet removedServlet = null;
         List<ServletMapping> mappings =
             new ArrayList<ServletMapping>(Arrays.asList(servletHandler.getServletMappings()));
         String path = uri.getPath();

         if (!path.startsWith("/")) {
             path = '/' + path;
         }

         if (!path.startsWith(contextPath)) {
             path = contextPath + path;
         }

         for (ServletMapping mapping : mappings) {
             if (Arrays.asList(mapping.getPathSpecs()).contains(path)) {
                 try {
                     removedServlet = servletHandler.getServlet(mapping.getServletName()).getServlet();
                 } catch (ServletException e) {
                     throw new IllegalStateException(e);
                 }
                 mappings.remove(mapping);
                 logger.info("Removed Servlet mapping: " + path);
                 break;
             }
         }
         if (removedServlet != null) {
             servletHandler.setServletMappings(mappings.toArray(new ServletMapping[mappings.size()]));

             // Stop the port if there are no servlet mappings on it anymore
             if (mappings.size() == 0) {
                 try {
                     Server server = port.getServer();
                     server.stop();
                     server.setStopAtShutdown(false);
                 } catch (Exception e) {
                     throw new IllegalStateException(e);
                 }
                 ports.remove(portNumber);
             }

         } else {
             logger.warning("Trying to Remove servlet mapping: " + path + " where mapping is not registered");
         }

         return removedServlet;
     }

     public RequestDispatcher getRequestDispatcher(String suri) throws ServletMappingException {
         //FIXME implement this later
         return null;
     }

     public String getContextPath() {
         return contextPath;
     }

     public void setContextPath(String path) {
         this.contextPath = path;
     }

     /**
      * A wrapper to enable use of a WorkScheduler with Jetty
      */
     private class WorkSchedulerThreadPool implements ThreadPool {

         public boolean dispatch(Runnable work) {
             workScheduler.scheduleWork(work);
             return true;
         }

         public void join() throws InterruptedException {
             synchronized (joinLock) {
                 joinLock.wait();
             }
         }

         public int getThreads() {
             throw new UnsupportedOperationException();
         }

         public int getIdleThreads() {
             throw new UnsupportedOperationException();
         }

         public boolean isLowOnThreads() {
             return false;
         }
     }

     public void setAttribute(String name, Object value) {
         throw new UnsupportedOperationException();
     }

     public void start() {
         try {
             jettyLogger = new JettyLogger(logger);
             Log.setLog(jettyLogger);
         } catch (Throwable e) {
             // Ignore
         }
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.apache.tuscany.sca.http.jetty;

	import java.net.InetAddress;
	import java.net.MalformedURLException;
	import java.net.URI;
	import java.net.URL;
	import java.net.UnknownHostException;
	import java.security.AccessController;
	import java.security.KeyStore;
	import java.security.PrivilegedAction;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.Map.Entry;
	import java.util.logging.Logger;

	import javax.servlet.RequestDispatcher;
	import javax.servlet.Servlet;
	import javax.servlet.ServletException;

	import org.apache.tuscany.sca.core.ExtensionPointRegistry;
	import org.apache.tuscany.sca.core.LifeCycleListener;
	import org.apache.tuscany.sca.core.UtilityExtensionPoint;
	import org.apache.tuscany.sca.host.http.DefaultResourceServlet;
	import org.apache.tuscany.sca.host.http.SecurityContext;
	import org.apache.tuscany.sca.host.http.ServletHost;
	import org.apache.tuscany.sca.host.http.ServletMappingException;
	import org.apache.tuscany.sca.work.WorkScheduler;
	import org.mortbay.jetty.Connector;
	import org.mortbay.jetty.Server;
	import org.mortbay.jetty.handler.ContextHandler;
	import org.mortbay.jetty.nio.SelectChannelConnector;
	import org.mortbay.jetty.security.SslSocketConnector;
	import org.mortbay.jetty.servlet.DefaultServlet;
	import org.mortbay.jetty.servlet.ServletHandler;
	import org.mortbay.jetty.servlet.ServletHolder;
	import org.mortbay.jetty.servlet.ServletMapping;
	import org.mortbay.jetty.servlet.SessionHandler;
	import org.mortbay.log.Log;
	import org.mortbay.thread.ThreadPool;

	/**
	* Implements an HTTP transport service using Jetty.
	*
	* @version $Rev$ $Date$
	*/
	public class JettyServer implements ServletHost, LifeCycleListener {
	private static final Logger logger = Logger.getLogger(JettyServer.class.getName());

	private final Object joinLock = new Object();
	private String trustStore;
	private String trustStorePassword;
	private String keyStore;
	private String keyStorePassword;

	private String keyStoreType;
	private String trustStoreType;

	private boolean sendServerVersion;
	private WorkScheduler workScheduler;

	// TODO - this static seems to be set by the JSORPC binding unit test
	// doesn't look to be a great way of doing things
	public static int portDefault = 8080;
	private int defaultPort = portDefault;
	private int defaultSSLPort = 8443;

	/**
	* Represents a port and the server that serves it.
	*/
	private class Port {
	private Server server;
	private ServletHandler servletHandler;

	private Port(Server server, ServletHandler servletHandler) {
	this.server = server;
	this.servletHandler = servletHandler;
	}

	public Server getServer() {
	return server;
	}

	public ServletHandler getServletHandler() {
	return servletHandler;
	}
	}

	private Map<Integer, Port> ports = new HashMap<Integer, Port>();

	private String contextPath = "/";
	private org.mortbay.log.Logger jettyLogger;

	public JettyServer(ExtensionPointRegistry registry) {
	this(registry.getExtensionPoint(UtilityExtensionPoint.class).getUtility(WorkScheduler.class));
	}

	protected JettyServer(WorkScheduler workScheduler) {
	this.defaultPort = portDefault;
	this.workScheduler = workScheduler;
	AccessController.doPrivileged(new PrivilegedAction<Object>() {
	public Object run() {
	trustStore = System.getProperty("javax.net.ssl.trustStore");
	trustStorePassword = System.getProperty("javax.net.ssl.trustStorePassword");
	keyStore = System.getProperty("javax.net.ssl.keyStore");
	keyStorePassword = System.getProperty("javax.net.ssl.keyStorePassword");

	keyStoreType = System.getProperty("javax.net.ssl.keyStoreType", KeyStore.getDefaultType());
	trustStoreType = System.getProperty("javax.net.ssl.trustStoreType", KeyStore.getDefaultType());

	System.setProperty("JETTY_NO_SHUTDOWN_HOOK", "true");
	return null;
	}
	});
	}

	public String getName() {
	return "jetty";
	}

	public void setDefaultPort(int port) {
	defaultPort = port;
	}

	public int getDefaultPort() {
	return defaultPort;
	}

	public void setSendServerVersion(boolean sendServerVersion) {
	this.sendServerVersion = sendServerVersion;
	}

	/**
	* Stop all the started servers.
	*/
	public void stop() {
	synchronized (joinLock) {
	joinLock.notifyAll();
	}
	try {
	Set<Entry<Integer, Port>> entries = new HashSet<Entry<Integer, Port>>(ports.entrySet());
	for (Entry<Integer, Port> entry : entries) {
	Port port = entry.getValue();
	Server server = port.getServer();
	server.stop();
	server.setStopAtShutdown(false);
	ports.remove(entry.getKey());
	}
	} catch (Exception e) {
	throw new ServletMappingException(e);
	} finally {
	if (jettyLogger != null) {
	Log.setLog(jettyLogger);
	jettyLogger = null;
	}
	}
	}

	private void configureSSL(SslSocketConnector connector, SecurityContext securityContext) {
	connector.setProtocol("TLS");
	if (securityContext != null) {
	keyStoreType = securityContext.getSSLProperties().getProperty("javax.net.ssl.keyStoreType", KeyStore.getDefaultType());
	keyStore = securityContext.getSSLProperties().getProperty("javax.net.ssl.keyStore");
	keyStorePassword = securityContext.getSSLProperties().getProperty("javax.net.ssl.keyStorePassword");

	trustStoreType = securityContext.getSSLProperties().getProperty("javax.net.ssl.trustStoreType", KeyStore.getDefaultType());
	trustStore = securityContext.getSSLProperties().getProperty("javax.net.ssl.trustStore");
	trustStorePassword = securityContext.getSSLProperties().getProperty("javax.net.ssl.trustStorePassword");
	}
	connector.setKeystore(keyStore);
	connector.setKeyPassword(keyStorePassword);
	connector.setKeystoreType(keyStoreType);

	connector.setTruststore(trustStore);
	connector.setTrustPassword(trustStorePassword);
	connector.setTruststoreType(trustStoreType);

	connector.setPassword(keyStorePassword);
	if (trustStore != null) {
	connector.setNeedClientAuth(true);
	}

	}

	public String addServletMapping(String suri, Servlet servlet) throws ServletMappingException {
	return addServletMapping(suri, servlet, null);
	}

	public String addServletMapping(String suri, Servlet servlet, final SecurityContext securityContext) throws ServletMappingException {
	URI uri = URI.create(suri);

	// Get the URI scheme and port
	String scheme = null;
	if(securityContext != null && securityContext.isSSLEnabled()) {
	scheme = "https";
	} else {
	scheme = uri.getScheme();
	if (scheme == null) {
	scheme = "http";
	}
	}

	String host = uri.getHost();
	if ("0.0.0.0".equals(host)) {
	host = null;
	}

	int portNumber = uri.getPort();
	if (portNumber == -1) {
	if ("http".equals(scheme)) {
	portNumber = defaultPort;
	} else {
	portNumber = defaultSSLPort;
	}
	}

	// Get the port object associated with the given port number
	Port port = ports.get(portNumber);
	if (port == null) {

	// Create and start a new server
	try {
	Server server = new Server();
	server.setThreadPool(new WorkSchedulerThreadPool());
	if ("https".equals(scheme)) {
	// Connector httpConnector = new SelectChannelConnector();
	// httpConnector.setPort(portNumber);
	SslSocketConnector sslConnector = new SslSocketConnector();
	sslConnector.setPort(portNumber);
	// FIXME: [rfeng] We should set the host to be bound but binding-ws-axis2 is passing
	// in an absolute URI with host set to one of the ip addresses
	sslConnector.setHost(host);
	configureSSL(sslConnector, securityContext);
	server.setConnectors(new Connector[] {sslConnector});
	} else {
	SelectChannelConnector selectConnector = new SelectChannelConnector();
	selectConnector.setPort(portNumber);
	// FIXME: [rfeng] We should set the host to be bound but binding-ws-axis2 is passing
	// in an absolute URI with host set to one of the ip addresses
	selectConnector.setHost(host);
	server.setConnectors(new Connector[] {selectConnector});
	}

	ContextHandler contextHandler = new ContextHandler();
	//contextHandler.setContextPath(contextPath);
	contextHandler.setContextPath("/");
	server.setHandler(contextHandler);

	SessionHandler sessionHandler = new SessionHandler();
	ServletHandler servletHandler = new ServletHandler();
	sessionHandler.addHandler(servletHandler);

	contextHandler.setHandler(sessionHandler);

	server.setStopAtShutdown(true);
	server.setSendServerVersion(sendServerVersion);
	server.start();

	// Keep track of the new server and Servlet handler
	port = new Port(server, servletHandler);
	ports.put(portNumber, port);

	} catch (Exception e) {
	throw new ServletMappingException(e);
	}
	}

	// Register the Servlet mapping
	ServletHandler servletHandler = port.getServletHandler();
	ServletHolder holder;
	if (servlet instanceof DefaultResourceServlet) {

	// Optimize the handling of resource requests, use the Jetty default Servlet
	// instead of our default resource Servlet
	String servletPath = uri.getPath();
	if (servletPath.endsWith("*")) {
	servletPath = servletPath.substring(0, servletPath.length() - 1);
	}
	if (servletPath.endsWith("/")) {
	servletPath = servletPath.substring(0, servletPath.length() - 1);
	}
	if (!servletPath.startsWith("/")) {
	servletPath = '/' + servletPath;
	}

	DefaultResourceServlet resourceServlet = (DefaultResourceServlet)servlet;
	DefaultServlet defaultServlet = new JettyDefaultServlet(servletPath, resourceServlet.getDocumentRoot());
	holder = new ServletHolder(defaultServlet);

	} else {
	holder = new ServletHolder(servlet);
	}
	servletHandler.addServlet(holder);

	ServletMapping mapping = new ServletMapping();
	mapping.setServletName(holder.getName());
	String path = uri.getPath();

	if (!path.startsWith("/")) {
	path = '/' + path;
	}

	if (!path.startsWith(contextPath)) {
	path = contextPath + path;
	}

	mapping.setPathSpec(path);
	servletHandler.addServletMapping(mapping);

	// Compute the complete URL
	if (host == null) {
	try {
	host = InetAddress.getLocalHost().getHostAddress();
	} catch (UnknownHostException e) {
	host = "localhost";
	}
	}
	URL addedURL;
	try {
	addedURL = new URL(scheme, host, portNumber, path);
	} catch (MalformedURLException e) {
	throw new ServletMappingException(e);
	}
	logger.info("Added Servlet mapping: " + addedURL);
	return addedURL.toString();
	}

	public URL getURLMapping(String suri, SecurityContext securityContext) throws ServletMappingException {
	return map(suri, securityContext, true);
	}

	private URL map(String suri, SecurityContext securityContext, boolean resolve) throws ServletMappingException {
	URI uri = URI.create(suri);

	// Get the URI scheme and port
	String scheme = null;
	if(securityContext != null && securityContext.isSSLEnabled()) {
	scheme = "https";
	} else {
	scheme = uri.getScheme();
	if (scheme == null) {
	scheme = "http";
	}
	}

	int portNumber = uri.getPort();
	if (portNumber == -1) {
	if ("http".equals(scheme)) {
	portNumber = defaultPort;
	} else {
	portNumber = defaultSSLPort;
	}
	}

	// Get the host
	String host = uri.getHost();
	if (host == null) {
	host = "0.0.0.0";
	if (resolve) {
	try {
	host = InetAddress.getLocalHost().getHostAddress();
	} catch (UnknownHostException e) {
	host = "localhost";
	}
	}
	}

	// Construct the URL
	String path = uri.getPath();

	if (!path.startsWith("/")) {
	path = '/' + path;
	}

	if (!path.startsWith(contextPath)) {
	path = contextPath + path;
	}

	URL url;
	try {
	url = new URL(scheme, host, portNumber, path);
	} catch (MalformedURLException e) {
	throw new ServletMappingException(e);
	}
	return url;
	}

	public Servlet getServletMapping(String suri) throws ServletMappingException {

	if (suri == null) {
	return null;
	}

	URI uri = URI.create(suri);

	// Get the URI port
	int portNumber = uri.getPort();
	if (portNumber == -1) {
	portNumber = defaultPort;
	}

	// Get the port object associated with the given port number
	Port port = ports.get(portNumber);
	if (port == null) {
	return null;
	}

	// Remove the Servlet mapping for the given Servlet
	ServletHandler servletHandler = port.getServletHandler();
	Servlet servlet = null;
	List<ServletMapping> mappings =
	new ArrayList<ServletMapping>(Arrays.asList(servletHandler.getServletMappings()));
	String path = uri.getPath();

	if (!path.startsWith("/")) {
	path = '/' + path;
	}

	if (!path.startsWith(contextPath)) {
	path = contextPath + path;
	}

	for (ServletMapping mapping : mappings) {
	if (Arrays.asList(mapping.getPathSpecs()).contains(path)) {
	try {
	servlet = servletHandler.getServlet(mapping.getServletName()).getServlet();
	} catch (ServletException e) {
	throw new IllegalStateException(e);
	}
	break;
	}
	}
	return servlet;
	}

	public Servlet removeServletMapping(String suri) {
	URI uri = URI.create(suri);

	// Get the URI port
	int portNumber = uri.getPort();
	if (portNumber == -1) {
	portNumber = defaultPort;
	}

	// Get the port object associated with the given port number
	Port port = ports.get(portNumber);
	if (port == null) {
	// TODO - EPR - SL commented out exception temporarily as the runtime is shared
	// between multiple nodes in a VM and shutting down one node blows
	// up any other nodes when they shut down.
	//throw new IllegalStateException("No servlet registered at this URI: " + suri);
	logger.warning("No servlet registered at this URI: " + suri);
	return null;
	}

	// Remove the Servlet mapping for the given Servlet
	ServletHandler servletHandler = port.getServletHandler();
	Servlet removedServlet = null;
	List<ServletMapping> mappings =
	new ArrayList<ServletMapping>(Arrays.asList(servletHandler.getServletMappings()));
	String path = uri.getPath();

	if (!path.startsWith("/")) {
	path = '/' + path;
	}

	if (!path.startsWith(contextPath)) {
	path = contextPath + path;
	}

	for (ServletMapping mapping : mappings) {
	if (Arrays.asList(mapping.getPathSpecs()).contains(path)) {
	try {
	removedServlet = servletHandler.getServlet(mapping.getServletName()).getServlet();
	} catch (ServletException e) {
	throw new IllegalStateException(e);
	}
	mappings.remove(mapping);
	logger.info("Removed Servlet mapping: " + path);
	break;
	}
	}
	if (removedServlet != null) {
	servletHandler.setServletMappings(mappings.toArray(new ServletMapping[mappings.size()]));

	// Stop the port if there are no servlet mappings on it anymore
	if (mappings.size() == 0) {
	try {
	Server server = port.getServer();
	server.stop();
	server.setStopAtShutdown(false);
	} catch (Exception e) {
	throw new IllegalStateException(e);
	}
	ports.remove(portNumber);
	}

	} else {
	logger.warning("Trying to Remove servlet mapping: " + path + " where mapping is not registered");
	}

	return removedServlet;
	}

	public RequestDispatcher getRequestDispatcher(String suri) throws ServletMappingException {
	//FIXME implement this later
	return null;
	}

	public String getContextPath() {
	return contextPath;
	}

	public void setContextPath(String path) {
	this.contextPath = path;
	}

	/**
	* A wrapper to enable use of a WorkScheduler with Jetty
	*/
	private class WorkSchedulerThreadPool implements ThreadPool {

	public boolean dispatch(Runnable work) {
	workScheduler.scheduleWork(work);
	return true;
	}

	public void join() throws InterruptedException {
	synchronized (joinLock) {
	joinLock.wait();
	}
	}

	public int getThreads() {
	throw new UnsupportedOperationException();
	}

	public int getIdleThreads() {
	throw new UnsupportedOperationException();
	}

	public boolean isLowOnThreads() {
	return false;
	}
	}

	public void setAttribute(String name, Object value) {
	throw new UnsupportedOperationException();
	}

	public void start() {
	try {
	jettyLogger = new JettyLogger(logger);
	Log.setLog(jettyLogger);
	} catch (Throwable e) {
	// Ignore
	}
	}

	}