AbstractPolicyGroupByActiveThreadsDistributed.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.hazelcast;

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

  27. import org.openspcoop2.core.controllo_traffico.beans.ActivePolicy;
  28. import org.openspcoop2.core.controllo_traffico.beans.DatiCollezionati;
  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.UniqueIdentifierUtilities;
  32. import org.openspcoop2.core.controllo_traffico.constants.Costanti;
  33. import org.openspcoop2.core.controllo_traffico.driver.IPolicyGroupByActiveThreadsInMemory;
  34. import org.openspcoop2.core.controllo_traffico.driver.PolicyException;
  35. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  36. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  37. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  38. import org.openspcoop2.utils.UtilsException;
  39. import org.slf4j.Logger;

  41. import com.hazelcast.core.HazelcastInstance;
  42. import com.hazelcast.map.IMap;

  44. /**     
  45.  *  PolicyGroupByActiveThreadsDistributedAbstract
  46.  *
  47.  * @author Francesco Scarlato (scarlato@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public abstract class AbstractPolicyGroupByActiveThreadsDistributed implements IPolicyGroupByActiveThreadsInMemory {
  52.     
  53.     protected final HazelcastInstance hazelcast;
  54.     protected final IMap<IDUnivocoGroupByPolicy, DatiCollezionati> distributedMap;
  55.     protected final ActivePolicy activePolicy;
  56.     
  57.     protected PolicyGroupByActiveThreadsType type;
  58.     
  59.     protected String uniqueIdMap_idActivePolicy;
  60.     protected Date uniqueIdMap_updateTime;
  61.     
  62.     public AbstractPolicyGroupByActiveThreadsDistributed(ActivePolicy policy, String uniqueIdMap, PolicyGroupByActiveThreadsType type, HazelcastInstance hazelcast) throws PolicyException {
  63.         this.activePolicy = policy;
  64.         this.hazelcast = hazelcast;
  65.     
  66.         this.uniqueIdMap_idActivePolicy = UniqueIdentifierUtilities.extractIdActivePolicy(uniqueIdMap);
  67.         try {
  68.             this.uniqueIdMap_updateTime = UniqueIdentifierUtilities.extractUpdateTimeActivePolicy(uniqueIdMap);
  69.         }catch(Exception e) {
  70.             throw new PolicyException(e.getMessage(),e);
  71.         }
  72.         
  73.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  74.         Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(op2Properties.isControlloTrafficoDebug());
  75.     
  76.         this.type = type;
  77.         String mapName = "hazelcast-";
  78.         switch (type) {
  79.         case HAZELCAST_MAP:
  80.             mapName = "hazelcast-";
  81.             break;
  82.         case HAZELCAST_NEAR_CACHE:
  83.             mapName = "hazelcast-near-cache-";
  84.             break;
  85.         case HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP:
  86.             mapName = "hazelcast-near-cache-unsafe-sync-map-";
  87.             break;
  88.         case HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP:
  89.             mapName = "hazelcast-near-cache-unsafe-async-map-";
  90.             break;
  91.         case HAZELCAST_LOCAL_CACHE:
  92.             mapName = "hazelcast-local-cache-";
  93.             break;
  94.         default:
  95.             break;
  96.         }
  97.         
  98.         boolean oneMapForeachPolicy = OpenSPCoop2Properties.getInstance().isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy();
  99.         if(oneMapForeachPolicy && PolicyGroupByActiveThreadsType.HAZELCAST_LOCAL_CACHE.equals(this.type)) {
  100.             log.warn("Property isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy non compatibile con HAZELCAST_LOCAL_CACHE");
  101.             oneMapForeachPolicy = false;
  102.         }
  103.         
  104.         if (oneMapForeachPolicy) {
  105.             this.distributedMap = this.hazelcast.getMap(mapName + this.uniqueIdMap_idActivePolicy + "-rate-limiting");
  106.             log.info("Hazelcast: Utilizzo Una Distributed Map per gruppo.");
  107.         } else {
  108.             this.distributedMap = this.hazelcast.getMap(mapName+"rate-limiting");
  109.             log.info("Hazelcast: Utilizzo Una Distributed Map globale.");
  110.         }
  111.         
  112.         // dummy get per inizializzare la map
  113.         if(this.distributedMap.get(new IDUnivocoGroupByPolicy())!=null) {
  114.             // ignore
  115.         }

  117.     }
  118.     

  120.     @Override
  121.     public ActivePolicy getActivePolicy() {
  122.         return this.activePolicy;
  123.     }


  126.     @Override
  127.     public Map<IDUnivocoGroupByPolicy, DatiCollezionati> getMapActiveThreads() {
  128.         return this.distributedMap;
  129.     }
  130.     
  131.     public IMap<IDUnivocoGroupByPolicy, DatiCollezionati> getDistributedMapActiveThreads(){
  132.         return this.distributedMap;
  133.     }


  136.     @Override
  137.     public long getActiveThreads() {
  138.         return this.getActiveThreads(null);
  139.     }
  140.     
  141.     @Override
  142.     public void initMap(Map<IDUnivocoGroupByPolicy, DatiCollezionati> map) {
  143.         if(map!=null && !map.isEmpty()) {
  144.             for (IDUnivocoGroupByPolicy datiGroupBy : map.keySet()) {
  145.                 datiGroupBy = augmentIDUnivoco(datiGroupBy);
  146.                 DatiCollezionati dati = map.get(datiGroupBy);
  147.                 InitProcessor initProcessor = new InitProcessor(dati);
  148.                 this.distributedMap.executeOnKey(datiGroupBy, initProcessor);           
  149.             }
  150.         }
  151.         
  152.     }


  155.     @Override
  156.     public long getActiveThreads(IDUnivocoGroupByPolicy filtro) {

  158.         long counter = 0;
  159.         
  160.         // Quando leggo dalla distributedMap non aumento l'idUnivoco perchè
  161.         // mi aspetto che sulla map vengano già registrati così.
  162.         
  163.         if(filtro!=null){
  164.     //      FIX: iterando nella maniera sottostante si ottiene il seguente errore se si usa la near-cache: key cannot be of type Data! hazelcast 
  165.     //      for (var entry : this.distributedMap) {
  166.             for (IDUnivocoGroupByPolicy datiGroupBy : this.distributedMap.keySet()) {
  167.                 if(!datiGroupBy.match(filtro)){
  168.                     continue;
  169.                 }
  170.                 DatiCollezionati datiCollezionati = this.distributedMap.get(datiGroupBy);
  171.                 counter += datiCollezionati.getActiveRequestCounter();
  172.             }
  173.         }
  174.         
  175.         return counter;
  176.     }


  179.     @Override
  180.     public void resetCounters() {
  181.         this.distributedMap.executeOnEntries(new ResetCountersProcessor());
  182.     }

  184.     @Override
  185.     public void remove() throws UtilsException{
  186.     //      FIX: iterando nella maniera sottostante si ottiene il seguente errore se si usa la near-cache: key cannot be of type Data! hazelcast 
  187.     //      for (var entry : this.distributedMap) {
  188.         List<IDUnivocoGroupByPolicy> deleteList = new ArrayList<IDUnivocoGroupByPolicy>();
  189.         for (IDUnivocoGroupByPolicy datiGroupBy : this.distributedMap.keySet()) {
  190.             if(datiGroupBy instanceof IDUnivocoGroupByPolicyMapId){
  191.                 IDUnivocoGroupByPolicyMapId mapId = (IDUnivocoGroupByPolicyMapId) datiGroupBy;
  192.                 if(this.uniqueIdMap_idActivePolicy.equals(mapId.getUniqueMapId())) {
  193.                     deleteList.add(datiGroupBy);
  194.                 }
  195.             }
  196.         }
  197.         while(!deleteList.isEmpty()) {
  198.             IDUnivocoGroupByPolicy id = deleteList.remove(0);
  199.             this.distributedMap.remove(id); 
  200.         }
  201.     }
  202.     
  203.     @Override
  204.     public String printInfos(Logger log, String separatorGroups) throws UtilsException {
  205.         return printInfos(log, separatorGroups, this.distributedMap);
  206.     }
  207.     protected String printInfos(Logger log, String separatorGroups, Map<IDUnivocoGroupByPolicy, DatiCollezionati> map) throws UtilsException {
  208.         StringBuilder bf = new StringBuilder();

  210.         //System.out.println("\n\nPRINT INFO");
  211.         
  212.         for (IDUnivocoGroupByPolicy datiGroupBy : map.keySet()) {
  213.             
  214.             DatiCollezionati datiCollezionati = map.get(datiGroupBy);
  215.             
  216. //      FIX: iterando nella maniera sottostante si ottiene il seguente errore se si usa la near-cache: key cannot be of type Data! hazelcast 
  217. //      for (var entry : this.distributedMap) {
  218. //          IDUnivocoGroupByPolicy datiGroupBy = entry.getKey();
  219.             
  220.             if (!OpenSPCoop2Properties.getInstance().isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy()) {
  221.                 IDUnivocoGroupByPolicyMapId mapId = (IDUnivocoGroupByPolicyMapId) datiGroupBy;
  222.                 if(!this.uniqueIdMap_idActivePolicy.equals(mapId.getUniqueMapId())) {
  223.                     continue;
  224.                 }
  225.             }
  226.             
  227.             //System.out.println("ID["+datiGroupBy.hashCode()+"] ["+datiGroupBy.toString()+"] ["+datiGroupBy.toString(false)+"]");
  228.                     
  229.             bf.append(separatorGroups);
  230.             bf.append("\n");
  231.             bf.append(Costanti.LABEL_MODALITA_SINCRONIZZAZIONE).append(" ").append(this.type.toLabel());
  232.             bf.append("\n");
  233.             bf.append("Criterio di Collezionamento dei Dati\n");
  234.             bf.append(datiGroupBy.toString(true));
  235.             bf.append("\n");
  236. //          entry.getValue().checkDate(log, this.activePolicy); // imposta correttamente gli intervalli
  237. //          bf.append(entry.getValue().toString());
  238.             datiCollezionati.checkDate(log, this.activePolicy); // imposta correttamente gli intervalli
  239.             bf.append(datiCollezionati.toString());
  240.             bf.append("\n");
  241.         }

  243.         if(bf.length()<=0){
  244.             bf.append("Nessuna informazione disponibile");
  245.             return bf.toString();
  246.         }
  247.         else{
  248.             return bf.toString()+separatorGroups;
  249.         }
  250.     }
  251.     
  252.     
  253.     protected IDUnivocoGroupByPolicy augmentIDUnivoco(IDUnivocoGroupByPolicy idUnivoco) {
  254.         // utile sempre aggiungere un id per l'inizializzazione
  255.         if (OpenSPCoop2Properties.getInstance().isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy()) {
  256.             return idUnivoco;
  257.         } else {
  258.             if(idUnivoco instanceof IDUnivocoGroupByPolicyMapId) {
  259.                 return idUnivoco;
  260.             }
  261.             else {
  262.                 return new IDUnivocoGroupByPolicyMapId(idUnivoco, this.uniqueIdMap_idActivePolicy); // NOTA: non serve gestirlo all'interno poichè verrà creato un nuovo identificativo //, this.uniqueIdMap_updateTime);
  263.             }
  264.         }
  265.     }
  266.     
  267.     

  269. }
Created with JaCoCo 0.8.8.202204050719