PolicyGroupByActiveThreadsDistributedCounters.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.controllo_traffico.policy.driver;

  23. import java.io.Serializable;
  24. import java.util.ArrayList;
  25. import java.util.Date;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;

  30. import org.openspcoop2.core.controllo_traffico.beans.ActivePolicy;
  31. import org.openspcoop2.core.controllo_traffico.beans.DatiCollezionati;
  32. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupBy;
  33. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicy;
  34. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicyMapId;
  35. import org.openspcoop2.core.controllo_traffico.beans.IDatiCollezionatiDistributed;
  36. import org.openspcoop2.core.controllo_traffico.beans.MisurazioniTransazione;
  37. import org.openspcoop2.core.controllo_traffico.beans.UniqueIdentifierUtilities;
  38. import org.openspcoop2.core.controllo_traffico.constants.Costanti;
  39. import org.openspcoop2.core.controllo_traffico.driver.IPolicyGroupByActiveThreadsInMemory;
  40. import org.openspcoop2.core.controllo_traffico.driver.PolicyException;
  41. import org.openspcoop2.core.controllo_traffico.driver.PolicyNotFoundException;
  42. import org.openspcoop2.protocol.utils.EsitiProperties;
  43. import org.openspcoop2.utils.Map;
  44. import org.openspcoop2.utils.SemaphoreLock;
  45. import org.openspcoop2.utils.UtilsException;
  46. import org.slf4j.Logger;

  48. /**
  49.  * PolicyGroupByActiveThreadsDistributedCounters
  50.  *
  51.  * @author Francesco Scarlato (scarlato@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */
  55. public class PolicyGroupByActiveThreadsDistributedCounters implements Serializable,IPolicyGroupByActiveThreadsInMemory {

  57.     private static final long serialVersionUID = 1L;

  59.     private transient org.openspcoop2.utils.Semaphore _lock = null; // usato solo in creazione e quando si accede a tutta la mappa
  60.     private synchronized void initLock() {
  61.         if(this._lock==null) {
  62.             this._lock = new org.openspcoop2.utils.Semaphore("PolicyGroupByActiveThreadsDistributedCounters"); 
  63.         }
  64.     }
  65.     public org.openspcoop2.utils.Semaphore getLock(){
  66.         if(this._lock==null) {
  67.             initLock();
  68.         }
  69.         return this._lock;
  70.     }   
  71.     
  72.     private final java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> mapActiveThreads = new HashMap<IDUnivocoGroupByPolicy, DatiCollezionati>();
  73.     
  74.     private String uniqueIdMap_idActivePolicy;
  75.     @SuppressWarnings("unused")
  76.     private Date uniqueIdMap_updateTime;
  77.     
  78.     private final ActivePolicy activePolicy;
  79.     private final BuilderDatiCollezionatiDistributed builderDatiCollezionati;

  81.     public PolicyGroupByActiveThreadsDistributedCounters(ActivePolicy activePolicy, String uniqueIdMap, BuilderDatiCollezionatiDistributed builder) throws PolicyException {
  82.         this.activePolicy = activePolicy;
  83.         this.builderDatiCollezionati = builder;
  84.         
  85.         this.uniqueIdMap_idActivePolicy = UniqueIdentifierUtilities.extractIdActivePolicy(uniqueIdMap);
  86.         try {
  87.             this.uniqueIdMap_updateTime = UniqueIdentifierUtilities.extractUpdateTimeActivePolicy(uniqueIdMap);
  88.         }catch(Exception e) {
  89.             throw new PolicyException(e.getMessage(),e);
  90.         }
  91.     }


  94.     @Override
  95.     public ActivePolicy getActivePolicy() {
  96.         return this.activePolicy;
  97.     }
  98.     @Override
  99.     public java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> getMapActiveThreads(){
  100.         return this.mapActiveThreads;
  101.     }


  104.     @Override
  105.     public void initMap(java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> map) {
  106.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("initMap");
  107.         try {
  108.             if(map!=null && !map.isEmpty()) {
  109.                 for (IDUnivocoGroupByPolicy datiGroupBy : map.keySet()) {
  110.                     IDUnivocoGroupByPolicyMapId datiGroupByMapId = augmentIDUnivoco(datiGroupBy);
  111.                     DatiCollezionati dati = map.get(datiGroupBy);
  112.                     DatiCollezionati datiContatoriDistribuiti = this.builderDatiCollezionati.build(dati, datiGroupByMapId, this.activePolicy);
  113.                     this.mapActiveThreads.put(datiGroupByMapId, datiContatoriDistribuiti);
  114.                 }
  115.             }
  116.         }
  117.         finally {
  118.             this.getLock().release(slock, "initMap");
  119.         }
  120.     }


  123.     @Override
  124.     public void resetCounters(){

  126.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("resetCounters");
  127.         try {
  128.             if(this.mapActiveThreads.size()>0){
  129.                 Iterator<DatiCollezionati> datiCollezionati = this.mapActiveThreads.values().iterator();
  130.                 while (datiCollezionati.hasNext()) {
  131.                     DatiCollezionati item = datiCollezionati.next();
  132.                     item.resetCounters();
  133.                 }
  134.             }
  135.         }
  136.         finally {
  137.             this.getLock().release(slock, "resetCounters");
  138.         }
  139.     }
  140.     
  141.     
  142.     @Override
  143.     public void remove() throws UtilsException {
  144.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("remove");

  146.         try {
  147.             List<IDUnivocoGroupByPolicy> deleteList = new ArrayList<>();
  148.             for (IDUnivocoGroupByPolicy datiGroupBy : this.mapActiveThreads.keySet()) {
  149.                 if(datiGroupBy instanceof IDUnivocoGroupByPolicyMapId){
  150.                     IDUnivocoGroupByPolicyMapId mapId = (IDUnivocoGroupByPolicyMapId) datiGroupBy;
  151.                     if(this.uniqueIdMap_idActivePolicy.equals(mapId.getUniqueMapId())) {
  152.                         deleteList.add(datiGroupBy);
  153.                     }
  154.                 }
  155.             }
  156.             while(!deleteList.isEmpty()) {
  157.                 IDUnivocoGroupByPolicy id = deleteList.remove(0);
  158.                 IDatiCollezionatiDistributed dati = (IDatiCollezionatiDistributed) this.mapActiveThreads.remove(id);    
  159.                 dati.destroyDatiDistribuiti();
  160.             }
  161.             
  162.         }   finally {
  163.             this.getLock().release(slock, "remove");
  164.         }
  165.     }


  168.     private DatiCollezionati initStartRequest(Logger log, String idTransazione, IDUnivocoGroupByPolicyMapId datiGroupByMapId, Map<Object> ctx) throws PolicyException{
  169.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("initStartRequest");
  170.         DatiCollezionati datiCollezionati = null;
  171.         try {
  172.             datiCollezionati = this.mapActiveThreads.get(datiGroupByMapId);
  173.             if (datiCollezionati == null){              
  174.                 datiCollezionati = this.builderDatiCollezionati.build( 
  175.                         this.activePolicy.getInstanceConfiguration().getUpdateTime(), 
  176.                         datiGroupByMapId,
  177.                         this.activePolicy,
  178.                         ctx
  179.                         );

  181.                 this.mapActiveThreads.put(datiGroupByMapId, datiCollezionati); // registro nuova immagine
  182.             }
  183.             // La gestione dell'else è stata spostata dentro il costruttore degli oggetti DatiCollezionatiDistributedXXXX
  184. /**         else {
  185. //              if(datiCollezionati.getUpdatePolicyDate()!=null) {
  186. //                  if(!datiCollezionati.getUpdatePolicyDate().equals(this.activePolicy.getInstanceConfiguration().getUpdateTime())) {
  187. //                      // data aggiornata
  188. //                      datiCollezionati.resetCounters(this.activePolicy.getInstanceConfiguration().getUpdateTime());
  189. //                  }
  190. //              }
  191. //          }*/
  192.             return datiCollezionati;
  193.         }
  194.         finally {
  195.             this.getLock().release(slock, "initStartRequest");
  196.         }
  197.     }
  198.     @Override
  199.     public DatiCollezionati registerStartRequest(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException{

  201.         IDUnivocoGroupByPolicyMapId datiGroupByMapId = augmentIDUnivoco(datiGroupBy);
  202.         DatiCollezionati datiCollezionati = this.mapActiveThreads.get(datiGroupByMapId);
  203.         if (datiCollezionati == null){              
  204.             datiCollezionati = initStartRequest(log, idTransazione, datiGroupByMapId, ctx);
  205.         }
  206.         DatiCollezionati datiCollezionatiPerPolicyVerifier = datiCollezionati.newInstance(); // i valori utilizzati dal policy verifier verranno impostati con il valore remoto corretto
  207.         // l'oggetto datiCollezionati, anche se appena creato, è già stato inizializzato dentro il costruttore di DatiCollezionatiXXX
  208.         
  209.         // incremento il numero di thread
  210.         datiCollezionati.registerStartRequest(log, this.activePolicy, ctx, datiCollezionatiPerPolicyVerifier);
  211.         
  212.         return datiCollezionatiPerPolicyVerifier;

  214.     }


  217.     @Override
  218.     public DatiCollezionati updateDatiStartRequestApplicabile(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException,PolicyNotFoundException{

  220.         IDUnivocoGroupByPolicyMapId datiGroupByMapId = augmentIDUnivoco(datiGroupBy);
  221.         DatiCollezionati datiCollezionati = this.mapActiveThreads.get(datiGroupByMapId);
  222.         if(datiCollezionati == null) {
  223.             throw new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupByMapId.toString()+"]");
  224.         }
  225.         DatiCollezionati datiCollezionatiPerPolicyVerifier = datiCollezionati.newInstance(); // i valori utilizzati dal policy verifier verranno impostati con il valore remoto corretto
  226.         
  227.         // incremento il numero dei contatori
  228.         boolean updated = datiCollezionati.updateDatiStartRequestApplicabile(log, this.activePolicy, ctx, datiCollezionatiPerPolicyVerifier);

  230.         // mi salvo fuori dal synchronized l'attuale stato
  231.         if(updated) {
  232.             return datiCollezionatiPerPolicyVerifier;
  233.         }

  235.         return null;
  236.     }


  239.     @Override
  240.     public void registerStopRequest(Logger log, String idTransazione,IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx, 
  241.             MisurazioniTransazione dati, boolean isApplicabile, boolean isViolata) throws PolicyException,PolicyNotFoundException{

  243.         IDUnivocoGroupByPolicyMapId datiGroupByMapId = augmentIDUnivoco(datiGroupBy);
  244.         DatiCollezionati datiCollezionati =  this.mapActiveThreads.get(datiGroupByMapId);
  245.         if(datiCollezionati == null) {
  246.             throw new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupByMapId.toString()+"]");
  247.         }
  248.         
  249.         datiCollezionati.registerEndRequest(log, this.activePolicy, ctx, dati);
  250.         if(isApplicabile){

  252.             List<Integer> esitiCodeOk = null;
  253.             List<Integer> esitiCodeKoSenzaFaultApplicativo = null;
  254.             List<Integer> esitiCodeFaultApplicativo = null;
  255.             try {
  256.                 EsitiProperties esitiProperties = EsitiProperties.getInstanceFromProtocolName(log,dati.getProtocollo());
  257.                 esitiCodeOk = esitiProperties.getEsitiCodeOk_senzaFaultApplicativo();
  258.                 esitiCodeKoSenzaFaultApplicativo = esitiProperties.getEsitiCodeKo_senzaFaultApplicativo();
  259.                 esitiCodeFaultApplicativo = esitiProperties.getEsitiCodeFaultApplicativo();
  260.             }catch(Exception e) {
  261.                 throw new PolicyException(e.getMessage(),e);
  262.             }
  263.             datiCollezionati.updateDatiEndRequestApplicabile(log, this.activePolicy, ctx, dati,
  264.                     esitiCodeOk,esitiCodeKoSenzaFaultApplicativo, esitiCodeFaultApplicativo, isViolata);
  265.         }

  267.     }


  270.     @Override
  271.     public long getActiveThreads(){
  272.         return this.getActiveThreads(null);
  273.     }
  274.     @Override
  275.     public long getActiveThreads(IDUnivocoGroupByPolicy filtro){

  277.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("getActiveThreads");
  278.         try {
  279.             long counter = 0l;

  281.             if(this.mapActiveThreads!=null && !this.mapActiveThreads.isEmpty()) {
  282.                 for (IDUnivocoGroupByPolicy datiGroupBy : this.mapActiveThreads.keySet()) {
  283.     
  284.                     if(filtro!=null){
  285.                         IDUnivocoGroupBy<IDUnivocoGroupByPolicy> idAstype = datiGroupBy;
  286.                         if(!idAstype.match(filtro)){
  287.                             continue;
  288.                         }
  289.                     }
  290.     
  291.                     counter = counter + this.mapActiveThreads.get(datiGroupBy).getActiveRequestCounter();
  292.                 }
  293.             }

  295.             return counter;
  296.         }
  297.         finally {
  298.             this.getLock().release(slock, "getActiveThreads");
  299.         }

  301.     }


  304.     @Override
  305.     public String printInfos(Logger log, String separatorGroups) throws UtilsException{

  307.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("printInfos");
  308.         try {
  309.             StringBuilder bf = new StringBuilder();
  310.             if(this.mapActiveThreads!=null && !this.mapActiveThreads.isEmpty()) {
  311.                 for (IDUnivocoGroupByPolicy datiGroupBy : this.mapActiveThreads.keySet()) {
  312.                     bf.append(separatorGroups);
  313.                     bf.append("\n");
  314.                     bf.append(Costanti.LABEL_MODALITA_SINCRONIZZAZIONE).append(" ").append(this.builderDatiCollezionati.tipoPolicy.toLabel());
  315.                     bf.append("\n");
  316.                     bf.append("Criterio di Collezionamento dei Dati\n");
  317.                     bf.append(datiGroupBy.toString(true));
  318.                     bf.append("\n");
  319.                     this.mapActiveThreads.get(datiGroupBy).checkDate(log, this.activePolicy); // imposta correttamente gli intervalli
  320.                     bf.append(this.mapActiveThreads.get(datiGroupBy).toString());
  321.                     bf.append("\n");
  322.                 }
  323.             }
  324.             if(bf.length()<=0){
  325.                 bf.append("Nessuna informazione disponibile");
  326.                 return bf.toString();
  327.             }
  328.             else{
  329.                 return bf.toString()+separatorGroups;
  330.             }
  331.         }
  332.         finally {
  333.             this.getLock().release(slock, "printInfos");
  334.         }

  336.     }


  339.     protected IDUnivocoGroupByPolicyMapId augmentIDUnivoco(IDUnivocoGroupByPolicy idUnivoco) {
  340.         if(idUnivoco instanceof IDUnivocoGroupByPolicyMapId) {
  341.             return (IDUnivocoGroupByPolicyMapId) idUnivoco;
  342.         }
  343.         else {
  344.             return new IDUnivocoGroupByPolicyMapId(idUnivoco, this.uniqueIdMap_idActivePolicy); // NOTA: non serve gestirlo all'interno poichè verrà creato un nuovo identificativo //, this.uniqueIdMap_updateTime);
  345.         }
  346.     }
  347. }
Created with JaCoCo 0.8.8.202204050719