KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > catalina > core > StandardContextValve


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.core;
20
21
22 import java.io.IOException JavaDoc;
23
24 import javax.servlet.ServletException JavaDoc;
25 import javax.servlet.ServletRequest JavaDoc;
26 import javax.servlet.ServletRequestEvent JavaDoc;
27 import javax.servlet.ServletRequestListener JavaDoc;
28 import javax.servlet.http.HttpServletResponse JavaDoc;
29
30 import org.apache.catalina.CometEvent;
31 import org.apache.catalina.Container;
32 import org.apache.catalina.Globals;
33 import org.apache.catalina.Wrapper;
34 import org.apache.catalina.connector.Request;
35 import org.apache.catalina.connector.Response;
36 import org.apache.catalina.util.StringManager;
37 import org.apache.catalina.valves.ValveBase;
38 import org.apache.tomcat.util.buf.MessageBytes;
39
40 /**
41  * Valve that implements the default basic behavior for the
42  * <code>StandardContext</code> container implementation.
43  * <p>
44  * <b>USAGE CONSTRAINT</b>: This implementation is likely to be useful only
45  * when processing HTTP requests.
46  *
47  * @author Craig R. McClanahan
48  * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
49  */
50
51 final class StandardContextValve
52     extends ValveBase {
53
54
55     // ----------------------------------------------------- Instance Variables
56
57
58     /**
59      * The descriptive information related to this implementation.
60      */
61     private static final String JavaDoc info =
62         "org.apache.catalina.core.StandardContextValve/1.0";
63
64
65     /**
66      * The string manager for this package.
67      */
68     private static final StringManager sm =
69         StringManager.getManager(Constants.Package);
70
71
72     private StandardContext context = null;
73     
74
75     // ------------------------------------------------------------- Properties
76
77
78     /**
79      * Return descriptive information about this Valve implementation.
80      */
81     public String JavaDoc getInfo() {
82
83         return (info);
84
85     }
86
87
88     // --------------------------------------------------------- Public Methods
89
90
91     /**
92      * Cast to a StandardContext right away, as it will be needed later.
93      *
94      * @see org.apache.catalina.Contained#setContainer(org.apache.catalina.Container)
95      */
96     public void setContainer(Container container) {
97         super.setContainer(container);
98         context = (StandardContext) container;
99     }
100
101     
102     /**
103      * Select the appropriate child Wrapper to process this request,
104      * based on the specified request URI. If no matching Wrapper can
105      * be found, return an appropriate HTTP error.
106      *
107      * @param request Request to be processed
108      * @param response Response to be produced
109      * @param valveContext Valve context used to forward to the next Valve
110      *
111      * @exception IOException if an input/output error occurred
112      * @exception ServletException if a servlet error occurred
113      */
114     public final void invoke(Request JavaDoc request, Response JavaDoc response)
115         throws IOException JavaDoc, ServletException JavaDoc {
116
117         // Disallow any direct access to resources under WEB-INF or META-INF
118 MessageBytes requestPathMB = request.getRequestPathMB();
119         if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))
120             || (requestPathMB.equalsIgnoreCase("/META-INF"))
121             || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))
122             || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {
123             String JavaDoc requestURI = request.getDecodedRequestURI();
124             notFound(requestURI, response);
125             return;
126         }
127
128         // Wait if we are reloading
129 while (context.getPaused()) {
130             try {
131                 Thread.sleep(1000);
132             } catch (InterruptedException JavaDoc e) {
133                 ;
134             }
135         }
136
137         // Select the Wrapper to be used for this Request
138 Wrapper wrapper = request.getWrapper();
139         if (wrapper == null) {
140             String JavaDoc requestURI = request.getDecodedRequestURI();
141             notFound(requestURI, response);
142             return;
143         }
144
145         // Normal request processing
146 Object JavaDoc instances[] = context.getApplicationEventListeners();
147
148         ServletRequestEvent JavaDoc event = null;
149
150         if ((instances != null)
151                 && (instances.length > 0)) {
152             event = new ServletRequestEvent JavaDoc
153                 (((StandardContext) container).getServletContext(),
154                  request.getRequest());
155             // create pre-service event
156 for (int i = 0; i < instances.length; i++) {
157                 if (instances[i] == null)
158                     continue;
159                 if (!(instances[i] instanceof ServletRequestListener JavaDoc))
160                     continue;
161                 ServletRequestListener JavaDoc listener =
162                     (ServletRequestListener JavaDoc) instances[i];
163                 try {
164                     listener.requestInitialized(event);
165                 } catch (Throwable JavaDoc t) {
166                     container.getLogger().error(sm.getString("standardContext.requestListener.requestInit",
167                                      instances[i].getClass().getName()), t);
168                     ServletRequest JavaDoc sreq = request.getRequest();
169                     sreq.setAttribute(Globals.EXCEPTION_ATTR,t);
170                     return;
171                 }
172             }
173         }
174
175         wrapper.getPipeline().getFirst().invoke(request, response);
176
177         if ((instances !=null ) &&
178                 (instances.length > 0)) {
179             // create post-service event
180 for (int i = 0; i < instances.length; i++) {
181                 if (instances[i] == null)
182                     continue;
183                 if (!(instances[i] instanceof ServletRequestListener JavaDoc))
184                     continue;
185                 ServletRequestListener JavaDoc listener =
186                     (ServletRequestListener JavaDoc) instances[i];
187                 try {
188                     listener.requestDestroyed(event);
189                 } catch (Throwable JavaDoc t) {
190                     container.getLogger().error(sm.getString("standardContext.requestListener.requestDestroy",
191                                      instances[i].getClass().getName()), t);
192                     ServletRequest JavaDoc sreq = request.getRequest();
193                     sreq.setAttribute(Globals.EXCEPTION_ATTR,t);
194                 }
195             }
196         }
197                 
198     }
199
200
201     /**
202      * Select the appropriate child Wrapper to process this request,
203      * based on the specified request URI. If no matching Wrapper can
204      * be found, return an appropriate HTTP error.
205      *
206      * @param request Request to be processed
207      * @param response Response to be produced
208      * @param valveContext Valve context used to forward to the next Valve
209      *
210      * @exception IOException if an input/output error occurred
211      * @exception ServletException if a servlet error occurred
212      */
213     public final void event(Request JavaDoc request, Response JavaDoc response, CometEvent event)
214         throws IOException JavaDoc, ServletException JavaDoc {
215
216         // Select the Wrapper to be used for this Request
217 Wrapper wrapper = request.getWrapper();
218
219         // Normal request processing
220 // FIXME: This could be an addition to the core API too
221 /*
222         Object instances[] = context.getApplicationEventListeners();
223
224         ServletRequestEvent event = null;
225
226         if ((instances != null)
227                 && (instances.length > 0)) {
228             event = new ServletRequestEvent
229                 (((StandardContext) container).getServletContext(),
230                  request.getRequest());
231             // create pre-service event
232             for (int i = 0; i < instances.length; i++) {
233                 if (instances[i] == null)
234                     continue;
235                 if (!(instances[i] instanceof ServletRequestListener))
236                     continue;
237                 ServletRequestListener listener =
238                     (ServletRequestListener) instances[i];
239                 try {
240                     listener.requestInitialized(event);
241                 } catch (Throwable t) {
242                     container.getLogger().error(sm.getString("requestListenerValve.requestInit",
243                                      instances[i].getClass().getName()), t);
244                     ServletRequest sreq = request.getRequest();
245                     sreq.setAttribute(Globals.EXCEPTION_ATTR,t);
246                     return;
247                 }
248             }
249         }
250         */
251
252         wrapper.getPipeline().getFirst().event(request, response, event);
253
254         /*
255         if ((instances !=null ) &&
256                 (instances.length > 0)) {
257             // create post-service event
258             for (int i = 0; i < instances.length; i++) {
259                 if (instances[i] == null)
260                     continue;
261                 if (!(instances[i] instanceof ServletRequestListener))
262                     continue;
263                 ServletRequestListener listener =
264                     (ServletRequestListener) instances[i];
265                 try {
266                     listener.requestDestroyed(event);
267                 } catch (Throwable t) {
268                     container.getLogger().error(sm.getString("requestListenerValve.requestDestroy",
269                                      instances[i].getClass().getName()), t);
270                     ServletRequest sreq = request.getRequest();
271                     sreq.setAttribute(Globals.EXCEPTION_ATTR,t);
272                 }
273             }
274         }
275         */
276       
277     }
278
279
280     // -------------------------------------------------------- Private Methods
281
282
283     /**
284      * Report a "not found" error for the specified resource. FIXME: We
285      * should really be using the error reporting settings for this web
286      * application, but currently that code runs at the wrapper level rather
287      * than the context level.
288      *
289      * @param requestURI The request URI for the requested resource
290      * @param response The response we are creating
291      */
292     private void notFound(String JavaDoc requestURI, HttpServletResponse JavaDoc response) {
293
294         try {
295             response.sendError(HttpServletResponse.SC_NOT_FOUND, requestURI);
296         } catch (IllegalStateException JavaDoc e) {
297             ;
298         } catch (IOException JavaDoc e) {
299             ;
300         }
301
302     }
303
304
305 }
306
Popular Tags