JCS3CacheImpl.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.cache;

  23. import java.io.ByteArrayOutputStream;
  24. import java.io.FileInputStream;
  25. import java.io.IOException;
  26. import java.io.ObjectOutputStream;
  27. import java.io.OutputStream;
  28. import java.io.Serializable;
  29. import java.util.ArrayList;
  30. import java.util.Arrays;
  31. import java.util.Enumeration;
  32. import java.util.List;
  33. import java.util.Properties;
  34. import java.util.Set;

  36. import org.apache.commons.jcs3.JCS;
  37. import org.apache.commons.jcs3.access.CacheAccess;
  38. import org.apache.commons.jcs3.admin.CountingOnlyOutputStream;
  39. import org.apache.commons.jcs3.admin.JCSAdminBean;
  40. import org.apache.commons.jcs3.engine.CacheElementSerialized;
  41. import org.apache.commons.jcs3.engine.behavior.ICacheElement;
  42. import org.apache.commons.jcs3.engine.behavior.ICompositeCacheAttributes;
  43. import org.apache.commons.jcs3.engine.behavior.IElementAttributes;
  44. import org.apache.commons.jcs3.engine.control.CompositeCache;
  45. import org.apache.commons.jcs3.engine.memory.behavior.IMemoryCache;
  46. import org.apache.commons.jcs3.log.LogManager;
  47. import org.openspcoop2.utils.Utilities;
  48. import org.openspcoop2.utils.UtilsException;
  49. import org.openspcoop2.utils.properties.CollectionProperties;
  50. import org.openspcoop2.utils.properties.PropertiesUtilities;
  51. import org.slf4j.Logger;

  53. /**
  54.  * JCS3CacheImpl
  55.  *
  56.  * @author Poli Andrea (apoli@link.it)
  57.  * @author $Author$
  58.  * @version $Rev$, $Date$
  59.  */
  60. public class JCS3CacheImpl extends AbstractCacheImpl {

  62.     public static void setLog4jSystem() {
  63.         System.setProperty("jcs.logSystem", LogManager.LOGSYSTEM_LOG4J2);
  64.     }
  65.     public static boolean initialize(Logger logConsole,Logger logCore,
  66.             String cachePropertiesName,
  67.             String rootDirectory,Properties objectProperties,
  68.             String OPENSPCOOP2_LOCAL_HOME,String OPENSPCOOP2_CACHE_PROPERTIES,String OPENSPCOOP2_CACHE_LOCAL_PATH){
  69.         try{
  70.             
  71.             // Originale
  72.             java.util.Properties cacheProperties = new java.util.Properties();
  73.             java.io.File loggerFile = new java.io.File(rootDirectory+cachePropertiesName);
  74.             if(loggerFile .exists() == false ){
  75.                 cacheProperties.load(Cache.class.getResourceAsStream("/"+cachePropertiesName));
  76.             }else{
  77.                 FileInputStream fin = null;
  78.                 try{
  79.                     fin = new java.io.FileInputStream(loggerFile);
  80.                     cacheProperties.load(fin);
  81.                 }finally{
  82.                     try{
  83.                         if(fin!=null){
  84.                             fin.close();
  85.                         }
  86.                     }catch(Exception eClose){
  87.                         // close
  88.                     }
  89.                 }
  90.             }
  91.             
  92.             // File Local Implementation
  93.             CollectionProperties cachePropertiesRidefinito =  
  94.                 PropertiesUtilities.searchLocalImplementation(OPENSPCOOP2_LOCAL_HOME,logConsole, OPENSPCOOP2_CACHE_PROPERTIES ,OPENSPCOOP2_CACHE_LOCAL_PATH, rootDirectory);
  95.             if(cachePropertiesRidefinito!=null && cachePropertiesRidefinito.size()>0){
  96.                 Enumeration<?> ridefinito = cachePropertiesRidefinito.keys();
  97.                 while (ridefinito.hasMoreElements()) {
  98.                     String key = (String) ridefinito.nextElement();
  99.                     String value = (String) cachePropertiesRidefinito.get(key);
  100.                     if(cacheProperties.containsKey(key)){
  101.                         //Object o = 
  102.                         cacheProperties.remove(key);
  103.                     }
  104.                     cacheProperties.put(key, value);
  105.                     //System.out.println("CHECK NUOVO VALORE: "+loggerProperties.get(key));
  106.                 }
  107.             }
  108.             
  109.             // File Object Implementation
  110.             if(objectProperties!=null && objectProperties.size()>0){
  111.                 Enumeration<?> ridefinito = objectProperties.keys();
  112.                 while (ridefinito.hasMoreElements()) {
  113.                     String key = (String) ridefinito.nextElement();
  114.                     String value = (String) objectProperties.get(key);
  115.                     if(cacheProperties.containsKey(key)){
  116.                         //Object o = 
  117.                         cacheProperties.remove(key);
  118.                     }
  119.                     cacheProperties.put(key, value);
  120.                     //System.out.println("CHECK NUOVO VALORE: "+loggerProperties.get(key));
  121.                 }
  122.             }
  123.             
  124.             JCS.setConfigProperties(cacheProperties);
  125.             
  126.             return true;
  127.             
  128.         }catch(Exception e){
  129.             logCore.error("Riscontrato errore durante l'inizializzazione del sistema di cache: "
  130.                     +e.getMessage(),e);
  131.             return false;
  132.         }
  133.     }
  134.     
  135.     
  136.     private CacheAccess<Object, Serializable> cache = null;
  137.     @SuppressWarnings("unused")
  138.     private JCSAdminBean cacheAdmin = null;
  139.     
  140.     private JCS3CacheImpl() {
  141.         // Metodo usato per le utilities
  142.         setLog4jSystem();
  143.         this.cacheAdmin = new JCSAdminBean();
  144.     }
  145.     public JCS3CacheImpl(String name) throws UtilsException{
  146.         this(name, org.openspcoop2.utils.cache.Cache.DEFAULT_DISABLE_SYNCRONIZED_GET);
  147.     }
  148.     @Deprecated
  149.     private JCS3CacheImpl(String name, boolean disableSyncronizedGet) throws UtilsException{
  150.         super(CacheType.JCS, name);
  151.         setLog4jSystem();
  152.         try{
  153.             this.cacheAdmin = new JCSAdminBean();
  154.             this.cache = JCS.getInstance(this.cacheName);
  155.             if(disableSyncronizedGet) {
  156.                 // Dalla versione 3.0 non è più presente la gestione del synchronized
  157.                 //this.cache.getCacheControl().setSyncDisabled(disableSyncronizedGet);
  158.             }
  159.         }catch(Exception e){
  160.             throw new UtilsException(e.getMessage(),e);
  161.         }
  162.     }
  163.     
  164.     
  165.     //  *** Inizializzazione ***
  166.     
  167.     @Override
  168.     public int getCacheSize() {
  169.         return this.cache.getCacheAttributes().getMaxObjects();
  170.     }
  171.     @Override
  172.     public void setCacheSize(int cacheSize) {
  173.         // E' necessario prendere l'oggetto e poi risettarlo a causa di un bug.
  174.         ICompositeCacheAttributes attr = this.cache.getCacheAttributes();
  175.         attr.setMaxObjects(cacheSize);
  176.         this.cache.setCacheAttributes(attr);
  177.     }

  179.     @Override
  180.     public CacheAlgorithm getCacheAlgoritm() {
  181.         return CacheAlgorithm.toEnum(this.cache.getCacheAttributes().getCacheName());
  182.     }
  183.     @Override
  184.     public void setCacheAlgoritm(CacheAlgorithm cacheAlgoritm) {
  185.         // E' necessario prendere l'oggetto e poi risettarlo a causa di un bug.
  186.         ICompositeCacheAttributes attr = this.cache.getCacheAttributes();
  187.         attr.setCacheName(cacheAlgoritm.getAlgorithm());
  188.         this.cache.setCacheAttributes(attr);
  189.     }

  191.     @Override
  192.     public long getItemIdleTime() throws UtilsException {
  193.         try{
  194.             return this.cache.getDefaultElementAttributes().getIdleTime();
  195.         }catch(Exception e){
  196.             throw new UtilsException(e.getMessage(),e);
  197.         }
  198.     }
  199.     @Override
  200.     public void setItemIdleTime(long itemIdleTimeCache) throws UtilsException {
  201.         try{
  202.             // E' necessario prendere l'oggetto e poi risettarlo a causa di un bug.
  203.             IElementAttributes el = this.cache.getDefaultElementAttributes();
  204.             el.setIdleTime(itemIdleTimeCache);
  205.             this.cache.setDefaultElementAttributes(el);
  206.         }catch(Exception e){
  207.             throw new UtilsException(e.getMessage(),e);
  208.         }
  209.     }

  211.     @Override
  212.     public long getItemLifeTime() throws UtilsException {
  213.         try{
  214.             return this.cache.getDefaultElementAttributes().getMaxLife();
  215.         }catch(Exception e){
  216.             throw new UtilsException(e.getMessage(),e);
  217.         }
  218.     }
  219.     @Override
  220.     public boolean isEternal() throws UtilsException {
  221.         try{
  222.             return this.cache.getDefaultElementAttributes().getIsEternal();
  223.         }catch(Exception e){
  224.             throw new UtilsException(e.getMessage(),e);
  225.         }
  226.     }
  227.     @Override
  228.     public void setItemLifeTime(long itemLifeTimeCache) throws UtilsException {
  229.         try{
  230.             // E' necessario prendere l'oggetto e poi risettarlo a causa di un bug.
  231.             IElementAttributes el = this.cache.getDefaultElementAttributes();
  232.             if(itemLifeTimeCache>0) {
  233.                 el.setIsEternal(false);
  234.                 el.setMaxLife(itemLifeTimeCache);
  235.             }
  236.             else {
  237.                 el.setIsEternal(true);
  238.                 el.setMaxLife(-1);
  239.             }
  240.             this.cache.setDefaultElementAttributes(el);
  241.         }catch(Exception e){
  242.             throw new UtilsException(e.getMessage(),e);
  243.         }
  244.     }
  245.     
  246.     @Override
  247.     public void build() throws UtilsException{
  248.         // nop; le operazioni di aggiustamento delle dimensioni, si fanno direttamente sugli oggetti
  249.     }
  250.     
  251.     
  252.     //  *** Gestione ***
  253.     
  254.     @Override
  255.     public void clear() throws UtilsException{
  256.         if(this.cache!=null){
  257.             try{
  258.                 this.cache.clear();
  259.             }catch(Exception e){
  260.                 throw new UtilsException(e.getMessage(),e);
  261.             }
  262.         }
  263.     }
  264.     
  265.     @Override
  266.     public Object get(String key){
  267.         return this.cache.get(this.formatKeyCache(key));
  268.     }
  269.     
  270.     @Override
  271.     public void remove(String key) throws UtilsException{
  272.         try{
  273.             this.cache.remove(this.formatKeyCache(key));
  274.         }catch(Exception e){
  275.             throw new UtilsException(e.getMessage(),e);
  276.         }   
  277.     }
  278.     
  279.     @Override
  280.     public void put(String key,org.openspcoop2.utils.cache.CacheResponse value) throws UtilsException{
  281.         try{
  282.             this.cache.put(this.formatKeyCache(key), value);
  283.         }catch(Exception e){
  284.             throw new UtilsException(e.getMessage(),e);
  285.         }
  286.     }
  287.     @Override
  288.     public void put(String key,Serializable value) throws UtilsException{
  289.         try{
  290.             this.cache.put(this.formatKeyCache(key), value);
  291.         }catch(Exception e){
  292.             throw new UtilsException(e.getMessage(),e);
  293.         }
  294.     }
  295.     
  296.     private String formatKeyCache(String key) {
  297.         // org/apache/commons/jcs/engine/control/CompositeCache.java
  298.         //      if ( cacheElement.getKey() instanceof String
  299.         //              && cacheElement.getKey().toString().endsWith( NAME_COMPONENT_DELIMITER ) )
  300.         //          {
  301.         //              throw new IllegalArgumentException( "key must not end with " + NAME_COMPONENT_DELIMITER
  302.         //                  + " for a put operation" );
  303.         //          }
  304.         //
  305.         // Dove in org.apache.commons.jcs3.engine.behavior.ICache
  306.         //      public static final String NAME_COMPONENT_DELIMITER = ":";

  308.         /*StringBuilder bf = new StringBuilder(key);
  309.         if(bf.toString().endsWith(org.apache.commons.jcs3.engine.behavior.ICache.NAME_COMPONENT_DELIMITER)){
  310.             bf.append("_");
  311.         }
  312.         return bf.toString();*/
  313.         if(key.endsWith(org.apache.commons.jcs3.engine.behavior.ICache.NAME_COMPONENT_DELIMITER)) {
  314.             return key+"_";
  315.         }
  316.         else {
  317.             return key;
  318.         }
  319.     }
  320.     
  321.     @Override
  322.     public int getItemCount()  throws UtilsException {
  323.         CompositeCache<Object, Serializable> cache = JCSAdminBean.getCompositeCacheManager().getCache(this.cacheName);
  324.         return cache.getSize();
  325.     }
  326.     
  327.     @Override
  328.     public List<String> keys() throws UtilsException {
  329.         try{
  330.             
  331.             List<String> keys = new ArrayList<>();
  332.             Serializable[] keysObject = this.cache.getCacheControl().getKeySet().toArray(new Serializable[0]);
  333.             if(keysObject!=null){
  334.                 for (int i = 0; i < keysObject.length; i++) {
  335.                     keys.add((String)keysObject[i]);
  336.                 }
  337.             }
  338.             return keys;
  339.         
  340.         }catch(Exception e){
  341.             throw new UtilsException(e.getMessage(),e);
  342.         }
  343.     }
  344.     
  345.     
  346.     
  347.     //  *** Info ***
  348.     
  349.     @Override
  350.     public void printStats(OutputStream out, String separator) throws UtilsException{
  351.         this.printStats(this.cacheName,out,separator,true);
  352.     }
  353.     
  354.     private void printStats(String cacheName, OutputStream out, String separator, boolean thisCache) throws UtilsException {
  355.         
  356.         try{
  357.         
  358.             StringBuilder bf = new StringBuilder();
  359.             
  360.             CompositeCache<Object, Serializable> cache = JCSAdminBean.getCompositeCacheManager().getCache(cacheName);
  361.                         
  362.             //bf.append(Utilities.convertBytesToFormatString(region.getByteCount()));
  363.             // NOTA: e' stato re-implementato il metodo poiche' casualmente avveniva un errore del tipo:
  364.             //       Problem getting byte count.  Likley cause is a non serilizable object.null
  365.             //       Il problema derivava dall'implementazione del metodo all'interno della classe org/apache/commons/jcs/admin/JCSAdminBean
  366.             //       Viene utilizzato l'iterator dentro una struttura dinamica che cambia.
  367.             //       A volte, quando poi veniva registrato l'errore soprastante, avveniva questo errore (scoperto aggiungendo stampe nelle classi di JCS)
  368.             //       java.util.ConcurrentModificationException
  369.             //          at java.util.Hash table$Enumerator.next(Hash table.java:1031)
  370.             //          at org.apache.commons.jcs3.engine.memory.lru.LRUMemoryCache$IteratorWrapper.next(LRUMemoryCache.java:428)
  371.             //          at org.apache.commons.jcs3.admin.JCSAdminBean.getByteCount(JCSAdminBean.java:95)
  372.             int tentativi = 0;
  373.             long sizeAttuale = -1;
  374.             while (tentativi<10) {
  375.                 sizeAttuale = this.getByteCount(cache);
  376.                 if(this.errorOccursCountingBytes==false){
  377.                     break;
  378.                 }
  379.                 if(thisCache){
  380.                     //System.err.println("PROVO ALTRO TENTATIVO");
  381.                     tentativi++;
  382.                     cache = JCSAdminBean.getCompositeCacheManager().getCache(cacheName);
  383.                 }
  384.                 else{
  385.                     break;
  386.                 }
  387.             }
  388.                 
  389.             
  390.             bf.append("Nome:");
  391.             bf.append(cacheName);
  392.             bf.append(" ");
  393.             
  394.             bf.append(separator);
  395.             
  396.             bf.append("Tipo:");
  397.             bf.append(CacheType.JCS);
  398.             bf.append(" ");
  399.             
  400.             bf.append(separator);
  401.             
  402.             bf.append("Stato:");
  403.             bf.append(cache.getStatus());
  404.             bf.append(" ");
  405.             
  406.             bf.append(separator);
  407.             
  408.             // Dalla versione 3.0 non è più presente la gestione del synchronized
  409. //          bf.append("GetSyncDisabled:");
  410. //          bf.append(cache.isSyncDisabled());
  411. //          bf.append(" ");
  412. //          
  413. //          bf.append(separator);
  414.             
  415.             if(cache.getCacheAttributes()!=null){
  416.             
  417.                 bf.append("Algoritmo:");
  418.                 String cacheAlgoName = cache.getCacheAttributes().getCacheName();
  419.                 CacheAlgorithm cacheEnum = CacheAlgorithm.toEnum(cacheAlgoName);
  420.                 if(cacheEnum!=null){
  421.                     bf.append(cacheEnum.name());
  422.                 }else{
  423.                     bf.append(cacheAlgoName);
  424.                 }
  425.                 bf.append(" ");
  426.                 
  427.                 bf.append(separator);
  428.                 
  429.                 bf.append("Dimensione:");
  430.                 bf.append(cache.getCacheAttributes().getMaxObjects());
  431.                 bf.append(" ");
  432.                 
  433.                 bf.append(separator);
  434.                 
  435.             }
  436.             
  437.             bf.append("ElementiInCache:");
  438.             bf.append(cache.getSize());
  439.             bf.append(" ");
  440.             
  441.             bf.append(separator);
  442.             
  443.             bf.append("MemoriaOccupata:");
  444.             if(this.errorOccursCountingBytes){
  445.                 bf.append("[WARN !Error occurs counting bytes, re-try!]");
  446.             }
  447.             bf.append(Utilities.convertBytesToFormatString(sizeAttuale));
  448.             bf.append(" ");
  449.             
  450.             bf.append(separator);
  451.             
  452.             if(cache.getElementAttributes()!=null){
  453.             
  454.                 bf.append("IdleTime:");
  455.                 long idleTime = cache.getElementAttributes().getIdleTime();
  456.                 if(idleTime>0){
  457.                     bf.append(Utilities.convertSystemTimeIntoStringMillisecondi(idleTime*1000,false));
  458.                 }
  459.                 else if(idleTime==0){
  460.                     bf.append("0");
  461.                 }
  462.                 else if(idleTime<0){
  463.                     bf.append("Infinito");
  464.                 }
  465.                 bf.append(" ");
  466.                 
  467.                 bf.append(separator);
  468.                 
  469.                 bf.append("LifeTime:");
  470.                 long lifeTime = cache.getElementAttributes().getMaxLife();
  471.                 if(lifeTime>0){
  472.                     bf.append(Utilities.convertSystemTimeIntoStringMillisecondi(lifeTime*1000,false));
  473.                 }
  474.                 else if(lifeTime==0){
  475.                     bf.append("0");
  476.                 }
  477.                 else if(lifeTime<0){
  478.                     if(cache.getElementAttributes().getIsEternal()) {
  479.                         bf.append("Infinito");
  480.                     }
  481.                     else {
  482.                         bf.append("Infinito (NoEternal?)");
  483.                     }
  484.                 }
  485.                 bf.append(" ");
  486.                 
  487.                 bf.append(separator);
  488.             
  489.             }
  490.             
  491.             bf.append("PutCount:");
  492.             bf.append(cache.getUpdateCount());
  493.             bf.append(" ");
  494.             
  495.             bf.append(separator);
  496.             
  497.             bf.append("HitCount(Aux):");
  498.             bf.append(cache.getHitCountAux());
  499.             bf.append(" ");
  500.             
  501.             bf.append(separator);
  502.             
  503.             bf.append("HitCount(Ram):");
  504.             bf.append(cache.getHitCountRam());
  505.             bf.append(" ");
  506.             
  507.             bf.append(separator);
  508.             
  509.             bf.append("MissCount(Expired):");
  510.             bf.append(cache.getMissCountExpired());
  511.             bf.append(" ");
  512.             
  513.             bf.append(separator);
  514.             
  515.             bf.append("MissCount(NotFound):");
  516.             bf.append(cache.getMissCountNotFound());
  517.             bf.append(" ");
  518.             
  519.             out.write(bf.toString().getBytes());
  520.             
  521.         }catch(Exception e){
  522.             throw new UtilsException(e.getMessage(),e);
  523.         }
  524.     }
  525.     
  526.     private boolean errorOccursCountingBytes_debug = false;
  527.     private boolean errorOccursCountingBytes = false;
  528.     public <K, V> long getByteCount(CompositeCache<K, V> cache)
  529.     {
  530.         this.errorOccursCountingBytes = false;
  531.         
  532.         if (cache == null)
  533.         {
  534.             throw new IllegalArgumentException("The cache object specified was null.");
  535.         }

  537.         long size = 0;
  538.         IMemoryCache<K, V> memCache = cache.getMemoryCache();

  540.         try {
  541.             for (K key : memCache.getKeySet())
  542.             {
  543.                 ICacheElement<K, V> ice = null;
  544.                 try
  545.                 {
  546.                     ice = memCache.get(key);
  547.                 }
  548.                 catch (IOException e)
  549.                 {
  550.                     //Modificato per openspcoop
  551.                     if(this.errorOccursCountingBytes_debug) {
  552.                         System.err.println("["+this.cacheName+"] Element cache get");
  553.                         e.printStackTrace(System.err);
  554.                     }
  555.                     this.errorOccursCountingBytes = true;
  556.                     continue;
  557.                     //throw new RuntimeException("IOException while trying to get a cached element", e);
  558.                 }

  560.                 if (ice == null)
  561.                 {
  562.                     continue;
  563.                 }

  565.                 if (ice instanceof CacheElementSerialized)
  566.                 {
  567.                     size += ((CacheElementSerialized<K, V>) ice).getSerializedValue().length;
  568.                 }
  569.                 else
  570.                 {
  571.                     Object element = ice.getVal();
  572.                     if(element == null) {
  573.                         //Modificato per openspcoop
  574.                         if(this.errorOccursCountingBytes_debug) {
  575.                             System.err.println("["+this.cacheName+"] Element cache is null");
  576.                         }
  577.                         this.errorOccursCountingBytes = true;
  578.                         continue;
  579.                     }

  581.                     //CountingOnlyOutputStream: Keeps track of the number of bytes written to it, but doesn't write them anywhere.
  582.                     CountingOnlyOutputStream counter = new CountingOnlyOutputStream();
  583.                     try (ObjectOutputStream out = new ObjectOutputStream(counter);)
  584.                     {
  585.                         out.writeObject(element);
  586.                     }
  587.                     catch (IOException e)
  588.                     {
  589.                         // Modificato per openspcoop
  590.                         if(this.errorOccursCountingBytes_debug) {
  591.                             System.err.println("["+this.cacheName+"] Element cache writeObject ("+element.getClass().getName()+")");
  592.                             e.printStackTrace(System.err);
  593.                         }
  594.                         this.errorOccursCountingBytes = true;
  595.                         continue;
  596.                         //throw new RuntimeException("IOException while trying to measure the size of the cached element", e);
  597.                     }
  598.                     finally
  599.                     {
  600.                         try
  601.                         {
  602.                             counter.close();
  603.                         }
  604.                         catch (IOException e)
  605.                         {
  606.                             // ignore
  607.                         }
  608.                     }

  610.                     // 4 bytes lost for the serialization header
  611.                    size += counter.getCount() - 4;
  612.                 }
  613.             }
  614.         }
  615.         catch ( Exception e )
  616.         {
  617.             System.err.println( "Problem getting byte count (Modified by GovWay).  Likley cause is a non serilizable object." + e.getMessage() );
  618.             e.printStackTrace(System.err);   
  619.         }

  621.         return size;
  622.     }
  623.     
  624.     public static String printAllStats(String separatorStat, String separatorCache) throws UtilsException {
  625.         try{
  626.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  627.             printAllStats(bout,separatorStat,separatorCache);
  628.             bout.flush();
  629.             bout.close();
  630.             return bout.toString();
  631.         }catch(Exception e){
  632.             throw new UtilsException(e.getMessage(),e);
  633.         }
  634.     }
  635.     public static void printAllStats(OutputStream out, String separatorStat, String separatorCache) throws UtilsException {
  636.         try{
  637.             JCS3CacheImpl cacheUtility = new JCS3CacheImpl();
  638.             
  639.             Set<String> cacheNames_tmp = JCSAdminBean.getCompositeCacheManager().getCacheNames();
  640.             if(cacheNames_tmp.size()>0) {
  641.                 String[] cacheNames = new String[cacheNames_tmp.size()];
  642.                 int index = 0;
  643.                 for (String name : cacheNames_tmp) {
  644.                     cacheNames[index] = name;
  645.                     index++;
  646.                 }
  647.                 Arrays.sort( cacheNames );
  648.                 for ( int i = 0; i < cacheNames.length; i++ ) {
  649.                     cacheUtility.printStats(cacheNames[i],out,separatorStat,false);
  650.                     out.write(separatorCache.getBytes());
  651.                 }
  652.             }
  653.         }catch(Exception e){
  654.             throw new UtilsException(e.getMessage(),e);
  655.         }
  656.     }
  657.     
  658.     
  659.     
  660.     
  661.     //  *** Sincronizzazione ***
  662.     
  663.     @SuppressWarnings("deprecation")
  664.     @Override
  665.     @Deprecated
  666.     public void disableSyncronizedGet() throws UtilsException {
  667.         if(this.cache==null) {
  668.             throw new UtilsException("Cache disabled");
  669.         }
  670.         try{
  671.             // Dalla versione 3.0 non è più presente la gestione del synchronized
  672.             //this.cache.getCacheControl().setSyncDisabled(true);
  673.         }catch(Exception e){
  674.             throw new UtilsException(e.getMessage(),e);
  675.         }
  676.     }
  677.     @SuppressWarnings("deprecation")
  678.     @Override
  679.     @Deprecated
  680.     public boolean isDisableSyncronizedGet() throws UtilsException {
  681.         if(this.cache==null) {
  682.             throw new UtilsException("Cache disabled");
  683.         }
  684.         try{
  685.             // Dalla versione 3.0 non è più presente la gestione del synchronized
  686.             //return this.cache.getCacheControl().isSyncDisabled();
  687.             return true;
  688.         }catch(Exception e){
  689.             throw new UtilsException(e.getMessage(),e);
  690.         }
  691.     }
  692.     
  693.     @SuppressWarnings("deprecation")
  694.     @Override
  695.     @Deprecated
  696.     public void enableDebugSystemOut() throws UtilsException {
  697.         if(this.cache==null) {
  698.             throw new UtilsException("Cache disabled");
  699.         }
  700.         try{
  701.             // Dalla versione 3.0 non è più presente la gestione del synchronized
  702.             //this.cache.getCacheControl().setDebugSystemOut(true);
  703.         }catch(Exception e){
  704.             throw new UtilsException(e.getMessage(),e);
  705.         }
  706.     }
  707.     @SuppressWarnings("deprecation")
  708.     @Override
  709.     @Deprecated
  710.     public boolean isEnableDebugSystemOut() throws UtilsException {
  711.         if(this.cache==null) {
  712.             throw new UtilsException("Cache disabled");
  713.         }
  714.         try{
  715.             // Dalla versione 3.0 non è più presente la gestione del synchronized
  716.             //return this.cache.getCacheControl().isDebugSystemOut();
  717.             return false;
  718.         }catch(Exception e){
  719.             throw new UtilsException(e.getMessage(),e);
  720.         }
  721.     }
  722. }
Created with JaCoCo 0.8.8.202204050719