001    /**
002     * Copyright (c) 2000-2011 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,
049                    boolean usingDefault) {
050    
051                    if (Validator.isNull(configurationPath)) {
052                            return null;
053                    }
054    
055                    URL configurationURL = EhcacheConfigurationUtil.class.getResource(
056                            configurationPath);
057    
058                    return getConfiguration(configurationURL, clusterAware, usingDefault);
059            }
060    
061            public static Configuration getConfiguration(URL configurationURL) {
062                    return getConfiguration(configurationURL, false);
063            }
064    
065            public static Configuration getConfiguration(
066                    URL configurationURL, boolean clusterAware) {
067    
068                    return getConfiguration(configurationURL, clusterAware, false);
069            }
070    
071            public static Configuration getConfiguration(
072                    URL configurationURL, boolean clusterAware, boolean usingDefault) {
073    
074                    if (Validator.isNull(configurationURL)) {
075                            return null;
076                    }
077    
078                    Configuration configuration = ConfigurationFactory.parseConfiguration(
079                            configurationURL);
080    
081                    boolean enableClusterLinkReplication = false;
082    
083                    if (PropsValues.CLUSTER_LINK_ENABLED &&
084                            PropsValues.EHCACHE_CLUSTER_LINK_REPLICATION_ENABLED) {
085    
086                            enableClusterLinkReplication = true;
087                    }
088    
089                    if (clusterAware && (usingDefault || enableClusterLinkReplication)) {
090                            return _processDefaultClusterLinkReplication(
091                                    configuration, usingDefault, enableClusterLinkReplication);
092                    }
093    
094                    return configuration;
095            }
096    
097            private static String _clearCacheEventListenerConfigurations(
098                    CacheConfiguration cacheConfiguration) {
099    
100                    cacheConfiguration.addBootstrapCacheLoaderFactory(null);
101    
102                    List<?> cacheEventListenerConfigurations =
103                            cacheConfiguration.getCacheEventListenerConfigurations();
104    
105                    String cacheEventListenerProperties = null;
106    
107                    for (Object cacheEventListenerConfiguration :
108                                    cacheEventListenerConfigurations) {
109    
110                            CacheEventListenerFactoryConfiguration
111                                    cacheEventListenerFactoryConfiguration =
112                                            (CacheEventListenerFactoryConfiguration)
113                                                    cacheEventListenerConfiguration;
114    
115                            String fullyQualifiedClassPath =
116                                    cacheEventListenerFactoryConfiguration.
117                                            getFullyQualifiedClassPath();
118    
119                            if (fullyQualifiedClassPath.contains(
120                                            "LiferayCacheEventListenerFactory") ||
121                                    fullyQualifiedClassPath.contains(
122                                            "net.sf.ehcache.distribution")) {
123    
124                                    cacheEventListenerProperties =
125                                            cacheEventListenerFactoryConfiguration.getProperties();
126    
127                                    break;
128                            }
129                    }
130    
131                    cacheEventListenerConfigurations.clear();
132    
133                    return cacheEventListenerProperties;
134            }
135    
136            private static void _configureCacheEventListeners(
137                    boolean enableClusterLinkReplication,
138                    boolean clearCachePeerProviderConfigurations, boolean usingDefault,
139                    CacheConfiguration cacheConfiguration) {
140    
141                    if (cacheConfiguration == null) {
142                            return;
143                    }
144    
145                    List<CacheEventListenerFactoryConfiguration>
146                            cacheEventListenerFactoryConfigurations =
147                                    cacheConfiguration.getCacheEventListenerConfigurations();
148    
149                    boolean usingLiferayCacheEventListenerFactory = false;
150    
151                    for (CacheEventListenerFactoryConfiguration
152                                    cacheEventListenerFactoryConfiguration :
153                                            cacheEventListenerFactoryConfigurations) {
154    
155                            String className =
156                                    cacheEventListenerFactoryConfiguration.
157                                            getFullyQualifiedClassPath();
158    
159                            if (className.equals(
160                                            LiferayCacheEventListenerFactory.class.getName())) {
161    
162                                    usingLiferayCacheEventListenerFactory = true;
163    
164                                    break;
165                            }
166                    }
167    
168                    if (clearCachePeerProviderConfigurations ||
169                            (!usingDefault && usingLiferayCacheEventListenerFactory)) {
170    
171                            String cacheEventListenerProperties =
172                                    _clearCacheEventListenerConfigurations(cacheConfiguration);
173    
174                            if (enableClusterLinkReplication) {
175                                    _enableClusterLinkReplication(
176                                            cacheConfiguration, cacheEventListenerProperties);
177                            }
178                    }
179            }
180    
181            private static void _enableClusterLinkReplication(
182                    CacheConfiguration cacheConfiguration,
183                    String cacheEventListenerProperties) {
184    
185                    CacheEventListenerFactoryConfiguration
186                            cacheEventListenerFactoryConfiguration =
187                                    new CacheEventListenerFactoryConfiguration();
188    
189                    cacheEventListenerFactoryConfiguration.setClass(
190                            EhcachePortalCacheClusterReplicatorFactory.class.getName());
191                    cacheEventListenerFactoryConfiguration.setProperties(
192                            cacheEventListenerProperties);
193    
194                    cacheConfiguration.addCacheEventListenerFactory(
195                            cacheEventListenerFactoryConfiguration);
196            }
197    
198            private static Configuration _processDefaultClusterLinkReplication(
199                    Configuration configuration, boolean usingDefault,
200                    boolean enableClusterLinkReplication) {
201    
202                    boolean clearCachePeerProviderConfigurations = false;
203    
204                    if (((usingDefault && enableClusterLinkReplication) ||
205                            (usingDefault && !PropsValues.CLUSTER_LINK_ENABLED))) {
206    
207                            clearCachePeerProviderConfigurations = true;
208                    }
209    
210                    if (clearCachePeerProviderConfigurations) {
211                            configuration.getCacheManagerPeerListenerFactoryConfigurations().
212                                    clear();
213                            configuration.getCacheManagerPeerProviderFactoryConfiguration().
214                                    clear();
215                    }
216    
217                    CacheConfiguration defaultCacheConfiguration =
218                            configuration.getDefaultCacheConfiguration();
219    
220                    _configureCacheEventListeners(
221                            enableClusterLinkReplication, clearCachePeerProviderConfigurations,
222                            usingDefault, defaultCacheConfiguration);
223    
224                    Map<String, CacheConfiguration> cacheConfigurations =
225                            configuration.getCacheConfigurations();
226    
227                    for (CacheConfiguration cacheConfiguration :
228                                    cacheConfigurations.values()) {
229    
230                            _configureCacheEventListeners(
231                                    enableClusterLinkReplication,
232                                    clearCachePeerProviderConfigurations, usingDefault,
233                                    cacheConfiguration);
234                    }
235    
236                    return configuration;
237            }
238    
239    }