PolicyGroupByActiveThreadsDB.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;

  22. import java.io.ByteArrayOutputStream;
  23. import java.io.InputStream;
  24. import java.io.Serializable;
  25. import java.security.SecureRandom;
  26. import java.sql.Connection;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.Timestamp;
  30. import java.util.Date;
  31. import java.util.HashMap;
  32. import java.util.Iterator;
  33. import java.util.List;

  35. import org.openspcoop2.core.commons.DBUtils;
  36. import org.openspcoop2.core.controllo_traffico.beans.ActivePolicy;
  37. import org.openspcoop2.core.controllo_traffico.beans.DatiCollezionati;
  38. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupBy;
  39. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicy;
  40. import org.openspcoop2.core.controllo_traffico.beans.MisurazioniTransazione;
  41. import org.openspcoop2.core.controllo_traffico.beans.UniqueIdentifierUtilities;
  42. import org.openspcoop2.core.controllo_traffico.constants.Costanti;
  43. import org.openspcoop2.core.controllo_traffico.driver.IPolicyGroupByActiveThreadsInMemory;
  44. import org.openspcoop2.core.controllo_traffico.driver.PolicyException;
  45. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  46. import org.openspcoop2.core.controllo_traffico.driver.PolicyNotFoundException;
  47. import org.openspcoop2.core.id.IDSoggetto;
  48. import org.openspcoop2.pdd.config.DBManager;
  49. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  50. import org.openspcoop2.pdd.config.Resource;
  51. import org.openspcoop2.pdd.core.controllo_traffico.policy.PolicyDateUtils;
  52. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  53. import org.openspcoop2.protocol.sdk.state.IState;
  54. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  55. import org.openspcoop2.protocol.sdk.state.StateMessage;
  56. import org.openspcoop2.protocol.utils.EsitiProperties;
  57. import org.openspcoop2.utils.Map;
  58. import org.openspcoop2.utils.SemaphoreLock;
  59. import org.openspcoop2.utils.Utilities;
  60. import org.openspcoop2.utils.UtilsException;
  61. import org.openspcoop2.utils.date.DateManager;
  62. import org.openspcoop2.utils.date.DateUtils;
  63. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  64. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  65. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  66. import org.openspcoop2.utils.serialization.JavaDeserializer;
  67. import org.openspcoop2.utils.serialization.JavaSerializer;
  68. import org.openspcoop2.utils.sql.ISQLQueryObject;
  69. import org.openspcoop2.utils.sql.SQLObjectFactory;
  70. import org.slf4j.Logger;

  72. /**     
  73.  * PolicyGroupByActiveThreads
  74.  *
  75.  * @author Poli Andrea (poli@link.it)
  76.  * @author $Author$
  77.  * @version $Rev$, $Date$
  78.  */
  79. public class PolicyGroupByActiveThreadsDB implements Serializable,IPolicyGroupByActiveThreadsInMemory {

  81.     /**
  82.      * 
  83.      */
  84.     private static final long serialVersionUID = 1L;
  85.     
  86.     private static final String CT_MAP_TABLE = "ct_map";
  87.     private static final String CT_MAP_COLUMN_KEY = "map_key";
  88.     private static final String CT_MAP_COLUMN_UPDATE_TIME = "map_update_time";
  89.     private static final String CT_MAP_COLUMN_VALUE = "map_value";

  91.     private static java.util.Random _rnd = null;
  92.     private static synchronized void initRandom() {
  93.         if(_rnd==null) {
  94.             _rnd = new SecureRandom();
  95.         }
  96.     }
  97.     public static java.util.Random getRandom() {
  98.         if(_rnd==null) {
  99.             initRandom();
  100.         }
  101.         return _rnd;
  102.     }
  103.     
  104.     private boolean mapExists = false;
  105.     
  106.     private ActivePolicy activePolicy;
  107.     private PolicyGroupByActiveThreadsType tipoGestore;
  108.     private String uniqueIdMap_idActivePolicy;
  109.     private Date uniqueIdMap_updateTime;
  110.     private IState state;
  111.     private IDSoggetto dominio;
  112.     private String idTransazione;
  113.     private transient OpenSPCoop2Properties _op2Properties; 
  114.     private String tipoDatabase;
  115.     private IJDBCAdapter jdbcAdapter;
  116.     private transient JavaSerializer _javaSerializer = null;
  117.     private transient JavaDeserializer _javaDeserializer = null;
  118.     private Logger log;
  119.     private Logger logSql;
  120.     private boolean debug;
  121.     private boolean transactionMode = true;
  122.     
  123.     private long attesaAttivaJDBC;
  124.     private int checkIntervalloJDBC;

  126.     public PolicyGroupByActiveThreadsDB(ActivePolicy activePolicy, PolicyGroupByActiveThreadsType tipoGestore, String uniqueIdMap, IState state,IDSoggetto dominio, String idTransazione) throws PolicyException {
  127.         this.activePolicy = activePolicy;
  128.         this.tipoGestore = tipoGestore;
  129.         this.uniqueIdMap_idActivePolicy = UniqueIdentifierUtilities.extractIdActivePolicy(uniqueIdMap);
  130.         try {
  131.             this.uniqueIdMap_updateTime = UniqueIdentifierUtilities.extractUpdateTimeActivePolicy(uniqueIdMap);
  132.         }catch(Exception e) {
  133.             throw new PolicyException(e.getMessage(),e);
  134.         }
  135.         this.state = state;
  136.         this.dominio = dominio;
  137.         this.idTransazione = idTransazione;
  138.         this._op2Properties = OpenSPCoop2Properties.getInstance();
  139.         this.tipoDatabase = this._op2Properties.getDatabaseType();
  140.         try {
  141.             this.jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.tipoDatabase);
  142.         }catch(Exception e){
  143.             throw new PolicyException("[createJDBCAdapter] "+e.getMessage(),e);
  144.         }
  145.         this._javaSerializer = new JavaSerializer();
  146.         this._javaDeserializer = new JavaDeserializer();
  147.         this.debug = this._op2Properties.isControlloTrafficoDebug();
  148.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(this.debug);
  149.         this.logSql = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTrafficoSql(this.debug);
  150.         
  151.         this.transactionMode = this._op2Properties.isControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction();
  152.         this.attesaAttivaJDBC = this._op2Properties.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva();
  153.         this.checkIntervalloJDBC = this._op2Properties.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval();
  154.                 
  155.     }
  156.     
  157.     private synchronized void initJavaSerializer() {
  158.         if(this._javaSerializer==null) {
  159.             this._javaSerializer = new JavaSerializer();
  160.         }
  161.     }
  162.     public JavaSerializer getJavaSerializer(){
  163.         if(this._javaSerializer==null) {
  164.             initJavaSerializer();
  165.         }
  166.         return this._javaSerializer;
  167.     }
  168.     
  169.     private synchronized void initJavaDeserializer() {
  170.         if(this._javaDeserializer==null) {
  171.             this._javaDeserializer = new JavaDeserializer();
  172.         }
  173.     }
  174.     public JavaDeserializer getJavaDeserializer(){
  175.         if(this._javaDeserializer==null) {
  176.             initJavaDeserializer();
  177.         }
  178.         return this._javaDeserializer;
  179.     }
  180.     
  181.     private synchronized void initOpenSPCoop2Properties() {
  182.         if(this._op2Properties==null) {
  183.             this._op2Properties = OpenSPCoop2Properties.getInstance();
  184.         }
  185.     }
  186.     public OpenSPCoop2Properties getOpenSPCoop2Properties(){
  187.         if(this._op2Properties==null) {
  188.             initOpenSPCoop2Properties();
  189.         }
  190.         return this._op2Properties;
  191.     }
  192.     
  193.     
  194.     
  195.     @Override
  196.     public ActivePolicy getActivePolicy() {
  197.         return this.activePolicy;
  198.     }
  199.     
  200.     @Override
  201.     public java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> getMapActiveThreads(){
  202.         
  203.         PolicyConnessioneRuntime resource = null;
  204.         try {
  205.             resource = getConnessione(this.state, this.dominio, "getMapActiveThreads", this.idTransazione, null);
  206.             
  207.             //checkMap(resource.con);
  208.             
  209.             return _getMapActiveThreads(resource.con);
  210.             
  211.         }
  212.         catch(Throwable e) {
  213.             this.log.error(e.getMessage(),e);
  214.             throw new RuntimeException(e.getMessage(),e);
  215.         }
  216.         finally {
  217.             if(resource!=null) {
  218.                 releaseConnessione(resource, this.dominio, "getMapActiveThreads", null);
  219.             }
  220.         }
  221.     }
  222.     
  223.     @Override
  224.     public void initMap(java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> map) {
  225.         
  226.         // Non serve essendo già persistente, si rischia di salvare una precedente immagine.
  227.         
  228.         /*
  229.         if(map!=null && map.size()>0){
  230.             PolicyConnessioneRuntime resource = null;
  231.             try {
  232.                 resource = getConnessione(this.state, this.dominio, "initMap", this.idTransazione);
  233.                 
  234.                 checkMap(resource.con);
  235.                 
  236.                 _initMap(resource.con, map);
  237.                 
  238.             }
  239.             catch(Throwable e) {
  240.                 this.log.error(e.getMessage(),e);
  241.                 throw new RuntimeException(e.getMessage(),e);
  242.             }
  243.             finally {
  244.                 if(resource!=null) {
  245.                     releaseConnessione(resource, this.dominio, "initMap");
  246.                 }
  247.             }
  248.         }
  249.         */
  250.         
  251.     }
  252.     
  253.     @Override
  254.     public void resetCounters(){
  255.         
  256.         PolicyConnessioneRuntime resource = null;
  257.         try {
  258.             resource = getConnessione(this.state, this.dominio, "resetCounters", this.idTransazione, null);
  259.             
  260.             //checkMap(resource.con);
  261.             
  262.             _resetCounters(resource.con);
  263.             
  264.         }
  265.         catch(Throwable e) {
  266.             this.log.error(e.getMessage(),e);
  267.             throw new RuntimeException(e.getMessage(),e);
  268.         }
  269.         finally {
  270.             if(resource!=null) {
  271.                 releaseConnessione(resource, this.dominio, "resetCounters", null);
  272.             }
  273.         }
  274.         
  275.     }
  276.     
  277.     @Override
  278.     public void remove() throws UtilsException{
  279.         
  280.         PolicyConnessioneRuntime resource = null;
  281.         try {
  282.             resource = getConnessione(this.state, this.dominio, "remove", this.idTransazione, null);
  283.             
  284.             //checkMap(resource.con);
  285.             
  286.             _remove(resource.con);
  287.             
  288.         }
  289.         catch(Throwable e) {
  290.             this.log.error(e.getMessage(),e);
  291.             throw new RuntimeException(e.getMessage(),e);
  292.         }
  293.         finally {
  294.             if(resource!=null) {
  295.                 releaseConnessione(resource, this.dominio, "remove", null);
  296.             }
  297.         }
  298.         
  299.     }
  300.     
  301.     @Override
  302.     public DatiCollezionati registerStartRequest(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException{
  303.         
  304.         PolicyConnessioneRuntime resource = null;
  305.         DatiCollezionati datiCollezionatiReaded = null;
  306.         try {
  307.             resource = getConnessione(this.state, this.dominio, "registerStartRequest", idTransazione, ctx);
  308.             
  309.             checkMap(resource.con);
  310.             
  311.             // mi salvo fuori dal synchronized l'attuale stato
  312.             datiCollezionatiReaded = _registerStartRequest(resource.con, log, idTransazione, datiGroupBy, ctx); 
  313.             
  314.         }finally {
  315.             if(resource!=null) {
  316.                 releaseConnessione(resource, this.dominio, "registerStartRequest", ctx);
  317.             }
  318.         }
  319.         
  320.         // Tutti i restanti controlli sono effettuati usando il valore di datiCollezionatiReaded, che e' gia' stato modificato
  321.         // Inoltre e' stato re-inserito nella map come oggetto nuovo, quindi il valore dentro il metodo non subira' trasformazioni (essendo stato fatto il deserialize da db)
  322.         // E' possibile procedere con l'analisi rispetto al valore che possiedono il counter dentro questo scope.
  323.         
  324.         return datiCollezionatiReaded;

  326.     }
  327.     
  328.     @Override
  329.     public DatiCollezionati updateDatiStartRequestApplicabile(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException,PolicyNotFoundException{
  330.         
  331.         PolicyConnessioneRuntime resource = null;
  332.         DatiCollezionati datiCollezionatiReaded = null;
  333.         try {
  334.             resource = getConnessione(this.state, this.dominio, "updateDatiStartRequestApplicabile", idTransazione, ctx);
  335.             
  336.             //checkMap(resource.con);
  337.             
  338.             // mi salvo fuori dal synchronized l'attuale stato
  339.             datiCollezionatiReaded = _updateDatiStartRequestApplicabile(resource.con, log, idTransazione, datiGroupBy, ctx);
  340.             
  341.         }finally {
  342.             if(resource!=null) {
  343.                 releaseConnessione(resource, this.dominio, "updateDatiStartRequestApplicabile", ctx);
  344.             }
  345.         }
  346.         
  347.         // Tutti i restanti controlli sono effettuati usando il valore di datiCollezionatiReaded, che e' gia' stato modificato
  348.         // Inoltre e' stato re-inserito nella map come oggetto nuovo, quindi il valore dentro il metodo non subira' trasformazioni (essendo stato fatto il deserialize da db)
  349.         // E' possibile procedere con l'analisi rispetto al valore che possiedono il counter dentro questo scope.
  350.         
  351.         return datiCollezionatiReaded;

  353.     }
  354.     
  355.     @Override
  356.     public void registerStopRequest(Logger log, String idTransazione,IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx, 
  357.             MisurazioniTransazione dati, boolean isApplicabile, boolean isViolata) throws PolicyException,PolicyNotFoundException{
  358.         
  359.         PolicyConnessioneRuntime resource = null;
  360.         try {
  361.             resource = getConnessione(this.state, this.dominio, "registerStopRequest", idTransazione, ctx);
  362.             
  363.             //checkMap(resource.con);
  364.             
  365.             _registerStopRequest(resource.con, log, idTransazione,datiGroupBy, ctx,
  366.                     dati, isApplicabile, isViolata);
  367.             
  368.         }finally {
  369.             if(resource!=null) {
  370.                 releaseConnessione(resource, this.dominio, "registerStopRequest", ctx);
  371.             }
  372.         }
  373.         
  374.     }

  376.     
  377.     @Override
  378.     public long getActiveThreads(){
  379.         return this.getActiveThreads(null);
  380.     }
  381.     @Override
  382.     public long getActiveThreads(IDUnivocoGroupByPolicy filtro){
  383.         
  384.         PolicyConnessioneRuntime resource = null;
  385.         try {
  386.             resource = getConnessione(this.state, this.dominio, "getActiveThreads", this.idTransazione, null);
  387.             
  388.             //checkMap(resource.con);
  389.             
  390.             return _getActiveThreads(resource.con, filtro);
  391.             
  392.         }
  393.         catch(Throwable e) {
  394.             this.log.error(e.getMessage(),e);
  395.             throw new RuntimeException(e.getMessage(),e);
  396.         }
  397.         finally {
  398.             if(resource!=null) {
  399.                 releaseConnessione(resource, this.dominio, "getActiveThreads", null);
  400.             }
  401.         }
  402.         
  403.     }
  404.     
  405.     @Override
  406.     public String printInfos(Logger log, String separatorGroups) throws UtilsException{
  407.         
  408.         PolicyConnessioneRuntime resource = null;
  409.         try {
  410.             resource = getConnessione(this.state, this.dominio, "printInfos", this.idTransazione, null);
  411.             
  412.             //checkMap(resource.con);
  413.             
  414.             return _printInfos(resource.con, log, separatorGroups);
  415.             
  416.         }
  417.         catch(Throwable e) {
  418.             this.log.error(e.getMessage(),e);
  419.             throw new RuntimeException(e.getMessage(),e);
  420.         }
  421.         finally {
  422.             if(resource!=null) {
  423.                 releaseConnessione(resource, this.dominio, "printInfos", null);
  424.             }
  425.         }
  426.         
  427.     }
  428.     
  429.     private PolicyConnessioneRuntime getConnessione(IState state,IDSoggetto dominio, String funzione, String idTransazione, Map<Object> ctx) throws PolicyException {
  430.         
  431.         DBManager dbManager = null;
  432.         Resource r = null;
  433.         String modulo = null;
  434.         try {
  435.             Connection con = null;
  436.                 
  437.             if(state!=null) {
  438.                 if(state instanceof StateMessage) {
  439.                     StateMessage s = (StateMessage) state;
  440.                     if(s.getConnectionDB()!=null && !s.getConnectionDB().isClosed()) {
  441.                         con = s.getConnectionDB();
  442.                         if(con!=null) {
  443.                             PolicyConnessioneRuntime cr = new PolicyConnessioneRuntime();
  444.                             cr.con = con;
  445.                             return cr;
  446.                         }
  447.                     }
  448.                 }
  449.             }
  450.             
  451.             if(dominio==null) {
  452.                 
  453.                 String protocolName = null;
  454.                 if(ctx!=null && ctx.containsKey(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME)) {
  455.                     protocolName = (String) ctx.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME);
  456.                 }
  457.                 
  458.                 RequestInfo requestInfo = null;
  459.                 if(ctx!=null && ctx.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  460.                     requestInfo = (RequestInfo) ctx.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  461.                 }
  462.                 
  463.                 dominio = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolName, requestInfo);
  464.             }
  465.             
  466.             modulo = "RateLimitingActiveThreadsDB"+"."+funzione;
  467.             dbManager = DBManager.getInstance();
  468.             r = dbManager.getResource(dominio, modulo, idTransazione);
  469.             if(r==null){
  470.                 throw new Exception("Risorsa al database non disponibile");
  471.             }
  472.             con = (Connection) r.getResource();
  473.             if(con == null)
  474.                 throw new Exception("Connessione non disponibile"); 
  475.             
  476.             PolicyConnessioneRuntime cr = new PolicyConnessioneRuntime();
  477.             cr.con = con;
  478.             cr.r = r;
  479.             return cr;
  480.         }catch(Throwable e) {
  481.             if(r!=null) {
  482.                 try {
  483.                     dbManager.releaseResource(dominio, modulo, r);
  484.                 }catch(Throwable eClose) {
  485.                     // ignore
  486.                 }
  487.             }
  488.             throw new PolicyException(e.getMessage(),e);
  489.         }
  490.         
  491.     }
  492.     
  493.     private void releaseConnessione(PolicyConnessioneRuntime p, IDSoggetto dominio, String funzione, Map<Object> ctx) {
  494.         if(p.r!=null) {
  495.             if(dominio==null) {
  496.                 String protocolName = null;
  497.                 if(ctx!=null && ctx.containsKey(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME)) {
  498.                     protocolName = (String) ctx.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME);
  499.                 }               
  500.                 
  501.                 RequestInfo requestInfo = null;
  502.                 if(ctx!=null && ctx.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  503.                     requestInfo = (RequestInfo) ctx.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  504.                 }
  505.                 
  506.                 dominio = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolName, requestInfo);
  507.             }
  508.             DBManager.getInstance().releaseResource(dominio, "RateLimitingActiveThreadsDB"+"."+funzione, p.r);
  509.         }
  510.     }
  511.     
  512.     private transient org.openspcoop2.utils.Semaphore _lock_checkMap = null;
  513.     private synchronized void initLockCheckMap() {
  514.         if(this._lock_checkMap==null) {
  515.             this._lock_checkMap = new org.openspcoop2.utils.Semaphore("PolicyGroupByActiveThreadsDB_checkMap"); 
  516.         }
  517.     }
  518.     public org.openspcoop2.utils.Semaphore getLockCheckMap(){
  519.         if(this._lock_checkMap==null) {
  520.             initLockCheckMap();
  521.         }
  522.         return this._lock_checkMap;
  523.     }
  524.     
  525.     private void checkMap(Connection con) throws PolicyException {
  526.         if(!this.mapExists) {
  527.             _checkMap(con);
  528.         }
  529.     }
  530.     private void _checkMap(Connection con) throws PolicyException {
  531.         
  532.         SemaphoreLock lock = this.getLockCheckMap().acquireThrowRuntime("checkMap");
  533.         try {

  535.             if(!this.mapExists) {
  536.             
  537.                 PreparedStatement pstmt = null;
  538.                 ResultSet rs = null;
  539.                 try {
  540.                 
  541.                     ISQLQueryObject sqlGet = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  542.                     sqlGet.addSelectField(CT_MAP_COLUMN_KEY);
  543.                     sqlGet.addFromTable(CT_MAP_TABLE);
  544.                     sqlGet.setANDLogicOperator(true);
  545.                     sqlGet.addWhereCondition(CT_MAP_COLUMN_KEY+"=?");
  546.                     String query = sqlGet.createSQLQuery();
  547.                     if(this.debug) {
  548.                         this.logSql.debug("[checkMap"+""+this.idTransazione+"] execute "+DBUtils.formatSQLString(query, this.uniqueIdMap_idActivePolicy));
  549.                     }
  550.                     pstmt = con.prepareStatement(query);
  551.                     pstmt.setString(1, this.uniqueIdMap_idActivePolicy);
  552.                     rs = pstmt.executeQuery();
  553.                     if(rs == null) {
  554.                         pstmt.close();
  555.                         throw new UtilsException("CheckMap failed: ResultSet is null?");        
  556.                     }
  557.                     boolean exist = rs.next();
  558.                     if(this.debug) {
  559.                         this.logSql.debug("[checkMap"+""+this.idTransazione+"] executed (result:"+exist+") "+DBUtils.formatSQLString(query, this.uniqueIdMap_idActivePolicy));
  560.                     }
  561.                     rs.close();
  562.                     pstmt.close();
  563.                     
  564.                     if(!exist) {
  565.                         
  566.                         try{
  567.                             if(con.isClosed()){
  568.                                 throw new UtilsException("Connessione risulta già chiusa");
  569.                             }
  570.                         }catch(Exception e){
  571.                             throw new UtilsException("CheckMap failed: connection closed; "+e.getMessage(),e);
  572.                         }

  574.                         boolean originalConnectionAutocommit = false;
  575.                         boolean autoCommitModificato = false;
  576.                         try{
  577.                             originalConnectionAutocommit = con.getAutoCommit();
  578.                         }catch(Exception e){
  579.                             throw new UtilsException("CheckMap failed: autocommit mode disabled; "+e.getMessage(),e); 
  580.                         }
  581.                         if(originalConnectionAutocommit==false){
  582.                             throw new UtilsException("CheckMap failed: autocommit mode disabled; non e' possibile fornire una connessione con autocommit disabilitato poiche' l'utility ha necessita' di effettuare operazioni di commit/rollback)");       
  583.                         }
  584.                         
  585.                         int originalConnectionTransactionIsolation = -1;
  586.                         boolean transactionIsolationModificato = false;
  587.                         try{
  588.                             originalConnectionTransactionIsolation = con.getTransactionIsolation();
  589.                         }catch(Exception e){
  590.                             throw new UtilsException("Lettura livello di isolamento transazione della Connessione non riuscito: "+e.getMessage(),e); 
  591.                         }
  592.                         
  593.                         try {
  594.                             
  595.                             try{                

  597.                                 //System.out.println("SET TRANSACTION SERIALIZABLE ("+conDB.getTransactionIsolation()+","+conDB.getAutoCommit()+")");
  598.                                 // Il rollback, non servirebbe, pero le WrappedConnection di JBoss hanno un bug, per cui alcune risorse non vengono rilasciate.
  599.                                 // Con il rollback tali risorse vengono rilasciate, e poi effettivamente la ConnectionSottostante emette una eccezione.
  600.                                 try{
  601.                                     con.rollback();
  602.                                 }catch(Exception e){
  603.                                     //System.out.println("ROLLBACK ERROR: "+e.getMessage());
  604.                                 }
  605.                                 
  606.                                 JDBCUtilities.setTransactionIsolationSerializable(this.tipoDatabase, con);
  607.                                 transactionIsolationModificato = true;
  608.                                                                 
  609.                                 if(originalConnectionAutocommit){
  610.                                     con.setAutoCommit(false);
  611.                                     autoCommitModificato = true;
  612.                                 }
  613.                                 
  614.                             } catch(Exception er) {
  615.                                 throw new UtilsException("CheckMap failed: setting connection error; "+er.getMessage(),er);     
  616.                             }
  617.                             
  618.                             long scadenzaWhile = DateManager.getTimeMillis()
  619.                                     + this.attesaAttivaJDBC;
  620.                             boolean transactionInsertFinished = false;
  621.                             int iteration = 0;
  622.                             
  623.                             while(transactionInsertFinished==false && DateManager.getTimeMillis() < scadenzaWhile){
  624.                                 
  625.                                 try {
  626.                                     sqlGet = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  627.                                     sqlGet.addSelectField(CT_MAP_COLUMN_KEY);
  628.                                     sqlGet.addFromTable(CT_MAP_TABLE);
  629.                                     sqlGet.setANDLogicOperator(true);
  630.                                     sqlGet.addWhereCondition(CT_MAP_COLUMN_KEY+"=?");
  631.                                     sqlGet.setSelectForUpdate(true);
  632.                                     
  633.                                     query = sqlGet.createSQLQuery();
  634.                                     if(this.debug) {
  635.                                         this.logSql.debug("[checkMap"+""+this.idTransazione+"] (forUpdate) execute "+DBUtils.formatSQLString(query, this.uniqueIdMap_idActivePolicy));
  636.                                     }
  637.                                     pstmt = con.prepareStatement(query);
  638.                                     pstmt.setString(1, this.uniqueIdMap_idActivePolicy);
  639.                                     rs = pstmt.executeQuery();
  640.                                     if(rs == null) {
  641.                                         pstmt.close();
  642.                                         throw new UtilsException("CheckMap failed: ResultSet is null?");        
  643.                                     }
  644.                                     exist = rs.next();
  645.                                     if(this.debug) {
  646.                                         this.logSql.debug("[checkMap"+""+this.idTransazione+"] (forUpdate) executed (result:"+exist+") "+DBUtils.formatSQLString(query, this.uniqueIdMap_idActivePolicy));
  647.                                     }
  648.                                     //System.out.println("@check SELECT result:"+exist);
  649.                                     rs.close();
  650.                                     pstmt.close();
  651.                                     
  652.                                     if(!exist) {
  653.                                         
  654.                                         java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> mapActiveThreads = new HashMap<IDUnivocoGroupByPolicy, DatiCollezionati>();
  655.                                         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  656.                                         this.getJavaSerializer().writeObject(mapActiveThreads, bout);
  657.                                         bout.flush();
  658.                                         bout.close();
  659.                                         
  660.                                         StringBuilder queryInsert = new StringBuilder();
  661.                                         ISQLQueryObject sqlInsert = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  662.                                         sqlInsert.addInsertTable(CT_MAP_TABLE);
  663.                                         sqlInsert.addInsertField(CT_MAP_COLUMN_KEY, "?");
  664.                                         sqlInsert.addInsertField(CT_MAP_COLUMN_UPDATE_TIME, "?");
  665.                                         sqlInsert.addInsertField(CT_MAP_COLUMN_VALUE, "?");
  666.                                         queryInsert.append(sqlInsert.createSQLInsert());
  667.                                         //System.out.println("INSERT ["+queryInsert.toString()+"]");
  668.                                         
  669.                                         if(this.debug) {
  670.                                             this.logSql.debug("[checkMap"+""+this.idTransazione+"] execute "+DBUtils.formatSQLString(queryInsert.toString(), 
  671.                                                     this.uniqueIdMap_idActivePolicy, 
  672.                                                     DateUtils.getSimpleDateFormatMs().format(this.uniqueIdMap_updateTime), 
  673.                                                     ("blob-size:"+bout.size())));
  674.                                         }
  675.                                         
  676.                                         pstmt = con.prepareStatement(queryInsert.toString());
  677.                                         pstmt.setString(1, this.uniqueIdMap_idActivePolicy);
  678.                                         Timestamp t = new Timestamp(this.uniqueIdMap_updateTime.getTime());
  679.                                         pstmt.setTimestamp(2, t);
  680.                                         this.jdbcAdapter.setBinaryData(pstmt, 3, bout.toByteArray());
  681.                                         int rows = pstmt.executeUpdate();
  682.                                         pstmt.close();
  683.                                         
  684.                                         if(this.debug) {
  685.                                             this.logSql.debug("[checkMap"+""+this.idTransazione+"] executed (rows:"+rows+") "+DBUtils.formatSQLString(queryInsert.toString(), 
  686.                                                     this.uniqueIdMap_idActivePolicy, 
  687.                                                     DateUtils.getSimpleDateFormatMs().format(this.uniqueIdMap_updateTime), 
  688.                                                     ("blob-size:"+bout.size())));
  689.                                         }
  690.                                         
  691.                                         //System.out.println("@check INSERT rows:"+rows);
  692.                                         
  693.                                     }
  694.                                     
  695.                                     // Chiusura Transazione
  696.                                     con.commit();
  697.     
  698.                                     // ID Costruito
  699.                                     transactionInsertFinished = true;
  700.                                     
  701.                                 } catch(Throwable e) {
  702.                                     if(this.debug) {
  703.                                         this.logSql.debug("Transaction error: "+e.getMessage(),e);
  704.                                     }
  705.                                     //System.out.println("ERRORE INSERT ("+iteration+"): "+e.getMessage());
  706.                                     //log.info("ERROR GET SERIAL SQL ["+e.getMessage()+"]");
  707.                                     try{
  708.                                         if( rs != null )
  709.                                             rs.close();
  710.                                     } catch(Exception er) {
  711.                                         // close
  712.                                     }
  713.                                     try{
  714.                                         if( pstmt != null )
  715.                                             pstmt.close();
  716.                                     } catch(Exception er) {
  717.                                         // close
  718.                                     }
  719.                                     try{
  720.                                         con.rollback();
  721.                                     } catch(Exception er) {
  722.                                         // ignore
  723.                                     }
  724.                                 }

  726.                                 if(transactionInsertFinished == false){
  727.                                     // Per aiutare ad evitare conflitti
  728.                                     try{
  729.                                         int sleep = (getRandom()).nextInt(this.checkIntervalloJDBC);
  730.                                         //System.out.println("Sleep: "+sleep);
  731.                                         Utilities.sleep(sleep); // random
  732.                                     }catch(Exception eRandom){
  733.                                         // ignore
  734.                                     }
  735.                                 }
  736.                                 
  737.                                 iteration++;
  738.                                 
  739.                             }
  740.                             
  741.                             if(!transactionInsertFinished) {
  742.                                 throw new Exception("Check non riuscito dopo '"+iteration+"' tentativi");
  743.                             }
  744.                             
  745.                         }
  746.                         finally{

  748.                             // Ripristino Transazione
  749.                             try{
  750.                                 if(transactionIsolationModificato){
  751.                                     con.setTransactionIsolation(originalConnectionTransactionIsolation);
  752.                                 }
  753.                                 if(autoCommitModificato){
  754.                                     con.setAutoCommit(originalConnectionAutocommit);
  755.                                 }
  756.                             } catch(Exception er) {
  757.                                 //System.out.println("ERROR UNSET:"+er.getMessage());
  758.                                 //throw new UtilsException("CheckMap failed: unsetting connection error; "+er.getMessage());
  759.                                 if(this.log!=null) {
  760.                                     this.log.error("CheckMap failed: unsetting connection error; "+er.getMessage(),er);
  761.                                 }
  762.                             }
  763.                         }
  764.                         
  765.                     }
  766.                     else {
  767.                         
  768.                         this.mapExists = true;
  769.                         
  770.                     }
  771.                     
  772.                 }catch(Throwable e) {
  773.                     throw new PolicyException(e.getMessage(),e);
  774.                 }
  775.                 
  776.                 
  777.                 
  778.             }
  779.             
  780.         }finally {
  781.             this.getLockCheckMap().release(lock, "checkMap");
  782.         }
  783.     }
  784.     
  785.     private java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> _getMapActiveThreads(Connection con){
  786.         try {
  787.             return _updateMap(con, OperationType.getMapActiveThreads,
  788.                     this.log, this.idTransazione, null, null,
  789.                     null, false, false,
  790.                     null,
  791.                     null).map;
  792.         }catch(Throwable e) {
  793.             throw new RuntimeException(e.getMessage(),e);
  794.         }
  795.     }
  796.     @SuppressWarnings("unused")
  797.     private void _initMap(Connection con, java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> map) {
  798.         try {
  799.             if(map!=null && map.size()>0){
  800.                 _updateMap(con, OperationType.initMap,
  801.                         this.log, this.idTransazione, null, null,
  802.                         null, false, false,
  803.                         null,
  804.                         map);
  805.             }
  806.         }catch(Throwable e) {
  807.             throw new RuntimeException(e.getMessage(),e);
  808.         }
  809.     }
  810.     private DatiCollezionati _registerStartRequest(Connection con,Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException {
  811.         try {
  812.             return _updateMap(con, OperationType.registerStartRequest,
  813.                     log, idTransazione, datiGroupBy, ctx,
  814.                     null, false, false,
  815.                     null,
  816.                     null).datiCollezionatiReaded;
  817.         }catch(PolicyNotFoundException e) {
  818.             throw new PolicyException(e.getMessage(),e);
  819.         }
  820.     }
  821.     private DatiCollezionati _updateDatiStartRequestApplicabile(Connection con,Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException,PolicyNotFoundException{
  822.         return _updateMap(con, OperationType.updateDatiStartRequestApplicabile,
  823.                 log, idTransazione, datiGroupBy, ctx,
  824.                 null, false, false,
  825.                 null,
  826.                 null).datiCollezionatiReaded;
  827.     }
  828.     private void _registerStopRequest(Connection con,Logger log, String idTransazione,IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx, 
  829.             MisurazioniTransazione dati, boolean isApplicabile, boolean isViolata) throws PolicyException,PolicyNotFoundException{
  830.         _updateMap(con, OperationType.registerStopRequest,
  831.                 log, idTransazione, datiGroupBy, ctx,
  832.                 dati, isApplicabile, isViolata,
  833.                 null,
  834.                 null);
  835.     }
  836.     private void _resetCounters(Connection con){
  837.         try {
  838.             _updateMap(con, OperationType.resetCounters,
  839.                     this.log, this.idTransazione, null, null,
  840.                     null, false, false,
  841.                     null,
  842.                     null);
  843.         }catch(Throwable e) {
  844.             throw new RuntimeException(e.getMessage(),e);
  845.         }
  846.     }
  847.     private void _remove(Connection con){
  848.         try {
  849.             _updateMap(con, OperationType.remove,
  850.                     this.log, this.idTransazione, null, null,
  851.                     null, false, false,
  852.                     null,
  853.                     null);
  854.         }catch(Throwable e) {
  855.             throw new RuntimeException(e.getMessage(),e);
  856.         }
  857.     }
  858.     private long _getActiveThreads(Connection con,IDUnivocoGroupByPolicy filtro){
  859.         try {
  860.             return _updateMap(con, OperationType.getActiveThreads,
  861.                     this.log, this.idTransazione, filtro, null,
  862.                     null, false, false,
  863.                     null,
  864.                     null).counter;
  865.         }catch(Throwable e) {
  866.             throw new RuntimeException(e.getMessage(),e);
  867.         }
  868.     }
  869.     private String _printInfos(Connection con,Logger log, String separatorGroups) throws UtilsException{
  870.         try {
  871.             return _updateMap(con, OperationType.printInfos,
  872.                     log, this.idTransazione, null, null,
  873.                     null, false, false,
  874.                     separatorGroups,
  875.                     null).info;
  876.         }catch(Exception e) {
  877.             throw new UtilsException(e.getMessage(),e);
  878.         }
  879.     }
  880.     @SuppressWarnings({ "unchecked"})
  881.     private UpdateResult _updateMap(Connection con, OperationType opType,
  882.             Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx,
  883.             MisurazioniTransazione dati, boolean isApplicabile, boolean isViolata,
  884.             String separatorGroups,
  885.             java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> map) throws PolicyException, PolicyNotFoundException {
  886.             
  887.         UpdateResult updateResult = new UpdateResult();
  888.         
  889.         try{
  890.             if(con.isClosed()){
  891.                 throw new UtilsException("Connessione risulta già chiusa");
  892.             }
  893.         }catch(Exception e){
  894.             throw new PolicyException("CheckMap failed: connection closed; "+e.getMessage(),e);
  895.         }

  897.         boolean originalConnectionAutocommit = false;
  898.         boolean autoCommitModificato = false;
  899.         try{
  900.             originalConnectionAutocommit = con.getAutoCommit();
  901.         }catch(Exception e){
  902.             throw new PolicyException("CheckMap failed: autocommit mode disabled; "+e.getMessage(),e); 
  903.         }
  904.         if(originalConnectionAutocommit==false){
  905.             throw new PolicyException("CheckMap failed: autocommit mode disabled; non e' possibile fornire una connessione con autocommit disabilitato poiche' l'utility ha necessita' di effettuare operazioni di commit/rollback)");      
  906.         }
  907.                 
  908.         try {
  909.             
  910.             if(this.transactionMode) {
  911.                 try{                
  912.     
  913.                     //System.out.println("SET TRANSACTION SERIALIZABLE ("+conDB.getTransactionIsolation()+","+conDB.getAutoCommit()+")");
  914.                     // Il rollback, non servirebbe, pero le WrappedConnection di JBoss hanno un bug, per cui alcune risorse non vengono rilasciate.
  915.                     // Con il rollback tali risorse vengono rilasciate, e poi effettivamente la ConnectionSottostante emette una eccezione.
  916.                     try{
  917.                         con.rollback();
  918.                     }catch(Exception e){
  919.                         //System.out.println("ROLLBACK ERROR: "+e.getMessage());
  920.                     }
  921.                                 
  922.                     if(originalConnectionAutocommit){
  923.                         con.setAutoCommit(false);
  924.                         autoCommitModificato = true;
  925.                     }
  926.                     
  927.                 } catch(Exception er) {
  928.                     throw new PolicyException("CheckMap failed: setting connection error; "+er.getMessage(),er);        
  929.                 }
  930.             }
  931.             
  932.             long scadenzaWhile = DateManager.getTimeMillis()
  933.                     + this.attesaAttivaJDBC;
  934.             boolean transactionUpdateFinished = false;
  935.             
  936.             int iteration = 0;
  937.             
  938.             PolicyNotFoundException policyNotFoundException = null;
  939.             PolicyException policyException = null;
  940.             
  941.             while(transactionUpdateFinished==false && DateManager.getTimeMillis() < scadenzaWhile){
  942.                 
  943.                 try {           
  944.                     ISQLQueryObject sqlGet = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  945.                     sqlGet.addSelectField(CT_MAP_COLUMN_VALUE);
  946.                     sqlGet.addSelectField(CT_MAP_COLUMN_UPDATE_TIME);
  947.                     sqlGet.addFromTable(CT_MAP_TABLE);
  948.                     sqlGet.setANDLogicOperator(true);
  949.                     sqlGet.addWhereCondition(CT_MAP_COLUMN_KEY+"=?");
  950.                     if(this.transactionMode) {
  951.                         sqlGet.setSelectForUpdate(true);
  952.                     }
  953.                     
  954.                     ResultSet rsMap = null;
  955.                     java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> mapActiveThreads = null;
  956.                     boolean updateDate = false;
  957.                     String query = sqlGet.createSQLQuery();
  958.                     if(this.debug) {
  959.                         this.logSql.debug("[updateMap"+""+this.idTransazione+"] (forUpdate) execute "+DBUtils.formatSQLString(query, this.uniqueIdMap_idActivePolicy));
  960.                     }
  961.                     try (PreparedStatement pstmtMap = con.prepareStatement(query)){
  962.                         pstmtMap.setString(1, this.uniqueIdMap_idActivePolicy);
  963.                         try{
  964.                             rsMap = pstmtMap.executeQuery();
  965.                             if(rsMap == null) {
  966.                                 throw new UtilsException("CheckMap failed: ResultSet is null?");        
  967.                             }
  968.                             boolean exist = rsMap.next();
  969.                             if(this.debug) {
  970.                                 this.logSql.debug("[updateMap"+""+this.idTransazione+"] (forUpdate) executed (result:"+exist+") "+DBUtils.formatSQLString(query, this.uniqueIdMap_idActivePolicy));
  971.                             }
  972.                             //System.out.println("@update SELECT ["+opType+"] result:"+exist);
  973.                             
  974.                             if(!exist) {
  975.                                 if(!OperationType.getMapActiveThreads.equals(opType) &&
  976.                                         !OperationType.resetCounters.equals(opType)  &&
  977.                                         !OperationType.remove.equals(opType) &&
  978.                                         !OperationType.getActiveThreads.equals(opType)  &&
  979.                                         !OperationType.printInfos.equals(opType)) {
  980.                                     throw new Exception("Map with id '"+this.uniqueIdMap_idActivePolicy+"' not found ?");
  981.                                 }
  982.                             }
  983.                             else {
  984.                                 Timestamp tCheck = rsMap.getTimestamp(CT_MAP_COLUMN_UPDATE_TIME);
  985.                                 if(this.uniqueIdMap_updateTime.equals(tCheck)) {
  986.                                     try(InputStream is = this.jdbcAdapter.getBinaryStream(rsMap, CT_MAP_COLUMN_VALUE);){
  987.                                         mapActiveThreads = (java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati>) this.getJavaDeserializer().readObject(is, java.util.Map.class);
  988.                                     }
  989.                                 }
  990.                                 else {
  991.                                     // data aggiornata
  992.                                     mapActiveThreads = new HashMap<IDUnivocoGroupByPolicy, DatiCollezionati>();
  993.                                     updateDate = true;
  994.                                 }
  995.                                 if(mapActiveThreads == null) {
  996.                                     if(!OperationType.getMapActiveThreads.equals(opType) &&
  997.                                             !OperationType.resetCounters.equals(opType)  &&
  998.                                             !OperationType.getActiveThreads.equals(opType)  &&
  999.                                             !OperationType.printInfos.equals(opType)) {
  1000.                                         throw new Exception("Map with id '"+this.uniqueIdMap_idActivePolicy+"' null ?");
  1001.                                     }
  1002.                                 }
  1003.                             }
  1004.                         }finally {
  1005.                             try{
  1006.                                 if( rsMap != null ) {
  1007.                                     rsMap.close();
  1008.                                 }
  1009.                             } catch(Throwable er) {
  1010.                                 // close rs
  1011.                             }
  1012.                         }
  1013.                     } // close pstmt
  1014.                     
  1015.                     
  1016.                     DatiCollezionati datiCollezionati = null;
  1017.                     boolean deleteMap = false;
  1018.                     boolean updateMap = false;
  1019.                     switch (opType) {
  1020.                     
  1021.                     case getMapActiveThreads:
  1022.                         
  1023.                         updateResult.map = mapActiveThreads;
  1024.                         break;
  1025.                     
  1026.                     case initMap:
  1027.                         
  1028.                         if(map!=null && map.size()>0){
  1029.                             
  1030.                             if(mapActiveThreads == null) {
  1031.                                 throw new Exception("Map with id '"+this.uniqueIdMap_idActivePolicy+"' null ?");
  1032.                             }
  1033.                             
  1034.                             mapActiveThreads.putAll(map);
  1035.                             updateMap = true;
  1036.                         }
  1037.                         
  1038.                         break;
  1039.                         
  1040.                     case registerStartRequest:
  1041.                         
  1042.                         if(mapActiveThreads == null) {
  1043.                             throw new Exception("Map with id '"+this.uniqueIdMap_idActivePolicy+"' null ?");
  1044.                         }
  1045.                         
  1046.                         try {
  1047.                             if(mapActiveThreads.containsKey(datiGroupBy)){
  1048.                                 //System.out.println("<"+idTransazione+">registerStartRequest CHECK CONTAINS ["+datiGroupBy+"]=true");
  1049.                                 datiCollezionati = mapActiveThreads.get(datiGroupBy);   
  1050.                             }
  1051.                             else{
  1052.                                 //System.out.println("<"+idTransazione+">registerStartRequest CHECK CONTAINS ["+datiGroupBy+"]=false");
  1053.                                 Date gestorePolicyConfigDate = PolicyDateUtils.readGestorePolicyConfigDateIntoContext(ctx);
  1054.                                 datiCollezionati = new DatiCollezionati(this.activePolicy.getInstanceConfiguration().getUpdateTime(), gestorePolicyConfigDate);
  1055.                                 //System.out.println("<"+idTransazione+">registerStartRequest PUT");
  1056.                                 mapActiveThreads.put(datiGroupBy, datiCollezionati); // registro nuova immagine
  1057.                             }
  1058.                             
  1059.                             // incremento il numero di thread
  1060.                             //System.out.println("<"+idTransazione+">registerStartRequest in datiCollezionati ...");
  1061.                             datiCollezionati.registerStartRequest(log, this.activePolicy, ctx);
  1062.                             //System.out.println("<"+idTransazione+">registerStartRequest in datiCollezionati ok: "+datiCollezionati.getActiveRequestCounter());
  1063.                             
  1064.                             updateMap = true;
  1065.                             
  1066.                             // mi salvo fuori dal synchronized l'attuale stato
  1067.                             updateResult.datiCollezionatiReaded = (DatiCollezionati) datiCollezionati.newInstance(); 
  1068.                             
  1069.                         }catch(Exception e) {
  1070.                             policyException = new PolicyException(e.getMessage(),e);
  1071.                             transactionUpdateFinished = true;
  1072.                         }
  1073.                                                 
  1074.                         break;

  1076.                     case updateDatiStartRequestApplicabile:
  1077.                         
  1078.                         if(mapActiveThreads == null) {
  1079.                             throw new Exception("Map with id '"+this.uniqueIdMap_idActivePolicy+"' null ?");
  1080.                         }
  1081.                         
  1082.                         try {
  1083.                             if(mapActiveThreads.containsKey(datiGroupBy)==false){
  1084.                                 //System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");
  1085.                                 policyNotFoundException = new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");
  1086.                                 transactionUpdateFinished = true;
  1087.                             }
  1088.                             else{
  1089.                                 datiCollezionati = mapActiveThreads.get(datiGroupBy);   
  1090.                             
  1091.                                 // incremento il numero dei contatori
  1092.                                 //System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile updateDatiStartRequestApplicabile ...");
  1093.                                 boolean updated = datiCollezionati.updateDatiStartRequestApplicabile(log, this.activePolicy, ctx);
  1094.                                 //System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile updateDatiStartRequestApplicabile ok");
  1095.                                                         
  1096.                                 if(updated) {
  1097.                                     
  1098.                                     updateMap = true;
  1099.                                     
  1100.                                     // mi salvo fuori dal synchronized l'attuale stato
  1101.                                     updateResult.datiCollezionatiReaded = (DatiCollezionati) datiCollezionati.newInstance();
  1102.                                 }
  1103.                             }
  1104.                         }
  1105.                         catch(Exception e) {
  1106.                             policyException = new PolicyException(e.getMessage(),e);
  1107.                             transactionUpdateFinished = true;
  1108.                         }
  1109.                         
  1110.                         break;
  1111.                         
  1112.                     case registerStopRequest:
  1113.                         
  1114.                         if(mapActiveThreads == null) {
  1115.                             throw new Exception("Map with id '"+this.uniqueIdMap_idActivePolicy+"' null ?");
  1116.                         }
  1117.                         
  1118.                         try {
  1119.                             if(mapActiveThreads.containsKey(datiGroupBy)==false){
  1120.                                 //System.out.println("<"+idTransazione+">registerStopRequest Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");
  1121.                                 policyNotFoundException = new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");
  1122.                                 transactionUpdateFinished = true;
  1123.                             }
  1124.                             else{
  1125.                                 //System.out.println("<"+idTransazione+">registerStopRequest get ...");
  1126.                                 datiCollezionati = mapActiveThreads.get(datiGroupBy);   
  1127.                                 //System.out.println("<"+idTransazione+">registerStopRequest registerEndRequest ...");
  1128.                                 datiCollezionati.registerEndRequest(log, this.activePolicy, ctx, dati);
  1129.                                 //System.out.println("<"+idTransazione+">registerStopRequest registerEndRequest ok");
  1130.                                 if(isApplicabile){
  1131.                                     //System.out.println("<"+idTransazione+">registerStopRequest updateDatiEndRequestApplicabile ...");
  1132.                                     EsitiProperties esitiProperties = EsitiProperties.getInstanceFromProtocolName(log,dati.getProtocollo());
  1133.                                     List<Integer> esitiCodeOk = esitiProperties.getEsitiCodeOk_senzaFaultApplicativo();
  1134.                                     List<Integer> esitiCodeKo_senzaFaultApplicativo = esitiProperties.getEsitiCodeKo_senzaFaultApplicativo();
  1135.                                     List<Integer> esitiCodeFaultApplicativo = esitiProperties.getEsitiCodeFaultApplicativo();
  1136.                                     datiCollezionati.updateDatiEndRequestApplicabile(log, this.activePolicy, ctx, dati,
  1137.                                             esitiCodeOk,esitiCodeKo_senzaFaultApplicativo, esitiCodeFaultApplicativo, isViolata);
  1138.                                     //System.out.println("<"+idTransazione+">registerStopRequest updateDatiEndRequestApplicabile ok");
  1139.                                 }
  1140.                                 
  1141.                                 updateMap = true;
  1142.                             }
  1143.                         }catch(Exception e) {
  1144.                             policyException = new PolicyException(e.getMessage(),e);
  1145.                             transactionUpdateFinished = true;
  1146.                         }
  1147.                         
  1148.                         break;
  1149.                         
  1150.                     case resetCounters:
  1151.                         
  1152.                         if(mapActiveThreads!=null && mapActiveThreads.size()>0){
  1153.                             Iterator<DatiCollezionati> datiCollezionatiIter = mapActiveThreads.values().iterator();
  1154.                             while (datiCollezionatiIter.hasNext()) {
  1155.                                 DatiCollezionati item = (DatiCollezionati) datiCollezionatiIter.next();
  1156.                                 item.resetCounters();
  1157.                             }
  1158.                             
  1159.                             updateMap = true;
  1160.                         }
  1161.                         
  1162.                         break;
  1163.                         
  1164.                         
  1165.                     case remove:
  1166.                         
  1167.                         if(mapActiveThreads!=null) {
  1168.                             deleteMap = true;
  1169.                         }
  1170.                         
  1171.                         break;
  1172.                         
  1173.                     case getActiveThreads:
  1174.                         
  1175.                         try {
  1176.                             long counter = 0l;
  1177.                             
  1178.                             if(mapActiveThreads!=null && !mapActiveThreads.isEmpty()) {
  1179.                                 for (IDUnivocoGroupByPolicy check : mapActiveThreads.keySet()) {
  1180.                                     
  1181.                                     if(datiGroupBy!=null){
  1182.                                         IDUnivocoGroupBy<IDUnivocoGroupByPolicy> idAstype = (IDUnivocoGroupBy<IDUnivocoGroupByPolicy>) check;
  1183.                                         if(!idAstype.match(datiGroupBy)){
  1184.                                             continue;
  1185.                                         }
  1186.                                     }
  1187.                                     
  1188.                                     counter = counter + mapActiveThreads.get(check).getActiveRequestCounter();
  1189.                                 }
  1190.                             }
  1191.                             
  1192.                             // mi appoggio a questa struttura
  1193.                             updateResult.counter = counter;
  1194.                             
  1195.                         }catch(Exception e) {
  1196.                             policyException = new PolicyException(e.getMessage(),e);
  1197.                             transactionUpdateFinished = true;
  1198.                         }
  1199.                         
  1200.                         break;
  1201.                         
  1202.                     case printInfos:
  1203.                         
  1204.                         StringBuilder bf = new StringBuilder();
  1205.                         if(mapActiveThreads!=null && !mapActiveThreads.isEmpty()) {
  1206.                             for (IDUnivocoGroupByPolicy check : mapActiveThreads.keySet()) {
  1207.                                 bf.append(separatorGroups);
  1208.                                 bf.append("\n");
  1209.                                 bf.append(Costanti.LABEL_MODALITA_SINCRONIZZAZIONE).append(" ").append(this.tipoGestore.toLabel());
  1210.                                 bf.append("\n");
  1211.                                 bf.append("Criterio di Collezionamento dei Dati\n");
  1212.                                 bf.append(check.toString(true));
  1213.                                 bf.append("\n");
  1214.                                 mapActiveThreads.get(check).checkDate(log, this.activePolicy); // imposta correttamente gli intervalli
  1215.                                 bf.append(mapActiveThreads.get(check).toString());
  1216.                                 bf.append("\n");
  1217.                             }
  1218.                         }
  1219.                         if(bf.length()<=0){
  1220.                             bf.append("Nessuna informazione disponibile");
  1221.                             updateResult.info = bf.toString();
  1222.                         }
  1223.                         else{
  1224.                             updateResult.info = bf.toString()+separatorGroups;
  1225.                         }
  1226.                         
  1227.                         break;
  1228.                     }
  1229.                     
  1230.                     if(updateMap) {
  1231.                     
  1232.                         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1233.                         this.getJavaSerializer().writeObject(mapActiveThreads, bout);
  1234.                         bout.flush();
  1235.                         bout.close();
  1236.                         
  1237.                         ISQLQueryObject sqlUpdate = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1238.                         sqlUpdate.addUpdateTable(CT_MAP_TABLE);
  1239.                         //sqlUpdate.addUpdateField(CT_MAP_COLUMN_KEY, "?");
  1240.                         if(updateDate) {
  1241.                             sqlUpdate.addUpdateField(CT_MAP_COLUMN_UPDATE_TIME, "?");
  1242.                         }
  1243.                         sqlUpdate.addUpdateField(CT_MAP_COLUMN_VALUE, "?");
  1244.                         sqlUpdate.setANDLogicOperator(true);
  1245.                         sqlUpdate.addWhereCondition(CT_MAP_COLUMN_KEY+"=?");
  1246.                         String queryUpdate = sqlUpdate.createSQLUpdate();
  1247.                         
  1248.                         if(this.debug) {
  1249.                             if(updateDate) {
  1250.                                 this.logSql.debug("[updateMap"+""+this.idTransazione+"] execute "+DBUtils.formatSQLString(queryUpdate,
  1251.                                         DateUtils.getSimpleDateFormatMs().format(this.uniqueIdMap_updateTime),
  1252.                                         ("blob-size:"+bout.size()), 
  1253.                                         this.uniqueIdMap_idActivePolicy));
  1254.                             }
  1255.                             else {
  1256.                                 this.logSql.debug("[updateMap"+""+this.idTransazione+"] execute "+DBUtils.formatSQLString(queryUpdate,
  1257.                                         ("blob-size:"+bout.size()), 
  1258.                                         this.uniqueIdMap_idActivePolicy));
  1259.                             }
  1260.                         }
  1261.                         
  1262.                         PreparedStatement pstmtUpdateMap = null;
  1263.                         int rows = -1;
  1264.                         try {
  1265.                             //System.out.println("INSERT ["+queryInsert.toString()+"]");
  1266.                             pstmtUpdateMap = con.prepareStatement(queryUpdate);
  1267.                             int index = 1;
  1268.                             if(updateDate) {
  1269.                                 Timestamp t = new Timestamp(this.uniqueIdMap_updateTime.getTime());
  1270.                                 pstmtUpdateMap.setTimestamp(index++, t);
  1271.                             }
  1272.                             this.jdbcAdapter.setBinaryData(pstmtUpdateMap, index++, bout.toByteArray());
  1273.                             pstmtUpdateMap.setString(index++, this.uniqueIdMap_idActivePolicy);
  1274.                             rows = pstmtUpdateMap.executeUpdate();
  1275.                         }
  1276.                         finally {
  1277.                             try {
  1278.                                 if(pstmtUpdateMap!=null) {
  1279.                                     pstmtUpdateMap.close();
  1280.                                 }
  1281.                             }catch(Throwable t) {
  1282.                                 // ignore
  1283.                             }
  1284.                         }
  1285.                         
  1286.                         if(this.debug) {
  1287.                             if(updateDate) {
  1288.                                 this.logSql.debug("[updateMap"+""+this.idTransazione+"] executed (rows:"+rows+") "+DBUtils.formatSQLString(queryUpdate,
  1289.                                         DateUtils.getSimpleDateFormatMs().format(this.uniqueIdMap_updateTime),
  1290.                                         ("blob-size:"+bout.size()), 
  1291.                                         this.uniqueIdMap_idActivePolicy));
  1292.                             }
  1293.                             else {
  1294.                                 this.logSql.debug("[updateMap"+""+this.idTransazione+"] executed (rows:"+rows+") "+DBUtils.formatSQLString(queryUpdate,
  1295.                                         ("blob-size:"+bout.size()), 
  1296.                                         this.uniqueIdMap_idActivePolicy));
  1297.                             }
  1298.                         }
  1299.                         
  1300.                         //System.out.println("@update UPDATE ["+opType+"]: "+rows);
  1301.                     }
  1302.                     
  1303.                     if(deleteMap) {
  1304.                         
  1305.                         ISQLQueryObject sqlDelete = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1306.                         sqlDelete.addDeleteTable(CT_MAP_TABLE);
  1307.                         sqlDelete.setANDLogicOperator(true);
  1308.                         sqlDelete.addWhereCondition(CT_MAP_COLUMN_KEY+"=?");
  1309.                         String queryDelete = sqlDelete.createSQLDelete();
  1310.                         
  1311.                         if(this.debug) {
  1312.                             this.logSql.debug("[deleteMap"+""+this.idTransazione+"] execute "+DBUtils.formatSQLString(queryDelete,
  1313.                                         this.uniqueIdMap_idActivePolicy));
  1314.                         }
  1315.                         
  1316.                         //System.out.println("INSERT ["+queryInsert.toString()+"]");
  1317.                         PreparedStatement pstmtDeleteMap = null;
  1318.                         int rows = -1;
  1319.                         try {
  1320.                             pstmtDeleteMap = con.prepareStatement(queryDelete);
  1321.                             int index = 1;
  1322.                             pstmtDeleteMap.setString(index++, this.uniqueIdMap_idActivePolicy);
  1323.                             rows = pstmtDeleteMap.executeUpdate();
  1324.                         }
  1325.                         finally {
  1326.                             try {
  1327.                                 if(pstmtDeleteMap!=null) {
  1328.                                     pstmtDeleteMap.close();
  1329.                                 }
  1330.                             }catch(Throwable t) {
  1331.                                 // ignore
  1332.                             }
  1333.                         }
  1334.                         
  1335.                         if(this.debug) {
  1336.                             this.logSql.debug("[updateMap"+""+this.idTransazione+"] executed (rows:"+rows+") "+DBUtils.formatSQLString(queryDelete,
  1337.                                         this.uniqueIdMap_idActivePolicy));
  1338.                         }
  1339.                         
  1340.                     }
  1341.                     
  1342.                     if(this.transactionMode) {
  1343.                         // Chiusura Transazione
  1344.                         con.commit();
  1345.                     }
  1346.                     
  1347.                     // ID Costruito
  1348.                     transactionUpdateFinished = true;
  1349.                 } catch(Throwable e) {
  1350.                     //System.out.println("ERRORE UPDATE ("+iteration+"): "+e.getMessage());
  1351.                     //log.info("ERROR GET SERIAL SQL ["+e.getMessage()+"]",e);
  1352.                     if(this.transactionMode) {
  1353.                         try{
  1354.                             con.rollback();
  1355.                         } catch(Exception er) {
  1356.                             // ignore
  1357.                         }
  1358.                     }
  1359.                     else {
  1360.                         throw new PolicyException("Operazione non riuscita: "+e.getMessage(),e);
  1361.                     }
  1362.                 }

  1364.                 if(transactionUpdateFinished == false){
  1365.                     if(this.transactionMode) {
  1366.                         // Per aiutare ad evitare conflitti
  1367.                         try{
  1368.                             int sleep = (getRandom()).nextInt(this.checkIntervalloJDBC);
  1369.                             //System.out.println("Sleep: "+sleep);
  1370.                             Utilities.sleep(sleep); // random
  1371.                         }catch(Exception eRandom){
  1372.                             // ignore
  1373.                         }
  1374.                     }
  1375.                     else {
  1376.                         throw new PolicyException("Operazione non riuscita");
  1377.                     }
  1378.                 }
  1379.                 
  1380.                 iteration++;
  1381.                 
  1382.                 if(policyNotFoundException!=null) {
  1383.                     throw policyNotFoundException;
  1384.                 }
  1385.                 if(policyException!=null) {
  1386.                     throw policyException;
  1387.                 }
  1388.                 
  1389.             }
  1390.             
  1391.             if(!transactionUpdateFinished) {
  1392.                 throw new PolicyException("Operazione non riuscita dopo '"+iteration+"' tentativi");
  1393.             }
  1394.             
  1395.         }
  1396.         finally{

  1398.             // Ripristino Transazione
  1399.             if(this.transactionMode) {
  1400.                 try{
  1401.                     if(autoCommitModificato){
  1402.                         con.setAutoCommit(originalConnectionAutocommit);
  1403.                     }
  1404.                 } catch(Exception er) {
  1405.                     //System.out.println("ERROR UNSET:"+er.getMessage());
  1406.                     //throw new PolicyException("CheckMap failed: unsetting connection error; "+er.getMessage());
  1407.                     if(this.log!=null) {
  1408.                         this.log.error("CheckMap failed: unsetting connection error; "+er.getMessage(),er);
  1409.                     }
  1410.                 }
  1411.             }
  1412.         }

  1414.         return updateResult;
  1415.         
  1416.     }
  1417. }
  1418.     
  1419. class PolicyConnessioneRuntime{
  1420.     
  1421.     Resource r = null;
  1422.     Connection con = null;
  1423.     
  1424. }

  1426. class UpdateResult{
  1427.     
  1428.     DatiCollezionati datiCollezionatiReaded;
  1429.     long counter;
  1430.     String info;
  1431.     java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> map;
  1432.     
  1433. }

  1435. enum OperationType {
  1436.     
  1437.     registerStartRequest,
  1438.     updateDatiStartRequestApplicabile,
  1439.     registerStopRequest,
  1440.     getActiveThreads,
  1441.     printInfos,
  1442.     resetCounters,
  1443.     remove,
  1444.     getMapActiveThreads,
  1445.     initMap
  1446.     
  1447. }
Created with JaCoCo 0.8.8.202204050719