GestoreRichieste.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.pdd.core;

  23. import java.util.ArrayList;
  24. import java.util.HashMap;
  25. import java.util.List;
  26. import java.util.Map;

  28. import org.openspcoop2.core.commons.CoreException;
  29. import org.openspcoop2.core.config.ServizioApplicativo;
  30. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  31. import org.openspcoop2.core.constants.TipoPdD;
  32. import org.openspcoop2.core.id.IDAccordo;
  33. import org.openspcoop2.core.id.IDConnettore;
  34. import org.openspcoop2.core.id.IDGenericProperties;
  35. import org.openspcoop2.core.id.IDPortaApplicativa;
  36. import org.openspcoop2.core.id.IDPortaDelegata;
  37. import org.openspcoop2.core.id.IDRuolo;
  38. import org.openspcoop2.core.id.IDScope;
  39. import org.openspcoop2.core.id.IDServizio;
  40. import org.openspcoop2.core.id.IDServizioApplicativo;
  41. import org.openspcoop2.core.id.IDSoggetto;
  42. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  43. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  44. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  45. import org.openspcoop2.message.constants.ServiceBinding;
  46. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  47. import org.openspcoop2.pdd.config.ConfigurazionePdD;
  48. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  49. import org.openspcoop2.protocol.sdk.state.RequestConfig;
  50. import org.openspcoop2.protocol.sdk.state.RequestFruitore;
  51. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  52. import org.openspcoop2.protocol.sdk.state.RequestRateLimitingConfig;
  53. import org.openspcoop2.protocol.sdk.state.RequestThreadContext;
  54. import org.openspcoop2.utils.SemaphoreLock;
  55. import org.openspcoop2.utils.UtilsException;
  56. import org.openspcoop2.utils.cache.Cache;
  57. import org.openspcoop2.utils.cache.CacheAlgorithm;
  58. import org.openspcoop2.utils.cache.CacheResponse;
  59. import org.openspcoop2.utils.cache.CacheType;
  60. import org.openspcoop2.utils.cache.Constants;
  61. import org.openspcoop2.utils.certificate.CertificateInfo;
  62. import org.openspcoop2.utils.transport.http.HttpConstants;
  63. import org.slf4j.Logger;

  65. /**
  66.  * GestoreRichieste
  67.  *
  68.  * @author Andrea Poli (apoli@link.it)
  69.  * @author $Author$
  70.  * @version $Rev$, $Date$
  71.  */
  72. public class GestoreRichieste {

  74.     private GestoreRichieste() {}
  75.     
  76.     private static boolean useCache = true;
  77.     public static boolean isUseCache() {
  78.         return useCache;
  79.     }
  80.     public static void setUseCache(boolean useCache) {
  81.         GestoreRichieste.useCache = useCache;
  82.     }

  84.     /** Chiave della cache per il Gestore delle Richieste  */
  85.     public static final String GESTORE_RICHIESTE_PREFIX_CACHE_NAME = "gestoreRichieste-";
  86.     private static final String GESTORE_RICHIESTE_API_CACHE_NAME = GESTORE_RICHIESTE_PREFIX_CACHE_NAME+"API";
  87.     private static final String GESTORE_RICHIESTE_RATE_LIMITING_CACHE_NAME = GESTORE_RICHIESTE_PREFIX_CACHE_NAME+"RateLimiting";
  88.     private static final String GESTORE_RICHIESTE_FRUITORI_CACHE_NAME = GESTORE_RICHIESTE_PREFIX_CACHE_NAME+"Fruitori";
  89.     
  90.     private static Cache cacheApi = null;
  91.     private static Cache cacheRateLimiting = null;
  92.     private static Cache cacheFruitori = null;
  93.     private static Map<String, Cache> caches = null;
  94.     private static List<String> cacheKeys = null;
  95.     private static synchronized void initCacheKeys() {
  96.         if(cacheKeys==null) {
  97.             cacheKeys = new ArrayList<>();
  98.             cacheKeys.add(GESTORE_RICHIESTE_API_CACHE_NAME);
  99.             cacheKeys.add(GESTORE_RICHIESTE_RATE_LIMITING_CACHE_NAME);
  100.             cacheKeys.add(GESTORE_RICHIESTE_FRUITORI_CACHE_NAME);
  101.         }
  102.     }
  103.     
  104.     private static final org.openspcoop2.utils.Semaphore lockCache = new org.openspcoop2.utils.Semaphore(GESTORE_RICHIESTE_API_CACHE_NAME);
  105.     private static final org.openspcoop2.utils.Semaphore lockCache_rateLimiting = new org.openspcoop2.utils.Semaphore(GESTORE_RICHIESTE_RATE_LIMITING_CACHE_NAME);
  106.     private static final org.openspcoop2.utils.Semaphore lockCache_fruitori = new org.openspcoop2.utils.Semaphore(GESTORE_RICHIESTE_FRUITORI_CACHE_NAME);
  107.     
  108.     /** Logger log */
  109.     private static Logger logger = null;
  110.     private static Logger logConsole = OpenSPCoop2Logger.getLoggerOpenSPCoopConsole();
  111.     
  112.     
  113.     /* --------------- Cache --------------------*/
  114.     public static void resetCache() throws CoreException{
  115.         if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  116.             try{
  117.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  118.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  119.                     if(cache!=null) {
  120.                         cache.clear();
  121.                     }
  122.                 }
  123.             }catch(Exception e){
  124.                 throw new CoreException(e.getMessage(),e);
  125.             }
  126.         }
  127.     }
  128.     public static String printStatsCache(String separator) throws CoreException{
  129.         try{
  130.             if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  131.                 StringBuilder sb = new StringBuilder();
  132.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  133.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  134.                     if(cache!=null) {
  135.                         if(sb.length()>0) {
  136.                             sb.append(separator);
  137.                         }
  138.                         /** String funzione = cacheKey.substring(cacheKey.indexOf("-")+1, cacheKey.length());
  139.                         sb.append(funzione).append(separator); */
  140.                         sb.append(cache.printStats(separator));
  141.                     }
  142.                 }
  143.                 return sb.toString();
  144.             }
  145.             else{
  146.                 throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  147.             }
  148.         }catch(Exception e){
  149.             throw new CoreException("Visualizzazione Statistiche riguardante la cache dei dati di gestione delle richieste non riuscita: "+e.getMessage(),e);
  150.         }
  151.     }
  152.     public static void abilitaCache() throws CoreException{
  153.         if(GestoreRichieste.cacheKeys!=null)
  154.             throw new CoreException("Cache gia' abilitata");
  155.         else{
  156.             try{
  157.                 initCacheKeys();
  158.                 GestoreRichieste.cacheApi = new Cache(CacheType.JCS, GESTORE_RICHIESTE_API_CACHE_NAME); // lascio JCS come default abilitato via jmx
  159.                 GestoreRichieste.cacheRateLimiting = new Cache(CacheType.JCS, GESTORE_RICHIESTE_RATE_LIMITING_CACHE_NAME); // lascio JCS come default abilitato via jmx
  160.                 GestoreRichieste.cacheFruitori = new Cache(CacheType.JCS, GESTORE_RICHIESTE_FRUITORI_CACHE_NAME); // lascio JCS come default abilitato via jmx
  161.                 
  162.                 GestoreRichieste.cacheApi.build();
  163.                 GestoreRichieste.cacheRateLimiting.build();
  164.                 GestoreRichieste.cacheFruitori.build();
  165.                 
  166.                 GestoreRichieste.caches = new HashMap<>();
  167.                 GestoreRichieste.caches.put(GESTORE_RICHIESTE_API_CACHE_NAME, GestoreRichieste.cacheApi);
  168.                 GestoreRichieste.caches.put(GESTORE_RICHIESTE_RATE_LIMITING_CACHE_NAME, GestoreRichieste.cacheRateLimiting);
  169.                 GestoreRichieste.caches.put(GESTORE_RICHIESTE_FRUITORI_CACHE_NAME, GestoreRichieste.cacheFruitori);
  170.             }catch(Exception e){
  171.                 throw new CoreException(e.getMessage(),e);
  172.             }
  173.         }
  174.     }
  175.     public static void abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond) throws CoreException{
  176.         if(GestoreRichieste.cacheKeys!=null)
  177.             throw new CoreException("Cache già abilitata");
  178.         else{
  179.             try{
  180.                 int dimensioneCacheInt = -1;
  181.                 if(dimensioneCache!=null){
  182.                     dimensioneCacheInt = dimensioneCache.intValue();
  183.                 }
  184.                 
  185.                 String algoritmoCache = null;
  186.                 if(algoritmoCacheLRU!=null){
  187.                     if(algoritmoCacheLRU)
  188.                          algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString();
  189.                     else
  190.                          algoritmoCache = CostantiConfigurazione.CACHE_MRU.toString();
  191.                 }else{
  192.                     algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString();
  193.                 }
  194.                 
  195.                 long itemIdleTimeLong = -1;
  196.                 if(itemIdleTime!=null){
  197.                     itemIdleTimeLong = itemIdleTime;
  198.                 }
  199.                 
  200.                 long itemLifeSecondLong = -1;
  201.                 if(itemLifeSecond!=null){
  202.                     itemLifeSecondLong = itemLifeSecond;
  203.                 }
  204.                 
  205.                 GestoreRichieste.initCacheGestoreRichieste(CacheType.JCS, dimensioneCacheInt, algoritmoCache, itemIdleTimeLong, itemLifeSecondLong, null); // lascio JCS come default abilitato via jmx
  206.             }catch(Exception e){
  207.                 throw new CoreException(e.getMessage(),e);
  208.             }
  209.         }
  210.     }
  211.     public static void disabilitaCache() throws CoreException{
  212.         if(GestoreRichieste.cacheKeys==null)
  213.             throw new CoreException("Cache già disabilitata");
  214.         else{
  215.             disabilitaCacheEngine();
  216.         }
  217.     }
  218.     private static synchronized void disabilitaCacheEngine() throws CoreException{
  219.         if(GestoreRichieste.cacheKeys!=null) {
  220.             try{
  221.                 GestoreRichieste.cacheApi.clear();
  222.                 GestoreRichieste.cacheApi = null;
  223.                 
  224.                 GestoreRichieste.cacheRateLimiting.clear();
  225.                 GestoreRichieste.cacheRateLimiting = null;
  226.                 
  227.                 GestoreRichieste.cacheFruitori.clear();
  228.                 GestoreRichieste.cacheFruitori = null;
  229.                 
  230.                 GestoreRichieste.caches.clear();
  231.                 GestoreRichieste.caches = null;
  232.                 
  233.                 GestoreRichieste.cacheKeys.clear();
  234.                 GestoreRichieste.cacheKeys = null;
  235.             }catch(Exception e){
  236.                 throw new CoreException(e.getMessage(),e);
  237.             }
  238.         }
  239.     }
  240.     public static boolean isCacheAbilitata(){
  241.         return GestoreRichieste.cacheKeys != null;
  242.     }
  243.     public static String listKeysCache(String separator) throws CoreException{
  244.         if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  245.             StringBuilder sb = new StringBuilder();
  246.             for (String cacheKey : GestoreRichieste.cacheKeys) {
  247.                 Cache cache = GestoreRichieste.caches.get(cacheKey);
  248.                 if(cache!=null) {
  249.                     if(sb.length()>0) {
  250.                         sb.append(separator);
  251.                     }
  252.                     try{
  253.                         String nomeCache = cacheKey;
  254.                         if(nomeCache.startsWith(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME)) {
  255.                             nomeCache = nomeCache.substring(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME.length());
  256.                         }
  257.                         sb.append( cache.printKeys(separator).replaceFirst(Constants.MSG_CACHE,Constants.MSG_CACHE_PREFIX+nomeCache ) );
  258.                     }catch(Exception e){
  259.                         throw new CoreException(e.getMessage(),e);
  260.                     }
  261.                 }
  262.             }
  263.             return sb.toString();
  264.         }else{
  265.             throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  266.         }
  267.     }
  268.     /**
  269.      * non viene gestito correttamente la chiave rispetto alla cache, potrebbe essere presente la solita chiave
  270.      */
  271.     @Deprecated
  272.     public static List<String> listKeysCache() throws CoreException{
  273.         if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  274.             List<String> keys = new ArrayList<>();
  275.             for (String cacheKey : GestoreRichieste.cacheKeys) {
  276.                 Cache cache = GestoreRichieste.caches.get(cacheKey);
  277.                 if(cache!=null) {
  278.                     try{
  279.                         List<String> k = cache.keys();
  280.                         if(k!=null && !k.isEmpty()) {
  281.                             keys.addAll(k);
  282.                         }
  283.                     }catch(Exception e){
  284.                         throw new CoreException(e.getMessage(),e);
  285.                     }
  286.                 }
  287.             }
  288.             return keys;
  289.         }else{
  290.             throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  291.         }
  292.     }
  293.     public static String getObjectCache(String key) throws CoreException{
  294.         if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  295.             try{
  296.                 Object o = null;
  297.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  298.                     
  299.                     // trucco per avere il valore di una precisa cache              
  300.                     if(key.startsWith(Constants.MSG_CACHE_PREFIX)) {
  301.                         
  302.                         String nomeCache = cacheKey;
  303.                         if(nomeCache.startsWith(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME)) {
  304.                             nomeCache = nomeCache.substring(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME.length());
  305.                         }
  306.                         nomeCache = Constants.MSG_CACHE_PREFIX+nomeCache+" ";
  307.                         
  308.                         if(!key.startsWith(nomeCache)) {
  309.                             continue; // cerco in altra cache
  310.                         }
  311.                         else {
  312.                             key = key.substring(nomeCache.length());
  313.                         }
  314.                     }
  315.                     
  316.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  317.                     if(cache!=null) {
  318.                         o = cache.get(key);
  319.                         if(o!=null) {
  320.                             break;
  321.                         }
  322.                     }
  323.                 }
  324.                 if(o!=null){
  325.                     return o.toString();
  326.                 }else{
  327.                     return "oggetto con chiave ["+key+"] non presente";
  328.                 }
  329.             }catch(Exception e){
  330.                 throw new CoreException(e.getMessage(),e);
  331.             }
  332.         }else{
  333.             throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  334.         }
  335.     }
  336.     public static Object getRawObjectCache(String key) throws CoreException{
  337.         if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  338.             try{
  339.                 Object o = null;
  340.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  341.                     
  342.                     // trucco per avere il valore di una precisa cache      
  343.                     if(key.startsWith(Constants.MSG_CACHE_PREFIX)) {
  344.                         
  345.                         String nomeCache = cacheKey;
  346.                         if(nomeCache.startsWith(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME)) {
  347.                             nomeCache = nomeCache.substring(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME.length());
  348.                         }
  349.                         nomeCache = Constants.MSG_CACHE_PREFIX+nomeCache+" ";
  350.                         
  351.                         if(!key.startsWith(nomeCache)) {
  352.                             continue; // cerco in altra cache
  353.                         }
  354.                         else {
  355.                             key = key.substring(nomeCache.length());
  356.                         }
  357.                     }
  358.                     
  359.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  360.                     if(cache!=null) {
  361.                         o = cache.get(key);
  362.                         if(o!=null) {
  363.                             break;
  364.                         }
  365.                     }
  366.                 }
  367.                 return getRawObjectCacheEngine(o);
  368.             }catch(Exception e){
  369.                 throw new CoreException(e.getMessage(),e);
  370.             }
  371.         }else{
  372.             throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  373.         }
  374.     }
  375.     public static Object getRawObjectCacheEngine(Object o) throws CoreException{
  376.         if(o!=null){
  377.             if(o instanceof CacheResponse) {
  378.                 CacheResponse cR = (CacheResponse) o;
  379.                 if(cR.getObject()!=null) {
  380.                     o = cR.getObject();
  381.                 }
  382.                 else if(cR.getException()!=null) {
  383.                     o = cR.getException();
  384.                 }
  385.             }
  386.             return o;
  387.         }else{
  388.             return null;
  389.         }
  390.     }
  391.     public static void removeObjectCache(String key) throws CoreException{
  392.         if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  393.             try{
  394.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  395.                     
  396.                     // trucco per avere il valore di una precisa cache      
  397.                     if(key.startsWith(Constants.MSG_CACHE_PREFIX)) {
  398.                         
  399.                         String nomeCache = cacheKey;
  400.                         if(nomeCache.startsWith(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME)) {
  401.                             nomeCache = nomeCache.substring(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME.length());
  402.                         }
  403.                         nomeCache = Constants.MSG_CACHE_PREFIX+nomeCache+" ";
  404.                         
  405.                         if(!key.startsWith(nomeCache)) {
  406.                             continue; // cerco in altra cache
  407.                         }
  408.                         else {
  409.                             key = key.substring(nomeCache.length());
  410.                         }
  411.                     }
  412.                     
  413.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  414.                     if(cache!=null) {
  415.                         cache.remove(key);
  416.                     }
  417.                 }
  418.             }catch(Exception e){
  419.                 throw new CoreException(e.getMessage(),e);
  420.             }
  421.         }else{
  422.             throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  423.         }
  424.     }
  425.     


  428.     /*----------------- INIZIALIZZAZIONE --------------------*/
  429.     public static void initialize(Logger log) throws Exception{
  430.         GestoreRichieste.initialize(null, false, -1,null,-1l,-1l, log);
  431.     }
  432.     public static void initialize(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  433.             long idleTime, long itemLifeSecond, Logger log) throws Exception{
  434.         GestoreRichieste.initialize(cacheType, true, dimensioneCache,algoritmoCache,idleTime,itemLifeSecond, log);
  435.     }

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

  440.         // Inizializzo log
  441.         GestoreRichieste.logger = log;
  442.         
  443.         // Inizializzazione Cache
  444.         if(cacheAbilitata){
  445.             GestoreRichieste.initCacheGestoreRichieste(cacheType, dimensioneCache, algoritmoCache, idleTime, itemLifeSecond, log);
  446.         }

  448.     }


  451.     public static void initCacheGestoreRichieste(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  452.             long idleTime, long itemLifeSecond, Logger log) throws UtilsException, CoreException {
  453.         
  454.         if(log!=null)
  455.             log.info("Inizializzazione cache GestoreRichieste");

  457.         initCacheKeys();
  458.         
  459.         GestoreRichieste.cacheApi = new Cache(cacheType, GESTORE_RICHIESTE_API_CACHE_NAME); 
  460.         GestoreRichieste.cacheRateLimiting = new Cache(cacheType, GESTORE_RICHIESTE_RATE_LIMITING_CACHE_NAME);
  461.         GestoreRichieste.cacheFruitori = new Cache(cacheType, GESTORE_RICHIESTE_FRUITORI_CACHE_NAME); 
  462.         
  463.         GestoreRichieste.caches = new HashMap<>();
  464.         GestoreRichieste.caches.put(GESTORE_RICHIESTE_API_CACHE_NAME, GestoreRichieste.cacheApi);
  465.         GestoreRichieste.caches.put(GESTORE_RICHIESTE_RATE_LIMITING_CACHE_NAME, GestoreRichieste.cacheRateLimiting);
  466.         GestoreRichieste.caches.put(GESTORE_RICHIESTE_FRUITORI_CACHE_NAME, GestoreRichieste.cacheFruitori);
  467.         
  468.         if( (dimensioneCache>0) ||
  469.                 (algoritmoCache != null) ){

  471.             if( dimensioneCache>0 ){
  472.                 try{
  473.                     // divido per il numero di cache interne
  474.                     int dimensioneCacheInterna = dimensioneCache / GestoreRichieste.cacheKeys.size();
  475.                     
  476.                     String msg = "Dimensione della cache (GestoreRichieste) impostata al valore: "+dimensioneCache+" ("+GestoreRichieste.cacheKeys.size()+" cache interne di "+dimensioneCacheInterna+" elementi ciascuna)";
  477.                     if(log!=null)
  478.                         log.info(msg);
  479.                     GestoreRichieste.logConsole.info(msg);
  480.                     for (String cacheKey : GestoreRichieste.cacheKeys) {
  481.                         Cache cache = GestoreRichieste.caches.get(cacheKey);
  482.                         cache.setCacheSize(dimensioneCacheInterna);
  483.                     }
  484.                 }catch(Exception error){
  485.                     throw new CoreException("Parametro errato per la dimensione della cache (Gestore Messaggi): "+error.getMessage(),error);
  486.                 }
  487.             }
  488.             if(algoritmoCache != null ){
  489.                 String msg = "Algoritmo di cache (GestoreRichieste) impostato al valore: "+algoritmoCache;
  490.                 if(log!=null)
  491.                     log.info(msg);
  492.                 GestoreRichieste.logConsole.info(msg);
  493.                 CacheAlgorithm ca = null;
  494.                 if(CostantiConfigurazione.CACHE_MRU.toString().equalsIgnoreCase(algoritmoCache)) {
  495.                     ca = CacheAlgorithm.MRU;
  496.                 }else {
  497.                     ca = CacheAlgorithm.LRU;
  498.                 }
  499.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  500.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  501.                     cache.setCacheAlgoritm(ca);
  502.                 }
  503.             }

  505.         }

  507.         if( idleTime > 0  ){
  508.             try{
  509.                 String msg = "Attributo 'IdleTime' (GestoreRichieste) impostato al valore: "+idleTime;
  510.                 if(log!=null)
  511.                     log.info(msg);
  512.                 GestoreRichieste.logConsole.info(msg);
  513.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  514.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  515.                     cache.setItemIdleTime(idleTime);
  516.                 }
  517.             }catch(Exception error){
  518.                 throw new CoreException("Parametro errato per l'attributo 'IdleTime' (Gestore Messaggi): "+error.getMessage(),error);
  519.             }
  520.         }

  522.         try{
  523.             String msg = "Attributo 'MaxLifeSecond' (GestoreRichieste) impostato al valore: "+itemLifeSecond;
  524.             if(log!=null)
  525.                 log.info(msg);
  526.             GestoreRichieste.logConsole.info(msg);
  527.             for (String cacheKey : GestoreRichieste.cacheKeys) {
  528.                 Cache cache = GestoreRichieste.caches.get(cacheKey);
  529.                 cache.setItemLifeTime(itemLifeSecond);
  530.             }
  531.         }catch(Exception error){
  532.             throw new CoreException("Parametro errato per l'attributo 'MaxLifeSecond' (Gestore Messaggi): "+error.getMessage(),error);
  533.         }

  535.         GestoreRichieste.cacheApi.build();
  536.         GestoreRichieste.cacheRateLimiting.build();
  537.         GestoreRichieste.cacheFruitori.build();
  538.     }
  539.     
  540.     @SuppressWarnings("deprecation")
  541.     @Deprecated
  542.     public static void disableSyncronizedGet() throws UtilsException {
  543.         if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  544.             try{
  545.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  546.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  547.                     if(cache!=null) {
  548.                         cache.disableSyncronizedGet();
  549.                     }
  550.                 }
  551.             }catch(Exception e){
  552.                 throw new UtilsException(e.getMessage(),e);
  553.             }
  554.         }else{
  555.             throw new UtilsException("Cache disabled");
  556.         }
  557.     }
  558.     @SuppressWarnings("deprecation")
  559.     @Deprecated
  560.     public static boolean isDisableSyncronizedGet() throws UtilsException {
  561.         if(GestoreRichieste.cacheKeys!=null && !GestoreRichieste.cacheKeys.isEmpty()){
  562.             try{
  563.                 boolean isDisabled = true;
  564.                 for (String cacheKey : GestoreRichieste.cacheKeys) {
  565.                     Cache cache = GestoreRichieste.caches.get(cacheKey);
  566.                     if(cache!=null &&
  567.                         (!cache.isDisableSyncronizedGet())
  568.                         ) {
  569.                         isDisabled = false;
  570.                         break;
  571.                     }
  572.                 }
  573.                 return isDisabled;
  574.             }catch(Exception e){
  575.                 throw new UtilsException(e.getMessage(),e);
  576.             }
  577.         }else{
  578.             throw new UtilsException("Cache disabled");
  579.         }
  580.     }
  581.     

  583.     
  584.     
  585.     
  586.     /*----------------- CLEANER - RATELIMITING --------------------*/
  587.     
  588.     public static void removeRateLimitingConfigGlobale() throws UtilsException {
  589.         if(GestoreRichieste.cacheRateLimiting!=null) {
  590.             GestoreRichieste.cacheRateLimiting.clear();
  591.         }
  592.     }
  593.     
  594.     public static void removeRateLimitingConfig(TipoPdD tipoPdD, String nomePorta) throws UtilsException, CoreException {
  595.         
  596.         if(GestoreRichieste.cacheRateLimiting!=null) {
  597.             List<String> keyForClean = new ArrayList<>();
  598.             List<String> keys = GestoreRichieste.cacheRateLimiting.keys();
  599.             if(keys!=null && !keys.isEmpty()) {
  600.                 for (String key : keys) {
  601.                     if(key!=null) {
  602.                         Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheRateLimiting.get(key));
  603.                         if(o instanceof RequestRateLimitingConfig) {
  604.                             RequestRateLimitingConfig rl = (RequestRateLimitingConfig) o;
  605.                             if(tipoPdD.equals(rl.getTipoPdD()) && nomePorta.equals(rl.getNomePorta())) {
  606.                                 keyForClean.add(key);
  607.                             }
  608.                         }
  609.                     }
  610.                 }
  611.             }
  612.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  613.                 for (String key : keyForClean) {
  614.                     GestoreRichieste.cacheRateLimiting.remove(key);
  615.                 }
  616.             }
  617.         }
  618.         
  619.     }

  621.     
  622.     
  623.     /*----------------- CLEANER --------------------*/
  624.     
  625.     public static void removeApi(IDAccordo idAccordo) throws UtilsException, CoreException {
  626.         
  627.         IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  628.         
  629.         // RequestConfig
  630.         {
  631.             List<String> keyForClean = new ArrayList<>();
  632.             List<String> keys = GestoreRichieste.cacheApi.keys();
  633.             if(keys!=null && !keys.isEmpty()) {
  634.                 for (String key : keys) {
  635.                     if(key!=null) {
  636.                         Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  637.                         if(o instanceof RequestConfig) {
  638.                             RequestConfig rc = (RequestConfig) o;
  639.                             IDAccordo idCheck = null;
  640.                             try {
  641.                                 idCheck = idAccordoFactory.getIDAccordoFromAccordo(rc.getAspc());
  642.                             }catch(Exception e) {
  643.                                 throw new CoreException(e.getMessage(),e);
  644.                             }
  645.                             if(rc.getAspc()!=null && idAccordo.equals(idCheck)) {
  646.                                 keyForClean.add(key);
  647.                             }
  648.                         }
  649.                     }
  650.                 }
  651.             }
  652.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  653.                 for (String key : keyForClean) {
  654.                     GestoreRichieste.cacheApi.remove(key);
  655.                 }
  656.             }
  657.         }
  658.         
  659.     }
  660.     public static void removeErogazione(IDServizio idServizio) throws UtilsException, CoreException {
  661.         removeErogazioneRequestConfig(idServizio);
  662.         removeErogazioneRequestRateLimitingConfig(idServizio);
  663.     }
  664.     private static void removeErogazioneRequestConfig(IDServizio idServizio) throws UtilsException, CoreException {
  665.         // RequestConfig
  666.         List<String> keyForClean = new ArrayList<>();
  667.         List<String> keys = GestoreRichieste.cacheApi.keys();
  668.         if(keys!=null && !keys.isEmpty()) {
  669.             for (String key : keys) {
  670.                 if(key!=null) {
  671.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  672.                     if(o instanceof RequestConfig) {
  673.                         RequestConfig rc = (RequestConfig) o;
  674.                         if(rc.getIdServizio()!=null && idServizio.equals(rc.getIdServizio(),false)) {
  675.                             keyForClean.add(key);
  676.                         }
  677.                     }
  678.                 }
  679.             }
  680.         }
  681.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  682.             for (String key : keyForClean) {
  683.                 GestoreRichieste.cacheApi.remove(key);
  684.             }
  685.         }
  686.     }
  687.     private static void removeErogazioneRequestRateLimitingConfig(IDServizio idServizio) throws UtilsException, CoreException {
  688.         // RequestRateLimitingConfig
  689.         List<String> keyForClean = new ArrayList<>();
  690.         List<String> keys = GestoreRichieste.cacheRateLimiting.keys();
  691.         if(keys!=null && !keys.isEmpty()) {
  692.             for (String key : keys) {
  693.                 if(key!=null) {
  694.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheRateLimiting.get(key));
  695.                     if(o instanceof RequestRateLimitingConfig) {
  696.                         RequestRateLimitingConfig rl = (RequestRateLimitingConfig) o;
  697.                         if(rl.getIdServizio()!=null && idServizio.equals(rl.getIdServizio(),false)) {
  698.                             keyForClean.add(key);
  699.                         }
  700.                     }
  701.                 }
  702.             }
  703.         }
  704.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  705.             for (String key : keyForClean) {
  706.                 GestoreRichieste.cacheRateLimiting.remove(key);
  707.             }
  708.         }
  709.     }
  710.     
  711.     public static void removeFruizione(IDSoggetto fruitore, IDServizio idServizio) throws UtilsException, CoreException {
  712.         removeFruizioneRequestConfig(fruitore, idServizio);
  713.         removeFruizioneRequestRateLimitingConfig(fruitore, idServizio);
  714.         removeFruizioneRequestFruitore(fruitore, idServizio);
  715.     }
  716.     private static void removeFruizioneRequestConfig(IDSoggetto fruitore, IDServizio idServizio) throws UtilsException, CoreException { 
  717.         // RequestConfig
  718.         List<String> keyForClean = new ArrayList<>();
  719.         List<String> keys = GestoreRichieste.cacheApi.keys();
  720.         if(keys!=null && !keys.isEmpty()) {
  721.             for (String key : keys) {
  722.                 if(key!=null) {
  723.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  724.                     if(o instanceof RequestConfig) {
  725.                         RequestConfig rc = (RequestConfig) o;
  726.                         if(rc.getIdServizio()!=null && idServizio.equals(rc.getIdServizio(),false) &&
  727.                                 rc.getIdFruitore()!=null && fruitore.equals(rc.getIdFruitore())) {
  728.                             keyForClean.add(key);
  729.                         }
  730.                     }
  731.                 }
  732.             }
  733.         }
  734.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  735.             for (String key : keyForClean) {
  736.                 GestoreRichieste.cacheApi.remove(key);
  737.             }
  738.         }
  739.     }
  740.     private static void removeFruizioneRequestRateLimitingConfig(IDSoggetto fruitore, IDServizio idServizio) throws UtilsException, CoreException {
  741.         // RequestRateLimitingConfig
  742.         List<String> keyForClean = new ArrayList<>();
  743.         List<String> keys = GestoreRichieste.cacheRateLimiting.keys();
  744.         if(keys!=null && !keys.isEmpty()) {
  745.             for (String key : keys) {
  746.                 if(key!=null) {
  747.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheRateLimiting.get(key));
  748.                     if(o instanceof RequestRateLimitingConfig) {
  749.                         RequestRateLimitingConfig rl = (RequestRateLimitingConfig) o;
  750.                         if(rl.getIdServizio()!=null && idServizio.equals(rl.getIdServizio(),false) &&
  751.                                 rl.getIdFruitore()!=null && fruitore.equals(rl.getIdFruitore())) {
  752.                             keyForClean.add(key);
  753.                         }
  754.                     }
  755.                 }
  756.             }
  757.         }
  758.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  759.             for (String key : keyForClean) {
  760.                 GestoreRichieste.cacheRateLimiting.remove(key);
  761.             }
  762.         }
  763.     }
  764.     private static void removeFruizioneRequestFruitore(IDSoggetto fruitore, IDServizio idServizio) throws UtilsException, CoreException {
  765.         // RequestFruitore
  766.         List<String> keyForClean = new ArrayList<>();
  767.         List<String> keys = GestoreRichieste.cacheFruitori.keys();
  768.         if(keys!=null && !keys.isEmpty()) {
  769.             for (String key : keys) {
  770.                 if(key!=null) {
  771.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheFruitori.get(key));
  772.                     if(o instanceof RequestFruitore) {
  773.                         RequestFruitore rf = (RequestFruitore) o;
  774.                         if(rf.getIdSoggettoFruitore()!=null && fruitore.equals(rf.getIdSoggettoFruitore())) {
  775.                             keyForClean.add(key);
  776.                         }
  777.                     }
  778.                 }
  779.             }
  780.         }
  781.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  782.             for (String key : keyForClean) {
  783.                 GestoreRichieste.cacheFruitori.remove(key);
  784.             }
  785.         }
  786.     }
  787.     
  788.     public static void removePortaApplicativa(IDPortaApplicativa idPA) throws UtilsException, CoreException {
  789.         removePortaApplicativaRequestConfig(idPA);
  790.         removePortaApplicativaRequestRateLimitingConfig(idPA) ;
  791.     }
  792.     private static void removePortaApplicativaRequestConfig(IDPortaApplicativa idPA) throws UtilsException, CoreException {
  793.         // RequestConfig
  794.         List<String> keyForClean = new ArrayList<>();
  795.         List<String> keys = GestoreRichieste.cacheApi.keys();
  796.         if(keys!=null && !keys.isEmpty()) {
  797.             for (String key : keys) {
  798.                 if(key!=null) {
  799.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  800.                     if(o instanceof RequestConfig) {
  801.                         RequestConfig rc = (RequestConfig) o;
  802.                         if(rc.getIdPortaApplicativaDefault()!=null && idPA.equals(rc.getIdPortaApplicativaDefault())) {
  803.                             keyForClean.add(key);
  804.                         }
  805.                         else if(rc.getIdPortaApplicativa()!=null && idPA.equals(rc.getIdPortaApplicativa())) {
  806.                             keyForClean.add(key);
  807.                         }
  808.                         else if(rc.getPortaApplicativaDefault()!=null && rc.getPortaApplicativaDefault().getNome()!=null && idPA!=null && 
  809.                                 rc.getPortaApplicativaDefault().getNome().equals(idPA.getNome())) {
  810.                             keyForClean.add(key);
  811.                         }
  812.                         else if(rc.getPortaApplicativa()!=null && rc.getPortaApplicativa().getNome()!=null && idPA!=null && 
  813.                                 rc.getPortaApplicativa().getNome().equals(idPA.getNome())) {
  814.                             keyForClean.add(key);
  815.                         }
  816.                         else {
  817.                             
  818.                             boolean find = false;
  819.                             if(rc.getListPorteApplicativeByFiltroRicerca()!=null && !rc.getListPorteApplicativeByFiltroRicerca().isEmpty()) {
  820.                                 for (String keyID : rc.getListPorteApplicativeByFiltroRicerca().keySet()) {
  821.                                     List<IDPortaApplicativa> ids =  rc.getListPorteApplicativeByFiltroRicerca().get(keyID);
  822.                                     if(ids!=null && ids.contains(idPA)) {
  823.                                         find = true;
  824.                                         break;
  825.                                     }
  826.                                 }
  827.                             }
  828.                             if(!find &&
  829.                                 rc.getListMappingErogazionePortaApplicativa()!=null && !rc.getListMappingErogazionePortaApplicativa().isEmpty()) {
  830.                                 for (MappingErogazionePortaApplicativa mapping : rc.getListMappingErogazionePortaApplicativa()) {
  831.                                     if(mapping!=null && mapping.getIdPortaApplicativa()!=null && mapping.getIdPortaApplicativa().equals(idPA)) {
  832.                                         find = true;
  833.                                         break;
  834.                                     }
  835.                                 }
  836.                             }
  837.                             if(find) {
  838.                                 keyForClean.add(key);
  839.                             }
  840.                             
  841.                         }
  842.                     }
  843.                 }
  844.             }
  845.         }
  846.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  847.             for (String key : keyForClean) {
  848.                 GestoreRichieste.cacheApi.remove(key);
  849.             }
  850.         }
  851.     }
  852.     private static void removePortaApplicativaRequestRateLimitingConfig(IDPortaApplicativa idPA) throws UtilsException, CoreException {
  853.         // RequestRateLimitingConfig
  854.         List<String> keyForClean = new ArrayList<>();
  855.         List<String> keys = GestoreRichieste.cacheRateLimiting.keys();
  856.         if(keys!=null && !keys.isEmpty()) {
  857.             for (String key : keys) {
  858.                 if(key!=null) {
  859.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheRateLimiting.get(key));
  860.                     if(o instanceof RequestRateLimitingConfig) {
  861.                         RequestRateLimitingConfig rl = (RequestRateLimitingConfig) o;
  862.                         if(TipoPdD.APPLICATIVA.equals(rl.getTipoPdD()) && idPA.getNome().equals(rl.getNomePorta())) {
  863.                             keyForClean.add(key);
  864.                         }
  865.                     }
  866.                 }
  867.             }
  868.         }
  869.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  870.             for (String key : keyForClean) {
  871.                 GestoreRichieste.cacheRateLimiting.remove(key);
  872.             }
  873.         }
  874.     }
  875.     
  876.     public static void removeConnettore(IDConnettore idConnettore)throws UtilsException, CoreException {
  877.         
  878.         // RequestConfig
  879.         List<String> keyForClean = new ArrayList<>();
  880.         List<String> keys = GestoreRichieste.cacheApi.keys();
  881.         if(keys!=null && !keys.isEmpty()) {
  882.             for (String key : keys) {
  883.                 if(key!=null) {
  884.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  885.                     if(o instanceof RequestConfig) {
  886.                         RequestConfig rc = (RequestConfig) o;
  887.                         if(rc.getIdServizio()!=null && rc.getIdServizio().getSoggettoErogatore()!=null && idConnettore.getIdSoggettoProprietario().equals(rc.getIdServizio().getSoggettoErogatore())) {
  888.                             ServizioApplicativo sa = rc.getServizioApplicativoErogatore(idConnettore.getNome());
  889.                             if(sa!=null) {
  890.                                 keyForClean.add(key);
  891.                             }
  892.                         }
  893.                     }
  894.                 }
  895.             }
  896.         }
  897.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  898.             for (String key : keyForClean) {
  899.                 GestoreRichieste.cacheApi.remove(key);
  900.             }
  901.         }
  902.         
  903.     }
  904.     
  905.     public static void removePortaDelegata(IDPortaDelegata idPD) throws UtilsException, CoreException {
  906.         removePortaDelegataRequestConfig(idPD);
  907.         removePortaDelegataRequestRateLimitingConfig(idPD);
  908.     }
  909.     private static void removePortaDelegataRequestConfig(IDPortaDelegata idPD) throws UtilsException, CoreException {
  910.         // RequestConfig
  911.         List<String> keyForClean = new ArrayList<>();
  912.         List<String> keys = GestoreRichieste.cacheApi.keys();
  913.         if(keys!=null && !keys.isEmpty()) {
  914.             for (String key : keys) {
  915.                 if(key!=null) {
  916.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  917.                     if(o instanceof RequestConfig) {
  918.                         RequestConfig rc = (RequestConfig) o;
  919.                         if(rc.getIdPortaDelegataDefault()!=null && idPD.equals(rc.getIdPortaDelegataDefault())) {
  920.                             keyForClean.add(key);
  921.                         }
  922.                         else if(rc.getIdPortaDelegata()!=null && idPD.equals(rc.getIdPortaDelegata())) {
  923.                             keyForClean.add(key);
  924.                         }
  925.                         else if(rc.getPortaDelegataDefault()!=null && rc.getPortaDelegataDefault().getNome()!=null && idPD!=null && 
  926.                                 rc.getPortaDelegataDefault().getNome().equals(idPD.getNome())) {
  927.                             keyForClean.add(key);
  928.                         }
  929.                         else if(rc.getPortaDelegata()!=null && rc.getPortaDelegata().getNome()!=null && idPD!=null && 
  930.                                 rc.getPortaDelegata().getNome().equals(idPD.getNome())) {
  931.                             keyForClean.add(key);
  932.                         }
  933.                         else {
  934.                             
  935.                             boolean find = false;
  936.                             if(rc.getListPorteDelegateByFiltroRicerca()!=null && !rc.getListPorteDelegateByFiltroRicerca().isEmpty()) {
  937.                                 for (String keyID : rc.getListPorteDelegateByFiltroRicerca().keySet()) {
  938.                                     List<IDPortaDelegata> ids =  rc.getListPorteDelegateByFiltroRicerca().get(keyID);
  939.                                     if(ids!=null && ids.contains(idPD)) {
  940.                                         find = true;
  941.                                         break;
  942.                                     }
  943.                                 }
  944.                             }
  945.                             if(!find &&
  946.                                 rc.getListMappingFruizionePortaDelegata()!=null && !rc.getListMappingFruizionePortaDelegata().isEmpty()) {
  947.                                 for (MappingFruizionePortaDelegata mapping : rc.getListMappingFruizionePortaDelegata()) {
  948.                                     if(mapping!=null && mapping.getIdPortaDelegata()!=null && mapping.getIdPortaDelegata().equals(idPD)) {
  949.                                         find = true;
  950.                                         break;
  951.                                     }
  952.                                 }
  953.                             }
  954.                             if(find) {
  955.                                 keyForClean.add(key);
  956.                             }
  957.                             
  958.                         }
  959.                     }
  960.                 }
  961.             }
  962.         }
  963.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  964.             for (String key : keyForClean) {
  965.                 GestoreRichieste.cacheApi.remove(key);
  966.             }
  967.         }
  968.     }
  969.     private static void removePortaDelegataRequestRateLimitingConfig(IDPortaDelegata idPD) throws UtilsException, CoreException {   
  970.         // RequestRateLimitingConfig
  971.         List<String> keyForClean = new ArrayList<>();
  972.         List<String> keys = GestoreRichieste.cacheRateLimiting.keys();
  973.         if(keys!=null && !keys.isEmpty()) {
  974.             for (String key : keys) {
  975.                 if(key!=null) {
  976.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheRateLimiting.get(key));
  977.                     if(o instanceof RequestRateLimitingConfig) {
  978.                         RequestRateLimitingConfig rl = (RequestRateLimitingConfig) o;
  979.                         if(TipoPdD.DELEGATA.equals(rl.getTipoPdD()) && idPD.getNome().equals(rl.getNomePorta())) {
  980.                             keyForClean.add(key);
  981.                         }
  982.                     }
  983.                 }
  984.             }
  985.         }
  986.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  987.             for (String key : keyForClean) {
  988.                 GestoreRichieste.cacheRateLimiting.remove(key);
  989.             }
  990.         }
  991.     }
  992.     
  993.     public static void removePdd(String portaDominio) throws UtilsException, CoreException {
  994.         
  995.         // RequestConfig
  996.         List<String> keyForClean = new ArrayList<>();
  997.         List<String> keys = GestoreRichieste.cacheApi.keys();
  998.         if(keys!=null && !keys.isEmpty()) {
  999.             for (String key : keys) {
  1000.                 if(key!=null) {
  1001.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  1002.                     if(o instanceof RequestConfig) {
  1003.                         RequestConfig rc = (RequestConfig) o;
  1004.                         if(
  1005.                                 (rc.getSoggettoErogatorePdd()!=null && rc.getSoggettoErogatorePdd().getNome()!=null && portaDominio.equals(rc.getSoggettoErogatorePdd().getNome()))
  1006.                                 ||
  1007.                                 (rc.getSoggettoFruitorePdd()!=null && rc.getSoggettoFruitorePdd().getNome()!=null && portaDominio.equals(rc.getSoggettoFruitorePdd().getNome()))
  1008.                             ) {
  1009.                             keyForClean.add(key);
  1010.                         }
  1011.                     }
  1012.                 }
  1013.             }
  1014.         }
  1015.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1016.             for (String key : keyForClean) {
  1017.                 GestoreRichieste.cacheApi.remove(key);
  1018.             }
  1019.         }
  1020.         
  1021.     }
  1022.     
  1023.     public static void removeSoggetto(IDSoggetto idSoggetto) throws UtilsException, CoreException {
  1024.         removeSoggettoRequestConfig(idSoggetto);
  1025.         removeSoggettoRequestRateLimitingConfig(idSoggetto);
  1026.         removeSoggettoRequestFruitore(idSoggetto);
  1027.     }
  1028.     private static void removeSoggettoRequestConfig(IDSoggetto idSoggetto) throws UtilsException, CoreException {   
  1029.         // RequestConfig
  1030.         List<String> keyForClean = new ArrayList<>();
  1031.         List<String> keys = GestoreRichieste.cacheApi.keys();
  1032.         if(keys!=null && !keys.isEmpty()) {
  1033.             for (String key : keys) {
  1034.                 if(key!=null) {
  1035.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  1036.                     if(o instanceof RequestConfig) {
  1037.                         RequestConfig rc = (RequestConfig) o;
  1038.                         if(
  1039.                                 (rc.getIdServizio()!=null && rc.getIdServizio().getSoggettoErogatore()!=null && idSoggetto.equals(rc.getIdServizio().getSoggettoErogatore()))
  1040.                                 ||
  1041.                                 (rc.getIdFruitore()!=null && idSoggetto.equals(rc.getIdFruitore()))
  1042.                             ) {
  1043.                             keyForClean.add(key);
  1044.                         }
  1045.                     }
  1046.                 }
  1047.             }
  1048.         }
  1049.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1050.             for (String key : keyForClean) {
  1051.                 GestoreRichieste.cacheApi.remove(key);
  1052.             }
  1053.         }
  1054.     }
  1055.     private static void removeSoggettoRequestRateLimitingConfig(IDSoggetto idSoggetto) throws UtilsException, CoreException {
  1056.         // RequestRateLimitingConfig
  1057.         List<String> keyForClean = new ArrayList<>();
  1058.         List<String> keys = GestoreRichieste.cacheRateLimiting.keys();
  1059.         if(keys!=null && !keys.isEmpty()) {
  1060.             for (String key : keys) {
  1061.                 if(key!=null) {
  1062.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheRateLimiting.get(key));
  1063.                     if(o instanceof RequestRateLimitingConfig) {
  1064.                         RequestRateLimitingConfig rl = (RequestRateLimitingConfig) o;
  1065.                         if(
  1066.                                 (rl.getIdServizio()!=null && rl.getIdServizio().getSoggettoErogatore()!=null && idSoggetto.equals(rl.getIdServizio().getSoggettoErogatore()))
  1067.                                 ||
  1068.                                 (rl.getIdFruitore()!=null && idSoggetto.equals(rl.getIdFruitore()))
  1069.                             ) {
  1070.                             keyForClean.add(key);
  1071.                         }
  1072.                     }
  1073.                 }
  1074.             }
  1075.         }
  1076.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1077.             for (String key : keyForClean) {
  1078.                 GestoreRichieste.cacheRateLimiting.remove(key);
  1079.             }
  1080.         }
  1081.     }
  1082.     private static void removeSoggettoRequestFruitore(IDSoggetto idSoggetto) throws UtilsException, CoreException {
  1083.         // RequestFruitore
  1084.         List<String> keyForClean = new ArrayList<>();
  1085.         List<String> keys = GestoreRichieste.cacheFruitori.keys();
  1086.         if(keys!=null && !keys.isEmpty()) {
  1087.             for (String key : keys) {
  1088.                 if(key!=null) {
  1089.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheFruitori.get(key));
  1090.                     if(o instanceof RequestFruitore) {
  1091.                         RequestFruitore rf = (RequestFruitore) o;
  1092.                         if(
  1093.                                 (rf.getIdServizioApplicativoFruitore()!=null && rf.getIdServizioApplicativoFruitore().getIdSoggettoProprietario()!=null && idSoggetto.equals(rf.getIdServizioApplicativoFruitore().getIdSoggettoProprietario()))
  1094.                                 ||
  1095.                                 (rf.getIdSoggettoFruitore()!=null && idSoggetto.equals(rf.getIdSoggettoFruitore()))
  1096.                             ) {
  1097.                             keyForClean.add(key);
  1098.                         }
  1099.                     }
  1100.                 }
  1101.             }
  1102.         }
  1103.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1104.             for (String key : keyForClean) {
  1105.                 GestoreRichieste.cacheFruitori.remove(key);
  1106.             }
  1107.         }
  1108.     }
  1109.     
  1110.     public static void removeApplicativo(IDServizioApplicativo idApplicativo) throws UtilsException, CoreException {
  1111.         removeApplicativoRequestConfig(idApplicativo);
  1112.         removeApplicativoRequestFruitore(idApplicativo);
  1113.     }
  1114.     private static void removeApplicativoRequestConfig(IDServizioApplicativo idApplicativo) throws UtilsException, CoreException {
  1115.         // RequestConfig
  1116.         List<String> keyForClean = new ArrayList<>();
  1117.         List<String> keys = GestoreRichieste.cacheApi.keys();
  1118.         if(keys!=null && !keys.isEmpty()) {
  1119.             for (String key : keys) {
  1120.                 if(key!=null) {
  1121.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  1122.                     if(o instanceof RequestConfig) {
  1123.                         RequestConfig rc = (RequestConfig) o;
  1124.                         if(rc.getIdServizio()!=null && rc.getIdServizio().getSoggettoErogatore()!=null && idApplicativo.getIdSoggettoProprietario().equals(rc.getIdServizio().getSoggettoErogatore())) {
  1125.                             ServizioApplicativo sa = rc.getServizioApplicativoErogatore(idApplicativo.getNome());
  1126.                             if(sa!=null) {
  1127.                                 keyForClean.add(key);
  1128.                             }
  1129.                         }
  1130.                     }
  1131.                 }
  1132.             }
  1133.         }
  1134.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1135.             for (String key : keyForClean) {
  1136.                 GestoreRichieste.cacheApi.remove(key);
  1137.             }
  1138.         }
  1139.     }
  1140.     private static void removeApplicativoRequestFruitore(IDServizioApplicativo idApplicativo) throws UtilsException, CoreException {    
  1141.         // RequestFruitore
  1142.         List<String> keyForClean = new ArrayList<>();
  1143.         List<String> keys = GestoreRichieste.cacheFruitori.keys();
  1144.         if(keys!=null && !keys.isEmpty()) {
  1145.             for (String key : keys) {
  1146.                 if(key!=null) {
  1147.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheFruitori.get(key));
  1148.                     if(o instanceof RequestFruitore) {
  1149.                         RequestFruitore rf = (RequestFruitore) o;
  1150.                         if(rf.getIdServizioApplicativoFruitore()!=null && idApplicativo.equals(rf.getIdServizioApplicativoFruitore())) {
  1151.                             keyForClean.add(key);
  1152.                         }
  1153.                     }
  1154.                 }
  1155.             }
  1156.         }
  1157.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1158.             for (String key : keyForClean) {
  1159.                 GestoreRichieste.cacheFruitori.remove(key);
  1160.             }
  1161.         }
  1162.     }
  1163.     
  1164.     
  1165.     public static void removeRuolo(IDRuolo idRuolo) throws UtilsException, CoreException {
  1166.         // RequestConfig
  1167.         List<String> keyForClean = new ArrayList<>();
  1168.         List<String> keys = GestoreRichieste.cacheApi.keys();
  1169.         if(keys!=null && !keys.isEmpty()) {
  1170.             for (String key : keys) {
  1171.                 if(key!=null) {
  1172.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  1173.                     if(o instanceof RequestConfig) {
  1174.                         RequestConfig rc = (RequestConfig) o;
  1175.                         
  1176.                         List<String> ruoloKeys = rc.getRuoloKeys();
  1177.                         if(ruoloKeys!=null && ruoloKeys.contains(idRuolo.getNome())) {
  1178.                             keyForClean.add(key);
  1179.                         }
  1180.                     }
  1181.                 }
  1182.             }
  1183.         }
  1184.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1185.             for (String key : keyForClean) {
  1186.                 GestoreRichieste.cacheApi.remove(key);
  1187.             }
  1188.         }
  1189.     }
  1190.     
  1191.     public static void removeScope(IDScope idScope) throws UtilsException, CoreException {
  1192.         // RequestConfig
  1193.         List<String> keyForClean = new ArrayList<>();
  1194.         List<String> keys = GestoreRichieste.cacheApi.keys();
  1195.         if(keys!=null && !keys.isEmpty()) {
  1196.             for (String key : keys) {
  1197.                 if(key!=null) {
  1198.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  1199.                     if(o instanceof RequestConfig) {
  1200.                         RequestConfig rc = (RequestConfig) o;
  1201.                         
  1202.                         List<String> scopeKeys = rc.getScopeKeys();
  1203.                         if(scopeKeys!=null && scopeKeys.contains(idScope.getNome())) {
  1204.                             keyForClean.add(key);
  1205.                         }
  1206.                     }
  1207.                 }
  1208.             }
  1209.         }
  1210.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1211.             for (String key : keyForClean) {
  1212.                 GestoreRichieste.cacheApi.remove(key);
  1213.             }
  1214.         }
  1215.     }
  1216.     
  1217.     
  1218.     public static void removeGenericProperties(IDGenericProperties idGP) throws UtilsException, CoreException {
  1219.         // RequestConfig
  1220.         List<String> keyForClean = new ArrayList<>();
  1221.         List<String> keys = GestoreRichieste.cacheApi.keys();
  1222.         if(keys!=null && !keys.isEmpty()) {
  1223.             for (String key : keys) {
  1224.                 if(key!=null) {
  1225.                     Object o =  getRawObjectCacheEngine(GestoreRichieste.cacheApi.get(key));
  1226.                     if(o instanceof RequestConfig) {
  1227.                         RequestConfig rc = (RequestConfig) o;
  1228.                         
  1229.                         if(org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA.equals(idGP.getTipologia())) {
  1230.                             Object oT = rc.getPolicyValidazioneToken(idGP.getNome());
  1231.                             if(oT!=null) {
  1232.                                 keyForClean.add(key);
  1233.                                 continue;
  1234.                             }
  1235.                         }
  1236.                         
  1237.                         if(org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA_RETRIEVE.equals(idGP.getTipologia())) {
  1238.                             Object oT = rc.getPolicyNegoziazioneToken(idGP.getNome());
  1239.                             if(oT!=null) {
  1240.                                 keyForClean.add(key);
  1241.                                 continue;
  1242.                             }
  1243.                         }
  1244.                         
  1245.                         if(org.openspcoop2.pdd.core.token.Costanti.ATTRIBUTE_AUTHORITY.equals(idGP.getTipologia())) {
  1246.                             Object oT = rc.getAttributeAuthority(idGP.getNome());
  1247.                             if(oT!=null) {
  1248.                                 keyForClean.add(key);
  1249.                                 continue;
  1250.                             }
  1251.                         }
  1252.                         
  1253.                         List<String> forwardProxyKeys = (rc.getForwardProxyEnabled()!=null && rc.getForwardProxyEnabled()) ? rc.getForwardProxyKeys() : null;
  1254.                         String forwardProxyGP = ConfigurazionePdD._toKey_ForwardProxyConfigSuffix(idGP);
  1255.                         if(forwardProxyKeys!=null && forwardProxyKeys.contains(forwardProxyGP)) {
  1256.                             keyForClean.add(key);
  1257.                             continue;
  1258.                         }
  1259.                     }
  1260.                 }
  1261.             }
  1262.         }
  1263.         if(keyForClean!=null && !keyForClean.isEmpty()) {
  1264.             for (String key : keyForClean) {
  1265.                 GestoreRichieste.cacheApi.remove(key);
  1266.             }
  1267.         }
  1268.     }
  1269.     
  1270.     
  1271.     

  1273.     
  1274.     // ******** RICHIESTE **********
  1275.     
  1276.     private static final String KEY_IN_MEMORY_ONLY = "@@InMemoryOnly@@";
  1277.     private static final String INIT_SEPARATOR = "\n\n=======================";
  1278.     private static final String END_SEPARATOR = "=======================";
  1279.     
  1280.     public static void setRequestConfigInMemory(RequestInfo requestInfo) {
  1281.         if(org.openspcoop2.utils.cache.Cache.DEBUG_CACHE) {
  1282.             System.out.println(INIT_SEPARATOR);
  1283.             System.out.println("Creato RequestConfig in ram");
  1284.             System.out.println(END_SEPARATOR);
  1285.         }
  1286.                     
  1287.         RequestConfig rc = new RequestConfig();
  1288.         rc.setKey(KEY_IN_MEMORY_ONLY);
  1289.         rc.setCached(false);
  1290.         requestInfo.setRequestConfig(rc);
  1291.         
  1292.         RequestRateLimitingConfig rcRT = new RequestRateLimitingConfig();
  1293.         rcRT.setKey(KEY_IN_MEMORY_ONLY);
  1294.         rcRT.setCached(false);
  1295.         requestInfo.setRequestRateLimitingConfig(rcRT);
  1296.         
  1297.         RequestThreadContext rt = new RequestThreadContext(KEY_IN_MEMORY_ONLY, logger!=null ? logger : logConsole);
  1298.         requestInfo.setRequestThreadContext(rt);
  1299.     }
  1300.     
  1301.     public static void readRequestConfig(RequestInfo requestInfo) {
  1302.         
  1303.         if(!useCache) {
  1304.             setRequestConfigInMemory(requestInfo);
  1305.             return;
  1306.         }
  1307.         
  1308.         String key = buildKey(requestInfo, null, null);
  1309.         if(key==null) {
  1310.             return;
  1311.         }
  1312.         readRequestConfigEngine(requestInfo, key, null);
  1313.         readRequestRateLimitingConfigEngine(requestInfo, key);
  1314.         requestInfo.setRequestThreadContext(RequestThreadContext.getRequestThreadContext());
  1315.         if(requestInfo.getRequestThreadContext()!=null) {
  1316.             // ripulisco precedenti assegnamenti
  1317.             requestInfo.getRequestThreadContext().setRequestFruitoreTrasportoInfo(null);
  1318.             requestInfo.getRequestThreadContext().setRequestFruitoreTokenInfo(null);
  1319.         }
  1320.         
  1321.         if(org.openspcoop2.utils.cache.Cache.DEBUG_CACHE) {
  1322.             System.out.println(INIT_SEPARATOR);
  1323.             System.out.println("Creato RequestConfig con chiave '"+key+"'");
  1324.             System.out.println("\tRequestThreadContext '"+requestInfo.getRequestThreadContext().gettName()+"'");
  1325.             System.out.println(END_SEPARATOR);
  1326.         }
  1327.     }
  1328.     
  1329.     public static void updateRequestConfig(RequestInfo requestInfo, ServiceBinding serviceBinding, OpenSPCoop2MessageSoapStreamReader soapStreamReader) {
  1330.         
  1331.         if(!useCache) {
  1332.             return; // solo in memory, la differenza sull'azione non è importante
  1333.         }
  1334.         
  1335.         if(requestInfo==null || requestInfo.getRequestConfig()==null) {
  1336.             return;
  1337.         }
  1338.         String oldKey = requestInfo.getRequestConfig().getKey();
  1339.         String key = buildKey(requestInfo, serviceBinding, soapStreamReader);
  1340.         if(key==null) {
  1341.             return;
  1342.         }
  1343.         if(key.equals(oldKey)) {
  1344.             return; // non e' stato aggiunto il soapStreamReader o modifiche derivanti all'azione specifica
  1345.         }
  1346.         
  1347.         if(org.openspcoop2.utils.cache.Cache.DEBUG_CACHE) {
  1348.             System.out.println(INIT_SEPARATOR);
  1349.             System.out.println("AGGIORNO RequestConfig");
  1350.             System.out.println("OLD: "+oldKey);
  1351.             System.out.println("NEW: "+key);
  1352.             System.out.println(END_SEPARATOR);
  1353.         }
  1354.         
  1355.         RequestConfig rcOld = requestInfo.getRequestConfig();
  1356.         
  1357.         // Aggiorno nel contesto nuovi oggetti con nuova chiave
  1358.         readRequestConfigEngine(requestInfo, key, rcOld);
  1359.         readRequestRateLimitingConfigEngine(requestInfo, key);

  1361.         requestInfo.setPreRequestConfig(rcOld);

  1363.     }
  1364.     
  1365.     private static void readRequestConfigEngine(RequestInfo requestInfo, String key, RequestConfig srcClone) {
  1366.         
  1367.         if(cacheApi==null) {
  1368.             return;
  1369.         }
  1370.         
  1371.         org.openspcoop2.utils.cache.CacheResponse response = 
  1372.                 (org.openspcoop2.utils.cache.CacheResponse) cacheApi.get(key);
  1373.         if(response != null &&
  1374.             response.getObject()!=null){
  1375.             RequestConfig rc = (RequestConfig) response.getObject(); 
  1376.             /**System.out.println("TROVATA IN CACHE ("+rc.isCached()+")");*/
  1377.             if(rc.getIdServizio()!=null) {
  1378.                 rc.setIdServizio(rc.getIdServizio().clone()); // per l'azione
  1379.             }
  1380.             requestInfo.setRequestConfig(rc);
  1381.             return;
  1382.         }
  1383.         
  1384.         /**System.out.println("CONFIG NON TROVATA IN CACHE");*/
  1385.         RequestConfig rc = new RequestConfig();
  1386.         if(srcClone!=null) {
  1387.             rc.copyFrom(srcClone);
  1388.         }
  1389.         else {
  1390.             rc = new RequestConfig();
  1391.         }
  1392.         rc.setKey(key);
  1393.         rc.setCached(false);
  1394.         requestInfo.setRequestConfig(rc);
  1395.         
  1396.     }
  1397.     
  1398.     private static void readRequestRateLimitingConfigEngine(RequestInfo requestInfo, String key) {
  1399.         
  1400.         if(cacheRateLimiting==null) {
  1401.             return;
  1402.         }
  1403.         
  1404.         org.openspcoop2.utils.cache.CacheResponse response = 
  1405.                 (org.openspcoop2.utils.cache.CacheResponse) cacheRateLimiting.get(key);
  1406.         if(response != null &&
  1407.             response.getObject()!=null){
  1408.             RequestRateLimitingConfig rc = (RequestRateLimitingConfig) response.getObject(); 
  1409.             /** System.out.println("TROVATA IN CACHE ("+rc.isCached()+")"); */
  1410.             requestInfo.setRequestRateLimitingConfig(rc);
  1411.             return;
  1412.         }
  1413.         
  1414.         /** System.out.println("RATE LIMIT NON TROVATA IN CACHE"); */
  1415.         RequestRateLimitingConfig rc = new RequestRateLimitingConfig();
  1416.         rc.setKey(key);
  1417.         rc.setCached(false);
  1418.         requestInfo.setRequestRateLimitingConfig(rc);
  1419.         
  1420.     }
  1421.     
  1422.     public static void saveRequestConfig(RequestInfo requestInfo)throws UtilsException, CoreException {
  1423.         
  1424.         if(!useCache) {
  1425.             return;
  1426.         }
  1427.         
  1428.         if(requestInfo==null) {
  1429.             return;
  1430.         }       
  1431.         
  1432.         String idTransazione = requestInfo.getIdTransazione();
  1433.         
  1434.         if(cacheApi!=null && requestInfo.getPreRequestConfig()!=null && !requestInfo.getPreRequestConfig().isCached()) {
  1435.             SemaphoreLock lock = lockCache.acquire("savePreRequestConfig", idTransazione);
  1436.             try {
  1437.                 String key = requestInfo.getPreRequestConfig().getKey();
  1438.                 org.openspcoop2.utils.cache.CacheResponse response = 
  1439.                         (org.openspcoop2.utils.cache.CacheResponse) cacheApi.get(key);
  1440.                 if(response == null){
  1441.                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1442.                     requestInfo.getPreRequestConfig().setCached(true);
  1443.                     responseCache.setObject(requestInfo.getPreRequestConfig());
  1444.                     cacheApi.put(key,responseCache);
  1445.                     /** System.out.println("SALVATA IN CACHE con chiave ["+requestInfo.getPreRequestConfig().getKey()+"]"); */
  1446.                 }
  1447.                 else {
  1448.                     /** System.out.println("NON SALVATA IN CACHE, GIA PRESENTE"); */
  1449.                 }
  1450.                 
  1451.             }finally {
  1452.                 lockCache.release(lock, "savePreRequestConfig", idTransazione);
  1453.             }
  1454.         }
  1455.         
  1456.         if(cacheApi!=null && requestInfo.getRequestConfig()!=null && !requestInfo.getRequestConfig().isCached()) {
  1457.             SemaphoreLock lock = lockCache.acquire("saveRequestConfig", idTransazione);
  1458.             try {
  1459.                 String key = requestInfo.getRequestConfig().getKey();
  1460.                 org.openspcoop2.utils.cache.CacheResponse response = 
  1461.                         (org.openspcoop2.utils.cache.CacheResponse) cacheApi.get(key);
  1462.                 if(response == null){
  1463.                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1464.                     requestInfo.getRequestConfig().setCached(true);
  1465.                     responseCache.setObject(requestInfo.getRequestConfig());
  1466.                     cacheApi.put(key,responseCache);
  1467.                     /** System.out.println("SALVATA IN CACHE con chiave ["+requestInfo.getRequestConfig().getKey()+"]");*/
  1468.                 }
  1469.                 else {
  1470.                     /**System.out.println("NON SALVATA IN CACHE, GIA PRESENTE");*/
  1471.                 }
  1472.                 
  1473.             }finally {
  1474.                 lockCache.release(lock, "saveRequestConfig", idTransazione);
  1475.             }
  1476.         }
  1477.         
  1478.         if(cacheRateLimiting!=null && requestInfo.getRequestRateLimitingConfig()!=null && !requestInfo.getRequestRateLimitingConfig().isCached()) {
  1479.             SemaphoreLock lock = lockCache_rateLimiting.acquire("saveRequestRateLimitingConfig", idTransazione);
  1480.             try {
  1481.                 String key = requestInfo.getRequestConfig().getKey();
  1482.                 org.openspcoop2.utils.cache.CacheResponse response = 
  1483.                         (org.openspcoop2.utils.cache.CacheResponse) cacheRateLimiting.get(key);
  1484.                 if(response == null){
  1485.                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1486.                     requestInfo.getRequestRateLimitingConfig().setCached(true);
  1487.                     responseCache.setObject(requestInfo.getRequestRateLimitingConfig());
  1488.                     cacheRateLimiting.put(key,responseCache);
  1489.                     /** System.out.println("RATE LIMIT SALVATA IN CACHE con chiave ["+requestInfo.getRequestConfig().getKey()+"]");*/
  1490.                 }
  1491.                 else {
  1492.                     /** System.out.println("RATE LIMIT NON SALVATA IN CACHE, GIA PRESENTE");*/
  1493.                 }
  1494.                 
  1495.             }finally {
  1496.                 lockCache_rateLimiting.release(lock, "saveRequestRateLimitingConfig", idTransazione);
  1497.             }
  1498.         }
  1499.         
  1500.         if(requestInfo.getRequestThreadContext()!=null) {
  1501.             requestInfo.getRequestThreadContext().clear();
  1502.             requestInfo.setRequestThreadContext(null);
  1503.         }
  1504.     }
  1505.     
  1506.     
  1507.     private static String buildKey(RequestInfo requestInfo, ServiceBinding serviceBinding, OpenSPCoop2MessageSoapStreamReader soapStreamReader) {
  1508.         
  1509.         // Lo scopo e' individuare solo la porta applicativa/delegata di default e specifica (azione), il servizio e l'api
  1510.         // NOTA: 
  1511.         //     Se durante la gestione (in *ServiceUtils, tramite la chiamata del metodo RequestInfoConfigUtilities.checkRequestInfoConfig) 
  1512.         //     viene rilevata una identificazione dell'azione CONTENT_BASED,PROTOCOL_BASED,INPUT_BASED,DELEGATED_BY, la gestione della richiesta tramite url non viene attivata.
  1513.         //     Inoltre se si rileva una API SOAP con il riconoscimento dell'azione basata su wsdl (quindi rootElement), e tale informazione non è disponibile nel soapStreamReader
  1514.         //     la gestione della richiesta tramite url non viene attivata.
  1515.         
  1516.         StringBuilder bf = new StringBuilder();
  1517.         
  1518.         List<String> headerInKey = new ArrayList<>();
  1519.         headerInKey.add(HttpConstants.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  1520.         
  1521.         if(requestInfo.getProtocolContext()!=null) {
  1522.             
  1523.             // NOTA il meccanismo NON deve funzionare se non viene fornita il nome di una porta applicativa come per SPCoop
  1524.             if(requestInfo.getProtocolContext().getFunctionParameters()==null || "".equals(requestInfo.getProtocolContext().getFunctionParameters().trim())) {
  1525.                 return null;
  1526.             }
  1527.             
  1528.             if(requestInfo.getProtocolContext().getRequestType()!=null){
  1529.                 if(bf.length()>0) {
  1530.                     bf.append("\t");
  1531.                 }
  1532.                 bf.append("Method:").append(requestInfo.getProtocolContext().getRequestType());
  1533.             }
  1534.             else {
  1535.                 return null;
  1536.             }
  1537.             
  1538.             if(requestInfo.getProtocolContext()!=null){
  1539.                 if(bf.length()>0) {
  1540.                     bf.append("\t");
  1541.                 }
  1542.                 // i parametri non servono per identificare una risorsa
  1543.                 bf.append("URL:").append(requestInfo.getProtocolContext().getUrlInvocazioneWithoutParameters());
  1544.             }
  1545.             
  1546.             if(!headerInKey.isEmpty()) {
  1547.                 for (String header : headerInKey) {
  1548.                     String s = requestInfo.getProtocolContext().getHeader_compactMultipleValues(header);
  1549.                     if(s!=null) {
  1550.                         if(bf.length()>0) {
  1551.                             bf.append("\t");
  1552.                         }
  1553.                         bf.append(header).append(":").append(s);
  1554.                     }
  1555.                 }
  1556.             }

  1558.         }
  1559.         else {
  1560.             return null;
  1561.         }
  1562.         
  1563.         if( ServiceBinding.SOAP.equals(serviceBinding) && soapStreamReader!=null) {
  1564.             if(soapStreamReader.getRootElementLocalName()!=null && soapStreamReader.getRootElementNamespace()!=null) {
  1565.                 if(bf.length()>0) {
  1566.                     bf.append("\t");
  1567.                 }
  1568.                 bf.append("soapRootElement:{").
  1569.                     append(soapStreamReader.getRootElementNamespace()).
  1570.                     append("}").
  1571.                     append(soapStreamReader.getRootElementLocalName());
  1572.             }
  1573.             else {
  1574.                 return null;
  1575.             }
  1576.         }
  1577.         
  1578.         return bf.toString();
  1579.     }
  1580.     
  1581.     
  1582.     // ******** FRUITORI **********
  1583.     private static final String FRUITORE_TRASPORTO = "trasparto";
  1584.     private static final String FRUITORE_TOKEN = "token";
  1585.     private static final String FRUITORE_TOKEN_MODI = "token-modi";
  1586.     public static RequestFruitore readFruitoreTrasporto(RequestInfo requestInfo, IDSoggetto idSoggetto, IDServizioApplicativo servizioApplicativo) {
  1587.         return readFruitoreEngine(requestInfo, idSoggetto, servizioApplicativo, null, FRUITORE_TRASPORTO, true, false);
  1588.     }
  1589.     public static RequestFruitore readFruitoreToken(RequestInfo requestInfo, IDSoggetto idSoggetto, IDServizioApplicativo servizioApplicativo) {
  1590.         return readFruitoreEngine(requestInfo, idSoggetto, servizioApplicativo, null, FRUITORE_TOKEN, false, false);
  1591.     }
  1592.     public static RequestFruitore readFruitoreTokenModI(RequestInfo requestInfo, String certificateKey) {
  1593.         return readFruitoreEngine(requestInfo, null, null, certificateKey, FRUITORE_TOKEN_MODI, false, true);
  1594.     }
  1595.     private static RequestFruitore readFruitoreEngine(RequestInfo requestInfo, IDSoggetto idSoggetto, IDServizioApplicativo servizioApplicativo, String certificateKey, 
  1596.             String tipo, boolean trasporto, boolean tokenModi) {
  1597.         String key = null;
  1598.         if(tokenModi) {     
  1599.             key = buildKey(null, null, certificateKey, tipo, tokenModi);
  1600.         }
  1601.         else {
  1602.             key = buildKey(idSoggetto, servizioApplicativo,null, tipo, tokenModi);
  1603.         }
  1604.         if(key==null &&
  1605.             useCache) {
  1606.             return null;
  1607.         }
  1608.         if(useCache) {
  1609.             readFruitoreEngine(requestInfo, key, trasporto);
  1610.         }
  1611.         if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null) {
  1612.             if(trasporto) {
  1613.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo()!=null) {
  1614.                     return requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo();
  1615.                 }   
  1616.                 else {
  1617.                     return null;
  1618.                 }
  1619.             }
  1620.             else {
  1621.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo()!=null) {
  1622.                     return requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo();
  1623.                 }   
  1624.                 else {
  1625.                     return null;
  1626.                 }
  1627.             }
  1628.         }
  1629.         else {
  1630.             return null;
  1631.         }
  1632.     }
  1633.         
  1634.     public static RequestFruitore readFruitoreEngine(RequestInfo requestInfo, String key, boolean trasporto) {
  1635.         
  1636.         if(requestInfo==null || requestInfo.getRequestThreadContext()==null) {
  1637.             return null;
  1638.         }
  1639.         
  1640.         if(cacheFruitori==null) {
  1641.             return null;
  1642.         }
  1643.         
  1644.         org.openspcoop2.utils.cache.CacheResponse response = 
  1645.                 (org.openspcoop2.utils.cache.CacheResponse) cacheFruitori.get(key);
  1646.         if(response != null &&
  1647.             response.getObject()!=null){
  1648.             RequestFruitore rf = (RequestFruitore) response.getObject(); 
  1649.             /** System.out.println("TROVATO FUITORE IN CACHE ("+rf.isCached()+")");*/
  1650.             if(trasporto) {
  1651.                 requestInfo.getRequestThreadContext().setRequestFruitoreTrasportoInfo(rf);
  1652.             }
  1653.             else {
  1654.                 requestInfo.getRequestThreadContext().setRequestFruitoreTokenInfo(rf);
  1655.             }
  1656.             return rf;
  1657.         }
  1658.         
  1659.         /** System.out.println("FRUITORE NON TROVATO IN CACHE");*/
  1660.         return null;
  1661.         
  1662.     }
  1663.     
  1664.     public static void saveRequestFruitoreTrasporto(RequestInfo requestInfo, RequestFruitore rf)throws UtilsException {
  1665.          saveRequestFruitoreEngine(requestInfo, rf, FRUITORE_TRASPORTO, true, false);
  1666.     }
  1667.     public static void saveRequestFruitoreToken(RequestInfo requestInfo, RequestFruitore rf)throws UtilsException {
  1668.          saveRequestFruitoreEngine(requestInfo, rf, FRUITORE_TOKEN, false, false);
  1669.     }
  1670.     public static void saveRequestFruitoreTokenModI(RequestInfo requestInfo, RequestFruitore rf)throws UtilsException {
  1671.          saveRequestFruitoreEngine(requestInfo, rf, FRUITORE_TOKEN_MODI, false, true);
  1672.     }
  1673.     private static void saveRequestFruitoreEngine(RequestInfo requestInfo, RequestFruitore rf, 
  1674.             String tipo, boolean trasporto, boolean tokenModi) throws UtilsException {
  1675.         if(requestInfo==null || requestInfo.getRequestThreadContext()==null || rf==null) {
  1676.             return;
  1677.         }   
  1678.         
  1679.         String key = null;
  1680.         if(useCache) {
  1681.             if(tokenModi) {
  1682.                 if(rf.getCertificateKey()==null) {
  1683.                     return;
  1684.                 }
  1685.                 key = buildKey(null, null, rf.getCertificateKey(), tipo, tokenModi);
  1686.             }
  1687.             else {
  1688.                 if(rf.getIdSoggettoFruitore()==null) {
  1689.                     return;
  1690.                 }
  1691.                 key = buildKey(rf.getIdSoggettoFruitore(), rf.getIdServizioApplicativoFruitore(), null, tipo, tokenModi);
  1692.             }
  1693.             if(key==null) {
  1694.                 return;
  1695.             }
  1696.         }
  1697.         else {
  1698.             key=KEY_IN_MEMORY_ONLY;
  1699.         }
  1700.         
  1701.         rf.setKey(key);
  1702.         rf.setCached(false);
  1703.         if(trasporto) {
  1704.             requestInfo.getRequestThreadContext().setRequestFruitoreTrasportoInfo(rf);
  1705.         }
  1706.         else {
  1707.             requestInfo.getRequestThreadContext().setRequestFruitoreTokenInfo(rf);
  1708.         }
  1709.         
  1710.         
  1711.         if(!useCache || cacheFruitori==null) {
  1712.             return; // salvo solo nel thread context
  1713.         }
  1714.         
  1715.         String idTransazione = requestInfo.getIdTransazione();
  1716.         
  1717.         RequestFruitore requestFruitore = null;
  1718.         if(trasporto) {
  1719.             requestFruitore = requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo();
  1720.         }
  1721.         else {
  1722.             requestFruitore = requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo();
  1723.         }
  1724.         
  1725.         if(!requestFruitore.isCached()) {
  1726.             SemaphoreLock lock = lockCache_fruitori.acquire("saveRequestFruitore", idTransazione);
  1727.             try {
  1728.                 org.openspcoop2.utils.cache.CacheResponse response = 
  1729.                         (org.openspcoop2.utils.cache.CacheResponse) cacheFruitori.get(key);
  1730.                 if(response == null){
  1731.                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1732.                     requestFruitore.setCached(true);
  1733.                     responseCache.setObject(requestFruitore);
  1734.                     cacheFruitori.put(key,responseCache);
  1735.                     /** System.out.println("FRUITORE SALVATO IN CACHE con chiave ["+requestInfo.getRequestThreadContext().getRequestFruitoreInfo().getKey()+"]"); */
  1736.                 }
  1737.                 else {
  1738.                     /** System.out.println("FUITORE NON SALVATO IN CACHE, GIA PRESENTE"); */
  1739.                 }
  1740.                 
  1741.             }finally {
  1742.                 lockCache_fruitori.release(lock, "saveRequestFruitore", idTransazione);
  1743.             }
  1744.         }
  1745.         
  1746.     }
  1747.     
  1748.     private static String buildKey(IDSoggetto idSoggetto, IDServizioApplicativo servizioApplicativo, String certificateKey, String tipo, boolean tokenModi) {
  1749.                 
  1750.         StringBuilder bf = new StringBuilder();
  1751.         bf.append("auth:").append(tipo);
  1752.         
  1753.         if(tokenModi) {
  1754.             if(certificateKey==null) {
  1755.                 return null;
  1756.             }
  1757.             bf.append(" cert:");
  1758.             bf.append(certificateKey);
  1759.         }
  1760.         else {
  1761.             if(idSoggetto==null) {
  1762.                 return null;
  1763.             }
  1764.             bf.append(" soggetto:");
  1765.             bf.append(idSoggetto.toString());
  1766.             
  1767.             bf.append(" sa:");
  1768.             if(servizioApplicativo!=null) {
  1769.                 bf.append(servizioApplicativo.toFormatString());
  1770.             }
  1771.             else {
  1772.                 bf.append("-");
  1773.             }
  1774.         }
  1775.         
  1776.         return bf.toString();
  1777.     }
  1778.     
  1779.     public static String toCertificateKey(CertificateInfo certificateInfo) {
  1780.         StringBuilder sb = new StringBuilder();
  1781.         sb.append("[");
  1782.         if(certificateInfo.getSubject()!=null) {
  1783.             sb.append("subject:");
  1784.             sb.append(certificateInfo.getSubject().toString());
  1785.         }
  1786.         else {
  1787.             return null;
  1788.         }
  1789.         if(certificateInfo.getIssuer()!=null) {
  1790.             sb.append(" issuer:");
  1791.             sb.append(certificateInfo.getIssuer().toString());
  1792.         }
  1793.         else {
  1794.             return null;
  1795.         }
  1796.         if(certificateInfo.getSerialNumber()!=null) {
  1797.             sb.append(" serialNumber:");
  1798.             sb.append(certificateInfo.getSerialNumber());
  1799.         }
  1800.         else {
  1801.             return null;
  1802.         }
  1803.         sb.append("]");
  1804.         return sb.toString();
  1805.     }
  1806. }
Created with JaCoCo 0.8.8.202204050719