PolicyGroupByActiveThreadsDistributedCountersWithLock.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.  * PolicyGroupByActiveThreadsDistributedCountersWithLock
  50.  *
  51.  * @author Francesco Scarlato (scarlato@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */
  55. public class PolicyGroupByActiveThreadsDistributedCountersWithLock implements Serializable,IPolicyGroupByActiveThreadsInMemory {

  57.     private static final long serialVersionUID = 1L;

  59.     private transient org.openspcoop2.utils.Semaphore _lock = null; 
  60.     private synchronized void initLock() {
  61.         if(this._lock==null) {
  62.             this._lock = new org.openspcoop2.utils.Semaphore("PolicyGroupByActiveThreadsDistributedCountersWithLock"); 
  63.         }
  64.     }
  65.     public org.openspcoop2.utils.Semaphore getLock(){
  66.         if(this._lock==null) {
  67.             initLock();
  68.         }
  69.         return this._lock;
  70.     }   

  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 PolicyGroupByActiveThreadsDistributedCountersWithLock(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.     @Override
  169.     public DatiCollezionati registerStartRequest(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException{

  171.         DatiCollezionati datiCollezionati;

  173.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("registerStartRequest");
  174.         try {
  175.             IDUnivocoGroupByPolicyMapId datiGroupByMapId = augmentIDUnivoco(datiGroupBy);
  176.             datiCollezionati = this.mapActiveThreads.get(datiGroupByMapId);
  177.             if (datiCollezionati == null){              
  178.                 datiCollezionati = this.builderDatiCollezionati.build( 
  179.                         this.activePolicy.getInstanceConfiguration().getUpdateTime(), 
  180.                         datiGroupByMapId,
  181.                         this.activePolicy,
  182.                         ctx
  183.                         );

  185.                 this.mapActiveThreads.put(datiGroupByMapId, datiCollezionati); // registro nuova immagine
  186.             }
  187.             // La gestione dell'else è stata spostata dentro il costruttore degli oggetti DatiCollezionatiDistributedXXXX
  188. /**         else {
  189. //              if(datiCollezionati.getUpdatePolicyDate()!=null) {
  190. //                  if(!datiCollezionati.getUpdatePolicyDate().equals(this.activePolicy.getInstanceConfiguration().getUpdateTime())) {
  191. //                      // data aggiornata
  192. //                      datiCollezionati.resetCounters(this.activePolicy.getInstanceConfiguration().getUpdateTime());
  193. //                  }
  194. //              }
  195. //          }*/
  196.                         
  197.             // incremento il numero di thread
  198.             datiCollezionati.registerStartRequest(log, this.activePolicy, ctx);

  200.             return datiCollezionati.newInstance();
  201.         }
  202.         finally {
  203.             this.getLock().release(slock, "registerStartRequest");
  204.         }

  206.     }


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

  212.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("updateDatiStartRequestApplicabile");

  214.         try {
  215.             IDUnivocoGroupByPolicyMapId datiGroupByMapId = augmentIDUnivoco(datiGroupBy);
  216.             DatiCollezionati datiCollezionati = this.mapActiveThreads.get(datiGroupByMapId);
  217.             if(datiCollezionati == null) {
  218.                 throw new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupByMapId.toString()+"]");
  219.             }

  221.             // incremento il numero dei contatori
  222.             boolean updated = datiCollezionati.updateDatiStartRequestApplicabile(log, this.activePolicy, ctx);

  224.             // mi salvo fuori dal synchronized l'attuale stato
  225.             if(updated) {
  226.                 return datiCollezionati.newInstance();
  227.             }

  229.         }
  230.         finally {
  231.             this.getLock().release(slock, "updateDatiStartRequestApplicabile");
  232.         }

  234.         return null;
  235.     }


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

  242.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("registerStopRequest");
  243.         try {
  244.             IDUnivocoGroupByPolicyMapId datiGroupByMapId = augmentIDUnivoco(datiGroupBy);
  245.             DatiCollezionati datiCollezionati =  this.mapActiveThreads.get(datiGroupByMapId);
  246.             if(datiCollezionati == null) {
  247.                 throw new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupByMapId.toString()+"]");
  248.             }

  250.             datiCollezionati.registerEndRequest(log, this.activePolicy, ctx, dati);
  251.             if(isApplicabile){

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

  268.         }
  269.         finally {
  270.             this.getLock().release(slock, "registerStopRequest");
  271.         }

  273.     }


  276.     @Override
  277.     public long getActiveThreads(){
  278.         return this.getActiveThreads(null);
  279.     }
  280.     @Override
  281.     public long getActiveThreads(IDUnivocoGroupByPolicy filtro){

  283.         SemaphoreLock slock = this.getLock().acquireThrowRuntime("getActiveThreads");
  284.         try {
  285.             long counter = 0l;

  287.             if(this.mapActiveThreads!=null && !this.mapActiveThreads.isEmpty()) {
  288.                 for (IDUnivocoGroupByPolicy datiGroupBy : this.mapActiveThreads.keySet()) {
  289.     
  290.                     if(filtro!=null){
  291.                         IDUnivocoGroupBy<IDUnivocoGroupByPolicy> idAstype = datiGroupBy;
  292.                         if(!idAstype.match(filtro)){
  293.                             continue;
  294.                         }
  295.                     }
  296.     
  297.                     counter = counter + this.mapActiveThreads.get(datiGroupBy).getActiveRequestCounter();
  298.                 }
  299.             }

  301.             return counter;
  302.         }
  303.         finally {
  304.             this.getLock().release(slock, "getActiveThreads");
  305.         }

  307.     }


  310.     @Override
  311.     public String printInfos(Logger log, String separatorGroups) throws UtilsException{

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

  342.     }


  345.     protected IDUnivocoGroupByPolicyMapId augmentIDUnivoco(IDUnivocoGroupByPolicy idUnivoco) {
  346.         if(idUnivoco instanceof IDUnivocoGroupByPolicyMapId) {
  347.             return (IDUnivocoGroupByPolicyMapId) idUnivoco;
  348.         }
  349.         else {
  350.             return new IDUnivocoGroupByPolicyMapId(idUnivoco, this.uniqueIdMap_idActivePolicy); // NOTA: non serve gestirlo all'interno poichè verrà creato un nuovo identificativo //, this.uniqueIdMap_updateTime);
  351.         }
  352.     }
  353. }
Created with JaCoCo 0.8.8.202204050719