InvokerServlet


1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  
19  package org.apache.catalina.servlets;
20  
21  
22  import java.io.IOException  ;
23  
24  import javax.servlet.Servlet  ;
25  import javax.servlet.ServletException  ;
26  import javax.servlet.UnavailableException  ;
27  import javax.servlet.http.HttpServlet  ;
28  import javax.servlet.http.HttpServletRequest  ;
29  import javax.servlet.http.HttpServletResponse  ;
30  
31  import org.apache.catalina.ContainerServlet;
32  import org.apache.catalina.Context;
33  import org.apache.catalina.Globals;
34  import org.apache.catalina.Wrapper;
35  import org.apache.catalina.util.StringManager;
36  
37  
38  /**
39   * The default servlet-invoking servlet for most web applications,
40   * used to serve requests to servlets that have not been registered
41   * in the web application deployment descriptor.
42   *
43   * @author Craig R. McClanahan
44   * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
45   */
46  
47  public final class InvokerServlet
48      extends HttpServlet   implements ContainerServlet {
49  
50  
51      // ----------------------------------------------------- Instance Variables
52  
53  
54      /**
55       * The Context container associated with our web application.
56       */
57      private Context context = null;
58  
59  
60      /**
61       * The debugging detail level for this servlet.
62       */
63      private int debug = 0;
64  
65  
66      /**
67       * The string manager for this package.
68       */
69      private static StringManager sm =
70          StringManager.getManager(Constants.Package);
71  
72  
73      /**
74       * The Wrapper container associated with this servlet.
75       */
76      private Wrapper wrapper = null;
77  
78  
79      // ----------------------------------------------- ContainerServlet Methods
80  
81  
82      /**
83       * Return the Wrapper with which we are associated.
84       */
85      public Wrapper getWrapper() {
86  
87          return (this.wrapper);
88  
89      }
90  
91  
92      /**
93       * Set the Wrapper with which we are associated.
94       *
95       * @param wrapper The new wrapper
96       */
97      public void setWrapper(Wrapper wrapper) {
98  
99          this.wrapper = wrapper;
100         if (wrapper == null)
101             context = null;
102         else
103             context = (Context) wrapper.getParent();
104 
105     }
106 
107 
108     // --------------------------------------------------------- Public Methods
109 
110 
111     /**
112      * Finalize this servlet.
113      */
114     public void destroy() {
115 
116         ;       // No actions necessary
117 
118     }
119 
120 
121     /**
122      * Process a GET request for the specified resource.
123      *
124      * @param request The servlet request we are processing
125      * @param response The servlet response we are creating
126      *
127      * @exception IOException if an input/output error occurs
128      * @exception ServletException if a servlet-specified error occurs
129      */
130     public void doGet(HttpServletRequest   request,
131                       HttpServletResponse   response)
132         throws IOException  , ServletException   {
133 
134         serveRequest(request, response);
135 
136     }
137 
138 
139     /**
140      * Process a HEAD request for the specified resource.
141      *
142      * @param request The servlet request we are processing
143      * @param response The servlet response we are creating
144      *
145      * @exception IOException if an input/output error occurs
146      * @exception ServletException if a servlet-specified error occurs
147      */
148     public void doHead(HttpServletRequest   request,
149                        HttpServletResponse   response)
150         throws IOException  , ServletException   {
151 
152         serveRequest(request, response);
153 
154     }
155 
156 
157     /**
158      * Process a POST request for the specified resource.
159      *
160      * @param request The servlet request we are processing
161      * @param response The servlet response we are creating
162      *
163      * @exception IOException if an input/output error occurs
164      * @exception ServletException if a servlet-specified error occurs
165      */
166     public void doPost(HttpServletRequest   request,
167                        HttpServletResponse   response)
168         throws IOException  , ServletException   {
169 
170         serveRequest(request, response);
171 
172     }
173 
174 
175     /**
176      * Initialize this servlet.
177      */
178     public void init() throws ServletException   {
179 
180         // Ensure that our ContainerServlet properties have been set
181         if ((wrapper == null) || (context == null))
182             throw new UnavailableException  
183                 (sm.getString("invokerServlet.noWrapper"));
184 
185         // Set our properties from the initialization parameters
186         if (getServletConfig().getInitParameter("debug") != null)
187             debug = Integer.parseInt(getServletConfig().getInitParameter("debug"));
188 
189         if (debug >= 1)
190             log("init: Associated with Context '" + context.getPath() + "'");
191 
192     }
193 
194 
195 
196     // -------------------------------------------------------- Private Methods
197 
198 
199     /**
200      * Serve the specified request, creating the corresponding response.
201      * After the first time a particular servlet class is requested, it will
202      * be served directly (like any registered servlet) because it will have
203      * been registered and mapped in our associated Context.
204      *
205      * @param request The servlet request we are processing
206      * @param response The servlet response we are creating
207      *
208      * @exception IOException if an input/output error occurs
209      * @exception ServletException if a servlet-specified error occurs
210      */
211     public void serveRequest(HttpServletRequest   request,
212                              HttpServletResponse   response)
213         throws IOException  , ServletException   {
214 
215         // Disallow calling this servlet via a named dispatcher
216         if (request.getAttribute(Globals.NAMED_DISPATCHER_ATTR) != null)
217             throw new ServletException  
218                 (sm.getString("invokerServlet.notNamed"));
219 
220         // Identify the input parameters and our "included" state
221         String   inRequestURI = null;
222         String   inServletPath = null;
223         String   inPathInfo = null;
224         boolean included =
225             (request.getAttribute(Globals.INCLUDE_REQUEST_URI_ATTR) != null);
226 
227         if (included) {
228             inRequestURI =
229                 (String  ) request.getAttribute(Globals.INCLUDE_REQUEST_URI_ATTR);
230             inServletPath =
231                 (String  ) request.getAttribute(Globals.INCLUDE_SERVLET_PATH_ATTR);
232             inPathInfo =
233                 (String  ) request.getAttribute(Globals.INCLUDE_PATH_INFO_ATTR);
234         } else {
235             inRequestURI = request.getRequestURI();
236             inServletPath = request.getServletPath();
237             inPathInfo = request.getPathInfo();
238         }
239         if (debug >= 1) {
240             log("included='" + included + "', requestURI='" +
241                 inRequestURI + "'");
242             log("  servletPath='" + inServletPath + "', pathInfo='" +
243                 inPathInfo + "'");
244         }
245 
246         // Make sure a servlet name or class name was specified
247         if (inPathInfo == null) {
248             if (debug >= 1)
249                 log("Invalid pathInfo '" + inPathInfo + "'");
250             if (included)
251                 throw new ServletException  
252                     (sm.getString("invokerServlet.invalidPath", inRequestURI));
253             else {
254                 response.sendError(HttpServletResponse.SC_NOT_FOUND,
255                                    inRequestURI);
256                 return;
257             }
258         }
259 
260         // Identify the outgoing servlet name or class, and outgoing path info
261         String   pathInfo = inPathInfo;
262         String   servletClass = pathInfo.substring(1);
263         int slash = servletClass.indexOf('/');
264         if (slash >= 0) {
265             pathInfo = servletClass.substring(slash);
266             servletClass = servletClass.substring(0, slash);
267         } else {
268             pathInfo = "";
269         }
270 
271         if (servletClass.startsWith("org.apache.catalina")) {
272             response.sendError(HttpServletResponse.SC_NOT_FOUND,
273                                inRequestURI);
274             return;
275         }
276 
277         if (debug >= 1)
278             log("Processing servlet '" + servletClass +
279                 "' with path info '" + pathInfo + "'");
280         String   name = "org.apache.catalina.INVOKER." + servletClass;
281         String   pattern = inServletPath + "/" + servletClass + "/*";
282         Wrapper wrapper = null;
283 
284         // Synchronize to avoid race conditions when multiple requests
285         // try to initialize the same servlet at the same time
286         synchronized (this) {
287 
288             // Are we referencing an existing servlet class or name?
289             wrapper = (Wrapper) context.findChild(servletClass);
290             if (wrapper == null)
291                 wrapper = (Wrapper) context.findChild(name);
292             if (wrapper != null) {
293                 String   actualServletClass = wrapper.getServletClass();
294                 if ((actualServletClass != null)
295                     && (actualServletClass.startsWith
296                         ("org.apache.catalina"))) {
297                     response.sendError(HttpServletResponse.SC_NOT_FOUND,
298                                        inRequestURI);
299                     return;
300                 }
301                 if (debug >= 1)
302                     log("Using wrapper for servlet '" +
303                         wrapper.getName() + "' with mapping '" +
304                         pattern + "'");
305                 context.addServletMapping(pattern, wrapper.getName());
306             }
307 
308             // No, create a new wrapper for the specified servlet class
309             else {
310 
311                 if (debug >= 1)
312                     log("Creating wrapper for '" + servletClass +
313                         "' with mapping '" + pattern + "'");
314 
315                 try {
316                     wrapper = context.createWrapper();
317                     wrapper.setName(name);
318                     wrapper.setLoadOnStartup(1);
319                     wrapper.setServletClass(servletClass);
320                     context.addChild(wrapper);
321                     context.addServletMapping(pattern, name);
322                 } catch (Exception   e) {
323                     log(sm.getString("invokerServlet.cannotCreate",
324                                      inRequestURI), e);
325                     context.removeServletMapping(pattern);
326                     context.removeChild(wrapper);
327                     if (included)
328                         throw new ServletException  
329                             (sm.getString("invokerServlet.cannotCreate",
330                                           inRequestURI), e);
331                     else {
332                         response.sendError(HttpServletResponse.SC_NOT_FOUND,
333                                            inRequestURI);
334                         return;
335                     }
336                 }
337             }
338 
339         }
340 
341         // Create a request wrapper to pass on to the invoked servlet
342         InvokerHttpRequest wrequest =
343             new InvokerHttpRequest(request);
344         wrequest.setRequestURI(inRequestURI);
345         StringBuffer   sb = new StringBuffer  (inServletPath);
346         sb.append("/");
347         sb.append(servletClass);
348         wrequest.setServletPath(sb.toString());
349         if ((pathInfo == null) || (pathInfo.length() < 1)) {
350             wrequest.setPathInfo(null);
351             wrequest.setPathTranslated(null);
352         } else {
353             wrequest.setPathInfo(pathInfo);
354             wrequest.setPathTranslated
355                 (getServletContext().getRealPath(pathInfo));
356         }
357 
358         // Allocate a servlet instance to perform this request
359         Servlet   instance = null;
360         try {
361             instance = wrapper.allocate();
362         } catch (ServletException   e) {
363             log(sm.getString("invokerServlet.allocate", inRequestURI), e);
364             context.removeServletMapping(pattern);
365             context.removeChild(wrapper);
366             Throwable   rootCause = e.getRootCause();
367             if (rootCause == null)
368                 rootCause = e;
369             if (rootCause instanceof ClassNotFoundException  ) {
370                 response.sendError(HttpServletResponse.SC_NOT_FOUND,
371                                    inRequestURI);
372                 return;
373             } else if (rootCause instanceof IOException  ) {
374                 throw (IOException  ) rootCause;
375             } else if (rootCause instanceof RuntimeException  ) {
376                 throw (RuntimeException  ) rootCause;
377             } else if (rootCause instanceof ServletException  ) {
378                 throw (ServletException  ) rootCause;
379             } else {
380                 throw new ServletException  
381                     (sm.getString("invokerServlet.allocate", inRequestURI),
382                      rootCause);
383             }
384         }
385 
386         // After loading the wrapper, restore some of the fields when including
387         if (included) {
388             wrequest.setRequestURI(request.getRequestURI());
389             wrequest.setPathInfo(request.getPathInfo());
390             wrequest.setServletPath(request.getServletPath());
391         }
392 
393         // Invoke the service() method of the allocated servlet
394         try {
395             String   jspFile = wrapper.getJspFile();
396             if (jspFile != null)
397                 request.setAttribute(Globals.JSP_FILE_ATTR, jspFile);
398             else
399                 request.removeAttribute(Globals.JSP_FILE_ATTR);
400             request.setAttribute(Globals.INVOKED_ATTR,
401                                  request.getServletPath());
402             instance.service(wrequest, response);
403         } catch (UnavailableException   e) {
404             context.removeServletMapping(pattern);
405             throw e;
406         } finally {
407             request.removeAttribute(Globals.INVOKED_ATTR);
408             request.removeAttribute(Globals.JSP_FILE_ATTR);
409             // Deallocate the allocated servlet instance
410             try {
411                 wrapper.deallocate(instance);
412             } catch (ServletException   e) {
413                 log(sm.getString("invokerServlet.deallocate", inRequestURI), e);
414                 throw e;
415             }
416         }
417 
418     }
419 
420 
421 }
422
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags