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 1706239 2015-10-01 13:18:35Z tv $
74   */
75  @Deprecated
76  public class TurbineAvalonComponentService
77          extends TurbineBaseService
78          implements AvalonComponentService, Initializable, Disposable
79  {
80      /** Logging */
81      private static Log log = LogFactory.getLog(
82              TurbineAvalonComponentService.class);
83  
84      /** Component manager */
85      private ExcaliburComponentManager manager = null;
86  
87      // -------------------------------------------------------------
88      // Service initialization
89      // -------------------------------------------------------------
90  
91      /**
92       * Load all configured components and initialize them. This is
93       * a zero parameter variant which queries the Turbine Servlet
94       * for its config.
95       *
96       * @throws InitializationException Something went wrong in the init
97       *         stage
98       */
99      @Override
100     public void init()
101             throws InitializationException
102     {
103         try
104         {
105             initialize();
106 
107             setInit(true);
108         }
109         catch (Exception e)
110         {
111             throw new InitializationException("init failed", e);
112         }
113     }
114 
115     /**
116      * Shuts the Component Service down, calls dispose on the components that
117      * implement this interface
118      *
119      */
120     @Override
121     public void shutdown()
122     {
123         dispose();
124         setInit(false);
125     }
126 
127     // -------------------------------------------------------------
128     // Avalon lifecycle interfaces
129     // -------------------------------------------------------------
130 
131     /**
132      * Initializes the container
133      *
134      * @throws Exception generic exception
135      */
136     @Override
137     public void initialize() throws Exception
138     {
139         org.apache.commons.configuration.Configuration conf
140                 = getConfiguration();
141 
142         // get the filenames and expand them relative to webapp root
143         String sysConfigFilename = Turbine.getRealPath(
144                 conf.getString(COMPONENT_CONFIG_KEY, COMPONENT_CONFIG_VALUE));
145         String roleConfigFilename = Turbine.getRealPath(
146                 conf.getString(COMPONENT_ROLE_KEY, COMPONENT_ROLE_VALUE));
147 
148         log.debug("Config File: " + sysConfigFilename);
149         log.debug("Role File:   " + roleConfigFilename);
150 
151         // process configuration files
152 
153         DefaultConfigurationBuilder builder = new DefaultConfigurationBuilder();
154         Configuration sysConfig  = builder.buildFromFile(sysConfigFilename);
155         Configuration roleConfig = builder.buildFromFile(roleConfigFilename);
156 
157         // Create the LoggerManager for Log4J
158         LoggerManager lm = new Log4JLoggerManager();
159 
160         // Setup the RoleManager
161         DefaultRoleManager roles = new DefaultRoleManager();
162 
163         Logger logger = lm.getLoggerForCategory(AVALON_LOG_CATEGORY);
164 
165         roles.enableLogging(logger);
166         roles.configure(roleConfig);
167 
168         // Setup ECM
169         manager = new ExcaliburComponentManager();
170 
171         manager.setLoggerManager(lm);
172         manager.enableLogging(logger);
173 
174         DefaultContext context = new DefaultContext();
175         String realPath = Turbine.getRealPath("/");
176 
177         context.put(AvalonComponentService.COMPONENT_APP_ROOT, realPath);
178         // urn:avalon:home is used by Merlinized components.  Makes things
179         // a bit more backwards compatible.
180         context.put("urn:avalon:home", realPath);
181         System.setProperty("applicationRoot", realPath);
182         System.setProperty("urn:avalon:home", realPath);
183 
184         log.debug("Application Root is " + realPath);
185 
186         manager.contextualize(context);
187         manager.setRoleManager(roles);
188         manager.configure(sysConfig);
189 
190         // Init ECM!!!!
191         manager.initialize();
192 
193         List<Object> lookupComponents = conf.getList(COMPONENT_LOOKUP_KEY,
194                 new ArrayList<Object>());
195 
196         for (Iterator<Object> it = lookupComponents.iterator(); it.hasNext();)
197         {
198             String component = (String) it.next();
199             try
200             {
201                 Component c = manager.lookup(component);
202                 log.info("Lookup for Component " + component + " successful");
203                 manager.release(c);
204             }
205             catch (Exception e)
206             {
207                 log.error("Lookup for Component " + component + " failed!");
208             }
209         }
210     }
211 
212     /**
213      * Disposes of the container and releases resources
214      */
215     @Override
216     public void dispose()
217     {
218         manager.dispose();
219     }
220 
221     /**
222      * Returns an instance of the named component
223      *
224      * @param roleName Name of the role the component fills.
225      * @return an instance of the named component
226      */
227     @Override
228     public Object lookup(String roleName)
229             throws ServiceException
230     {
231         try
232         {
233             return manager.lookup(roleName);
234         }
235         catch (ComponentException e)
236         {
237             throw new ServiceException(name, e.getMessage());
238         }
239     }
240 
241     /**
242      * Releases the component
243      *
244      * @param component the component to release
245      */
246     @Override
247     public void release(Object component)
248     {
249         if( component instanceof Component )
250         {
251             manager.release((Component)component);
252         }
253     }
254 
255     /**
256      * @see org.apache.avalon.framework.service.ServiceManager#hasService(java.lang.String)
257      */
258     @Override
259     public boolean hasService(String roleName)
260     {
261         return manager.hasComponent(roleName);
262     }
263 
264     // -------------------------------------------------------------
265     // TurbineServiceProvider
266     // -------------------------------------------------------------
267 
268     /**
269      * @see org.apache.turbine.services.TurbineServiceProvider#exists(java.lang.String)
270      */
271     @Override
272     public boolean exists(String roleName)
273     {
274         return this.hasService(roleName);
275     }
276 
277     /**
278      * @see org.apache.turbine.services.TurbineServiceProvider#get(java.lang.String)
279      */
280     @Override
281     public Object get(String roleName) throws InstantiationException
282     {
283         try
284         {
285             return this.lookup(roleName);
286         }
287         catch (ServiceException e)
288         {
289             String msg = "Unable to get the following service : " + roleName;
290             log.error(msg);
291             throw new InstantiationException(msg);
292         }
293         catch (Throwable t)
294         {
295             String msg = "Unable to get the following service : " + roleName;
296             log.error(msg,t);
297             throw new InstantiationException(msg,t);
298         }
299     }
300 }