GestoreLoadBalancerCaching.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.  */
  20. package org.openspcoop2.pdd.core.behaviour.built_in.load_balance;

  22. import java.util.ArrayList;
  23. import java.util.Date;
  24. import java.util.List;

  26. import org.openspcoop2.core.commons.CoreException;
  27. import org.openspcoop2.core.config.PortaApplicativa;
  28. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  29. import org.openspcoop2.core.config.Proprieta;
  30. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  31. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  32. import org.openspcoop2.core.config.constants.TipoBehaviour;
  33. import org.openspcoop2.core.id.IDPortaApplicativa;
  34. import org.openspcoop2.message.OpenSPCoop2Message;
  35. import org.openspcoop2.pdd.core.PdDContext;
  36. import org.openspcoop2.pdd.core.behaviour.BehaviourEmitDiagnosticException;
  37. import org.openspcoop2.pdd.core.behaviour.BehaviourException;
  38. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.health_check.HealthCheckUtils;
  39. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.sticky.StickyConnector;
  40. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.sticky.StickyResult;
  41. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.sticky.StickyUtils;
  42. import org.openspcoop2.pdd.core.behaviour.conditional.ConditionalFilterResult;
  43. import org.openspcoop2.pdd.core.behaviour.conditional.ConditionalUtils;
  44. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  45. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  46. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  47. import org.openspcoop2.protocol.sdk.Busta;
  48. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  49. import org.openspcoop2.protocol.sdk.state.IState;
  50. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  51. import org.openspcoop2.protocol.utils.PorteNamingUtils;
  52. import org.openspcoop2.utils.SemaphoreLock;
  53. import org.openspcoop2.utils.UtilsException;
  54. import org.openspcoop2.utils.cache.Cache;
  55. import org.openspcoop2.utils.cache.CacheAlgorithm;
  56. import org.openspcoop2.utils.cache.CacheType;
  57. import org.openspcoop2.utils.date.DateManager;
  58. import org.openspcoop2.utils.date.DateUtils;
  59. import org.slf4j.Logger;

  61. /**     
  62.  * GestoreCacheKeystore
  63.  *
  64.  * @author Poli Andrea (poli@link.it)
  65.  * @author $Author$
  66.  * @version $Rev$, $Date$
  67.  */
  68. public class GestoreLoadBalancerCaching {

  70.     /** Chiave della cache */
  71.     private static final String LOAD_BALANCER_CACHE_NAME = "consegnaApplicativi";
  72.     /** Cache */
  73.     private static Cache cache = null;
  74.     private static final org.openspcoop2.utils.Semaphore lock = new org.openspcoop2.utils.Semaphore("GestoreLoadBalancerCaching");
  75.     

  77.     /* --------------- Cache --------------------*/
  78.     public static boolean isCacheAbilitata() {
  79.         return cache!=null;
  80.     }
  81.     public static void resetCache() throws Exception{
  82.         try{
  83.             if(cache!=null){
  84.                 cache.clear();
  85.             }
  86.         }catch(Exception e){
  87.             throw new Exception("Reset della cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  88.         }
  89.     }
  90.     public static String printStatsCache(String separator) throws Exception{
  91.         try{
  92.             if(cache!=null){
  93.                 try{
  94.                     return cache.printStats(separator);
  95.                 }catch(Exception e){
  96.                     throw new Exception(e.getMessage(),e);
  97.                 }
  98.             }else{
  99.                 throw new Exception("Cache non abilitata");
  100.             }
  101.         }catch(Exception e){
  102.             throw new Exception("Visualizzazione Statistiche riguardante la cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  103.         }
  104.     }
  105.     public static void abilitaCache() throws Exception{
  106.         try{
  107.             if(cache!=null)
  108.                 throw new Exception("Cache gia' abilitata");
  109.             else{
  110.                 _abilitaCache();
  111.             }
  112.         }catch(Exception e){
  113.             throw new Exception("Abilitazione cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  114.         }
  115.     }
  116.     private static synchronized void _abilitaCache() throws Exception{
  117.         try{
  118.             if(cache==null) {
  119.                 cache = new Cache(CacheType.JCS, LOAD_BALANCER_CACHE_NAME);  // lascio JCS come default abilitato via jmx
  120.                 cache.build();
  121.             }
  122.         }catch(Exception e){
  123.             throw new Exception("Abilitazione cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  124.         }
  125.     }
  126.     public static void abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond, Logger log) throws Exception{
  127.         try{
  128.             if(cache!=null)
  129.                 throw new Exception("Cache gia' abilitata");
  130.             else{
  131.                 int dimensione = -1;
  132.                 if(dimensioneCache!=null){
  133.                     dimensione = dimensioneCache.intValue();
  134.                 }
  135.                 initCache(CacheType.JCS, dimensione, algoritmoCacheLRU, itemIdleTime, itemLifeSecond, log);  // lascio JCS come default abilitato via jmx
  136.             }
  137.         }catch(Exception e){
  138.             throw new Exception("Abilitazione cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  139.         }
  140.     }
  141.     public static void disabilitaCache() throws Exception{
  142.         try{
  143.             if(cache==null)
  144.                 throw new Exception("Cache gia' disabilitata");
  145.             else{
  146.                 _disabilitaCache();
  147.             }
  148.         }catch(Exception e){
  149.             throw new Exception("Disabilitazione cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  150.         }
  151.     }   
  152.     private static synchronized void _disabilitaCache() throws Exception{
  153.         try{
  154.             if(cache!=null) {
  155.                 cache.clear();
  156.                 cache = null;
  157.             }
  158.         }catch(Exception e){
  159.             throw new Exception("Disabilitazione cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  160.         }
  161.     }   
  162.     public static String listKeysCache(String separator) throws Exception{
  163.         try{
  164.             if(cache!=null){
  165.                 try{
  166.                     return cache.printKeys(separator);
  167.                 }catch(Exception e){
  168.                     throw new Exception(e.getMessage(),e);
  169.                 }
  170.             }else{
  171.                 throw new Exception("Cache non abilitata");
  172.             }
  173.         }catch(Exception e){
  174.             throw new Exception("Visualizzazione chiavi presenti nella cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  175.         }
  176.     }
  177.     public static List<String> keysCache() throws Exception{
  178.         if(cache!=null){
  179.             try{
  180.                 return cache.keys();
  181.             }catch(Exception e){
  182.                 throw new Exception(e.getMessage(),e);
  183.             }
  184.         }else{
  185.             throw new Exception("Cache non abilitata");
  186.         }
  187.     }
  188.     public static String getObjectCache(String key) throws Exception{
  189.         try{
  190.             if(cache!=null){
  191.                 try{
  192.                     Object o = cache.get(key);
  193.                     if(o!=null){
  194.                         return o.toString();
  195.                     }else{
  196.                         return "oggetto con chiave ["+key+"] non presente";
  197.                     }
  198.                 }catch(Exception e){
  199.                     throw new Exception(e.getMessage(),e);
  200.                 }
  201.             }else{
  202.                 throw new Exception("Cache non abilitata");
  203.             }
  204.         }catch(Exception e){
  205.             throw new Exception("Visualizzazione oggetto presente nella cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  206.         }
  207.     }
  208.     
  209.     public static void removeObjectCache(String key) throws Exception{
  210.         try{
  211.             if(cache!=null){
  212.                 try{
  213.                     cache.remove(key);
  214.                 }catch(Exception e){
  215.                     throw new Exception(e.getMessage(),e);
  216.                 }
  217.             }else{
  218.                 throw new Exception("Cache non abilitata");
  219.             }
  220.         }catch(Exception e){
  221.             throw new Exception("Rimozione oggetto presente nella cache per i dati contenenti i dati di bilanciamento del carico non riuscita: "+e.getMessage(),e);
  222.         }
  223.     }
  224.     
  225.     
  226.     
  227.     
  228.     
  229.     /*----------------- CLEANER --------------------*/
  230.     
  231.     public static void removePortaApplicativa(IDPortaApplicativa idPA) throws Exception {
  232.         
  233.         if(cache!=null){
  234.             
  235.             IProtocolFactory<?> protocolFactory = null;
  236.             PorteNamingUtils namingUtils = null;
  237.             try {
  238.                 ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  239.                 String protocol = protocolFactoryManager.getProtocolByOrganizationType(idPA.getIdentificativiErogazione().getIdServizio().getSoggettoErogatore().getTipo());
  240.                 protocolFactory = protocolFactoryManager.getProtocolFactoryByName(protocol);
  241.                 namingUtils = new PorteNamingUtils(protocolFactory);
  242.             }catch(Throwable t) {
  243.                 OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Errore durante la comprensione del protocol factory della PA ["+idPA+"]");
  244.             }
  245.             
  246.             String nomePorta = idPA.getNome(); 
  247.             String nomePorta_normalized = null; 
  248.             if(namingUtils!=null) {
  249.                 nomePorta_normalized = namingUtils.normalizePA(nomePorta);
  250.             }
  251.             
  252.             String porta = _toKey_getKeyCacheNomePorta(nomePorta);
  253.             String porta_normalized = null;
  254.             if(nomePorta_normalized!=null){
  255.                 porta_normalized = _toKey_getKeyCacheNomePorta(nomePorta_normalized);
  256.             }
  257.             
  258.             List<String> keyForClean = new ArrayList<>();
  259.             List<String> keys = GestoreLoadBalancerCaching.keysCache();
  260.             if(keys!=null && !keys.isEmpty()) {
  261.                 for (String key : keys) {
  262.                     if(key!=null) {
  263.                         if(key.contains(porta)) {
  264.                             keyForClean.add(key);
  265.                         }
  266.                         else if(porta_normalized!=null && key.contains(porta_normalized)) {
  267.                             keyForClean.add(key);
  268.                         }
  269.                     }
  270.                 }
  271.             }
  272.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  273.                 for (String key : keyForClean) {
  274.                     removeObjectCache(key);
  275.                 }
  276.             }
  277.             
  278.         }
  279.     }
  280.     
  281.     
  282.     

  284.     /*----------------- INIZIALIZZAZIONE --------------------*/

  286.     public static void initialize(Logger log) throws Exception{
  287.         GestoreLoadBalancerCaching.initialize(null, false, -1,null,-1l,-1l, log);
  288.     }
  289.     public static void initialize(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  290.             long idleTime, long itemLifeSecond, Logger log) throws Exception{
  291.         GestoreLoadBalancerCaching.initialize(cacheType, true, dimensioneCache,algoritmoCache,idleTime,itemLifeSecond, log);
  292.     }

  294.     private static void initialize(CacheType cacheType, boolean cacheAbilitata,int dimensioneCache,String algoritmoCache,
  295.             long idleTime, long itemLifeSecond, Logger log) throws Exception{

  297.         // Inizializzazione Cache
  298.         if(cacheAbilitata){
  299.             GestoreLoadBalancerCaching.initCache(cacheType, dimensioneCache, algoritmoCache, idleTime, itemLifeSecond, log);
  300.         }

  302.     }
  303.     private static void initCache(CacheType cacheType, Integer dimensioneCache,String algoritmoCache,Long itemIdleTime,Long itemLifeSecond,Logger alog) throws Exception{
  304.         initCache(cacheType, dimensioneCache, CostantiConfigurazione.CACHE_LRU.toString().equalsIgnoreCase(algoritmoCache), itemIdleTime, itemLifeSecond, alog);
  305.     }
  306.     
  307.     private static void initCache(CacheType cacheType, Integer dimensioneCache,boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond,Logger alog) throws Exception{
  308.         
  309.         cache = new Cache(cacheType, LOAD_BALANCER_CACHE_NAME);
  310.     
  311.         // dimensione
  312.         if(dimensioneCache!=null && dimensioneCache>0){
  313.             try{
  314.                 String msg = "Dimensione della cache (ResponseCaching) impostata al valore: "+dimensioneCache;
  315.                 alog.info(msg);
  316.                 cache.setCacheSize(dimensioneCache);
  317.             }catch(Exception error){
  318.                 String msg = "Parametro errato per la dimensione della cache (ResponseCaching): "+error.getMessage();
  319.                 alog.error(msg);
  320.                 throw new Exception(msg,error);
  321.             }
  322.         }
  323.         
  324.         // algoritno
  325.         String msg = "Algoritmo di cache (ResponseCaching) impostato al valore: LRU";
  326.         if(!algoritmoCacheLRU){
  327.             msg = "Algoritmo di cache (ResponseCaching) impostato al valore: MRU";
  328.         }
  329.         alog.info(msg);
  330.         if(!algoritmoCacheLRU)
  331.             cache.setCacheAlgoritm(CacheAlgorithm.MRU);
  332.         else
  333.             cache.setCacheAlgoritm(CacheAlgorithm.LRU);
  334.         
  335.         
  336.         // idle time
  337.         if(itemIdleTime!=null && itemIdleTime>0){
  338.             try{
  339.                 msg = "Attributo 'IdleTime' (ResponseCaching) impostato al valore: "+itemIdleTime;
  340.                 alog.info(msg);
  341.                 cache.setItemIdleTime(itemIdleTime);
  342.             }catch(Exception error){
  343.                 msg = "Parametro errato per l'attributo 'IdleTime' (ResponseCaching): "+error.getMessage();
  344.                 alog.error(msg);
  345.                 throw new Exception(msg,error);
  346.             }
  347.         }
  348.         
  349.         // LifeSecond
  350.         long longItemLife = -1; 
  351.         if(itemLifeSecond!=null && itemLifeSecond>0){
  352.             longItemLife = itemLifeSecond.longValue();
  353.         }
  354.         try{
  355.             msg = "Attributo 'MaxLifeSecond' (ResponseCaching) impostato al valore: "+longItemLife;
  356.             alog.info(msg);
  357.             cache.setItemLifeTime(longItemLife);
  358.         }catch(Exception error){
  359.             msg = "Parametro errato per l'attributo 'MaxLifeSecond' (ResponseCaching): "+error.getMessage();
  360.             alog.error(msg);
  361.             throw new Exception(msg,error);
  362.         }
  363.         
  364.         cache.build();
  365.     }
  366.     
  367.     @SuppressWarnings("deprecation")
  368.     @Deprecated
  369.     public static void disableSyncronizedGet() throws UtilsException {
  370.         if(GestoreLoadBalancerCaching.cache==null) {
  371.             throw new UtilsException("Cache disabled");
  372.         }
  373.         GestoreLoadBalancerCaching.cache.disableSyncronizedGet();
  374.     }
  375.     @SuppressWarnings("deprecation")
  376.     @Deprecated
  377.     public static boolean isDisableSyncronizedGet() throws UtilsException {
  378.         if(GestoreLoadBalancerCaching.cache==null) {
  379.             throw new UtilsException("Cache disabled");
  380.         }
  381.         return GestoreLoadBalancerCaching.cache.isDisableSyncronizedGet();
  382.     }
  383.     
  384.     

  386.     
  387.     
  388.     private static GestoreLoadBalancerCaching staticInstance = null;
  389.     public static synchronized void initialize() {
  390.         if(staticInstance==null){
  391.             staticInstance = new GestoreLoadBalancerCaching();
  392.         }
  393.     }
  394.     public static GestoreLoadBalancerCaching getInstance() throws CoreException{
  395.         if(staticInstance==null){
  396.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  397.             synchronized (GestoreLoadBalancerCaching.class) {
  398.                 throw new CoreException("GestoreKeystore non inizializzato");
  399.             }
  400.         }
  401.         return staticInstance;
  402.     }
  403.     
  404.     @SuppressWarnings("unused")
  405.     private Logger log;
  406.     
  407.     private GestoreLoadBalancerCaching() {
  408.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  409.     }
  410.     
  411.     
  412.     
  413.     
  414.     
  415.     
  416.     
  417.     
  418.     
  419.     /* ********************** ENGINE ************************** */
  420.     
  421.     public static LoadBalancerInstance getLoadBalancerInstance(PortaApplicativa pa, OpenSPCoop2Message message, Busta busta, 
  422.             RequestInfo requestInfo, PdDContext pddContext, 
  423.             MsgDiagnostico msgDiag, Logger log,
  424.             LoadBalancerType loadBalancerType, IState state) throws BehaviourException, BehaviourEmitDiagnosticException{
  425.         
  426.         LoadBalancerInstance instance = new LoadBalancerInstance();
  427.         
  428.         ConditionalFilterResult filterResult = 
  429.                 ConditionalUtils.filter(pa, message, busta, requestInfo, pddContext, msgDiag, log, 
  430.                         TipoBehaviour.CONSEGNA_LOAD_BALANCE, state);
  431.         
  432.         String keyCache = getKeyCache(pa, message, busta, 
  433.                 requestInfo, pddContext, 
  434.                 msgDiag, log,
  435.                 filterResult);
  436.         
  437.         String keyCacheLoadBalancerPool = "[POOL] "+keyCache;
  438.         instance.setLoadBalancerPool(getLoadBalancerPool(pa, message, busta, 
  439.                 requestInfo, pddContext, 
  440.                 msgDiag, log, 
  441.                 keyCacheLoadBalancerPool, filterResult));
  442.         
  443.         StickyResult stickyResult = null;
  444.         if(LoadBalancerType.IP_HASH.equals(loadBalancerType)) {
  445.             String clientIp = LoadBalancer.getIpSourceFromContet(pddContext);
  446.             stickyResult = new StickyResult();
  447.             stickyResult.setCondition(clientIp);
  448.             stickyResult.setFound(true);
  449.         }
  450.         else {
  451.             stickyResult = getStickyInfo(pa, message, busta, 
  452.                     requestInfo, pddContext, 
  453.                     msgDiag, log,
  454.                     state);
  455.         }
  456.         
  457.         if(stickyResult!=null && stickyResult.isFound()) {
  458.             String keyCacheSticky = "[STICKY '"+stickyResult.getCondition()+"'] "+keyCache;
  459.             instance.setConnectorSelected(getNomeConnettore(pa, message, busta, 
  460.                     requestInfo, pddContext, 
  461.                     msgDiag, log, 
  462.                     keyCacheSticky, instance.getLoadBalancerPool(), loadBalancerType, stickyResult));
  463.         }
  464.         
  465.         if(instance.getConnectorSelected()==null) {
  466.             instance.setConnectorSelected(selectConnector(loadBalancerType, instance.getLoadBalancerPool(), pddContext));
  467.         }
  468.         
  469.         return instance;
  470.     }
  471.     
  472.     private static StickyResult getStickyInfo(PortaApplicativa pa, OpenSPCoop2Message message, Busta busta, 
  473.             RequestInfo requestInfo, PdDContext pddContext, 
  474.             MsgDiagnostico msgDiag, Logger log,
  475.             IState state) throws BehaviourException, BehaviourEmitDiagnosticException{
  476.         
  477.         if(StickyUtils.isConfigurazioneSticky(pa, log)) {
  478.             return StickyUtils.getStickyResult(pa, message, busta, requestInfo, pddContext, msgDiag, log, state);
  479.         }
  480.         
  481.         return null;
  482.         
  483.     }
  484.     
  485.     protected static String _toKey_getKeyCacheNomePorta(String nomePorta) {
  486.         return " pa:"+nomePorta+" ";
  487.     }
  488.     
  489.     private static String getKeyCache(PortaApplicativa pa, OpenSPCoop2Message message, Busta busta, 
  490.             RequestInfo requestInfo, PdDContext pddContext, 
  491.             MsgDiagnostico msgDiag, Logger log,
  492.             ConditionalFilterResult filterResult) throws BehaviourException, BehaviourEmitDiagnosticException {
  493.         
  494.         String keyCache = "["+pa.getBehaviour().getNome()+"] "+pa.getTipoSoggettoProprietario()+"/"+pa.getNomeSoggettoProprietario()+
  495.                 _toKey_getKeyCacheNomePorta(pa.getNome());
  496.         if(filterResult!=null) {
  497.             if(filterResult.isByFilter()) {
  498.                 keyCache = keyCache +" [Conditional-By-Filter] ";
  499.             }
  500.             else {
  501.                 keyCache = keyCache +" [Conditional-By-Name] ";
  502.             }
  503.             if(filterResult.getRegola()!=null) {
  504.                 keyCache = keyCache +"[Regola "+filterResult.getRegola()+"] ";
  505.             }
  506.             if(filterResult.getCondition()!=null) {
  507.                 keyCache = keyCache +" "+filterResult.getCondition();
  508.             }
  509.         }
  510.         
  511.         return keyCache;
  512.         
  513.     }
  514.     
  515.     private static LoadBalancerPool getLoadBalancerPool(PortaApplicativa pa, OpenSPCoop2Message message, Busta busta, 
  516.             RequestInfo requestInfo, PdDContext pddContext, 
  517.             MsgDiagnostico msgDiag, Logger log,
  518.             String keyCache, ConditionalFilterResult filterResult) throws BehaviourException, BehaviourEmitDiagnosticException{
  519.         
  520.         if(GestoreLoadBalancerCaching.cache==null){
  521.             throw new BehaviourException("La funzionalità di Load Balancer richiede che sia abilitata la cache dedicata alla funzionalità");
  522.         }
  523.         else{
  524.             
  525.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  526.             org.openspcoop2.utils.cache.CacheResponse response = 
  527.                 (org.openspcoop2.utils.cache.CacheResponse) GestoreLoadBalancerCaching.cache.get(keyCache);
  528.             if(response != null){
  529.                 if(response.getObject()!=null){
  530.                     log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:getLoadBalancerPool) in cache.");
  531.                     return (LoadBalancerPool) response.getObject();
  532.                 }else if(response.getException()!=null){
  533.                     log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:getLoadBalancerPool) in cache.");
  534.                     throw new BehaviourException( (Exception) response.getException() );
  535.                 }else{
  536.                     log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  537.                 }
  538.             }
  539.             
  540.             String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  541.             //synchronized (GestoreLoadBalancerCaching.cache) {
  542.             SemaphoreLock lock = GestoreLoadBalancerCaching.lock.acquireThrowRuntime("getLoadBalancerPool", idTransazione);
  543.             try {
  544.                 
  545.                 response = 
  546.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreLoadBalancerCaching.cache.get(keyCache);
  547.                 if(response != null){
  548.                     if(response.getObject()!=null){
  549.                         log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:getLoadBalancerPool) in cache.");
  550.                         return (LoadBalancerPool) response.getObject();
  551.                     }else if(response.getException()!=null){
  552.                         log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:getLoadBalancerPool) in cache.");
  553.                         throw new BehaviourException( (Exception) response.getException() );
  554.                     }else{
  555.                         log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  556.                     }
  557.                 }

  559.                 // Effettuo la query
  560.                 log.debug("oggetto con chiave ["+keyCache+"] (method:getLoadBalancerPool) ricerco nella configurazione...");
  561.                 LoadBalancerPool lbPool = readLoadBalancerPool(log, pa, filterResult);
  562.                 
  563.                 // Aggiungo la risposta in cache (se esiste una cache)  
  564.                 // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  565.                 // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  566.                 // - impostare il noCache a true
  567.                 if(lbPool!=null){
  568.                     log.info("Aggiungo oggetto ["+keyCache+"] in cache");
  569.                     try{    
  570.                         org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  571.                         responseCache.setObject(lbPool);
  572.                         GestoreLoadBalancerCaching.cache.put(keyCache,responseCache);
  573.                     }catch(UtilsException e){
  574.                         log.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  575.                     }
  576.                     return lbPool;
  577.                 }else{
  578.                     throw new BehaviourException("Metodo (getLoadBalancerPool) non è riuscito a costruire un pool");
  579.                 }
  580.             }finally {
  581.                 GestoreLoadBalancerCaching.lock.release(lock, "getLoadBalancerPool", idTransazione);
  582.             }
  583.         }
  584.         
  585.     }
  586.     
  587.     
  588.     private static LoadBalancerPool readLoadBalancerPool(Logger log, PortaApplicativa pa, ConditionalFilterResult filterResult) throws BehaviourException {
  589.         
  590.         List<PortaApplicativaServizioApplicativo> listSA = null;
  591.         if(filterResult==null) {
  592.             listSA = pa.getServizioApplicativoList();
  593.         }
  594.         else {
  595.             listSA = filterResult.getListServiziApplicativi();
  596.         }
  597.         
  598.         LoadBalancerPool pool = new LoadBalancerPool(HealthCheckUtils.read(pa, log));
  599.         if(!listSA.isEmpty()) {
  600.             for (PortaApplicativaServizioApplicativo servizioApplicativo : listSA) {
  601.                 if(servizioApplicativo.getDatiConnettore()==null || servizioApplicativo.getDatiConnettore().getStato()==null || 
  602.                         StatoFunzionalita.ABILITATO.equals(servizioApplicativo.getDatiConnettore().getStato())) {
  603.                     int weight = -1;
  604.                     if(servizioApplicativo.getDatiConnettore()!=null && servizioApplicativo.getDatiConnettore().sizeProprietaList()>0) {
  605.                         String weightDefined = null;
  606.                         for (Proprieta p : servizioApplicativo.getDatiConnettore().getProprietaList()) {
  607.                             if(Costanti.LOAD_BALANCER_WEIGHT.equals(p.getNome())) {
  608.                                 weightDefined = p.getValore();
  609.                             }
  610.                         }
  611.                         if(weightDefined!=null) {
  612.                             try {
  613.                                 weight = Integer.valueOf(weightDefined);
  614.                             }catch(Exception e) {}
  615.                         }
  616.                     }
  617.                     String nomeConnettore = null;
  618.                     if(servizioApplicativo.getDatiConnettore()!=null) {
  619.                         nomeConnettore = servizioApplicativo.getDatiConnettore().getNome();
  620.                     }
  621.                     if(nomeConnettore==null) {
  622.                         nomeConnettore = org.openspcoop2.pdd.core.behaviour.built_in.Costanti.NOME_CONNETTORE_DEFAULT;
  623.                     }
  624.                     if(weight>0) {
  625.                         pool.addConnector(nomeConnettore, weight);
  626.                     }
  627.                     else {
  628.                         pool.addConnector(nomeConnettore);
  629.                     }
  630.                 }
  631.             }
  632.         }
  633.         
  634.         return pool;
  635.     }
  636.     
  637.     private static String getNomeConnettore(PortaApplicativa pa, OpenSPCoop2Message message, Busta busta, 
  638.             RequestInfo requestInfo, PdDContext pddContext, 
  639.             MsgDiagnostico msgDiag, Logger log,
  640.             String keyCache, LoadBalancerPool loadBalancerPool, LoadBalancerType loadBalancerType, StickyResult stickyResult) throws BehaviourException, BehaviourEmitDiagnosticException{
  641.         
  642.         if(GestoreLoadBalancerCaching.cache==null){
  643.             throw new BehaviourException("La funzionalità di Load Balancer richiede che sia abilitata la cache dedicata alla funzionalità");
  644.         }
  645.         else{
  646.             
  647.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  648.             
  649.             org.openspcoop2.utils.cache.CacheResponse response = 
  650.                 (org.openspcoop2.utils.cache.CacheResponse) GestoreLoadBalancerCaching.cache.get(keyCache);
  651.             if(response != null){
  652.                 if(response.getObject()!=null){
  653.                     log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:getLoadBalancerPool) in cache.");
  654.                     
  655.                     StickyConnector stickyConnector = (StickyConnector) response.getObject();
  656.                     if(stickyConnector.getExpirationDate()!=null) {
  657.                         Date now = DateManager.getDate();
  658.                         if(stickyConnector.getExpirationDate().after(now)){
  659.                             String c = stickyConnector.getConnector();
  660.                             if(loadBalancerPool.getConnectorNames(true).contains(c)) {
  661.                                 return c;
  662.                             }
  663.                             else {
  664.                                 // eseguo operazione in synchronized mode
  665.                             }
  666.                         }
  667.                         else {
  668.                             // eseguo operazione in synchronized mode
  669.                         }
  670.                     }
  671.                     else {
  672.                         String c = stickyConnector.getConnector();
  673.                         if(loadBalancerPool.getConnectorNames(true).contains(c)) {
  674.                             return c;
  675.                         }
  676.                         else {
  677.                             // eseguo operazione in synchronized mode
  678.                         }
  679.                     }
  680.                     
  681.                 }else if(response.getException()!=null){
  682.                     log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:getLoadBalancerPool) in cache.");
  683.                     throw new BehaviourException( (Exception) response.getException() );
  684.                 }else{
  685.                     log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  686.                 }
  687.             }
  688.             
  689.             String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  690.             //synchronized (GestoreLoadBalancerCaching.cache) {
  691.             SemaphoreLock lock = GestoreLoadBalancerCaching.lock.acquireThrowRuntime("getNomeConnettore", idTransazione);
  692.             try {
  693.                 
  694.                 response = 
  695.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreLoadBalancerCaching.cache.get(keyCache);
  696.                 if(response != null){
  697.                     if(response.getObject()!=null){
  698.                         log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:getLoadBalancerPool) in cache.");
  699.                         
  700.                         StickyConnector stickyConnector = (StickyConnector) response.getObject();
  701.                         if(stickyConnector.getExpirationDate()!=null) {
  702.                             Date now = DateManager.getDate();
  703.                             if(stickyConnector.getExpirationDate().after(now)){
  704.                                 String c = stickyConnector.getConnector();
  705.                                 if(loadBalancerPool.getConnectorNames(true).contains(c)) {
  706.                                     return c;
  707.                                 }
  708.                                 else {
  709.                                     String msg = "Connettore '"+stickyConnector.getConnector()+"' per sticky '"+stickyResult.getCondition()+"' non risulta più valido dopo il passive health check";
  710.                                     log.debug(msg);
  711.                                     try {
  712.                                         GestoreLoadBalancerCaching.cache.remove(keyCache);
  713.                                     }catch(Exception e) {
  714.                                         throw new BehaviourException(msg+". Rimozione dalla cache non riuscita: "+e.getMessage(),e);
  715.                                     }
  716.                                 }
  717.                             }
  718.                             else {
  719.                                 String msg = "Connettore '"+stickyConnector.getConnector()+"' scaduto per sticky '"+stickyResult.getCondition()+"' in data "+
  720.                                         DateUtils.getSimpleDateFormatMs().format(stickyConnector.getExpirationDate())+"";
  721.                                 log.debug(msg);
  722.                                 try {
  723.                                     GestoreLoadBalancerCaching.cache.remove(keyCache);
  724.                                 }catch(Exception e) {
  725.                                     throw new BehaviourException(msg+". Rimozione dalla cache non riuscita: "+e.getMessage(),e);
  726.                                 }
  727.                             }
  728.                         }
  729.                         else {
  730.                             String c = stickyConnector.getConnector();
  731.                             if(loadBalancerPool.getConnectorNames(true).contains(c)) {
  732.                                 return c;
  733.                             }
  734.                             else {
  735.                                 String msg = "Connettore '"+stickyConnector.getConnector()+"' per sticky '"+stickyResult.getCondition()+"' non risulta più valido dopo il passive health check";
  736.                                 log.debug(msg);
  737.                                 try {
  738.                                     GestoreLoadBalancerCaching.cache.remove(keyCache);
  739.                                 }catch(Exception e) {
  740.                                     throw new BehaviourException(msg+". Rimozione dalla cache non riuscita: "+e.getMessage(),e);
  741.                                 }
  742.                             }
  743.                         }
  744.                         
  745.                     }else if(response.getException()!=null){
  746.                         log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:getLoadBalancerPool) in cache.");
  747.                         throw new BehaviourException( (Exception) response.getException() );
  748.                     }else{
  749.                         log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  750.                     }
  751.                 }

  753.                 // Effettuo la query
  754.                 log.debug("oggetto con chiave ["+keyCache+"] (method:getNomeConnettore) ricerco nella configurazione...");
  755.                 String selectedConnector = selectConnector(loadBalancerType, loadBalancerPool, pddContext);
  756.                 if(selectedConnector==null) {
  757.                     throw new BehaviourException("Metodo (getNomeConnettore) non è riuscito a selezionare un connettore");
  758.                 }
  759.                 StickyConnector stickyConnector = new StickyConnector();
  760.                 stickyConnector.setConnector(selectedConnector);
  761.                 if(stickyResult.getMaxAgeSeconds()!=null && stickyResult.getMaxAgeSeconds().intValue()>0) {
  762.                     Date expire = new Date((DateManager.getTimeMillis() + (1000*stickyResult.getMaxAgeSeconds().intValue())));
  763.                     stickyConnector.setExpirationDate(expire);
  764.                 }
  765.                 
  766.                 // Aggiungo la risposta in cache (se esiste una cache)  
  767.                 // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  768.                 // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  769.                 // - impostare il noCache a true
  770.                 log.info("Aggiungo oggetto ["+keyCache+"] in cache");
  771.                 try{    
  772.                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  773.                     responseCache.setObject(stickyConnector);
  774.                     GestoreLoadBalancerCaching.cache.put(keyCache,responseCache);
  775.                 }catch(UtilsException e){
  776.                     log.error("Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage());
  777.                 }
  778.                 return stickyConnector.getConnector();

  780.             }finally {
  781.                 GestoreLoadBalancerCaching.lock.release(lock, "getNomeConnettore", idTransazione);
  782.             }
  783.         }
  784.         
  785.     }

  787.     private static String selectConnector(LoadBalancerType loadBalancerType, LoadBalancerPool pool, PdDContext pddContext) throws BehaviourException {
  788.         LoadBalancer lb = new LoadBalancer(loadBalancerType, pool, pddContext);
  789.         String nomeConnettore = lb.selectConnector();
  790.         if(nomeConnettore==null) {
  791.             throw new BehaviourException("Nessun connettore selezionato");
  792.         }
  793.         return nomeConnettore;
  794.     }
  795. }
Created with JaCoCo 0.8.8.202204050719