Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* This Source Code Form is subject to the terms of the Mozilla Public
   * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   * You can obtain one at http://mozilla.org/MPL/2.0/. */
  
  package pt.webdetails.cda.cache;
  
 import java.net.URL;
 
 
 import  org.apache.commons.logging.Log;
 import  org.apache.commons.logging.LogFactory;
 import  org.pentaho.platform.engine.core.system.PentahoSystem;
 import  org.pentaho.reporting.libraries.base.util.StringUtils;
 
 
 
 import  mondrian.olap.InvalidArgumentException;
 import  net.sf.ehcache.Cache;
 import  net.sf.ehcache.CacheException;
 import  net.sf.ehcache.CacheManager;
 import  net.sf.ehcache.Element;
 import  net.sf.ehcache.Status;
 import  org.apache.commons.io.IOUtils;
 import  org.pentaho.platform.api.engine.IPluginManager;
 import  org.pentaho.platform.api.engine.IPluginResourceLoader;
 
 public class EHCacheQueryCache implements IQueryCache {
 
   private static final Log logger = LogFactory.getLog(EHCacheQueryCache.class);
   private static final String CACHE_NAME = "pentaho-cda-dataaccess";
   private static final String CACHE_CFG_FILE = "ehcache.xml";
   private static final String CACHE_CFG_FILE_DIST = "ehcache-dist.xml";
   private static final String PLUGIN_PATH = "system/" + . + "/";
   private static final String USE_TERRACOTTA_PROPERTY = "pt.webdetails.cda.UseTerracotta";
   private static CacheManager cacheManager;
   
   private static class CacheElement implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
     private TableModel table;
     private ExtraCacheInfo info;
     
     public CacheElement(TableModel tableExtraCacheInfo info){
       this. = table;
       this. = info;
     }
 
     public TableModel getTable() {
       return ;
     }
 
     public ExtraCacheInfo getInfo() {
       return ;
     }
     
     private void writeObject(ObjectOutputStream outthrows IOException {
       out.writeObject();
       out.writeObject();
     }
     
     private void readObject(ObjectInputStream inthrows IOExceptionClassNotFoundException {
        = (TableModelin.readObject();
        = (ExtraCacheInfoin.readObject();
     }
     
   }
   
   protected static synchronized net.sf.ehcache.Cache getCacheFromManager() throws CacheException
   {
     if ( == null)
     {// 'new CacheManager' used instead of 'CacheManager.create' to avoid overriding default cache
       boolean useTerracotta = Boolean.parseBoolean(CdaBoot.getInstance().getGlobalConfig().getConfigProperty());
       String cacheConfigFile = useTerracotta ?  : ;
 
       if (CdaEngine.isStandalone())
       {//look for the one under src/jar
         URL cfgFile = CdaBoot.class.getResource(cacheConfigFile);
          = new net.sf.ehcache.CacheManager(cfgFile);
         .debug("Cache started using " + cfgFile);
       }
       else
       {//look at cda folder in pentaho
         try
         {//preferred way: proper config in plugin folder
           IPluginResourceLoader pluginResourceLoader = PentahoSystem.get(IPluginResourceLoader.class);
           IPluginManager pluginManager = PentahoSystem.get(IPluginManager.class);
          ClassLoader classLoader = pluginManager.getClassLoader(.);
          
          InputStream inputStream = pluginResourceLoader.getResourceAsStream(classLoadercacheConfigFile);
                   
           = new net.sf.ehcache.CacheManager(inputStream);
          .debug("Cache started using " + cacheConfigFile);
        }
        catch(CacheException exc)
        {//fallback to standalone 
          .warn("Cache configuration not found in plugin folder, using fallback.");
          URL cfgFile = CdaBoot.class.getResource(cacheConfigFile);
           = new net.sf.ehcache.CacheManager(cfgFile);
        }
      }
      // enable clean shutdown so ehcache's diskPersistent attribute can work
      if (!useTerracotta)
      {
        enableCacheProperShutdown(true);
      }
    }
    if (.cacheExists() == false)
    {
      .addCache();
    }
    return .getCache();
  }
  
  
  
  private static void enableCacheProperShutdown(final boolean force)
  {
    if (!force)
    {
      try
      {
        System.getProperty(net.sf.ehcache.CacheManager.ENABLE_SHUTDOWN_HOOK_PROPERTY);
        return;//unless force, ignore if already set
      }
      catch (NullPointerException npe)
      {
      } // key null, continue
      catch (InvalidArgumentException iae)
      {
      }// key not there, continue
      catch (SecurityException se)
      {
        return;//no permissions to set
      }
    }
    System.setProperty(net.sf.ehcache.CacheManager.ENABLE_SHUTDOWN_HOOK_PROPERTY, "true");
  }
  
  Cache cache = null;
  
  public EHCacheQueryCache(Cache cache){
    this. = cache;
  }
  
  public EHCacheQueryCache(){
    this. = getCacheFromManager();
  }
  
  public void putTableModel(TableCacheKey keyTableModel tableint ttlSec){
    putTableModel(key,table,ttlSec,new ExtraCacheInfo("","",-1,table));
  }
  
  public void putTableModel(TableCacheKey keyTableModel tableint ttlSecExtraCacheInfo info
  {
    final CacheElement cacheElement = new CacheElement(tableinfo);
    final Element storeElement = new Element(keycacheElement);
    storeElement.setTimeToLive(ttlSec);
    .put(storeElement);
    .flush();
    
    // Print cache status size
    .debug("Cache status: " + .getMemoryStoreSize() + " in memory, " + 
            .getDiskStoreSize() + " in disk");
  }
    ClassLoader contextCL = Thread.currentThread().getContextClassLoader();
    try{
      //make sure we have the right class loader in thread to instantiate cda classes in case DiskStore is used
      //TODO: ehcache 2.5 has ClassLoaderAwareCache
      final Element element = .get(key);
      if (element != null// Are we explicitly saying to bypass the cache?
      {
        final TableModel cachedTableModel = (TableModel) ((CacheElementelement.getObjectValue()).getTable();
        if (cachedTableModel != null)
        {
          // we have a entry in the cache ... great!
          .debug("Found tableModel in cache. Returning");
          // Print cache status size
          .debug("Cache status: " + .getMemoryStoreSize() + " in memory, " + 
                  .getDiskStoreSize() + " in disk");
          return cachedTableModel;
        }
      }
      return null;
    }
    catch(Exception e){
      .error("Error while attempting to load from cache, bypassing cache (cause: " + e.getClass() + ")"e);
      return null;
    }
    finally{
      Thread.currentThread().setContextClassLoader(contextCL);
    }
  }
  public void clearCache() {
    .removeAll();
  }
  
  public Cache getCache(){
    return this.;
  }
  public boolean remove(TableCacheKey key) {
    return .remove(key);
  }
  @SuppressWarnings("unchecked")
  public Iterable<TableCacheKeygetKeys() {
    return .getKeys();
  }
  {
    ClassLoader contextCL = Thread.currentThread().getContextClassLoader();
    try{
      //make sure we have the right class loader in thread to instantiate cda classes in case DiskStore is used
      //TODO: ehcache 2.5 has ClassLoaderAwareCache
      Element element = .get(key);
      if(element == null){
        .warn("Null element in cache, removing.");
        remove(key);
        return null;
      }
      Object val = element.getValue();
      if(val instanceof CacheElement){
        return ((CacheElement)val).getInfo();  
      }
      else {
        .error("Expected " + CacheElement.class.getCanonicalName() + ", found " + val.getClass().getCanonicalName() + " instead");
        remove(key);
        return null;
      }
    }
    catch(Exception e){
      .error("Error while attempting to load from cache, bypassing cache (cause: " + e.getClass() + ")"e);
      return null;
    }
    finally{
      Thread.currentThread().setContextClassLoader(contextCL);
    }
  }
    
    Element element = .getQuiet(key);
    CacheElementInfo info = new CacheElementInfo();
    info.setKey(key);
    if(element!= null){
      
      info.setInsertTime(element.getLatestOfCreationAndUpdateTime());
      info.setAccessTime(element.getLastAccessTime());
      info.setHits(element.getHitCount());
      Object val = element.getValue();
      if(val instanceof CacheElement){
        info.setRows(((CacheElementval).getTable().getRowCount()); 
      }
    }
    return info;
  }
  public int removeAll(String cdaSettingsIdString dataAccessId) {
    int deleteCount = 0;
    
    if(cdaSettingsId == null){
      deleteCount = .getSize();
      clearCache();
    }
    
    for(TableCacheKey key : getKeys()){
      ExtraCacheInfo info = ((CacheElement).getQuiet(key).getObjectValue()).getInfo();
      
      if(StringUtils.equals(cdaSettingsIdinfo.getCdaSettingsId()) &&
              (dataAccessId==null || 
               StringUtils.equals(dataAccessIdinfo.getDataAccessId())))
      {
        if(remove(key)) deleteCount++;
      }
    }
    return deleteCount;
  }
  public void shutdownIfRunning() {
    if(!= null){
      if(!=null){
        .flush();
      }
      if(.getStatus() == Status.STATUS_ALIVE){
        .debug("Shutting down cache manager.");
        .shutdown();
         = null;
      }
    }
  }
New to GrepCode? Check out our FAQ X