/* ===============================================================================
*
* Part of the InfoGlue Content Management Platform (www.infoglue.org)
*
* ===============================================================================
*
* Copyright (C)
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License version 2, as published by the
* Free Software Foundation. See the file LICENSE.html for more information.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY, including the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc. / 59 Temple
* Place, Suite 330 / Boston, MA 02111-1307 / USA.
*
* ===============================================================================
*/
package org.infoglue.deliver.util;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.pluto.portalImpl.services.ServiceManager;
import org.apache.pluto.portalImpl.services.portletentityregistry.PortletEntityRegistry;
import org.exolab.castor.jdo.CacheManager;
import org.exolab.castor.jdo.Database;
import org.exolab.castor.jdo.ObjectNotFoundException;
import org.infoglue.cms.applications.common.VisualFormatter;
import org.infoglue.cms.controllers.kernel.impl.simple.AccessRightController;
import org.infoglue.cms.controllers.kernel.impl.simple.CastorDatabaseService;
import org.infoglue.cms.controllers.kernel.impl.simple.ComponentController;
import org.infoglue.cms.controllers.kernel.impl.simple.ContentCategoryController;
import org.infoglue.cms.controllers.kernel.impl.simple.ContentController;
import org.infoglue.cms.controllers.kernel.impl.simple.ContentTypeDefinitionController;
import org.infoglue.cms.controllers.kernel.impl.simple.ContentVersionController;
import org.infoglue.cms.controllers.kernel.impl.simple.DigitalAssetController;
import org.infoglue.cms.controllers.kernel.impl.simple.GroupPropertiesController;
import org.infoglue.cms.controllers.kernel.impl.simple.InterceptionPointController;
import org.infoglue.cms.controllers.kernel.impl.simple.PropertiesCategoryController;
import org.infoglue.cms.controllers.kernel.impl.simple.SiteNodeController;
import org.infoglue.cms.controllers.kernel.impl.simple.SiteNodeVersionController;
import org.infoglue.cms.entities.content.ContentCategoryVO;
import org.infoglue.cms.entities.content.ContentVO;
import org.infoglue.cms.entities.content.ContentVersionVO;
import org.infoglue.cms.entities.content.SmallestContentVersionVO;
import org.infoglue.cms.entities.content.impl.simple.ContentCategoryImpl;
import org.infoglue.cms.entities.content.impl.simple.ContentImpl;
import org.infoglue.cms.entities.content.impl.simple.ContentRelationImpl;
import org.infoglue.cms.entities.content.impl.simple.ContentVersionImpl;
import org.infoglue.cms.entities.content.impl.simple.DigitalAssetImpl;
import org.infoglue.cms.entities.content.impl.simple.MediumContentImpl;
import org.infoglue.cms.entities.content.impl.simple.MediumDigitalAssetImpl;
import org.infoglue.cms.entities.content.impl.simple.SmallContentImpl;
import org.infoglue.cms.entities.content.impl.simple.SmallContentVersionImpl;
import org.infoglue.cms.entities.content.impl.simple.SmallDigitalAssetImpl;
import org.infoglue.cms.entities.content.impl.simple.SmallestContentVersionImpl;
import org.infoglue.cms.entities.content.impl.simple.SmallishContentImpl;
import org.infoglue.cms.entities.management.AccessRightVO;
import org.infoglue.cms.entities.management.ContentTypeDefinitionVO;
import org.infoglue.cms.entities.management.InterceptionPointVO;
import org.infoglue.cms.entities.management.impl.simple.AccessRightGroupImpl;
import org.infoglue.cms.entities.management.impl.simple.AccessRightImpl;
import org.infoglue.cms.entities.management.impl.simple.AccessRightRoleImpl;
import org.infoglue.cms.entities.management.impl.simple.AccessRightUserImpl;
import org.infoglue.cms.entities.management.impl.simple.AvailableServiceBindingImpl;
import org.infoglue.cms.entities.management.impl.simple.CategoryImpl;
import org.infoglue.cms.entities.management.impl.simple.ContentTypeDefinitionImpl;
import org.infoglue.cms.entities.management.impl.simple.FormEntryImpl;
import org.infoglue.cms.entities.management.impl.simple.FormEntryValueImpl;
import org.infoglue.cms.entities.management.impl.simple.GroupContentTypeDefinitionImpl;
import org.infoglue.cms.entities.management.impl.simple.GroupImpl;
import org.infoglue.cms.entities.management.impl.simple.GroupPropertiesImpl;
import org.infoglue.cms.entities.management.impl.simple.InterceptionPointImpl;
import org.infoglue.cms.entities.management.impl.simple.InterceptorImpl;
import org.infoglue.cms.entities.management.impl.simple.LanguageImpl;
import org.infoglue.cms.entities.management.impl.simple.PropertiesCategoryImpl;
import org.infoglue.cms.entities.management.impl.simple.RedirectImpl;
import org.infoglue.cms.entities.management.impl.simple.RegistryImpl;
import org.infoglue.cms.entities.management.impl.simple.RepositoryImpl;
import org.infoglue.cms.entities.management.impl.simple.RepositoryLanguageImpl;
import org.infoglue.cms.entities.management.impl.simple.RoleContentTypeDefinitionImpl;
import org.infoglue.cms.entities.management.impl.simple.RoleImpl;
import org.infoglue.cms.entities.management.impl.simple.RolePropertiesImpl;
import org.infoglue.cms.entities.management.impl.simple.ServerNodeImpl;
import org.infoglue.cms.entities.management.impl.simple.ServiceDefinitionImpl;
import org.infoglue.cms.entities.management.impl.simple.SiteNodeTypeDefinitionImpl;
import org.infoglue.cms.entities.management.impl.simple.SmallAvailableServiceBindingImpl;
import org.infoglue.cms.entities.management.impl.simple.SmallGroupImpl;
import org.infoglue.cms.entities.management.impl.simple.SmallRepositoryImpl;
import org.infoglue.cms.entities.management.impl.simple.SmallRoleImpl;
import org.infoglue.cms.entities.management.impl.simple.SmallSystemUserImpl;
import org.infoglue.cms.entities.management.impl.simple.SubscriptionImpl;
import org.infoglue.cms.entities.management.impl.simple.SystemUserGroupImpl;
import org.infoglue.cms.entities.management.impl.simple.SystemUserImpl;
import org.infoglue.cms.entities.management.impl.simple.SystemUserRoleImpl;
import org.infoglue.cms.entities.management.impl.simple.UserContentTypeDefinitionImpl;
import org.infoglue.cms.entities.management.impl.simple.UserPropertiesImpl;
import org.infoglue.cms.entities.publishing.impl.simple.PublicationImpl;
import org.infoglue.cms.entities.structure.SiteNodeVO;
import org.infoglue.cms.entities.structure.SiteNodeVersionVO;
import org.infoglue.cms.entities.structure.impl.simple.PureSiteNodeImpl;
import org.infoglue.cms.entities.structure.impl.simple.QualifyerImpl;
import org.infoglue.cms.entities.structure.impl.simple.ServiceBindingImpl;
import org.infoglue.cms.entities.structure.impl.simple.SiteNodeImpl;
import org.infoglue.cms.entities.structure.impl.simple.SiteNodeVersionImpl;
import org.infoglue.cms.entities.structure.impl.simple.SmallSiteNodeImpl;
import org.infoglue.cms.entities.structure.impl.simple.SmallSiteNodeVersionImpl;
import org.infoglue.cms.entities.workflow.impl.simple.ActionDefinitionImpl;
import org.infoglue.cms.entities.workflow.impl.simple.ActionImpl;
import org.infoglue.cms.entities.workflow.impl.simple.ActorImpl;
import org.infoglue.cms.entities.workflow.impl.simple.ConsequenceDefinitionImpl;
import org.infoglue.cms.entities.workflow.impl.simple.ConsequenceImpl;
import org.infoglue.cms.entities.workflow.impl.simple.EventImpl;
import org.infoglue.cms.entities.workflow.impl.simple.WorkflowDefinitionImpl;
import org.infoglue.cms.entities.workflow.impl.simple.WorkflowImpl;
import org.infoglue.cms.exception.Bug;
import org.infoglue.cms.exception.SystemException;
import org.infoglue.cms.io.FileHelper;
import org.infoglue.cms.security.InfoGlueAuthenticationFilter;
import org.infoglue.cms.util.CmsPropertyHandler;
import org.infoglue.cms.util.sorters.CacheComparator;
import org.infoglue.cms.util.workflow.InfoGlueJDBCPropertySet;
import org.infoglue.deliver.applications.actions.InfoGlueComponent;
import org.infoglue.deliver.applications.databeans.CacheEvictionBean;
import org.infoglue.deliver.applications.databeans.DatabaseWrapper;
import org.infoglue.deliver.cache.PageCacheHelper;
import org.infoglue.deliver.invokers.PageInvoker;
import org.infoglue.deliver.portal.ServletConfigContainer;
import org.xmlpull.v1.builder.XmlDocument;
import org.xmlpull.v1.builder.XmlElement;
import org.xmlpull.v1.builder.XmlInfosetBuilder;
import org.xmlpull.v1.builder.xpath.Xb1XPath;
import com.opensymphony.oscache.base.AbstractCacheAdministrator;
import com.opensymphony.oscache.base.CacheEntry;
import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.base.algorithm.ImprovedLRUCache;
import com.opensymphony.oscache.base.events.CacheEntryEventListener;
import com.opensymphony.oscache.base.events.CacheMapAccessEventListener;
import com.opensymphony.oscache.extra.CacheEntryEventListenerImpl;
import com.opensymphony.oscache.extra.CacheMapAccessEventListenerImpl;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;
public class CacheController extends Thread
{
private static long readLockTimeout = 5;
private static long writeLockTimeout = 50;
public final static Logger logger = Logger.getLogger(CacheController.class.getName());
private static VisualFormatter formatter = new VisualFormatter();
public static final String SETTINGSPROPERTIESCACHENAME = "serverNodePropertiesCache";
public static final String SETTINGSPROPERTIESDOCUMENTCACHENAME = "serverNodePropertiesDocumentCache";
public static List notifications = Collections.synchronizedList(new ArrayList());
private static Map eventListeners = new HashMap();
//private static Map caches = new HashMap();
private static ConcurrentMap caches = new ConcurrentHashMap();
//private static Map caches = Collections.synchronizedMap(new HashMap());
private boolean expireCacheAutomatically = false;
private int cacheExpireInterval = 1800000;
private boolean continueRunning = true;
public static Pattern pattern = null;
public static Date expireDateTime = null;
public static Date publishDateTime = null;
private static Map<Integer, Integer> assetContentIdMapping = new HashMap<Integer, Integer>();
private static CompressionHelper compressionHelper = new CompressionHelper();
private static AtomicInteger numberOfPageCacheFiles = new AtomicInteger(0);
//Force mode only happens when a cache eviction has to wait to long. Then we switch to force mode
private static class ThreadLocalCacheEvictionMode extends ThreadLocal
{
public Object initialValue()
{
return false;
}
}
//boolean forcedCacheEvictionMode = false;
private static ThreadLocalCacheEvictionMode cem = new ThreadLocalCacheEvictionMode();
public static Boolean getForcedCacheEvictionMode()
{
return (Boolean) cem.get();
}
public static void setForcedCacheEvictionMode(Boolean cemValue)
{
if(logger.isInfoEnabled())
logger.info("Forcing quick cache eviction...");
cem.set(cemValue);
}
//Force defeatCaches-mode
private static class ThreadLocalDefeatCacheMode extends ThreadLocal<DefeatCacheParameters>
{
public DefeatCacheParameters initialValue()
{
return new DefeatCacheParameters();
}
}
private static ThreadLocalDefeatCacheMode defeatCaches = new ThreadLocalDefeatCacheMode();
public static DefeatCacheParameters getDefeatCaches()
{
return (DefeatCacheParameters) defeatCaches.get();
}
public static void setDefeatCaches(boolean defeatCache, Map<Class, List<Object>> entities)
{
DefeatCacheParameters defeatCachesValue = new DefeatCacheParameters();
defeatCachesValue.setDefeatCache(defeatCache);
if(entities != null)
defeatCachesValue.getEntities().putAll(entities);
if(logger.isInfoEnabled())
logger.info("Forcing defeatCaches...");
defeatCaches.set(defeatCachesValue);
boolean skipClearCastor = false;
if(defeatCaches.get().getEntities() == null || defeatCaches.get().getEntities().size() == 0)
skipClearCastor = true;
if(defeatCache && defeatCaches.get() != null && !skipClearCastor)
{
try
{
clearCastorCaches(defeatCaches.get());
}
catch (Exception e)
{
logger.error("Error setting defeatCaches:" + e.getMessage(), e);
}
}
else if(defeatCache && skipClearCastor)
{
logger.info("Skipping clearCastorCaches as entities was null");
}
}
//Store extra info
private static class ThreadLocalNotificationExtraInformation extends ThreadLocal<Map<String,Map<String,String>>>
{
public Map<String,Map<String,String>> initialValue()
{
return new HashMap<String,Map<String,String>>();
}
}
private static ThreadLocalNotificationExtraInformation extraInfo = new ThreadLocalNotificationExtraInformation();
public static Map<String, String> getExtraInfo(String entityClassName, String entityId)
{
Map<String, Map<String,String>> allExtra = (Map<String, Map<String,String>>) extraInfo.get();
//System.out.println("Returning allExtra for: " + entityClassName + "_" + entityId + ":" + allExtra.get(entityClassName + "_" + entityId));
return allExtra.get(entityClassName + "_" + entityId);
}
public static void setExtraInfo(String entityClassName, String entityId, Map<String,String> extraInfoMap)
{
//System.out.println("Adding extraInfoMap:" + extraInfoMap + " TO " + entityClassName + "_" + entityId);
Map<String, Map<String,String>> allExtra = (Map<String, Map<String,String>>) extraInfo.get();
//System.out.println("Adding allExtra for: " + entityClassName + "_" + entityId + ":" + allExtra);
Map existingMap = getExtraInfo(entityClassName, entityId);
if(existingMap == null)
allExtra.put(entityClassName + "_" + entityId, extraInfoMap);
else
existingMap.putAll(extraInfoMap);
}
private static StringPool stringPool = new StringPool();
public static String getPooledString(Integer type, Object id)
{
if(type == null || id == null)
{
logger.info("Broken was returned from pool:" + type + ":" + id);
return "broken";
}
return stringPool.getCanonicalVersion(type, id.toString());
}
public static String getPooledString(int hashCode)
{
return stringPool.getCanonicalVersion(hashCode);
}
public static Integer getPooledStringSize()
{
return stringPool.getPoolSize();
}
public static Integer getPooledStringHits()
{
return stringPool.getHits();
}
public static void clearPooledString()
{
stringPool.clearPool();
}
public CacheController()
{
super();
}
public static void preCacheCMSEntities() throws Exception
{
Timer t = new Timer();
ContentTypeDefinitionController.getController().getContentTypeDefinitionVOList();
logger.warn("pre cache content types took:" + t.getElapsedTime());
ComponentController.getController().preCacheComponents(-1);
logger.warn("preCacheComponents took:" + t.getElapsedTime());
List<SiteNodeVO> snVOList = SiteNodeController.getController().getSiteNodeVOList(false, 0, 30000);
logger.warn("snVOList:" + snVOList.size() + " fetched and precached in " + t.getElapsedTime() + " ms");
List<ContentVO> cList = ContentController.getContentController().getContentVOList(10000);
logger.warn("cList:" + snVOList.size() + " fetched and precached in " + t.getElapsedTime() + " ms");
/*
List<SiteNodeVO> snVOList = SiteNodeController.getController().getSiteNodeVOList(false, 0, 10000);
logger.info("snVOList:" + snVOList.size() + " fetched and precached");
List<SiteNodeVersionVO> snvVOList = SiteNodeController.getController().getSiteNodeVersionVOList(false, 0, 10000);
logger.info("snvVOList:" + snvVOList.size() + " fetched and precached");
List<ContentVO> cList = ContentController.getContentController().getContentVOList(false, 10000);
logger.info("cList:" + cList.size() + " fetched and precached");
List<ContentVersionVO> cvList = ContentVersionController.getContentVersionController().getContentVersionVOList(null, false, 0);
logger.info("cvList:" + cvList.size() + " fetched and precached");
*/
}
public static void preCacheDeliverEntities() throws Exception
{
Timer t = new Timer();
class PreCacheGroupPropertiesTask implements Runnable
{
PreCacheGroupPropertiesTask() { }
public void run()
{
try
{
Timer t = new Timer();
Database db = CastorDatabaseService.getDatabase();
try
{
beginTransaction(db);
GroupPropertiesController.getController().preCacheAllGroupProperties(db);
logger.warn("preCacheAllGroupProperties took: " + t.getElapsedTime());
commitTransaction(db);
}
catch (Exception e)
{
logger.error("Error precaching all group properties: " + e.getMessage(), e);
rollbackTransaction(db);
}
}
catch (Exception e)
{
logger.error("Could not start PreCacheTask:" + e.getMessage(), e);
}
finally
{
GroupPropertiesController.inCacheProgress.set(false);
}
}
}
if(GroupPropertiesController.inCacheProgress.compareAndSet(false, true))
{
Thread thread = new Thread(new PreCacheGroupPropertiesTask());
thread.start();
}
if(CacheController.getCacheSize("propertiesCategoryCache") == 0 && GroupPropertiesController.preCacheInProgress.compareAndSet(false, true))
{
try
{
PropertiesCategoryController.getController().preCacheAllPropertiesCategoryVOList();
}
finally
{
GroupPropertiesController.preCacheInProgress.set(false);
}
logger.warn("preCacheAllPropertiesCategoryVOList took: " + t.getElapsedTime());
}
ContentTypeDefinitionController.getController().getContentTypeDefinitionVOList();
logger.warn("pre cache content types took:" + t.getElapsedTime());
ComponentController.getController().preCacheComponents(-1);
logger.warn("preCacheComponents took:" + t.getElapsedTime());
List<SiteNodeVO> snVOList = SiteNodeController.getController().getSiteNodeVOList(false, new Integer(CmsPropertyHandler.getOperatingMode()), 30000);
logger.warn("snVOList:" + snVOList.size() + " fetched and precached in " + t.getElapsedTime() + " ms");
List<ContentVO> cList = ContentController.getContentController().getContentVOList(10000);
logger.warn("cList:" + snVOList.size() + " fetched and precached in " + t.getElapsedTime() + " ms");
/*
FileInputStream fis = new FileInputStream(CmsPropertyHandler.getDigitalAssetPath() + File.separator + "startupCache.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Map<Integer,Integer> mostUsedContentId = (Map<Integer,Integer>) ois.readObject();
ois.close();
*/
/*
List<SiteNodeVO> snVOList = SiteNodeController.getController().getSiteNodeVOList(false, 0, 100000);
logger.info("snVOList:" + snVOList.size() + " fetched and precached");
List<SiteNodeVersionVO> snvVOList = SiteNodeController.getController().getSiteNodeVersionVOList(false, 0, 100000);
logger.info("snvVOList:" + snvVOList.size() + " fetched and precached");
List<ContentVO> cList = ContentController.getContentController().getContentVOList(false, 100000);
logger.info("cList:" + cList.size() + " fetched and precached");
List<ContentVersionVO> cvList = ContentVersionController.getContentVersionController().getContentVersionVOList(null, false, 0, 100000);
logger.info("cvList:" + cvList.size() + " fetched and precached");
*/
}
public void setCacheExpireInterval(int cacheExpireInterval)
{
this.cacheExpireInterval = cacheExpireInterval;
}
public static void renameCache(String cacheName, String newCacheName)
{
//synchronized(caches)
//{
Object cacheInstance = caches.get(cacheName);
if(cacheInstance != null)
{
synchronized(cacheInstance)
{
caches.put(newCacheName, cacheInstance);
//locksCache.put(newCacheName, new ReentrantReadWriteLock());
caches.remove(cacheName);
}
}
//}
}
public static void clearServerNodeProperty(boolean reCache)
{
if(reCache)
InfoGlueJDBCPropertySet.reCache();
else
InfoGlueJDBCPropertySet.clearCaches();
clearCache("serverNodePropertiesCache");
clearCache("encodedStringsCache");
clearCache("principalToolPropertiesCache");
CmsPropertyHandler.resetHardCachedSettings();
}
public static void cacheObject(String cacheName, Object key, Object value)
{
if(cacheName == null || key == null || value == null)
return;
//synchronized(caches)
//{
if(caches.get(cacheName) == null)
caches.put(cacheName, new HashMap());
//}
//synchronized(caches)
//{
Map cacheInstance = (Map)caches.get(cacheName);
if(cacheInstance != null && key != null && value != null)
{
if(CmsPropertyHandler.getUseSynchronizationOnCaches())
{
synchronized(cacheInstance)
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheInstance.put("" + key.hashCode(), value);
else
cacheInstance.put(key, value);
}
}
else
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheInstance.put("" + key.hashCode(), value);
else
cacheInstance.put(key, value);
}
}
//}
}
public static Object getCachedObject(String cacheName, Object key)
{
if(cacheName == null || key == null)
return null;
if(getDefeatCaches() != null && getDefeatCaches().getDefeatCache("" + cacheName + "_" + key))
{
if(!cacheName.equals("serverNodePropertiesCache") &&
!cacheName.equals("contentTypeDefinitionCache")
)
{
if (logger.isInfoEnabled())
{
logger.info("Missed cache: " + cacheName + " because of defeat caches. Cache.key: " + key);
}
return null;
}
}
//synchronized(caches)
//{
Map cacheInstance = (Map)caches.get(cacheName);
if(cacheInstance != null)
{
//TODO
if(CmsPropertyHandler.getUseSynchronizationOnCaches())
{
synchronized(cacheInstance)
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
return cacheInstance.get("" + key.hashCode());
else
return cacheInstance.get(key);
}
}
else
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
return cacheInstance.get("" + key.hashCode());
else
return cacheInstance.get(key);
}
}
//}
return null;
}
public static void cacheObjectInAdvancedCacheWithGroupsAsSet(String cacheName, Object key, Object value, Set<String> groupsAsList, boolean useGroups)
{
String[] groups = groupsAsList.toArray(new String[0]);
cacheObjectInAdvancedCache(cacheName, key, value, groups, useGroups);
}
public static void cacheObjectInAdvancedCache(String cacheName, Object key, Object value)
{
cacheObjectInAdvancedCache(cacheName, key, value, null, false);
}
public static void cacheObjectInAdvancedCache(String cacheName, Object key, Object value, boolean useFileCacheFallback, String fileCacheCharEncoding)
{
cacheObjectInAdvancedCache(cacheName, key, value, null, false, useFileCacheFallback, true, fileCacheCharEncoding);
}
public static void cacheObjectInAdvancedCache(String cacheName, Object key, Object value, String[] groups, boolean useGroups)
{
cacheObjectInAdvancedCache(cacheName, key, value, groups, useGroups, false, true, null);
}
public static void cacheObjectInAdvancedCache(String cacheName, Object key, Object value, String[] groups, boolean useGroups, boolean useFileCacheFallback, boolean useMemoryCache, String fileCacheCharEncoding)
{
if(cacheName == null || key == null || value == null || key.toString().length() == 0)
return;
if(defeatCaches.get().getDefeatCache())
defeatCaches.get().setDefeatedKey("" + cacheName + "_" + key.toString());
/*
if(cacheName.equalsIgnoreCase("pageCacheExtra"))
System.out.println("key pageCacheExtra: " + key);
if(cacheName.equalsIgnoreCase("pageCache"))
System.out.println("key pageCache: " + key);
*/
if(logger.isInfoEnabled() && cacheName.equalsIgnoreCase("pageCacheExtra"))
{
logger.info("cacheName: " + cacheName);
logger.info("key: " + key);
logger.info("useGroups: " + useGroups);
logger.info("useFileCacheFallback: " + useFileCacheFallback);
logger.info("useMemoryCache: "+ useMemoryCache);
logger.info("groups: " + (groups == null ? "null" : groups.length));
if(groups != null)
{
for(String group : groups)
logger.info(group + ",");
}
}
if(useMemoryCache)
{
if(!caches.containsKey(cacheName))
{
GeneralCacheAdministrator cacheAdministrator = null;
Map cacheSettings = (Map)getCachedObject("serverNodePropertiesCacheSettings", "cacheSettings");
if(cacheSettings == null)
{
cacheSettings = CmsPropertyHandler.getCacheSettings();
cacheObject("serverNodePropertiesCacheSettings", "cacheSettings", cacheSettings);
}
String cacheCapacity = (String)cacheSettings.get("CACHE_CAPACITY_" + cacheName);
if(cacheCapacity == null || !cacheCapacity.equals(""))
cacheCapacity = "15000";
if(cacheName != null && cacheName.startsWith("contentAttributeCache"))
cacheCapacity = "50000";
if(cacheName != null && cacheName.startsWith("metaInfoContentAttributeCache"))
cacheCapacity = "40000";
//else if(cacheName != null && cacheName.startsWith("contentAttributeCache"))
// cacheCapacity = "1000";
String pageCacheSize = "100";
String pageCacheExtraSize = "300";
if(CmsPropertyHandler.getOperatingMode().equals("3"))
{
pageCacheSize = "10000";
pageCacheExtraSize = "30000";
}
if(cacheName != null && cacheName.startsWith("pageCache"))
cacheCapacity = pageCacheSize;
if(cacheName != null && cacheName.startsWith("pageCacheExtra"))
cacheCapacity = pageCacheExtraSize;
if(cacheName != null && cacheName.equalsIgnoreCase("encodedStringsCache"))
cacheCapacity = "2000";
if(cacheName != null && cacheName.equalsIgnoreCase("assetUrlCacheWithGroups"))
cacheCapacity = "10000";
if(cacheName != null && cacheName.equalsIgnoreCase("importTagResultCache"))
cacheCapacity = "500";
if(cacheName != null && cacheName.equalsIgnoreCase("componentPropertyCache"))
cacheCapacity = "10000";
if(cacheName != null && cacheName.equalsIgnoreCase("componentPropertyVersionIdCache"))
cacheCapacity = "10000";
if(cacheName != null && cacheName.equalsIgnoreCase("componentPropertyCacheRepoGroups"))
cacheCapacity = "5000";
if(cacheName != null && cacheName.equalsIgnoreCase("componentPropertyVersionIdCacheRepoGroups"))
cacheCapacity = "5000";
if(cacheName != null && cacheName.equalsIgnoreCase("componentEditorCache"))
cacheCapacity = "3000";
if(cacheName != null && cacheName.equalsIgnoreCase("componentEditorVersionIdCache"))
cacheCapacity = "3000";
if(cacheName != null && cacheName.equalsIgnoreCase("contentVersionIdCache"))
cacheCapacity = "30000";
if(cacheName != null && cacheName.equalsIgnoreCase("contentVersionCache"))
cacheCapacity = "30000";
if(cacheName != null && cacheName.equalsIgnoreCase("pageComponentsCache"))
cacheCapacity = "10000";
if(cacheName != null && cacheName.equalsIgnoreCase("boundContentCache"))
cacheCapacity = "5000";
if(cacheName != null && cacheName.equalsIgnoreCase("childSiteNodesCache"))
cacheCapacity = "20000";
if(cacheName != null && cacheName.equalsIgnoreCase("childPagesCache"))
cacheCapacity = "20000";
if(cacheName != null && cacheName.equalsIgnoreCase("siteNodeCache"))
cacheCapacity = "20000";
if(cacheName != null && cacheName.equalsIgnoreCase("contentCache"))
cacheCapacity = "20000";
if(cacheName != null && cacheName.equalsIgnoreCase("latestSiteNodeVersionCache"))
cacheCapacity = "20000";
if(cacheName != null && cacheName.equalsIgnoreCase("pageDeliveryMetaDataCache"))
cacheCapacity = "50000";
/*
if(cacheCapacity.length() > 4)
cacheCapacity = "10000";
*/
/*
if(cacheName != null && (cacheName.equalsIgnoreCase("contentAttributeCache_Title") ||
cacheName.equalsIgnoreCase("contentAttributeCache_NavigationTitle") ||
cacheName.equalsIgnoreCase("contentAttributeCache_hideInNavigation") ||
cacheName.equalsIgnoreCase("contentAttributeCache_SortOrder")))
{
cacheCapacity = "100000";
}
*/
if(cacheCapacity != null && !cacheCapacity.equals(""))
{
Properties p = new Properties();
String cacheAlgorithm = (String)cacheSettings.get("CACHE_ALGORITHM_" + cacheName);
if(cacheAlgorithm == null || cacheAlgorithm.equals(""))
p.setProperty(AbstractCacheAdministrator.CACHE_ALGORITHM_KEY, "com.opensymphony.oscache.base.algorithm.ImprovedLRUCache");
else
p.setProperty(AbstractCacheAdministrator.CACHE_ALGORITHM_KEY, cacheAlgorithm);
//p.setProperty(AbstractCacheAdministrator.CACHE_ALGORITHM_KEY, "com.opensymphony.oscache.base.algorithm.LRUCache");
p.setProperty(AbstractCacheAdministrator.CACHE_CAPACITY_KEY, cacheCapacity);
cacheAdministrator = new GeneralCacheAdministrator(p);
}
else
{
cacheAdministrator = new GeneralCacheAdministrator();
}
CacheEntryEventListenerImpl cacheEntryEventListener = new ExtendedCacheEntryEventListenerImpl();
CacheMapAccessEventListenerImpl cacheMapAccessEventListener = new CacheMapAccessEventListenerImpl();
cacheAdministrator.getCache().addCacheEventListener(cacheEntryEventListener, CacheEntryEventListener.class);
cacheAdministrator.getCache().addCacheEventListener(cacheMapAccessEventListener, CacheMapAccessEventListener.class);
caches.put(cacheName, cacheAdministrator);
//locksCache.put(cacheName, new ReentrantReadWriteLock());
}
GeneralCacheAdministrator cacheAdministrator = (GeneralCacheAdministrator)caches.get(cacheName);
//if(cacheName.startsWith("contentAttribute")/* || cacheName.startsWith("contentVersionIdCache")*/)
// useGroups = false;
//boolean containsSelectiveCacheUpdateNonApplicable = false;
if(groups != null)
{
List<String> groupCandidateListStandard = new ArrayList<String>();
List<String> groupCandidateListSpecial = new ArrayList<String>();
for(int i=0; i<groups.length; i++)
{
if(groups[i].startsWith("content") || groups[i].startsWith("siteNode"))
groupCandidateListStandard.add(groups[i]);
else
groupCandidateListSpecial.add(groups[i]);
}
if(!groupCandidateListSpecial.contains("selectiveCacheUpdateNonApplicable"))
{
groupCandidateListSpecial.addAll(groupCandidateListStandard);
}
String[] newGroups = new String[groupCandidateListSpecial.size()];
groups = groupCandidateListSpecial.toArray(newGroups);
}
if(logger.isInfoEnabled() && cacheName.equalsIgnoreCase("pageCacheExtra"))
{
logger.info("real groups: " + (groups == null ? "null" : groups.length));
if(groups != null)
{
for(String group : groups)
logger.info(group + ",");
}
}
//Kanske tillbaka om minnet sticker
if(cacheName.equals("componentPropertyCache") || cacheName.equals("componentPropertyVersionIdCache"))
{
//logger.error("Skipping useGroups on " + cacheName + ". Groups was:" + groups.length + " for " + key);
useGroups = false;
}
/*
if(cacheName.equals("componentPropertyCache") || cacheName.equals("componentPropertyVersionIdCache"))
{
//logger.error("Skipping useGroups on " + cacheName + ". Groups was:" + groups.length + " for " + key);
useGroups = false;
}
*/
/*
if(cacheName.startsWith("pageCache"))
{
//logger.error("Skipping useGroups on pageCache. Groups was:" + groups.length + " for " + key);
useGroups = false;
}
*/
//TODO
if(CmsPropertyHandler.getUseSynchronizationOnCaches())
{
synchronized(cacheAdministrator) //Back
{
try
{
if(useGroups)
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.putInCache("" + key.toString().hashCode(), value, groups);
else
cacheAdministrator.putInCache(key.toString(), value, groups);
}
else
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.putInCache("" + key.toString().hashCode(), value);
else
cacheAdministrator.putInCache(key.toString(), value);
}
}
catch (Exception e)
{
logger.warn("Error putting in cache:" + e.getMessage());
}
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Putting object in " + cacheName, t.getElapsedTime());
}
}
else
{
try
{
if(useGroups)
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.putInCache("" + key.toString().hashCode(), value, groups);
else
cacheAdministrator.putInCache(key.toString(), value, groups);
}
else
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.putInCache("" + key.toString().hashCode(), value);
else
cacheAdministrator.putInCache(key.toString(), value);
}
}
catch (Exception e)
{
logger.warn("Error putting in cache:" + e.getMessage(), e);
}
}
}
// logger.info("numberOfPageCacheFiles:" + numberOfPageCacheFiles.get());
if(cacheName.equals("pageCache") && numberOfPageCacheFiles.get() > 30000)
{
if(logger.isInfoEnabled())
logger.info("Skipping file cache as to many files were allready there");
useFileCacheFallback = false;
}
//if(cacheName.equals("pageCache"))
// logger.info("useFileCacheFallback:" + useFileCacheFallback + " - useGroups:" + useGroups);
if(useFileCacheFallback && !useGroups)
{
if(logger.isInfoEnabled())
logger.info("Caching value to disk also");
String compressPageCache = CmsPropertyHandler.getCompressPageCache();
//System.out.println("Caching in file...:" + value.toString());
if(cacheName.equals("pageCache") && compressPageCache != null && compressPageCache.equals("true"))
putCachedCompressedContentInFile(cacheName, key.toString(), (byte[])value);
else
putCachedContentInFile(cacheName, key.toString(), value.toString(), fileCacheCharEncoding);
}
//logger.info("Done cacheObjectInAdvancedCache");
}
/*
public static void printLockDebug(ReentrantReadWriteLock rwl) {
System.out.println("CurrentThread hasLock: " + rwl.writeLock().isHeldByCurrentThread());
System.out.println("CurrentThread getWriteHoldCount: " + rwl.getWriteHoldCount());
System.out.println("CurrentThread getWriteHoldCount: " + rwl.getReadLockCount());
System.out.println("CurrentThread getQueueLength: " + rwl.getQueueLength());
System.out.println("CurrentThread hasQueuedThreads: " + rwl.hasQueuedThreads());
System.out.println("CurrentThread isWriteLocked: " + rwl.isWriteLocked());
}
*/
public static void cacheObjectInAdvancedCache(String cacheName, Object key, Object value, boolean useFileCacheFallback, boolean useMemoryCache, String fileCacheCharEncoding, Integer memoryCacheSize, boolean unlimitedDiskCache)
{
cacheObjectInAdvancedCache(cacheName, key, value, null, false, useFileCacheFallback, useMemoryCache, fileCacheCharEncoding, memoryCacheSize, unlimitedDiskCache, false);
}
public static void cacheObjectInAdvancedCache(String cacheName, Object key, Object value, String[] groups, boolean useGroups, boolean useFileCacheFallback, boolean useMemoryCache, String fileCacheCharEncoding, Integer memoryCacheSize, boolean unlimitedDiskCache, boolean persistentCachesBetweenRestarts)
{
if(cacheName == null || key == null || value == null || key.toString().length() == 0)
return;
if(defeatCaches.get().getDefeatCache())
defeatCaches.get().setDefeatedKey("" + cacheName + "_" + key.toString());
if(logger.isInfoEnabled())
{
logger.info("cacheName: " + cacheName);
logger.info("key: " + key);
logger.info("useFileCacheFallback: " + useFileCacheFallback);
logger.info("useMemoryCache: "+ useMemoryCache);
logger.info("fileCacheCharEncoding: "+ fileCacheCharEncoding);
logger.info("memoryCacheSize: "+ memoryCacheSize);
logger.info("unlimitedDiskCache: "+ unlimitedDiskCache);
logger.info("persistentCachesBetweenRestarts: "+ persistentCachesBetweenRestarts);
}
if(!caches.containsKey(cacheName))
{
GeneralCacheAdministrator cacheAdministrator = null;
Properties p = new Properties();
p.setProperty(AbstractCacheAdministrator.CACHE_MEMORY_KEY, Boolean.toString(useMemoryCache));
p.setProperty(AbstractCacheAdministrator.CACHE_DISK_UNLIMITED_KEY, Boolean.toString(unlimitedDiskCache));
p.setProperty(AbstractCacheAdministrator.CACHE_CAPACITY_KEY, "" + memoryCacheSize);
p.setProperty(AbstractCacheAdministrator.CACHE_PERSISTENCE_OVERFLOW_KEY, Boolean.toString(useFileCacheFallback));
p.setProperty(AbstractCacheAdministrator.CACHE_ALGORITHM_KEY, "com.opensymphony.oscache.base.algorithm.ImprovedLRUCache");
p.setProperty("cache.persistence.class", "com.opensymphony.oscache.plugins.diskpersistence.DiskPersistenceListener");
p.setProperty("cache.path", CmsPropertyHandler.getDigitalAssetPath() + File.separator + (persistentCachesBetweenRestarts ? "persistentCaches" : "caches") + File.separator + cacheName);
cacheAdministrator = new GeneralCacheAdministrator(p);
//Adding one entry just to get the disk cache active
if(useFileCacheFallback && memoryCacheSize == 1)
cacheAdministrator.putInCache("dummy", "value");
//CacheEntryEventListenerImpl cacheEntryEventListener = new ExtendedCacheEntryEventListenerImpl();
//CacheMapAccessEventListenerImpl cacheMapAccessEventListener = new CacheMapAccessEventListenerImpl();
//cacheAdministrator.getCache().addCacheEventListener(cacheEntryEventListener, CacheEntryEventListener.class);
//cacheAdministrator.getCache().addCacheEventListener(cacheMapAccessEventListener, CacheMapAccessEventListener.class);
caches.put(cacheName, cacheAdministrator);
//locksCache.put(cacheName, new ReentrantReadWriteLock());
//eventListeners.put(cacheName + "_cacheEntryEventListener", cacheEntryEventListener);
//eventListeners.put(cacheName + "_cacheMapAccessEventListener", cacheMapAccessEventListener);
}
GeneralCacheAdministrator cacheAdministrator = (GeneralCacheAdministrator)caches.get(cacheName);
if(groups != null)
{
List<String> groupCandidateListStandard = new ArrayList<String>();
List<String> groupCandidateListSpecial = new ArrayList<String>();
for(int i=0; i<groups.length; i++)
{
if(groups[i].startsWith("content") || groups[i].startsWith("siteNode"))
groupCandidateListStandard.add(groups[i]);
else
groupCandidateListSpecial.add(groups[i]);
}
if(!groupCandidateListSpecial.contains("selectiveCacheUpdateNonApplicable"))
{
groupCandidateListSpecial.addAll(groupCandidateListStandard);
}
String[] newGroups = new String[groupCandidateListSpecial.size()];
groups = groupCandidateListSpecial.toArray(newGroups);
}
if(CmsPropertyHandler.getUseSynchronizationOnCaches())
{
synchronized(cacheAdministrator) //Back
{
try
{
if(useGroups)
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.putInCache("" + key.toString().hashCode(), value, groups);
else
cacheAdministrator.putInCache(key.toString(), value, groups);
}
else
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.putInCache("" + key.toString().hashCode(), value);
else
cacheAdministrator.putInCache(key.toString(), value);
}
}
catch (Exception e)
{
logger.warn("Error putting in cache:" + e.getMessage());
}
}
}
else
{
try
{
if(useGroups)
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.putInCache("" + key.toString().hashCode(), value, groups);
else
cacheAdministrator.putInCache(key.toString(), value, groups);
}
else
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.putInCache("" + key.toString().hashCode(), value);
else
cacheAdministrator.putInCache(key.toString(), value);
}
}
catch (Exception e)
{
logger.warn("Error putting in cache:" + e.getMessage(), e);
}
}
//logger.info("Done cacheObjectInAdvancedCache");
}
public static Object getCachedObjectFromAdvancedCache(String cacheName, String key)
{
return getCachedObjectFromAdvancedCache(cacheName, key, false, "UTF-8", false);
}
public static Object getCachedObjectFromAdvancedCache(String cacheName, String key, boolean useFileCacheFallback, String fileCacheCharEncoding, boolean cacheFileResultInMemory)
{
if(cacheName == null || key == null || key.length() == 0)
return null;
if(getDefeatCaches().getDefeatCache("" + cacheName + "_" + key))
return null;
Object value = null;
boolean stopUseFileCacheFallback = false;
//synchronized(caches)
//{
GeneralCacheAdministrator cacheAdministrator = (GeneralCacheAdministrator)caches.get(cacheName);
if(cacheAdministrator != null)
{
//TODO
if(CmsPropertyHandler.getUseSynchronizationOnCaches())
{
synchronized(cacheAdministrator) //Back
{
try
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
value = (cacheAdministrator == null) ? null : cacheAdministrator.getFromCache("" + key.hashCode(), CacheEntry.INDEFINITE_EXPIRY);
else
value = (cacheAdministrator == null) ? null : cacheAdministrator.getFromCache(key, CacheEntry.INDEFINITE_EXPIRY);
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Getting from cache on " + cacheName, t.getElapsedTime());
}
catch (NeedsRefreshException nre)
{
if(useFileCacheFallback && nre.getCacheContent() != null)
{
stopUseFileCacheFallback = true;
}
try
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.cancelUpdate("" + key.hashCode());
else
cacheAdministrator.cancelUpdate(key);
}
catch (Exception e)
{
logger.error("Error:" + e.getMessage());
}
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Getting object 3 part 2 from " + cacheName, t.getElapsedTime());
}
}
}
else
{
try
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
value = (cacheAdministrator == null) ? null : cacheAdministrator.getFromCache("" + key.hashCode(), CacheEntry.INDEFINITE_EXPIRY);
else
value = (cacheAdministrator == null) ? null : cacheAdministrator.getFromCache(key, CacheEntry.INDEFINITE_EXPIRY);
}
catch (NeedsRefreshException nre)
{
if(useFileCacheFallback && nre.getCacheContent() != null)
{
stopUseFileCacheFallback = true;
}
try
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.cancelUpdate("" + key.hashCode());
else
cacheAdministrator.cancelUpdate(key);
}
catch (Exception e)
{
logger.error("Error:" + e.getMessage());
}
}
}
}
if(value == null && useFileCacheFallback && !stopUseFileCacheFallback)
{
Timer t = new Timer();
if(logger.isInfoEnabled())
logger.info("Getting cache content from file..");
value = getCachedContentFromFile(cacheName, key, fileCacheCharEncoding);
if(value != null && cacheFileResultInMemory)
{
if(logger.isInfoEnabled())
logger.info("Got cached content from file as it did not exist in memory...:" + value.toString().length());
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheObjectInAdvancedCache(cacheName, "" + key.hashCode(), value);
else
cacheObjectInAdvancedCache(cacheName, key, value);
}
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("File cache", t.getElapsedTime());
}
//}
return value;
}
public static Object getCachedObjectFromAdvancedCache(String cacheName, String key, boolean useFileCacheFallback, String fileCacheCharEncoding, boolean cacheFileResultInMemory, Object o, Method m, Object[] args, PageInvoker pageInvoker) throws Exception
{
if(cacheName == null || key == null || key.length() == 0)
return null;
Object value = null;
String pageKey = key;
//if(CmsPropertyHandler.getUseHashCodeInCaches())
// pageKey = "" + key.hashCode();
GeneralCacheAdministrator cacheAdministrator = (GeneralCacheAdministrator)caches.get(cacheName);
if(cacheAdministrator == null)
{
Map cacheSettings = (Map)getCachedObject("serverNodePropertiesCacheSettings", "cacheSettings");
if(cacheSettings == null)
{
cacheSettings = CmsPropertyHandler.getCacheSettings();
cacheObject("serverNodePropertiesCacheSettings", "cacheSettings", cacheSettings);
}
String cacheCapacity = "20000";
String cacheCapacityProperty = (String)cacheSettings.get("CACHE_CAPACITY_" + cacheName);
if(cacheCapacityProperty != null && !cacheCapacityProperty.equals(""))
cacheCapacity = cacheCapacityProperty;
if(cacheCapacity != null && !cacheCapacity.equals(""))
{
Properties p = new Properties();
logger.info("Creating cache " + cacheName + " with:" + cacheCapacity);
p.setProperty(AbstractCacheAdministrator.CACHE_ALGORITHM_KEY, "com.opensymphony.oscache.base.algorithm.ImprovedLRUCache");
p.setProperty(AbstractCacheAdministrator.CACHE_CAPACITY_KEY, cacheCapacity);
cacheAdministrator = new GeneralCacheAdministrator(p);
}
else
{
cacheAdministrator = new GeneralCacheAdministrator();
logger.info("Creating cache without limit" + cacheName);
}
if(cacheAdministrator.getCache().cacheMap instanceof ImprovedLRUCache)
((ImprovedLRUCache)cacheAdministrator.getCache().cacheMap).setIsPageCache(true);
CacheEntryEventListenerImpl cacheEntryEventListener = new ExtendedCacheEntryEventListenerImpl();
CacheMapAccessEventListenerImpl cacheMapAccessEventListener = new CacheMapAccessEventListenerImpl();
cacheAdministrator.getCache().addCacheEventListener(cacheEntryEventListener, CacheEntryEventListener.class);
cacheAdministrator.getCache().addCacheEventListener(cacheMapAccessEventListener, CacheMapAccessEventListener.class);
caches.put(cacheName, cacheAdministrator);
//locksCache.put(cacheName, new ReentrantReadWriteLock());
}
if(logger.isInfoEnabled())
logger.info("Getting from file: " + pageKey);
Object pageCacheFileName = getCachedObjectFromAdvancedCache(cacheName, pageKey, CacheEntry.INDEFINITE_EXPIRY);
if(logger.isInfoEnabled())
logger.info("pageCacheFileName:" + pageCacheFileName + " from " + cacheName + " and key: " + pageKey);
if(pageCacheFileName != null && !pageCacheFileName.equals(""))
value = PageCacheHelper.getInstance().getCachedPageString(pageKey, new File(pageCacheFileName.toString()));
else
logger.info("No page file name in memory cache:" + pageKey);
//System.out.println("value:" + value);
//value = getCachedObjectFromAdvancedCache(cacheName, pageKey, CacheEntry.INDEFINITE_EXPIRY);
if(value == null)
{
logger.info("Invoking:" + cacheName);
String result = (String)m.invoke(o, args);
logger.info("result:" + (result == null ? "null" : result.length()));
value = result;
if(result != null)
{
cacheNewResult(pageInvoker, cacheAdministrator, pageKey, result);
}
value = result;
}
if(value != null && value instanceof byte[])
value = compressionHelper.decompress((byte[])value);
return value;
}
public static Map<String,Object> getCachedObjectsFromAdvancedCacheFilteredOnKeyEnd(String cacheName, String keyNameFilter)
{
if(cacheName == null)
return null;
if(getDefeatCaches().getDefeatCache())
return null;
Map<String,Object> cachedValues = new HashMap<String,Object>();
GeneralCacheAdministrator cacheAdministrator = (GeneralCacheAdministrator)caches.get(cacheName);
if(cacheAdministrator != null)
{
synchronized(cacheAdministrator) //Back
{
try
{
if(cacheAdministrator != null)
{
for(String key : (Set<String>)cacheAdministrator.getCache().cacheMap.keySet())
{
if(key.toString().endsWith(keyNameFilter))
{
try
{
cachedValues.put(key, cacheAdministrator.getCache().getFromCache(key));
}
catch (NeedsRefreshException nre)
{
logger.info("Stale cache entry");
cacheAdministrator.cancelUpdate(key);
}
}
}
}
}
catch (Exception e)
{
logger.error("Problem getting all cache keys and values:" + e.getMessage(), e);
}
}
}
return cachedValues;
}
private static boolean cacheNewResult(PageInvoker pageInvoker, GeneralCacheAdministrator cacheAdministrator, String pageKey, String value)
{
/*
int argumentCount = StringUtils.countMatches(pageKey, "&");
if(argumentCount > 4)
{
logger.error("Skipping caching as we don't cache url:s with more than 3 params:" + pageKey);
return false;
}
argumentCount = StringUtils.countMatches(pageKey, "/");
if(argumentCount > 7)
{
logger.error("Skipping caching as we don't cache url:s with more than 7 slashes:" + pageKey);
return false;
}
*/
boolean isCached = false;
String pageCacheExtraName = "pageCacheExtra";
if(!pageInvoker.getTemplateController().getIsPageCacheDisabled() && !pageInvoker.getDeliveryContext().getDisablePageCache()) //Caching page if not disabled
{
Integer newPageCacheTimeout = pageInvoker.getDeliveryContext().getPageCacheTimeout();
if(newPageCacheTimeout == null)
newPageCacheTimeout = pageInvoker.getTemplateController().getPageCacheTimeout();
//String[] allUsedEntitiesCopy = pageInvoker.getDeliveryContext().getAllUsedEntities().clone();
List<String> allUsedEntitiesSet = pageInvoker.getDeliveryContext().getAllUsedEntitiesAsSet();
//String[] allUsedEntitiesCopy = allUsedEntitiesSet.toArray(new String[0]);
//System.out.println("allUsedEntitiesSet:" + allUsedEntitiesSet.size());
String pageCacheExclusionsRegexp = null;
Integer pageCacheMaxGroups = 500;
try
{
Map cacheSettings = CmsPropertyHandler.getCacheSettings();
//System.out.println("cacheSettings:" + cacheSettings);
if(cacheSettings != null)
{
pageCacheExclusionsRegexp = (String)cacheSettings.get("PAGE_CACHE_EXCLUSIONS");
String pageCacheMaxGroupsString = (String)cacheSettings.get("PAGE_CACHE_MAX_GROUPS");
if(pageCacheMaxGroupsString != null)
pageCacheMaxGroups = new Integer(pageCacheMaxGroupsString);
if(pageCacheExclusionsRegexp != null && !pageCacheExclusionsRegexp.equals(""))
pattern = Pattern.compile(pageCacheExclusionsRegexp);
}
}
catch (Exception e)
{
logger.warn("cacheSettings was null:" + e.getMessage(), e);
}
if(logger.isInfoEnabled())
{
logger.info("pageCacheExclusionsRegexp:" + pageCacheExclusionsRegexp);
logger.info("pageCacheMaxGroups:" + pageCacheMaxGroups);
}
boolean detailedRelations = true;
if(allUsedEntitiesSet.size() > pageCacheMaxGroups)
detailedRelations = false;
//System.out.println("detailedRelations:" + detailedRelations);
//System.out.println("allUsedEntitiesSet:" + allUsedEntitiesSet.size());
Object extraData = pageInvoker.getDeliveryContext().getExtraData();
List<String> allUsedEntitiesFilteredCopy = new ArrayList<String>();
for(String s : allUsedEntitiesSet)
{
if(detailedRelations)
{
if(s.startsWith("content_") && s.indexOf("_", 8) > -1)
{
//allUsedEntitiesFilteredCopy.add(getPooledString(s.hashCode()));
allUsedEntitiesFilteredCopy.add(s); //(getPooledString(s.hashCode()));
//System.out.println("Added: " + s);
}
else if(s.startsWith("siteNode_"))
allUsedEntitiesFilteredCopy.add(s);
else if(s.startsWith("selectiveCacheUpdateNonApplicable"))
allUsedEntitiesFilteredCopy.add(s);
}
else
{
if(s.startsWith("content_") && s.indexOf("_", 8) == -1)
{
allUsedEntitiesFilteredCopy.add(s);
//allUsedEntitiesFilteredCopy.add(s); //getPooledString(s.hashCode()));
//System.out.println("Added: " + s);
}
else if(s.startsWith("siteNode_"))
allUsedEntitiesFilteredCopy.add(s);
else if(s.startsWith("selectiveCacheUpdateNonApplicable"))
allUsedEntitiesFilteredCopy.add(s);
}
}
//System.out.println("allUsedEntitiesFilteredCopy:" + allUsedEntitiesFilteredCopy.size());
try
{
logger.info("pageCacheExclusionsRegexp:" + pageCacheExclusionsRegexp);
logger.info("pageCacheMaxGroups:" + pageCacheMaxGroups);
if(pattern != null)
{
Matcher matcher = pattern.matcher(pageKey);
if(matcher.find())
{
logger.info("Skipping caching key 1:" + pageKey);
return false;
}
if(pageCacheMaxGroups != null && !pageCacheMaxGroups.equals("") && allUsedEntitiesFilteredCopy.size() > pageCacheMaxGroups)
{
logger.info("Skipping caching key 2:" + pageKey);
return false;
}
matcher.reset();
}
}
catch (Exception e)
{
logger.warn("cacheSettings was null:" + e.getMessage(), e);
}
String[] allUsedEntitiesCopy = allUsedEntitiesFilteredCopy.toArray(new String[0]);
//System.out.println("allUsedEntitiesCopy:" + allUsedEntitiesCopy.length);
logger.info("allUsedEntitiesCopy:" + allUsedEntitiesCopy.length);
logger.info("Caching:" + pageKey);
synchronized (cacheAdministrator)
{
byte[] compressedData = compressionHelper.compress(value);
//logger.info("Compressing page for pageCache took " + (System.currentTimeMillis() - startCompression) + " with a compressionFactor of " + (this.pageString.length() / compressedData.length));
if(pageInvoker.getTemplateController().getOperatingMode().intValue() == 3 && !CmsPropertyHandler.getLivePublicationThreadClass().equalsIgnoreCase("org.infoglue.deliver.util.SelectiveLivePublicationThread"))
{
PageCacheHelper.getInstance().cachePageString(pageKey, compressedData);
//cacheAdministrator.putInCache(pageKey, compressedData, allUsedEntitiesCopy);
isCached = true;
//CacheController.cacheObjectInAdvancedCache(pageCacheExtraName, pageKey, extraData, allUsedEntitiesCopy, false);
//CacheController.cacheObjectInAdvancedCache(pageCacheExtraName, pageKey + "_pageCacheTimeout", newPageCacheTimeout, allUsedEntitiesCopy, false);
}
else
{
//FIX THE part above as well
//System.out.println("Caching in pageCache");
PageCacheHelper.getInstance().cachePageString(pageKey, compressedData);
//cacheAdministrator.putInCache(pageKey, compressedData, allUsedEntitiesCopy);
isCached = true;
/*
if(pageInvoker.getTemplateController().getHttpServletRequest().getParameter("listMostUsed") != null)
{
System.out.println("These contents were used before:" + ContentDeliveryController.mostUsedContentIds.size());
Map<Integer,Integer> contentIds = ContentDeliveryController.mostUsedContentIds;
for(Integer contentId : contentIds.keySet())
{
if(contentIds.get(contentId) > 3)
System.out.println("" + contentId + ":" + contentIds.get(contentId));
}
}
*/
if(pageInvoker.getTemplateController().getHttpServletRequest().getParameter("listEntities") != null)
{
List<String> debug = Arrays.asList(allUsedEntitiesCopy);
Collections.sort(debug);
for(String s : debug)
{
System.out.println("s:" + s);
}
}
CacheController.cacheObjectInAdvancedCache(pageCacheExtraName, pageKey, extraData, null, false);
CacheController.cacheObjectInAdvancedCache(pageCacheExtraName, pageKey + "_pageCacheTimeout", newPageCacheTimeout, null, false);
//CacheController.cacheObjectInAdvancedCache(pageCacheExtraName, pageKey + "_entities", allUsedEntitiesCopy, null, false);
String allUsedEntitiesCopyAsString = StringUtils.join(allUsedEntitiesCopy, "|");
if(logger.isInfoEnabled())
{
logger.info("pageKey:" + pageKey);
logger.info("allUsedEntitiesCopyAsString:" + allUsedEntitiesCopyAsString);
}
if(CmsPropertyHandler.getOperatingMode().equals("0"))
{
CacheController.cacheObjectInAdvancedCache(pageCacheExtraName, pageKey + "_entitiesAsByte", allUsedEntitiesCopyAsString);
}
else
{
byte[] compressedAllUsedEntitiesCopyAsString = compressionHelper.compress(allUsedEntitiesCopyAsString);
CacheController.cacheObjectInAdvancedCache(pageCacheExtraName, pageKey + "_entitiesAsByte", compressedAllUsedEntitiesCopyAsString);
}
}
}
}
else
{
if(logger.isInfoEnabled())
logger.info("Page caching was disabled for the page " + pageInvoker.getDeliveryContext().getSiteNodeId() + " with pageKey " + pageInvoker.getDeliveryContext().getPageKey() + " - modifying the logic to enable page caching would boast performance.");
}
return isCached;
}
public static Object getCachedObjectFromAdvancedCache(String cacheName, String key, int updateInterval)
{
return getCachedObjectFromAdvancedCache(cacheName, key, updateInterval, false, "UTF-8", false);
}
public static Object getCachedObjectFromAdvancedCache(String cacheName, String key, int updateInterval, boolean useFileCacheFallback, String fileCacheCharEncoding, boolean cacheFileResultInMemory)
{
if(cacheName == null || key == null)
return null;
if(getDefeatCaches().getDefeatCache("" + cacheName + "_" + key))
return null;
//logger.info("getCachedObjectFromAdvancedCache start:" + cacheName + ":" + key + ":" + updateInterval);
//return getCachedObject(cacheName, key);
Object value = null;
boolean stopUseFileCacheFallback = false;
//synchronized(caches)
//{
GeneralCacheAdministrator cacheAdministrator = (GeneralCacheAdministrator)caches.get(cacheName);
if(cacheAdministrator != null)
{
//TODO
if(CmsPropertyHandler.getUseSynchronizationOnCaches())
{
try
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
value = (cacheAdministrator == null) ? null : cacheAdministrator.getFromCache("" + key.hashCode(), updateInterval);
else
value = (cacheAdministrator == null) ? null : cacheAdministrator.getFromCache(key, updateInterval);
}
catch (NeedsRefreshException nre)
{
if(useFileCacheFallback && nre.getCacheContent() != null)
{
stopUseFileCacheFallback = true;
}
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.cancelUpdate("" + key.hashCode());
else
cacheAdministrator.cancelUpdate(key);
}
}
else
{
try
{
if(CmsPropertyHandler.getUseHashCodeInCaches())
value = (cacheAdministrator == null) ? null : cacheAdministrator.getFromCache("" + key.hashCode(), updateInterval);
else
value = (cacheAdministrator == null) ? null : cacheAdministrator.getFromCache(key, updateInterval);
}
catch (NeedsRefreshException nre)
{
if(useFileCacheFallback && nre.getCacheContent() != null)
{
stopUseFileCacheFallback = true;
}
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheAdministrator.cancelUpdate("" + key.hashCode());
else
cacheAdministrator.cancelUpdate(key);
}
}
if(useFileCacheFallback && !stopUseFileCacheFallback)
{
if(logger.isInfoEnabled())
logger.info("Getting cache content from file..");
value = getCachedContentFromFile(cacheName, key, updateInterval, fileCacheCharEncoding);
if(value != null && cacheFileResultInMemory)
{
if(logger.isInfoEnabled())
logger.info("Got cached content from file as it did not exist in memory...:" + value.toString().length());
if(CmsPropertyHandler.getUseHashCodeInCaches())
cacheObjectInAdvancedCache(cacheName, "" + key.hashCode(), value);
else
cacheObjectInAdvancedCache(cacheName, key, value);
}
}
}
//}
return value;
}
/**
* This method let's you get a list of caches and entries in which the given entity is located.
* @param entityName
* @param entityId
* @throws Exception
*/
public static String debugCache(String entityName, String entityId, String cacheNamesToDebug, String forceClear) throws Exception
{
StringBuffer debug = new StringBuffer();
if(entityName.equalsIgnoreCase("content"))
entityName = "content";
if(entityName.equalsIgnoreCase("sitenode"))
entityName = "siteNode";
logger.error("Debugging " + entityName + "=" + entityId + " (" + cacheNamesToDebug + ")" + " - forceClear:" + forceClear);
/*
Boolean isEntityPublicationProcessed = false;
try
{
isEntityPublicationProcessed = PublicationController.getController().getIsEntityPublicationProcessed(entityName, entityId);
System.out.println("isEntityPublicationProcessed: " + isEntityPublicationProcessed);
}
catch (Exception e)
{
e.printStackTrace();
}
*/
if(cacheNamesToDebug == null || cacheNamesToDebug.equals(""))
cacheNamesToDebug = "contentVersionCache,contentVersionIdCache,contentCache,matchingContentsCache,pageCache,pageCacheExtra";
logger.info("cacheNamesToDebug:" + cacheNamesToDebug);
Set<String> pageCacheNotifications = new HashSet<String>();
List<String[]> entriesToClear = new ArrayList<String[]>();
String[] cacheNamesToDebugArray = cacheNamesToDebug.split(",");
List<String> cacheNamesToDebugList = Arrays.asList(cacheNamesToDebugArray);
synchronized(caches)
{
for (Iterator i = caches.entrySet().iterator(); i.hasNext(); )
{
Map.Entry e = (Map.Entry) i.next();
String cachName = (String)e.getKey();
//System.out.println("Cache: " + cachName);
if(cacheNamesToDebugList.contains(cachName))
{
//debug.append("Checked: " + cachName + ",");
Object object = e.getValue();
if(object instanceof Map)
{
Map cacheInstance = (Map)e.getValue();
synchronized(cacheInstance)
{
Set<Map.Entry<String,Object>> entrySet = cacheInstance.entrySet();
logger.info("entrySet:" + entrySet.size());
Iterator<Map.Entry<String,Object>> entrySetIterator = entrySet.iterator();
while(entrySetIterator.hasNext())
{
Map.Entry<String,Object> entry = entrySetIterator.next();
if(entry.getKey().toLowerCase().contains(entityName.toLowerCase()) || entry.getKey().contains("selectiveCacheUpdateNonApplicable"))
{
debug.append("" + cachName + "=" + entry.getKey() + ",");
entriesToClear.add(new String[]{cachName, entry.getKey()});
}
}
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)e.getValue();
synchronized(cacheInstance)
{
pageCacheNotifications.add(entityName + "_" + entityId);
Set<String> entries = cacheInstance.getCache().getGroup(entityName + "_" + entityId);
logger.info("entries:" + entries.size());
for(String entry : entries)
{
//debug.append("" + cachName + "=" + entry + ",");
entriesToClear.add(new String[]{cachName, entry});
}
try
{
pageCacheNotifications.add("selectiveCacheUpdateNonApplicable");
if(entityName.toLowerCase().equals("content"))
{
List<ContentTypeDefinitionVO> contentTypeDefinitionVOList = ContentTypeDefinitionController.getController().getContentTypeDefinitionVOList();
for(ContentTypeDefinitionVO ctdVO : contentTypeDefinitionVOList)
{
//System.out.println("Group:" + "selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + ctdVO.getId());
Set<String> selectiveCacheUpdateNonApplicableEntries = cacheInstance.getCache().getGroup("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + ctdVO.getId());
for(String entry : selectiveCacheUpdateNonApplicableEntries)
{
//debug.append("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + ctdVO.getId() + "/" + cachName + "=" + entry + ",");
//debug.append("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + ctdVO.getId() + ",");
entriesToClear.add(new String[]{cachName, entry});
pageCacheNotifications.add("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + ctdVO.getId());
}
}
}
Set<String> selectiveCacheUpdateNonApplicableEntries = cacheInstance.getCache().getGroup("selectiveCacheUpdateNonApplicable");
for(String entry : selectiveCacheUpdateNonApplicableEntries)
{
//debug.append("selectiveCacheUpdateNonApplicable: " + cachName + "=" + entry + ",");
entriesToClear.add(new String[]{cachName, entry});
pageCacheNotifications.add("selectiveCacheUpdateNonApplicable");
}
}
catch (Exception e2)
{
e2.printStackTrace();
}
}
}
}
else
logger.info("Skipping cache:" + cachName);
}
}
if(forceClear != null && forceClear.equalsIgnoreCase("true"))
{
logger.info("********** Clearing caches *********");
String entityNameFull = ContentImpl.class.getName();
if(entityName.toLowerCase().contains("sitenode"))
entityNameFull = SiteNodeImpl.class.getName();
CacheController.clearCaches(entityNameFull, entityId, null);
}
for(String[] clearEntries : entriesToClear)
{
debug.append("" + clearEntries[0] + "=" + clearEntries[1] + ",");
if(forceClear != null && forceClear.equalsIgnoreCase("true"))
{
clearCacheHard(clearEntries[0], clearEntries[1]);
}
}
for(String pageCacheNotification : pageCacheNotifications)
{
logger.info("Asking page cache to clear on: " + pageCacheNotification);
debug.append("PageCache: " + pageCacheNotification + ",");
if(forceClear != null && forceClear.equalsIgnoreCase("true"))
PageCacheHelper.getInstance().notify(pageCacheNotification);
}
if(forceClear != null && forceClear.equalsIgnoreCase("true"))
System.out.println("************************************");
if(entityName.contains("siteNode"))
{
SiteNodeVO siteNodeVO = SiteNodeController.getController().getSiteNodeVOWithId(new Integer(entityId));
if(siteNodeVO != null && siteNodeVO.getMetaInfoContentId() != null)
{
debug.append(debugCache("Content", siteNodeVO.getMetaInfoContentId().toString(), cacheNamesToDebug, forceClear));
}
}
return debug.toString();
}
public static void clearCachesStartingWith(String cacheNamePrefix)
{
Set keySet = new HashSet();
keySet.addAll(caches.keySet());
Iterator cachesIterator = keySet.iterator();
while(cachesIterator.hasNext())
{
String cacheName = (String)cachesIterator.next();
if(cacheName.startsWith(cacheNamePrefix))
clearCache(cacheName);
}
}
public static void clearUserAccessCache(String accessRightKey)
{
if(caches.containsKey("userAccessCache"))
{
Object object = caches.get("userAccessCache");
Map cacheInstance = (Map)object;
synchronized(cacheInstance)
{
for(Object personalCache : cacheInstance.values())
{
//System.out.println("personalCache:" + personalCache);
if(personalCache instanceof Map)
{
//System.out.println("personalCache contains:" + ((Map)personalCache).containsKey(accessRightKey));
//((Map) personalCache).remove(accessRightKey);
((Map) personalCache).put(accessRightKey, -1);
//System.out.println("personalCache contains after:" + ((Map)personalCache).containsKey(accessRightKey));
}
}
}
logger.info("clearCache stop...");
}
}
public static int getCacheSize(String cacheName)
{
int cacheSize = 0;
synchronized(caches)
{
if(caches.containsKey(cacheName))
{
Object object = caches.get(cacheName);
if(object instanceof Map)
{
Map cacheInstance = (Map)object;
synchronized(cacheInstance)
{
cacheSize = cacheInstance.size();
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)object;
synchronized(cacheInstance) //Back
{
/*
Timer t = new Timer();
ReentrantReadWriteLock rwl = locksCache.get(cacheName);
boolean lockSuccess = false;
try {
System.out.println("YAAAAAAAAAAAAA 2");
lockSuccess = rwl.readLock().tryLock(readLockTimeout, TimeUnit.SECONDS);
} catch (InterruptedException e1) {
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Error getting lock in getCacheSize on " + cacheName, t.getElapsedTime());
printLockDebug(rwl);
return 0;
}
//rwl.readLock().lock();
try
{
if(!lockSuccess)
{
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Timeout getting lock in getCacheSize on " + cacheName, t.getElapsedTime());
return 0;
}
*/
cacheSize = cacheInstance.getCache().getSize();
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Getting getCacheSize on " + cacheName, t.getElapsedTime());
}
/*
finally
{
if(lockSuccess)
rwl.readLock().unlock();
}
*/
}
}
}
return cacheSize;
}
public static void clearCache(String cacheName)
{
logger.info("Clearing the cache called " + cacheName);
synchronized(caches)
{
if(caches.containsKey(cacheName))
{
Object object = caches.get(cacheName);
if(object instanceof Map)
{
Map cacheInstance = (Map)object;
synchronized(cacheInstance)
{
cacheInstance.clear();
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)object;
synchronized(cacheInstance) //Back
{
/*
Timer t = new Timer();
ReentrantReadWriteLock rwl = locksCache.get(cacheName);
boolean lockSuccess = false;
try {
lockSuccess = rwl.writeLock().tryLock(writeLockTimeout, TimeUnit.SECONDS);
printLockDebug(rwl);
} catch (InterruptedException e1) {
return;
}
//rwl.writeLock().lock();
try
{
if(!lockSuccess)
{
printLockDebug(rwl);
return;
}
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Getting lock for flushing " + cacheName, t.getElapsedTime());
*/
cacheInstance.flushAll();
cacheInstance.destroy();
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Flushing " + cacheName, t.getElapsedTime());
}
/*
finally
{
if(lockSuccess)
rwl.writeLock().unlock();
}
*/
}
caches.remove(cacheName);
logger.info("clearCache stop...");
}
}
}
public static void flushCache(String cacheName)
{
logger.info("Flushing the cache called " + cacheName);
synchronized(caches)
{
if(caches.containsKey(cacheName))
{
Object object = caches.get(cacheName);
if(object instanceof Map)
{
Map cacheInstance = (Map)object;
synchronized(cacheInstance)
{
cacheInstance.clear();
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)object;
synchronized(cacheInstance) //Back
{
/*
Timer t = new Timer();
ReentrantReadWriteLock rwl = locksCache.get(cacheName);
boolean lockSuccess = false;
try {
System.out.println("ddddddddddddddddddd");
lockSuccess = rwl.writeLock().tryLock(writeLockTimeout, TimeUnit.SECONDS);
} catch (InterruptedException e1) {
printLockDebug(rwl);
return;
}
//rwl.writeLock().lock();
try
{
if(!lockSuccess)
{
printLockDebug(rwl);
return;
}
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Getting lock for flushing " + cacheName, t.getElapsedTime());
*/
cacheInstance.flushAll();
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Flushing " + cacheName, t.getElapsedTime());
}
/*
finally
{
if(lockSuccess)
rwl.writeLock().unlock();
}
*/
}
//caches.remove(cacheName);
//eventListeners.remove(cacheName + "_cacheEntryEventListener");
//eventListeners.remove(cacheName + "_cacheMapAccessEventListener");
logger.info("clearCache stop...");
}
}
}
public static void clearCache(String cacheName, String key)
{
//synchronized(caches)
//{
if(caches.containsKey(cacheName))
{
Object object = caches.get(cacheName);
if(object instanceof Map)
{
Map cacheInstance = (Map)object;
synchronized(cacheInstance)
{
cacheInstance.remove(key);
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)object;
synchronized(cacheInstance) //Back
{
cacheInstance.flushEntry(key);
}
}
}
//}
}
public static void clearCacheHard(String cacheName, String key)
{
if(caches.containsKey(cacheName))
{
Object object = caches.get(cacheName);
if(object instanceof Map)
{
Map cacheInstance = (Map)object;
synchronized(cacheInstance)
{
cacheInstance.remove(key);
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)object;
synchronized(cacheInstance) //Back
{
//cacheInstance.flushEntry(key);
cacheInstance.removeEntry(key);
}
}
}
}
/**
* This method clears part of a cache.
* @param cacheName
* @param groups
*/
public static void clearCacheForGroup(String cacheName, String group)
{
/*
if(cacheName.indexOf("pageCache") > -1)
Thread.dumpStack();
*/
synchronized(caches)
{
if(caches.containsKey(cacheName))
{
Object object = caches.get(cacheName);
if(object instanceof Map)
{
Map cacheInstance = (Map)object;
synchronized(cacheInstance)
{
cacheInstance.clear();
logger.info("Clearing full cache:" + cacheName + " - the call wanted partly clear for [" + group + "] but the cache was a Map.");
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)object;
synchronized(cacheInstance) //Back
{
/*
Timer t = new Timer();
ReentrantReadWriteLock rwl = locksCache.get(cacheName);
boolean lockSuccess = false;
try {
System.out.println("YEEEEEEEEEEEEEEEEEAAAAAAH");
lockSuccess = rwl.writeLock().tryLock(writeLockTimeout, TimeUnit.SECONDS);
printLockDebug(rwl);
} catch (InterruptedException e1) {
return;
}
//rwl.writeLock().lock();
try
{
if(!lockSuccess)
{
return;
}
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Getting lock for flushGroup in " + cacheName, t.getElapsedTime());
*/
cacheInstance.flushGroup(group);
// RequestAnalyser.getRequestAnalyser().registerComponentStatistics("FlushGroup on " + cacheName, t.getElapsedTime());
}
/*
finally
{
if(lockSuccess)
rwl.writeLock().unlock();
}
*/
}
}
}
}
/**
* This method clears part of a cache.
* @param cacheName
* @param groups
*/
/*
public static void clearFileCacheForGroup(GeneralCacheAdministrator cacheInstance, String groupName) throws Exception
{
Set groupEntries = cacheInstance.getCache().cacheMap.getGroup(groupName);
if(logger.isInfoEnabled())
{
if(groupEntries != null)
logger.info("groupEntries for " + groupName + ":" + groupEntries.size() + " in cacheInstance:" + cacheInstance);
else
logger.info("no groupEntries for " + groupName + " in cacheInstance:" + cacheInstance);
}
if (groupEntries != null)
{
Iterator groupEntriesIterator = groupEntries.iterator();
while (groupEntriesIterator.hasNext())
{
String key = (String) groupEntriesIterator.next();
CacheEntry entry = (CacheEntry) cacheInstance.getCache().cacheMap.get(key);
if(logger.isInfoEnabled())
logger.info("Removing file with key:" + key);
removeCachedContentInFile("pageCache", key);
numberOfPageCacheFiles.decrementAndGet();
}
}
}
*/
public static void clearCaches(String entity, String entityId, String[] cachesToSkip) throws Exception
{
clearCaches(entity, entityId, null, cachesToSkip, false);
}
public static void clearCaches(String entity, String entityId, Map<String,String> extraInformation, String[] cachesToSkip) throws Exception
{
clearCaches(entity, entityId, extraInformation, cachesToSkip, false);
}
public static void clearCaches(String entity, String entityId, Map<String,String> extraInformation, String[] cachesToSkip, boolean forceClear) throws Exception
{
Timer t = new Timer();
//t.setActive(false);
if(CmsPropertyHandler.getOperatingMode().equals("3"))
{
long wait = 0;
//while(true && !getForcedCacheEvictionMode())
while(!forceClear && !getForcedCacheEvictionMode() && RequestAnalyser.getRequestAnalyser().getNumberOfActiveRequests() > 0)
{
logger.warn("Number of requests: " + RequestAnalyser.getRequestAnalyser().getNumberOfCurrentRequests() + " was more than 0 - lets wait a bit.");
if(wait > 1000)
{
logger.warn("The clearCache method waited over " + ((wait * 10) / 1000) + " seconds but there seems to be " + RequestAnalyser.getRequestAnalyser().getNumberOfCurrentRequests() + " requests blocking all the time. Continuing anyway.");
//printThreads();
break;
}
if(wait > 100)
setForcedCacheEvictionMode(true);
Thread.sleep(10);
wait++;
}
}
logger.info("clearCaches start in " + CmsPropertyHandler.getContextRootPath());
if(entity == null)
{
logger.info("Clearing the caches");
//synchronized(caches)
//{
for (Iterator i = caches.entrySet().iterator(); i.hasNext(); )
{
Map.Entry e = (Map.Entry) i.next();
logger.info("e:" + e.getKey());
boolean skip = false;
if(cachesToSkip != null)
{
for(int index=0; index<cachesToSkip.length; index++)
{
if(e.getKey().equals(cachesToSkip[index]))
{
skip = true;
break;
}
}
}
if(!skip)
{
Object object = e.getValue();
if(object instanceof Map)
{
Map cacheInstance = (Map)e.getValue();
synchronized(cacheInstance)
{
cacheInstance.clear();
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)e.getValue();
synchronized(cacheInstance)
{
cacheInstance.flushAll();
}
}
logger.info("Cleared cache:" + e.getKey());
i.remove();
}
}
//}
}
else if(entity.equalsIgnoreCase("CacheNames"))
{
String[] cacheNames = entityId.split(",");
for(int i=0; i<cacheNames.length; i++)
{
String cacheName = cacheNames[i];
CacheController.clearCache(cacheName);
}
}
else
{
logger.info("Clearing some caches");
logger.info("entity:" + entity);
String useSelectivePageCacheUpdateString = CmsPropertyHandler.getUseSelectivePageCacheUpdate();
boolean useSelectivePageCacheUpdate = false;
if(useSelectivePageCacheUpdateString != null && useSelectivePageCacheUpdateString.equalsIgnoreCase("true"))
useSelectivePageCacheUpdate = true;
String operatingMode = CmsPropertyHandler.getOperatingMode();
TreeMap<String, Object> orderedCaches = new TreeMap<String,Object>(new CacheComparator());
orderedCaches.putAll(caches);
/*
for (String key : orderedCaches.keySet())
{
System.out.println("key:" + key);
}
*/
//t.printElapsedTime("Start cache eviction");
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Start cache eviction", t.getElapsedTime());
//t.printElapsedTime("START cachesLoop:" + entity + ":" + entityId);
//synchronized(caches)
//{
//for (Iterator i = caches.entrySet().iterator(); i.hasNext(); )
cachesLoop:for (Iterator i = orderedCaches.entrySet().iterator(); i.hasNext(); )
{
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("cache iteration top", t.getElapsedTime());
Map.Entry e = (Map.Entry) i.next();
logger.info("e:" + e.getKey());
boolean clear = false;
boolean selectiveCacheUpdate = false;
String cacheName = e.getKey().toString();
if(cachesToSkip != null)
{
for(int index=0; index<cachesToSkip.length; index++)
{
if(cacheName.equals(cachesToSkip[index]))
{
continue cachesLoop;
}
}
}
//t.printElapsedTime("clearCaches 3");
if(cacheName.equalsIgnoreCase("serviceDefinitionCache") && entity.indexOf("ServiceBinding") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("qualifyerListCache") && (entity.indexOf("Qualifyer") > 0 || entity.indexOf("ServiceBinding") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("availableServiceBindingCache") && entity.indexOf("AvailableServiceBinding") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("categoriesCache") && entity.indexOf("Category") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("repositoryCache") && entity.indexOf("Repository") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("languageCache") && entity.indexOf("Language") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("localeCache") && entity.indexOf("Language") > 0)
{
clear = true;
}
if((cacheName.equalsIgnoreCase("latestSiteNodeVersionCache") || cacheName.equalsIgnoreCase("pageCacheLatestSiteNodeVersions") || cacheName.equalsIgnoreCase("pageCacheSiteNodeTypeDefinition")) && entity.indexOf("SiteNode") > 0)
{
clear = true;
selectiveCacheUpdate = true;
}
if((cacheName.equalsIgnoreCase("parentSiteNodeCache") || cacheName.equalsIgnoreCase("pageCacheParentSiteNodeCache")) && entity.indexOf("SiteNode") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("NavigationCache") && (entity.indexOf("SiteNode") > 0 || entity.indexOf("Content") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("pagePathCache") && (entity.indexOf("SiteNode") > 0 || entity.indexOf("Content") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("componentEditorCache") && (entity.indexOf("SiteNode") > 0 || entity.indexOf("Content") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("componentEditorVersionIdCache") && (entity.indexOf("SiteNode") > 0 || entity.indexOf("Content") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("masterLanguageCache") && (entity.indexOf("Repository") > 0 || entity.indexOf("Language") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("parentRepository") && entity.indexOf("Repository") > 0)
{
clear = true;
}
if(cacheName.startsWith("contentAttributeCache") && (entity.indexOf("Content") > -1 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.startsWith("metaInfoContentAttributeCache") && entity.indexOf("Content") > -1)
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("contentVersionCache") && (entity.indexOf("Content") > -1 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.startsWith("contentVersionIdCache") && (entity.indexOf("Content") > -1 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("referencingPagesCache") && (entity.indexOf("ContentVersion") > -1 || entity.indexOf("Qualifyer") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("boundSiteNodeCache") && (entity.indexOf("ServiceBinding") > 0 || entity.indexOf("Qualifyer") > 0 || entity.indexOf("SiteNodeVersion") > 0 || entity.indexOf("SiteNodeVersion") > 0 || entity.indexOf("SiteNode") > 0 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("boundContentCache") && (entity.indexOf("ServiceBinding") > 0 || entity.indexOf("Qualifyer") > 0 || entity.indexOf("SiteNodeVersion") > 0 || entity.indexOf("ContentVersion") > 0 || entity.indexOf("Content") > 0 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
}
if(cacheName.startsWith("pageCache") && entity.indexOf("Registry") == -1)
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.startsWith("pageCacheExtra") && entity.indexOf("Registry") == -1)
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("componentCache") && entity.indexOf("Registry") == -1)
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("componentPropertyCache") && (entity.indexOf("SiteNode") > -1 || entity.indexOf("ContentVersion") > -1 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
//selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("componentPropertyVersionIdCache") && (entity.indexOf("SiteNode") > -1 || entity.indexOf("ContentVersion") > -1 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
//selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("componentPropertyCacheRepoGroups") && (entity.indexOf("SiteNode") > -1 || entity.indexOf("ContentVersion") > -1 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
if(entity.indexOf("SiteNode") > -1 || entity.indexOf("ContentVersion") > -1)
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("componentPropertyVersionIdCacheRepoGroups") && (entity.indexOf("SiteNode") > -1 || entity.indexOf("ContentVersion") > -1 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
if(entity.indexOf("SiteNode") > -1 || entity.indexOf("ContentVersion") > -1)
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("pageComponentsCache") && (entity.indexOf("ContentVersion") > -1 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
//selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("includeCache"))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("authorizationCache") && (entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0 || entity.indexOf("Intercept") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("personalAuthorizationCache") && (entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0 || entity.indexOf("Intercept") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("componentPaletteDivCache") && (entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("userCache") && (entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("principalCache") && (entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
}
if((cacheName.equalsIgnoreCase("assetUrlCache") || cacheName.equalsIgnoreCase("assetUrlCacheWithGroups") || cacheName.equalsIgnoreCase("assetThumbnailUrlCache")) && (entity.indexOf("DigitalAsset") > 0 || entity.indexOf("ContentVersion") > 0 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
if(cacheName.equalsIgnoreCase("assetUrlCacheWithGroups") && (entity.indexOf("ContentVersion") > -1 || entity.indexOf("DigitalAsset") > -1))
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("digitalAssetCache") && (entity.indexOf("DigitalAsset") > 0 || entity.indexOf("ContentVersion") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("sortedChildContentsCache") && (entity.indexOf("Content") > 0 || entity.indexOf("ContentVersion") > 0 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("childContentCache") && (entity.indexOf("Content") > 0 || entity.indexOf("ContentVersion") > 0 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("matchingContentsCache") && (entity.indexOf("Content") > 0 || entity.indexOf("ContentVersion") > 0 || entity.indexOf("AccessRight") > 0 || entity.indexOf("SystemUser") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("Group") > 0))
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("workflowCache") && entity.indexOf("WorkflowDefinition") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("rootSiteNodeCache") && entity.indexOf("SiteNode") > 0)
{
if(CmsPropertyHandler.getOperatingMode().equals("0"))
clear = true;
}
if((cacheName.equalsIgnoreCase("siteNodeCache") || cacheName.equalsIgnoreCase("siteNodeVOCache")) && entity.indexOf("SiteNode") > 0)
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("contentCache") && entity.indexOf("Content") > 0)
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("rootContentCache") && entity.indexOf("Content") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("componentContentsCache") && entity.indexOf("Content") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("childSiteNodesCache") && (entity.indexOf("SiteNode") > 0 || entity.indexOf("ContentVersion") > 0))
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("childPagesCache") && (entity.indexOf("SiteNode") > 0 || entity.indexOf("Content") > 0))
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("siteNodeCacheWithLatestVersion") && entity.indexOf("SiteNode") > 0)
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("propertySetCache") && entity.indexOf("SiteNode") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("groupVOListCache") && entity.indexOf("Group") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("roleListCache") && entity.indexOf("Role") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("groupPropertiesCache") && (entity.indexOf("Group") > 0 || entity.indexOf("PropertiesCategory") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("propertiesCategoryCache") && (entity.indexOf("Group") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("User") > 0 || entity.indexOf("PropertiesCategory") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("rolePropertiesCache") && entity.indexOf("Role") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("principalPropertyValueCache") && (entity.indexOf("Group") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("User") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("relatedCategoriesCache") && (entity.indexOf("Group") > 0 || entity.indexOf("Role") > 0 || entity.indexOf("User") > 0 || entity.indexOf("PropertiesCategory") > 0))
{
clear = true;
}
if(cacheName.equalsIgnoreCase("categoryCache") && entity.indexOf("Category") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("contentCategoryCache") && entity.indexOf("ContentVersion") > 0)
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("redirectCache") && entity.indexOf("Redirect") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("interceptorsCache") && entity.indexOf("Intercept") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("interceptionPointCache") && entity.indexOf("Intercept") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("siteNodeLanguageCache") && (entity.indexOf("Repository") > 0 || entity.indexOf("Language") > 0 || entity.indexOf("SiteNode") > 0))
{
clear = true;
selectiveCacheUpdate = true;
}
if(cacheName.equalsIgnoreCase("contentTypeDefinitionCache") && entity.indexOf("ContentTypeDefinition") > 0)
{
clear = true;
}
if(cacheName.equalsIgnoreCase("ServerNodeProperties"))
{
clear = true;
}
if(!cacheName.equalsIgnoreCase("serverNodePropertiesCache") && entity.equalsIgnoreCase("ServerNodeProperties"))
{
clear = true;
}
if(!cacheName.equalsIgnoreCase("encodedStringsCache") && entity.equalsIgnoreCase("ServerNodeProperties"))
{
clear = true;
}
if(logger.isInfoEnabled())
logger.info("clear:" + clear);
if(clear)
{
if(logger.isInfoEnabled())
logger.info("clearing:" + e.getKey());
Object object = e.getValue();
String sentContentId = null;
String sentParentContentId = null;
String sentSiteNodeId = null;
String sentParentSiteNodeId = null;
String sentRepositoryId = null;
String sentContentTypeDefinitionId = null;
String sentContentIsProtected = null;
if (extraInformation != null)
{
sentContentId = extraInformation.get("contentId");
sentParentContentId = extraInformation.get("parentContentId");
sentSiteNodeId = extraInformation.get("siteNodeId");
sentParentSiteNodeId = extraInformation.get("parentSiteNodeId");
sentRepositoryId = extraInformation.get("repositoryId");
sentContentTypeDefinitionId = extraInformation.get("contentTypeDefinitionId");
sentContentIsProtected = extraInformation.get("contentIsProtected");
}
//System.out.println("sentContentId:" + sentContentId);
//System.out.println("sentParentContentId:" + sentParentContentId);
//System.out.println("sentSiteNodeId:" + sentSiteNodeId);
//System.out.println("sentParentSiteNodeId:" + sentParentSiteNodeId);
//System.out.println("sentRepositoryId:" + sentRepositoryId);
if(object instanceof Map)
{
Map cacheInstance = (Map)e.getValue();
synchronized(cacheInstance)
{
if(cacheName.equals("componentContentsCache"))
{
try
{
if(entity.indexOf("ContentVersion") > 0)
{
String contentId = sentContentId;
String contentTypeDefinitionId = sentContentTypeDefinitionId;
if(contentId == null || contentId.equals(""))
{
try
{
contentId = ""+ContentVersionController.getContentVersionController().getContentIdForContentVersion(new Integer(entityId));
}
catch (Exception e2)
{
logger.info("Error loading content with id " + entityId + ":" + e2.getMessage());
}
}
if(contentId != null)
{
//ContentVO contentVO = ContentController.getContentController().getContentVOWithId(contentId);
if(contentTypeDefinitionId != null && !contentTypeDefinitionId.equals(""))
{
ContentTypeDefinitionVO ctdVO = ContentTypeDefinitionController.getController().getContentTypeDefinitionVOWithId(new Integer(contentTypeDefinitionId));
if(ctdVO.getName().equals("HTMLTemplate") || ctdVO.getName().equals("PagePartTemplate"))
{
ComponentController.getController().reIndexComponentContentsDelayed(new Integer(contentId));
}
}
else
logger.info("No content type for " + contentId);
}
}
else
logger.info("skipping clearing components as it seems stupid");
}
catch (Exception e2)
{
logger.warn("Error clearing componentContentsCache:" + e2.getMessage(), e2);
}
}
else if(!(cacheName.equals("userAccessCache") && cacheInstance.size() < 100))
{
logger.info("clearing ordinary map:" + e.getKey() + " (" + cacheInstance.size() + ")");
cacheInstance.clear();
}
else
logger.info("skipping clearing this as it seems stupid");
}
}
else
{
GeneralCacheAdministrator cacheInstance = (GeneralCacheAdministrator)e.getValue();
synchronized(cacheInstance) //Back
{
//t.printElapsedTime("START:" + entity + ":" + entityId);
//ADD logic to flush correct on sitenode and sitenodeversion
/*
if(selectiveCacheUpdate && entity.indexOf("SiteNode") > 0)
{
cacheInstance.flushAll();
eventListeners.remove(cacheName + "_cacheEntryEventListener");
eventListeners.remove(cacheName + "_cacheMapAccessEventListener");
logger.info("clearing:" + e.getKey());
}
*/
//System.out.println("entity:" + entity);
if(entity.indexOf("pageCache") == 0)
{
if(entity.indexOf("pageCache:") == 0)
{
String groupQualifyer = entity.substring("pageCache:".length());
logger.info("CacheController: This is a application pageCache-clear request... specific:" + groupQualifyer);
logger.info("clearing " + e.getKey() + " : " + groupQualifyer);
PageCacheHelper.getInstance().notify("" + groupQualifyer);
/*
if(cacheName.equals("pageCacheExtra"))
{
clearFileCacheForGroup(cacheInstance, "" + groupQualifyer);
}
else if(cacheName.equals("pageCache"))
{
cacheInstance.flushGroup("" + groupQualifyer);
}
*/
}
else
{
PageCacheHelper.getInstance().notify("selectiveCacheUpdateNonApplicable");
/*
logger.error("clearing " + e.getKey() + " selectiveCacheUpdateNonApplicable");
if(cacheName.equals("pageCacheExtra"))
{
clearFileCacheForGroup(cacheInstance, "selectiveCacheUpdateNonApplicable");
}
else if(cacheName.equals("pageCache"))
{
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
}
*/
}
}
if(selectiveCacheUpdate && entity.indexOf("Repository") > 0 && useSelectivePageCacheUpdate)
{
if(cacheName.equals("pageCacheExtra"))
{
PageCacheHelper.getInstance().notify("repository_" + entityId);
PageCacheHelper.getInstance().notify("selectiveCacheUpdateNonApplicable");
}
else
{
cacheInstance.flushGroup("repository_" + entityId);
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
}
/*
logger.info("clearing " + e.getKey() + " with group " + "repository_" + entityId);
if(cacheName.equals("pageCacheExtra"))
{
clearFileCacheForGroup(cacheInstance, "repository_" + entityId);
clearFileCacheForGroup(cacheInstance, "selectiveCacheUpdateNonApplicable");
}
else
{
cacheInstance.flushGroup("repository_" + entityId);
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
}
*/
}
else if(selectiveCacheUpdate && entity.indexOf("SiteNodeVersion") > 0)
{
//Thread.dumpStack();
//How to solve this good
if(CmsPropertyHandler.getOperatingMode().equalsIgnoreCase("0"))
{
if(cacheName.equals("pageCacheExtra"))
{
PageCacheHelper.getInstance().notify("siteNodeVersion_" + entityId);
PageCacheHelper.getInstance().notify("selectiveCacheUpdateNonApplicable");
//clearFileCacheForGroup(cacheInstance, "siteNodeVersion_" + entityId);
//clearFileCacheForGroup(cacheInstance, "selectiveCacheUpdateNonApplicable");
}
else
{
cacheInstance.flushGroup("siteNodeVersion_" + entityId);
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
}
logger.info("clearing " + e.getKey() + " with group " + "siteNodeVersion_" + entityId);
try
{
logger.info("BeforesiteNodeVersionVO...");
String siteNodeId = sentSiteNodeId;
String repositoryId = sentRepositoryId;
String parentSiteNodeId = sentParentSiteNodeId;
//System.out.println("siteNodeId:" + siteNodeId);
//System.out.println("repositoryId:" + repositoryId);
//System.out.println("parentSiteNodeId:" + parentSiteNodeId);
if(siteNodeId == null || siteNodeId.equals(""))
{
try
{
SiteNodeVersionVO snvVO = SiteNodeVersionController.getController().getSiteNodeVersionVOWithId(new Integer(entityId));
siteNodeId = ""+snvVO.getSiteNodeId();
if(repositoryId == null)
{
SiteNodeVO snVO = SiteNodeController.getController().getSiteNodeVOWithId(snvVO.getSiteNodeId());
repositoryId = ""+snVO.getRepositoryId();
parentSiteNodeId = ""+snVO.getParentSiteNodeId();
}
}
catch (Exception e2)
{
logger.info("Error getting siteNodeVersion " + entityId);
}
}
if(siteNodeId != null)
{
logger.info("Before flushGroup2...");
if(cacheName.equals("pageCacheExtra"))
{
PageCacheHelper.getInstance().notify("siteNode_" + siteNodeId);
//clearFileCacheForGroup(cacheInstance, "siteNode_" + siteNodeId);
}
else
{
cacheInstance.flushGroup("siteNode_" + siteNodeId);
cacheInstance.flushGroup("" + siteNodeId);
}
if(siteNodeId != null && (cacheName.equals("childSiteNodesCache") || cacheName.equals("childPagesCache") || cacheName.equals("siteNodeCache") || cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups")))
{
if(cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups"))
{
cacheInstance.flushGroup("" + repositoryId);
logger.info("Clearing componentPropertyCacheRepoGroups for repo:" + repositoryId);
}
if(parentSiteNodeId != null)
{
cacheInstance.flushGroup("siteNode_" + parentSiteNodeId);
cacheInstance.flushGroup("" + parentSiteNodeId);
cacheInstance.flushEntry("" + parentSiteNodeId);
logger.info("Clearing for:" + parentSiteNodeId);
}
}
logger.info("After flushGroup2...");
}
}
catch(Exception se)
{
logger.warn("Missing siteNode version: " + se.getMessage(), se);
}
}
else
{
try
{
if((cacheName.equals("childSiteNodesCache") || cacheName.equals("childPagesCache") || cacheName.equals("siteNodeCache") || cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups")))
{
SiteNodeVersionVO snvVO = SiteNodeVersionController.getController().getSiteNodeVersionVOWithId(new Integer(entityId));
SiteNodeVO snVO = SiteNodeController.getController().getSiteNodeVOWithId(snvVO.getSiteNodeId());
Integer repositoryId = snVO.getRepositoryId();
Integer parentSiteNodeId = snVO.getParentSiteNodeId();
if(cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups"))
{
cacheInstance.flushGroup("" + repositoryId);
logger.info("Clearing componentPropertyCacheRepoGroups for repo:" + repositoryId);
}
if(parentSiteNodeId != null)
{
cacheInstance.flushGroup("siteNode_" + parentSiteNodeId);
cacheInstance.flushGroup("" + parentSiteNodeId);
cacheInstance.flushEntry("" + parentSiteNodeId);
logger.info("Clearing for:" + parentSiteNodeId);
}
}
}
catch (Exception e2)
{
logger.error("Problem clearing cache for site node version:" + e2.getMessage(), e2);
}
}
}
else if(selectiveCacheUpdate && (entity.indexOf("SiteNode") > 0 && entity.indexOf("SiteNodeTypeDefinition") == -1) && useSelectivePageCacheUpdate)
{
//System.out.println("Entity: " + entity);
logger.info("Flushing " + "" + entityId);
logger.info("Flushing " + "siteNode_" + entityId);
logger.info("Flushing " + "selectiveCacheUpdateNonApplicable");
if(cacheName.equals("pageCacheExtra"))
{
PageCacheHelper.getInstance().notify("siteNode_" + entityId);
PageCacheHelper.getInstance().notify("selectiveCacheUpdateNonApplicable");
//clearFileCacheForGroup(cacheInstance, "siteNode_" + entityId);
//clearFileCacheForGroup(cacheInstance, "selectiveCacheUpdateNonApplicable");
}
else
{
cacheInstance.flushEntry("" + entityId);
cacheInstance.flushGroup("" + entityId);
cacheInstance.flushGroup("siteNode_" + entityId);
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
if(cacheName.equals("childSiteNodesCache") || cacheName.equals("childPagesCache") || cacheName.equals("siteNodeCache") || cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups"))
{
logger.info("Flushing parent also");
String repositoryId = sentRepositoryId;
String parentSiteNodeId = sentParentSiteNodeId;
try
{
if(repositoryId == null)
{
SiteNodeVO snVO = SiteNodeController.getController().getSiteNodeVOWithId(new Integer(entityId));
if(snVO != null)
{
repositoryId = "" + snVO.getRepositoryId();
parentSiteNodeId = "" + snVO.getParentSiteNodeId();
}
}
if(cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups"))
{
cacheInstance.flushGroup("" + repositoryId);
logger.info("Clearing componentPropertyCacheRepoGroups for repo:" + repositoryId);
}
if(parentSiteNodeId != null && !parentSiteNodeId.equals(""))
{
logger.info("Flushing " + "" + entityId);
logger.info("Flushing " + "siteNode_" + entityId);
cacheInstance.flushGroup("siteNode_" + parentSiteNodeId);
cacheInstance.flushGroup("" + parentSiteNodeId);
cacheInstance.flushEntry("" + parentSiteNodeId);
logger.info("Clearing for:" + parentSiteNodeId);
}
}
catch(SystemException se)
{
logger.warn("Missing siteNode: " + se.getMessage(), se);
}
}
}
logger.info("clearing " + e.getKey() + " with group " + "siteNode_" + entityId);
}
else if(selectiveCacheUpdate && entity.indexOf("ContentVersion") > 0 && useSelectivePageCacheUpdate)
{
//t.printElapsedTime("CV start....");
logger.info("ContentVersion entity was sent: " + entity + ":" + entityId + " and cacheName:" + cacheName);
logger.info("Getting eventListeners...");
//Object cacheEntryEventListener = eventListeners.get(e.getKey() + "_cacheEntryEventListener");
//Object cacheMapAccessEventListener = eventListeners.get(e.getKey() + "_cacheMapAccessEventListener");
//System.out.println("entity:" + entity);
//System.out.println("Before flushGroup:" +cacheName);
logger.info("Before flushGroup...");
if(cacheName.equals("pageCacheExtra"))
{
//clearFileCacheForGroup(cacheInstance, "contentVersion_" + entityId);
//clearFileCacheForGroup(cacheInstance, "selectiveCacheUpdateNonApplicable");
}
else if(cacheName.equals("pageCache"))
{
logger.info("Skipping clearing pageCache for version");
//cacheInstance.flushGroup("contentVersion_" + entityId);
//cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
}
else if(cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups"))
{
Timer t2 = new Timer();
try
{
String repositoryId = sentRepositoryId;
if(repositoryId == null)
{
String contentId = sentContentId;
if(contentId == null)
contentId = "" + ContentVersionController.getContentVersionController().getContentIdForContentVersion(new Integer(entityId));
ContentVO contentVO = ContentController.getContentController().getContentVOWithId(new Integer(contentId));
repositoryId = "" + contentVO.getRepositoryId();
}
cacheInstance.flushGroup("" + repositoryId);
//t2.printElapsedTime("3");
if(cacheName.equals("componentPropertyVersionIdCacheRepoGroups"))
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
//t2.printElapsedTime("4");
logger.info("Clearing componentPropertyCacheRepoGroups for repo:" +repositoryId);
}
catch (Exception e2)
{
logger.info("Error loading content with id " + entityId + ":" + e2.getMessage());
}
//t.printElapsedTime("componentPropertyCacheRepoGroups");
}
else if(cacheName.equals("assetUrlCacheWithGroups"))
{
try
{
String contentId = sentContentId;
if(contentId == null || contentId.equals(""))
contentId = ""+ContentVersionController.getContentVersionController().getContentIdForContentVersion(new Integer(entityId));
cacheInstance.flushGroup("content_" + contentId);
logger.info("Clearing assetUrlCacheWithGroups for content:" + "content_" + contentId);
}
catch (Exception e2)
{
logger.warn("Flushing assetUrlCacheWithGroups as it was a missing entity - was probably a delete");
cacheInstance.flushAll();
}
//t.printElapsedTime("assetUrlCacheWithGroups");
}
else if(cacheName.equals("childPagesCache") || cacheName.equals("childSiteNodesCache"))
{
//System.out.println("childPagesCache:" + entity + "=" + entityId);
//t.printElapsedTime("childPagesCache start");
try
{
String contentId = sentContentId;
//System.out.println("sentContentId:" + sentContentId);
if(contentId == null || contentId.equals(""))
contentId = ""+ContentVersionController.getContentVersionController().getContentIdForContentVersion(new Integer(entityId));
//System.out.println("contentId:" + contentId);
//t.printElapsedTime("childPagesCache A");
ContentTypeDefinitionVO metaInfoContentTypeDefinitionVO = ContentTypeDefinitionController.getController().getContentTypeDefinitionVOWithName("Meta info");
//t.printElapsedTime("childPagesCache B");
ContentVO contentVO = ContentController.getContentController().getContentVOWithId(new Integer(contentId));
//t.printElapsedTime("childPagesCache C");
if(metaInfoContentTypeDefinitionVO.getId().equals(contentVO.getContentTypeDefinitionId()))
{
try
{
SiteNodeVO siteNodeVO = SiteNodeController.getController().getSiteNodeVOWithMetaInfoContentId(new Integer(contentId));
//t.printElapsedTime("childPagesCache getSiteNodeVOWithMetaInfoContentId");
if(siteNodeVO != null)
{
cacheInstance.flushGroup("siteNode_" + siteNodeVO.getId());
cacheInstance.flushGroup("siteNode_" + siteNodeVO.getParentSiteNodeId());
}
}
catch (Exception e2)
{
logger.error("Did not find a sitenode with this meta info:" + contentId);
}
cacheInstance.flushGroup("content_" + contentId);
cacheInstance.flushGroup("contentVersion_" + entityId);
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
//t.printElapsedTime("childPagesCache flush done...");
logger.info("Clearing childPagesCache for content:" + "content_" + contentId);
}
}
catch (Exception e2)
{
logger.warn("Flushing childPagesCache as it was a missing entity - was probably a delete");
cacheInstance.flushAll();
}
//t.printElapsedTime("childPagesCache");
}
else if(cacheName.equals("matchingContentsCache"))
{
try
{
String contentId = sentContentId;
if(contentId == null || contentId.equals(""))
contentId = ""+ContentVersionController.getContentVersionController().getContentIdForContentVersion(new Integer(entityId));
try
{
ContentVO contentVO = ContentController.getContentController().getContentVOWithId(new Integer(contentId));
String contentTypeDefinitionId = "" + contentVO.getContentTypeDefinitionId();
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentTypeDefinitionId);
cacheInstance.putInCache("recacheMark_" + contentTypeDefinitionId, "" + System.currentTimeMillis());
cacheInstance.putInCache("recacheMark", "" + System.currentTimeMillis());
}
catch (Exception e2)
{
logger.warn("Flushing all as it was a missing entity - was probably a delete:" + e2.getMessage());
cacheInstance.flushAll();
}
cacheInstance.flushGroup("content_" + contentId);
logger.info("Clearing assetUrlCacheWithGroups for content:" + "content_" + contentId);
}
catch (Exception e2)
{
logger.warn("Flushing all as it was a missing entity - was probably a delete:" + e2.getMessage());
cacheInstance.flushAll();
}
//t.printElapsedTime("matchingContentsCache");
}
else
{
//t.printElapsedTime("Before");
cacheInstance.flushGroup("contentVersion_" + entityId);
//if(!cacheName.equals("contentCache") && !cacheName.equals("contentVersionCache") && !cacheName.equals("contentAttributeCache") && !cacheName.equals("contentVersionIdCache") && !cacheName.equals("contentCategoryCache") && !cacheName.equals("metaInfoContentAttributeCache"))
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
logger.info("clearing " + e.getKey() + " with selectiveCacheUpdateNonApplicable");
//t.printElapsedTime("clearing " + e.getKey() + " with selectiveCacheUpdateNonApplicable");
}
logger.info("clearing " + e.getKey() + " with group " + "contentVersion_" + entityId);
//String[] changedAttributes = new String[]{"Title","NavigationTitle"};
try
{
//t.printElapsedTime("Cache 3.4");
logger.info("Before contentVersionVO...");
//System.out.println("cacheName:" + cacheName);
//System.out.println("entity:" + entity);
//System.out.println("entityId:" + entityId);
String contentIdString = sentContentId;
String contentTypeDefinitionId = sentContentTypeDefinitionId;
String contentIsProtected = sentContentIsProtected;
if(contentIdString == null || contentIdString.equals(""))
{
try
{
contentIdString = "" + ContentVersionController.getContentVersionController().getContentIdForContentVersion(new Integer(entityId));
}
catch (Exception e2)
{
logger.info("Error loading content with id " + entityId + ":" + e2.getMessage());
}
}
Integer contentId = null;
if(contentIdString != null)
contentId = new Integer(contentIdString);
if(contentTypeDefinitionId == null && contentIsProtected == null && contentId != null)
{
ContentVO contentVO = ContentController.getContentController().getContentVOWithId(new Integer(contentId));
contentTypeDefinitionId = ""+contentVO.getContentTypeDefinitionId();
contentIsProtected = ""+contentVO.getIsProtected().intValue();
}
//t.printElapsedTime("Cache 3.5");
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Cache 3.5", t.getElapsedTime());
if(contentId != null)
{
List<String> changes = Collections.EMPTY_LIST;
//System.out.println("extraInformation:" + extraInformation);
String changedAttributes = extraInformation == null ? null : extraInformation.get("changedAttributeNames");
if(changedAttributes != null && changedAttributes.length() > 0)
changes = new ArrayList<String>(Arrays.asList(StringUtils.split(changedAttributes, ",")));
//ContentVO contentVO = ContentController.getContentController().getContentVOWithId(new Integer(contentId));
logger.info("Before flushGroup2...");
if(cacheName.equals("pageCacheExtra"))
{
if(contentIsProtected.equals(""+ContentVO.YES.intValue()))
{
List<InterceptionPointVO> interceptionPointVOList = InterceptionPointController.getController().getInterceptionPointVOList("Content");
for(InterceptionPointVO interceptionPointVO : interceptionPointVOList)
{
if(interceptionPointVO.getName().endsWith(".Read"))
{
String acKey = "" + interceptionPointVO.getId() + "_" + entityId;
CacheController.clearUserAccessCache(acKey);
}
}
}
PageCacheHelper.getInstance().notify("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentTypeDefinitionId);
PageCacheHelper.getInstance().notify("content_" + contentId);
//clearFileCacheForGroup(cacheInstance, "selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentVO.getContentTypeDefinitionId());
if((changes == null || changes.size() == 0) && CmsPropertyHandler.getOperatingMode().equals("3"))
{
ContentVersionVO oldContentVersionVO = ContentVersionController.getContentVersionController().getContentVersionVOWithId(new Integer(entityId));
ContentVersionVO newContentVersionVO = ContentVersionController.getContentVersionController().getLatestActiveContentVersionVO(contentId, oldContentVersionVO.getLanguageId(), new Integer(CmsPropertyHandler.getOperatingMode()));
if(newContentVersionVO != null && oldContentVersionVO != null && newContentVersionVO.getId().equals(oldContentVersionVO.getId()))
{
oldContentVersionVO = null;
//System.out.println("SHIT - same version allready - must find other");
List<SmallestContentVersionVO> contentVersionVOList = ContentVersionController.getContentVersionController().getSmallestContentVersionVOList(new Integer(contentId));
for(SmallestContentVersionVO cvVO : contentVersionVOList)
{
if(!cvVO.getId().equals(newContentVersionVO.getId()) && cvVO.getStateId().equals(new Integer(CmsPropertyHandler.getOperatingMode())) && cvVO.getLanguageId().equals(newContentVersionVO.getLanguageId()) && cvVO.getIsActive() && (oldContentVersionVO == null || oldContentVersionVO.getId() < cvVO.getId()))
{
oldContentVersionVO = ContentVersionController.getContentVersionController().getContentVersionVOWithId(cvVO.getId());
}
}
}
//System.out.println("Now we should have current and previous version:" + newContentVersionVO + " / " + oldContentVersionVO);
if(newContentVersionVO != null && oldContentVersionVO != null)
changes = ContentVersionController.getContentVersionController().getChangedAttributeNames(newContentVersionVO, oldContentVersionVO);
}
//System.out.println("changes:" + changes);
for(String changedAttributeName : changes)
{
if(changedAttributeName.indexOf("ComponentStructure") > -1)
{
//Map allreadyFlushedEntries....
Set<String> groupEntries = (Set<String>)cacheInstance.getCache().cacheMap.getGroup("content_" + contentId + "_ComponentStructureDependency");
//System.out.println("groupEntries:" + groupEntries);
if(groupEntries != null)
{
System.out.println("groupEntries:" + groupEntries.size());
outer:for(String key : groupEntries)
{
//System.out.println("key 1:" + key);
try
{
//String[] usedEntities = (String[])cacheInstance.getFromCache(key + "_entities");
byte[] usedEntitiesByteArray = (byte[])cacheInstance.getFromCache(key + "_entitiesAsByte");
String usedEntitiesString = compressionHelper.decompress(usedEntitiesByteArray);
//t.printElapsedTime("Decompress to " + usedEntitiesString.length() + " took");
String[] usedEntities = StringUtils.split(usedEntitiesString, "|");
//t.printElapsedTime("Split to usedEntities " + usedEntities.length + " took");
ContentVersionVO newContentVersionVO = ContentVersionController.getContentVersionController().getContentVersionVOWithId(new Integer(entityId));
String newComponentStructure = ContentVersionController.getContentVersionController().getAttributeValue(newContentVersionVO, "ComponentStructure", false);
for(String usedEntity : usedEntities)
{
//System.out.println("usedEntity:" + usedEntity);
if(usedEntity.startsWith("content_" + contentId + "_ComponentStructure("))
{
//System.out.println("Match - now lets parse: " + usedEntity);
String arguments = usedEntity.substring(usedEntity.indexOf("(") + 1, usedEntity.indexOf(")"));
Integer oldComponentPropertyHash = new Integer(usedEntity.substring(usedEntity.indexOf("=") + 1));
String[] args = arguments.split(",");
Integer componentId = new Integer(args[0]);
String propertyName = args[1];
Integer siteNodeId = new Integer(args[2]);
Integer languageId = new Integer(args[3]);
//System.out.println("componentId:" + componentId);
//System.out.println("propertyName:" + propertyName);
//System.out.println("siteNodeId:" + siteNodeId);
//System.out.println("languageId:" + languageId);
int newComponentPropertyHash = getPropertyAsStringHashCode(newComponentStructure, componentId, propertyName, siteNodeId, languageId);
//System.out.println("oldComponentPropertyHash:" + oldComponentPropertyHash);
//System.out.println("newComponentPropertyHash:" + newComponentPropertyHash);
if(oldComponentPropertyHash.intValue() != newComponentPropertyHash)
{
//System.out.println("Yes - clearing - must have changed something important:" + usedEntity);
PageCacheHelper.getInstance().notify(usedEntity);
//clearFileCacheForGroup(cacheInstance, usedEntity);
}
else
{
//System.out.println("Flushing content_" + currentPageMetaInfoContentId + "_ComponentStructure just to catch page itself");
//cacheInstance.flushGroup("content_" + currentPageMetaInfoContentId + "_ComponentStructure");
//System.out.println("Flushing content_" + contentId + "_ComponentStructure just to catch page itself");
//cacheInstance.flushGroup("content_" + contentId + "_ComponentStructure");
}
}
else if(usedEntity.startsWith("content_" + contentId + "_ComponentStructure:"))
{
//System.out.println("Match - now lets parse component order etc: " + usedEntity);
String xPath = usedEntity.substring(usedEntity.indexOf(":") + 1, usedEntity.lastIndexOf("="));
Integer oldComponentPropertyHash = new Integer(usedEntity.substring(usedEntity.lastIndexOf("=") + 1));
//System.out.println("xPath:" + xPath);
int newComponentPropertyHash = getComponentsAsStringHashCode(newComponentStructure, xPath);
//System.out.println("oldComponentPropertyHash:" + oldComponentPropertyHash);
//System.out.println("newComponentPropertyHash:" + newComponentPropertyHash);
if(oldComponentPropertyHash.intValue() != newComponentPropertyHash)
{
//System.out.println("Yes - clearing - must have changed order or added/subtracted components:" + usedEntity);
PageCacheHelper.getInstance().notify(usedEntity);
//clearFileCacheForGroup(cacheInstance, usedEntity);
}
}
}
}
catch (Exception ex)
{
//logger.error("Got error trying to update cache:" + ex.getMessage());
logger.warn("Got error trying to update cache:" + ex.getMessage(), ex);
//clearFileCacheForGroup(cacheInstance, "content_" + contentId + "_" + changedAttributeName);
//cacheInstance.flushGroup("content_" + contentId + "_" + changedAttributeName);
//logger.warn("Cleared pageCache for " + "content_" + contentId + "_" + changedAttributeName);
break outer;
}
}
}
}
else
{
PageCacheHelper.getInstance().notify("content_" + contentId + "_" + changedAttributeName);
//clearFileCacheForGroup(cacheInstance, "content_" + contentId + "_" + changedAttributeName);
//System.out.println("Cleared for " + "content_" + contentId + "_" + changedAttributeName);
}
}
//t.printElapsedTime("Handled page cache extra");
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Handled page cache extra", t.getElapsedTime());
//clearFileCacheForGroup(cacheInstance, "content_" + contentId);
}
else if(cacheName.equals("pageCache"))
{
//t.printElapsedTime("Page cache start");
RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Page cache start", t.getElapsedTime());
logger.info("Flushing pageCache for content type def");
String contentTypeDefKey = "selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentTypeDefinitionId;
cacheInstance.flushGroup(contentTypeDefKey);
//cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentVO.getContentTypeDefinitionId());
//cacheInstance.flushGroup("content_" + contentVO.getId());
//System.out.println("Flushing:" + getPooledString(1, contentVO.getId()));
cacheInstance.flushGroup(getPooledString(1, new Integer(contentId)));
PageCacheHelper.getInstance().notify("content_" + contentId);
ContentVersionVO oldContentVersionVO = null;
ContentVersionVO newContentVersionVO = null;
String debug = "";
if((changes == null || changes.size() == 0) && CmsPropertyHandler.getOperatingMode().equals("3"))
{
debug += "entityId:" + entityId + "\n";
debug += "contentId:" + contentId + "\n";
oldContentVersionVO = ContentVersionController.getContentVersionController().getContentVersionVOWithId(new Integer(entityId));
debug += "oldContentVersionVO:" + oldContentVersionVO.getId() + ":" + oldContentVersionVO.getLanguageId() + "\n";
debug += "oldContentVersionVO:" + CmsPropertyHandler.getOperatingMode() + "\n";
newContentVersionVO = ContentVersionController.getContentVersionController().getLatestActiveContentVersionVO(contentId, oldContentVersionVO.getLanguageId(), new Integer(CmsPropertyHandler.getOperatingMode()));
debug += "newContentVersionVO:" + newContentVersionVO + "\n";
if(newContentVersionVO != null && oldContentVersionVO != null && newContentVersionVO.getId().equals(oldContentVersionVO.getId()))
{
debug += "newContentVersionVO:" + newContentVersionVO.getId() + "\n";
oldContentVersionVO = null;
debug += "SHIT - same version allready - must find other";
List<SmallestContentVersionVO> contentVersionVOList = ContentVersionController.getContentVersionController().getSmallestContentVersionVOList(new Integer(contentId));
for(SmallestContentVersionVO cvVO : contentVersionVOList)
{
if(!cvVO.getId().equals(newContentVersionVO.getId()) && cvVO.getStateId().equals(new Integer(CmsPropertyHandler.getOperatingMode())) && cvVO.getLanguageId().equals(newContentVersionVO.getLanguageId()) && cvVO.getIsActive() && (oldContentVersionVO == null || oldContentVersionVO.getId() < cvVO.getId()))
{
oldContentVersionVO = ContentVersionController.getContentVersionController().getContentVersionVOWithId(cvVO.getId());
}
}
debug += "oldContentVersionVO:" + (oldContentVersionVO == null ? "null" : oldContentVersionVO.getId()) + "\n";
}
//System.out.println("Now we should have current and previous version:" + newContentVersionVO + " / " + oldContentVersionVO);
if(newContentVersionVO != null && oldContentVersionVO != null)
changes = ContentVersionController.getContentVersionController().getChangedAttributeNames(newContentVersionVO, oldContentVersionVO);
}
//t.printElapsedTime("Changes analyzed");
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Changes analyzed", t.getElapsedTime());
if((changes == null || changes.size() == 0) && CmsPropertyHandler.getOperatingMode().equals("3"))
{
if(oldContentVersionVO == null || newContentVersionVO == null)
{
//Hur kan det bli detta????
logger.warn("Fishy 1: " + oldContentVersionVO + ":" + newContentVersionVO + " in " + CmsPropertyHandler.getContextRootPath());
logger.warn("DEBUG: " + debug);
}
else
{
logger.warn("Fishy 2: No changes found between content versions " + newContentVersionVO.getId() + " and " + oldContentVersionVO.getId() + " in " + CmsPropertyHandler.getContextRootPath());
logger.warn("DEBUG: " + debug);
logger.warn("Fishy: newContentVersionVO: " + newContentVersionVO.getVersionValue());
logger.warn("Fishy: newContentVersionVO: " + oldContentVersionVO.getVersionValue());
}
logger.warn("Just to make sure pages are updated we pretend all attributes changed until we find the bug");
changes = ContentVersionController.getContentVersionController().getAttributeNames(newContentVersionVO);
}
//System.out.println("changes:" + changes);
for(String changedAttributeName : changes)
{
logger.warn("changedAttributeName: " + changedAttributeName);
if(changedAttributeName.indexOf("ComponentStructure") > -1 && cacheName.equals("pageCache"))
{
//Map allreadyFlushedEntries....
//It's something wrong here..
GeneralCacheAdministrator pageCacheExtraInstance = (GeneralCacheAdministrator)caches.get("pageCacheExtra");
String cacheGroupKey = "content_" + contentId + "_ComponentStructureDependency";
//Set<String> groupEntries = (Set<String>)cacheInstance.getCache().cacheMap.getGroup("content_" + contentId + "_ComponentStructureDependency");
Set<String> groupEntries = (Set<String>)cacheInstance.getCache().cacheMap.getGroup(getPooledString(cacheGroupKey.hashCode()));
//System.out.println("groupEntries:" + groupEntries);
if(groupEntries != null)
{
outer:for(String key : groupEntries)
{
logger.info("key 2:" + key);
try
{
//String[] usedEntities = (String[])pageCacheExtraInstance.getFromCache(key + "_entities");
byte[] usedEntitiesByteArray = (byte[])pageCacheExtraInstance.getFromCache(key + "_entitiesAsByte");
String usedEntitiesString = compressionHelper.decompress(usedEntitiesByteArray);
//t.printElapsedTime("Decompress to " + usedEntitiesString.length() + " took");
String[] usedEntities = StringUtils.split(usedEntitiesString, ",");
//t.printElapsedTime("Split to usedEntities " + usedEntities.length + " took");
ContentVersionVO newestContentVersionVO = ContentVersionController.getContentVersionController().getContentVersionVOWithId(new Integer(entityId));
String newComponentStructure = ContentVersionController.getContentVersionController().getAttributeValue(newestContentVersionVO, "ComponentStructure", false);
for(String usedEntity : usedEntities)
{
//System.out.println("usedEntity:" + usedEntity);
if(usedEntity.startsWith("content_" + contentId + "_ComponentStructure("))
{
//System.out.println("Match - now lets parse: " + usedEntity);
String arguments = usedEntity.substring(usedEntity.indexOf("(") + 1, usedEntity.indexOf(")"));
Integer oldComponentPropertyHash = new Integer(usedEntity.substring(usedEntity.indexOf("=") + 1));
String[] args = arguments.split(",");
Integer componentId = new Integer(args[0]);
String propertyName = args[1];
Integer siteNodeId = new Integer(args[2]);
Integer languageId = new Integer(args[3]);
//System.out.println("componentId:" + componentId);
//System.out.println("propertyName:" + propertyName);
//System.out.println("siteNodeId:" + siteNodeId);
//System.out.println("languageId:" + languageId);
int newComponentPropertyHash = getPropertyAsStringHashCode(newComponentStructure, componentId, propertyName, siteNodeId, languageId);
//System.out.println("oldComponentPropertyHash:" + oldComponentPropertyHash);
//System.out.println("newComponentPropertyHash:" + newComponentPropertyHash);
if(oldComponentPropertyHash.intValue() != newComponentPropertyHash)
{
//System.out.println("Yes - clearing - must have changed something important:" + usedEntity);
//cacheInstance.flushGroup(usedEntity);
cacheInstance.flushGroup(getPooledString(usedEntity.hashCode()));
//clearFileCacheForGroup(cacheInstance, usedEntity);
}
else
{
//System.out.println("Flushing content_" + currentPageMetaInfoContentId + "_ComponentStructure just to catch page itself");
//cacheInstance.flushGroup("content_" + currentPageMetaInfoContentId + "_ComponentStructure");
//System.out.println("Flushing content_" + contentId + "_ComponentStructure just to catch page itself");
String componentStructureKey = "content_" + contentId + "_ComponentStructure";
//cacheInstance.flushGroup(componentStructureKey);
cacheInstance.flushGroup(getPooledString(componentStructureKey.hashCode()));
cacheInstance.flushGroup(getPooledString(usedEntity.hashCode()));
}
}
else if(usedEntity.startsWith("content_" + contentId + "_ComponentStructure:"))
{
//System.out.println("Match - now lets parse component order etc: " + usedEntity);
String xPath = usedEntity.substring(usedEntity.indexOf(":") + 1, usedEntity.lastIndexOf("="));
Integer oldComponentPropertyHash = new Integer(usedEntity.substring(usedEntity.lastIndexOf("=") + 1));
//System.out.println("xPath:" + xPath);
int newComponentPropertyHash = getComponentsAsStringHashCode(newComponentStructure, xPath);
//System.out.println("oldComponentPropertyHash:" + oldComponentPropertyHash);
//System.out.println("newComponentPropertyHash:" + newComponentPropertyHash);
if(oldComponentPropertyHash.intValue() != newComponentPropertyHash)
{
//System.out.println("Yes - clearing - must have changed order or added/subtracted components:" + usedEntity);
cacheInstance.flushGroup(getPooledString(usedEntity.hashCode()));
//cacheInstance.flushGroup(usedEntity);
}
}
}
}
catch(Exception ex)
{
//logger.error("Got error trying to update cache:" + ex.getMessage());
logger.warn("Got error trying to update cache:" + ex.getMessage(), ex);
try
{
String attributeKey = "content_" + contentId + "_" + changedAttributeName;
//cacheInstance.flushGroup(attributeKey);
cacheInstance.flushGroup(getPooledString(attributeKey.hashCode()));
logger.warn("Cleared pageCache for " + getPooledString(attributeKey.hashCode()));
}
catch(Exception ex2)
{
logger.error("Got error trying to flushGroup 2:" + ex2.getMessage());
cacheInstance.flushAll();
}
break outer;
}
t.printElapsedTime("Handled group entries");
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Handled group entries", t.getElapsedTime());
}
}
}
else
{
String attributeKey = "content_" + contentId + "_" + changedAttributeName;
//cacheInstance.flushGroup("content_" + contentId + "_" + changedAttributeName);
cacheInstance.flushGroup(getPooledString(attributeKey.hashCode()));
logger.info("Cleared pageCache for " + "content_" + contentId + "_" + changedAttributeName);
}
}
//cacheInstance.flushGroup("content_" + contentId);
}
else
{
String contentTypeDefKey = "selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentTypeDefinitionId;
//cacheInstance.flushGroup(contentTypeDefKey);
cacheInstance.flushGroup(contentTypeDefKey);
//System.out.println("Cleared for " + "content_" + contentId + " on cache " + cacheName);
String contentKey = "content_" + contentId;
cacheInstance.flushGroup(contentKey);
//cacheInstance.flushGroup(contentKey);
}
//t.printElapsedTime("Handled page cache");
//RequestAnalyser.getRequestAnalyser().registerComponentStatistics("Handled page cache", t.getElapsedTime());
logger.info("After flushGroup2...");
}
//}
if (cacheName.equals("contentVersionCache"))
{
new AssetUpdatingThread(entityId).start();
}
}
catch(SystemException se)
{
se.printStackTrace();
logger.info("Missing content version: " + se.getMessage());
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
else if(selectiveCacheUpdate && (entity.indexOf("Content") > 0 && entity.indexOf("ContentTypeDefinition") == -1 && entity.indexOf("ContentCategory") == -1) && useSelectivePageCacheUpdate)
{
logger.info("Content entity was sent: " + entity + ":" + entityId);
//System.out.println("Content entity was called and needs to be fixed:" + entity);
//String[] changedAttributes = new String[]{"Title","NavigationTitle"};
/*
ContentVO contentVO = null;
if(isObjectCachedInCastor(SmallContentImpl.class, new Integer(entityId)))
contentVO = ContentController.getContentController().getContentVOWithId(new Integer(entityId));
*/
String repositoryId = sentRepositoryId;
String contentTypeDefinitionId = sentContentTypeDefinitionId;
String contentIsProtected = sentContentIsProtected;
if(repositoryId == null || contentTypeDefinitionId == null || contentIsProtected == null)
{
//System.out.println("repositoryId:" + repositoryId);
//System.out.println("contentTypeDefinitionId:" + contentTypeDefinitionId);
//System.out.println("contentIsProtected:" + contentIsProtected);
try
{
ContentVO contentVO = ContentController.getContentController().getContentVOWithId(new Integer(entityId));
//t.printElapsedTime("clearCaches cv u1 contentVO", 10);
repositoryId = ""+contentVO.getRepositoryId();
contentTypeDefinitionId = ""+contentVO.getContentTypeDefinitionId();
contentIsProtected = ""+contentVO.getIsProtected();
}
catch (Exception e2)
{
logger.info("Error loading content with id " + entityId + ":" + e2.getMessage());
}
}
if(cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups"))
{
cacheInstance.flushGroup("" + repositoryId);
logger.info("Clearing componentPropertyCacheRepoGroups for repo:" + repositoryId);
}
if(cacheName.equals("pageCacheExtra"))
{
//clearFileCacheForGroup(cacheInstance, "content_" + entityId);
PageCacheHelper.getInstance().notify("content_" + entityId);
try
{
//cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentVO.getContentTypeDefinitionId());
if(contentTypeDefinitionId != null)
{
//clearFileCacheForGroup(cacheInstance, "selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentVO.getContentTypeDefinitionId());
PageCacheHelper.getInstance().notify("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentTypeDefinitionId);
}
}
catch (Exception e2)
{
logger.warn("Could not find content type to clear pages based on: " + e2.getMessage(), e2);
}
}
else if(cacheName.equals("pageCache"))
{
logger.info("Flushing page cache for {" + entityId + "} and {content_" + entityId + "}");
String entityKey = "" + entityId;
String contentEntityKey = "content_" + entityId;
//cacheInstance.flushGroup("" + entityId);
//cacheInstance.flushGroup(contentEntityKey);
cacheInstance.flushGroup(entityKey);
cacheInstance.flushGroup(contentEntityKey);
try
{
if(contentTypeDefinitionId != null)
{
String contentTypeCacheKey = "selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentTypeDefinitionId;
//cacheInstance.flushGroup(contentTypeCacheKey);
cacheInstance.flushGroup(contentTypeCacheKey);
}
}
catch (Exception e2)
{
logger.warn("Could not find content type to clear pages based on: " + e2.getMessage(), e2);
}
}
else
{
cacheInstance.flushGroup("" + entityId);
cacheInstance.flushGroup("content_" + entityId);
logger.info("clearing " + e.getKey() + " with selectiveCacheUpdateNonApplicable");
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
if(contentTypeDefinitionId != null)
{
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentTypeDefinitionId);
}
}
if(contentTypeDefinitionId != null)
{
//System.out.println("****************************************************************");
if(contentIsProtected.equals(""+ContentVO.YES.intValue()))
{
List<InterceptionPointVO> interceptionPointVOList = InterceptionPointController.getController().getInterceptionPointVOList("Content");
for(InterceptionPointVO interceptionPointVO : interceptionPointVOList)
{
if(interceptionPointVO.getName().endsWith(".Read"))
{
String acKey = "" + interceptionPointVO.getId() + "_" + entityId;
//System.out.println("Clearing access rights for:" + acKey);
CacheController.clearUserAccessCache(acKey);
}
}
}
}
//System.out.println("************************END************************************");
logger.info("clearing " + e.getKey() + " with group " + "content_" + entityId);
}
else if(selectiveCacheUpdate && entity.indexOf("DigitalAsset") > -1)
{
logger.info("Asset entity was sent: " + entity + ":" + entityId);
Integer contentId = assetContentIdMapping.get(new Integer(entityId));
if(contentId == null)
{
logger.info("Checking fot cv for asset:" + entityId);
List<SmallestContentVersionVO> contentVersions = DigitalAssetController.getContentVersionVOListConnectedToAssetWithId(new Integer(entityId));
if(contentVersions != null)
{
for(SmallestContentVersionVO contentVersionVO : contentVersions)
{
contentId = contentVersionVO.getContentId();
assetContentIdMapping.put(new Integer(entityId), contentId);
break;
}
}
}
else
logger.info("Using read asset");
//Integer contentId = null;
ContentVO contentVO = null;
try
{
contentVO = ContentController.getContentController().getContentVOWithId(contentId);
if(cacheName.equals("componentPropertyCacheRepoGroups") || cacheName.equals("componentPropertyVersionIdCacheRepoGroups"))
{
cacheInstance.flushGroup("" + contentVO.getRepositoryId());
logger.info("Clearing componentPropertyCacheRepoGroups for repo:" + contentVO.getRepositoryId());
}
}
catch (Exception e2)
{
logger.info("Error loading content with id " + contentId + ":" + e2.getMessage());
}
//ContentVO contentVO = ContentController.getContentController().getContentVOWithId(new Integer(entityId));
if(cacheName.equals("pageCacheExtra"))
{
//clearFileCacheForGroup(cacheInstance, "content_" + entityId);
PageCacheHelper.getInstance().notify("content_" + contentId);
try
{
//cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentVO.getContentTypeDefinitionId());
if(contentVO != null)
{
//clearFileCacheForGroup(cacheInstance, "selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentVO.getContentTypeDefinitionId());
PageCacheHelper.getInstance().notify("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentVO.getContentTypeDefinitionId());
}
}
catch (Exception e2)
{
logger.warn("Could not find content type to clear pages based on: " + e2.getMessage(), e2);
}
}
else if(cacheName.equals("pageCache"))
{
logger.info("Flushing page cache for {" + contentId + "} and {content_" + contentId + "}");
String entityKey = "" + contentId;
String contentEntityKey = "content_" + contentId;
//cacheInstance.flushGroup("" + entityId);
//cacheInstance.flushGroup(contentEntityKey);
cacheInstance.flushGroup(entityKey);
cacheInstance.flushGroup(contentEntityKey);
try
{
if(contentVO != null)
{
String contentTypeCacheKey = "selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentVO.getContentTypeDefinitionId();
//cacheInstance.flushGroup(contentTypeCacheKey);
cacheInstance.flushGroup(contentTypeCacheKey);
}
}
catch (Exception e2)
{
logger.warn("Could not find content type to clear pages based on: " + e2.getMessage(), e2);
}
}
else
{
cacheInstance.flushGroup("" + contentId);
cacheInstance.flushGroup("content_" + contentId);
logger.info("clearing " + e.getKey() + " with selectiveCacheUpdateNonApplicable");
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
}
logger.info("clearing " + e.getKey() + " with group " + "content_" + entityId);
}
else if(selectiveCacheUpdate && entity.indexOf("Publication") > 0 && useSelectivePageCacheUpdate && (operatingMode != null && operatingMode.equalsIgnoreCase("3")) && CmsPropertyHandler.getLivePublicationThreadClass().equalsIgnoreCase("org.infoglue.deliver.util.SelectiveLivePublicationThread"))
{
logger.info("Now we will ease out the publication...");
/*
List publicationDetailVOList = PublicationController.getController().getPublicationDetailVOList(new Integer(entityId));
Iterator publicationDetailVOListIterator = publicationDetailVOList.iterator();
while(publicationDetailVOListIterator.hasNext())
{
PublicationDetailVO publicationDetailVO = (PublicationDetailVO)publicationDetailVOListIterator.next();
logger.info("publicationDetailVO.getEntityClass():" + publicationDetailVO.getEntityClass());
logger.info("publicationDetailVO.getEntityId():" + publicationDetailVO.getEntityId());
if(Class.forName(publicationDetailVO.getEntityClass()).getName().equals(ContentVersion.class.getName()))
{
logger.error("We clear all caches having references to contentVersion: " + publicationDetailVO.getEntityId());
Integer contentId = ContentVersionController.getContentVersionController().getContentIdForContentVersion(publicationDetailVO.getEntityId());
cacheInstance.flushGroup("content_" + contentId);
cacheInstance.flushGroup(CacheController.getPooledString(2, publicationDetailVO.getEntityId().toString()));
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable");
logger.info("clearing " + e.getKey() + " with group " + "content_" + contentId);
logger.info("clearing " + e.getKey() + " with group " + "content_" + contentId);
}
else if(Class.forName(publicationDetailVO.getEntityClass()).getName().equals(SiteNodeVersion.class.getName()))
{
Integer siteNodeId = SiteNodeVersionController.getController().getSiteNodeVersionVOWithId(publicationDetailVO.getEntityId()).getSiteNodeId();
CacheController.clearCaches(publicationDetailVO.getEntityClass(), publicationDetailVO.getEntityId().toString(), null);
}
}
*/
}
else if(entity.equals("org.infoglue.cms.entities.management.impl.simple.AccessRightImpl"))
{
//System.out.println("This was an access right update - do we handle it:" + cacheName);
if(!CmsPropertyHandler.getOperatingMode().equalsIgnoreCase("3"))
{
try
{
AccessRightVO acVO = AccessRightController.getController().getAccessRightVOWithId(new Integer(entityId));
InterceptionPointVO icpVO = InterceptionPointController.getController().getInterceptionPointVOWithId(acVO.getInterceptionPointId());
//System.out.println("icpVO:" + icpVO.getName());
if(icpVO.getName().indexOf("Content.") > -1)
{
//System.out.println("Was a content access... let's clear caches for that content.");
String idAsString = acVO.getParameters();
if(idAsString != null && !idAsString.equals(""))
clearCaches("org.infoglue.cms.entities.content.impl.simple.ContentImpl", idAsString, null, cachesToSkip, forceClear);
}
else if(icpVO.getName().indexOf("ContentVersion.") > -1)
{
//System.out.println("Was a contentversion access... let's clear caches for that content.");
String idAsString = acVO.getParameters();
if(idAsString != null && !idAsString.equals(""))
clearCaches("org.infoglue.cms.entities.content.impl.simple.ContentVersionImpl", idAsString, null, cachesToSkip, forceClear);
}
else if(icpVO.getName().indexOf("SiteNode.") > -1)
{
//System.out.println("Was a sitenode access... let's clear caches for that content.");
String idAsString = acVO.getParameters();
if(idAsString != null && !idAsString.equals(""))
clearCaches("org.infoglue.cms.entities.structure.impl.simple.SiteNodeImpl", idAsString, null, cachesToSkip, forceClear);
}
else if(icpVO.getName().indexOf("SiteNodeVersion.") > -1)
{
//System.out.println("Was a sitenode version access... let's clear caches for that content.");
String idAsString = acVO.getParameters();
if(idAsString != null && !idAsString.equals(""))
clearCaches("org.infoglue.cms.entities.structure.impl.simple.SiteNodeVersionImpl", idAsString, null, cachesToSkip, forceClear);
}
else
{
//System.out.println("****************************");
//System.out.println("* WHAT TO DO WITH IN CACHECONTROLLER: " + icpVO.getName() + " *");
//System.out.println("****************************");
}
}
catch(Exception e2)
{
logger.error("Error handling access right update: " + e2.getMessage(), e2);
}
}
else
logger.info("Skipping it as this is live mode..");
}
else if(selectiveCacheUpdate && (entity.indexOf("ServiceBinding") > 0 || entity.indexOf("Qualifyer") > 0))
{
logger.info("Ignoring this kind of notification... never used anymore:" + cacheName);
}
else if(entity.indexOf("AccessRightImpl") > -1)
{
logger.info("Ignoring handling of entity:" + entity);
}
else if(cacheName.equalsIgnoreCase("matchingContentsCache") && entity.indexOf("MediumContentCategoryImpl") > 0)
{
try
{
String contentId = sentContentId;
//if(contentId == null || contentId.equals(""))
ContentCategoryVO contentCategoryVO = ContentCategoryController.getController().findById(new Integer(entityId));
ContentVersionVO contentVersionVO = ContentVersionController.getContentVersionController().getContentVersionVOWithId(contentCategoryVO.getContentVersionId());
ContentVO contentVO = ContentController.getContentController().getContentVOWithId(contentVersionVO.getContentId());
String contentTypeDefinitionId = "" + contentVO.getContentTypeDefinitionId();
cacheInstance.flushGroup("selectiveCacheUpdateNonApplicable_contentTypeDefinitionId_" + contentTypeDefinitionId);
cacheInstance.putInCache("recacheMark_" + contentTypeDefinitionId, "" + System.currentTimeMillis());
cacheInstance.putInCache("recacheMark", "" + System.currentTimeMillis());
}
catch (Exception e2)
{
cacheInstance.putInCache("recacheAllMark", "" + System.currentTimeMillis());
logger.warn("Flushing all as it was a missing entity - was probably a delete: " + e2.getMessage());
cacheInstance.flushAll();
}
}
else if(entity.indexOf("MediumContentCategoryImpl") > 0)
{
logger.info("Special handling - no handling");
}
else if(cacheName.equalsIgnoreCase("componentEditorVersionIdCache") && entity.indexOf("ContentVersionImpl") > 0)
{
logger.info("Special handling componentEditorVersionIdCache");
String contentId = sentContentId;
if(contentId == null || contentId.equals(""))
contentId = ""+ContentVersionController.getContentVersionController().getContentIdForContentVersion(new Integer(entityId));
cacheInstance.flushGroup("content_" + contentId);
cacheInstance.flushGroup("contentVersion_" + entityId);
}
else if((cacheName.equalsIgnoreCase("componentEditorCache") ||
cacheName.equalsIgnoreCase("componentPropertyCache") ||
cacheName.equalsIgnoreCase("componentPropertyVersionIdCache") ||
cacheName.equalsIgnoreCase("pageComponentsCache"))
&& entity.indexOf("ContentVersionImpl") > 0)
{
try
{
logger.info("Special handling componentEditorVersionIdCache");
String contentId = sentContentId;
if(contentId == null || contentId.equals(""))
contentId = ""+ContentVersionController.getContentVersionController().getContentIdForContentVersion(new Integer(entityId));
ContentVO contentVO = ContentController.getContentController().getContentVOWithId(new Integer(contentId));
if(contentVO != null && contentVO.getContentTypeDefinitionId() != null)
{
ContentTypeDefinitionVO ctdVO = ContentTypeDefinitionController.getController().getContentTypeDefinitionVOWithId(contentVO.getContentTypeDefinitionId());
if(ctdVO.getName().equals("Meta info"))
cacheInstance.flushAll();
else
{
if(cacheName.equalsIgnoreCase("componentEditorCache") && (ctdVO.getName().equals("HTMLTemplate") || ctdVO.getName().equals("PagePartTemplate")))
{
cacheInstance.flushAll(); //CacheController.clearCache("componentEditorCache");
}
else
logger.info("No need to clear page stuff");
}
}
}
catch (Exception e2)
{
if(e2.getCause() instanceof ObjectNotFoundException || (e2.getCause() != null && e2.getCause().getCause() instanceof ObjectNotFoundException))
logger.info("Error clearing caches - object was probably deleted.");
else
logger.warn("Error handling mixed caches: " + e2.getMessage(), e2);
}
}
else
{
if(entity.indexOf("EventImpl") == -1 && entity.indexOf(".Publication") == -1)
{
if(logger.isInfoEnabled())
logger.info("Clearing all on: " + cacheName + ":" + entity);
cacheInstance.flushAll();
if(logger.isInfoEnabled())
logger.info("clearing:" + e.getKey());
}
}
} //BACK
}
long elapsedTime = t.getElapsedTime();
if(elapsedTime > 20)
logger.warn("Clear cache end took " + e.getKey() + ": " + elapsedTime);
logger.info("Cleared cache:" + e.getKey());
if(!selectiveCacheUpdate)
i.remove();
}
else
{
logger.info("Did not clear " + e.getKey());
}
}
//}
if(!useSelectivePageCacheUpdate || entity.indexOf("AccessRight") > -1)
{
logger.info("Clearing all pageCaches");
CacheController.clearFileCaches("pageCache");
}
}
t.printElapsedTime("clearCaches stop", 100);
/*
logger.info("clearCaches stop");
long time = t.getElapsedTime();
if(time > 3000)
logger.warn("clearCaches took long time:" + time);
*/
}
private static void printThreads()
{
ThreadGroup tg = Thread.currentThread().getThreadGroup();
int n = tg.activeCount();
logger.warn("Number of active threads: " + n);
Thread[] threadArray = new Thread[n];
n = tg.enumerate(threadArray, false);
for (int i=0; i<n; i++)
{
String currentThreadId = "" + threadArray[i].getId();
Thread t = threadArray[i];
Map stacks = t.getAllStackTraces();
Iterator stacksIterator = stacks.values().iterator();
while(stacksIterator.hasNext())
{
StackTraceElement[] el = (StackTraceElement[])stacksIterator.next();
String stackString = "";
if (el != null && el.length != 0)
{
for (int j = 0; j < el.length; j++)
{
StackTraceElement frame = el[j];
if (frame == null)
stackString += " null stack frame" + "<br/>";
else
stackString += " null stack frame" + frame.toString() + "<br/>";
}
logger.warn("\n\nThreads:\n\n " + stackString);
}
}
}
}
public static void clearCastorCaches(DefeatCacheParameters dcp) throws Exception
{
if(CmsPropertyHandler.getApplicationName().equals("cms"))
logger.info("Emptying the Castor Caches - why");
long wait = 0;
while(!getForcedCacheEvictionMode() && RequestAnalyser.getRequestAnalyser().getApproximateNumberOfDatabaseQueries() > 0)
//while(!getForcedCacheEvictionMode() && RequestAnalyser.getRequestAnalyser().getNumberOfActiveRequests() > 0)
{
if(wait > 1000)
{
logger.warn("The clearCastorCaches method waited over " + ((wait * 10) / 1000) + " seconds but there seems to be " + RequestAnalyser.getRequestAnalyser().getApproximateNumberOfDatabaseQueries() + " queries blocking all the time. Continuing anyway.");
break;
}
if(wait > 100)
setForcedCacheEvictionMode(true);
Thread.sleep(10);
wait++;
}
Database db = CastorDatabaseService.getDatabase();
//CastorDatabaseService.setBlock(true);
try
{
//db.getCacheManager().expireCache();
Map<Class,List<Object>> entities = dcp.getEntities();
Iterator<Class> keyIterator = entities.keySet().iterator();
while(keyIterator.hasNext())
{
Class clazz = keyIterator.next();
List<Object> ids = entities.get(clazz);
if(ids.size() > 0)
{
clearCache(clazz, ids.toArray(), true, db);
logger.info("Emptied clazz:" + clazz + " with ids:" + ids);
}
else
{
clearCache(db, clazz);
logger.info("Emptied clazz:" + clazz);
}
}
//commitTransaction(db);
logger.info("Emptied the Castor Caches");
}
catch(Exception e)
{
logger.error("Exception when tried empty the Castor Caches");
rollbackTransaction(db);
}
finally
{
db.close();
//CastorDatabaseService.setBlock(false);
}
}
public static void clearCastorCaches() throws Exception
{
if(CmsPropertyHandler.getApplicationName().equals("cms"))
System.out.println("Emptying the Castor Caches... why");
long wait = 0;
while(!getForcedCacheEvictionMode() && RequestAnalyser.getRequestAnalyser().getApproximateNumberOfDatabaseQueries() > 0)
//while(!getForcedCacheEvictionMode() && RequestAnalyser.getRequestAnalyser().getNumberOfActiveRequests() > 0)
{
if(wait > 1000)
{
logger.warn("The clearCastorCaches method waited over " + ((wait * 10) / 1000) + " seconds but there seems to be " + RequestAnalyser.getRequestAnalyser().getApproximateNumberOfDatabaseQueries() + " queries blocking all the time. Continuing anyway.");
break;
}
if(wait > 100)
setForcedCacheEvictionMode(true);
Thread.sleep(10);
wait++;
}
Database db = CastorDatabaseService.getDatabase();
//CastorDatabaseService.setBlock(true);
try
{
//db.getCacheManager().expireCache();
clearCache(db, SmallContentImpl.class);
clearCache(db, SmallishContentImpl.class);
clearCache(db, MediumContentImpl.class);
clearCache(db, ContentImpl.class);
clearCache(db, ContentRelationImpl.class);
clearCache(db, SmallContentVersionImpl.class);
clearCache(db, SmallestContentVersionImpl.class);
clearCache(db, ContentVersionImpl.class);
clearCache(db, DigitalAssetImpl.class);
clearCache(db, SmallDigitalAssetImpl.class);
clearCache(db, MediumDigitalAssetImpl.class);
clearCache(db, SmallAvailableServiceBindingImpl.class);
clearCache(db, AvailableServiceBindingImpl.class);
clearCache(db, ContentTypeDefinitionImpl.class);
clearCache(db, LanguageImpl.class);
clearCache(db, RepositoryImpl.class);
clearCache(db, SmallRepositoryImpl.class);
clearCache(db, RepositoryLanguageImpl.class);
clearCache(db, RoleImpl.class);
clearCache(db, GroupImpl.class);
clearCache(db, SmallRoleImpl.class);
clearCache(db, SmallGroupImpl.class);
clearCache(db, SystemUserRoleImpl.class);
clearCache(db, SystemUserGroupImpl.class);
clearCache(db, ServiceDefinitionImpl.class);
clearCache(db, SiteNodeTypeDefinitionImpl.class);
clearCache(db, SystemUserImpl.class);
clearCache(db, SmallSystemUserImpl.class);
clearCache(db, QualifyerImpl.class);
clearCache(db, ServiceBindingImpl.class);
clearCache(db, SmallSiteNodeImpl.class);
clearCache(db, SiteNodeImpl.class);
clearCache(db, SiteNodeVersionImpl.class);
clearCache(db, SmallSiteNodeVersionImpl.class);
clearCache(db, PublicationImpl.class);
//clearCache(db, PublicationDetailImpl.class); // This class depends on publication
clearCache(db, ActionImpl.class);
clearCache(db, ActionDefinitionImpl.class);
clearCache(db, ActorImpl.class);
clearCache(db, ConsequenceImpl.class);
clearCache(db, ConsequenceDefinitionImpl.class);
clearCache(db, EventImpl.class);
clearCache(db, WorkflowImpl.class);
clearCache(db, WorkflowDefinitionImpl.class);
clearCache(db, CategoryImpl.class);
clearCache(db, ContentCategoryImpl.class);
clearCache(db, RegistryImpl.class);
clearCache(db, RedirectImpl.class);
clearCache(db, InterceptionPointImpl.class);
clearCache(db, InterceptorImpl.class);
clearCache(db, AccessRightImpl.class);
clearCache(db, AccessRightRoleImpl.class);
clearCache(db, AccessRightGroupImpl.class);
clearCache(db, AccessRightUserImpl.class);
clearCache(db, RolePropertiesImpl.class);
clearCache(db, UserPropertiesImpl.class);
clearCache(db, GroupPropertiesImpl.class);
clearCache(db, UserContentTypeDefinitionImpl.class);
clearCache(db, RoleContentTypeDefinitionImpl.class);
clearCache(db, GroupContentTypeDefinitionImpl.class);
clearCache(db, PropertiesCategoryImpl.class);
clearCache(db, ServerNodeImpl.class);
clearCache(db, SubscriptionImpl.class);
clearCache(db, FormEntryImpl.class);
clearCache(db, FormEntryValueImpl.class);
//commitTransaction(db);
logger.info("Emptied the Castor Caches");
}
catch(Exception e)
{
logger.error("Exception when tried empty the Castor Caches");
rollbackTransaction(db);
}
finally
{
db.close();
//CastorDatabaseService.setBlock(false);
}
}
public static void clearCache(Class type, Object[] ids) throws Exception
{
clearCache(type, ids, false);
}
public static void clearCache(Class type, Object[] ids, boolean forceClear) throws Exception
{
Timer t = new Timer();
if(CmsPropertyHandler.getOperatingMode().equals("3"))
{
long wait = 0;
while(!forceClear && !getForcedCacheEvictionMode() && RequestAnalyser.getRequestAnalyser().getApproximateNumberOfDatabaseQueries() > 0)
{
logger.warn("Number of requests: " + RequestAnalyser.getRequestAnalyser().getNumberOfCurrentRequests() + " was more than 0 - lets wait a bit.");
if(wait > 1000)
{
logger.warn("The clearCache method waited over " + ((wait * 10) / 1000) + " seconds but there seems to be " + RequestAnalyser.getRequestAnalyser().getNumberOfCurrentRequests() + " requests blocking all the time. Continuing anyway.");
//printThreads();
break;
}
if(wait > 100)
setForcedCacheEvictionMode(true);
Thread.sleep(10);
wait++;
}
}
Database db = CastorDatabaseService.getDatabase();
try
{
if(type.getName().contains(".SiteNodeVersionImpl") ||
type.getName().contains(".MediumSiteNodeVersionImpl") ||
type.getName().contains(".SiteNodeImpl") ||
type.getName().contains(".LanguageImpl") ||
type.getName().contains(".RepositoryImpl") ||
type.getName().contains(".RepositoryLanguageImpl") ||
type.getName().contains(".DigitalAssetImpl") ||
type.getName().contains(".MediumDigitalAssetImpl") ||
type.getName().contains(".ContentImpl") ||
type.getName().contains(".MediumContentImpl") ||
type.getName().contains(".SmallContentImpl") ||
type.getName().contains(".SmallishContentImpl") ||
type.getName().contains(".ContentVersionImpl") ||
type.getName().contains(".MediumContentVersionImpl") ||
type.getName().contains(".SmallContentVersionImpl") ||
type.getName().contains(".SmallestContentVersionImpl") ||
type.getName().contains(".AccessRightImpl") ||
type.getName().contains(".SmallAccessRightImpl") ||
type.getName().contains(".AccessRightRoleImpl") ||
type.getName().contains(".AccessRightGroupImpl") ||
type.getName().contains(".AccessRightUserImpl") ||
type.getName().contains(".RegistryImpl"))
{
logger.info("Skipping clear of " + type);
}
else
{
logger.info("Clearing " + type);
CacheManager manager = db.getCacheManager();
manager.expireCache(type, ids);
//Class[] types = {type};
//db.expireCache(types, ids);
}
if(type.getName().equalsIgnoreCase(SmallContentImpl.class.getName()) ||
type.getName().equalsIgnoreCase(SmallishContentImpl.class.getName()) ||
type.getName().equalsIgnoreCase(MediumContentImpl.class.getName()) ||
type.getName().equalsIgnoreCase(ContentImpl.class.getName()) ||
type.getName().equalsIgnoreCase(SmallSiteNodeImpl.class.getName()) ||
type.getName().equalsIgnoreCase(PureSiteNodeImpl.class.getName()) ||
type.getName().equalsIgnoreCase(SiteNodeImpl.class.getName()))
{
expireDateTime = null;
publishDateTime = null;
}
}
catch(Exception e)
{
logger.error("Error clearing cache:" + e.getMessage() + " for type:" + type + ":" + ids + ":" + forceClear);
}
finally
{
try
{
db.close();
}
catch (Exception e)
{
logger.error("Error closing database: " + e.getMessage());
}
}
}
public static void clearCache(Class c) throws Exception
{
Database db = CastorDatabaseService.getDatabase();
try
{
clearCache(db, c);
}
catch(Exception e)
{
e.printStackTrace();
}
finally
{
db.close();
}
}
public static void clearCache(Class type, Object[] ids, Database db) throws Exception
{
clearCache(type, ids, false, db);
}
public static void clearCache(Class type, Object[] ids, boolean forceClear, Database db) throws Exception
{
long wait = 0;
while(!forceClear && !getForcedCacheEvictionMode() && RequestAnalyser.getRequestAnalyser().getApproximateNumberOfDatabaseQueries() > 0)
{
if(wait > 1000)
{
logger.warn("The clearCache method waited over " + ((wait * 10) / 1000) + " seconds but there seems to be " + RequestAnalyser.getRequestAnalyser().getNumberOfCurrentRequests() + " requests blocking all the time. Continuing anyway.");
//printThreads();
break;
}
if(wait > 100)
setForcedCacheEvictionMode(true);
Thread.sleep(10);
wait++;
}
if(type.getName().contains(".SiteNodeVersionImpl") ||
type.getName().contains(".MediumSiteNodeVersionImpl") ||
type.getName().contains(".SiteNodeImpl") ||
type.getName().contains(".LanguageImpl") ||
type.getName().contains(".RepositoryImpl") ||
type.getName().contains(".RepositoryLanguageImpl") ||
type.getName().contains(".DigitalAssetImpl") ||
type.getName().contains(".MediumDigitalAssetImpl") ||
type.getName().contains(".ContentImpl") ||
type.getName().contains(".MediumContentImpl") ||
type.getName().contains(".SmallContentImpl") ||
type.getName().contains(".SmallishContentImpl") ||
type.getName().contains(".ContentVersionImpl") ||
type.getName().contains(".MediumContentVersionImpl") ||
type.getName().contains(".SmallContentVersionImpl") ||
type.getName().contains(".SmallestContentVersionImpl") ||
type.getName().contains(".AccessRightImpl") ||
type.getName().contains(".SmallAccessRightImpl") ||
type.getName().contains(".AccessRightRoleImpl") ||
type.getName().contains(".AccessRightGroupImpl") ||
type.getName().contains(".AccessRightUserImpl") ||
type.getName().contains(".RegistryImpl"))
{
logger.info("Skipping clear of " + type);
}
else
{
logger.info("Clearing for real: " + type);
CacheManager manager = db.getCacheManager();
manager.expireCache(type, ids);
//Class[] types = {type};
//db.expireCache(types, ids);
}
if(type.getName().equalsIgnoreCase(SmallContentImpl.class.getName()) ||
type.getName().equalsIgnoreCase(SmallishContentImpl.class.getName()) ||
type.getName().equalsIgnoreCase(MediumContentImpl.class.getName()) ||
type.getName().equalsIgnoreCase(ContentImpl.class.getName()) ||
type.getName().equalsIgnoreCase(SmallSiteNodeImpl.class.getName()) ||
type.getName().equalsIgnoreCase(PureSiteNodeImpl.class.getName()) ||
type.getName().equalsIgnoreCase(SiteNodeImpl.class.getName()))
{
expireDateTime = null;
publishDateTime = null;
}
}
public static void clearCache(Database db, Class c) throws Exception
{
long wait = 0;
while(!getForcedCacheEvictionMode() && RequestAnalyser.getRequestAnalyser().getApproximateNumberOfDatabaseQueries() > 0)
{
if(wait > 1000)
{
logger.warn("The clearCache method waited over " + ((wait * 10) / 1000) + " seconds but there seems to be " + RequestAnalyser.getRequestAnalyser().getNumberOfCurrentRequests() + " requests blocking all the time. Continuing anyway.");
//printThreads();
break;
}
if(wait > 100)
setForcedCacheEvictionMode(true);
Thread.sleep(10);
wait++;
}
if(c.getName().contains(".SiteNodeVersionImpl") ||
c.getName().contains(".MediumSiteNodeVersionImpl") ||
c.getName().contains(".SiteNodeImpl") ||
c.getName().contains(".LanguageImpl") ||
c.getName().contains(".RepositoryImpl") ||
c.getName().contains(".RepositoryLanguageImpl") ||
c.getName().contains(".DigitalAssetImpl") ||
c.getName().contains(".MediumDigitalAssetImpl") ||
c.getName().contains(".ContentImpl") ||
c.getName().contains(".MediumContentImpl") ||
c.getName().contains(".SmallContentImpl") ||
c.getName().contains(".SmallishContentImpl") ||
c.getName().contains(".ContentVersionImpl") ||
c.getName().contains(".MediumContentVersionImpl") ||
c.getName().contains(".SmallContentVersionImpl") ||
c.getName().contains(".SmallestContentVersionImpl") ||
c.getName().contains(".AccessRightImpl") ||
c.getName().contains(".SmallAccessRightImpl") ||
c.getName().contains(".AccessRightRoleImpl") ||
c.getName().contains(".AccessRightGroupImpl") ||
c.getName().contains(".AccessRightUserImpl") ||
c.getName().contains(".RegistryImpl"))
{
logger.info("Skipping " + c.getName() + " as they have no castor cache");
}
else
{
logger.info("Clearing for real: " + c);
Class[] types = {c};
CacheManager manager = db.getCacheManager();
manager.expireCache(types);
//db.expireCache(types, null);
}
if(c.getName().equalsIgnoreCase(SmallContentImpl.class.getName()) ||
c.getName().equalsIgnoreCase(SmallishContentImpl.class.getName()) ||
c.getName().equalsIgnoreCase(MediumContentImpl.class.getName()) ||
c.getName().equalsIgnoreCase(ContentImpl.class.getName()) ||
c.getName().equalsIgnoreCase(SmallSiteNodeImpl.class.getName()) ||
c.getName().equalsIgnoreCase(PureSiteNodeImpl.class.getName()) ||
c.getName().equalsIgnoreCase(SiteNodeImpl.class.getName()))
{
expireDateTime = null;
publishDateTime = null;
}
}
public void run()
{
while(this.continueRunning && expireCacheAutomatically)
{
logger.info("Clearing caches");
try
{
clearCastorCaches();
}
catch(Exception e)
{
logger.error("Error clearing cache in expireCacheAutomatically thread:" + e.getMessage(), e);
}
logger.info("Castor cache cleared");
try
{
clearCaches(null, null, null);
}
catch(Exception e)
{
logger.error("Error clearing other caches in expireCacheAutomatically thread:" + e.getMessage(), e);
}
logger.info("All other caches cleared");
try
{
sleep(cacheExpireInterval);
}
catch (InterruptedException e){}
}
}
public static void cacheCentralCastorCaches() throws Exception
{
Database db = CastorDatabaseService.getDatabase();
DatabaseWrapper dbWrapper = new DatabaseWrapper(db);
try
{
beginTransaction(db);
String siteNodesToRecacheOnPublishing = CmsPropertyHandler.getSiteNodesToRecacheOnPublishing();
String recachePublishingMethod = CmsPropertyHandler.getRecachePublishingMethod();
logger.info("siteNodesToRecacheOnPublishing:" + siteNodesToRecacheOnPublishing);
if(siteNodesToRecacheOnPublishing != null && !siteNodesToRecacheOnPublishing.equals("") && siteNodesToRecacheOnPublishing.indexOf("siteNodesToRecacheOnPublishing") == -1)
{
String[] siteNodeIdArray = siteNodesToRecacheOnPublishing.split(",");
for(int i=0; i<siteNodeIdArray.length; i++)
{
Integer siteNodeId = new Integer(siteNodeIdArray[i]);
logger.info("siteNodeId to recache:" + siteNodeId);
if(recachePublishingMethod != null && recachePublishingMethod.equalsIgnoreCase("contentCentric"))
new ContentCentricCachePopulator().recache(dbWrapper, siteNodeId);
else if(recachePublishingMethod != null && recachePublishingMethod.equalsIgnoreCase("requestCentric"))
new RequestCentricCachePopulator().recache(dbWrapper, siteNodeId);
else if(recachePublishingMethod != null && recachePublishingMethod.equalsIgnoreCase("requestAndMetaInfoCentric"))
new RequestAndMetaInfoCentricCachePopulator().recache(dbWrapper, siteNodeId);
else
logger.warn("No recaching was made during publishing - set the parameter recachePublishingMethod to 'contentCentric' or 'requestCentric' to recache.");
}
}
commitTransaction(db);
}
catch(Exception e)
{
logger.error("An error occurred when we tried to rebuild the castor cache:" + e.getMessage(), e);
rollbackTransaction(db);
}
finally
{
closeDatabase(db);
}
}
public void stopThread()
{
this.continueRunning = false;
}
public boolean getExpireCacheAutomatically()
{
return expireCacheAutomatically;
}
public void setExpireCacheAutomatically(boolean expireCacheAutomatically)
{
this.expireCacheAutomatically = expireCacheAutomatically;
}
public static Map getCaches()
{
return caches;
}
public static void evictWaitingCache() throws Exception
{
Timer t = new Timer();
String operatingMode = CmsPropertyHandler.getOperatingMode();
synchronized(RequestAnalyser.getRequestAnalyser())
{
if(RequestAnalyser.getRequestAnalyser().getBlockRequests() && RequestAnalyser.getRequestAnalyser().getBlockRequestTime() < 30000)
{
logger.warn("evictWaitingCache allready in progress - returning to avoid conflict");
return;
}
else if(RequestAnalyser.getRequestAnalyser().getBlockRequests() && RequestAnalyser.getRequestAnalyser().getBlockRequestTime() > 30000)
logger.warn("An block must have gone wrong... there has gone over 30 seconds and still not reported done.. let's run anyway.");
RequestAnalyser.getRequestAnalyser().setBlockRequests(true);
}
logger.info("evictWaitingCache starting");
logger.info("blocking");
synchronized(notifications)
{
if(notifications == null || notifications.size() == 0)
{
logger.info("No notifications...");
RequestAnalyser.getRequestAnalyser().setBlockRequests(false);
return;
}
}
logger.info("Had some notifications to handle:" + notifications.size());
WorkingPublicationThread wpt = new WorkingPublicationThread();
SelectiveLivePublicationThread pt = null;
String livePublicationThreadClass = "";
try
{
livePublicationThreadClass = CmsPropertyHandler.getLivePublicationThreadClass();
if(operatingMode != null && operatingMode.equalsIgnoreCase("3")) //If published-mode we update entire cache to be sure..
{
if(livePublicationThreadClass.equalsIgnoreCase("org.infoglue.deliver.util.SelectiveLivePublicationThread"))
pt = new SelectiveLivePublicationThread(notifications);
}
}
catch (Exception e)
{
logger.error("Could not get livePublicationThreadClass:" + e.getMessage(), e);
}
List localNotifications = new ArrayList();
boolean startedThread = false;
if(pt == null)
{
logger.info("before notifications:" + notifications.size());
synchronized(notifications)
{
localNotifications.addAll(notifications);
notifications.clear();
}
Iterator i = localNotifications.iterator();
while(i.hasNext())
{
CacheEvictionBean cacheEvictionBean = (CacheEvictionBean)i.next();
String className = cacheEvictionBean.getClassName();
logger.info("className:" + className);
logger.info("pt:" + pt);
//RequestAnalyser.getRequestAnalyser().addPublication("" + formatter.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss") + " - " + cacheEvictionBean.getClassName() + " - " + cacheEvictionBean.getObjectId());
if(pt == null)
wpt.getCacheEvictionBeans().add(cacheEvictionBean);
//else
// pt.getCacheEvictionBeans().add(cacheEvictionBean);
try
{
//Here we do what we need to if the server properties has changed.
if(className != null && className.equalsIgnoreCase("ServerNodeProperties"))
{
try
{
logger.info("clearing InfoGlueAuthenticationFilter");
clearServerNodeProperty(true);
logger.info("cleared InfoGlueAuthenticationFilter");
InfoGlueAuthenticationFilter.initializeProperties();
logger.info("initialized InfoGlueAuthenticationFilter");
logger.info("Shortening page stats");
RequestAnalyser.shortenPageStatistics();
}
catch (Exception e1)
{
logger.warn("Could not refresh authentication filter:" + e1.getMessage(), e1);
}
catch (Throwable throwable)
{
logger.warn("Could not refresh authentication filter:" + throwable.getMessage(), throwable);
}
}
if(operatingMode != null && !operatingMode.equalsIgnoreCase("3") && className != null && className.equalsIgnoreCase("PortletRegistry"))
{
logger.info("clearing portletRegistry");
clearPortlets();
logger.info("cleared portletRegistry");
}
if(operatingMode != null && operatingMode.equalsIgnoreCase("3")) //If published-mode we update entire cache to be sure..
{
if(!livePublicationThreadClass.equalsIgnoreCase("org.infoglue.deliver.util.SelectiveLivePublicationThread"))
{
logger.info("Starting publication thread...");
PublicationThread lpt = new PublicationThread();
lpt.setPriority(Thread.MIN_PRIORITY);
lpt.start();
startedThread = true;
logger.info("Done starting publication thread...");
}
}
}
catch(Exception e)
{
logger.error("Cache eviction reported an error:" + e.getMessage(), e);
}
logger.info("Cache evicted..");
i.remove();
}
}
if(operatingMode != null && !operatingMode.equalsIgnoreCase("3"))
{
logger.info("Starting the work method");
//wpt.setPriority(Thread.MAX_PRIORITY);
//wpt.start();
wpt.work();
startedThread = true;
logger.info("Done starting working publication thread...");
}
if(operatingMode != null && operatingMode.equalsIgnoreCase("3") && pt != null) //If published-mode we update entire cache to be sure..
{
int size = 0;
synchronized(notifications)
{
size = notifications.size();
}
if(size > 0)
{
logger.info("Starting selective publication thread [" + pt.getClass().getName() + "]");
pt.setPriority(Thread.MIN_PRIORITY);
pt.start();
startedThread = true;
logger.info("Done starting publication thread...");
}
}
if(!startedThread)
RequestAnalyser.getRequestAnalyser().setBlockRequests(false);
t.printElapsedTime("evict done");
logger.info("evictWaitingCache stop");
}
public static void clearPortlets()
{
//run registry services to load new portlet info from the registry files
String[] svcs =
{
"org.apache.pluto.portalImpl.services.portletdefinitionregistry.PortletDefinitionRegistryService",
"org.apache.pluto.portalImpl.services.portletentityregistry.PortletEntityRegistryService"
};
int len = svcs.length;
for (int i = 0; i < len; i++)
{
try
{
ServiceManager.hotInit(ServletConfigContainer.getContainer().getServletConfig(), svcs[i]);
}
catch (Throwable e)
{
String svc = svcs[i].substring(svcs[i].lastIndexOf('.') + 1);
String msg = "Initialization of " + svc + " service for hot deployment failed!";
logger.error(msg);
break;
}
try
{
ServiceManager.postHotInit(ServletConfigContainer.getContainer().getServletConfig(), svcs[i]);
}
catch (Throwable e)
{
String svc = svcs[i].substring(svcs[i].lastIndexOf('.') + 1);
String msg = "Post initialization of " + svc + " service for hot deployment failed!";
logger.error(msg);
break;
}
}
try
{
PortletEntityRegistry.load();
}
catch (IOException e)
{
e.printStackTrace();
}
}
public static String[] getPublicationPersistentCacheNames()
{
List<String> caches = new ArrayList<String>();
caches.add("redirectCache");
caches.add("languageCache");
caches.add("childSiteNodesCache");
caches.add("childPagesCache");
caches.add("parentSiteNodeCache");
caches.add("contentTypeDefinitionCache");
caches.add("componentContentsCache");
caches.add("contentVersionIdCache");
caches.add("rootSiteNodeCache");
caches.add("contentCache");
caches.add("relatedCategoriesCache");
caches.add("matchingContentsCache");
caches.add("propertiesCategoryCache");
caches.add("userCache");
caches.add("siteNodeCache");
caches.add("contentCategoryCache");
caches.add("contentVersionCache");
caches.add("digitalAssetCache");
caches.add("latestSiteNodeVersionCache");
caches.add("interceptionPointCache");
caches.add("contentAttributeCache");
caches.add("metaInfoContentAttributeCache");
caches.add("ServerNodeProperties");
caches.add("serverNodePropertiesCache");
caches.add("pageCache");
caches.add("pageCacheExtra");
caches.add("componentCache");
caches.add("NavigationCache");
caches.add("pagePathCache");
caches.add("userCache");
caches.add("pageCacheParentSiteNodeCache");
caches.add("pageCacheLatestSiteNodeVersions");
caches.add("pageCacheSiteNodeTypeDefinition");
caches.add("JNDIAuthorizationCache");
caches.add("WebServiceAuthorizationCache");
caches.add("importTagResultCache");
caches.add("assetUrlCacheWithGroups");
caches.add("componentPropertyCacheRepoGroups");
caches.add("pageDeliveryMetaDataCache");
List<String> userCaches = CmsPropertyHandler.getExtraPublicationPersistentCacheNames();
logger.info("Adding ExtraPublicationPersistentCacheNames:" + userCaches);
caches.addAll(userCaches);
String[] cachesArr = caches.toArray(new String[caches.size()]);
return cachesArr;
}
/**
* Composer of the pageCacheKey.
*
* @param siteNodeId
* @param languageId
* @param contentId
* @param userAgent
* @param queryString
* @return
*/
public static String getPageCacheKey(HttpSession session, HttpServletRequest request, Integer siteNodeId, Integer languageId, Integer contentId, String userAgent, String queryString, String extra)
{
String originalRequestURL = request.getParameter("originalRequestURL");
if(originalRequestURL == null || originalRequestURL.length() == 0)
originalRequestURL = request.getRequestURL().toString();
String pageKey = null;
String pageKeyProperty = CmsPropertyHandler.getPageKey();
if(pageKeyProperty != null && pageKeyProperty.length() > 0)
{
pageKey = pageKeyProperty;
pageKey = pageKey.replaceAll("\\$siteNodeId", "" + siteNodeId);
pageKey = pageKey.replaceAll("\\$languageId", "" + languageId);
pageKey = pageKey.replaceAll("\\$contentId", "" + contentId);
pageKey = pageKey.replaceAll("\\$useragent", "" + userAgent);
pageKey = pageKey.replaceAll("\\$queryString", "" + queryString);
if(logger.isInfoEnabled())
logger.info("Raw pageKey:" + pageKey);
int sessionAttributeStartIndex = pageKey.indexOf("$session.");
while(sessionAttributeStartIndex > -1)
{
int sessionAttributeEndIndex = pageKey.indexOf("_", sessionAttributeStartIndex);
String sessionAttribute = null;
if(sessionAttributeEndIndex > -1)
sessionAttribute = pageKey.substring(sessionAttributeStartIndex + 9, sessionAttributeEndIndex);
else
sessionAttribute = pageKey.substring(sessionAttributeStartIndex + 9);
Object sessionAttributeValue = session.getAttribute(sessionAttribute);
if(sessionAttributeValue == null && sessionAttribute.equalsIgnoreCase("principal"))
sessionAttributeValue = session.getAttribute("infogluePrincipal");
if(logger.isInfoEnabled())
logger.info("sessionAttribute:" + sessionAttribute);
pageKey = pageKey.replaceAll("_\\$session." + sessionAttribute, "" + (sessionAttributeValue == null ? "" : "_" + sessionAttributeValue));
sessionAttributeStartIndex = pageKey.indexOf("$session.");
}
if(logger.isInfoEnabled())
logger.info("after session pageKey:" + pageKey);
int cookieAttributeStartIndex = pageKey.indexOf("$cookie.");
while(cookieAttributeStartIndex > -1)
{
int cookieAttributeEndIndex = pageKey.indexOf("_", cookieAttributeStartIndex);
String cookieAttribute = null;
if(cookieAttributeEndIndex > -1)
cookieAttribute = pageKey.substring(cookieAttributeStartIndex + 8, cookieAttributeEndIndex);
else
cookieAttribute = pageKey.substring(cookieAttributeStartIndex + 8);
HttpHelper httpHelper = new HttpHelper();
pageKey = pageKey.replaceAll("\\$cookie." + cookieAttribute, "" + httpHelper.getCookie(request, cookieAttribute));
cookieAttributeStartIndex = pageKey.indexOf("$cookie.");
}
}
else
pageKey = "" + siteNodeId + "_" + languageId + "_" + contentId + "_" + userAgent + "_" + queryString;
return originalRequestURL + "_" + pageKey + extra;
}
/**
* Composer of the componentCacheKey.
*
* @param siteNodeId
* @param languageId
* @param contentId
* @param userAgent
* @param queryString
* @return
*/
public static String getComponentCacheKey(String keyPattern, String pageKey, HttpSession session, HttpServletRequest request, Integer siteNodeId, Integer languageId, Integer contentId, String userAgent, String queryString, InfoGlueComponent component, String extra)
{
String originalRequestURL = request.getParameter("originalRequestURL");
if(originalRequestURL == null || originalRequestURL.length() == 0)
originalRequestURL = request.getRequestURL().toString();
String componentKey = null;
if(keyPattern != null && keyPattern.length() > 0)
{
componentKey = keyPattern;
componentKey = componentKey.replaceAll("\\$siteNodeId", "" + siteNodeId);
componentKey = componentKey.replaceAll("\\$languageId", "" + languageId);
componentKey = componentKey.replaceAll("\\$contentId", "" + contentId);
componentKey = componentKey.replaceAll("\\$useragent", "" + userAgent);
componentKey = componentKey.replaceAll("\\$queryString", "" + queryString);
componentKey = componentKey.replaceAll("\\$pageKey", "" + pageKey);
componentKey = componentKey.replaceAll("\\$component.id", "" + component.getId());
componentKey = componentKey.replaceAll("\\$component.slotName", "" + component.getSlotName());
componentKey = componentKey.replaceAll("\\$component.contentId", "" + component.getContentId());
componentKey = componentKey.replaceAll("\\$component.isInherited", "" + component.getIsInherited());
int sessionAttributeStartIndex = componentKey.indexOf("$session.");
while(sessionAttributeStartIndex > -1)
{
int sessionAttributeEndIndex = componentKey.indexOf("_", sessionAttributeStartIndex);
String sessionAttribute = null;
if(sessionAttributeEndIndex > -1)
sessionAttribute = componentKey.substring(sessionAttributeStartIndex + 9, sessionAttributeEndIndex);
else
sessionAttribute = componentKey.substring(sessionAttributeStartIndex + 9);
Object sessionAttributeValue = session.getAttribute(sessionAttribute);
if(sessionAttributeValue == null && sessionAttribute.equalsIgnoreCase("principal"))
sessionAttributeValue = session.getAttribute("infogluePrincipal");
componentKey = componentKey.replaceAll("\\$session." + sessionAttribute, "" + sessionAttributeValue);
sessionAttributeStartIndex = componentKey.indexOf("$session.");
}
int cookieAttributeStartIndex = componentKey.indexOf("$cookie.");
while(cookieAttributeStartIndex > -1)
{
int cookieAttributeEndIndex = componentKey.indexOf("_", cookieAttributeStartIndex);
String cookieAttribute = null;
if(cookieAttributeEndIndex > -1)
cookieAttribute = componentKey.substring(cookieAttributeStartIndex + 8, cookieAttributeEndIndex);
else
cookieAttribute = componentKey.substring(cookieAttributeStartIndex + 8);
HttpHelper httpHelper = new HttpHelper();
componentKey = componentKey.replaceAll("\\$cookie." + cookieAttribute, "" + httpHelper.getCookie(request, cookieAttribute));
cookieAttributeStartIndex = componentKey.indexOf("$cookie.");
}
}
return componentKey;
}
private static String getCachedContentFromFile(String cacheName, String key, String charEncoding)
{
return getCachedContentFromFile(cacheName, key, null, charEncoding);
}
private static String getCachedContentFromFile(String cacheName, String key, Integer updateInterval, String charEncoding)
{
Timer t = new Timer();
if(!logger.isInfoEnabled())
t.setActive(false);
String compressPageCache = CmsPropertyHandler.getCompressPageCache();
String contents = null;
try
{
String firstPart = ("" + key.hashCode()).substring(0, 3);
String filePath = CmsPropertyHandler.getDigitalAssetPath() + File.separator + "caches" + File.separator + cacheName + File.separator + firstPart + File.separator + key.hashCode();
File file = new File(filePath);
if(file.exists())
{
//logger.info("updateInterval:" + updateInterval);
if(updateInterval != null)
{
long updateDateTime = file.lastModified();
long now = System.currentTimeMillis();
//logger.info("diff:" + (now - updateDateTime) / 1000);
if((now - updateDateTime) / 1000 < updateInterval)
{
if(cacheName.equals("pageCache") && compressPageCache != null && compressPageCache.equals("true"))
{
byte[] cachedCompressedData = FileHelper.getFileBytes(file);
if(cachedCompressedData != null && cachedCompressedData.length > 0)
contents = compressionHelper.decompress(cachedCompressedData);
}
else
{
//logger.info("getting file anyway:" + updateInterval);
contents = FileHelper.getFileAsStringOpt(file, charEncoding);
}
//contents = FileHelper.getFileAsString(file, charEncoding);
}
else
{
//logger.info("Old file - skipping:" + ((now - updateDateTime) / 1000));
if(logger.isInfoEnabled())
logger.info("Old file - skipping:" + ((now - updateDateTime) / 1000));
}
}
else
{
//logger.info("getting file:" + file);
if(cacheName.equals("pageCache") && compressPageCache != null && compressPageCache.equals("true"))
{
byte[] cachedCompressedData = FileHelper.getFileBytes(file);
if(cachedCompressedData != null && cachedCompressedData.length > 0)
contents = compressionHelper.decompress(cachedCompressedData);
}
else
{
//logger.info("getting file anyway:" + updateInterval);
contents = FileHelper.getFileAsStringOpt(file, charEncoding);
}
//contents = FileHelper.getFileAsString(file, charEncoding);
}
}
else
{
if(logger.isInfoEnabled())
logger.info("No filecache existed:" + filePath);
}
}
catch (Exception e)
{
logger.warn("Problem loading data from file:" + e.getMessage());
}
return contents;
}
private static void putCachedContentInFile(String cacheName, String key, String value, String fileCacheCharEncoding)
{
try
{
String firstPart = ("" + key.hashCode()).substring(0, 3);
String dir = CmsPropertyHandler.getDigitalAssetPath() + File.separator + "caches" + File.separator + cacheName + File.separator + firstPart;
File dirFile = new File(dir);
dirFile.mkdirs();
File file = new File(dir + File.separator + key.hashCode());
File tmpOutputFile = new File(dir + File.separator + Thread.currentThread().getId() + "_tmp_" + key.hashCode());
FileHelper.write(tmpOutputFile, value, false, fileCacheCharEncoding);
if(logger.isInfoEnabled())
logger.info("Wrote file..");
if(tmpOutputFile.exists())
{
if(tmpOutputFile.length() == 0)
{
tmpOutputFile.delete();
}
else
{
if(logger.isInfoEnabled())
logger.info("Renaming file " + tmpOutputFile.getAbsolutePath() + " to " + file.getAbsolutePath());
if(logger.isInfoEnabled())
logger.info("file:" + file.exists() + ":" + file.length());
if(file.exists())
file.delete();
boolean renamed = tmpOutputFile.renameTo(file);
if(logger.isInfoEnabled())
logger.info("renamed:" + renamed);
if(cacheName.equals("pageCache"))
numberOfPageCacheFiles.incrementAndGet();
}
}
}
catch (Exception e)
{
logger.warn("Problem storing data to file:" + e.getMessage());
}
}
private static void putCachedCompressedContentInFile(String cacheName, String key, byte[] value)
{
try
{
String firstPart = ("" + key.hashCode()).substring(0, 3);
String dir = CmsPropertyHandler.getDigitalAssetPath() + File.separator + "caches" + File.separator + cacheName + File.separator + firstPart;
File dirFile = new File(dir);
dirFile.mkdirs();
File file = new File(dir + File.separator + key.hashCode());
File tmpOutputFile = new File(dir + File.separator + Thread.currentThread().getId() + "_tmp_" + key.hashCode());
FileHelper.writeToFile(tmpOutputFile, value);
if(logger.isInfoEnabled())
logger.info("Wrote file..");
if(tmpOutputFile.exists())
{
if(tmpOutputFile.length() == 0)
{
tmpOutputFile.delete();
}
else
{
if(logger.isInfoEnabled())
logger.info("Renaming file " + tmpOutputFile.getAbsolutePath() + " to " + file.getAbsolutePath());
if(logger.isInfoEnabled())
logger.info("file:" + file.exists() + ":" + file.length());
if(file.exists())
file.delete();
boolean renamed = tmpOutputFile.renameTo(file);
if(logger.isInfoEnabled())
logger.info("renamed:" + renamed);
if(cacheName.equals("pageCache"))
numberOfPageCacheFiles.incrementAndGet();
}
}
}
catch (Exception e)
{
logger.warn("Problem storing data to file:" + e.getMessage());
}
}
public static void clearPageCache(String key)
{
clearCache("pageCache", key);
/*
try
{
String firstPart = ("" + key.hashCode()).substring(0, 3);
String dir = CmsPropertyHandler.getDigitalAssetPath() + File.separator + "caches" + File.separator + "pageCache" + File.separator + firstPart;
File dirFile = new File(dir);
dirFile.mkdirs();
File file = new File(dir + File.separator + key.hashCode());
if(logger.isInfoEnabled())
logger.info("Deleting " + file.getPath() + ":" + file.exists());
if(file.exists())
{
boolean deleted = file.delete();
if(logger.isInfoEnabled())
logger.info("Deleted: " + deleted);
}
}
catch (Exception e)
{
logger.warn("Problem storing data to file:" + e.getMessage());
}
*/
}
private static void removeCachedContentInFile(String cacheName, String key)
{
try
{
String firstPart = ("" + key).substring(0, 3);
String dir = CmsPropertyHandler.getDigitalAssetPath() + File.separator + "caches" + File.separator + cacheName + File.separator + firstPart;
File dirFile = new File(dir);
dirFile.mkdirs();
File file = new File(dir + File.separator + key);
logger.info("Deleting " + file.getPath());
file.delete();
}
catch (Exception e)
{
logger.warn("Problem storing data to file:" + e.getMessage());
}
}
public static void clearFileCaches()
{
String dir = CmsPropertyHandler.getDigitalAssetPath() + File.separator + "caches";
File dirFile = new File(dir);
File dirOldFile = new File(dir+"CAN_BE_REMOVED");
if(dirFile.exists())
dirFile.renameTo(dirOldFile);
new Thread(new Runnable() { public void run() {try {CacheController.clearFileCachesImpl(new File(CmsPropertyHandler.getDigitalAssetPath() + File.separator + "caches_CAN_BE_REMOVED"));} catch (Exception e) {}}}).start();
}
public static void clearFileCachesImpl(File dirFile)
{
//System.out.println("dirFile:" + dirFile.exists());
if(dirFile.exists())
{
File[] subCaches = dirFile.listFiles();
for(int i=0; i<subCaches.length; i++)
{
File subCacheDir = subCaches[i];
//System.out.println("subCacheDir:" + subCacheDir.getName());
if(subCacheDir.isDirectory())
{
File[] subSubCacheFiles = subCacheDir.listFiles();
for(int j=0; j<subSubCacheFiles.length; j++)
{
File subSubCacheDir = subSubCacheFiles[j];
if(subSubCacheDir.isDirectory())
{
File[] cacheFiles = subSubCacheDir.listFiles();
for(int k=0; k<cacheFiles.length; k++)
{
File cacheFile = cacheFiles[k];
//System.out.println("cacheFile:" + cacheFile.getName());
cacheFile.delete();
}
subCacheDir.delete();
}
//System.out.println("cacheFile:" + cacheFile.getName());
subSubCacheDir.delete();
}
subCacheDir.delete();
}
}
}
}
public static void clearFileCaches(String cacheName)
{
CacheController.clearFileCachesImpl(cacheName);
//new Thread(new Runnable() { public void run() {try {CacheController.clearFileCachesImpl(cacheName);} catch (Exception e) {}}}).start();
}
public static void clearFileCachesImpl(String cacheName)
{
String dir = CmsPropertyHandler.getDigitalAssetPath() + File.separator + "caches";
File dirFile = new File(dir);
//System.out.println("dirFile:" + dirFile.exists());
if(dirFile.exists())
{
File[] subCaches = dirFile.listFiles();
for(int i=0; i<subCaches.length; i++)
{
File subCacheDir = subCaches[i];
//System.out.println("subCacheDir:" + subCacheDir.getName());
if(subCacheDir.isDirectory() && subCacheDir.getName().equals(cacheName) || (cacheName.equals("pageCache") && subCacheDir.getName().startsWith(cacheName)))
{
try
{
File[] subSubCacheFiles = subCacheDir.listFiles();
for(int j=0; j<subSubCacheFiles.length; j++)
{
File subSubCacheDir = subSubCacheFiles[j];
if(subSubCacheDir.isDirectory())
{
File[] cacheFiles = subSubCacheDir.listFiles();
if(cacheFiles != null)
{
for(int k=0; k<cacheFiles.length; k++)
{
File cacheFile = cacheFiles[k];
//System.out.println("cacheFile:" + cacheFile.getName());
cacheFile.delete();
}
}
subCacheDir.delete();
}
//System.out.println("cacheFile:" + cacheFile.getName());
subSubCacheDir.delete();
}
subCacheDir.delete();
}
catch (Exception e)
{
logger.warn("It seems the cache dir: " + cacheName + " was allready empty or removed. Error: " + e.getMessage());
}
}
}
}
}
/**
* Rollbacks a transaction on the named database
*/
/*
public static void closeTransaction(Database db) throws SystemException
{
//if(db != null && !db.isClosed() && db.isActive())
commitTransaction(db);
}
*/
/**
* Begins a transaction on the named database
*/
public static void beginTransaction(Database db) throws SystemException
{
try
{
db.begin();
}
catch(Exception e)
{
logger.error("An error occurred when we tried to begin an transaction. Reason:" + e.getMessage());
throw new SystemException("An error occurred when we tried to begin an transaction. Reason:" + e.getMessage(), e);
}
}
/**
* Ends a transaction on the named database
*/
static void commitTransaction(Database db) throws SystemException
{
try
{
if (db.isActive())
{
db.commit();
}
}
catch(Exception e)
{
logger.error("An error occurred when we tried to commit an transaction. Reason:" + e.getMessage());
throw new SystemException("An error occurred when we tried to commit an transaction. Reason:" + e.getMessage(), e);
}
}
/**
* Rollbacks a transaction on the named database
*/
public static void rollbackTransaction(Database db)
{
try
{
if (db.isActive())
{
db.rollback();
}
}
catch(Exception e)
{
logger.error("An error occurred when we tried to rollback an transaction. Reason:" + e.getMessage());
}
}
/**
* Close the database
*/
public static void closeDatabase(Database db)
{
try
{
db.close();
}
catch(Exception e)
{
logger.error("An error occurred when we tried to close a database. Reason:" + e.getMessage(), e);
}
}
public static int getPropertyAsStringHashCode(String inheritedPageComponentsXML, Integer componentId, String propertyName, Integer siteNodeId, Integer languageId) throws Exception
{
Map property = null;
XmlInfosetBuilder builder = XmlInfosetBuilder.newInstance();
XmlDocument doc = builder.parseReader(new StringReader( inheritedPageComponentsXML ) );
String propertyXPath = "//component[@id=" + componentId + "]/properties/property[@name='" + propertyName + "']";
Xb1XPath xpathObject = new Xb1XPath( propertyXPath );
List anl = xpathObject.selectNodes( doc );
//If not found on the same component id - let's check them all and use the first we find.
if(anl == null || anl.size() == 0)
{
String globalPropertyXPath = "(//component/properties/property[@name='" + propertyName + "'])[1]";
Xb1XPath globalXpathObject = new Xb1XPath( globalPropertyXPath );
anl = globalXpathObject.selectNodes( doc );
}
StringBuilder sb = new StringBuilder();
Iterator anlIterator = anl.iterator();
while(anlIterator.hasNext())
{
XmlElement infosetItem = (XmlElement)anlIterator.next();
String propertyXML = builder.serializeToString(infosetItem);
//System.out.println("propertyXML:" + propertyXML);
sb.append(propertyXML);
}
//System.out.println("propertyXML HASH:" + sb.toString().hashCode());
return sb.toString().hashCode();
}
public static int getComponentsAsStringHashCode(String inheritedPageComponentsXML, String componentXPath) throws Exception
{
XmlInfosetBuilder builder = XmlInfosetBuilder.newInstance();
XmlDocument doc = builder.parseReader(new StringReader( inheritedPageComponentsXML ) );
Xb1XPath xpathObject = new Xb1XPath( componentXPath );
//This keeps track of the cached inherited components.
StringBuilder sb = new StringBuilder();
List componentNodeList = xpathObject.selectNodes( doc.getDocumentElement() );
Iterator componentNodeListIterator = componentNodeList.iterator();
while(componentNodeListIterator.hasNext())
{
XmlElement child = (XmlElement)componentNodeListIterator.next();
String componentString = builder.serializeToString(child).trim();
sb.append(componentString);
//System.out.println("componentString:" + componentString);
}
//System.out.println("propertyXML HASH:" + sb.toString().hashCode());
return sb.toString().hashCode();
}
public static Map getEventListeners()
{
return eventListeners;
}
}