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 }