001 package org.apache.turbine.util;
002
003
004 /*
005 * Licensed to the Apache Software Foundation (ASF) under one
006 * or more contributor license agreements. See the NOTICE file
007 * distributed with this work for additional information
008 * regarding copyright ownership. The ASF licenses this file
009 * to you under the Apache License, Version 2.0 (the
010 * "License"); you may not use this file except in compliance
011 * with the License. You may obtain a copy of the License at
012 *
013 * http://www.apache.org/licenses/LICENSE-2.0
014 *
015 * Unless required by applicable law or agreed to in writing,
016 * software distributed under the License is distributed on an
017 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
018 * KIND, either express or implied. See the License for the
019 * specific language governing permissions and limitations
020 * under the License.
021 */
022
023
024 import java.io.BufferedInputStream;
025 import java.io.File;
026 import java.io.FileInputStream;
027 import java.io.FileNotFoundException;
028 import java.io.InputStream;
029 import java.net.MalformedURLException;
030 import java.net.URL;
031 import java.util.Enumeration;
032 import java.util.HashMap;
033 import java.util.Map;
034 import java.util.Set;
035 import java.util.Vector;
036
037 import javax.servlet.RequestDispatcher;
038 import javax.servlet.Servlet;
039 import javax.servlet.ServletConfig;
040 import javax.servlet.ServletContext;
041
042 import org.apache.avalon.framework.activity.Disposable;
043 import org.apache.avalon.framework.activity.Initializable;
044 import org.apache.commons.logging.Log;
045 import org.apache.commons.logging.LogFactory;
046 import org.apache.turbine.Turbine;
047
048 /**
049 * A class used for initialization of Turbine without a servlet container.
050 * <p>
051 * If you need to use Turbine outside of a servlet container, you can
052 * use this class for initialization of the Turbine servlet.
053 * <p>
054 * <blockquote><code><pre>
055 * TurbineConfig config = new TurbineConfig(".", "conf/TurbineResources.properties");
056 * </pre></code></blockquote>
057 * <p>
058 * All paths referenced in TurbineResources.properties and the path to
059 * the properties file itself (the second argument) will be resolved
060 * relative to the directory given as the first argument of the constructor,
061 * here - the directory where application was started. Don't worry about
062 * discarding the references to objects created above. They are not needed,
063 * once everything is initialized.
064 * <p>
065 * In order to initialize the Services Framework outside of the Turbine Servlet,
066 * you need to call the <code>init()</code> method. By default, this will
067 * initialize the Resource and Logging Services and any other services you
068 * have defined in your TurbineResources.properties file.
069 *
070 * @todo Make this class enforce the lifecycle contracts
071 *
072 * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
073 * @author <a href="mailto:krzewski@e-point.pl">Rafal Krzewski</a>
074 * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
075 * @author <a href="mailto:dlr@collab.net">Daniel Rall</a>
076 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
077 * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
078 * @version $Id: TurbineConfig.java 1073174 2011-02-21 22:18:45Z tv $
079 */
080 public class TurbineConfig
081 implements ServletConfig, ServletContext, Initializable, Disposable
082 {
083 /**
084 * Servlet initialization parameter name for the path to
085 * TurbineConfiguration.xml file used by Turbine
086 */
087 public static final String CONFIGURATION_PATH_KEY = "configuration";
088
089 /**
090 * Servlet initialization parameter name for the path to
091 * Turbine.properties file used by Turbine
092 */
093 public static final String PROPERTIES_PATH_KEY = "properties";
094
095 /**
096 * Default value of TurbineResources.properties file path
097 * (<code>/WEB-INF/conf/TurbineResources.properties</code>).
098 */
099 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 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 {
134 root = new File(path);
135 this.attributes = attributes;
136 this.initParams = initParams;
137 }
138
139 /**
140 * @see #TurbineConfig(String path, Map attributes, Map initParams)
141 */
142 public TurbineConfig(String path, Map<String, String> initParams)
143 {
144 this(path, new HashMap<String, Object>(0), initParams);
145 }
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 this(path, new HashMap<String, String>(1));
159 initParams.put(PROPERTIES_PATH_KEY, properties);
160 }
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 turbine = new Turbine();
171 turbine.init(this);
172 }
173 catch (Exception e)
174 {
175 log.error("TurbineConfig: Initialization failed", e);
176 }
177 }
178
179 /**
180 * Initialization requiring a HTTP <code>GET</code> request.
181 */
182 public void init(RunData data)
183 {
184 if (turbine != null)
185 {
186 turbine.init(data);
187 }
188 }
189
190 /**
191 * Shutdown the Turbine System, lifecycle style
192 *
193 */
194 public void dispose()
195 {
196 if (turbine != null)
197 {
198 turbine.destroy();
199 }
200 }
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 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 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 String result = null;
233 File f = new File(root, path);
234
235 if (log.isDebugEnabled())
236 {
237 StringBuffer sb = new StringBuffer();
238
239 sb.append("TurbineConfig.getRealPath: path '");
240 sb.append(path);
241 sb.append("' translated to '");
242 sb.append(f.getPath());
243 sb.append("' ");
244 sb.append(f.exists() ? "" : "not ");
245 sb.append("found");
246 log.debug(sb.toString());
247 }
248
249 if (f.exists())
250 {
251 result = f.getPath();
252 }
253 else
254 {
255 log.error("getRealPath(\"" + path + "\") is undefined, returning null");
256 }
257
258 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 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 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 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 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 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 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 FileInputStream fis = new FileInputStream(getRealPath(s));
345 return new BufferedInputStream(fis);
346 }
347 catch (FileNotFoundException e)
348 {
349 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 log.info(m, e);
364 }
365
366 /**
367 * Logs a message.
368 *
369 * @param m a message.
370 */
371 public void log(String m)
372 {
373 log.info(m);
374 }
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 log.info(m, t);
385 }
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 throw new UnsupportedOperationException();
560 }
561 }