001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.cache.ehcache;
016    
017    import com.liferay.portal.cache.cluster.EhcachePortalCacheClusterReplicatorFactory;
018    import com.liferay.portal.kernel.util.Validator;
019    import com.liferay.portal.util.PropsValues;
020    
021    import java.net.URL;
022    
023    import java.util.List;
024    import java.util.Map;
025    
026    import net.sf.ehcache.config.CacheConfiguration.CacheEventListenerFactoryConfiguration;
027    import net.sf.ehcache.config.CacheConfiguration;
028    import net.sf.ehcache.config.Configuration;
029    import net.sf.ehcache.config.ConfigurationFactory;
030    
031    /**
032     * @author Shuyang Zhou
033     * @author Edward Han
034     */
035    public class EhcacheConfigurationUtil {
036    
037            public static Configuration getConfiguration(
038                    String configurationPath) {
039    
040                    return getConfiguration(configurationPath, false);
041            }
042    
043            public static Configuration getConfiguration(
044                    String configurationPath, boolean clusterAware) {
045    
046                    return getConfiguration(configurationPath, clusterAware, false);
047            }
048    
049            public static Configuration getConfiguration(
050                    String configurationPath, boolean clusterAware,
051                    boolean usingDefault) {
052    
053                    if (Validator.isNull(configurationPath)) {
054                            return null;
055                    }
056    
057                    URL configurationURL = EhcacheConfigurationUtil.class.getResource(
058                            configurationPath);
059    
060                    return getConfiguration(configurationURL, clusterAware, usingDefault);
061            }
062    
063            public static Configuration getConfiguration(URL configurationURL) {
064                    return getConfiguration(configurationURL, false);
065            }
066    
067            public static Configuration getConfiguration(
068                    URL configurationURL, boolean clusterAware) {
069    
070                    return getConfiguration(configurationURL, clusterAware, false);
071            }
072    
073            public static Configuration getConfiguration(
074                    URL configurationURL, boolean clusterAware, boolean usingDefault) {
075    
076                    if (Validator.isNull(configurationURL)) {
077                            return null;
078                    }
079    
080                    Configuration configuration = ConfigurationFactory.parseConfiguration(
081                            configurationURL);
082    
083                    boolean enableClusterLinkReplication = false;
084    
085                    if (PropsValues.CLUSTER_LINK_ENABLED &&
086                            PropsValues.EHCACHE_CLUSTER_LINK_REPLICATION_ENABLED) {
087    
088                            enableClusterLinkReplication = true;
089                    }
090    
091                    if (clusterAware && (usingDefault || enableClusterLinkReplication)) {
092                            return _processDefaultClusterLinkReplication(
093                                    configuration, usingDefault, enableClusterLinkReplication);
094                    }
095    
096                    return configuration;
097            }
098    
099            private static void _clearCacheEventListenerConfigurations(
100                    CacheConfiguration cacheConfiguration) {
101    
102                    cacheConfiguration.addBootstrapCacheLoaderFactory(null);
103    
104                    cacheConfiguration.getCacheEventListenerConfigurations().clear();
105            }
106    
107            private static void _configureCacheEventListeners(
108                    boolean enableClusterLinkReplication,
109                    boolean clearCachePeerProviderConfigurations, boolean usingDefault,
110                    CacheConfiguration cacheConfiguration) {
111    
112                    if (cacheConfiguration == null) {
113                            return;
114                    }
115    
116                    List<CacheEventListenerFactoryConfiguration>
117                            cacheEventListenerFactoryConfigurations =
118                                    cacheConfiguration.getCacheEventListenerConfigurations();
119    
120                    boolean usingLiferayCacheEventListenerFactory = false;
121    
122                    for (CacheEventListenerFactoryConfiguration
123                                    cacheEventListenerFactoryConfiguration :
124                                            cacheEventListenerFactoryConfigurations) {
125    
126                            String className =
127                                    cacheEventListenerFactoryConfiguration.
128                                            getFullyQualifiedClassPath();
129    
130                            if (className.equals(
131                                            LiferayCacheEventListenerFactory.class.getName())) {
132    
133                                    usingLiferayCacheEventListenerFactory = true;
134    
135                                    break;
136                            }
137                    }
138    
139                    if (clearCachePeerProviderConfigurations ||
140                            (!usingDefault && usingLiferayCacheEventListenerFactory)) {
141    
142                            _clearCacheEventListenerConfigurations(cacheConfiguration);
143    
144                            if (enableClusterLinkReplication) {
145                                    _enableClusterLinkReplication(cacheConfiguration);
146                            }
147                    }
148            }
149    
150            private static void _enableClusterLinkReplication(
151                    CacheConfiguration cacheConfiguration) {
152    
153                    CacheEventListenerFactoryConfiguration
154                            cacheEventListenerFactoryConfiguration =
155                                    new CacheEventListenerFactoryConfiguration();
156    
157                    cacheEventListenerFactoryConfiguration.setClass(
158                            EhcachePortalCacheClusterReplicatorFactory.class.getName());
159    
160                    cacheConfiguration.addCacheEventListenerFactory(
161                            cacheEventListenerFactoryConfiguration);
162            }
163    
164            private static Configuration _processDefaultClusterLinkReplication(
165                    Configuration configuration, boolean usingDefault,
166                    boolean enableClusterLinkReplication) {
167    
168                    boolean clearCachePeerProviderConfigurations = false;
169    
170                    if (((usingDefault && enableClusterLinkReplication) ||
171                            (usingDefault && !PropsValues.CLUSTER_LINK_ENABLED))) {
172    
173                            clearCachePeerProviderConfigurations = true;
174                    }
175    
176                    if (clearCachePeerProviderConfigurations) {
177                            configuration.getCacheManagerPeerListenerFactoryConfigurations().
178                                    clear();
179                            configuration.getCacheManagerPeerProviderFactoryConfiguration().
180                                    clear();
181                    }
182    
183                    CacheConfiguration defaultCacheConfiguration =
184                            configuration.getDefaultCacheConfiguration();
185    
186                    _configureCacheEventListeners(
187                            enableClusterLinkReplication, clearCachePeerProviderConfigurations,
188                            usingDefault, defaultCacheConfiguration);
189    
190                    Map<String, CacheConfiguration> cacheConfigurations =
191                            configuration.getCacheConfigurations();
192    
193                    for (CacheConfiguration cacheConfiguration :
194                                    cacheConfigurations.values()) {
195    
196                            _configureCacheEventListeners(
197                                    enableClusterLinkReplication,
198                                    clearCachePeerProviderConfigurations, usingDefault,
199                                    cacheConfiguration);
200                    }
201    
202                    return configuration;
203            }
204    
205    }