summaryrefslogtreecommitdiffstats
path: root/sca-java-2.x/trunk/modules/host-webapp/src/main/java
diff options
context:
space:
mode:
authorlresende <lresende@13f79535-47bb-0310-9956-ffa450edef68>2009-11-20 23:53:35 +0000
committerlresende <lresende@13f79535-47bb-0310-9956-ffa450edef68>2009-11-20 23:53:35 +0000
commita3c48da9bb8971497d414f86e352123d95b9c3da (patch)
treefdf0f3636b65946c061c8b2e89d657b488be274e /sca-java-2.x/trunk/modules/host-webapp/src/main/java
parentcc7496466097c3cb8e793ebf3e332b025705aaa7 (diff)
Moving 2.x trunk
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@882795 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'sca-java-2.x/trunk/modules/host-webapp/src/main/java')
-rw-r--r--sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/ServletHostHelper.java188
-rw-r--r--sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/TuscanyContextListener.java59
-rw-r--r--sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/TuscanyServletFilter.java109
-rw-r--r--sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/WebAppRequestDispatcher.java117
-rw-r--r--sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/WebAppServletHost.java312
5 files changed, 785 insertions, 0 deletions
diff --git a/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/ServletHostHelper.java b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/ServletHostHelper.java
new file mode 100644
index 0000000000..4ad9519ad8
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/ServletHostHelper.java
@@ -0,0 +1,188 @@
+/*
+ * 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.host.webapp;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URL;
+import java.util.Enumeration;
+import java.util.List;
+
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.host.http.DefaultServletHostExtensionPoint;
+import org.apache.tuscany.sca.host.http.ServletHost;
+import org.apache.tuscany.sca.host.http.ServletHostExtensionPoint;
+import org.apache.tuscany.sca.node.Node;
+import org.apache.tuscany.sca.node.NodeFactory;
+import org.apache.tuscany.sca.node.configuration.NodeConfiguration;
+import org.apache.tuscany.sca.node.impl.NodeImpl;
+
+public class ServletHostHelper {
+ public static final String DOMAIN_NAME_ATTR = "org.apache.tuscany.sca.domain.name";
+ public static final String SCA_NODE_ATTRIBUTE = Node.class.getName();
+ private static NodeFactory factory;
+
+ private static URL getResource(ServletContext servletContext, String location) throws IOException {
+ URI uri = URI.create(location);
+ if (uri.isAbsolute()) {
+ return uri.toURL();
+ } else {
+ String path = location;
+ if (!path.startsWith("/")) {
+ path = "/" + path;
+ }
+ URL url = servletContext.getResource(path);
+ if (url != null && url.getProtocol().equals("jndi")) {
+ //this is Tomcat case, we should use getRealPath
+ File warRootFile = new File(servletContext.getRealPath(path));
+ return warRootFile.toURI().toURL();
+ } else {
+ //this is Jetty case
+ return url;
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private static NodeConfiguration getNodeConfiguration(ServletContext servletContext) throws IOException {
+ NodeConfiguration configuration = null;
+ String nodeConfigURI = (String) servletContext.getAttribute("node.configuration");
+ if (nodeConfigURI != null) {
+ URL url = getResource(servletContext, nodeConfigURI);
+ configuration = factory.loadConfiguration(url.openStream(), url);
+ } else {
+ configuration = factory.createNodeConfiguration();
+ configuration.setDomainURI(factory.getDomainURI());
+ Enumeration<String> names = servletContext.getAttributeNames();
+ while (names.hasMoreElements()) {
+ String name = names.nextElement();
+ if (name.startsWith("contribution.")) {
+ String contrib = (String) servletContext.getAttribute(name);
+ if (contrib != null) {
+ configuration.addContribution(getResource(servletContext, contrib));
+ }
+ }
+ }
+ if (configuration.getContributions().isEmpty()) {
+ // TODO: Which path should be the default root
+ configuration.addContribution(getResource(servletContext, "/"));
+ }
+ URL composite = getResource(servletContext, "/WEB-INF/web.composite");
+ if (composite != null) {
+ configuration.getContributions().get(0).addDeploymentComposite(composite);
+ }
+ String nodeURI = (String) servletContext.getAttribute("node.uri");
+ if (nodeURI == null) {
+ nodeURI = new File(servletContext.getRealPath("/")).getName();
+ }
+ configuration.setURI(nodeURI);
+ String domainURI = (String) servletContext.getAttribute("domain.uri");
+ if (domainURI != null) {
+ configuration.setDomainURI(domainURI);
+ }
+ }
+ return configuration;
+ }
+
+ public static ServletHost init(final ServletContext servletContext) {
+ Node node = (Node)servletContext.getAttribute(SCA_NODE_ATTRIBUTE);
+ if (node == null) {
+ try {
+ String domainName = (String)servletContext.getAttribute(DOMAIN_NAME_ATTR);
+ if (domainName != null) {
+ factory = NodeFactory.getInstance(domainName);
+ } else {
+ factory = NodeFactory.newInstance();
+ }
+ for (Enumeration<String> e = servletContext.getInitParameterNames(); e.hasMoreElements();) {
+ String name = e.nextElement();
+ String value = servletContext.getInitParameter(name);
+ servletContext.setAttribute(name, value);
+ }
+ node = createNode(servletContext);
+ servletContext.setAttribute(SCA_NODE_ATTRIBUTE, node);
+ getServletHost(node).init(new ServletConfig() {
+ public String getInitParameter(String name) {
+ return servletContext.getInitParameter(name);
+ }
+
+ public Enumeration<?> getInitParameterNames() {
+ return servletContext.getInitParameterNames();
+ }
+
+ public ServletContext getServletContext() {
+ return servletContext;
+ }
+
+ public String getServletName() {
+ return servletContext.getServletContextName();
+ }
+ });
+ } catch (ServletException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ return getServletHost(node);
+ }
+
+ private static WebAppServletHost getServletHost(Node node) {
+ NodeImpl nodeImpl = (NodeImpl)node;
+ ExtensionPointRegistry eps = nodeImpl.getExtensionPoints();
+ ServletHostExtensionPoint servletHosts = eps.getExtensionPoint(ServletHostExtensionPoint.class);
+ List<ServletHost> hosts = servletHosts.getServletHosts();
+ if (hosts == null || hosts.size() < 1) {
+ throw new IllegalStateException("No ServletHost found");
+ }
+ for (ServletHost servletHost : hosts) {
+ if ("webapp".equals(servletHost.getName())) {
+ if(servletHost instanceof DefaultServletHostExtensionPoint.LazyServletHost) {
+ return (WebAppServletHost) ((DefaultServletHostExtensionPoint.LazyServletHost) servletHost).getServletHost();
+ } else if(servletHost instanceof WebAppServletHost) {
+ return (WebAppServletHost) servletHost;
+ }
+ }
+ }
+ throw new IllegalStateException("No WebApp Servlet host is configured");
+ }
+
+ private static Node createNode(final ServletContext servletContext) throws ServletException {
+ NodeConfiguration configuration;
+ try {
+ configuration = getNodeConfiguration(servletContext);
+ } catch (IOException e) {
+ throw new ServletException(e);
+ }
+ Node node = factory.createNode(configuration).start();
+ return node;
+ }
+
+ public static void stop(ServletContext servletContext) {
+ Node node = (Node)servletContext.getAttribute(ServletHostHelper.SCA_NODE_ATTRIBUTE);
+ if (node != null) {
+ node.stop();
+ servletContext.setAttribute(ServletHostHelper.SCA_NODE_ATTRIBUTE, null);
+ }
+ }
+}
diff --git a/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/TuscanyContextListener.java b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/TuscanyContextListener.java
new file mode 100644
index 0000000000..62c238e135
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/TuscanyContextListener.java
@@ -0,0 +1,59 @@
+/*
+ * 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.host.webapp;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.servlet.ServletContextEvent;
+import javax.servlet.ServletContextListener;
+
+/**
+ * A ServletContextListener to create and close the SCADomain
+ * when the webapp is initialized or destroyed.
+ */
+public class TuscanyContextListener implements ServletContextListener {
+ private final Logger logger = Logger.getLogger(TuscanyContextListener.class.getName());
+ private boolean inited;
+
+ public void contextInitialized(ServletContextEvent event) {
+ logger.info(event.getServletContext().getServletContextName() + " is starting.");
+ try {
+ ServletHostHelper.init(event.getServletContext());
+ } catch (Throwable e) {
+ logger.log(Level.SEVERE, e.getMessage(), e);
+ }
+ inited = true;
+ }
+
+ public void contextDestroyed(ServletContextEvent event) {
+ logger.info(event.getServletContext().getServletContextName() + " is stopping.");
+ if (!inited) {
+ return;
+ }
+ try {
+ ServletHostHelper.stop(event.getServletContext());
+ } catch (Throwable e) {
+ logger.log(Level.SEVERE, e.getMessage(), e);
+ }
+ inited = false;
+ }
+
+}
diff --git a/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/TuscanyServletFilter.java b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/TuscanyServletFilter.java
new file mode 100644
index 0000000000..72a76a789e
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/TuscanyServletFilter.java
@@ -0,0 +1,109 @@
+/*
+ * 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.host.webapp;
+
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterConfig;
+import javax.servlet.RequestDispatcher;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.tuscany.sca.host.http.ServletHost;
+
+/**
+ * A Servlet filter that forwards service requests to the Servlets registered with
+ * the Tuscany ServletHost.
+ *
+ * @version $Rev$ $Date$
+ */
+public class TuscanyServletFilter implements Filter {
+ private static final long serialVersionUID = 1L;
+ private Logger logger = Logger.getLogger(TuscanyServletFilter.class.getName());
+
+ private transient ServletContext context;
+ private transient ServletHost servletHost;
+
+ public TuscanyServletFilter() {
+ super();
+ }
+
+ public void init(final FilterConfig config) throws ServletException {
+ try {
+ context = config.getServletContext();
+ for (Enumeration<String> e = config.getInitParameterNames(); e.hasMoreElements();) {
+ String name = e.nextElement();
+ String value = config.getInitParameter(name);
+ context.setAttribute(name, value);
+ }
+ servletHost = ServletHostHelper.init(context);
+ } catch (Throwable e) {
+ logger.log(Level.SEVERE, e.getMessage(), e);
+ context.log(e.getMessage(), e);
+ throw new ServletException(e);
+ }
+ }
+
+ public void destroy() {
+ ServletHostHelper.stop(context);
+ servletHost = null;
+ }
+
+ public void doFilter(ServletRequest request, ServletResponse response, javax.servlet.FilterChain chain)
+ throws IOException, ServletException {
+ try {
+ // Get the Servlet path
+ HttpServletRequest httpRequest = (HttpServletRequest)request;
+ String path = httpRequest.getPathInfo();
+ if (path == null) {
+ path = httpRequest.getServletPath();
+ }
+ if (path == null) {
+ path = "/";
+ }
+
+ // Get a request dispatcher for the Servlet mapped to that path
+ RequestDispatcher dispatcher = servletHost.getRequestDispatcher(path);
+ if (dispatcher != null) {
+
+ // Let the dispatcher forward the request to the Servlet
+ dispatcher.forward(request, response);
+
+ } else {
+
+ // Proceed down the filter chain
+ chain.doFilter(request, response);
+
+ }
+ } catch (Throwable e) {
+ logger.log(Level.SEVERE, e.getMessage(), e);
+ context.log(e.getMessage(), e);
+ throw new ServletException(e);
+ }
+ }
+
+}
diff --git a/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/WebAppRequestDispatcher.java b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/WebAppRequestDispatcher.java
new file mode 100644
index 0000000000..76cce939ad
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/WebAppRequestDispatcher.java
@@ -0,0 +1,117 @@
+/*
+ * 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.host.webapp;
+
+import java.io.IOException;
+import java.util.StringTokenizer;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.Servlet;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletRequestWrapper;
+
+/**
+ * A Servlet request dispatcher that can be used to delegate requests to a
+ * Servlet registered with the Webapp Servlet host.
+ *
+ * @version $Rev$ $Date$
+ */
+class WebAppRequestDispatcher implements RequestDispatcher {
+ private String servletPath;
+ private Servlet servlet;
+
+ public WebAppRequestDispatcher(String mapping, Servlet servlet) {
+ if (mapping.endsWith("*")) {
+ mapping = mapping.substring(0, mapping.length()-1);
+ }
+ if (mapping.endsWith("/")) {
+ mapping = mapping.substring(0, mapping.length()-1);
+ }
+ this.servletPath = mapping;
+ this.servlet = servlet;
+ }
+
+ /**
+ * Returns a request wrapper which will return the correct Servlet path
+ * and path info.
+ *
+ * @param request
+ * @return
+ */
+ private HttpServletRequest createRequestWrapper(ServletRequest request) {
+ HttpServletRequest requestWrapper = new HttpServletRequestWrapper((HttpServletRequest)request) {
+
+ @Override
+ public String getServletPath() {
+ return servletPath;
+ }
+
+ @Override
+ public String getPathInfo() {
+ String path = super.getServletPath();
+ if (path.length() == 0) {
+ path = super.getPathInfo();
+ }
+
+ // TODO: another context path hack, revisit when context path is sorted out
+ path = fiddlePath(path, servletPath);
+
+ return path;
+ }
+ };
+ return requestWrapper;
+ }
+
+ /**
+ * Remove any path suffix thats part of the Servlet context path
+ */
+ protected String fiddlePath(String path, String servletPath) {
+ if (path.startsWith(servletPath)) {
+ return path.substring(servletPath.length());
+ }
+ StringTokenizer st = new StringTokenizer(path, "/");
+ if (st.countTokens() == 1) {
+ return path;
+ }
+ String root = "";
+ while (st.hasMoreTokens()){
+ String s = st.nextToken();
+ if (servletPath.endsWith((root + "/" + s))) {
+ root += "/" + s;
+ } else {
+ break;
+ }
+ }
+ String fiddlePath = path.substring(root.length());
+ return fiddlePath;
+ }
+
+ public void forward(ServletRequest request, ServletResponse response) throws ServletException, IOException {
+ servlet.service(createRequestWrapper(request), response);
+ }
+
+ public void include(ServletRequest request, ServletResponse response) throws ServletException, IOException {
+ servlet.service(createRequestWrapper(request), response);
+ }
+}
+
diff --git a/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/WebAppServletHost.java b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/WebAppServletHost.java
new file mode 100644
index 0000000000..4e32d8bcad
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/host-webapp/src/main/java/org/apache/tuscany/sca/host/webapp/WebAppServletHost.java
@@ -0,0 +1,312 @@
+/*
+ * 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.host.webapp;
+
+import java.lang.reflect.Method;
+import java.net.InetAddress;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Collections;
+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.ServletConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+
+import org.apache.tuscany.sca.host.http.ServletHost;
+import org.apache.tuscany.sca.host.http.ServletMappingException;
+import org.apache.tuscany.sca.node.Node;
+
+/**
+ * ServletHost implementation for use in a webapp environment.
+ *
+ * @version $Rev$ $Date$
+ */
+public class WebAppServletHost implements ServletHost {
+ private static final Logger logger = Logger.getLogger(WebAppServletHost.class.getName());
+
+ public static final String SCA_NODE_ATTRIBUTE = Node.class.getName();
+
+ private Map<String, Servlet> servlets;
+ private String contextPath = "/";
+ private int defaultPortNumber = 8080;
+ private String contributionRoot;
+
+ private ServletContext servletContext;
+ private Map<String, Object> tempAttributes = new HashMap<String, Object>();
+
+ public WebAppServletHost() {
+ servlets = new HashMap<String, Servlet>();
+ }
+
+ public void setDefaultPort(int port) {
+ defaultPortNumber = port;
+ }
+
+ public int getDefaultPort() {
+ return defaultPortNumber;
+ }
+
+ public String getName() {
+ return "webapp";
+ }
+
+ public void addServletMapping(String suri, Servlet servlet) throws ServletMappingException {
+ URI pathURI = URI.create(suri);
+
+ // Make sure that the path starts with a /
+ suri = pathURI.getPath();
+ if (!suri.startsWith("/")) {
+ suri = '/' + suri;
+ }
+
+ if (!suri.startsWith(contextPath)) {
+ suri = contextPath + suri;
+ }
+
+ // In a webapp just use the given path and ignore the host and port
+ // as they are fixed by the Web container
+ servlets.put(suri, servlet);
+
+ logger.info("Added Servlet mapping: " + suri);
+ }
+
+ public Servlet removeServletMapping(String suri) throws ServletMappingException {
+ URI pathURI = URI.create(suri);
+
+ // Make sure that the path starts with a /
+ suri = pathURI.getPath();
+ if (!suri.startsWith("/")) {
+ suri = '/' + suri;
+ }
+
+ if (!suri.startsWith(contextPath)) {
+ suri = contextPath + suri;
+ }
+
+ // In a webapp just use the given path and ignore the host and port
+ // as they are fixed by the Web container
+ return servlets.remove(suri);
+ }
+
+ public Servlet getServletMapping(String suri) throws ServletMappingException {
+ if (!suri.startsWith("/")) {
+ suri = '/' + suri;
+ }
+
+ if (!suri.startsWith(contextPath)) {
+ suri = contextPath + suri;
+ }
+
+ // Get the Servlet mapped to the given path
+ Servlet servlet = servlets.get(suri);
+ return servlet;
+ }
+
+ 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 = defaultPortNumber;
+ }
+
+ // 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 (contextPath != null && !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 RequestDispatcher getRequestDispatcher(String suri) throws ServletMappingException {
+
+ // Make sure that the path starts with a /
+ if (!suri.startsWith("/")) {
+ suri = '/' + suri;
+ }
+
+ if (contextPath != null && contextPath.length() > 0 && !"/".equals(contextPath)) {
+ suri = contextPath + suri;
+ }
+
+ // Get the Servlet mapped to the given path
+ Servlet servlet = servlets.get(suri);
+ if (servlet != null) {
+ return new WebAppRequestDispatcher(suri, servlet);
+ }
+
+ for (Map.Entry<String, Servlet> entry : servlets.entrySet()) {
+ String servletPath = entry.getKey();
+ if (servletPath.endsWith("*")) {
+ servletPath = servletPath.substring(0, servletPath.length() - 1);
+ if (suri.startsWith(servletPath)) {
+ // entry key is contextPath/servletPath, WebAppRequestDispatcher only wants servletPath
+ return new WebAppRequestDispatcher(entry.getKey().substring(contextPath.length()), entry.getValue());
+ } else {
+ if ((suri + "/").startsWith(servletPath)) {
+ return new WebAppRequestDispatcher(entry.getKey().substring(contextPath.length()), entry.getValue());
+ }
+ }
+ }
+ }
+
+ // No Servlet found
+ return null;
+ }
+
+ public void init(ServletConfig config) throws ServletException {
+
+ servletContext = config.getServletContext();
+
+ for (String name : tempAttributes.keySet()) {
+ servletContext.setAttribute(name, tempAttributes.get(name));
+ }
+
+ ServletHostHelper.init(servletContext);
+
+ initContextPath(config);
+
+ // Initialize the registered Servlets
+ for (Servlet servlet : servlets.values()) {
+ servlet.init(config);
+ }
+
+ }
+
+ /**
+ * Initializes the contextPath
+ * The 2.5 Servlet API has a getter for this, for pre 2.5 Servlet
+ * containers use an init parameter.
+ */
+ @SuppressWarnings("unchecked")
+ public void initContextPath(ServletConfig config) {
+
+ String oldContextPath = contextPath;
+
+ if (Collections.list(config.getInitParameterNames()).contains("contextPath")) {
+ contextPath = config.getInitParameter("contextPath");
+ } else {
+ // The getContextPath() is introduced since Servlet 2.5
+ ServletContext context = config.getServletContext();
+ try {
+ // Try to get the method anyway since some ServletContext impl has this method even before 2.5
+ Method m = context.getClass().getMethod("getContextPath", new Class[] {});
+ contextPath = (String)m.invoke(context, new Object[] {});
+ } catch (Exception e) {
+ logger.warning("Servlet level is: " + context.getMajorVersion() + "." + context.getMinorVersion());
+ throw new IllegalStateException("'contextPath' init parameter must be set for pre-2.5 servlet container");
+ }
+ }
+
+ logger.info("ContextPath: " + contextPath);
+
+ // if the context path changes after some servlets have been registered then
+ // need to reregister them (this can happen if extensions start before webapp init)
+ if (!oldContextPath.endsWith(contextPath)) {
+ List<String> oldServletURIs = new ArrayList<String>();
+ for (String oldServletURI : servlets.keySet()) {
+ if (oldServletURI.startsWith(oldContextPath)) {
+ if (!oldServletURI.startsWith(contextPath)) {
+ oldServletURIs.add(oldServletURI);
+ }
+ }
+ }
+ for (String oldURI : oldServletURIs) {
+ String ns = contextPath + "/" + oldURI.substring(oldContextPath.length());
+ servlets.put(ns, servlets.remove(oldURI));
+ }
+ }
+
+ }
+
+ void destroy() {
+
+ // Destroy the registered Servlets
+ for (Servlet servlet : servlets.values()) {
+ servlet.destroy();
+ }
+
+ // Close the SCA domain
+ ServletHostHelper.stop(servletContext);
+ }
+
+ public String getContextPath() {
+ return contextPath;
+ }
+
+ public void setContextPath(String path) {
+ }
+
+ /**
+ * TODO: How context paths work is still up in the air so for now
+ * this hacks in a path that gets some samples working
+ * can't use setContextPath as NodeImpl calls that later
+ */
+ public void setContextPath2(String path) {
+ if (path != null && path.length() > 0) {
+ this.contextPath = path;
+ }
+ }
+
+ public String getContributionRoot() {
+ return contributionRoot;
+ }
+
+ public void setAttribute(String name, Object value) {
+ if (servletContext != null) {
+ servletContext.setAttribute(name, value);
+ } else {
+ tempAttributes.put(name, value);
+ }
+ }
+}