| // 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 |
| // 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. |
| package com.cloud.utils.component; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.Serializable; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.concurrent.ConcurrentHashMap; |
| |
| import javax.ejb.Local; |
| import javax.management.InstanceAlreadyExistsException; |
| import javax.management.MBeanRegistrationException; |
| import javax.management.MalformedObjectNameException; |
| import javax.management.NotCompliantMBeanException; |
| import javax.naming.ConfigurationException; |
| import javax.xml.parsers.ParserConfigurationException; |
| import javax.xml.parsers.SAXParser; |
| import javax.xml.parsers.SAXParserFactory; |
| |
| import net.sf.cglib.proxy.Callback; |
| import net.sf.cglib.proxy.CallbackFilter; |
| import net.sf.cglib.proxy.Enhancer; |
| import net.sf.cglib.proxy.Factory; |
| import net.sf.cglib.proxy.MethodInterceptor; |
| import net.sf.cglib.proxy.MethodProxy; |
| import net.sf.cglib.proxy.NoOp; |
| |
| import org.apache.log4j.Logger; |
| import org.apache.log4j.PropertyConfigurator; |
| import org.apache.log4j.xml.DOMConfigurator; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| import com.cloud.utils.Pair; |
| import com.cloud.utils.PropertiesUtil; |
| import com.cloud.utils.db.DatabaseCallback; |
| import com.cloud.utils.db.DatabaseCallbackFilter; |
| import com.cloud.utils.db.GenericDao; |
| import com.cloud.utils.exception.CloudRuntimeException; |
| import com.cloud.utils.mgmt.JmxUtil; |
| import com.cloud.utils.mgmt.ManagementBean; |
| |
| /** |
| * ComponentLocator ties together several different concepts. First, it |
| * deals with how a system should be put together. It manages different |
| * types of components: |
| * - Manager: Singleton implementation of a certain process. |
| * - Adapter: Different singleton implementations for the same functions. |
| * - SystemIntegrityChecker: Singletons that are called at the load time. |
| * - Dao: Data Access Objects. |
| * |
| * These components can be declared in several ways: |
| * - ComponentLibrary - A Java class that declares the above components. The |
| * advantage of declaring components here is they change automatically |
| * with any refactoring. |
| * - components specification - An xml file that overrides the |
| * ComponentLibrary. The advantage of declaring components here is |
| * they can change by hand on every deployment. |
| * |
| * The two are NOT mutually exclusive. ComponentLocator basically locates |
| * the components specification, which specifies the ComponentLibrary within. |
| * Components found in the ComponentLibrary are overridden by components |
| * found in components specification. |
| * |
| * Components specification can also be nested. One components specification |
| * can point to another components specification and, therefore, "inherits" |
| * those components but still override one or more components. ComponentLocator |
| * reads the child components specification first and follow the chain up. |
| * the child's components overrides the ones in the parent. |
| * |
| * ComponentLocator looks for the components specification as follows: |
| * 1. By following the path specified by "cloud-stack-components-specification" |
| * within the environment.properties file. |
| * 2. Look for components.xml in the class path. |
| * |
| * ComponentLocator also ties in component injection. Components can specify |
| * an @Inject annotation to components ComponentLocator knows. When |
| * instantiating components, ComponentLocator attempts to inject these |
| * components. |
| * |
| **/ |
| @SuppressWarnings("unchecked") |
| public class ComponentLocator implements ComponentLocatorMBean { |
| protected static final Logger s_logger = Logger.getLogger(ComponentLocator.class); |
| |
| protected static final ThreadLocal<ComponentLocator> s_tl = new ThreadLocal<ComponentLocator>(); |
| protected static final ConcurrentHashMap<Class<?>, Singleton> s_singletons = new ConcurrentHashMap<Class<?>, Singleton>(111); |
| protected static final HashMap<String, ComponentLocator> s_locators = new HashMap<String, ComponentLocator>(); |
| protected static final HashMap<Class<?>, InjectInfo> s_factories = new HashMap<Class<?>, InjectInfo>(); |
| protected static Boolean s_once = false; |
| protected static Boolean _hasCheckerRun = false; |
| protected static Callback[] s_callbacks = new Callback[] { NoOp.INSTANCE, new DatabaseCallback()}; |
| protected static CallbackFilter s_callbackFilter = new DatabaseCallbackFilter(); |
| protected static final List<AnnotationInterceptor<?>> s_interceptors = new ArrayList<AnnotationInterceptor<?>>(); |
| protected static CleanupThread s_janitor = null; |
| |
| protected HashMap<String, Adapters<? extends Adapter>> _adapterMap; |
| protected HashMap<String, ComponentInfo<Manager>> _managerMap; |
| protected LinkedHashMap<String, ComponentInfo<SystemIntegrityChecker>> _checkerMap; |
| protected LinkedHashMap<String, ComponentInfo<GenericDao<?, ? extends Serializable>>> _daoMap; |
| protected String _serverName; |
| protected Object _component; |
| protected HashMap<Class<?>, Class<?>> _factories; |
| protected HashMap<String, ComponentInfo<PluggableService>> _pluginsMap; |
| |
| static { |
| if (s_janitor == null) { |
| s_janitor = new CleanupThread(); |
| Runtime.getRuntime().addShutdownHook(new CleanupThread()); |
| } |
| } |
| |
| public ComponentLocator(String server) { |
| _serverName = server; |
| if (s_janitor == null) { |
| s_janitor = new CleanupThread(); |
| Runtime.getRuntime().addShutdownHook(new CleanupThread()); |
| } |
| } |
| |
| public String getLocatorName() { |
| return _serverName; |
| } |
| |
| @Override |
| public String getName() { |
| return getLocatorName(); |
| } |
| |
| protected Pair<XmlHandler, HashMap<String, List<ComponentInfo<Adapter>>>> parse2(String filename) { |
| try { |
| SAXParserFactory spfactory = SAXParserFactory.newInstance(); |
| SAXParser saxParser = spfactory.newSAXParser(); |
| _daoMap = new LinkedHashMap<String, ComponentInfo<GenericDao<?, ? extends Serializable>>>(); |
| _managerMap = new LinkedHashMap<String, ComponentInfo<Manager>>(); |
| _checkerMap = new LinkedHashMap<String, ComponentInfo<SystemIntegrityChecker>>(); |
| _adapterMap = new HashMap<String, Adapters<? extends Adapter>>(); |
| _factories = new HashMap<Class<?>, Class<?>>(); |
| _pluginsMap = new LinkedHashMap<String, ComponentInfo<PluggableService>>(); |
| File file = PropertiesUtil.findConfigFile(filename); |
| if (file == null) { |
| s_logger.info("Unable to find " + filename); |
| return null; |
| } |
| s_logger.info("Config file found at " + file.getAbsolutePath() + ". Configuring " + _serverName); |
| XmlHandler handler = new XmlHandler(_serverName); |
| saxParser.parse(file, handler); |
| |
| HashMap<String, List<ComponentInfo<Adapter>>> adapters = new HashMap<String, List<ComponentInfo<Adapter>>>(); |
| if (handler.parent != null) { |
| String[] tokens = handler.parent.split(":"); |
| String parentFile = filename; |
| String parentName = handler.parent; |
| if (tokens.length > 1) { |
| parentFile = tokens[0]; |
| parentName = tokens[1]; |
| } |
| ComponentLocator parentLocator = new ComponentLocator(parentName); |
| adapters.putAll(parentLocator.parse2(parentFile).second()); |
| _daoMap.putAll(parentLocator._daoMap); |
| _managerMap.putAll(parentLocator._managerMap); |
| _factories.putAll(parentLocator._factories); |
| _pluginsMap.putAll(parentLocator._pluginsMap); |
| } |
| |
| ComponentLibrary library = null; |
| if (handler.library != null) { |
| Class<?> clazz = Class.forName(handler.library); |
| library = (ComponentLibrary)clazz.newInstance(); |
| _daoMap.putAll(library.getDaos()); |
| _managerMap.putAll(library.getManagers()); |
| adapters.putAll(library.getAdapters()); |
| _factories.putAll(library.getFactories()); |
| _pluginsMap.putAll(library.getPluggableServices()); |
| } |
| |
| _daoMap.putAll(handler.daos); |
| _managerMap.putAll(handler.managers); |
| _checkerMap.putAll(handler.checkers); |
| adapters.putAll(handler.adapters); |
| _pluginsMap.putAll(handler.pluggableServices); |
| |
| return new Pair<XmlHandler, HashMap<String, List<ComponentInfo<Adapter>>>>(handler, adapters); |
| } catch (ParserConfigurationException e) { |
| s_logger.error("Unable to load " + _serverName + " due to errors while parsing " + filename, e); |
| System.exit(1); |
| } catch (SAXException e) { |
| s_logger.error("Unable to load " + _serverName + " due to errors while parsing " + filename, e); |
| System.exit(1); |
| } catch (IOException e) { |
| s_logger.error("Unable to load " + _serverName + " due to errors while reading from " + filename, e); |
| System.exit(1); |
| } catch (CloudRuntimeException e) { |
| s_logger.error("Unable to load configuration for " + _serverName + " from " + filename, e); |
| System.exit(1); |
| } catch (Exception e) { |
| s_logger.error("Unable to load configuration for " + _serverName + " from " + filename, e); |
| System.exit(1); |
| } |
| return null; |
| } |
| |
| protected void parse(String filename) { |
| Pair<XmlHandler, HashMap<String, List<ComponentInfo<Adapter>>>> result = parse2(filename); |
| if (result == null) { |
| s_logger.info("Skipping configuration using " + filename); |
| return; |
| } |
| |
| instantiatePluggableServices(); |
| |
| XmlHandler handler = result.first(); |
| HashMap<String, List<ComponentInfo<Adapter>>> adapters = result.second(); |
| try { |
| runCheckers(); |
| startDaos(); // daos should not be using managers and adapters. |
| instantiateAdapters(adapters); |
| instantiateManagers(); |
| if (handler.componentClass != null) { |
| _component = createInstance(handler.componentClass, true, true); |
| } |
| configureManagers(); |
| configureAdapters(); |
| startManagers(); |
| startAdapters(); |
| //TODO do we need to follow the instantiate -> inject -> configure -> start -> stop flow of singletons like managers/adapters? |
| //TODO do we need to expose pluggableServices to MBean (provide getNames?) |
| } catch (CloudRuntimeException e) { |
| s_logger.error("Unable to load configuration for " + _serverName + " from " + filename, e); |
| System.exit(1); |
| } catch (Exception e) { |
| s_logger.error("Unable to load configuration for " + _serverName + " from " + filename, e); |
| System.exit(1); |
| } |
| } |
| |
| protected void runCheckers() { |
| Set<Map.Entry<String, ComponentInfo<SystemIntegrityChecker>>> entries = _checkerMap.entrySet(); |
| for (Map.Entry<String, ComponentInfo<SystemIntegrityChecker>> entry : entries) { |
| ComponentInfo<SystemIntegrityChecker> info = entry.getValue(); |
| try { |
| info.instance = (SystemIntegrityChecker)createInstance(info.clazz, false, info.singleton); |
| info.instance.check(); |
| } catch (Exception e) { |
| s_logger.error("Problems with running checker:" + info.name, e); |
| System.exit(1); |
| } |
| } |
| } |
| /** |
| * Daos should not refer to any other components so it is safe to start them |
| * here. |
| */ |
| protected void startDaos() { |
| Set<Map.Entry<String, ComponentInfo<GenericDao<?, ? extends Serializable>>>> entries = _daoMap.entrySet(); |
| |
| for (Map.Entry<String, ComponentInfo<GenericDao<?, ?>>> entry : entries) { |
| ComponentInfo<GenericDao<?, ?>> info = entry.getValue(); |
| try { |
| info.instance = (GenericDao<?, ?>)createInstance(info.clazz, true, info.singleton); |
| if (info.singleton) { |
| s_logger.info("Starting singleton DAO: " + info.name); |
| Singleton singleton = s_singletons.get(info.clazz); |
| if (singleton.state == Singleton.State.Instantiated) { |
| inject(info.clazz, info.instance); |
| singleton.state = Singleton.State.Injected; |
| } |
| if (singleton.state == Singleton.State.Injected) { |
| if (!info.instance.configure(info.name, info.params)) { |
| s_logger.error("Unable to configure DAO: " + info.name); |
| System.exit(1); |
| } |
| singleton.state = Singleton.State.Started; |
| } |
| } else { |
| s_logger.info("Starting DAO: " + info.name); |
| inject(info.clazz, info.instance); |
| if (!info.instance.configure(info.name, info.params)) { |
| s_logger.error("Unable to configure DAO: " + info.name); |
| System.exit(1); |
| } |
| } |
| } catch (ConfigurationException e) { |
| s_logger.error("Unable to configure DAO: " + info.name, e); |
| System.exit(1); |
| } catch (Exception e) { |
| s_logger.error("Problems while configuring DAO: " + info.name, e); |
| System.exit(1); |
| } |
| if (info.instance instanceof ManagementBean) { |
| registerMBean((ManagementBean) info.instance); |
| } |
| } |
| } |
| |
| private static Object createInstance(Class<?> clazz, boolean inject, boolean singleton, Object... args) { |
| Factory factory = null; |
| Singleton entity = null; |
| synchronized(s_factories) { |
| if (singleton) { |
| entity = s_singletons.get(clazz); |
| if (entity != null) { |
| s_logger.debug("Found singleton instantiation for " + clazz.toString()); |
| return entity.singleton; |
| } |
| } |
| InjectInfo info = s_factories.get(clazz); |
| if (info == null) { |
| Enhancer enhancer = new Enhancer(); |
| enhancer.setSuperclass(clazz); |
| enhancer.setCallbackFilter(s_callbackFilter); |
| enhancer.setCallbacks(s_callbacks); |
| factory = (Factory)enhancer.create(); |
| info = new InjectInfo(enhancer, factory); |
| s_factories.put(clazz, info); |
| } else { |
| factory = info.factory; |
| } |
| } |
| |
| |
| Class<?>[] argTypes = null; |
| if (args != null && args.length > 0) { |
| Constructor<?>[] constructors = clazz.getConstructors(); |
| for (Constructor<?> constructor : constructors) { |
| Class<?>[] paramTypes = constructor.getParameterTypes(); |
| if (paramTypes.length == args.length) { |
| boolean found = true; |
| for (int i = 0; i < paramTypes.length; i++) { |
| if (!paramTypes[i].isAssignableFrom(args[i].getClass()) && !paramTypes[i].isPrimitive()) { |
| found = false; |
| break; |
| } |
| } |
| if (found) { |
| argTypes = paramTypes; |
| break; |
| } |
| } |
| } |
| |
| if (argTypes == null) { |
| throw new CloudRuntimeException("Unable to find constructor to match parameters given: " + clazz.getName()); |
| } |
| |
| entity = new Singleton(factory.newInstance(argTypes, args, s_callbacks)); |
| } else { |
| entity = new Singleton(factory.newInstance(s_callbacks)); |
| } |
| |
| if (inject) { |
| inject(clazz, entity.singleton); |
| entity.state = Singleton.State.Injected; |
| } |
| |
| if (singleton) { |
| synchronized(s_factories) { |
| s_singletons.put(clazz, entity); |
| } |
| } |
| |
| return entity.singleton; |
| } |
| |
| |
| protected ComponentInfo<GenericDao<?, ?>> getDao(String name) { |
| ComponentInfo<GenericDao<?, ?>> info = _daoMap.get(name); |
| if (info == null) { |
| throw new CloudRuntimeException("Unable to find DAO " + name); |
| } |
| |
| return info; |
| } |
| |
| public static synchronized Object getComponent(String componentName) { |
| synchronized(_hasCheckerRun) { |
| /* System Integrity checker will run before all components really loaded */ |
| if (!_hasCheckerRun && !componentName.equalsIgnoreCase(SystemIntegrityChecker.Name)) { |
| ComponentLocator.getComponent(SystemIntegrityChecker.Name); |
| _hasCheckerRun = true; |
| } |
| } |
| |
| ComponentLocator locator = s_locators.get(componentName); |
| if (locator == null) { |
| locator = ComponentLocator.getLocator(componentName); |
| } |
| return locator._component; |
| } |
| |
| public <T extends GenericDao<?, ? extends Serializable>> T getDao(Class<T> clazz) { |
| ComponentInfo<GenericDao<?, ?>> info = getDao(clazz.getName()); |
| return info != null ? (T)info.instance : null; |
| } |
| |
| protected void instantiateManagers() { |
| Set<Map.Entry<String, ComponentInfo<Manager>>> entries = _managerMap.entrySet(); |
| for (Map.Entry<String, ComponentInfo<Manager>> entry : entries) { |
| ComponentInfo<Manager> info = entry.getValue(); |
| if (info.instance == null) { |
| s_logger.info("Instantiating Manager: " + info.name); |
| info.instance = (Manager)createInstance(info.clazz, false, info.singleton); |
| } |
| } |
| } |
| |
| protected void configureManagers() { |
| Set<Map.Entry<String, ComponentInfo<Manager>>> entries = _managerMap.entrySet(); |
| for (Map.Entry<String, ComponentInfo<Manager>> entry : entries) { |
| ComponentInfo<Manager> info = entry.getValue(); |
| if (info.singleton) { |
| Singleton s = s_singletons.get(info.clazz); |
| if (s.state == Singleton.State.Instantiated) { |
| s_logger.debug("Injecting singleton Manager: " + info.name); |
| inject(info.clazz, info.instance); |
| s.state = Singleton.State.Injected; |
| } |
| } else { |
| s_logger.info("Injecting Manager: " + info.name); |
| inject(info.clazz, info.instance); |
| } |
| } |
| for (Map.Entry<String, ComponentInfo<Manager>> entry : entries) { |
| ComponentInfo<Manager> info = entry.getValue(); |
| if (info.singleton) { |
| Singleton s = s_singletons.get(info.clazz); |
| if (s.state == Singleton.State.Injected) { |
| s_logger.info("Configuring singleton Manager: " + info.name); |
| try { |
| info.instance.configure(info.name, info.params); |
| } catch (ConfigurationException e) { |
| s_logger.error("Unable to configure manager: " + info.name, e); |
| System.exit(1); |
| } |
| s.state = Singleton.State.Configured; |
| } |
| } else { |
| s_logger.info("Configuring Manager: " + info.name); |
| try { |
| info.instance.configure(info.name, info.params); |
| } catch (ConfigurationException e) { |
| s_logger.error("Unable to configure manager: " + info.name, e); |
| System.exit(1); |
| } |
| } |
| } |
| } |
| |
| protected static void inject(Class<?> clazz, Object entity) { |
| ComponentLocator locator = ComponentLocator.getCurrentLocator(); |
| |
| do { |
| Field[] fields = clazz.getDeclaredFields(); |
| for (Field field : fields) { |
| Inject inject = field.getAnnotation(Inject.class); |
| if (inject == null) { |
| continue; |
| } |
| Class<?> fc = field.getType(); |
| Object instance = null; |
| if (Manager.class.isAssignableFrom(fc)) { |
| s_logger.trace("Manager: " + fc.getName()); |
| instance = locator.getManager(fc); |
| } else if (GenericDao.class.isAssignableFrom(fc)) { |
| s_logger.trace("Dao:" + fc.getName()); |
| instance = locator.getDao((Class<? extends GenericDao<?, ? extends Serializable>>)fc); |
| } else if (Adapters.class.isAssignableFrom(fc)) { |
| s_logger.trace("Adapter" + fc.getName()); |
| instance = locator.getAdapters(inject.adapter()); |
| } else { |
| s_logger.trace("Other:" + fc.getName()); |
| instance = locator.getManager(fc); |
| } |
| |
| if (instance == null) { |
| throw new CloudRuntimeException("Unable to inject " + fc.getSimpleName() + " in " + clazz.getSimpleName()); |
| } |
| |
| try { |
| field.setAccessible(true); |
| field.set(entity, instance); |
| } catch (IllegalArgumentException e) { |
| throw new CloudRuntimeException("hmmm....is it really illegal?", e); |
| } catch (IllegalAccessException e) { |
| throw new CloudRuntimeException("what! what ! what!", e); |
| } |
| } |
| clazz = clazz.getSuperclass(); |
| } while (clazz != Object.class && clazz != null); |
| } |
| |
| protected void startManagers() { |
| Set<Map.Entry<String, ComponentInfo<Manager>>> entries = _managerMap.entrySet(); |
| for (Map.Entry<String, ComponentInfo<Manager>> entry : entries) { |
| ComponentInfo<Manager> info = entry.getValue(); |
| if (info.singleton) { |
| Singleton s = s_singletons.get(info.clazz); |
| if (s.state == Singleton.State.Configured) { |
| s_logger.info("Starting singleton Manager: " + info.name); |
| if (!info.instance.start()) { |
| throw new CloudRuntimeException("Incorrect Configuration: " + info.name); |
| } |
| if (info.instance instanceof ManagementBean) { |
| registerMBean((ManagementBean) info.instance); |
| } |
| s_logger.info("Started Manager: " + info.name); |
| s.state = Singleton.State.Started; |
| } |
| } else { |
| s_logger.info("Starting Manager: " + info.name); |
| if (!info.instance.start()) { |
| throw new CloudRuntimeException("Incorrect Configuration: " + info.name); |
| } |
| if (info.instance instanceof ManagementBean) { |
| registerMBean((ManagementBean) info.instance); |
| } |
| s_logger.info("Started Manager: " + info.name); |
| } |
| } |
| } |
| |
| protected void registerMBean(ManagementBean mbean) { |
| try { |
| JmxUtil.registerMBean(mbean); |
| } catch (MalformedObjectNameException e) { |
| s_logger.warn("Unable to register MBean: " + mbean.getName(), e); |
| } catch (InstanceAlreadyExistsException e) { |
| s_logger.warn("Unable to register MBean: " + mbean.getName(), e); |
| } catch (MBeanRegistrationException e) { |
| s_logger.warn("Unable to register MBean: " + mbean.getName(), e); |
| } catch (NotCompliantMBeanException e) { |
| s_logger.warn("Unable to register MBean: " + mbean.getName(), e); |
| } |
| s_logger.info("Registered MBean: " + mbean.getName()); |
| } |
| |
| protected ComponentInfo<Manager> getManager(String name) { |
| ComponentInfo<Manager> mgr = _managerMap.get(name); |
| return mgr; |
| } |
| |
| public <T> T getManager(Class<T> clazz) { |
| ComponentInfo<Manager> info = getManager(clazz.getName()); |
| if (info == null) { |
| return null; |
| } |
| if (info.instance == null) { |
| info.instance = (Manager)createInstance(info.clazz, false, info.singleton); |
| } |
| return (T)info.instance; |
| } |
| |
| protected void configureAdapters() { |
| for (Adapters<? extends Adapter> adapters : _adapterMap.values()) { |
| List<ComponentInfo<Adapter>> infos = adapters._infos; |
| for (ComponentInfo<Adapter> info : infos) { |
| try { |
| if (info.singleton) { |
| Singleton singleton = s_singletons.get(info.clazz); |
| if (singleton.state == Singleton.State.Instantiated) { |
| s_logger.info("Injecting singleton Adapter: " + info.getName()); |
| inject(info.clazz, info.instance); |
| singleton.state = Singleton.State.Injected; |
| } |
| if (singleton.state == Singleton.State.Injected) { |
| s_logger.info("Configuring singleton Adapter: " + info.getName()); |
| if (!info.instance.configure(info.name, info.params)) { |
| s_logger.error("Unable to configure adapter: " + info.name); |
| System.exit(1); |
| } |
| singleton.state = Singleton.State.Configured; |
| } |
| } else { |
| s_logger.info("Injecting Adapter: " + info.getName()); |
| inject(info.clazz, info.instance); |
| s_logger.info("Configuring singleton Adapter: " + info.getName()); |
| if (!info.instance.configure(info.name, info.params)) { |
| s_logger.error("Unable to configure adapter: " + info.name); |
| System.exit(1); |
| } |
| } |
| } catch (ConfigurationException e) { |
| s_logger.error("Unable to configure adapter: " + info.name, e); |
| System.exit(1); |
| } catch (Exception e) { |
| s_logger.error("Unable to configure adapter: " + info.name, e); |
| System.exit(1); |
| } |
| } |
| } |
| } |
| |
| protected void populateAdapters(Map<String, List<ComponentInfo<Adapter>>> map) { |
| Set<Map.Entry<String, List<ComponentInfo<Adapter>>>> entries = map.entrySet(); |
| for (Map.Entry<String, List<ComponentInfo<Adapter>>> entry : entries) { |
| for (ComponentInfo<Adapter> info : entry.getValue()) { |
| s_logger.info("Instantiating Adapter: " + info.name); |
| info.instance = (Adapter)createInstance(info.clazz, false, info.singleton); |
| } |
| Adapters<Adapter> adapters = new Adapters<Adapter>(entry.getKey(), entry.getValue()); |
| _adapterMap.put(entry.getKey(), adapters); |
| } |
| } |
| |
| protected void instantiateAdapters(Map<String, List<ComponentInfo<Adapter>>> map) { |
| Set<Map.Entry<String, List<ComponentInfo<Adapter>>>> entries = map.entrySet(); |
| for (Map.Entry<String, List<ComponentInfo<Adapter>>> entry : entries) { |
| for (ComponentInfo<Adapter> info : entry.getValue()) { |
| s_logger.info("Instantiating Adapter: " + info.name); |
| info.instance = (Adapter)createInstance(info.clazz, false, info.singleton); |
| } |
| Adapters<Adapter> adapters = new Adapters<Adapter>(entry.getKey(), entry.getValue()); |
| _adapterMap.put(entry.getKey(), adapters); |
| } |
| } |
| |
| protected void startAdapters() { |
| for (Map.Entry<String, Adapters<? extends Adapter>> entry : _adapterMap.entrySet()) { |
| for (ComponentInfo<Adapter> adapter : entry.getValue()._infos) { |
| if (adapter.singleton) { |
| Singleton s = s_singletons.get(adapter.clazz); |
| if (s.state == Singleton.State.Configured) { |
| s_logger.info("Starting singleton Adapter: " + adapter.getName()); |
| if (!adapter.instance.start()) { |
| throw new CloudRuntimeException("Unable to start adapter: " + adapter.getName()); |
| } |
| if (adapter.instance instanceof ManagementBean) { |
| registerMBean((ManagementBean)adapter.instance); |
| } |
| s_logger.info("Started Adapter: " + adapter.instance.getName()); |
| } |
| s.state = Singleton.State.Started; |
| } else { |
| s_logger.info("Starting Adapter: " + adapter.getName()); |
| if (!adapter.instance.start()) { |
| throw new CloudRuntimeException("Unable to start adapter: " + adapter.getName()); |
| } |
| if (adapter.instance instanceof ManagementBean) { |
| registerMBean((ManagementBean)adapter.instance); |
| } |
| s_logger.info("Started Adapter: " + adapter.instance.getName()); |
| } |
| } |
| } |
| } |
| |
| protected void instantiatePluggableServices() { |
| Set<Map.Entry<String, ComponentInfo<PluggableService>>> entries = _pluginsMap.entrySet(); |
| for (Map.Entry<String, ComponentInfo<PluggableService>> entry : entries) { |
| ComponentInfo<PluggableService> info = entry.getValue(); |
| if (info.instance == null) { |
| s_logger.info("Instantiating PluggableService: " + info.name); |
| info.instance = (PluggableService)createInstance(info.clazz, false, info.singleton); |
| |
| if (info.instance instanceof Plugin) { |
| Plugin plugin = (Plugin)info.instance; |
| |
| ComponentLibrary lib = plugin.getComponentLibrary(); |
| _managerMap.putAll(lib.getManagers()); |
| _daoMap.putAll(lib.getDaos()); |
| } |
| } |
| } |
| } |
| |
| protected ComponentInfo<PluggableService> getPluggableService(String name) { |
| ComponentInfo<PluggableService> mgr = _pluginsMap.get(name); |
| return mgr; |
| } |
| |
| public <T> T getPluggableService(Class<T> clazz) { |
| ComponentInfo<PluggableService> info = getPluggableService(clazz.getName()); |
| if (info == null) { |
| return null; |
| } |
| if (info.instance == null) { |
| info.instance = (PluggableService)createInstance(info.clazz, false, info.singleton); |
| } |
| return (T)info.instance; |
| } |
| |
| public <T> List<T> getAllPluggableServices() { |
| List<T> services = new ArrayList<T>(); |
| Set<Map.Entry<String, ComponentInfo<PluggableService>>> entries = _pluginsMap.entrySet(); |
| for (Map.Entry<String, ComponentInfo<PluggableService>> entry : entries) { |
| ComponentInfo<PluggableService> info = entry.getValue(); |
| if (info.instance == null) { |
| s_logger.info("Instantiating PluggableService: " + info.name); |
| info.instance = (PluggableService)createInstance(info.clazz, false, info.singleton); |
| } |
| services.add((T) info.instance); |
| } |
| return services; |
| } |
| |
| public static <T> T inject(Class<T> clazz) { |
| return (T)createInstance(clazz, true, false); |
| } |
| |
| public <T> T createInstance(Class<T> clazz) { |
| Class<? extends T> impl = (Class<? extends T>)_factories.get(clazz); |
| if (impl == null) { |
| throw new CloudRuntimeException("Unable to find a factory for " + clazz); |
| } |
| return inject(impl); |
| } |
| |
| public static <T> T inject(Class<T> clazz, Object... args) { |
| return (T)createInstance(clazz, true, false, args); |
| } |
| |
| @Override |
| public Map<String, List<String>> getAdapterNames() { |
| HashMap<String, List<String>> result = new HashMap<String, List<String>>(); |
| for (Map.Entry<String, Adapters<? extends Adapter>> entry : _adapterMap.entrySet()) { |
| Adapters<? extends Adapter> adapters = entry.getValue(); |
| Enumeration<? extends Adapter> en = adapters.enumeration(); |
| List<String> lst = new ArrayList<String>(); |
| while (en.hasMoreElements()) { |
| Adapter adapter = en.nextElement(); |
| lst.add(adapter.getName() + "-" + adapter.getClass().getName()); |
| } |
| result.put(entry.getKey(), lst); |
| } |
| return result; |
| } |
| |
| public Map<String, List<String>> getAllAccessibleAdapters() { |
| Map<String, List<String>> parentResults = new HashMap<String, List<String>>(); |
| Map<String, List<String>> results = getAdapterNames(); |
| parentResults.putAll(results); |
| return parentResults; |
| } |
| |
| @Override |
| public Collection<String> getManagerNames() { |
| Collection<String> names = new HashSet<String>(); |
| for (Map.Entry<String, ComponentInfo<Manager>> entry : _managerMap.entrySet()) { |
| names.add(entry.getValue().name); |
| } |
| return names; |
| } |
| |
| @Override |
| public Collection<String> getDaoNames() { |
| Collection<String> names = new HashSet<String>(); |
| for (Map.Entry<String, ComponentInfo<GenericDao<?, ?>>> entry : _daoMap.entrySet()) { |
| names.add(entry.getValue().name); |
| } |
| return names; |
| } |
| |
| public <T extends Adapter> Adapters<T> getAdapters(Class<T> clazz) { |
| return (Adapters<T>)getAdapters(clazz.getName()); |
| } |
| |
| public Adapters<? extends Adapter> getAdapters(String key) { |
| Adapters<? extends Adapter> adapters = _adapterMap.get(key); |
| if (adapters != null) { |
| return adapters; |
| } |
| return new Adapters<Adapter>(key, new ArrayList<ComponentInfo<Adapter>>()); |
| } |
| |
| protected void resetInterceptors(InterceptorLibrary library) { |
| library.addInterceptors(s_interceptors); |
| if (s_interceptors.size() > 0) { |
| s_callbacks = new Callback[s_interceptors.size() + 2]; |
| int i = 0; |
| s_callbacks[i++] = NoOp.INSTANCE; |
| s_callbacks[i++] = new InterceptorDispatcher(); |
| for (AnnotationInterceptor<?> interceptor : s_interceptors) { |
| s_callbacks[i++] = interceptor.getCallback(); |
| } |
| s_callbackFilter = new InterceptorFilter(); |
| } |
| } |
| |
| protected static ComponentLocator getLocatorInternal(String server, boolean setInThreadLocal, String configFileName, String log4jFilename) { |
| synchronized(s_once) { |
| if (!s_once) { |
| File file = PropertiesUtil.findConfigFile(log4jFilename + ".xml"); |
| if (file != null) { |
| s_logger.info("log4j configuration found at " + file.getAbsolutePath()); |
| DOMConfigurator.configureAndWatch(file.getAbsolutePath()); |
| } else { |
| file = PropertiesUtil.findConfigFile(log4jFilename + ".properties"); |
| if (file != null) { |
| s_logger.info("log4j configuration found at " + file.getAbsolutePath()); |
| PropertyConfigurator.configureAndWatch(file.getAbsolutePath()); |
| } |
| } |
| s_once = true; |
| } |
| } |
| |
| ComponentLocator locator; |
| synchronized (s_locators) { |
| locator = s_locators.get(server); |
| if (locator == null) { |
| locator = new ComponentLocator(server); |
| s_locators.put(server, locator); |
| if (setInThreadLocal) { |
| s_tl.set(locator); |
| } |
| locator.parse(configFileName); |
| } else { |
| if (setInThreadLocal) { |
| s_tl.set(locator); |
| } |
| } |
| } |
| |
| return locator; |
| } |
| |
| public static ComponentLocator getLocator(String server, String configFileName, String log4jFilename) { |
| return getLocatorInternal(server, true, configFileName, log4jFilename); |
| } |
| |
| public static ComponentLocator getLocator(String server) { |
| String configFile = null; |
| try { |
| final File propsFile = PropertiesUtil.findConfigFile("environment.properties"); |
| if (propsFile == null) { |
| s_logger.debug("environment.properties could not be opened"); |
| } else { |
| final FileInputStream finputstream = new FileInputStream(propsFile); |
| final Properties props = new Properties(); |
| props.load(finputstream); |
| finputstream.close(); |
| configFile = props.getProperty("cloud-stack-components-specification"); |
| } |
| } catch (IOException e) { |
| s_logger.debug("environment.properties could not be loaded:" + e.toString()); |
| } |
| |
| if (configFile == null || PropertiesUtil.findConfigFile(configFile) == null) { |
| configFile = "components.xml"; |
| if (PropertiesUtil.findConfigFile(configFile) == null){ |
| s_logger.debug("Can not find components.xml"); |
| } |
| } |
| return getLocatorInternal(server, true, configFile, "log4j-cloud"); |
| } |
| |
| public static ComponentLocator getCurrentLocator() { |
| return s_tl.get(); |
| } |
| |
| public static class ComponentInfo<T> { |
| Class<?> clazz; |
| HashMap<String, Object> params = new HashMap<String, Object>(); |
| String name; |
| List<String> keys = new ArrayList<String>(); |
| T instance; |
| boolean singleton = true; |
| |
| protected ComponentInfo() { |
| } |
| |
| public List<String> getKeys() { |
| return keys; |
| } |
| |
| public String getName() { |
| return name; |
| } |
| |
| public ComponentInfo(String name, Class<? extends T> clazz) { |
| this(name, clazz, new ArrayList<Pair<String, Object>>(0)); |
| } |
| |
| public ComponentInfo(String name, Class<? extends T> clazz, T instance) { |
| this(name, clazz); |
| this.instance = instance; |
| } |
| |
| public ComponentInfo(String name, Class<? extends T> clazz, List<Pair<String, Object>> params) { |
| this(name, clazz, params, true); |
| } |
| |
| public ComponentInfo(String name, Class<? extends T> clazz, List<Pair<String, Object>> params, boolean singleton) { |
| this.name = name; |
| this.clazz = clazz; |
| this.singleton = singleton; |
| for (Pair<String, Object> param : params) { |
| this.params.put(param.first(), param.second()); |
| } |
| fillInfo(); |
| } |
| |
| protected void fillInfo() { |
| String clazzName = clazz.getName(); |
| |
| Local local = clazz.getAnnotation(Local.class); |
| if (local == null) { |
| throw new CloudRuntimeException("Unable to find Local annotation for class " + clazzName); |
| } |
| |
| // Verify that all interfaces specified in the Local annotation is implemented by the class. |
| Class<?>[] classes = local.value(); |
| for (int i = 0; i < classes.length; i++) { |
| if (!classes[i].isInterface()) { |
| throw new CloudRuntimeException(classes[i].getName() + " is not an interface"); |
| } |
| if (classes[i].isAssignableFrom(clazz)) { |
| keys.add(classes[i].getName()); |
| s_logger.info("Found component: " + classes[i].getName() + " in " + clazzName + " - " + name); |
| } else { |
| throw new CloudRuntimeException(classes[i].getName() + " is not implemented by " + clazzName); |
| } |
| } |
| } |
| |
| public void addParameter(String name, String value) { |
| params.put(name, value); |
| } |
| } |
| |
| /** |
| * XmlHandler is used by AdapterManager to handle the SAX parser callbacks. |
| * It builds a hash map of lists of adapters and a hash map of managers. |
| **/ |
| protected class XmlHandler extends DefaultHandler { |
| public HashMap<String, List<ComponentInfo<Adapter>>> adapters; |
| public HashMap<String, ComponentInfo<Manager>> managers; |
| public LinkedHashMap<String, ComponentInfo<SystemIntegrityChecker>> checkers; |
| public LinkedHashMap<String, ComponentInfo<GenericDao<?, ?>>> daos; |
| public HashMap<String, ComponentInfo<PluggableService>> pluggableServices; |
| public String parent; |
| public String library; |
| |
| List<ComponentInfo<Adapter>> lst; |
| String paramName; |
| StringBuilder value; |
| String serverName; |
| boolean parse; |
| ComponentInfo<?> currentInfo; |
| Class<?> componentClass; |
| |
| public XmlHandler(String serverName) { |
| this.serverName = serverName; |
| parse = false; |
| adapters = new HashMap<String, List<ComponentInfo<Adapter>>>(); |
| managers = new HashMap<String, ComponentInfo<Manager>>(); |
| checkers = new LinkedHashMap<String, ComponentInfo<SystemIntegrityChecker>>(); |
| daos = new LinkedHashMap<String, ComponentInfo<GenericDao<?, ?>>>(); |
| pluggableServices = new HashMap<String, ComponentInfo<PluggableService>>(); |
| value = null; |
| parent = null; |
| } |
| |
| protected void fillInfo(Attributes atts, Class<?> interphace, ComponentInfo<?> info) { |
| String clazzName = getAttribute(atts, "class"); |
| if (clazzName == null) { |
| throw new CloudRuntimeException("Missing class attribute for " + interphace.getName()); |
| } |
| info.name = getAttribute(atts, "name"); |
| if (info.name == null) { |
| throw new CloudRuntimeException("Missing name attribute for " + interphace.getName()); |
| } |
| s_logger.debug("Looking for class " + clazzName); |
| try { |
| info.clazz = Class.forName(clazzName); |
| } catch (ClassNotFoundException e) { |
| throw new CloudRuntimeException("Unable to find class: " + clazzName); |
| } catch (Throwable e) { |
| throw new CloudRuntimeException("Caught throwable: ", e); |
| } |
| |
| if (!interphace.isAssignableFrom(info.clazz)) { |
| throw new CloudRuntimeException("Class " + info.clazz.toString() + " does not implment " + interphace); |
| } |
| String singleton = getAttribute(atts, "singleton"); |
| if (singleton != null) { |
| info.singleton = Boolean.parseBoolean(singleton); |
| } |
| |
| info.fillInfo(); |
| } |
| |
| @Override |
| public void startElement(String namespaceURI, String localName, String qName, Attributes atts) |
| throws SAXException { |
| if (qName.equals("interceptor") && s_interceptors.size() == 0) { |
| synchronized(s_interceptors){ |
| if (s_interceptors.size() == 0) { |
| String libraryName = getAttribute(atts, "library"); |
| try { |
| Class<?> libraryClazz = Class.forName(libraryName); |
| InterceptorLibrary library = (InterceptorLibrary)libraryClazz.newInstance(); |
| resetInterceptors(library); |
| } catch (ClassNotFoundException e) { |
| throw new CloudRuntimeException("Unable to find " + libraryName, e); |
| } catch (InstantiationException e) { |
| throw new CloudRuntimeException("Unable to instantiate " + libraryName, e); |
| } catch (IllegalAccessException e) { |
| throw new CloudRuntimeException("Illegal access " + libraryName, e); |
| } |
| } |
| } |
| } |
| if (!parse) { |
| if (qName.equals(_serverName)) { |
| parse = true; |
| parent = getAttribute(atts, "extends"); |
| String implementationClass = getAttribute(atts, "class"); |
| if (implementationClass != null) { |
| try { |
| componentClass = Class.forName(implementationClass); |
| } catch (ClassNotFoundException e) { |
| throw new CloudRuntimeException("Unable to find " + implementationClass, e); |
| } |
| } |
| |
| library = getAttribute(atts, "library"); |
| } |
| } else if (qName.equals("adapters")) { |
| lst = new ArrayList<ComponentInfo<Adapter>>(); |
| String key = getAttribute(atts, "key"); |
| if (key == null) { |
| throw new CloudRuntimeException("Missing key attribute for adapters"); |
| } |
| adapters.put(key, lst); |
| } else if (qName.equals("adapter")) { |
| ComponentInfo<Adapter> info = new ComponentInfo<Adapter>(); |
| fillInfo(atts, Adapter.class, info); |
| lst.add(info); |
| currentInfo = info; |
| } else if (qName.equals("manager")) { |
| ComponentInfo<Manager> info = new ComponentInfo<Manager>(); |
| fillInfo(atts, Manager.class, info); |
| s_logger.info("Adding Manager: " + info.name); |
| for (String key : info.keys) { |
| s_logger.info("Linking " + key + " to " + info.name); |
| managers.put(key, info); |
| } |
| currentInfo = info; |
| } else if (qName.equals("param")) { |
| paramName = getAttribute(atts, "name"); |
| value = new StringBuilder(); |
| } else if (qName.equals("dao")) { |
| ComponentInfo<GenericDao<?, ?>> info = new ComponentInfo<GenericDao<?, ?>>(); |
| fillInfo(atts, GenericDao.class, info); |
| for (String key : info.keys) { |
| daos.put(key, info); |
| } |
| currentInfo = info; |
| } else if (qName.equals("checker")) { |
| ComponentInfo<SystemIntegrityChecker> info = new ComponentInfo<SystemIntegrityChecker>(); |
| fillInfo(atts, SystemIntegrityChecker.class, info); |
| checkers.put(info.name, info); |
| s_logger.info("Adding system integrity checker: " + info.name); |
| currentInfo = info; |
| } else if (qName.equals("pluggableservice") || qName.equals("plugin")) { |
| ComponentInfo<PluggableService> info = new ComponentInfo<PluggableService>(); |
| fillInfo(atts, PluggableService.class, info); |
| s_logger.info("Adding PluggableService: " + info.name); |
| String key = getAttribute(atts, "key"); |
| if (key == null) { |
| throw new CloudRuntimeException("Missing key attribute for pluggableservice: "+info.name); |
| } |
| s_logger.info("Linking " + key + " to " + info.name); |
| pluggableServices.put(key, info); |
| currentInfo = info; |
| } else { |
| // ignore |
| } |
| } |
| |
| protected String getAttribute(Attributes atts, String name) { |
| for (int att = 0; att < atts.getLength(); att++) { |
| String attName = atts.getQName(att); |
| if (attName.equals(name)) { |
| return atts.getValue(att); |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public void endElement(String namespaceURI, String localName, String qName) throws SAXException { |
| if (!parse) { |
| return; |
| } |
| |
| if (qName.equals(_serverName)) { |
| parse = false; |
| } else if (qName.equals("adapters")) { |
| } else if (qName.equals("adapter")) { |
| } else if (qName.equals("manager")) { |
| } else if (qName.equals("dao")) { |
| } else if (qName.equals("pluggableservice")) { |
| } else if (qName.equals("param")) { |
| currentInfo.params.put(paramName, value.toString()); |
| paramName = null; |
| value = null; |
| } else { |
| // ignore |
| } |
| } |
| |
| @Override |
| public void characters(char[] ch, int start, int length) throws SAXException { |
| if (parse && value != null) { |
| value.append(ch, start, length); |
| } |
| } |
| } |
| |
| protected static class InjectInfo { |
| public Factory factory; |
| public Enhancer enhancer; |
| |
| public InjectInfo(Enhancer enhancer, Factory factory) { |
| this.factory = factory; |
| this.enhancer = enhancer; |
| } |
| } |
| |
| protected static class CleanupThread extends Thread { |
| @Override |
| public void run() { |
| synchronized (CleanupThread.class) { |
| for (ComponentLocator locator : s_locators.values()) { |
| Iterator<Adapters<? extends Adapter>> itAdapters = locator._adapterMap.values().iterator(); |
| while (itAdapters.hasNext()) { |
| Adapters<? extends Adapter> adapters = itAdapters.next(); |
| itAdapters.remove(); |
| for (ComponentInfo<Adapter> adapter : adapters._infos) { |
| if (adapter.singleton) { |
| Singleton singleton = s_singletons.get(adapter.clazz); |
| if (singleton.state == Singleton.State.Started) { |
| s_logger.info("Asking " + adapter.getName() + " to shutdown."); |
| adapter.instance.stop(); |
| singleton.state = Singleton.State.Stopped; |
| } else { |
| s_logger.debug("Skippng " + adapter.getName() + " because it has already stopped"); |
| } |
| } else { |
| s_logger.info("Asking " + adapter.getName() + " to shutdown."); |
| adapter.instance.stop(); |
| } |
| } |
| } |
| } |
| |
| for (ComponentLocator locator : s_locators.values()) { |
| Iterator<ComponentInfo<Manager>> itManagers = locator._managerMap.values().iterator(); |
| while (itManagers.hasNext()) { |
| ComponentInfo<Manager> manager = itManagers.next(); |
| itManagers.remove(); |
| if (manager.singleton == true) { |
| Singleton singleton = s_singletons.get(manager.clazz); |
| if (singleton != null && singleton.state == Singleton.State.Started) { |
| s_logger.info("Asking Manager " + manager.getName() + " to shutdown."); |
| manager.instance.stop(); |
| singleton.state = Singleton.State.Stopped; |
| } else { |
| s_logger.info("Skipping Manager " + manager.getName() + " because it is not in a state to shutdown."); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| static class Singleton { |
| public enum State { |
| Instantiated, |
| Injected, |
| Configured, |
| Started, |
| Stopped |
| } |
| |
| public Object singleton; |
| public State state; |
| |
| public Singleton(Object singleton) { |
| this.singleton = singleton; |
| this.state = State.Instantiated; |
| } |
| } |
| |
| protected class InterceptorDispatcher implements MethodInterceptor { |
| |
| @Override |
| public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { |
| ArrayList<Pair<AnnotationInterceptor<Object>, Object>> interceptors = new ArrayList<Pair<AnnotationInterceptor<Object>, Object>>(); |
| for (AnnotationInterceptor<?> interceptor : s_interceptors) { |
| if (interceptor.needToIntercept(method)) { |
| Object obj = interceptor.interceptStart(method); |
| interceptors.add(new Pair<AnnotationInterceptor<Object>, Object>((AnnotationInterceptor<Object>)interceptor, obj)); |
| } |
| } |
| boolean success = false; |
| try { |
| Object obj = methodProxy.invokeSuper(object, args); |
| success = true; |
| return obj; |
| } finally { |
| for (Pair<AnnotationInterceptor<Object>, Object> interceptor : interceptors) { |
| if (success) { |
| interceptor.first().interceptComplete(method, interceptor.second()); |
| } else { |
| interceptor.first().interceptException(method, interceptor.second()); |
| } |
| } |
| } |
| } |
| } |
| |
| protected static class InterceptorFilter implements CallbackFilter { |
| @Override |
| public int accept(Method method) { |
| int index = 0; |
| for (int i = 2; i < s_callbacks.length; i++) { |
| AnnotationInterceptor<?> interceptor = (AnnotationInterceptor<?>)s_callbacks[i]; |
| if (interceptor.needToIntercept(method)) { |
| if (index == 0) { |
| index = i; |
| } else { |
| return 1; |
| } |
| } |
| } |
| |
| return index; |
| } |
| } |
| } |
