package org.apache.turbine.services.assemblerbroker;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.ConcurrentMap;

 import org.apache.commons.configuration2.Configuration;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

 import org.apache.turbine.Turbine;

 import org.apache.turbine.TurbineConstants;

 import org.apache.turbine.annotation.AnnotationProcessor;

 import org.apache.turbine.modules.Assembler;

 import org.apache.turbine.modules.Loader;

 import org.apache.turbine.services.InitializationException;

 import org.apache.turbine.services.TurbineBaseService;

 import org.apache.turbine.services.assemblerbroker.util.AssemblerFactory;

 import org.apache.turbine.util.TurbineException;

 /**

  * TurbineAssemblerBrokerService allows assemblers (like screens,

  * actions and layouts) to be loaded from one or more AssemblerFactory

  * classes.  AssemblerFactory classes are registered with this broker

  * by adding them to the TurbineResources.properties file.

  *

  * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>

  * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>

  * @version $Id: TurbineAssemblerBrokerService.java 1854688 2019-03-03 10:36:42Z tv $

  */

 public class TurbineAssemblerBrokerService

         extends TurbineBaseService

         implements AssemblerBrokerService

 {

     /** Logging */

     private static Logger log

             = LogManager.getLogger(TurbineAssemblerBrokerService.class);

     /** A structure that holds the registered AssemblerFactories */

     private Map<Class<?>, List<?>> factories = null;

     /** A cache that holds the generated Assemblers */

     private ConcurrentMap<String, Assembler> assemblerCache = null;

     /** A cache that holds the Loaders */

     private ConcurrentMap<Class<?>, Loader<? extends Assembler>> loaderCache = null;

     /** Caching on/off */

     private boolean isCaching;

     /**

      * Get a list of AssemblerFactories of a certain type

      *

      * @param type type of Assembler

      *

      * @param <T> the type of the assembler

      *

      * @return list of AssemblerFactories

      */

     @SuppressWarnings("unchecked")

     private <T extends Assembler> List<AssemblerFactory<T>> getFactoryGroup(Class<T> type)

     {

         if (!factories.containsKey(type))

         {

             factories.put(type, new ArrayList<AssemblerFactory<T>>());

         }

         return (List<AssemblerFactory<T>>) factories.get(type);

     }

     /**

      * Utility method to register all factories for a given type.

      *

      * @param type type of Assembler

      * @throws TurbineException if the factory for the given type could not be registered

      */

     private void registerFactories(String type)

         throws TurbineException

     {

         List<Object> names = getConfiguration().getList(type);

         log.info("Registering {} {} factories.", Integer.valueOf(names.size()), type);

         for (Iterator<Object> it = names.iterator(); it.hasNext(); )

         {

             String factory = (String) it.next();

             try

             {

                 @SuppressWarnings("unchecked")

                 AssemblerFactory<? extends Assembler> af =

                     (AssemblerFactory<? extends Assembler>) Class.forName(factory).newInstance();

                 registerFactory(af);

             }

             // these must be passed to the VM

             catch (ThreadDeath | OutOfMemoryError e)

             {

                 throw e;

             }

             // when using Class.forName(), NoClassDefFoundErrors are likely

             // to happen (missing jar files)

             catch (Throwable t)

             {

                 throw new TurbineException("Failed registering " + type

                         + " factory: " + factory, t);

             }

         }

     }

     /**

      * Initializes the AssemblerBroker and loads the AssemblerFactory

      * classes registered in TurbineResources.Properties.

      *

      * @throws InitializationException if problems occur while registering the factories

      */

     @Override

     public void init()

         throws InitializationException

     {

         factories = new HashMap<Class<?>, List<?>>();

         try

         {

             Configuration conf = getConfiguration();

             for (Iterator<String> i = conf.getKeys(); i.hasNext();)

             {

                 String type = i.next();

                 if (!"classname".equalsIgnoreCase(type))

                 {

                     registerFactories(type);

                 }

             }

         }

         catch (TurbineException e)

         {

             throw new InitializationException(

                     "AssemblerBrokerService failed to initialize", e);

         }

         isCaching = Turbine.getConfiguration()

             .getBoolean(TurbineConstants.MODULE_CACHE_KEY,

                         TurbineConstants.MODULE_CACHE_DEFAULT);

         if (isCaching)

         {

             int cacheSize = Turbine.getConfiguration()

                 .getInt(TurbineConstants.MODULE_CACHE_SIZE_KEY,

                         TurbineConstants.MODULE_CACHE_SIZE_DEFAULT);

             assemblerCache = new ConcurrentHashMap<String, Assembler>(cacheSize);

             loaderCache = new ConcurrentHashMap<Class<?>, Loader<? extends Assembler>>(cacheSize);

         }

         setInit(true);

     }

     /**

      * Register a new AssemblerFactory

      *

      * @param factory factory to register

      *

      * @param <T> the type of the assembler

      *

      */

     @Override

     public <T extends Assembler> void registerFactory(AssemblerFactory<T> factory)

     {

         getFactoryGroup(factory.getManagedClass()).add(factory);

     }

     /**

      * Attempt to retrieve an Assembler of a given type with

      * a name.  Cycle through all the registered AssemblerFactory

      * classes of type and return the first non-null assembly

      * found.  If an assembly was not found return null.

      *

      * @param type type of Assembler

      * @param name name of the requested Assembler

      *

      * @param <T> the type of the assembler

      *

      * @return an Assembler or null

      * @throws TurbineException if the assembler could not be loaded

      */

     @Override

     @SuppressWarnings("unchecked")

     public <T extends Assembler> T getAssembler(Class<T> type, String name)

         throws TurbineException

     {

         String key = type + ":" + name;

         T assembler = null;

         if (isCaching && assemblerCache.containsKey(key))

         {

             assembler = (T) assemblerCache.get(key);

             log.debug("Found {} in the cache!", key);

         }

         else

         {

             log.debug("Loading {}", key);

             List<AssemblerFactory<T>> facs = getFactoryGroup(type);

             for (Iterator<AssemblerFactory<T>> it = facs.iterator(); (assembler == null) && it.hasNext();)

             {

                 AssemblerFactory<T> fac = it.next();

                 try

                 {

                     assembler = fac.getAssembler(name);

                 }

                 catch (Exception e)

                 {

                     throw new TurbineException("Failed to load an assembler for "

                                                + name + " from the "

                                                + type + " factory "

                                                + fac.getClass().getName(), e);

                 }

                 if (assembler != null)

                 {

                     AnnotationProcessor.process(assembler);

                     if (isCaching)

                     {

                         T oldAssembler = (T) assemblerCache.putIfAbsent(key, assembler);

                         if (oldAssembler != null)

                         {

                             assembler = oldAssembler;

                         }

                     }

                 }

             }

         }

         return assembler;

     }

     /**

      * Get a Loader for the given assembler type

      *

      * @param type The Type of the Assembler

      *

      * @param <T> the type of the assembler

      *

      * @return A Loader instance for the requested type

      */

     @Override

     @SuppressWarnings("unchecked")

     public <T extends Assembler> Loader<T> getLoader(Class<T> type)

     {

         Loader<T> loader = null;

         if (isCaching && loaderCache.containsKey(type))

         {

             loader = (Loader<T>) loaderCache.get(type);

             log.debug("Found {} loader in the cache!", type);

         }

         else

         {

             log.debug("Getting Loader for {}", type);

             List<AssemblerFactory<T>> facs = getFactoryGroup(type);

             for (Iterator<AssemblerFactory<T>> it = facs.iterator(); (loader == null) && it.hasNext();)

             {

                 AssemblerFactory<T> fac = it.next();

                 loader = fac.getLoader();

             }

             if (isCaching && loader != null)

             {

                 loaderCache.put(type, loader);

             }

         }

         if (loader == null)

         {

             log.warn("Loader for {} is null.", type);

         }

         return loader;

     }

 }