##### Coverage Report - org.apache.turbine.util.TurbineConfig

Classes in this File | Line Coverage | Branch Coverage | Complexity
TurbineConfig |
54% | 39/72
60% | 6/10
| 1.6176470588235294;1,618

1 |  |
     package org.apache.turbine.util;
2 |  |
3 |  |
4 |  |
     /*
5 |  |
      * Licensed to the Apache Software Foundation (ASF) under one
6 |  |
      * or more contributor license agreements.  See the NOTICE file
7 |  |
      * distributed with this work for additional information
8 |  |
      * regarding copyright ownership.  The ASF licenses this file
9 |  |
      * to you under the Apache License, Version 2.0 (the
10 |  |
      * "License"); you may not use this file except in compliance
11 |  |
      * with the License.  You may obtain a copy of the License at
12 |  |
      *
13 |  |
      *   http://www.apache.org/licenses/LICENSE-2.0
14 |  |
      *
15 |  |
      * Unless required by applicable law or agreed to in writing,
16 |  |
      * software distributed under the License is distributed on an
17 |  |
      * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
18 |  |
      * KIND, either express or implied.  See the License for the
19 |  |
      * specific language governing permissions and limitations
20 |  |
      * under the License.
21 |  |
      */
22 |  |
23 |  |
24 |  |
     import java.io.BufferedInputStream;
25 |  |
     import java.io.File;
26 |  |
     import java.io.FileInputStream;
27 |  |
     import java.io.FileNotFoundException;
28 |  |
     import java.io.InputStream;
29 |  |
     import java.net.MalformedURLException;
30 |  |
     import java.net.URL;
31 |  |
     import java.util.Enumeration;
32 |  |
     import java.util.HashMap;
33 |  |
     import java.util.Map;
34 |  |
     import java.util.Set;
35 |  |
     import java.util.Vector;
36 |  |
37 |  |
     import javax.servlet.RequestDispatcher;
38 |  |
     import javax.servlet.Servlet;
39 |  |
     import javax.servlet.ServletConfig;
40 |  |
     import javax.servlet.ServletContext;
41 |  |
42 |  |
     import org.apache.avalon.framework.activity.Disposable;
43 |  |
     import org.apache.avalon.framework.activity.Initializable;
44 |  |
     import org.apache.commons.logging.Log;
45 |  |
     import org.apache.commons.logging.LogFactory;
46 |  |
     import org.apache.turbine.Turbine;
47 |  |
48 |  |
     /**
49 |  |
      * A class used for initialization of Turbine without a servlet container.
50 |  |
      * <p>
51 |  |
      * If you need to use Turbine outside of a servlet container, you can
52 |  |
      * use this class for initialization of the Turbine servlet.
53 |  |
      * <p>
54 |  |
      * <blockquote><code><pre>
55 |  |
      * TurbineConfig config = new TurbineConfig(".", "conf/TurbineResources.properties");
56 |  |
      * </pre></code></blockquote>
57 |  |
      * <p>
58 |  |
      * All paths referenced in TurbineResources.properties and the path to
59 |  |
      * the properties file itself (the second argument) will be resolved
60 |  |
      * relative to the directory given as the first argument of the constructor,
61 |  |
      * here - the directory where application was started. Don't worry about
62 |  |
      * discarding the references to objects created above. They are not needed,
63 |  |
      * once everything is initialized.
64 |  |
      * <p>
65 |  |
      * In order to initialize the Services Framework outside of the Turbine Servlet,
66 |  |
      * you need to call the <code>init()</code> method. By default, this will
67 |  |
      * initialize the Resource and Logging Services and any other services you
68 |  |
      * have defined in your TurbineResources.properties file.
69 |  |
      *
70 |  |
      * @todo Make this class enforce the lifecycle contracts
71 |  |
      *
72 |  |
      * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
73 |  |
      * @author <a href="mailto:krzewski@e-point.pl">Rafal Krzewski</a>
74 |  |
      * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
75 |  |
      * @author <a href="mailto:dlr@collab.net">Daniel Rall</a>
76 |  |
      * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
77 |  |
      * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
78 |  |
      * @version $Id: TurbineConfig.java 1073174 2011-02-21 22:18:45Z tv $
79 |  |
      */
80 |  |
     public class TurbineConfig
81 |  |
             implements ServletConfig, ServletContext, Initializable, Disposable
82 |  |
     {
83 |  |
         /**
84 |  |
          * Servlet initialization parameter name for the path to
85 |  |
          * TurbineConfiguration.xml file used by Turbine
86 |  |
          */
87 |  |
         public static final String CONFIGURATION_PATH_KEY = "configuration";
88 |  |
89 |  |
         /**
90 |  |
          * Servlet initialization parameter name for the path to
91 |  |
          * Turbine.properties file used by Turbine
92 |  |
          */
93 |  |
         public static final String PROPERTIES_PATH_KEY = "properties";
94 |  |
95 |  |
         /**
96 |  |
          * Default value of TurbineResources.properties file path
97 |  |
          * (<code>/WEB-INF/conf/TurbineResources.properties</code>).
98 |  |
          */
99 |  |
         public static final String PROPERTIES_PATH_DEFAULT =
100 |  |
                 "/WEB-INF/conf/TurbineResources.properties";
101 |  |
102 |  |
         /** Filenames are looked up in this directory. */
103 |  |
         protected File root;
104 |  |
105 |  |
         /** Servlet container (or emulator) attributes. */
106 |  |
         protected Map<String, Object> attributes;
107 |  |
108 |  |
         /** Turbine servlet initialization parameters. */
109 |  |
         protected Map<String, String> initParams;
110 |  |
111 |  |
         /** The Turbine servlet instance used for initialization. */
112 |  |
         private Turbine turbine;
113 |  |
114 |  |
         /** Logging */
115 | 180 |
         private final Log log = LogFactory.getLog(this.getClass());
116 |  |
117 |  |
         /**
118 |  |
          * Constructs a new TurbineConfig.
119 |  |
          *
120 |  |
          * This is the general form of the constructor. You can provide
121 |  |
          * a path to search for files, and a name-value map of init
122 |  |
          * parameters.
123 |  |
          *
124 |  |
          * <p> For the list of recognized init parameters, see
125 |  |
          * {@link org.apache.turbine.Turbine} class.
126 |  |
          *
127 |  |
          * @param path The web application root (i.e. the path for file lookup).
128 |  |
          * @param attributes Servlet container (or emulator) attributes.
129 |  |
          * @param initParams initialization parameters.
130 |  |
          */
131 |  |
         public TurbineConfig(String path, Map<String, Object> attributes,
132 |  |
                 Map<String, String> initParams)
133 | 180 |
         {
134 | 180 |
             root = new File(path);
135 | 180 |
             this.attributes = attributes;
136 | 180 |
             this.initParams = initParams;
137 | 180 |
         }
138 |  |
139 |  |
         /**
140 |  |
          * @see #TurbineConfig(String path, Map attributes, Map initParams)
141 |  |
          */
142 |  |
         public TurbineConfig(String path, Map<String, String> initParams)
143 |  |
         {
144 | 176 |
             this(path, new HashMap<String, Object>(0), initParams);
145 | 176 |
         }
146 |  |
147 |  |
         /**
148 |  |
          * Constructs a TurbineConfig.
149 |  |
          *
150 |  |
          * This is a specialized constructor that allows to configure
151 |  |
          * Turbine easily in the common setups.
152 |  |
          *
153 |  |
          * @param path The web application root (i.e. the path for file lookup).
154 |  |
          * @param properties the relative path to TurbineResources.properties file
155 |  |
          */
156 |  |
         public TurbineConfig(String path, String properties)
157 |  |
         {
158 | 172 |
             this(path, new HashMap<String, String>(1));
159 | 172 |
             initParams.put(PROPERTIES_PATH_KEY, properties);
160 | 172 |
         }
161 |  |
162 |  |
         /**
163 |  |
          * Causes this class to initialize itself which in turn initializes
164 |  |
          * all of the Turbine Services that need to be initialized.
165 |  |
          */
166 |  |
         public void initialize()
167 |  |
         {
168 |  |
             try
169 |  |
             {
170 | 174 |
                 turbine = new Turbine();
171 | 174 |
                 turbine.init(this);
172 |  |
             }
173 | 0 |
             catch (Exception e)
174 |  |
             {
175 | 0 |
                 log.error("TurbineConfig: Initialization failed", e);
176 | 174 |
             }
177 | 174 |
         }
178 |  |
179 |  |
         /**
180 |  |
          * Initialization requiring a HTTP <code>GET</code> request.
181 |  |
          */
182 |  |
         public void init(RunData data)
183 |  |
         {
184 | 0 |
             if (turbine != null)
185 |  |
             {
186 | 0 |
                 turbine.init(data);
187 |  |
             }
188 | 0 |
         }
189 |  |
190 |  |
         /**
191 |  |
          * Shutdown the Turbine System, lifecycle style
192 |  |
          *
193 |  |
          */
194 |  |
         public void dispose()
195 |  |
         {
196 | 92 |
             if (turbine != null)
197 |  |
             {
198 | 92 |
                 turbine.destroy();
199 |  |
             }
200 | 92 |
         }
201 |  |
202 |  |
         /**
203 |  |
          * Returns a reference to the Turbine servlet that was initialized.
204 |  |
          *
205 |  |
          * @return a ServletContext reference
206 |  |
          */
207 |  |
         public Turbine getTurbine()
208 |  |
         {
209 | 6 |
             return turbine;
210 |  |
         }
211 |  |
212 |  |
         /**
213 |  |
          * Returns a reference to the object cast onto ServletContext type.
214 |  |
          *
215 |  |
          * @return a ServletContext reference
216 |  |
          */
217 |  |
         public ServletContext getServletContext()
218 |  |
         {
219 | 200 |
             return this;
220 |  |
         }
221 |  |
222 |  |
         /**
223 |  |
          * Translates a path relative to the web application root into an
224 |  |
          * absolute path.
225 |  |
          *
226 |  |
          * @param path A path relative to the web application root.
227 |  |
          * @return An absolute version of the supplied path, or <code>null</code>
228 |  |
          * if the translated path doesn't map to a file or directory.
229 |  |
          */
230 |  |
         public String getRealPath(String path)
231 |  |
         {
232 | 104 |
             String result = null;
233 | 104 |
             File f = new File(root, path);
234 |  |
235 | 104 |
             if (log.isDebugEnabled())
236 |  |
             {
237 | 104 |
                 StringBuffer sb = new StringBuffer();
238 |  |
239 | 104 |
                 sb.append("TurbineConfig.getRealPath: path '");
240 | 104 |
                 sb.append(path);
241 | 104 |
                 sb.append("' translated to '");
242 | 104 |
                 sb.append(f.getPath());
243 | 104 |
                 sb.append("' ");
244 | 104 |
                 sb.append(f.exists() ? "" : "not ");
245 | 104 |
                 sb.append("found");
246 | 104 |
                 log.debug(sb.toString());
247 |  |
             }
248 |  |
249 | 104 |
             if (f.exists())
250 |  |
             {
251 | 100 |
               result = f.getPath();
252 |  |
             }
253 |  |
             else
254 |  |
             {
255 | 4 |
                 log.error("getRealPath(\"" + path + "\") is undefined, returning null");
256 |  |
             }
257 |  |
258 | 104 |
             return result;
259 |  |
         }
260 |  |
261 |  |
         /**
262 |  |
          * Retrieves an initialization parameter.
263 |  |
          *
264 |  |
          * @param name the name of the parameter.
265 |  |
          * @return the value of the parameter.
266 |  |
          */
267 |  |
         public String getInitParameter(String name)
268 |  |
         {
269 | 1206 |
             return initParams.get(name);
270 |  |
         }
271 |  |
272 |  |
         /**
273 |  |
          * Retrieves an Enumeration of initialization parameter names.
274 |  |
          *
275 |  |
          * @return an Enumeration of initialization parameter names.
276 |  |
          */
277 |  |
         public Enumeration getInitParameterNames()
278 |  |
         {
279 | 0 |
             return new Vector<String>(initParams.keySet()).elements();
280 |  |
         }
281 |  |
282 |  |
         /**
283 |  |
          * Returns the servlet name.
284 |  |
          *
285 |  |
          * Fixed value "Turbine" is returned.
286 |  |
          *
287 |  |
          * @return the servlet name.
288 |  |
          */
289 |  |
         public String getServletName()
290 |  |
         {
291 | 0 |
             return "Turbine";
292 |  |
         }
293 |  |
294 |  |
         /**
295 |  |
          * Returns the context name.
296 |  |
          *
297 |  |
          * Fixed value "Turbine" is returned
298 |  |
          *
299 |  |
          * @return the context name
300 |  |
          */
301 |  |
         public String getServletContextName()
302 |  |
         {
303 | 0 |
             return "Turbine";
304 |  |
         }
305 |  |
306 |  |
         /**
307 |  |
          * Returns the context path.
308 |  |
          *
309 |  |
          * Fixed value "/turbine" is returned
310 |  |
          *
311 |  |
          * @return the context path
312 |  |
          */
313 |  |
         public String getContextPath()
314 |  |
         {
315 | 0 |
             return "/turbine";
316 |  |
             }
317 |  |
318 |  |
             /**
319 |  |
          * Returns a URL to the resource that is mapped to a specified
320 |  |
          * path. The path must begin with a "/" and is interpreted
321 |  |
          * as relative to the current context root.
322 |  |
          *
323 |  |
          * @param s the path to the resource
324 |  |
          * @return a URL pointing to the resource
325 |  |
          * @exception MalformedURLException
326 |  |
          */
327 |  |
         public URL getResource(String s)
328 |  |
                 throws MalformedURLException
329 |  |
         {
330 | 0 |
             return new URL("file://" + getRealPath(s));
331 |  |
         }
332 |  |
333 |  |
         /**
334 |  |
          * Returns the resource located at the named path as
335 |  |
          * an <code>InputStream</code> object.
336 |  |
          *
337 |  |
          * @param s the path to the resource
338 |  |
          * @return an InputStream object from which the resource can be read
339 |  |
          */
340 |  |
         public InputStream getResourceAsStream(String s)
341 |  |
         {
342 |  |
             try
343 |  |
             {
344 | 8 |
                 FileInputStream fis = new FileInputStream(getRealPath(s));
345 | 4 |
                 return new BufferedInputStream(fis);
346 |  |
             }
347 | 0 |
             catch (FileNotFoundException e)
348 |  |
             {
349 | 0 |
                 return null;
350 |  |
             }
351 |  |
         }
352 |  |
353 |  |
         /**
354 |  |
          * Logs an error message.
355 |  |
          *
356 |  |
          * @param e an Exception.
357 |  |
          * @param m a message.
358 |  |
          * @deprecated use log(String,Throwable) instead
359 |  |
          */
360 |  |
         @Deprecated
361 |  |
         public void log(Exception e, String m)
362 |  |
         {
363 | 0 |
             log.info(m, e);
364 | 0 |
         }
365 |  |
366 |  |
         /**
367 |  |
          * Logs a message.
368 |  |
          *
369 |  |
          * @param m a message.
370 |  |
          */
371 |  |
         public void log(String m)
372 |  |
         {
373 | 0 |
             log.info(m);
374 | 0 |
         }
375 |  |
376 |  |
         /**
377 |  |
          * Logs an error message.
378 |  |
          *
379 |  |
          * @param t a Throwable object.
380 |  |
          * @param m a message.
381 |  |
          */
382 |  |
         public void log(String m, Throwable t)
383 |  |
         {
384 | 0 |
             log.info(m, t);
385 | 0 |
         }
386 |  |
387 |  |
         /**
388 |  |
          * Returns the servlet container attribute with the given name, or
389 |  |
          * null if there is no attribute by that name.
390 |  |
          */
391 |  |
         public Object getAttribute(String s)
392 |  |
         {
393 | 0 |
             return attributes.get(s);
394 |  |
         }
395 |  |
396 |  |
         /**
397 |  |
          * Returns an Enumeration containing the attribute names available
398 |  |
          * within this servlet context.
399 |  |
          */
400 |  |
         public Enumeration getAttributeNames()
401 |  |
         {
402 | 0 |
             return new Vector<String>(attributes.keySet()).elements();
403 |  |
         }
404 |  |
405 |  |
         // Unimplemented methods follow
406 |  |
407 |  |
         /**
408 |  |
          * Not implemented.
409 |  |
          *
410 |  |
          * A method in ServletConfig or ServletContext interface that is not
411 |  |
          * implemented and will throw <code>UnsuportedOperationException</code>
412 |  |
          * upon invocation
413 |  |
          */
414 |  |
         public ServletContext getContext(String s)
415 |  |
         {
416 | 0 |
             throw new UnsupportedOperationException();
417 |  |
         }
418 |  |
419 |  |
         /**
420 |  |
          * Not implemented.
421 |  |
          *
422 |  |
          * A method in ServletConfig or ServletContext interface that is not
423 |  |
          * implemented and will throw <code>UnsuportedOperationException</code>
424 |  |
          * upon invocation
425 |  |
          */
426 |  |
         public int getMajorVersion()
427 |  |
         {
428 | 0 |
             throw new UnsupportedOperationException();
429 |  |
         }
430 |  |
431 |  |
         /**
432 |  |
          * Not implemented.
433 |  |
          *
434 |  |
          * A method in ServletConfig or ServletContext interface that is not
435 |  |
          * implemented and will throw <code>UnsuportedOperationException</code>
436 |  |
          * upon invocation
437 |  |
          */
438 |  |
         public String getMimeType(String s)
439 |  |
         {
440 | 0 |
             throw new UnsupportedOperationException();
441 |  |
         }
442 |  |
443 |  |
         /**
444 |  |
          * Not implemented.
445 |  |
          *
446 |  |
          * A method in ServletConfig or ServletContext interface that is not
447 |  |
          * implemented and will throw <code>UnsuportedOperationException</code>
448 |  |
          * upon invocation
449 |  |
          */
450 |  |
         public int getMinorVersion()
451 |  |
         {
452 | 0 |
             throw new UnsupportedOperationException();
453 |  |
         }
454 |  |
455 |  |
         /**
456 |  |
          * Not implemented.
457 |  |
          *
458 |  |
          * A method in ServletConfig or ServletContext interface that is not
459 |  |
          * implemented and will throw <code>UnsuportedOperationException</code>
460 |  |
          * upon invocation
461 |  |
          */
462 |  |
         public RequestDispatcher getNamedDispatcher(String s)
463 |  |
         {
464 | 0 |
             throw new UnsupportedOperationException();
465 |  |
         }
466 |  |
467 |  |
         /**
468 |  |
          * Not implemented.
469 |  |
          *
470 |  |
          * A method in ServletConfig or ServletContext interface that is not
471 |  |
          * implemented and will throw <code>UnsuportedOperationException</code>
472 |  |
          * upon invocation
473 |  |
          */
474 |  |
         public RequestDispatcher getRequestDispatcher(String s)
475 |  |
         {
476 | 0 |
             throw new UnsupportedOperationException();
477 |  |
         }
478 |  |
479 |  |
         /**
480 |  |
          * Not implemented.
481 |  |
          *
482 |  |
          * A method in ServletContext (2.3) interface that is not implemented and
483 |  |
          * will throw <code>UnsuportedOperationException</code> upon invocation
484 |  |
          */
485 |  |
         public Set getResourcePaths(String s)
486 |  |
         {
487 | 0 |
             throw new UnsupportedOperationException();
488 |  |
         }
489 |  |
490 |  |
         /**
491 |  |
          * Not implemented.
492 |  |
          *
493 |  |
          * A method in ServletContext (2.3) interface that is not implemented and
494 |  |
          * will throw <code>UnsuportedOperationException</code> upon invocation
495 |  |
          */
496 |  |
         public String getServerInfo()
497 |  |
         {
498 | 0 |
             throw new UnsupportedOperationException();
499 |  |
         }
500 |  |
501 |  |
         /**
502 |  |
          * Not implemented.
503 |  |
          *
504 |  |
          * A method in ServletContext interface that is not implemented and will
505 |  |
          * throw <code>UnsuportedOperationException</code> upon invocation
506 |  |
          * @deprecated As of Java Servlet API 2.1, with no direct replacement.
507 |  |
          */
508 |  |
         @Deprecated
509 |  |
         public Servlet getServlet(String s)
510 |  |
         {
511 | 0 |
             throw new UnsupportedOperationException();
512 |  |
         }
513 |  |
514 |  |
         /**
515 |  |
          * Not implemented.
516 |  |
          *
517 |  |
          * A method in ServletContext interface that is not implemented and will
518 |  |
          * throw <code>UnsuportedOperationException</code> upon invocation
519 |  |
          * @deprecated As of Java Servlet API 2.1, with no replacement.
520 |  |
          */
521 |  |
         @Deprecated
522 |  |
         public Enumeration getServletNames()
523 |  |
         {
524 | 0 |
             throw new UnsupportedOperationException();
525 |  |
         }
526 |  |
527 |  |
         /**
528 |  |
          * Not implemented.
529 |  |
          *
530 |  |
          * A method in ServletContext interface that is not implemented and will
531 |  |
          * throw <code>UnsuportedOperationException</code> upon invocation
532 |  |
          * @deprecated As of Java Servlet API 2.0, with no replacement.
533 |  |
          */
534 |  |
         @Deprecated
535 |  |
         public Enumeration getServlets()
536 |  |
         {
537 | 0 |
             throw new UnsupportedOperationException();
538 |  |
         }
539 |  |
540 |  |
         /**
541 |  |
          * Not implemented.
542 |  |
          *
543 |  |
          * A method in ServletContext interface that is not implemented and will
544 |  |
          * throw <code>UnsuportedOperationException</code> upon invocation
545 |  |
          */
546 |  |
         public void removeAttribute(String s)
547 |  |
         {
548 | 0 |
             throw new UnsupportedOperationException();
549 |  |
         }
550 |  |
551 |  |
         /**
552 |  |
          * Not implemented.
553 |  |
          *
554 |  |
          * A method in ServletContext interface that is not implemented and will
555 |  |
          * throw <code>UnsuportedOperationException</code> upon invocation
556 |  |
          */
557 |  |
         public void setAttribute(String s, Object o)
558 |  |
         {
559 | 0 |
             throw new UnsupportedOperationException();
560 |  |
         }
561 |  |
     }