001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
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(String configurationPath) {
038                    return getConfiguration(configurationPath, false);
039            }
040    
041            public static Configuration getConfiguration(
042                    String configurationPath, boolean clusterAware) {
043    
044                    return getConfiguration(configurationPath, clusterAware, false);
045            }
046    
047            public static Configuration getConfiguration(
048                    String configurationPath, boolean clusterAware, boolean usingDefault) {
049    
050                    if (Validator.isNull(configurationPath)) {
051                            return null;
052                    }
053    
054                    URL configurationURL = EhcacheConfigurationUtil.class.getResource(
055                            configurationPath);
056    
057                    return getConfiguration(configurationURL, clusterAware, usingDefault);
058            }
059    
060            public static Configuration getConfiguration(URL configurationURL) {
061                    return getConfiguration(configurationURL, false);
062            }
063    
064            public static Configuration getConfiguration(
065                    URL configurationURL, boolean clusterAware) {
066    
067                    return getConfiguration(configurationURL, clusterAware, false);
068            }
069    
070            public static Configuration getConfiguration(
071                    URL configurationURL, boolean clusterAware, boolean usingDefault) {
072    
073                    if (Validator.isNull(configurationURL)) {
074                            return null;
075                    }
076    
077                    Configuration configuration = ConfigurationFactory.parseConfiguration(
078                            configurationURL);
079    
080                    boolean enableClusterLinkReplication = false;
081    
082                    if (PropsValues.CLUSTER_LINK_ENABLED &&
083                            PropsValues.EHCACHE_CLUSTER_LINK_REPLICATION_ENABLED) {
084    
085                            enableClusterLinkReplication = true;
086                    }
087    
088                    if (clusterAware && (usingDefault || enableClusterLinkReplication)) {
089                            return _processDefaultClusterLinkReplication(
090                                    configuration, usingDefault, enableClusterLinkReplication);
091                    }
092    
093                    return configuration;
094            }
095    
096            private static String _clearCacheEventListenerConfigurations(
097                    CacheConfiguration cacheConfiguration) {
098    
099                    cacheConfiguration.addBootstrapCacheLoaderFactory(null);
100    
101                    List<?> cacheEventListenerConfigurations =
102                            cacheConfiguration.getCacheEventListenerConfigurations();
103    
104                    String cacheEventListenerProperties = null;
105    
106                    for (Object cacheEventListenerConfiguration :
107                                    cacheEventListenerConfigurations) {
108    
109                            CacheEventListenerFactoryConfiguration
110                                    cacheEventListenerFactoryConfiguration =
111                                            (CacheEventListenerFactoryConfiguration)
112                                                    cacheEventListenerConfiguration;
113    
114                            String fullyQualifiedClassPath =
115                                    cacheEventListenerFactoryConfiguration.
116                                            getFullyQualifiedClassPath();
117    
118                            if (fullyQualifiedClassPath.contains(
119                                            "LiferayCacheEventListenerFactory") ||
120                                    fullyQualifiedClassPath.contains(
121                                            "net.sf.ehcache.distribution")) {
122    
123                                    cacheEventListenerProperties =
124                                            cacheEventListenerFactoryConfiguration.getProperties();
125    
126                                    break;
127                            }
128                    }
129    
130                    cacheEventListenerConfigurations.clear();
131    
132                    return cacheEventListenerProperties;
133            }
134    
135            private static void _configureCacheEventListeners(
136                    boolean enableClusterLinkReplication,
137                    boolean clearCachePeerProviderConfigurations, boolean usingDefault,
138                    CacheConfiguration cacheConfiguration) {
139    
140                    if (cacheConfiguration == null) {
141                            return;
142                    }
143    
144                    List<CacheEventListenerFactoryConfiguration>
145                            cacheEventListenerFactoryConfigurations =
146                                    cacheConfiguration.getCacheEventListenerConfigurations();
147    
148                    boolean usingLiferayCacheEventListenerFactory = false;
149    
150                    for (CacheEventListenerFactoryConfiguration
151                                    cacheEventListenerFactoryConfiguration :
152                                            cacheEventListenerFactoryConfigurations) {
153    
154                            String className =
155                                    cacheEventListenerFactoryConfiguration.
156                                            getFullyQualifiedClassPath();
157    
158                            if (className.equals(
159                                            LiferayCacheEventListenerFactory.class.getName())) {
160    
161                                    usingLiferayCacheEventListenerFactory = true;
162    
163                                    break;
164                            }
165                    }
166    
167                    if (clearCachePeerProviderConfigurations ||
168                            (!usingDefault && usingLiferayCacheEventListenerFactory)) {
169    
170                            String cacheEventListenerProperties =
171                                    _clearCacheEventListenerConfigurations(cacheConfiguration);
172    
173                            if (enableClusterLinkReplication) {
174                                    _enableClusterLinkReplication(
175                                            cacheConfiguration, cacheEventListenerProperties);
176                            }
177                    }
178            }
179    
180            private static void _enableClusterLinkReplication(
181                    CacheConfiguration cacheConfiguration,
182                    String cacheEventListenerProperties) {
183    
184                    CacheEventListenerFactoryConfiguration
185                            cacheEventListenerFactoryConfiguration =
186                                    new CacheEventListenerFactoryConfiguration();
187    
188                    cacheEventListenerFactoryConfiguration.setClass(
189                            EhcachePortalCacheClusterReplicatorFactory.class.getName());
190                    cacheEventListenerFactoryConfiguration.setProperties(
191                            cacheEventListenerProperties);
192    
193                    cacheConfiguration.addCacheEventListenerFactory(
194                            cacheEventListenerFactoryConfiguration);
195            }
196    
197            private static Configuration _processDefaultClusterLinkReplication(
198                    Configuration configuration, boolean usingDefault,
199                    boolean enableClusterLinkReplication) {
200    
201                    boolean clearCachePeerProviderConfigurations = false;
202    
203                    if ((usingDefault && enableClusterLinkReplication) ||
204                            (usingDefault && !PropsValues.CLUSTER_LINK_ENABLED)) {
205    
206                            clearCachePeerProviderConfigurations = true;
207                    }
208    
209                    if (clearCachePeerProviderConfigurations) {
210                            configuration.getCacheManagerPeerListenerFactoryConfigurations().
211                                    clear();
212                            configuration.getCacheManagerPeerProviderFactoryConfiguration().
213                                    clear();
214                    }
215    
216                    CacheConfiguration defaultCacheConfiguration =
217                            configuration.getDefaultCacheConfiguration();
218    
219                    _configureCacheEventListeners(
220                            enableClusterLinkReplication, clearCachePeerProviderConfigurations,
221                            usingDefault, defaultCacheConfiguration);
222    
223                    Map<String, CacheConfiguration> cacheConfigurations =
224                            configuration.getCacheConfigurations();
225    
226                    for (CacheConfiguration cacheConfiguration :
227                                    cacheConfigurations.values()) {
228    
229                            _configureCacheEventListeners(
230                                    enableClusterLinkReplication,
231                                    clearCachePeerProviderConfigurations, usingDefault,
232                                    cacheConfiguration);
233                    }
234    
235                    return configuration;
236            }
237    
238    }