View Javadoc

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  public class MuleReceiverServlet extends AbstractReceiverServlet
48  {
49      /**
50       * Serial version
51       */
52      private static final long serialVersionUID = 6631307373079767439L;
53  
54      protected ServletConnector connector = null;
55  
56      protected void doInit(ServletConfig servletConfig) throws ServletException
57      {
58          String servletConnectorName = servletConfig.getInitParameter(SERVLET_CONNECTOR_NAME_PROPERTY);
59          if(servletConnectorName==null)
60          {
61              connector = (ServletConnector) TransportFactory.getConnectorByProtocol("servlet");
62              if (connector == null)
63              {
64                  throw new ServletException(HttpMessages.noConnectorForProtocolServlet().toString());
65              }
66          }
67          else
68          {
69              connector = (ServletConnector)MuleManager.getInstance().lookupConnector(servletConnectorName);
70              if (connector == null)
71              {
72                  throw new ServletException(
73                      HttpMessages.noServletConnectorFound(servletConnectorName).toString());
74              }
75          }
76  
77  
78      }
79  
80      protected void doHead(HttpServletRequest request, HttpServletResponse response)
81          throws ServletException, IOException
82      {
83          try
84          {
85              UMOMessageReceiver receiver = getReceiverForURI(request);
86              UMOMessage responseMessage = null;
87              UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
88              requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "HEAD");
89              setupRequestMessage(request, requestMessage);
90              receiver.routeMessage(requestMessage, true);
91              if (responseMessage != null)
92              {
93                  writeResponse(response, responseMessage);
94              }
95              else 
96              {
97                  response.setStatus(HttpConstants.SC_OK);
98              }
99          }
100         catch (Exception e)
101         {
102             handleException(e, e.getMessage(), response);
103         }
104     }
105     
106     protected void doGet(HttpServletRequest request, HttpServletResponse response)
107         throws ServletException, IOException
108     {
109         try
110         {
111             UMOMessageReceiver receiver = getReceiverForURI(request);
112             UMOMessage responseMessage;
113             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
114             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "GET");
115             setupRequestMessage(request, requestMessage);
116             responseMessage = receiver.routeMessage(requestMessage, true);
117             writeResponse(response, responseMessage);
118         }
119         catch (Exception e)
120         {
121             handleException(e, e.getMessage(), response);
122         }
123     }
124 
125     private void setupRequestMessage(HttpServletRequest request, UMOMessage requestMessage)
126     {
127         requestMessage.setProperty(HttpConnector.HTTP_REQUEST_PROPERTY, request.getRequestURI());
128     }
129 
130     protected void doPost(HttpServletRequest request, HttpServletResponse response)
131         throws ServletException, IOException
132     {
133         try
134         {
135             UMOMessageReceiver receiver = getReceiverForURI(request);
136             UMOMessage responseMessage;
137             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
138             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "POST");
139             setupRequestMessage(request, requestMessage);
140             responseMessage = receiver.routeMessage(requestMessage, true);
141             if (responseMessage != null)
142             {
143                 writeResponse(response, responseMessage);
144             }
145         }
146         catch (Exception e)
147         {
148             handleException(e, e.getMessage(), response);
149         }
150     }
151 
152     protected void doOptions(HttpServletRequest request, HttpServletResponse response)
153         throws ServletException, IOException
154     {
155         try
156         {
157             UMOMessageReceiver receiver = getReceiverForURI(request);
158             UMOMessage responseMessage;
159             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
160             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "OPTIONS");
161             setupRequestMessage(request, requestMessage);
162             responseMessage = receiver.routeMessage(requestMessage, true);
163             if (responseMessage != null)
164             {
165                 writeResponse(response, responseMessage);
166             }
167         }
168         catch (Exception e)
169         {
170             handleException(e, e.getMessage(), response);
171         }
172     }
173 
174     protected void doPut(HttpServletRequest request, HttpServletResponse response)
175         throws ServletException, IOException
176     {
177         try
178         {
179             UMOMessageReceiver receiver = getReceiverForURI(request);
180             UMOMessage responseMessage;
181             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
182             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "PUT");
183             setupRequestMessage(request, requestMessage);
184             responseMessage = receiver.routeMessage(requestMessage, true);
185             if (responseMessage != null)
186             {
187                 writeResponse(response, responseMessage);
188             }
189         }
190         catch (Exception e)
191         {
192             handleException(e, e.getMessage(), response);
193         }
194     }
195 
196     protected void doDelete(HttpServletRequest request, HttpServletResponse response)
197         throws ServletException, IOException
198     {
199         try
200         {
201             UMOMessageReceiver receiver = getReceiverForURI(request);
202             UMOMessage responseMessage;
203             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
204             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "DELETE");
205             setupRequestMessage(request, requestMessage);
206             responseMessage = receiver.routeMessage(requestMessage, true);
207             if (responseMessage != null)
208             {
209                 writeResponse(response, responseMessage);
210             }
211         }
212         catch (Exception e)
213         {
214             handleException(e, e.getMessage(), response);
215         }
216     }
217 
218     protected void doTrace(HttpServletRequest request, HttpServletResponse response)
219         throws ServletException, IOException
220     {
221         try
222         {
223             UMOMessageReceiver receiver = getReceiverForURI(request);
224             UMOMessage responseMessage;
225             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
226             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "TRACE");
227             setupRequestMessage(request, requestMessage);
228             responseMessage = receiver.routeMessage(requestMessage, true);
229             if (responseMessage != null)
230             {
231                 writeResponse(response, responseMessage);
232             }
233         }
234         catch (Exception e)
235         {
236             handleException(e, e.getMessage(), response);
237         }
238     }
239 
240     protected void doConnect(HttpServletRequest request, HttpServletResponse response)
241         throws ServletException, IOException
242     {
243         try
244         {
245             UMOMessageReceiver receiver = getReceiverForURI(request);
246             UMOMessage responseMessage;
247             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
248             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "CONNECT");
249             setupRequestMessage(request, requestMessage);
250             responseMessage = receiver.routeMessage(requestMessage, true);
251             if (responseMessage != null)
252             {
253                 writeResponse(response, responseMessage);
254             }
255         }
256         catch (Exception e)
257         {
258             handleException(e, e.getMessage(), response);
259         }
260     }
261 
262     protected UMOMessageReceiver getReceiverForURI(HttpServletRequest httpServletRequest)
263         throws EndpointException
264     {
265         String uri = getReceiverName(httpServletRequest);
266         if (uri == null)
267         {
268             throw new EndpointException(
269                 HttpMessages.unableToGetEndpointUri(httpServletRequest.getRequestURI()));
270         }
271 
272         UMOMessageReceiver receiver = (UMOMessageReceiver)getReceivers().get(uri);
273 
274         if (receiver == null)
275         {
276             // Nothing found lets try stripping the path and only use the last
277             // path element
278             int i = uri.lastIndexOf("/");
279             if (i > -1)
280             {
281                 String tempUri = uri.substring(i + 1);
282                 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             if (receiver == null) 
288             {
289                 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             if (receiver == null)
296             {
297                 Map receivers = getReceivers();
298                 Iterator iter = receivers.keySet().iterator();
299                 while (iter.hasNext())
300                 {
301                     String key = iter.next().toString();
302                     i = key.lastIndexOf("/");
303                     if (i > -1)
304                     {
305                         String key2 = key.substring(i+1);
306                         if (key2.equals(uri))
307                         {
308                             receiver = (AbstractMessageReceiver)receivers.get(key);
309                             break;
310                         }
311                     }
312                 }
313             }
314             
315             if (receiver == null)
316             {
317                 throw new NoReceiverForEndpointException("No receiver found for endpointUri: " + uri);
318             }
319         }
320         receiver.getEndpoint().setEndpointURI(new MuleEndpointURI(getRequestUrl(httpServletRequest)));
321         return receiver;
322     }
323 
324     protected String getRequestUrl(HttpServletRequest httpServletRequest)
325     {
326         StringBuffer url = new StringBuffer();
327         url.append(connector.getProtocol().toLowerCase());
328         url.append(":");
329         url.append(httpServletRequest.getScheme());
330         url.append("://");
331         url.append(httpServletRequest.getServerName());
332         url.append(":");
333         url.append(httpServletRequest.getServerPort());
334         url.append("/");
335         url.append(getReceiverName(httpServletRequest));
336         if (httpServletRequest.getQueryString() != null)
337         {
338             url.append("?");
339             url.append(httpServletRequest.getQueryString());
340         }
341         return url.toString();
342     }
343 
344     protected String getReceiverName(HttpServletRequest httpServletRequest)
345     {
346         String name = httpServletRequest.getPathInfo();
347         if (name == null)
348         {
349             name = httpServletRequest.getServletPath();
350             if (name == null)
351             {
352                 name = httpServletRequest.getParameter("endpoint");
353                 if (name == null)
354                 {
355                     Properties params = PropertiesUtils.getPropertiesFromQueryString(httpServletRequest.getQueryString());
356                     name = params.getProperty("endpoint");
357                     if (name == null)
358                     {
359                         return null;
360                     }
361                 }
362             }
363         }
364         
365         if (name.startsWith("/"))
366         {
367             name = name.substring(1);
368         }
369         return name;
370     }
371 
372     protected Map getReceivers()
373     {
374         return connector.getReceivers();
375     }
376 }