unreleased/modules/host-tomcat/src/main/java/org/apache/tuscany/sca/http/tomcat/TomcatServer.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.tomcat;

 import java.beans.PropertyChangeListener;
 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.security.PrivilegedActionException;
 import java.security.PrivilegedExceptionAction;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.logging.Logger;

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

 import org.apache.catalina.Container;
 import org.apache.catalina.Context;
 import org.apache.catalina.Engine;
 import org.apache.catalina.Host;
 import org.apache.catalina.Lifecycle;
 import org.apache.catalina.LifecycleException;
 import org.apache.catalina.Loader;
 import org.apache.catalina.connector.Connector;
 import org.apache.catalina.core.StandardEngine;
 import org.apache.catalina.startup.ContextConfig;
 import org.apache.catalina.startup.Embedded;
 import org.apache.coyote.http11.Http11Protocol;
 import org.apache.tomcat.util.buf.MessageBytes;
 import org.apache.tomcat.util.http.mapper.MappingData;
 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;

 /**
  * A Tomcat based implementation of ServletHost.
  *
  * @version $Rev$ $Date$
  */
 public class TomcatServer implements ServletHost, LifeCycleListener {
     private static final Logger logger = Logger.getLogger(TomcatServer.class.getName());

     private WorkScheduler workScheduler;
     private Embedded embedded;
     private Map<Integer, Port> ports = new HashMap<Integer, Port>();
     private String contextPath = "/";
     private int defaultPort = 8080;
     private int defaultSSLPort = 8443;

     private final class TuscanyLoader implements Loader {
         private final ClassLoader tccl;
         private boolean delegate;
         private boolean reloadable;
         private Container container;
         private List<String> repos = new ArrayList<String>();
         private List<PropertyChangeListener> listeners = new ArrayList<PropertyChangeListener>();

         private TuscanyLoader(ClassLoader tccl) {
             this.tccl = tccl;
         }

         public void addPropertyChangeListener(PropertyChangeListener listener) {
             listeners.add(listener);
         }

         public void addRepository(String repository) {
             repos.add(repository);
         }

         public void backgroundProcess() {
         }

         public String[] findRepositories() {
             return repos.toArray(new String[repos.size()]);
         }

         public Container getContainer() {
             return container;
         }

         public boolean getDelegate() {
             return delegate;
         }

         public String getInfo() {
             return "Tuscany Loader for Embedded Tomcat";
         }

         public boolean getReloadable() {
             return reloadable;
         }

         public boolean modified() {
             return false;
         }

         public void removePropertyChangeListener(PropertyChangeListener listener) {
             listeners.remove(listener);
         }

         public void setContainer(Container container) {
             this.container = container;
         }

         public void setDelegate(boolean delegate) {
             this.delegate = delegate;
         }

         public void setReloadable(boolean reloadable) {
             this.reloadable = reloadable;
         }

         public ClassLoader getClassLoader() {
             return tccl;
         }
     }

     /**
      * Represents a port and the server that serves it.
      */
     private class Port {
         private Engine engine;
         private Host host;
         private Connector connector;

         private Port(Engine engine, Host host, Connector connector) {
             this.engine = engine;
             this.host = host;
             this.connector = connector;
         }

         public Engine getEngine() {
             return engine;
         }

         public Host getHost() {
             return host;
         }

         public Connector getConnector() {
             return connector;
         }
     }

     /**
      * Constructs a new embedded Tomcat server.
      *
      */
     public TomcatServer(ExtensionPointRegistry registry, Map<String, String> attributes) {
         UtilityExtensionPoint utilities = registry.getExtensionPoint(UtilityExtensionPoint.class);
         this.workScheduler = utilities.getUtility(WorkScheduler.class);
         String port = attributes.get("defaultPort");
         if (port != null) {
             defaultPort = Integer.parseInt(port);
         }
         String sslPort = attributes.get("defaultSSLPort");
         if (sslPort != null) {
             defaultPort = Integer.parseInt(sslPort);
         }
         if (attributes.containsKey("contextPath")) {
             contextPath = attributes.get("contextPath");
         }
     }

     protected TomcatServer(WorkScheduler workScheduler) {
         this.workScheduler = workScheduler;
     }

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

     public int getDefaultPort() {
         return defaultPort;
     }

     /**
      * Stop all the started servers.
      */
     public void stop() {
         if (embedded != null) {
             try {
                 // embedded.stop();
                 embedded.destroy();
                 for (Port port : ports.values()) {
                     port.connector.stop();
                 }
             } catch (LifecycleException e) {
                 throw new IllegalStateException(e);
             }
         }
     }

     public synchronized String addServletMapping(String suri, Servlet servlet) {
         init();
         URI uri = URI.create(suri);

         // Get the URI scheme and port
         String scheme = uri.getScheme();
         if (scheme == null) {
             scheme = "http";
         }
         final int portNumber = (uri.getPort() == -1 ? defaultPort : uri.getPort());

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

             port = createInstance(scheme, portNumber);
             ports.put(portNumber, port);
         }

         // Register the Servlet mapping
         String path = uri.getPath();

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

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

         ServletWrapper wrapper;
         if (servlet instanceof DefaultResourceServlet) {
             String defaultServletPath = path;

             // Optimize the handling of resource requests, use the Tomcat default Servlet
             // instead of our default resource Servlet
             if (defaultServletPath.endsWith("*")) {
                 defaultServletPath = defaultServletPath.substring(0, defaultServletPath.length() - 1);
             }
             if (defaultServletPath.endsWith("/")) {
                 defaultServletPath = defaultServletPath.substring(0, defaultServletPath.length() - 1);
             }
             DefaultResourceServlet resourceServlet = (DefaultResourceServlet)servlet;
             TomcatDefaultServlet defaultServlet =
                 new TomcatDefaultServlet(defaultServletPath, resourceServlet.getDocumentRoot());
             wrapper = new ServletWrapper(defaultServlet);

         } else {
             wrapper = new ServletWrapper(servlet);
         }
         Context context = port.getHost().map(path);
         wrapper.setName(path);
         wrapper.addMapping(path);
         context.addChild(wrapper);
         context.addServletMapping(path, path);
         port.getConnector().getMapper().addWrapper("localhost", "", path, wrapper);

         // Initialize the Servlet
         try {
             wrapper.initServlet();
         } catch (ServletException e) {
             throw new ServletMappingException(e);
         }

         // Compute the complete URL
         String host;
         try {
             host = InetAddress.getLocalHost().getHostName();
         } 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();
     }

     private Port createInstance(String scheme, final int portNumber) {
         Port port;
         // Create an engine
         // Allow privileged access to read properties. Requires PropertiesPermission read in
         // security policy.
         final Engine engine = AccessController.doPrivileged(new PrivilegedAction<Engine>() {
             public Engine run() {
                 return embedded.createEngine();
             }
         });

         ((StandardEngine)engine).setBaseDir("");
         engine.setDefaultHost("localhost");
         engine.setName("engine/" + portNumber);

         // Create a host
         // Allow privileged access to read properties. Requires PropertiesPermission read in
         // security policy.
         final Host host = AccessController.doPrivileged(new PrivilegedAction<Host>() {
             public Host run() {
                 Host host = embedded.createHost("localhost", "");
                 engine.addChild(host);
                 return host;
             }
         });

         // Create the root context
         Context context = embedded.createContext("", "");
         final ClassLoader tccl = Thread.currentThread().getContextClassLoader();
         context.setLoader(new TuscanyLoader(tccl));
         // context.setParentClassLoader(tccl.getParent());
         ContextConfig config = new ContextConfig();
         ((Lifecycle)context).addLifecycleListener(config);
         host.addChild(context);

         embedded.addEngine(engine);

         // Install an HTTP connector

         Connector connector;
         // Allow privileged access to read properties. Requires PropertiesPermission read in
         // security policy.
         try {
             final String protocol = scheme;
             connector = AccessController.doPrivileged(new PrivilegedExceptionAction<Connector>() {
                 public Connector run() throws Exception {
                     Connector customConnector = new Connector();
                     customConnector.setPort(portNumber);

                     if ("https".equalsIgnoreCase(protocol)) {
                         configureSSL(customConnector);
                         ((Http11Protocol)customConnector.getProtocolHandler()).setSSLEnabled(true);
                     }
                     return customConnector;
                 }

                 private void configureSSL(Connector customConnector) {
                     String trustStore = System.getProperty("javax.net.ssl.trustStore");
                     String trustStorePass = System.getProperty("javax.net.ssl.trustStorePassword");
                     String keyStore = System.getProperty("javax.net.ssl.keyStore");
                     String keyStorePass = System.getProperty("javax.net.ssl.keyStorePassword");

                     customConnector.setProperty("protocol", "TLS");

                     customConnector.setProperty("keystore", keyStore);
                     customConnector.setProperty("keypass", keyStorePass);
                     String keyStoreType = System.getProperty("javax.net.ssl.keyStoreType", KeyStore.getDefaultType());
                     String trustStoreType =
                         System.getProperty("javax.net.ssl.trustStoreType", KeyStore.getDefaultType());
                     customConnector.setProperty("keytype", keyStoreType);
                     customConnector.setProperty("trusttype", trustStoreType);
                     customConnector.setProperty("truststore", trustStore);
                     customConnector.setProperty("trustpass", trustStorePass);

                     customConnector.setProperty("clientauth", "false");
                     customConnector.setProtocol("HTTP/1.1");
                     customConnector.setScheme(protocol);
                     customConnector.setProperty("backlog", "10");
                     customConnector.setSecure(true);
                 }
             });
         } catch (Exception e) {
             throw new ServletMappingException(e);
         }

         embedded.addConnector(connector);
         try {
             connector.start();
         } catch (LifecycleException e) {
             throw new ServletMappingException(e);
         }

         // Keep track of the running server
         port = new Port(engine, host, connector);
         return port;
     }

     private synchronized void init() {
         if (embedded != null) {
             return;
         }
         embedded = new Embedded();
         embedded.setAwait(true);
         // Allow privileged access to read properties. Requires PropertiesPermission read in
         // security policy.
         try {
             AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                 public Object run() throws LifecycleException {
                     embedded.start();
                     return null;
                 }
             });
         } catch (PrivilegedActionException e) {
             // throw (LifecycleException)e.getException();
             throw new ServletMappingException(e);
         }
     }

     public URL getURLMapping(String suri) throws ServletMappingException {
         URI uri = URI.create(suri);

         // Get the URI scheme and port
         String scheme = uri.getScheme();
         if (scheme == null) {
             scheme = "http";
         }
         int portNumber = uri.getPort();
         if (portNumber == -1) {
             portNumber = defaultPort;
         }

         // Get the host
         String host;
         try {
             host = InetAddress.getLocalHost().getHostName();
         } 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;
         }

         String mapping = uri.getPath();

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

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

         final Context context = port.getHost().map(mapping);
         final MappingData md = new MappingData();
         final MessageBytes mb = MessageBytes.newInstance();
         mb.setString(mapping);
         try {
             // Allow privileged access to read properties. Requires PropertiesPermission read in
             // security policy.
             AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                 public Object run() throws Exception {
                     context.getMapper().map(mb, md);
                     return null;
                 }
             });
         } catch (Exception e) {
             return null;
         }
         if (md.wrapper instanceof ServletWrapper) {
             ServletWrapper servletWrapper = (ServletWrapper)md.wrapper;
             return servletWrapper.getServlet();
         } else {
             return null;
         }
     }

     public synchronized 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) {
             throw new IllegalStateException("No servlet registered at this URI: " + suri);
         }

         String mapping = uri.getPath();

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

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

         final Context context = port.getHost().map(mapping);
         final MappingData md = new MappingData();
         final MessageBytes mb = MessageBytes.newInstance();
         mb.setString(mapping);
         try {
             // Allow privileged access to read properties. Requires PropertiesPermission read in
             // security policy.
             AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                 public Object run() throws Exception {
                     context.getMapper().map(mb, md);
                     return null;
                 }
             });
         } catch (Exception e) {
             return null;
         }
         if (md.wrapper instanceof ServletWrapper) {
             ServletWrapper servletWrapper = (ServletWrapper)md.wrapper;

             port.getConnector().getMapper().removeWrapper("localhost", "", mapping);

             try {
                 context.removeServletMapping(mapping);
             } catch (NegativeArraySizeException e) {
                 // JIRA TUSCANY-1599
                 // FIXME Looks like a bug in Tomcat when removing the last
                 // Servlet in the list, catch the exception for now as it doesn't
                 // seem harmful, will find a better solution for the next release
             }
             context.removeChild(servletWrapper);
             try {
                 servletWrapper.destroyServlet();
             } catch (Exception ex) {
                 // Hack to handle destruction of Servlets without Servlet context
             }

             logger.info("Removed Servlet mapping: " + suri);

             // Stop the port if there's no servlets on it anymore
             String[] contextNames = port.getConnector().getMapper().getContextNames();
             if (contextNames == null || contextNames.length == 0) {
                 try {
                     port.getConnector().stop();
                     ((StandardEngine)port.getEngine()).stop();
                     embedded.removeEngine(port.getEngine());
                     embedded.removeConnector(port.getConnector());
                     ports.remove(portNumber);
                 } catch (LifecycleException e) {
                     throw new IllegalStateException(e);
                 }
             }

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

     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;
     }

     public void start() {

     }

     public String addServletMapping(String uri, Servlet servlet, SecurityContext securityContext)
         throws ServletMappingException {
         return addServletMapping(uri, servlet);
     }

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

     public URL getURLMapping(String arg0, SecurityContext arg1) {
         return null;
     }

     public void setAttribute(String arg0, Object arg1) {
     }

     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;
     }

     @Override
     public ServletContext getServletContext() {
         if (ports.isEmpty()) {
             return null;
         } else {
             Port port = ports.values().iterator().next();
             return port.getHost().map(getContextPath()).getServletContext();
         }
     }

 }
	/*
	* 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.tomcat;

	import java.beans.PropertyChangeListener;
	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.security.PrivilegedActionException;
	import java.security.PrivilegedExceptionAction;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.logging.Logger;

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

	import org.apache.catalina.Container;
	import org.apache.catalina.Context;
	import org.apache.catalina.Engine;
	import org.apache.catalina.Host;
	import org.apache.catalina.Lifecycle;
	import org.apache.catalina.LifecycleException;
	import org.apache.catalina.Loader;
	import org.apache.catalina.connector.Connector;
	import org.apache.catalina.core.StandardEngine;
	import org.apache.catalina.startup.ContextConfig;
	import org.apache.catalina.startup.Embedded;
	import org.apache.coyote.http11.Http11Protocol;
	import org.apache.tomcat.util.buf.MessageBytes;
	import org.apache.tomcat.util.http.mapper.MappingData;
	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;

	/**
	* A Tomcat based implementation of ServletHost.
	*
	* @version $Rev$ $Date$
	*/
	public class TomcatServer implements ServletHost, LifeCycleListener {
	private static final Logger logger = Logger.getLogger(TomcatServer.class.getName());

	private WorkScheduler workScheduler;
	private Embedded embedded;
	private Map<Integer, Port> ports = new HashMap<Integer, Port>();
	private String contextPath = "/";
	private int defaultPort = 8080;
	private int defaultSSLPort = 8443;

	private final class TuscanyLoader implements Loader {
	private final ClassLoader tccl;
	private boolean delegate;
	private boolean reloadable;
	private Container container;
	private List<String> repos = new ArrayList<String>();
	private List<PropertyChangeListener> listeners = new ArrayList<PropertyChangeListener>();

	private TuscanyLoader(ClassLoader tccl) {
	this.tccl = tccl;
	}

	public void addPropertyChangeListener(PropertyChangeListener listener) {
	listeners.add(listener);
	}

	public void addRepository(String repository) {
	repos.add(repository);
	}

	public void backgroundProcess() {
	}

	public String[] findRepositories() {
	return repos.toArray(new String[repos.size()]);
	}

	public Container getContainer() {
	return container;
	}

	public boolean getDelegate() {
	return delegate;
	}

	public String getInfo() {
	return "Tuscany Loader for Embedded Tomcat";
	}

	public boolean getReloadable() {
	return reloadable;
	}

	public boolean modified() {
	return false;
	}

	public void removePropertyChangeListener(PropertyChangeListener listener) {
	listeners.remove(listener);
	}

	public void setContainer(Container container) {
	this.container = container;
	}

	public void setDelegate(boolean delegate) {
	this.delegate = delegate;
	}

	public void setReloadable(boolean reloadable) {
	this.reloadable = reloadable;
	}

	public ClassLoader getClassLoader() {
	return tccl;
	}
	}

	/**
	* Represents a port and the server that serves it.
	*/
	private class Port {
	private Engine engine;
	private Host host;
	private Connector connector;

	private Port(Engine engine, Host host, Connector connector) {
	this.engine = engine;
	this.host = host;
	this.connector = connector;
	}

	public Engine getEngine() {
	return engine;
	}

	public Host getHost() {
	return host;
	}

	public Connector getConnector() {
	return connector;
	}
	}

	/**
	* Constructs a new embedded Tomcat server.
	*
	*/
	public TomcatServer(ExtensionPointRegistry registry, Map<String, String> attributes) {
	UtilityExtensionPoint utilities = registry.getExtensionPoint(UtilityExtensionPoint.class);
	this.workScheduler = utilities.getUtility(WorkScheduler.class);
	String port = attributes.get("defaultPort");
	if (port != null) {
	defaultPort = Integer.parseInt(port);
	}
	String sslPort = attributes.get("defaultSSLPort");
	if (sslPort != null) {
	defaultPort = Integer.parseInt(sslPort);
	}
	if (attributes.containsKey("contextPath")) {
	contextPath = attributes.get("contextPath");
	}
	}

	protected TomcatServer(WorkScheduler workScheduler) {
	this.workScheduler = workScheduler;
	}

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

	public int getDefaultPort() {
	return defaultPort;
	}

	/**
	* Stop all the started servers.
	*/
	public void stop() {
	if (embedded != null) {
	try {
	// embedded.stop();
	embedded.destroy();
	for (Port port : ports.values()) {
	port.connector.stop();
	}
	} catch (LifecycleException e) {
	throw new IllegalStateException(e);
	}
	}
	}

	public synchronized String addServletMapping(String suri, Servlet servlet) {
	init();
	URI uri = URI.create(suri);

	// Get the URI scheme and port
	String scheme = uri.getScheme();
	if (scheme == null) {
	scheme = "http";
	}
	final int portNumber = (uri.getPort() == -1 ? defaultPort : uri.getPort());

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

	port = createInstance(scheme, portNumber);
	ports.put(portNumber, port);
	}

	// Register the Servlet mapping
	String path = uri.getPath();

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

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

	ServletWrapper wrapper;
	if (servlet instanceof DefaultResourceServlet) {
	String defaultServletPath = path;

	// Optimize the handling of resource requests, use the Tomcat default Servlet
	// instead of our default resource Servlet
	if (defaultServletPath.endsWith("*")) {
	defaultServletPath = defaultServletPath.substring(0, defaultServletPath.length() - 1);
	}
	if (defaultServletPath.endsWith("/")) {
	defaultServletPath = defaultServletPath.substring(0, defaultServletPath.length() - 1);
	}
	DefaultResourceServlet resourceServlet = (DefaultResourceServlet)servlet;
	TomcatDefaultServlet defaultServlet =
	new TomcatDefaultServlet(defaultServletPath, resourceServlet.getDocumentRoot());
	wrapper = new ServletWrapper(defaultServlet);

	} else {
	wrapper = new ServletWrapper(servlet);
	}
	Context context = port.getHost().map(path);
	wrapper.setName(path);
	wrapper.addMapping(path);
	context.addChild(wrapper);
	context.addServletMapping(path, path);
	port.getConnector().getMapper().addWrapper("localhost", "", path, wrapper);

	// Initialize the Servlet
	try {
	wrapper.initServlet();
	} catch (ServletException e) {
	throw new ServletMappingException(e);
	}

	// Compute the complete URL
	String host;
	try {
	host = InetAddress.getLocalHost().getHostName();
	} 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();
	}

	private Port createInstance(String scheme, final int portNumber) {
	Port port;
	// Create an engine
	// Allow privileged access to read properties. Requires PropertiesPermission read in
	// security policy.
	final Engine engine = AccessController.doPrivileged(new PrivilegedAction<Engine>() {
	public Engine run() {
	return embedded.createEngine();
	}
	});

	((StandardEngine)engine).setBaseDir("");
	engine.setDefaultHost("localhost");
	engine.setName("engine/" + portNumber);

	// Create a host
	// Allow privileged access to read properties. Requires PropertiesPermission read in
	// security policy.
	final Host host = AccessController.doPrivileged(new PrivilegedAction<Host>() {
	public Host run() {
	Host host = embedded.createHost("localhost", "");
	engine.addChild(host);
	return host;
	}
	});

	// Create the root context
	Context context = embedded.createContext("", "");
	final ClassLoader tccl = Thread.currentThread().getContextClassLoader();
	context.setLoader(new TuscanyLoader(tccl));
	// context.setParentClassLoader(tccl.getParent());
	ContextConfig config = new ContextConfig();
	((Lifecycle)context).addLifecycleListener(config);
	host.addChild(context);

	embedded.addEngine(engine);

	// Install an HTTP connector

	Connector connector;
	// Allow privileged access to read properties. Requires PropertiesPermission read in
	// security policy.
	try {
	final String protocol = scheme;
	connector = AccessController.doPrivileged(new PrivilegedExceptionAction<Connector>() {
	public Connector run() throws Exception {
	Connector customConnector = new Connector();
	customConnector.setPort(portNumber);

	if ("https".equalsIgnoreCase(protocol)) {
	configureSSL(customConnector);
	((Http11Protocol)customConnector.getProtocolHandler()).setSSLEnabled(true);
	}
	return customConnector;
	}

	private void configureSSL(Connector customConnector) {
	String trustStore = System.getProperty("javax.net.ssl.trustStore");
	String trustStorePass = System.getProperty("javax.net.ssl.trustStorePassword");
	String keyStore = System.getProperty("javax.net.ssl.keyStore");
	String keyStorePass = System.getProperty("javax.net.ssl.keyStorePassword");

	customConnector.setProperty("protocol", "TLS");

	customConnector.setProperty("keystore", keyStore);
	customConnector.setProperty("keypass", keyStorePass);
	String keyStoreType = System.getProperty("javax.net.ssl.keyStoreType", KeyStore.getDefaultType());
	String trustStoreType =
	System.getProperty("javax.net.ssl.trustStoreType", KeyStore.getDefaultType());
	customConnector.setProperty("keytype", keyStoreType);
	customConnector.setProperty("trusttype", trustStoreType);
	customConnector.setProperty("truststore", trustStore);
	customConnector.setProperty("trustpass", trustStorePass);

	customConnector.setProperty("clientauth", "false");
	customConnector.setProtocol("HTTP/1.1");
	customConnector.setScheme(protocol);
	customConnector.setProperty("backlog", "10");
	customConnector.setSecure(true);
	}
	});
	} catch (Exception e) {
	throw new ServletMappingException(e);
	}

	embedded.addConnector(connector);
	try {
	connector.start();
	} catch (LifecycleException e) {
	throw new ServletMappingException(e);
	}

	// Keep track of the running server
	port = new Port(engine, host, connector);
	return port;
	}

	private synchronized void init() {
	if (embedded != null) {
	return;
	}
	embedded = new Embedded();
	embedded.setAwait(true);
	// Allow privileged access to read properties. Requires PropertiesPermission read in
	// security policy.
	try {
	AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
	public Object run() throws LifecycleException {
	embedded.start();
	return null;
	}
	});
	} catch (PrivilegedActionException e) {
	// throw (LifecycleException)e.getException();
	throw new ServletMappingException(e);
	}
	}

	public URL getURLMapping(String suri) throws ServletMappingException {
	URI uri = URI.create(suri);

	// Get the URI scheme and port
	String scheme = uri.getScheme();
	if (scheme == null) {
	scheme = "http";
	}
	int portNumber = uri.getPort();
	if (portNumber == -1) {
	portNumber = defaultPort;
	}

	// Get the host
	String host;
	try {
	host = InetAddress.getLocalHost().getHostName();
	} 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;
	}

	String mapping = uri.getPath();

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

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

	final Context context = port.getHost().map(mapping);
	final MappingData md = new MappingData();
	final MessageBytes mb = MessageBytes.newInstance();
	mb.setString(mapping);
	try {
	// Allow privileged access to read properties. Requires PropertiesPermission read in
	// security policy.
	AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
	public Object run() throws Exception {
	context.getMapper().map(mb, md);
	return null;
	}
	});
	} catch (Exception e) {
	return null;
	}
	if (md.wrapper instanceof ServletWrapper) {
	ServletWrapper servletWrapper = (ServletWrapper)md.wrapper;
	return servletWrapper.getServlet();
	} else {
	return null;
	}
	}

	public synchronized 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) {
	throw new IllegalStateException("No servlet registered at this URI: " + suri);
	}

	String mapping = uri.getPath();

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

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

	final Context context = port.getHost().map(mapping);
	final MappingData md = new MappingData();
	final MessageBytes mb = MessageBytes.newInstance();
	mb.setString(mapping);
	try {
	// Allow privileged access to read properties. Requires PropertiesPermission read in
	// security policy.
	AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
	public Object run() throws Exception {
	context.getMapper().map(mb, md);
	return null;
	}
	});
	} catch (Exception e) {
	return null;
	}
	if (md.wrapper instanceof ServletWrapper) {
	ServletWrapper servletWrapper = (ServletWrapper)md.wrapper;

	port.getConnector().getMapper().removeWrapper("localhost", "", mapping);

	try {
	context.removeServletMapping(mapping);
	} catch (NegativeArraySizeException e) {
	// JIRA TUSCANY-1599
	// FIXME Looks like a bug in Tomcat when removing the last
	// Servlet in the list, catch the exception for now as it doesn't
	// seem harmful, will find a better solution for the next release
	}
	context.removeChild(servletWrapper);
	try {
	servletWrapper.destroyServlet();
	} catch (Exception ex) {
	// Hack to handle destruction of Servlets without Servlet context
	}

	logger.info("Removed Servlet mapping: " + suri);

	// Stop the port if there's no servlets on it anymore
	String[] contextNames = port.getConnector().getMapper().getContextNames();
	if (contextNames == null \|\| contextNames.length == 0) {
	try {
	port.getConnector().stop();
	((StandardEngine)port.getEngine()).stop();
	embedded.removeEngine(port.getEngine());
	embedded.removeConnector(port.getConnector());
	ports.remove(portNumber);
	} catch (LifecycleException e) {
	throw new IllegalStateException(e);
	}
	}

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

	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;
	}

	public void start() {

	}

	public String addServletMapping(String uri, Servlet servlet, SecurityContext securityContext)
	throws ServletMappingException {
	return addServletMapping(uri, servlet);
	}

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

	public URL getURLMapping(String arg0, SecurityContext arg1) {
	return null;
	}

	public void setAttribute(String arg0, Object arg1) {
	}

	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;
	}

	@Override
	public ServletContext getServletContext() {
	if (ports.isEmpty()) {
	return null;
	} else {
	Port port = ports.values().iterator().next();
	return port.getHost().map(getContextPath()).getServletContext();
	}
	}

	}