Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package pt.webdetails.cda.cache.monitor;
  
  import java.util.HashMap;
  
  
  import  org.apache.commons.logging.Log;
  import  org.apache.commons.logging.LogFactory;
 import  org.json.JSONArray;
 import  org.json.JSONException;
 import  org.json.JSONObject;
 import  org.pentaho.platform.api.engine.IParameterProvider;
 import  org.pentaho.platform.api.engine.IPentahoSession;
 import  org.pentaho.platform.engine.security.SecurityHelper;
 import  org.pentaho.reporting.libraries.base.util.StringUtils;
 
 
 public class CacheMonitorHandler extends JsonCallHandler 
 {
   
   private static Log logger = LogFactory.getLog(JsonCallHandler.class);
   
   private static CacheMonitorHandler _instance;
 
   public static synchronized CacheMonitorHandler getInstance()
   {
     if ( == null)
     {
        = new CacheMonitorHandler();
     }
     return ;
   }
 
 
   public CacheMonitorHandler()
   {
     registerMethods();
   }
   
   @Override
   protected boolean hasPermission(IPentahoSession sessionMethod method
   {//limit all interaction besides overview to admin role
     return method.getName().equals("cacheOverview") || SecurityHelper.isPentahoAdministrator(session);
   }
   
   private void registerMethods()
   {
     
     registerMethod("cached"new JsonCallHandler.Method() 
     {
      
get all cached items for given cda file and data access id
 
       public JSONObject execute(IParameterProvider paramsthrows JSONException, ExporterExceptionIOException {
         String cdaSettingsId = params.getStringParameter("cdaSettingsId"null);
         String dataAccessId = params.getStringParameter("dataAccessId"null);
         return listQueriesInCache(cdaSettingsIddataAccessId);
       }
     });
     
     registerMethod("cacheOverview"new JsonCallHandler.Method() 
     {
      
get details on a particular cached item
 
       public JSONObject execute(IParameterProvider paramsthrows JSONException 
       {
         String cdaSettingsId = params.getStringParameter("cdaSettingsId"null);
         return getCachedQueriesOverview(cdaSettingsId);
       }
     });
     
     registerMethod("getDetails"new JsonCallHandler.Method() 
     {
      
get details on a particular cached item
 
       public JSONObject execute(IParameterProvider paramsthrows UnsupportedEncodingException, JSONException, ExporterExceptionIOExceptionClassNotFoundException  
       {
         try{
           String encodedCacheKey=params.getStringParameter("key"null);
           return getcacheQueryTable(encodedCacheKey);
         }
         catch(ExporterException e){
           .error( "Error exporting table."e);
           return createJsonResultFromException(e);
         }
       }
     });
     
     registerMethod("removeCache"new JsonCallHandler.Method() 
     {
      
Remove item from cache
      public JSONObject execute(IParameterProvider paramsthrows JSONException, UnsupportedEncodingExceptionIOExceptionClassNotFoundException 
      {
        String serializedCacheKey = params.getStringParameter("key"null);
        return removeQueryFromCache(serializedCacheKey);
      }
    });
    
    registerMethod("removeAll"new JsonCallHandler.Method() {
      
      @Override
      public JSONObject execute(IParameterProvider paramsthrows JSONException {
        String cdaSettingsId = params.getStringParameter("cdaSettingsId"null);
        String dataAccessId = params.getStringParameter("dataAccessId"null);
        return removeAll(cdaSettingsIddataAccessId);
      }
    });
    
//    registerMethod("clusterInfo", new JsonCallHandler.Method() 
//    {
//      public JSONObject execute(IParameterProvider params) throws JSONException {
//        return getOKJson(HazelcastCacheMonitor.getClusterInfo()); 
//      }
//    });
//    
//    registerMethod("mapInfo", new JsonCallHandler.Method() 
//    {
//      public JSONObject execute(IParameterProvider params) throws JSONException {
//        return getOKJson(HazelcastCacheMonitor.getMapInfo()); 
//      }
//    });
    
    registerMethod("shutdown"new JsonCallHandler.Method() {
      
      @Override
      public JSONObject execute(IParameterProvider paramsthrows Exception {
        AbstractDataAccess.shutdowCache();
        return getOKJson("Cache shutdown.");
      }
    });
    
//    registerMethod("getElementDiskSize", new JsonCallHandler.Method()
//    {  
//      /**
//       * Get serialized size of an element
//       */
//      public JSONObject execute(IParameterProvider params) throws UnsupportedEncodingException, IOException, ClassNotFoundException, JSONException 
//      {
//        String serializedKey = params.getStringParameter("key", null);
//        return getElementSize(serializedKey, CacheSizeType.DISK);
//      }
//    });
//    
//    registerMethod("getElementMemorySize", new JsonCallHandler.Method()
//    {
//      /**
//       * Get in-memory size of an element
//       */
//      public JSONObject execute(IParameterProvider params) throws UnsupportedEncodingException, IOException, ClassNotFoundException, JSONException 
//      {
//        String serializedKey = params.getStringParameter("key", null);
//        return getElementSize(serializedKey, CacheSizeType.MEMORY);
//      }
//    });
    
  }
  
  
  private static class ResultFields extends JsonCallHandler.JsonResultFields {
    public static final String CDA_SETTINGS_ID = "cdaSettingsId";
    public static final String DATA_ACCESS_ID = "dataAccessId";
    public static final String COUNT = "count";
    public static final String ITEMS = "items";
  }
  
  
  private static class ErrorMsgs {
//    public static final String SIZEOF_NO_INSTRUMENTATION = "SizeOf needs to be declared as a java agent for this to work.";
    public static final String CACHE_ITEM_NOT_FOUND = "Cache element no longer in cache.";
    public static final String NO_CACHE_KEY_ARG = "No cache key received.";
  }
  
  private static JSONObject getcacheQueryTable(String encodedCacheKeythrows JSONException, ExporterExceptionUnsupportedEncodingExceptionIOExceptionClassNotFoundException {
    
    if(encodedCacheKey == null){
      throw new IllegalArgumentException("No cache key received.");
    }
    
    JSONObject result = new JSONObject();
    //Cache cdaCache = AbstractDataAccess.getCache();
    IQueryCache cdaCache = AbstractDataAccess.getCdaCache();
    TableCacheKey lookupCacheKey = TableCacheKey.getTableCacheKeyFromString(encodedCacheKey);
    //net.sf.ehcache.Element elem = cdaCache.getQuiet(lookupCacheKey);
    ExtraCacheInfo info = cdaCache.getCacheEntryInfo(lookupCacheKey);
    if(info != null){
      // put query results
      result.put(.info.getTableSnapshot());
      result.put(..);
    }
    else {
    }
    
    return result;
    
  }
  
  private static JSONObject getCachedQueriesOverview(String cdaSettingsIdFilterthrows JSONException {
    
    HashMap<StringHashMap<StringInteger>> cdaMap = new HashMap<StringHashMap<String,Integer>>();
    
    IQueryCache cdaCache = AbstractDataAccess.getCdaCache();
    JSONArray results = new JSONArray();
    
    for(TableCacheKey key : cdaCache.getKeys()) {
      
      ExtraCacheInfo info = cdaCache.getCacheEntryInfo(key);
      
      if(info == nullcontinue;
      
      String cdaSettingsId = info.getCdaSettingsId();
      String dataAccessId = info.getDataAccessId();
      
      if(cdaSettingsIdFilter != null && !cdaSettingsIdFilter.equals(cdaSettingsId)){
        continue;
      }
      
      //aggregate occurrences
      HashMap<StringIntegerdataAccessIdMap = cdaMap.get(cdaSettingsId);
      ifdataAccessIdMap == null ){
        dataAccessIdMap = new HashMap<StringInteger>();
        dataAccessIdMap.put(dataAccessId, 1);
        cdaMap.put(cdaSettingsIddataAccessIdMap);
      }
      else {
        Integer count = dataAccessIdMap.get(dataAccessId);
        if(count == null){
          dataAccessIdMap.put(dataAccessId, 1);
        }
        else {
          dataAccessIdMap.put(dataAccessId, ++count);
        }
      }
    }
    
    for(String cdaSettingsId :  cdaMap.keySet()){
      getOverviewForCdaSettingsId(cdaMapresultscdaSettingsId);
    }
    
    JSONObject result = new JSONObject();
    result.put(.results);
    return result;
  }


  

Parameters:
cdaMap
results
cdaSettingsId
Throws:
JSONException
  private static void getOverviewForCdaSettingsId(HashMap<StringHashMap<StringInteger>> cdaMap, JSONArray resultsString cdaSettingsIdthrows JSONException {
    for(String dataAccessId : cdaMap.get(cdaSettingsId).keySet() ){
      Integer count = cdaMap.get(cdaSettingsId).get(dataAccessId);
      JSONObject queryInfo = new JSONObject();
      queryInfo.put(.cdaSettingsId);
      queryInfo.put(.dataAccessId); 
      queryInfo.put(.count.intValue());
      
      results.put(queryInfo);
    }
  }
  
  private static JSONObject removeQueryFromCache(String serializedCacheKeythrows UnsupportedEncodingExceptionIOExceptionClassNotFoundException, JSONException 
  {
    TableCacheKey key = TableCacheKey.getTableCacheKeyFromString(serializedCacheKey);
    
    IQueryCache cdaCache = AbstractDataAccess.getCdaCache();
    boolean success = cdaCache.remove(key);
    
    JSONObject result = new JSONObject();
    if(success){
      result.put(..);
      result.put(.true);
      return result;
    }
    else {
    }
  }
  
  private static JSONObject listQueriesInCache(String cdaSettingsIdString dataAccessIdthrows JSONException, ExporterExceptionIOException {
    
    JSONArray results = new JSONArray();
    
    IQueryCache cdaCache = AbstractDataAccess.getCdaCache();
    
    for(TableCacheKey key : cdaCache.getKeys()) {
      
      ExtraCacheInfo info = cdaCache.getCacheEntryInfo(key);
      if(info == nullcontinue;
      
      if(!StringUtils.equals(cdaSettingsIdinfo.getCdaSettingsId()) ||
         (dataAccessId != null && !StringUtils.equals(dataAccessIdinfo.getDataAccessId())))
      {//not what we're looking for
        continue;
      }
      
      CacheElementInfo cacheInfo = cdaCache.getElementInfo(key);
      results.put(cacheInfo.toJson());
       
    }
    
    JSONObject result = new JSONObject();
    result.put(.cdaSettingsId);
    result.put(.dataAccessId);
    result.put(.results);
//    //total stats
//    result.put("cacheLength", cdaCache.getSize());
//    result.put("memoryStoreLength", cdaCache.getMemoryStoreSize());
//    result.put("diskStoreLength", cdaCache.getDiskStoreSize());
    
    JSONObject response = new JSONObject();
    response.put(..);
    response.put(.result);
    
    return response;
  }
  
  private static JSONObject removeAll(String cdaSettingsIdString dataAccessIdthrows JSONException
  {
    IQueryCache cdaCache = AbstractDataAccess.getCdaCache();
    int result = cdaCache.removeAll(cdaSettingsIddataAccessId);
    
    return getOKJson(result);
  }
  
New to GrepCode? Check out our FAQ X