Coverage Report - org.mule.transport.servlet.MuleReceiverServlet
 
Classes in this File Line Coverage Branch Coverage Complexity
MuleReceiverServlet
0%
0/127
0%
0/48
0
 
 1  
 /*
 2  
  * $Id: MuleReceiverServlet.java 20321 2010-11-24 15:21:24Z dfeist $
 3  
  * --------------------------------------------------------------------------------------
 4  
  * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
 5  
  *
 6  
  * The software in this package is published under the terms of the CPAL v1.0
 7  
  * license, a copy of which has been included with this distribution in the
 8  
  * LICENSE.txt file.
 9  
  */
 10  
 
 11  
 package org.mule.transport.servlet;
 12  
 
 13  
 import org.mule.api.MuleEvent;
 14  
 import org.mule.api.MuleException;
 15  
 import org.mule.api.MuleMessage;
 16  
 import org.mule.api.endpoint.EndpointException;
 17  
 import org.mule.api.endpoint.EndpointURI;
 18  
 import org.mule.api.endpoint.InboundEndpoint;
 19  
 import org.mule.api.lifecycle.InitialisationException;
 20  
 import org.mule.api.transport.MessageReceiver;
 21  
 import org.mule.api.transport.NoReceiverForEndpointException;
 22  
 import org.mule.api.transport.PropertyScope;
 23  
 import org.mule.endpoint.DynamicURIInboundEndpoint;
 24  
 import org.mule.endpoint.MuleEndpointURI;
 25  
 import org.mule.routing.filters.WildcardFilter;
 26  
 import org.mule.transport.http.HttpConnector;
 27  
 import org.mule.transport.http.HttpMessageReceiver;
 28  
 import org.mule.transport.http.i18n.HttpMessages;
 29  
 import org.mule.transport.service.TransportFactory;
 30  
 import org.mule.transport.servlet.i18n.ServletMessages;
 31  
 import org.mule.util.PropertiesUtils;
 32  
 
 33  
 import java.io.IOException;
 34  
 import java.util.Map;
 35  
 import java.util.Properties;
 36  
 
 37  
 import javax.servlet.ServletException;
 38  
 import javax.servlet.http.HttpServletRequest;
 39  
 import javax.servlet.http.HttpServletResponse;
 40  
 
 41  
 /**
 42  
  * Receives Http requests via a Servlet and routes them to listeners with servlet://
 43  
  * endpoints
 44  
  * <p/>
 45  
  */
 46  0
 public class MuleReceiverServlet extends AbstractReceiverServlet
 47  
 {
 48  
     /**
 49  
      * Serial version
 50  
      */
 51  
     private static final long serialVersionUID = 6631307373079767439L;
 52  
 
 53  0
     protected ServletConnector connector = null;
 54  
     
 55  0
     private boolean useCachedHttpServletRequest = false;
 56  
 
 57  
     @Override
 58  
     protected void doInit() throws ServletException
 59  
     {
 60  0
         connector = getOrCreateServletConnector(getServletConfig().getInitParameter(SERVLET_CONNECTOR_NAME_PROPERTY));
 61  0
     }
 62  
 
 63  
     protected ServletConnector getOrCreateServletConnector(String name) throws ServletException
 64  
     {
 65  
         ServletConnector servletConnector;
 66  0
         if (name == null)
 67  
         {
 68  0
             servletConnector = (ServletConnector) new TransportFactory(muleContext).getConnectorByProtocol("servlet");
 69  0
             if (servletConnector == null)
 70  
             {
 71  0
                 servletConnector = new ServletConnector(muleContext);
 72  0
                 servletConnector.setName("_generatedServletConnector");
 73  
                 try
 74  
                 {
 75  0
                     muleContext.getRegistry().registerConnector(servletConnector);
 76  
                 }
 77  0
                 catch (MuleException e)
 78  
                 {
 79  0
                     throw new ServletException("Failed to register the ServletConnector", e);
 80  0
                 }
 81  
             }
 82  
         }
 83  
         else
 84  
         {
 85  0
             servletConnector = (ServletConnector) muleContext.getRegistry().lookupConnector(name);
 86  0
             if (servletConnector == null)
 87  
             {
 88  0
                 throw new ServletException(ServletMessages.noServletConnectorFound(name).toString());
 89  
             }
 90  
         }
 91  0
         this.useCachedHttpServletRequest = servletConnector.isUseCachedHttpServletRequest();
 92  0
         return servletConnector;
 93  
     }
 94  
 
 95  
     protected void setupRequestMessage(HttpServletRequest request,
 96  
                                        MuleMessage requestMessage,
 97  
                                        MessageReceiver receiver)
 98  
     {
 99  
 
 100  0
         EndpointURI uri = receiver.getEndpointURI();
 101  0
         String reqUri = request.getRequestURI();
 102  0
         requestMessage.setProperty(HttpConnector.HTTP_REQUEST_PATH_PROPERTY, reqUri, PropertyScope.INBOUND);
 103  
 
 104  0
         String queryString = request.getQueryString();
 105  0
         if (queryString != null)
 106  
         {
 107  0
             reqUri += "?" + queryString;
 108  
         }
 109  
 
 110  0
         requestMessage.setProperty(HttpConnector.HTTP_REQUEST_PROPERTY, reqUri, PropertyScope.INBOUND);
 111  
 
 112  
         String path;
 113  0
         if ("servlet".equals(uri.getScheme()))
 114  
         {
 115  0
             path = HttpConnector.normalizeUrl(request.getContextPath());
 116  0
             if ("/".equals(path))
 117  
             {
 118  0
                 path = HttpConnector.normalizeUrl(request.getServletPath());
 119  
             }
 120  
             else
 121  
             {
 122  0
                 path = path + HttpConnector.normalizeUrl(request.getServletPath());
 123  
             }
 124  
 
 125  0
             String pathPart2 = uri.getAddress();
 126  
 
 127  0
             if (!path.endsWith("/"))
 128  
             {
 129  
                 // "/foo" + "bar"
 130  0
                 path = path + HttpConnector.normalizeUrl(pathPart2);
 131  
             }
 132  0
             else if (pathPart2.startsWith("/"))
 133  
             {
 134  
                 // "/foo/" + "/bar"
 135  0
                 path = path + pathPart2.substring(1);
 136  
             }
 137  
             else
 138  
             {
 139  
                 // "/foo/" + "bar"
 140  0
                 path = path + pathPart2;
 141  
             }
 142  0
         }
 143  
         else
 144  
         {
 145  
             // The Jetty transport has normal paths
 146  0
             path = HttpConnector.normalizeUrl(uri.getPath());
 147  
         }
 148  
 
 149  0
         requestMessage.setProperty(HttpConnector.HTTP_CONTEXT_PATH_PROPERTY, path, PropertyScope.INBOUND);
 150  
 
 151  
         // Call this to keep API compatability
 152  0
         setupRequestMessage(request, requestMessage);
 153  0
     }
 154  
 
 155  
 
 156  
     protected void setupRequestMessage(HttpServletRequest request, MuleMessage requestMessage)
 157  
     {
 158  
         // template method
 159  0
     }
 160  
     
 161  
     // We cannot override the service method and maintain MuleRESTServletReceiver
 162  
     // functionality. See MULE-4806.
 163  
     
 164  
     @Override
 165  
     protected void doGet(HttpServletRequest req, HttpServletResponse resp)
 166  
         throws ServletException, IOException
 167  
     {
 168  0
         doAllMethods(req, resp);
 169  0
     }
 170  
     
 171  
     @Override
 172  
     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
 173  
         throws ServletException, IOException
 174  
     {
 175  0
         doAllMethods(req, resp);
 176  0
     }
 177  
     
 178  
     @Override
 179  
     protected void doHead(HttpServletRequest req, HttpServletResponse resp)
 180  
         throws ServletException, IOException
 181  
     {
 182  0
         doAllMethods(req, resp);
 183  0
     }
 184  
     @Override
 185  
     protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
 186  
         throws ServletException, IOException
 187  
     {
 188  0
         doAllMethods(req, resp);
 189  0
     }
 190  
 
 191  
     @Override
 192  
     protected void doPut(HttpServletRequest req, HttpServletResponse resp)
 193  
         throws ServletException, IOException
 194  
     {
 195  0
         doAllMethods(req, resp);
 196  0
     }
 197  
     @Override
 198  
     protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
 199  
         throws ServletException, IOException
 200  
     {
 201  0
         doAllMethods(req, resp);
 202  0
     }
 203  
     @Override
 204  
     protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
 205  
         throws ServletException, IOException
 206  
     {
 207  0
         doAllMethods(req, resp);
 208  0
     }
 209  
 
 210  
     protected void doAllMethods(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
 211  
     {
 212  
         try
 213  
         {
 214  0
                 if (this.useCachedHttpServletRequest)
 215  
             {
 216  0
                 request = new CachedHttpServletRequest(request);
 217  
             }
 218  0
             MessageReceiver receiver = getReceiverForURI(request);
 219  
             
 220  0
             MuleMessage requestMessage = receiver.createMuleMessage(request);
 221  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, request.getMethod(), PropertyScope.INBOUND);
 222  
 
 223  0
             setupRequestMessage(request, requestMessage, receiver);
 224  
 
 225  0
             MuleEvent event = routeMessage(receiver, requestMessage, request);
 226  0
             MuleMessage result = event == null ? null : event.getMessage();
 227  0
             writeResponse(response, result);
 228  
         }
 229  0
         catch (Exception e)
 230  
         {
 231  0
             handleException(e, ServletMessages.failedToProcessRequest().getMessage(), response);
 232  0
         }
 233  0
     }
 234  
 
 235  
     protected MuleEvent routeMessage(MessageReceiver receiver, MuleMessage requestMessage, HttpServletRequest request)
 236  
             throws MuleException
 237  
     {
 238  0
         return receiver.routeMessage(requestMessage);
 239  
     }
 240  
 
 241  
     protected MessageReceiver getReceiverForURI(HttpServletRequest httpServletRequest)
 242  
             throws EndpointException
 243  
     {
 244  0
         String uri = getReceiverName(httpServletRequest);
 245  0
         if (uri == null)
 246  
         {
 247  0
             throw new EndpointException(
 248  
                     HttpMessages.unableToGetEndpointUri(httpServletRequest.getRequestURI()));
 249  
         }
 250  
 
 251  0
         MessageReceiver receiver = getReceivers().get(uri);
 252  
 
 253  
         // Lets see if the uri matches up with the last part of
 254  
         // any of the receiver keys.
 255  0
         if (receiver == null)
 256  
         {
 257  0
             receiver = HttpMessageReceiver.findReceiverByStem(connector.getReceivers(), uri);
 258  
         }
 259  
 
 260  0
         if (receiver == null)
 261  
         {
 262  0
             receiver = matchReceiverByWildcard(uri, receiver);
 263  
         }
 264  
 
 265  0
         if (receiver == null)
 266  
         {
 267  0
             throw new NoReceiverForEndpointException(uri);
 268  
         }
 269  
 
 270  0
         InboundEndpoint endpoint = receiver.getEndpoint();
 271  
 
 272  
         // Ensure that this receiver is using a dynamic (mutable) endpoint
 273  0
         if (!(endpoint instanceof DynamicURIInboundEndpoint))
 274  
         {
 275  0
             endpoint = new DynamicURIInboundEndpoint(receiver.getEndpoint());
 276  0
             receiver.setEndpoint(endpoint);
 277  
         }
 278  
 
 279  
         // Tell the dynamic endpoint about our new URL
 280  
         //Note we don't use the servlet: prefix since we need to be dealing with the raw endpoint here
 281  0
         EndpointURI epURI = new MuleEndpointURI(getRequestUrl(httpServletRequest), muleContext);
 282  
 
 283  
         try
 284  
         {
 285  0
             epURI.initialise();
 286  0
             epURI.getParams().setProperty("servlet.endpoint", "true");
 287  0
             ((DynamicURIInboundEndpoint) endpoint).setEndpointURI(epURI);
 288  
         }
 289  0
         catch (InitialisationException e)
 290  
         {
 291  0
             throw new EndpointException(e);
 292  0
         }
 293  0
         return receiver;
 294  
     }
 295  
 
 296  
     protected MessageReceiver matchReceiverByWildcard(String uri, MessageReceiver receiver)
 297  
     {
 298  
         // Now match wild cards
 299  0
         for (Object key : getReceivers().keySet())
 300  
         {
 301  0
             if (new WildcardFilter(key.toString()).accept(uri))
 302  
             {
 303  0
                 receiver = connector.getReceivers().get(key);
 304  0
                 break;
 305  
             }
 306  
         }
 307  0
         return receiver;
 308  
     }
 309  
 
 310  
     protected String getRequestUrl(HttpServletRequest httpServletRequest)
 311  
     {
 312  0
         StringBuffer url = new StringBuffer();
 313  
 
 314  0
         url.append(httpServletRequest.getScheme());
 315  0
         url.append("://");
 316  0
         url.append(httpServletRequest.getServerName());
 317  0
         url.append(":");
 318  0
         url.append(httpServletRequest.getServerPort());
 319  0
         url.append(httpServletRequest.getServletPath());
 320  
         
 321  0
         String pathInfo = httpServletRequest.getPathInfo();
 322  0
         if (pathInfo != null)
 323  
         {
 324  0
             url.append(pathInfo);
 325  
         }
 326  
         
 327  0
         String queryString = httpServletRequest.getQueryString();
 328  0
         if (queryString != null)
 329  
         {
 330  0
             url.append("?");
 331  0
             url.append(queryString);
 332  
         }
 333  0
         return url.toString();
 334  
     }
 335  
 
 336  
     protected String getReceiverName(HttpServletRequest httpServletRequest)
 337  
     {
 338  0
         String name = httpServletRequest.getPathInfo();
 339  0
         if (name == null)
 340  
         {
 341  0
             name = httpServletRequest.getServletPath();
 342  0
             if (name == null)
 343  
             {
 344  0
                 name = httpServletRequest.getParameter("endpoint");
 345  0
                 if (name == null)
 346  
                 {
 347  0
                     Properties params = PropertiesUtils.getPropertiesFromQueryString(httpServletRequest.getQueryString());
 348  0
                     name = params.getProperty("endpoint");
 349  0
                     if (name == null)
 350  
                     {
 351  0
                         return null;
 352  
                     }
 353  
                 }
 354  
             }
 355  
         }
 356  
 
 357  0
         if (name.startsWith("/"))
 358  
         {
 359  0
             name = name.substring(1);
 360  
         }
 361  0
         return name;
 362  
     }
 363  
 
 364  
     protected Map<Object, MessageReceiver> getReceivers()
 365  
     {
 366  0
         return connector.getReceivers();
 367  
     }
 368  
 }