PolicyGroupByActiveThreadsDistributedRedis.java

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

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

  26. import org.openspcoop2.core.controllo_traffico.beans.ActivePolicy;
  27. import org.openspcoop2.core.controllo_traffico.beans.DatiCollezionati;
  28. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupBy;
  29. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicy;
  30. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicyMapId;
  31. import org.openspcoop2.core.controllo_traffico.beans.MisurazioniTransazione;
  32. import org.openspcoop2.core.controllo_traffico.beans.UniqueIdentifierUtilities;
  33. import org.openspcoop2.core.controllo_traffico.constants.Costanti;
  34. import org.openspcoop2.core.controllo_traffico.driver.IPolicyGroupByActiveThreadsInMemory;
  35. import org.openspcoop2.core.controllo_traffico.driver.PolicyException;
  36. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  37. import org.openspcoop2.core.controllo_traffico.driver.PolicyNotFoundException;
  38. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  39. import org.openspcoop2.pdd.core.controllo_traffico.policy.PolicyDateUtils;
  40. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  41. import org.openspcoop2.protocol.utils.EsitiProperties;
  42. import org.openspcoop2.utils.Map;
  43. import org.openspcoop2.utils.UtilsException;
  44. import org.redisson.api.RMap;
  45. import org.redisson.api.RTransaction;
  46. import org.redisson.api.RedissonClient;
  47. import org.redisson.api.TransactionOptions;
  48. import org.redisson.transaction.TransactionException;
  49. import org.slf4j.Logger;

  51. /**     
  52.  *  PolicyGroupByActiveThreadsDistributedRedis
  53.  *
  54.  * @author Francesco Scarlato (scarlato@link.it)
  55.  * @author $Author$
  56.  * @version $Rev$, $Date$
  57.  */
  58. public class PolicyGroupByActiveThreadsDistributedRedis  implements IPolicyGroupByActiveThreadsInMemory  {
  59.     
  60.     private final ActivePolicy activePolicy;
  61.     private final RedissonClient redisson;
  62.     private final RMap<IDUnivocoGroupByPolicy, DatiCollezionati> distributedMap;
  63.     private String mapId = null;
  64.     
  65.     protected PolicyGroupByActiveThreadsType type;
  66.     
  67.     protected String uniqueIdMap_idActivePolicy;
  68.     protected Date uniqueIdMap_updateTime;
  69.     
  70.     public PolicyGroupByActiveThreadsDistributedRedis(ActivePolicy activePolicy, String uniqueIdMap,
  71.             RedissonClient redisson) throws PolicyException {
  72.         this.activePolicy = activePolicy;
  73.         this.redisson = redisson;
  74.         
  75.         this.uniqueIdMap_idActivePolicy = UniqueIdentifierUtilities.extractIdActivePolicy(uniqueIdMap);
  76.         try {
  77.             this.uniqueIdMap_updateTime = UniqueIdentifierUtilities.extractUpdateTimeActivePolicy(uniqueIdMap);
  78.         }catch(Exception e) {
  79.             throw new PolicyException(e.getMessage(),e);
  80.         }
  81.         
  82.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  83.         Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(op2Properties.isControlloTrafficoDebug());
  84.         
  85.         this.type = PolicyGroupByActiveThreadsType.REDISSON_MAP;
  86.         
  87.         boolean oneMapForeachPolicy = OpenSPCoop2Properties.getInstance().isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy();
  88.         String mapName = "redis-";
  89.         if (oneMapForeachPolicy) {
  90.             this.mapId = mapName + this.uniqueIdMap_idActivePolicy + "-rate-limiting";
  91.             this.distributedMap = redisson.getMap(this.mapId);
  92.             log.info("Hazelcast: Utilizzo Una Distributed Map per gruppo.");
  93.         } else {
  94.             this.mapId = mapName + "rate-limiting";
  95.             this.distributedMap = redisson.getMap(this.mapId);
  96.             log.info("Hazelcast: Utilizzo Una Distributed Map globale.");
  97.         }
  98.     }

  100.     
  101.     @Override
  102.     public DatiCollezionati registerStartRequest(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx)
  103.             throws PolicyException {
  104.         
  105.         RTransaction transaction = this.redisson.createTransaction(TransactionOptions.defaults());
  106.         RMap<IDUnivocoGroupByPolicy, DatiCollezionati> map = transaction.getMap(this.mapId);
  107.         
  108.         DatiCollezionati datiCollezionati = map.get(datiGroupBy);
  109.         if (datiCollezionati == null) {
  110.             Date gestorePolicyConfigDate = PolicyDateUtils.readGestorePolicyConfigDateIntoContext(ctx);
  111.             datiCollezionati = new DatiCollezionati(this.activePolicy.getInstanceConfiguration().getUpdateTime(), gestorePolicyConfigDate);
  112.         }
  113.         else {
  114.             if(datiCollezionati.getUpdatePolicyDate()!=null) {
  115.                 if(!datiCollezionati.getUpdatePolicyDate().equals(this.activePolicy.getInstanceConfiguration().getUpdateTime())) {
  116.                     // data aggiornata
  117.                     datiCollezionati.resetCounters(this.activePolicy.getInstanceConfiguration().getUpdateTime());
  118.                 }
  119.             }
  120.         }
  121.         
  122.         datiCollezionati.registerStartRequest(log, this.activePolicy, ctx);
  123.         
  124.         // mi salvo l'attuale stato
  125.         DatiCollezionati datiCollezionatiReaded = (DatiCollezionati) datiCollezionati.newInstance(); 
  126.         
  127.         map.fastPut(datiGroupBy, datiCollezionati);
  128.         
  129.         try {
  130.             transaction.commit();
  131.         } catch(TransactionException e) {
  132.             transaction.rollback();
  133.             throw new PolicyException("Errore durante la transazione registerStartRequest di Redis", e);
  134.         }
  135.         
  136.         return datiCollezionatiReaded;
  137.     }

  139.     
  140.     @Override
  141.     public DatiCollezionati updateDatiStartRequestApplicabile(Logger log, String idTransazione,
  142.             IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException, PolicyNotFoundException {
  143.         
  144.         RTransaction transaction = this.redisson.createTransaction(TransactionOptions.defaults());
  145.         RMap<IDUnivocoGroupByPolicy, DatiCollezionati> map = transaction.getMap(this.mapId);

  147.         DatiCollezionati datiCollezionati = map.get(datiGroupBy);
  148.         if(datiCollezionati == null){
  149.             throw new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");
  150.         }       
  151.         
  152.         datiCollezionati.updateDatiStartRequestApplicabile(log, this.activePolicy, ctx);
  153.         
  154.         // mi salvo l'attuale stato
  155.         DatiCollezionati datiCollezionatiReaded = (DatiCollezionati) datiCollezionati.newInstance(); 
  156.         
  157.         map.fastPut(datiGroupBy, datiCollezionati);
  158.         
  159.         try {
  160.             transaction.commit();
  161.         } catch(TransactionException e) {
  162.             transaction.rollback();
  163.             throw new PolicyException("Errore durante la transazione registerStartRequest di Redis", e);
  164.         }
  165.         
  166.         return datiCollezionatiReaded;
  167.     }

  169.     @Override
  170.     public void registerStopRequest(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx,
  171.             MisurazioniTransazione dati, boolean isApplicabile, boolean isViolata)
  172.             throws PolicyException, PolicyNotFoundException {
  173.         
  174.         RTransaction transaction = this.redisson.createTransaction(TransactionOptions.defaults());
  175.         RMap<IDUnivocoGroupByPolicy, DatiCollezionati> map = transaction.getMap(this.mapId);

  177.         DatiCollezionati datiCollezionati = map.get(datiGroupBy);
  178.         if(datiCollezionati == null){
  179.             throw new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");
  180.         }   
  181.         
  182.         if(isApplicabile) {
  183.             datiCollezionati.registerEndRequest(log, this.activePolicy, ctx, dati);
  184.             List<Integer> esitiCodeOk = null;
  185.             List<Integer> esitiCodeKo_senzaFaultApplicativo = null;
  186.             List<Integer> esitiCodeFaultApplicativo = null;
  187.             try {
  188.                 // In queste tre di sotto pare il logger non venga utilizzato
  189.                 EsitiProperties esitiProperties = EsitiProperties.getInstanceFromProtocolName(log,dati.getProtocollo());
  190.                 esitiCodeOk = esitiProperties.getEsitiCodeOk_senzaFaultApplicativo();
  191.                 esitiCodeKo_senzaFaultApplicativo = esitiProperties.getEsitiCodeKo_senzaFaultApplicativo();
  192.                 esitiCodeFaultApplicativo = esitiProperties.getEsitiCodeFaultApplicativo();
  193.                 datiCollezionati.updateDatiEndRequestApplicabile(
  194.                         log,    // logger
  195.                         this.activePolicy, ctx, dati,
  196.                         esitiCodeOk,esitiCodeKo_senzaFaultApplicativo, esitiCodeFaultApplicativo, 
  197.                         isViolata);
  198.             }catch(Exception e) {
  199.                 throw new PolicyException(e.getMessage(),e);
  200.             }
  201.             map.fastPut(datiGroupBy, datiCollezionati);
  202.         } else {
  203.             datiCollezionati.registerEndRequest(null, this.activePolicy, ctx, dati);
  204.             map.fastPut(datiGroupBy, datiCollezionati);
  205.         }
  206.         
  207.     }

  209.     
  210.     @Override
  211.     public ActivePolicy getActivePolicy() {
  212.         return this.activePolicy;
  213.     }

  215.     
  216.     @Override
  217.     public java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> getMapActiveThreads() {
  218.         return this.distributedMap;
  219.     }

  221.     
  222.     @Override
  223.     public void initMap(java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> map) {
  224.         this.distributedMap.putAll(map);        
  225.     }

  227.     
  228.     @Override
  229.     public long getActiveThreads() {
  230.         return getActiveThreads(null);
  231.     }

  233.     @Override
  234.     public long getActiveThreads(IDUnivocoGroupByPolicy filtro) {
  235.         long counter = 0;
  236.         
  237.         // Recupero tutta la map distribuita
  238.         var cloned = this.distributedMap.readAllEntrySet();
  239.         
  240.         for (var entry :  cloned) {
  241.             if(filtro!=null){
  242.                 IDUnivocoGroupBy<IDUnivocoGroupByPolicy> idAstype = (IDUnivocoGroupBy<IDUnivocoGroupByPolicy>) entry.getKey();
  243.                 if(!idAstype.match(filtro)){
  244.                     continue;
  245.                 }
  246.                 counter += entry.getValue().getActiveRequestCounter();
  247.             }
  248.         }
  249.         
  250.         return counter;
  251.     }

  253.     @Override
  254.     public void resetCounters() {
  255.         this.distributedMap.forEach( (var id, var dati) -> {
  256.             dati.resetCounters();
  257.         });
  258.     }
  259.     
  260.     @Override
  261.     public void remove() throws UtilsException{
  262.     //      FIX: iterando nella maniera sottostante si ottiene il seguente errore se si usa la near-cache: key cannot be of type Data! hazelcast 
  263.     //      for (var entry : this.distributedMap) {
  264.         List<IDUnivocoGroupByPolicy> deleteList = new ArrayList<IDUnivocoGroupByPolicy>();
  265.         for (IDUnivocoGroupByPolicy datiGroupBy : this.distributedMap.keySet()) {
  266.             if(datiGroupBy instanceof IDUnivocoGroupByPolicyMapId){
  267.                 IDUnivocoGroupByPolicyMapId mapId = (IDUnivocoGroupByPolicyMapId) datiGroupBy;
  268.                 if(this.uniqueIdMap_idActivePolicy.equals(mapId.getUniqueMapId())) {
  269.                     deleteList.add(datiGroupBy);
  270.                 }
  271.             }
  272.         }
  273.         while(!deleteList.isEmpty()) {
  274.             IDUnivocoGroupByPolicy id = deleteList.remove(0);
  275.             this.distributedMap.remove(id); 
  276.         }
  277.     }

  279.     @Override
  280.     public String printInfos(Logger log, String separatorGroups) throws UtilsException {
  281.         StringBuilder bf = new StringBuilder();

  283.         this.distributedMap.forEach( (var id, var dati) -> {
  284.             IDUnivocoGroupByPolicy datiGroupBy = id;
  285.             bf.append(separatorGroups);
  286.             bf.append("\n");
  287.             bf.append(Costanti.LABEL_MODALITA_SINCRONIZZAZIONE).append(" ").append(this.type.toLabel());
  288.             bf.append("\n");
  289.             bf.append("Criterio di Collezionamento dei Dati\n");
  290.             bf.append(datiGroupBy.toString(true));
  291.             bf.append("\n");
  292.             dati.checkDate(log, this.activePolicy); // imposta correttamente gli intervalli
  293.             bf.append(dati.toString());
  294.             bf.append("\n");            
  295.         });
  296.         
  297.         if(bf.length()<=0){
  298.             bf.append("Nessuna informazione disponibile");
  299.             return bf.toString();
  300.         }
  301.         else{
  302.             return bf.toString()+separatorGroups;
  303.         }
  304.     }

  306. }
Created with JaCoCo 0.8.8.202204050719