package org.infinispan.factories;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.CacheImpl;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.jmx.CacheJmxRegistration;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.upgrade.RollingUpgradeManager;
import org.infinispan.transaction.xa.recovery.RecoveryAdminOperations;
import org.infinispan.xsite.XSiteAdminOperations;
import java.lang.ref.WeakReference;
/**
* An internal factory for constructing Caches. Used by the {@link DefaultCacheManager}, this is not intended as public
* API.
* <p/>
* This is a special instance of a {@link AbstractComponentFactory} which contains bootstrap information for the {@link
* ComponentRegistry}.
* <p/>
*
* @author <a href="mailto:manik@jboss.org">Manik Surtani (manik@jboss.org)</a>
* @since 4.0
*/
public class InternalCacheFactory<K, V> extends AbstractNamedCacheComponentFactory {
/**
* This implementation clones the configuration passed in before using it.
*
*
* @param configuration to use
* @param globalComponentRegistry global component registry to attach the cache to
* @param cacheName name of the cache
* @return a cache
* @throws ConfigurationException if there are problems with the cfg
*/
public Cache<K, V> createCache(Configuration configuration,
GlobalComponentRegistry globalComponentRegistry,
String cacheName) throws CacheConfigurationException {
try {
return createAndWire(configuration, globalComponentRegistry, cacheName);
}
catch (CacheConfigurationException ce) {
throw ce;
}
catch (RuntimeException re) {
throw re;
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
protected AdvancedCache<K, V> createAndWire(Configuration configuration, GlobalComponentRegistry globalComponentRegistry,
String cacheName) throws Exception {
AdvancedCache<K, V> cache = new CacheImpl<K, V>(cacheName);
bootstrap(cacheName, cache, configuration, globalComponentRegistry);
return cache;
}
/**
* Bootstraps this factory with a Configuration and a ComponentRegistry.
*/
private void bootstrap(String cacheName, AdvancedCache<?, ?> cache, Configuration configuration,
GlobalComponentRegistry globalComponentRegistry) {
this.configuration = configuration;
// injection bootstrap stuff
componentRegistry = new ComponentRegistry(cacheName, configuration, cache, globalComponentRegistry, globalComponentRegistry.getClassLoader());
/*
--------------------------------------------------------------------------------------------------------------
This is where the bootstrap really happens. Registering the cache in the component registry will cause
the component registry to look at the cache's @Inject methods, and construct various components and their
dependencies, in turn.
--------------------------------------------------------------------------------------------------------------
*/
componentRegistry.registerComponent(cache, Cache.class.getName(), true);
componentRegistry.registerComponent(new CacheJmxRegistration(), CacheJmxRegistration.class.getName(), true);
if (configuration.transaction().transactionMode().isTransactional() && configuration.transaction().recovery().enabled()) {
componentRegistry.registerComponent(new RecoveryAdminOperations(), RecoveryAdminOperations.class.getName(), true);
}
if (configuration.sites().hasEnabledBackups()) {
componentRegistry.registerComponent(new XSiteAdminOperations(), XSiteAdminOperations.class.getName(), true);
}
// The RollingUpgradeManager should always be added so it is registered in JMX.
componentRegistry.registerComponent(new RollingUpgradeManager(), RollingUpgradeManager.class.getName(), true);
}
@Override
public <T> T construct(Class<T> componentType) {
throw new UnsupportedOperationException("Should never be invoked - this is a bootstrap factory.");
}
}