View Javadoc

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  public class MuleReceiverServlet extends AbstractReceiverServlet
46  {
47      /**
48       * Serial version
49       */
50      private static final long serialVersionUID = 6631307373079767439L;
51  
52      protected ServletConnector connector = null;
53  
54      protected void doInit(ServletConfig servletConfig) throws ServletException
55      {
56          String servletConnectorName = servletConfig.getInitParameter(SERVLET_CONNECTOR_NAME_PROPERTY);
57          if(servletConnectorName==null)
58          {
59              connector = (ServletConnector) TransportFactory.getConnectorByProtocol("servlet");
60              if (connector == null)
61              {
62                  throw new ServletException(HttpMessages.noConnectorForProtocolServlet().toString());
63              }
64          }
65          else
66          {
67              connector = (ServletConnector)MuleManager.getInstance().lookupConnector(servletConnectorName);
68              if (connector == null)
69              {
70                  throw new ServletException(
71                      HttpMessages.noServletConnectorFound(servletConnectorName).toString());
72              }
73          }
74  
75  
76      }
77  
78      protected void doHead(HttpServletRequest request, HttpServletResponse response)
79          throws ServletException, IOException
80      {
81          response.setStatus(HttpServletResponse.SC_OK);
82      }
83      
84      protected void doGet(HttpServletRequest request, HttpServletResponse response)
85          throws ServletException, IOException
86      {
87          try
88          {
89              AbstractMessageReceiver receiver = getReceiverForURI(request);
90              UMOMessage responseMessage;
91              UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
92              requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "GET");
93              responseMessage = receiver.routeMessage(requestMessage, true);
94              writeResponse(response, responseMessage);
95          }
96          catch (Exception e)
97          {
98              handleException(e, e.getMessage(), response);
99          }
100     }
101 
102     protected void doPost(HttpServletRequest request, HttpServletResponse response)
103         throws ServletException, IOException
104     {
105         try
106         {
107             AbstractMessageReceiver receiver = getReceiverForURI(request);
108             UMOMessage responseMessage;
109             UMOMessage requestMessage = new MuleMessage(new HttpRequestMessageAdapter(request));
110             requestMessage.setProperty(HttpConnector.HTTP_METHOD_PROPERTY, "POST");
111             responseMessage = receiver.routeMessage(requestMessage, true);
112             if (responseMessage != null)
113             {
114                 writeResponse(response, responseMessage);
115             }
116         }
117         catch (Exception e)
118         {
119             handleException(e, e.getMessage(), response);
120         }
121     }
122 
123     protected void doOptions(HttpServletRequest request, HttpServletResponse response)
124         throws ServletException, IOException
125     {
126         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
127         try
128         {
129             response.getWriter().write(
130                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_OPTIONS).toString() + HttpConstants.CRLF);
131         }
132         catch (Exception e)
133         {
134             handleException(e, e.getMessage(), response);
135         }
136     }
137 
138     protected void doPut(HttpServletRequest request, HttpServletResponse response)
139         throws ServletException, IOException
140     {
141         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
142         try
143         {
144             response.getWriter().write(
145                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_PUT).toString() + HttpConstants.CRLF);
146         }
147         catch (Exception e)
148         {
149             handleException(e, e.getMessage(), response);
150         }
151     }
152 
153     protected void doDelete(HttpServletRequest request, HttpServletResponse response)
154         throws ServletException, IOException
155     {
156         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
157         try
158         {
159             response.getWriter().write(
160                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_DELETE).toString() + HttpConstants.CRLF);
161         }
162         catch (Exception e)
163         {
164             handleException(e, e.getMessage(), response);
165         }
166     }
167 
168     protected void doTrace(HttpServletRequest request, HttpServletResponse response)
169         throws ServletException, IOException
170     {
171         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
172         try
173         {
174             response.getWriter().write(
175                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_TRACE).toString() + HttpConstants.CRLF);
176         }
177         catch (Exception e)
178         {
179             handleException(e, e.getMessage(), response);
180         }
181     }
182 
183     protected void doConnect(HttpServletRequest request, HttpServletResponse response)
184         throws ServletException, IOException
185     {
186         response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
187         try
188         {
189             response.getWriter().write(
190                 HttpMessages.methodNotAllowed(HttpConstants.METHOD_CONNECT).toString() + HttpConstants.CRLF);
191         }
192         catch (Exception e)
193         {
194             handleException(e, e.getMessage(), response);
195         }
196     }
197 
198     protected AbstractMessageReceiver getReceiverForURI(HttpServletRequest httpServletRequest)
199         throws EndpointException
200     {
201         String uri = getReceiverName(httpServletRequest);
202         if (uri == null)
203         {
204             throw new EndpointException(
205                 HttpMessages.unableToGetEndpointUri(httpServletRequest.getRequestURI()));
206         }
207 
208         AbstractMessageReceiver receiver = (AbstractMessageReceiver)getReceivers().get(uri);
209 
210         if (receiver == null)
211         {
212             // Nothing found lets try stripping the path and only use the last
213             // path element
214             int i = uri.lastIndexOf("/");
215             if (i > -1)
216             {
217                 String tempUri = uri.substring(i + 1);
218                 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             if (receiver == null)
226             {
227                 Map receivers = getReceivers();
228                 Iterator iter = receivers.keySet().iterator();
229                 while (iter.hasNext())
230                 {
231                     String key = iter.next().toString();
232                     i = key.lastIndexOf("/");
233                     if (i > -1)
234                     {
235                         if (key.substring(i+1).equals(uri))
236                         {
237                             receiver = (AbstractMessageReceiver)receivers.get(key);
238                             break;
239                         }
240                     }
241                 }
242             }
243             
244             if (receiver == null)
245             {
246                 throw new NoReceiverForEndpointException("No receiver found for endpointUri: " + uri);
247             }
248         }
249         receiver.getEndpoint().setEndpointURI(new MuleEndpointURI(getRequestUrl(httpServletRequest)));
250         return receiver;
251     }
252 
253     protected String getRequestUrl(HttpServletRequest httpServletRequest)
254     {
255         StringBuffer url = new StringBuffer();
256         url.append(connector.getProtocol().toLowerCase());
257         url.append(":");
258         url.append(httpServletRequest.getScheme());
259         url.append("://");
260         url.append(httpServletRequest.getServerName());
261         url.append(":");
262         url.append(httpServletRequest.getServerPort());
263         url.append("/");
264         url.append(getReceiverName(httpServletRequest));
265         if (httpServletRequest.getQueryString() != null)
266         {
267             url.append("?");
268             url.append(httpServletRequest.getQueryString());
269         }
270         return url.toString();
271     }
272 
273     protected String getReceiverName(HttpServletRequest httpServletRequest)
274     {
275         String name = httpServletRequest.getPathInfo();
276         if (name == null)
277         {
278             name = httpServletRequest.getServletPath();
279             if (name == null)
280             {
281                 name = httpServletRequest.getParameter("endpoint");
282                 if (name == null)
283                 {
284                     Properties params = PropertiesUtils.getPropertiesFromQueryString(httpServletRequest.getQueryString());
285                     name = params.getProperty("endpoint");
286                     if (name == null)
287                     {
288                         return null;
289                     }
290                 }
291             }
292         }
293         
294         if (name.startsWith("/"))
295         {
296             name = name.substring(1);
297         }
298         return name;
299     }
300 
301     protected Map getReceivers()
302     {
303         return connector.getReceivers();
304     }
305 }