Coverage Report - org.mule.providers.http.servlet.MuleReceiverServlet
 
Classes in this File Line Coverage Branch Coverage Complexity
MuleReceiverServlet
0%
0/113
0%
0/18
3.308
 
 1  
 /*
 2  
  * $Id: MuleReceiverServlet.java 7976 2007-08-21 14:26:13Z dirk.olmes $
 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.i18n.HttpMessages;
 20  
 import org.mule.providers.service.TransportFactory;
 21  
 import org.mule.umo.UMOMessage;
 22  
 import org.mule.umo.endpoint.EndpointException;
 23  
 import org.mule.umo.provider.NoReceiverForEndpointException;
 24  
 import org.mule.util.PropertiesUtils;
 25  
 
 26  
 import java.io.IOException;
 27  
 import java.util.Iterator;
 28  
 import java.util.Map;
 29  
 import java.util.Properties;
 30  
 
 31  
 import javax.servlet.ServletConfig;
 32  
 import javax.servlet.ServletException;
 33  
 import javax.servlet.http.HttpServletRequest;
 34  
 import javax.servlet.http.HttpServletResponse;
 35  
 
 36  
 /**
 37  
  * Receives Http requests via a Servlet and routes the to listeners with servlet://
 38  
  * endpoints
 39  
  *
 40  
  * There needs to be a ServletConnector configured on the Mule Server, this connector
 41  
  * must have the servletUrl property set that matches the Url for the container that this
 42  
  * Servlet is hosted in, i.e. something like http://192.168.10.21:8888
 43  
  */
 44  
 
 45  0
 public class MuleReceiverServlet extends AbstractReceiverServlet
 46  
 {
 47  
     /**
 48  
      * Serial version
 49  
      */
 50  
     private static final long serialVersionUID = 6631307373079767439L;
 51  
 
 52  0
     protected ServletConnector connector = null;
 53  
 
 54  
     protected void doInit(ServletConfig servletConfig) throws ServletException
 55  
     {
 56  0
         String servletConnectorName = servletConfig.getInitParameter(SERVLET_CONNECTOR_NAME_PROPERTY);
 57  0
         if(servletConnectorName==null)
 58  
         {
 59  0
             connector = (ServletConnector) TransportFactory.getConnectorByProtocol("servlet");
 60  0
             if (connector == null)
 61  
             {
 62  0
                 throw new ServletException(HttpMessages.noConnectorForProtocolServlet().toString());
 63  
             }
 64  
         }
 65  
         else
 66  
         {
 67  0
             connector = (ServletConnector)MuleManager.getInstance().lookupConnector(servletConnectorName);
 68  0
             if (connector == null)
 69  
             {
 70  0
                 throw new ServletException(
 71  
                     HttpMessages.noServletConnectorFound(servletConnectorName).toString());
 72  
             }
 73  
         }
 74  
 
 75  
 
 76  0
     }
 77  
 
 78  
     protected void doHead(HttpServletRequest request, HttpServletResponse response)
 79  
         throws ServletException, IOException
 80  
     {
 81  0
         response.setStatus(HttpServletResponse.SC_OK);
 82  0
     }
 83  
     
 84  
     protected void doGet(HttpServletRequest request, HttpServletResponse response)
 85  
         throws ServletException, IOException
 86  
     {
 87  
         try
 88  
         {
 89  0
             AbstractMessageReceiver receiver = getReceiverForURI(request);
 90  
             UMOMessage responseMessage;
 91  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 92  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "GET");
 93  0
             responseMessage = receiver.routeMessage(requestMessage, true);
 94  0
             writeResponse(response, responseMessage);
 95  
         }
 96  0
         catch (Exception e)
 97  
         {
 98  0
             handleException(e, e.getMessage(), response);
 99  0
         }
 100  0
     }
 101  
 
 102  
     protected void doPost(HttpServletRequest request, HttpServletResponse response)
 103  
         throws ServletException, IOException
 104  
     {
 105  
         try
 106  
         {
 107  0
             AbstractMessageReceiver receiver = getReceiverForURI(request);
 108  
             UMOMessage responseMessage;
 109  0
             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
 110  0
             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "POST");
 111  0
             responseMessage = receiver.routeMessage(requestMessage, true);
 112  0
             if (responseMessage != null)
 113  
             {
 114  0
                 writeResponse(response, responseMessage);
 115  
             }
 116  
         }
 117  0
         catch (Exception e)
 118  
         {
 119  0
             handleException(e, e.getMessage(), response);
 120  0
         }
 121  0
     }
 122  
 
 123  
     protected void doOptions(HttpServletRequest request, HttpServletResponse response)
 124  
         throws ServletException, IOException
 125  
     {
 126  0
         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
 127  
         try
 128  
         {
 129  0
             response.getWriter().write(
 130  
                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_OPTIONS).toString() + HttpConstants.CRLF);
 131  
         }
 132  0
         catch (Exception e)
 133  
         {
 134  0
             handleException(e, e.getMessage(), response);
 135  0
         }
 136  0
     }
 137  
 
 138  
     protected void doPut(HttpServletRequest request, HttpServletResponse response)
 139  
         throws ServletException, IOException
 140  
     {
 141  0
         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
 142  
         try
 143  
         {
 144  0
             response.getWriter().write(
 145  
                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_PUT).toString() + HttpConstants.CRLF);
 146  
         }
 147  0
         catch (Exception e)
 148  
         {
 149  0
             handleException(e, e.getMessage(), response);
 150  0
         }
 151  0
     }
 152  
 
 153  
     protected void doDelete(HttpServletRequest request, HttpServletResponse response)
 154  
         throws ServletException, IOException
 155  
     {
 156  0
         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
 157  
         try
 158  
         {
 159  0
             response.getWriter().write(
 160  
                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_DELETE).toString() + HttpConstants.CRLF);
 161  
         }
 162  0
         catch (Exception e)
 163  
         {
 164  0
             handleException(e, e.getMessage(), response);
 165  0
         }
 166  0
     }
 167  
 
 168  
     protected void doTrace(HttpServletRequest request, HttpServletResponse response)
 169  
         throws ServletException, IOException
 170  
     {
 171  0
         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
 172  
         try
 173  
         {
 174  0
             response.getWriter().write(
 175  
                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_TRACE).toString() + HttpConstants.CRLF);
 176  
         }
 177  0
         catch (Exception e)
 178  
         {
 179  0
             handleException(e, e.getMessage(), response);
 180  0
         }
 181  0
     }
 182  
 
 183  
     protected void doConnect(HttpServletRequest request, HttpServletResponse response)
 184  
         throws ServletException, IOException
 185  
     {
 186  0
         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
 187  
         try
 188  
         {
 189  0
             response.getWriter().write(
 190  
                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_CONNECT).toString() + HttpConstants.CRLF);
 191  
         }
 192  0
         catch (Exception e)
 193  
         {
 194  0
             handleException(e, e.getMessage(), response);
 195  0
         }
 196  0
     }
 197  
 
 198  
     protected AbstractMessageReceiver getReceiverForURI(HttpServletRequest httpServletRequest)
 199  
         throws EndpointException
 200  
     {
 201  0
         String uri = getReceiverName(httpServletRequest);
 202  0
         if (uri == null)
 203  
         {
 204  0
             throw new EndpointException(
 205  
                 HttpMessages.unableToGetEndpointUri(httpServletRequest.getRequestURI()));
 206  
         }
 207  
 
 208  0
         AbstractMessageReceiver receiver = (AbstractMessageReceiver)getReceivers().get(uri);
 209  
 
 210  0
         if (receiver == null)
 211  
         {
 212  
             // Nothing found lets try stripping the path and only use the last
 213  
             // path element
 214  0
             int i = uri.lastIndexOf("/");
 215  0
             if (i > -1)
 216  
             {
 217  0
                 String tempUri = uri.substring(i + 1);
 218  0
                 receiver = (AbstractMessageReceiver)getReceivers().get(tempUri);
 219  
             }
 220  
 
 221  
             // Conversely, lets see if the uri matches up with the last part of
 222  
             // any of the receiver keys. This will be necesary to find xfire
 223  
             // receivers
 224  
 
 225  0
             if (receiver == null)
 226  
             {
 227  0
                 Map receivers = getReceivers();
 228  0
                 Iterator iter = receivers.keySet().iterator();
 229  0
                 while (iter.hasNext())
 230  
                 {
 231  0
                     String key = iter.next().toString();
 232  0
                     i = key.lastIndexOf("/");
 233  0
                     if (i > -1)
 234  
                     {
 235  0
                         if (key.substring(i+1).equals(uri))
 236  
                         {
 237  0
                             receiver = (AbstractMessageReceiver)receivers.get(key);
 238  0
                             break;
 239  
                         }
 240  
                     }
 241  
                 }
 242  
             }
 243  
             
 244  0
             if (receiver == null)
 245  
             {
 246  0
                 throw new NoReceiverForEndpointException("No receiver found for endpointUri: " + uri);
 247  
             }
 248  
         }
 249  0
         receiver.getEndpoint().setEndpointURI(new MuleEndpointURI(getRequestUrl(httpServletRequest)));
 250  0
         return receiver;
 251  
     }
 252  
 
 253  
     protected String getRequestUrl(HttpServletRequest httpServletRequest)
 254  
     {
 255  0
         StringBuffer url = new StringBuffer();
 256  0
         url.append(connector.getProtocol().toLowerCase());
 257  0
         url.append(":");
 258  0
         url.append(httpServletRequest.getScheme());
 259  0
         url.append("://");
 260  0
         url.append(httpServletRequest.getServerName());
 261  0
         url.append(":");
 262  0
         url.append(httpServletRequest.getServerPort());
 263  0
         url.append("/");
 264  0
         url.append(getReceiverName(httpServletRequest));
 265  0
         if (httpServletRequest.getQueryString() != null)
 266  
         {
 267  0
             url.append("?");
 268  0
             url.append(httpServletRequest.getQueryString());
 269  
         }
 270  0
         return url.toString();
 271  
     }
 272  
 
 273  
     protected String getReceiverName(HttpServletRequest httpServletRequest)
 274  
     {
 275  0
         String name = httpServletRequest.getPathInfo();
 276  0
         if (name == null)
 277  
         {
 278  0
             name = httpServletRequest.getServletPath();
 279  0
             if (name == null)
 280  
             {
 281  0
                 name = httpServletRequest.getParameter("endpoint");
 282  0
                 if (name == null)
 283  
                 {
 284  0
                     Properties params = PropertiesUtils.getPropertiesFromQueryString(httpServletRequest.getQueryString());
 285  0
                     name = params.getProperty("endpoint");
 286  0
                     if (name == null)
 287  
                     {
 288  0
                         return null;
 289  
                     }
 290  
                 }
 291  
             }
 292  
         }
 293  
         
 294  0
         if (name.startsWith("/"))
 295  
         {
 296  0
             name = name.substring(1);
 297  
         }
 298  0
         return name;
 299  
     }
 300  
 
 301  
     protected Map getReceivers()
 302  
     {
 303  0
         return connector.getReceivers();
 304  
     }
 305  
 }