001    /**
002     * Copyright (c) 2000-2013 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;
027    import net.sf.ehcache.config.CacheConfiguration.CacheEventListenerFactoryConfiguration;
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                    List<?> cacheEventListenerConfigurations =
100                            cacheConfiguration.getCacheEventListenerConfigurations();
101    
102                    String cacheEventListenerProperties = null;
103    
104                    for (Object cacheEventListenerConfiguration :
105                                    cacheEventListenerConfigurations) {
106    
107                            CacheEventListenerFactoryConfiguration
108                                    cacheEventListenerFactoryConfiguration =
109                                            (CacheEventListenerFactoryConfiguration)
110                                                    cacheEventListenerConfiguration;
111    
112                            String fullyQualifiedClassPath =
113                                    cacheEventListenerFactoryConfiguration.
114                                            getFullyQualifiedClassPath();
115    
116                            if (fullyQualifiedClassPath.contains(
117                                            "LiferayCacheEventListenerFactory") ||
118                                    fullyQualifiedClassPath.contains(
119                                            "net.sf.ehcache.distribution")) {
120    
121                                    cacheEventListenerProperties =
122                                            cacheEventListenerFactoryConfiguration.getProperties();
123    
124                                    break;
125                            }
126                    }
127    
128                    cacheEventListenerConfigurations.clear();
129    
130                    return cacheEventListenerProperties;
131            }
132    
133            private static void _configureCacheEventListeners(
134                    boolean enableClusterLinkReplication,
135                    boolean clearCachePeerProviderConfigurations, boolean usingDefault,
136                    CacheConfiguration cacheConfiguration) {
137    
138                    if (cacheConfiguration == null) {
139                            return;
140                    }
141    
142                    List<CacheEventListenerFactoryConfiguration>
143                            cacheEventListenerFactoryConfigurations =
144                                    cacheConfiguration.getCacheEventListenerConfigurations();
145    
146                    boolean usingLiferayCacheEventListenerFactory = false;
147    
148                    for (CacheEventListenerFactoryConfiguration
149                                    cacheEventListenerFactoryConfiguration :
150                                            cacheEventListenerFactoryConfigurations) {
151    
152                            String className =
153                                    cacheEventListenerFactoryConfiguration.
154                                            getFullyQualifiedClassPath();
155    
156                            if (className.equals(
157                                            LiferayCacheEventListenerFactory.class.getName())) {
158    
159                                    usingLiferayCacheEventListenerFactory = true;
160    
161                                    break;
162                            }
163                    }
164    
165                    if (clearCachePeerProviderConfigurations ||
166                            (!usingDefault && usingLiferayCacheEventListenerFactory)) {
167    
168                            String cacheEventListenerProperties =
169                                    _clearCacheEventListenerConfigurations(cacheConfiguration);
170    
171                            if (enableClusterLinkReplication) {
172                                    _enableClusterLinkReplication(
173                                            cacheConfiguration, cacheEventListenerProperties);
174                            }
175                    }
176            }
177    
178            private static void _enableClusterLinkReplication(
179                    CacheConfiguration cacheConfiguration,
180                    String cacheEventListenerProperties) {
181    
182                    CacheEventListenerFactoryConfiguration
183                            cacheEventListenerFactoryConfiguration =
184                                    new CacheEventListenerFactoryConfiguration();
185    
186                    cacheEventListenerFactoryConfiguration.setClass(
187                            EhcachePortalCacheClusterReplicatorFactory.class.getName());
188                    cacheEventListenerFactoryConfiguration.setProperties(
189                            cacheEventListenerProperties);
190    
191                    cacheConfiguration.addCacheEventListenerFactory(
192                            cacheEventListenerFactoryConfiguration);
193            }
194    
195            private static Configuration _processDefaultClusterLinkReplication(
196                    Configuration configuration, boolean usingDefault,
197                    boolean enableClusterLinkReplication) {
198    
199                    boolean clearCachePeerProviderConfigurations = false;
200    
201                    if ((usingDefault && enableClusterLinkReplication) ||
202                            (usingDefault && !PropsValues.CLUSTER_LINK_ENABLED)) {
203    
204                            clearCachePeerProviderConfigurations = true;
205                    }
206    
207                    if (clearCachePeerProviderConfigurations) {
208                            configuration.getCacheManagerPeerListenerFactoryConfigurations().
209                                    clear();
210                            configuration.getCacheManagerPeerProviderFactoryConfiguration().
211                                    clear();
212                    }
213    
214                    CacheConfiguration defaultCacheConfiguration =
215                            configuration.getDefaultCacheConfiguration();
216    
217                    _configureCacheEventListeners(
218                            enableClusterLinkReplication, clearCachePeerProviderConfigurations,
219                            usingDefault, defaultCacheConfiguration);
220    
221                    Map<String, CacheConfiguration> cacheConfigurations =
222                            configuration.getCacheConfigurations();
223    
224                    for (CacheConfiguration cacheConfiguration :
225                                    cacheConfigurations.values()) {
226    
227                            _configureCacheEventListeners(
228                                    enableClusterLinkReplication,
229                                    clearCachePeerProviderConfigurations, usingDefault,
230                                    cacheConfiguration);
231                    }
232    
233                    return configuration;
234            }
235    
236    }