View Javadoc

1   package org.apache.turbine.services.avaloncomponent;
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.util.ArrayList;
25  import java.util.Iterator;
26  import java.util.List;
27  
28  import org.apache.avalon.excalibur.component.DefaultRoleManager;
29  import org.apache.avalon.excalibur.component.ExcaliburComponentManager;
30  import org.apache.avalon.excalibur.logger.Log4JLoggerManager;
31  import org.apache.avalon.excalibur.logger.LoggerManager;
32  import org.apache.avalon.framework.activity.Disposable;
33  import org.apache.avalon.framework.activity.Initializable;
34  import org.apache.avalon.framework.component.Component;
35  import org.apache.avalon.framework.component.ComponentException;
36  import org.apache.avalon.framework.configuration.Configuration;
37  import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
38  import org.apache.avalon.framework.context.DefaultContext;
39  import org.apache.avalon.framework.logger.Logger;
40  import org.apache.avalon.framework.service.ServiceException;
41  import org.apache.commons.logging.Log;
42  import org.apache.commons.logging.LogFactory;
43  import org.apache.turbine.Turbine;
44  import org.apache.turbine.services.InitializationException;
45  import org.apache.turbine.services.InstantiationException;
46  import org.apache.turbine.services.TurbineBaseService;
47  
48  /**
49   * An implementation of AvalonComponentService which loads all the
50   * components given in the TurbineResources.properties File.
51   * <p>
52   * For component which require the location of the application or
53   * context root, there are two ways to get it.
54   * <ol>
55   * <li>
56   *   Implement the Contextualizable interface.  The full path to the
57   *   correct OS directory can be found under the ComponentAppRoot key.
58   * </li>
59   * <li>
60   *   The system property "applicationRoot" is also set to the full path
61   *   of the correct OS directory.
62   * </li>
63   * </ol>
64   * If you want to initialize Torque by using the AvalonComponentService, you
65   * must activate Torque at initialization time by specifying
66   *
67   * services.AvalonComponentService.lookup = org.apache.torque.Torque
68   *
69   * in your TurbineResources.properties.
70   *
71   * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
72   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
73   * @version $Id: TurbineAvalonComponentService.java 615328 2008-01-25 20:25:05Z tv $
74   */
75  public class TurbineAvalonComponentService
76          extends TurbineBaseService
77          implements AvalonComponentService, Initializable, Disposable
78  {
79      /** Logging */
80      private static Log log = LogFactory.getLog(
81              TurbineAvalonComponentService.class);
82  
83      /** Component manager */
84      private ExcaliburComponentManager manager = null;
85  
86      // -------------------------------------------------------------
87      // Service initialization
88      // -------------------------------------------------------------
89  
90      /**
91       * Load all configured components and initialize them. This is
92       * a zero parameter variant which queries the Turbine Servlet
93       * for its config.
94       *
95       * @throws InitializationException Something went wrong in the init
96       *         stage
97       */
98      public void init()
99              throws InitializationException
100     {
101         try
102         {
103             initialize();
104 
105             setInit(true);
106         }
107         catch (Exception e)
108         {
109             throw new InitializationException("init failed", e);
110         }
111     }
112 
113     /**
114      * Shuts the Component Service down, calls dispose on the components that
115      * implement this interface
116      *
117      */
118     public void shutdown()
119     {
120         dispose();
121         setInit(false);
122     }
123 
124     // -------------------------------------------------------------
125     // Avalon lifecycle interfaces
126     // -------------------------------------------------------------
127 
128     /**
129      * Initializes the container
130      *
131      * @throws Exception generic exception
132      */
133     public void initialize() throws Exception
134     {
135         org.apache.commons.configuration.Configuration conf
136                 = getConfiguration();
137 
138         // get the filenames and expand them relative to webapp root
139         String sysConfigFilename = Turbine.getRealPath(
140                 conf.getString(COMPONENT_CONFIG_KEY, COMPONENT_CONFIG_VALUE));
141         String roleConfigFilename = Turbine.getRealPath(
142                 conf.getString(COMPONENT_ROLE_KEY, COMPONENT_ROLE_VALUE));
143 
144         log.debug("Config File: " + sysConfigFilename);
145         log.debug("Role File:   " + roleConfigFilename);
146 
147         // process configuration files
148 
149         DefaultConfigurationBuilder builder = new DefaultConfigurationBuilder();
150         Configuration sysConfig  = builder.buildFromFile(sysConfigFilename);
151         Configuration roleConfig = builder.buildFromFile(roleConfigFilename);
152 
153         // Create the LoggerManager for Log4J
154         LoggerManager lm = new Log4JLoggerManager();
155 
156         // Setup the RoleManager
157         DefaultRoleManager roles = new DefaultRoleManager();
158 
159         Logger logger = lm.getLoggerForCategory(AVALON_LOG_CATEGORY);
160 
161         roles.enableLogging(logger);
162         roles.configure(roleConfig);
163 
164         // Setup ECM
165         manager = new ExcaliburComponentManager();
166 
167         manager.setLoggerManager(lm);
168         manager.enableLogging(logger);
169 
170         DefaultContext context = new DefaultContext();
171         String realPath = Turbine.getRealPath("/");
172 
173         context.put(AvalonComponentService.COMPONENT_APP_ROOT, realPath);
174         // urn:avalon:home is used by Merlinized components.  Makes things
175         // a bit more backwards compatible.
176         context.put("urn:avalon:home", realPath);
177         System.setProperty("applicationRoot", realPath);
178         System.setProperty("urn:avalon:home", realPath);
179 
180         log.debug("Application Root is " + realPath);
181 
182         manager.contextualize(context);
183         manager.setRoleManager(roles);
184         manager.configure(sysConfig);
185 
186         // Init ECM!!!!
187         manager.initialize();
188 
189         List lookupComponents = conf.getList(COMPONENT_LOOKUP_KEY,
190                 new ArrayList());
191 
192         for (Iterator it = lookupComponents.iterator(); it.hasNext();)
193         {
194             String component = (String) it.next();
195             try
196             {
197                 Component c = manager.lookup(component);
198                 log.info("Lookup for Component " + component + " successful");
199                 manager.release(c);
200             }
201             catch (Exception e)
202             {
203                 log.error("Lookup for Component " + component + " failed!");
204             }
205         }
206     }
207 
208     /**
209      * Disposes of the container and releases resources
210      */
211     public void dispose()
212     {
213         manager.dispose();
214     }
215 
216     /**
217      * Returns an instance of the named component
218      *
219      * @param roleName Name of the role the component fills.
220      * @return an instance of the named component
221      * @throws ComponentException generic exception
222      */
223     public Object lookup(String roleName)
224             throws ServiceException
225     {
226         try
227         {
228             return manager.lookup(roleName);
229         }
230         catch (ComponentException e)
231         {
232             throw new ServiceException(name, e.getMessage());
233         }
234     }
235 
236     /**
237      * Releases the component
238      *
239      * @param component the component to release
240      */
241     public void release(Object component)
242     {
243         if( component instanceof Component )
244         {
245             manager.release((Component)component);
246         }
247     }
248 
249     /**
250      * @see org.apache.avalon.framework.service.ServiceManager#hasService(java.lang.String)
251      */
252     public boolean hasService(String roleName)
253     {
254         return manager.hasComponent(roleName);
255     }
256 
257     // -------------------------------------------------------------
258     // TurbineServiceProvider
259     // -------------------------------------------------------------
260 
261     /**
262      * @see org.apache.turbine.services.TurbineServiceProvider#exists(java.lang.String)
263      */
264     public boolean exists(String roleName)
265     {
266         return this.hasService(roleName);
267     }
268 
269     /**
270      * @see org.apache.turbine.services.TurbineServiceProvider#get(java.lang.String)
271      */
272     public Object get(String roleName) throws InstantiationException
273     {
274         try
275         {
276             return this.lookup(roleName);
277         }
278         catch (ServiceException e)
279         {
280             String msg = "Unable to get the following service : " + roleName;
281             log.error(msg);
282             throw new InstantiationException(msg);
283         }
284         catch (Throwable t)
285         {
286             String msg = "Unable to get the following service : " + roleName;
287             log.error(msg,t);
288             throw new InstantiationException(msg,t);
289         }
290     }
291 }