From e5b7380c874745c989d1816b8f552504f038e1bc Mon Sep 17 00:00:00 2001 From: lresende Date: Thu, 26 Sep 2013 20:33:20 +0000 Subject: 2.0 branch for possible maintenance release git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@1526672 13f79535-47bb-0310-9956-ffa450edef68 --- .../sca/http/jetty/JettyDefaultServlet.java | 90 +++ .../apache/tuscany/sca/http/jetty/JettyLogger.java | 107 ++++ .../apache/tuscany/sca/http/jetty/JettyServer.java | 609 +++++++++++++++++++++ .../org.apache.tuscany.sca.host.http.ServletHost | 18 + .../sca/http/jetty/JettyServerTestCase.java | 397 ++++++++++++++ .../src/test/resources/content/test.html | 21 + .../host-jetty/src/test/resources/tuscany.keyStore | Bin 0 -> 1265 bytes 7 files changed, 1242 insertions(+) create mode 100644 sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyDefaultServlet.java create mode 100644 sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyLogger.java create mode 100644 sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyServer.java create mode 100644 sca-java-2.x/branches/2.0/modules/host-jetty/src/main/resources/META-INF/services/org.apache.tuscany.sca.host.http.ServletHost create mode 100644 sca-java-2.x/branches/2.0/modules/host-jetty/src/test/java/org/apache/tuscany/sca/http/jetty/JettyServerTestCase.java create mode 100644 sca-java-2.x/branches/2.0/modules/host-jetty/src/test/resources/content/test.html create mode 100644 sca-java-2.x/branches/2.0/modules/host-jetty/src/test/resources/tuscany.keyStore (limited to 'sca-java-2.x/branches/2.0/modules/host-jetty/src') diff --git a/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyDefaultServlet.java b/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyDefaultServlet.java new file mode 100644 index 0000000000..4f5bfb3c62 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyDefaultServlet.java @@ -0,0 +1,90 @@ +/* + * 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.io.File; +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URL; + +import org.mortbay.jetty.servlet.DefaultServlet; +import org.mortbay.resource.Resource; +import org.mortbay.resource.URLResource; + +/** + * Customizes the Jetty default Servlet. + * + * @version $Rev$ $Date$ + */ +public class JettyDefaultServlet extends DefaultServlet { + private static final long serialVersionUID = 7000218247190209353L; + + private String documentRoot; + private String servletPath; + + public JettyDefaultServlet(String servletPath, String documentRoot) { + this.servletPath = servletPath + '/'; + this.documentRoot = documentRoot; + } + + @Override + public Resource getResource(String pathInContext) { + if (pathInContext.startsWith(servletPath)) { + if (pathInContext.length() > servletPath.length()) { + pathInContext = pathInContext.substring(servletPath.length()); + } else { + pathInContext = ""; + } + } else { + if ((pathInContext + "/").equals(servletPath)) { + pathInContext = ""; + } + } + + try { + URL url = new URL(documentRoot + "/" + pathInContext); + return new URLResource(url, url.openConnection()) { + private static final long serialVersionUID = 8560952113883507717L; + + @Override + public File getFile() throws IOException { + return null; + } + + }; + } catch (MalformedURLException e) { + return null; + } catch (IOException e) { + return null; + } + } + + @Override + public String getInitParameter(String name) { + if ("resourceBase".equals(name)) { + return documentRoot; + } else if ("redirectWelcome".equals(name)) { + return "true"; + } else { + return super.getInitParameter(name); + } + } + +} diff --git a/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyLogger.java b/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyLogger.java new file mode 100644 index 0000000000..be56bdb682 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyLogger.java @@ -0,0 +1,107 @@ +/* + * 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.util.logging.Level; + +import org.mortbay.log.Logger; + +/** + * Replaces Jetty's logging mechanism + * + * @version $Rev$ $Date$ + */ +public class JettyLogger implements Logger { + private java.util.logging.Logger jdkLogger; + + public JettyLogger() { + this(JettyLogger.class.getName()); + } + + public JettyLogger(String name) { + jdkLogger = java.util.logging.Logger.getLogger(name); + } + + /** + * @param jdkLogger + */ + public JettyLogger(java.util.logging.Logger jdkLogger) { + super(); + this.jdkLogger = jdkLogger; + } + + public String getName() { + return jdkLogger.getName(); + } + + public void debug(String msg) { + jdkLogger.log(Level.FINE, msg); + } + + public void debug(String msg, Throwable th) { + jdkLogger.log(Level.FINE, msg, th); + } + + public void debug(String msg, Object arg0, Object arg1) { + jdkLogger.log(Level.FINE, format(msg, arg0, arg1)); + } + + public Logger getLogger(String name) { + return new JettyLogger(name); + } + + public void info(String msg) { + jdkLogger.log(Level.INFO, msg); + } + + public void info(String msg, Object arg0, Object arg1) { + jdkLogger.log(Level.INFO, format(msg, arg0, arg1)); + } + + public boolean isDebugEnabled() { + return jdkLogger.isLoggable(Level.FINE); + } + + public void setDebugEnabled(boolean enabled) { + jdkLogger.setLevel(Level.FINE); + } + + public void warn(String msg) { + jdkLogger.log(Level.WARNING, msg); + } + + public void warn(String msg, Object arg0, Object arg1) { + jdkLogger.log(Level.WARNING, format(msg, arg0, arg1)); + } + + public void warn(String msg, Throwable th) { + jdkLogger.log(Level.WARNING, msg, th); + } + + private String format(String msg, Object arg0, Object arg1) { + int i0 = msg.indexOf("{}"); + int i1 = i0 < 0 ? -1 : msg.indexOf("{}", i0 + 2); + + if (arg1 != null && i1 >= 0) + msg = msg.substring(0, i1) + arg1 + msg.substring(i1 + 2); + if (arg0 != null && i0 >= 0) + msg = msg.substring(0, i0) + arg0 + msg.substring(i0 + 2); + return msg; + } +} diff --git a/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyServer.java b/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyServer.java new file mode 100644 index 0000000000..f62f24adc8 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/java/org/apache/tuscany/sca/http/jetty/JettyServer.java @@ -0,0 +1,609 @@ +/* + * 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.Map.Entry; +import java.util.Set; +import java.util.logging.Logger; + +import javax.servlet.RequestDispatcher; +import javax.servlet.Servlet; +import javax.servlet.ServletContext; +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.HttpScheme; +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.host.http.extensibility.HttpPortAllocator; +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; + + private HttpPortAllocator httpPortAllocator; + + // 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 = 0; + private int defaultPort; + private int defaultSSLPort; + + /** + * 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 ports = new HashMap(); + + private String contextPath = "/"; + private org.mortbay.log.Logger jettyLogger; + + public JettyServer(ExtensionPointRegistry registry) { + UtilityExtensionPoint utilityExtensionPoint = registry.getExtensionPoint(UtilityExtensionPoint.class); + this.workScheduler = utilityExtensionPoint.getUtility(WorkScheduler.class); + this.httpPortAllocator = utilityExtensionPoint.getUtility(HttpPortAllocator.class); + init(); + } + + protected JettyServer(WorkScheduler workScheduler, HttpPortAllocator httpPortAllocator) { + this.httpPortAllocator = httpPortAllocator; + this.workScheduler = workScheduler; + init(); + } + + private void init() { + this.defaultPort = this.httpPortAllocator.getDefaultPort(HttpScheme.HTTP); + //handle backdoor to set specific default port in tests + if(portDefault > 0) { + this.defaultPort = portDefault; + } + this.defaultSSLPort = this.httpPortAllocator.getDefaultPort(HttpScheme.HTTPS); + AccessController.doPrivileged(new PrivilegedAction() { + 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> entries = new HashSet>(ports.entrySet()); + for (Entry 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 mappings = + new ArrayList(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 mappings = + new ArrayList(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 + } + } + + @Override + public ServletContext getServletContext() { + if (ports.size() > 0) { + return ports.values().iterator().next().getServletHandler().getServletContext(); + } else { + return null; + } + } + +} diff --git a/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/resources/META-INF/services/org.apache.tuscany.sca.host.http.ServletHost b/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/resources/META-INF/services/org.apache.tuscany.sca.host.http.ServletHost new file mode 100644 index 0000000000..a93f4d5754 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/host-jetty/src/main/resources/META-INF/services/org.apache.tuscany.sca.host.http.ServletHost @@ -0,0 +1,18 @@ +# 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. +# Implementation class for the ServletHost +org.apache.tuscany.sca.http.jetty.JettyServer;name=jetty,ranking=100 diff --git a/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/java/org/apache/tuscany/sca/http/jetty/JettyServerTestCase.java b/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/java/org/apache/tuscany/sca/http/jetty/JettyServerTestCase.java new file mode 100644 index 0000000000..80666db8e3 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/java/org/apache/tuscany/sca/http/jetty/JettyServerTestCase.java @@ -0,0 +1,397 @@ +/* + * 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.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.net.ConnectException; +import java.net.InetAddress; +import java.net.ServerSocket; +import java.net.Socket; +import java.net.URL; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import javax.net.ssl.HostnameVerifier; +import javax.net.ssl.HttpsURLConnection; +import javax.net.ssl.SSLSession; +import javax.servlet.ServletConfig; +import javax.servlet.ServletException; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import junit.framework.TestCase; + +import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry; +import org.apache.tuscany.sca.core.UtilityExtensionPoint; +import org.apache.tuscany.sca.host.http.DefaultResourceServlet; +import org.apache.tuscany.sca.host.http.extensibility.HttpPortAllocator; +import org.apache.tuscany.sca.work.NotificationListener; +import org.apache.tuscany.sca.work.WorkScheduler; +import org.junit.Assert; + +/** + * @version $Rev$ $Date$ + */ +public class JettyServerTestCase extends TestCase { + + private static final String REQUEST1_HEADER = "GET / HTTP/1.0\n" + "Host: localhost\n" + + "Content-Type: text/xml\n" + + "Connection: close\n" + + "Content-Length: "; + private static final String REQUEST1_CONTENT = ""; + private static final String REQUEST1 = REQUEST1_HEADER + REQUEST1_CONTENT.getBytes().length + + "\n\n" + + REQUEST1_CONTENT; + + private static final String REQUEST2_HEADER = "GET /webcontent/test.html HTTP/1.0\n" + "Host: localhost\n" + + "Content-Type: text/xml\n" + + "Connection: close\n" + + "Content-Length: "; + private static final String REQUEST2_CONTENT = ""; + private static final String REQUEST2 = REQUEST2_HEADER + REQUEST2_CONTENT.getBytes().length + + "\n\n" + + REQUEST2_CONTENT; + + private static final int HTTP_PORT = 8085; + + private WorkScheduler workScheduler = new WorkScheduler() { + private ExecutorService executorService = Executors.newCachedThreadPool(); + + public void scheduleWork(T work) { + executorService.submit(work); + } + + public void scheduleWork(T work, NotificationListener listener) { + scheduleWork(work); + } + + public ExecutorService getExecutorService() { + return executorService; + } + }; + + private HttpPortAllocator httpPortAllocator = new DefaultExtensionPointRegistry() + .getExtensionPoint(UtilityExtensionPoint.class).getUtility(HttpPortAllocator.class); + + /** + * Verifies requests are properly routed according to the Servlet mapping + */ + public void testRegisterServletMapping() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + TestServlet servlet = new TestServlet(); + service.addServletMapping("http://127.0.0.1:" + HTTP_PORT + "/", servlet); + Socket client = new Socket("127.0.0.1", HTTP_PORT); + OutputStream os = client.getOutputStream(); + os.write(REQUEST1.getBytes()); + os.flush(); + read(client); + service.stop(); + assertTrue(servlet.invoked); + } + + /** + * Verifies requests are properly routed according to the Servlet mapping + */ + public void testDeployedURI() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.setDefaultPort(8085); + service.start(); + TestServlet servlet = new TestServlet(); + String host = InetAddress.getLocalHost().getHostAddress(); + String hostName = InetAddress.getLocalHost().getHostName(); + String url1 = service.addServletMapping("/MyService", servlet); + Assert.assertEquals("http://" + host + ":8085/MyService", url1); + String url2 = service.addServletMapping("http://localhost:8086/MyService", servlet); + Assert.assertEquals("http://localhost:8086/MyService", url2); + String url3 = service.addServletMapping("http://" + host + ":8087/MyService", servlet); + Assert.assertEquals("http://" + host + ":8087/MyService", url3); + String url4 = service.addServletMapping("http://0.0.0.0:8088/MyService", servlet); + Assert.assertEquals("http://" + host + ":8088/MyService", url4); + String url5 = service.addServletMapping("http://" + hostName + ":8089/MyService", servlet); + // Can't reliably test like this as on some hosts registering a servlet with a hostname + // produces a url with an IP address. + //Assert.assertEquals("http://" + hostName + ":8089/MyService", url5); + + service.stop(); + } + + public void testRegisterServletMappingSSL() throws Exception { + System.setProperty("javax.net.ssl.keyStore", "target/test-classes/tuscany.keyStore"); + System.setProperty("javax.net.ssl.keyStorePassword", "apache"); + System.setProperty("jetty.ssl.password", "apache"); + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + TestServlet servlet = new TestServlet(); + try { + service.addServletMapping("https://127.0.0.1:" + HTTP_PORT + "/foo", servlet); + } finally { + System.clearProperty("javax.net.ssl.keyStore"); + System.clearProperty("javax.net.ssl.keyStorePassword"); + System.clearProperty("jetty.ssl.password"); + } + System.setProperty("javax.net.ssl.trustStore", "target/test-classes/tuscany.keyStore"); + System.setProperty("javax.net.ssl.trustStorePassword", "apache"); + URL url = new URL("https://127.0.0.1:8085/foo"); + HttpsURLConnection conn = (HttpsURLConnection)url.openConnection(); + conn.setHostnameVerifier(new HostnameVerifier() { + public boolean verify(String hostname, SSLSession session) { + return true; + } + }); + + conn.connect(); + read(conn.getInputStream()); + + service.stop(); + assertTrue(servlet.invoked); + + } + + /** + * Verifies that Servlets can be registered with multiple ports + */ + public void testRegisterMultiplePorts() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + TestServlet servlet = new TestServlet(); + service.addServletMapping("http://127.0.0.1:" + HTTP_PORT + "/", servlet); + TestServlet servlet2 = new TestServlet(); + service.addServletMapping("http://127.0.0.1:" + (HTTP_PORT + 1) + "/", servlet2); + { + Socket client = new Socket("127.0.0.1", HTTP_PORT); + OutputStream os = client.getOutputStream(); + os.write(REQUEST1.getBytes()); + os.flush(); + read(client); + } + { + Socket client = new Socket("127.0.0.1", HTTP_PORT + 1); + OutputStream os = client.getOutputStream(); + os.write(REQUEST1.getBytes()); + os.flush(); + read(client); + } + + service.stop(); + assertTrue(servlet.invoked); + assertTrue(servlet2.invoked); + } + + public void testUnregisterMapping() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + TestServlet servlet = new TestServlet(); + String uri = "http://127.0.0.1:" + HTTP_PORT + "/foo"; + service.addServletMapping(uri, servlet); + service.removeServletMapping(uri); + try { + Socket client = new Socket("127.0.0.1", HTTP_PORT); + OutputStream os = client.getOutputStream(); + os.write(REQUEST1.getBytes()); + os.flush(); + read(client); + fail("Server still bound to port"); + } catch (ConnectException e) { + } + service.stop(); + assertFalse(servlet.invoked); + } + + public void testRequestSession() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + TestServlet servlet = new TestServlet(); + service.addServletMapping("http://127.0.0.1:" + HTTP_PORT + "/", servlet); + Socket client = new Socket("127.0.0.1", HTTP_PORT); + OutputStream os = client.getOutputStream(); + os.write(REQUEST1.getBytes()); + os.flush(); + read(client); + service.stop(); + assertTrue(servlet.invoked); + assertNotNull(servlet.sessionId); + } + + public void testRestart() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + service.stop(); + service.stop(); + } + + public void testNoMappings() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + Exception ex = null; + try { + new Socket("127.0.0.1", HTTP_PORT); + } catch (ConnectException e) { + ex = e; + } + assertNotNull(ex); + service.stop(); + } + + public void testResourceServlet() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + + String documentRoot = getClass().getClassLoader().getResource("content/test.html").toString(); + documentRoot = documentRoot.substring(0, documentRoot.lastIndexOf('/')); + DefaultResourceServlet resourceServlet = new DefaultResourceServlet(documentRoot); + TestResourceServlet servlet = new TestResourceServlet(resourceServlet); + service.addServletMapping("http://127.0.0.1:" + HTTP_PORT + "/webcontent/*", servlet); + + Socket client = new Socket("127.0.0.1", HTTP_PORT); + OutputStream os = client.getOutputStream(); + os.write(REQUEST2.getBytes()); + os.flush(); + + String document = read(client); + assertTrue(document.indexOf("

hello") != -1); + + service.stop(); + } + + public void testDefaultServlet() throws Exception { + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + service.start(); + + String documentRoot = getClass().getClassLoader().getResource("content/test.html").toString(); + documentRoot = documentRoot.substring(0, documentRoot.lastIndexOf('/')); + DefaultResourceServlet resourceServlet = new DefaultResourceServlet(documentRoot); + service.addServletMapping("http://127.0.0.1:" + HTTP_PORT + "/webcontent/*", resourceServlet); + + Socket client = new Socket("127.0.0.1", HTTP_PORT); + OutputStream os = client.getOutputStream(); + os.write(REQUEST2.getBytes()); + os.flush(); + + String document = read(client); + assertTrue(document.indexOf("

hello") != -1); + + service.stop(); + } + + public void testDefaultPort() throws IOException { + try { + // Open 9085 + System.setProperty("HTTP_PORT", "9085"); + JettyServer service = new JettyServer(workScheduler, httpPortAllocator); + assertEquals(9085, service.getDefaultPort()); + + // Try to find a free port + System.setProperty("HTTP_PORT", "0"); + service = new JettyServer(workScheduler, httpPortAllocator); + int port = service.getDefaultPort(); + assertNotSame(0, port); + + // Try to find the next free port + ServerSocket socket = null; + try { + socket = new ServerSocket(port); + service = new JettyServer(workScheduler, httpPortAllocator); + assertNotSame(port, service.getDefaultPort()); + } finally { + socket.close(); + } + } finally { + System.clearProperty("HTTP_PORT"); + } + } + + private static String read(Socket socket) throws IOException { + InputStream is = socket.getInputStream(); + return read(is); + } + + private static String read(InputStream is) throws IOException { + BufferedReader reader = null; + try { + reader = new BufferedReader(new InputStreamReader(is)); + StringBuffer sb = new StringBuffer(); + String str; + while ((str = reader.readLine()) != null) { + sb.append(str); + } + return sb.toString(); + } finally { + if (reader != null) { + reader.close(); + } + } + } + + private class TestServlet extends HttpServlet { + private static final long serialVersionUID = 1L; + boolean invoked; + String sessionId; + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + invoked = true; + sessionId = req.getSession().getId(); + OutputStream writer = resp.getOutputStream(); + try { + writer.write("result".getBytes()); + } finally { + writer.close(); + } + } + + } + + private class TestResourceServlet extends HttpServlet { + private static final long serialVersionUID = 1L; + private HttpServlet delegate; + + public TestResourceServlet(HttpServlet delegate) { + this.delegate = delegate; + } + + @Override + public void init() throws ServletException { + super.init(); + delegate.init(); + } + + @Override + public void init(ServletConfig config) throws ServletException { + super.init(); + delegate.init(config); + } + + @Override + protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + delegate.service(req, resp); + } + + @Override + public void destroy() { + super.destroy(); + delegate.destroy(); + } + } +} diff --git a/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/resources/content/test.html b/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/resources/content/test.html new file mode 100644 index 0000000000..f4b79d7f01 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/resources/content/test.html @@ -0,0 +1,21 @@ + + +

hello + \ No newline at end of file diff --git a/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/resources/tuscany.keyStore b/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/resources/tuscany.keyStore new file mode 100644 index 0000000000..7ea23f7ff4 Binary files /dev/null and b/sca-java-2.x/branches/2.0/modules/host-jetty/src/test/resources/tuscany.keyStore differ -- cgit v1.2.3