Coverage Report - org.mule.providers.http.servlet.MuleReceiverServlet
 
Classes in this File Line Coverage Branch Coverage Complexity
MuleReceiverServlet
28%
44/157
18%
9/50
3.714
 
 1  
 /*
 2  
  * $Id: MuleReceiverServlet.java 8288 2007-09-07 19:56:42Z aperepel $
 3  
  * --------------------------------------------------------------------------------------
 4  
  * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.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.providers.http.servlet;
 12  
 
 13  
 import org.mule.MuleManager;
 14  
 import org.mule.impl.MuleMessage;
 15  
 import org.mule.impl.endpoint.MuleEndpointURI;
 16  
 import org.mule.providers.AbstractMessageReceiver;
 17  
 import org.mule.providers.http.HttpConnector;
 18  
 import org.mule.providers.http.HttpConstants;
 19  
 import org.mule.providers.http.HttpMessageReceiver;
 20  
 import org.mule.providers.http.i18n.HttpMessages;
 21  
 import org.mule.providers.service.TransportFactory;
 22  
 import org.mule.umo.UMOMessage;
 23  
 import org.mule.umo.endpoint.EndpointException;
 24  
 import org.mule.umo.provider.NoReceiverForEndpointException;
 25  
 import org.mule.umo.provider.UMOMessageReceiver;
 26  
 import org.mule.util.PropertiesUtils;
 27  
 
 28  
 import java.io.IOException;
 29  
 import java.util.Iterator;
 30  
 import java.util.Map;
 31  
 import java.util.Properties;
 32  
 
 33  
 import javax.servlet.ServletConfig;
 34  
 import javax.servlet.ServletException;
 35  
 import javax.servlet.http.HttpServletRequest;
 36  
 import javax.servlet.http.HttpServletResponse;
 37  
 
 38  
 /**
 39  
  * Receives Http requests via a Servlet and routes the to listeners with servlet://
 40  
  * endpoints
 41  
  *
 42  
  * There needs to be a ServletConnector configured on the Mule Server, this connector
 43  
  * must have the servletUrl property set that matches the Url for the container that this
 44  
  * Servlet is hosted in, i.e. something like http://192.168.10.21:8888
 45  
  */
 46  
 
 47  6
 public class MuleReceiverServlet extends AbstractReceiverServlet
 48  
 {
 49  
     /**
 50  
      * Serial version
 51  
      */
 52  
     private static final long serialVersionUID = 6631307373079767439L;
 53  
 
 54  6
     protected ServletConnector connector = null;
 55  
 
 56  
     protected void doInit(ServletConfig servletConfig) throws ServletException
 57  
     {
 58  2
         String servletConnectorName = servletConfig.getInitParameter(SERVLET_CONNECTOR_NAME_PROPERTY);
 59  2
         if(servletConnectorName==null)
 60  
         {
 61  2
             connector = (ServletConnector) TransportFactory.getConnectorByProtocol("servlet");
 62  2
             if (connector == null)
 63  
             {
 64  0
                 throw new ServletException(HttpMessages.noConnectorForProtocolServlet().toString());
 65  
             }
 66  
         }
 67  
         else
 68  
         {
 69  0
             connector = (ServletConnector)MuleManager.getInstance().lookupConnector(servletConnectorName);
 70  0
             if (connector == null)
 71  
             {
 72  0
                 throw new ServletException(
 73  
                     HttpMessages.noServletConnectorFound(servletConnectorName).toString());
 74  
             }
 75  
         }
 76  
 
 77  
 
 78  2
     }
 79  
 
 80  
     protected void doHead(HttpServletRequest request, HttpServletResponse response)
 81  
         throws ServletException, IOException
 82  
     {
 83  
         try
 84  
         {
 85  0
             UMOMessageReceiver receiver = getReceiverForURI(request);
 86  0
             UMOMessage responseMessage = null;
 87  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 88  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "HEAD");
 89  0
             setupRequestMessage(request, requestMessage);
 90  0
             receiver.routeMessage(requestMessage, true);
 91  0
             if (responseMessage != null)
 92  
             {
 93  0
                 writeResponse(response, responseMessage);
 94  
             }
 95  
             else 
 96  
             {
 97  0
                 response.setStatus(HttpConstants.SC_OK);
 98  
             }
 99  
         }
 100  0
         catch (Exception e)
 101  
         {
 102  0
             handleException(e, e.getMessage(), response);
 103  0
         }
 104  0
     }
 105  
     
 106  
     protected void doGet(HttpServletRequest request, HttpServletResponse response)
 107  
         throws ServletException, IOException
 108  
     {
 109  
         try
 110  
         {
 111  0
             UMOMessageReceiver receiver = getReceiverForURI(request);
 112  
             UMOMessage responseMessage;
 113  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 114  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "GET");
 115  0
             setupRequestMessage(request, requestMessage);
 116  0
             responseMessage = receiver.routeMessage(requestMessage, true);
 117  0
             writeResponse(response, responseMessage);
 118  
         }
 119  0
         catch (Exception e)
 120  
         {
 121  0
             handleException(e, e.getMessage(), response);
 122  0
         }
 123  0
     }
 124  
 
 125  
     private void setupRequestMessage(HttpServletRequest request, UMOMessage requestMessage)
 126  
     {
 127  6
         requestMessage.setProperty(HttpConnector.HTTP_REQUEST_PROPERTY, request.getRequestURI());
 128  6
     }
 129  
 
 130  
     protected void doPost(HttpServletRequest request, HttpServletResponse response)
 131  
         throws ServletException, IOException
 132  
     {
 133  
         try
 134  
         {
 135  6
             UMOMessageReceiver receiver = getReceiverForURI(request);
 136  
             UMOMessage responseMessage;
 137  6
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 138  6
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "POST");
 139  6
             setupRequestMessage(request, requestMessage);
 140  6
             responseMessage = receiver.routeMessage(requestMessage, true);
 141  6
             if (responseMessage != null)
 142  
             {
 143  6
                 writeResponse(response, responseMessage);
 144  
             }
 145  
         }
 146  0
         catch (Exception e)
 147  
         {
 148  0
             handleException(e, e.getMessage(), response);
 149  6
         }
 150  6
     }
 151  
 
 152  
     protected void doOptions(HttpServletRequest request, HttpServletResponse response)
 153  
         throws ServletException, IOException
 154  
     {
 155  
         try
 156  
         {
 157  0
             UMOMessageReceiver receiver = getReceiverForURI(request);
 158  
             UMOMessage responseMessage;
 159  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 160  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "OPTIONS");
 161  0
             setupRequestMessage(request, requestMessage);
 162  0
             responseMessage = receiver.routeMessage(requestMessage, true);
 163  0
             if (responseMessage != null)
 164  
             {
 165  0
                 writeResponse(response, responseMessage);
 166  
             }
 167  
         }
 168  0
         catch (Exception e)
 169  
         {
 170  0
             handleException(e, e.getMessage(), response);
 171  0
         }
 172  0
     }
 173  
 
 174  
     protected void doPut(HttpServletRequest request, HttpServletResponse response)
 175  
         throws ServletException, IOException
 176  
     {
 177  
         try
 178  
         {
 179  0
             UMOMessageReceiver receiver = getReceiverForURI(request);
 180  
             UMOMessage responseMessage;
 181  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 182  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "PUT");
 183  0
             setupRequestMessage(request, requestMessage);
 184  0
             responseMessage = receiver.routeMessage(requestMessage, true);
 185  0
             if (responseMessage != null)
 186  
             {
 187  0
                 writeResponse(response, responseMessage);
 188  
             }
 189  
         }
 190  0
         catch (Exception e)
 191  
         {
 192  0
             handleException(e, e.getMessage(), response);
 193  0
         }
 194  0
     }
 195  
 
 196  
     protected void doDelete(HttpServletRequest request, HttpServletResponse response)
 197  
         throws ServletException, IOException
 198  
     {
 199  
         try
 200  
         {
 201  0
             UMOMessageReceiver receiver = getReceiverForURI(request);
 202  
             UMOMessage responseMessage;
 203  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 204  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "DELETE");
 205  0
             setupRequestMessage(request, requestMessage);
 206  0
             responseMessage = receiver.routeMessage(requestMessage, true);
 207  0
             if (responseMessage != null)
 208  
             {
 209  0
                 writeResponse(response, responseMessage);
 210  
             }
 211  
         }
 212  0
         catch (Exception e)
 213  
         {
 214  0
             handleException(e, e.getMessage(), response);
 215  0
         }
 216  0
     }
 217  
 
 218  
     protected void doTrace(HttpServletRequest request, HttpServletResponse response)
 219  
         throws ServletException, IOException
 220  
     {
 221  
         try
 222  
         {
 223  0
             UMOMessageReceiver receiver = getReceiverForURI(request);
 224  
             UMOMessage responseMessage;
 225  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 226  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "TRACE");
 227  0
             setupRequestMessage(request, requestMessage);
 228  0
             responseMessage = receiver.routeMessage(requestMessage, true);
 229  0
             if (responseMessage != null)
 230  
             {
 231  0
                 writeResponse(response, responseMessage);
 232  
             }
 233  
         }
 234  0
         catch (Exception e)
 235  
         {
 236  0
             handleException(e, e.getMessage(), response);
 237  0
         }
 238  0
     }
 239  
 
 240  
     protected void doConnect(HttpServletRequest request, HttpServletResponse response)
 241  
         throws ServletException, IOException
 242  
     {
 243  
         try
 244  
         {
 245  0
             UMOMessageReceiver receiver = getReceiverForURI(request);
 246  
             UMOMessage responseMessage;
 247  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 248  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "CONNECT");
 249  0
             setupRequestMessage(request, requestMessage);
 250  0
             responseMessage = receiver.routeMessage(requestMessage, true);
 251  0
             if (responseMessage != null)
 252  
             {
 253  0
                 writeResponse(response, responseMessage);
 254  
             }
 255  
         }
 256  0
         catch (Exception e)
 257  
         {
 258  0
             handleException(e, e.getMessage(), response);
 259  0
         }
 260  0
     }
 261  
 
 262  
     protected UMOMessageReceiver getReceiverForURI(HttpServletRequest httpServletRequest)
 263  
         throws EndpointException
 264  
     {
 265  2
         String uri = getReceiverName(httpServletRequest);
 266  2
         if (uri == null)
 267  
         {
 268  0
             throw new EndpointException(
 269  
                 HttpMessages.unableToGetEndpointUri(httpServletRequest.getRequestURI()));
 270  
         }
 271  
 
 272  2
         UMOMessageReceiver receiver = (UMOMessageReceiver)getReceivers().get(uri);
 273  
 
 274  2
         if (receiver == null)
 275  
         {
 276  
             // Nothing found lets try stripping the path and only use the last
 277  
             // path element
 278  0
             int i = uri.lastIndexOf("/");
 279  0
             if (i > -1)
 280  
             {
 281  0
                 String tempUri = uri.substring(i + 1);
 282  0
                 receiver = (AbstractMessageReceiver)getReceivers().get(tempUri);
 283  
             }
 284  
 
 285  
             // Lets see if the uri matches up with the last part of
 286  
             // any of the receiver keys.
 287  0
             if (receiver == null) 
 288  
             {
 289  0
                 receiver = HttpMessageReceiver.findReceiverByStem(connector.getReceivers(), uri);
 290  
             }
 291  
             
 292  
             // This is some bizarre piece of code so the XFire Servlet code works.
 293  
             // We should remove this at some point (see XFireWsdlCallTestCase for a failure
 294  
             // if this code is removed).
 295  0
             if (receiver == null)
 296  
             {
 297  0
                 Map receivers = getReceivers();
 298  0
                 Iterator iter = receivers.keySet().iterator();
 299  0
                 while (iter.hasNext())
 300  
                 {
 301  0
                     String key = iter.next().toString();
 302  0
                     i = key.lastIndexOf("/");
 303  0
                     if (i > -1)
 304  
                     {
 305  0
                         String key2 = key.substring(i+1);
 306  0
                         if (key2.equals(uri))
 307  
                         {
 308  0
                             receiver = (AbstractMessageReceiver)receivers.get(key);
 309  0
                             break;
 310  
                         }
 311  
                     }
 312  0
                 }
 313  
             }
 314  
             
 315  0
             if (receiver == null)
 316  
             {
 317  0
                 throw new NoReceiverForEndpointException("No receiver found for endpointUri: " + uri);
 318  
             }
 319  
         }
 320  2
         receiver.getEndpoint().setEndpointURI(new MuleEndpointURI(getRequestUrl(httpServletRequest)));
 321  2
         return receiver;
 322  
     }
 323  
 
 324  
     protected String getRequestUrl(HttpServletRequest httpServletRequest)
 325  
     {
 326  2
         StringBuffer url = new StringBuffer();
 327  2
         url.append(connector.getProtocol().toLowerCase());
 328  2
         url.append(":");
 329  2
         url.append(httpServletRequest.getScheme());
 330  2
         url.append("://");
 331  2
         url.append(httpServletRequest.getServerName());
 332  2
         url.append(":");
 333  2
         url.append(httpServletRequest.getServerPort());
 334  2
         url.append("/");
 335  2
         url.append(getReceiverName(httpServletRequest));
 336  2
         if (httpServletRequest.getQueryString() != null)
 337  
         {
 338  0
             url.append("?");
 339  0
             url.append(httpServletRequest.getQueryString());
 340  
         }
 341  2
         return url.toString();
 342  
     }
 343  
 
 344  
     protected String getReceiverName(HttpServletRequest httpServletRequest)
 345  
     {
 346  4
         String name = httpServletRequest.getPathInfo();
 347  4
         if (name == null)
 348  
         {
 349  4
             name = httpServletRequest.getServletPath();
 350  4
             if (name == null)
 351  
             {
 352  0
                 name = httpServletRequest.getParameter("endpoint");
 353  0
                 if (name == null)
 354  
                 {
 355  0
                     Properties params = PropertiesUtils.getPropertiesFromQueryString(httpServletRequest.getQueryString());
 356  0
                     name = params.getProperty("endpoint");
 357  0
                     if (name == null)
 358  
                     {
 359  0
                         return null;
 360  
                     }
 361  
                 }
 362  
             }
 363  
         }
 364  
         
 365  4
         if (name.startsWith("/"))
 366  
         {
 367  4
             name = name.substring(1);
 368  
         }
 369  4
         return name;
 370  
     }
 371  
 
 372  
     protected Map getReceivers()
 373  
     {
 374  2
         return connector.getReceivers();
 375  
     }
 376  
 }