Moving 2.x trunk

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@882795 13f79535-47bb-0310-9956-ffa450edef68

3 files changed, 534 insertions, 0 deletions

diff --git a/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/HttpServiceWrapper.java b/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/HttpServiceWrapper.java
new file mode 100644
index 0000000000..3cfca3e6c8
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/HttpServiceWrapper.java
@@ -0,0 +1,145 @@
+/*
+ * 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.osgi;
+
+import javax.servlet.Servlet;
+
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.InvalidSyntaxException;
+import org.osgi.framework.ServiceEvent;
+import org.osgi.framework.ServiceListener;
+import org.osgi.framework.ServiceReference;
+import org.osgi.service.http.HttpService;
+import org.osgi.util.tracker.ServiceTracker;
+
+/**
+ * A whiteboard for HttpService and Servlet
+ */
+public class HttpServiceWrapper {
+
+    static final String SERVLET_URI = "servlet.uri";
+    private ServiceTracker httpTracker;
+    private BundleContext bc;
+
+    private class HttpServiceTracker extends ServiceTracker {
+        private HttpServiceTracker() {
+            super(bc, HttpService.class.getName(), null);
+        }
+
+        @Override
+        public Object addingService(ServiceReference reference) {
+            HttpService httpService = (HttpService)super.addingService(reference);
+            // Register existing servlets
+            String filter = "(objectclass=" + Servlet.class.getName() + ")";
+            ServiceReference[] servlets = null;
+            try {
+                servlets = bc.getServiceReferences(null, filter);
+            } catch (InvalidSyntaxException e) {
+                throw new IllegalStateException(e);
+            }
+            for (int i = 0; servlets != null && i < servlets.length; i++) {
+                Servlet servlet = (Servlet)bc.getService(servlets[i]);
+                String alias = (String)servlets[i].getProperty(SERVLET_URI);
+
+                try {
+                    httpService.registerServlet(alias, servlet, null, null);
+                } catch (Exception e) {
+                    throw new IllegalStateException(e);
+                }
+            }
+            return httpService;
+        }
+    }
+
+    public HttpServiceWrapper(BundleContext bc) {
+        super();
+        this.bc = bc;
+    }
+
+    void open() {
+        httpTracker = new HttpServiceTracker();
+        httpTracker.open();
+
+        ServiceListener sl = new ServiceListener() {
+            public void serviceChanged(ServiceEvent ev) {
+                ServiceReference sr = ev.getServiceReference();
+                switch (ev.getType()) {
+                    case ServiceEvent.REGISTERED: {
+                        registerServlet(sr);
+                    }
+                        break;
+                    case ServiceEvent.UNREGISTERING: {
+                        unregisterServlet(sr);
+                    }
+                        break;
+                }
+            }
+        };
+
+        String filter = "(objectclass=" + Servlet.class.getName() + ")";
+        try {
+            bc.addServiceListener(sl, filter);
+            ServiceReference[] servlets = bc.getServiceReferences(null, filter);
+            for (int i = 0; servlets != null && i < servlets.length; i++) {
+                sl.serviceChanged(new ServiceEvent(ServiceEvent.REGISTERED, servlets[i]));
+            }
+        } catch (InvalidSyntaxException e) {
+            e.printStackTrace();
+        }
+    }
+
+    void close() {
+        if (httpTracker != null) {
+            httpTracker.close();
+        }
+    }
+
+    void registerServlet(ServiceReference sr) {
+        Servlet servlet = (Servlet)bc.getService(sr);
+        String alias = (String)sr.getProperty(SERVLET_URI);
+
+        Object[] httpServices = httpTracker.getServices();
+
+        for (int i = 0; httpServices != null && i < httpServices.length; i++) {
+            HttpService http = (HttpService)httpServices[i];
+            try {
+                http.registerServlet(alias, servlet, null, null);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+        }
+    }
+
+    void unregisterServlet(ServiceReference sr) {
+        String alias = (String)sr.getProperty(SERVLET_URI);
+        Object[] httpServices = httpTracker.getServices();
+
+        for (int i = 0; httpServices != null && i < httpServices.length; i++) {
+            HttpService http = (HttpService)httpServices[i];
+            try {
+                http.unregister(alias);
+            } catch (Exception e) {
+                throw new IllegalStateException(e);
+            }
+            bc.ungetService(sr);
+        }
+    }
+
+}
diff --git a/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/OSGiServletHost.java b/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/OSGiServletHost.java
new file mode 100644
index 0000000000..db77162b41
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/OSGiServletHost.java
@@ -0,0 +1,275 @@
+/*
+ * 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.osgi;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.InetAddress;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.net.UnknownHostException;
+import java.util.Dictionary;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.Servlet;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServlet;
+
+import org.apache.tuscany.sca.host.http.ServletHost;
+import org.apache.tuscany.sca.host.http.ServletMappingException;
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceRegistration;
+
+/**
+ *
+ */
+public class OSGiServletHost implements ServletHost, BundleActivator {
+    static final String DUMMY_URI = "/_tuscany";
+
+    /**
+     * Default servlet
+     */
+    private static class DefaultServlet extends HttpServlet {
+
+        @Override
+        public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
+            PrintWriter pw = response.getWriter();
+            pw.println("<html><body><h1>Apache Tuscany</h1></body></html>");
+            pw.flush();
+        }
+    }
+
+    private Map<String, Servlet> servlets = new ConcurrentHashMap<String, Servlet>();
+
+    private static final Logger logger = Logger.getLogger(OSGiServletHost.class.getName());
+
+    private String contextPath = "/";
+    private int defaultPortNumber = 8080;
+
+    private ServletContext servletContext;
+    private Map<String, Object> attributes = new HashMap<String, Object>();
+    private HttpServiceWrapper wrapper;
+
+    private static BundleContext bundleContext;
+
+    public void start(BundleContext context) {
+        bundleContext = context;
+        wrapper = new HttpServiceWrapper(bundleContext);
+        wrapper.open();
+
+        HttpServlet defaultServlet = new DefaultServlet();
+        addServletMapping(DUMMY_URI, defaultServlet);
+        // this.servletContext = defaultServlet.getServletContext();
+    }
+
+    public void stop(BundleContext bundleContext) {
+        removeServletMapping(DUMMY_URI);
+        wrapper.close();
+    }
+
+    public void setDefaultPort(int port) {
+        defaultPortNumber = port;
+    }
+
+    public int getDefaultPort() {
+        return defaultPortNumber;
+    }
+
+    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
+        try {
+            Dictionary<String, Object> props = new Hashtable<String, Object>();
+            props.put(HttpServiceWrapper.SERVLET_URI, suri);
+            ServiceRegistration reg = bundleContext.registerService(Servlet.class.getName(), servlet, props);
+            servlets.put(suri, servlet);
+        } catch (Exception e) {
+            throw new ServletMappingException(e);
+        }
+
+        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
+        try {
+            return servlets.remove(suri);
+        } catch (Exception e) {
+            throw new ServletMappingException(e);
+        }
+
+    }
+
+    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;
+        }
+
+        suri = contextPath + suri;
+
+        // Get the Servlet mapped to the given path
+        Servlet servlet = servlets.get(suri);
+        if (servlet != null) {
+            return new ServletRequestDispatcher(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 ServletRequestDispatcher(entry.getKey().substring(contextPath.length()), entry
+                        .getValue());
+                } else {
+                    if ((suri + "/").startsWith(servletPath)) {
+                        return new ServletRequestDispatcher(entry.getKey().substring(contextPath.length()), entry
+                            .getValue());
+                    }
+                }
+            }
+        }
+
+        // No Servlet found
+        return null;
+    }
+
+    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 void setAttribute(String name, Object value) {
+        if (servletContext != null) {
+            servletContext.setAttribute(name, value);
+        } else {
+            attributes.put(name, value);
+        }
+    }
+
+    public String getName() {
+        return "osgi";
+    }
+
+}
diff --git a/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/ServletRequestDispatcher.java b/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/ServletRequestDispatcher.java
new file mode 100644
index 0000000000..789deeb94e
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/host-http-osgi/src/main/java/org/apache/tuscany/sca/http/osgi/ServletRequestDispatcher.java
@@ -0,0 +1,114 @@
+/*
+ * 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.osgi;
+
+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 ServletRequestDispatcher implements RequestDispatcher {
+    private String servletPath;
+    private Servlet servlet;
+    
+    public ServletRequestDispatcher(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) {
+        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);
+    }
+}
+