DynamicClusterManager.java

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

  21. package org.openspcoop2.pdd.config;

  23. import java.sql.Connection;
  24. import java.sql.PreparedStatement;
  25. import java.sql.ResultSet;
  26. import java.sql.SQLException;
  27. import java.sql.Timestamp;
  28. import java.util.ArrayList;
  29. import java.util.Date;
  30. import java.util.List;

  32. import org.apache.commons.codec.digest.DigestUtils;
  33. import org.openspcoop2.core.commons.CoreException;
  34. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  35. import org.openspcoop2.core.constants.CostantiDB;
  36. import org.openspcoop2.pdd.services.ServicesUtils;
  37. import org.openspcoop2.pdd.services.connector.proxy.ProxyOperation;
  38. import org.openspcoop2.utils.LoggerWrapperFactory;
  39. import org.openspcoop2.utils.Utilities;
  40. import org.openspcoop2.utils.date.DateManager;
  41. import org.openspcoop2.utils.date.DateUtils;
  42. import org.openspcoop2.utils.id.apache.serial.MaxReachedException;
  43. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  44. import org.openspcoop2.utils.sql.ISQLQueryObject;
  45. import org.openspcoop2.utils.sql.SQLObjectFactory;
  46. import org.openspcoop2.utils.sql.SQLQueryObjectException;
  47. import org.slf4j.Logger;

  49. /**
  50.  * DynamicClusterManager
  51.  *
  52.  * @author Poli Andrea (apoli@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */
  56. public class DynamicClusterManager {

  58.     private static DynamicClusterManager staticInstance = null;
  59.     public static synchronized void initStaticInstance() throws CoreException {
  60.         if(staticInstance==null) {
  61.             staticInstance = new DynamicClusterManager();
  62.         }
  63.     }
  64.     public static DynamicClusterManager getInstance() throws CoreException {
  65.         if(staticInstance==null) {
  66.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  67.             synchronized (DynamicClusterManager.class) {
  68.                 initStaticInstance();
  69.             }
  70.         }
  71.         return staticInstance;
  72.     }
  73.     public static boolean isInitialized() {
  74.         return staticInstance!=null;
  75.     }
  76.     
  77.     private DriverConfigurazioneDB driverConfigurazioneDB = null;
  78.     private OpenSPCoop2Properties op2Properties = null;
  79.     
  80.     private DynamicClusterManager() throws CoreException {
  81.         Object oConfig = ConfigurazionePdDReader.getDriverConfigurazionePdD();
  82.         if(oConfig instanceof DriverConfigurazioneDB) {
  83.             this.driverConfigurazioneDB = (DriverConfigurazioneDB) oConfig;
  84.         }
  85.         else {
  86.             throw new CoreException("Modalità dinamica utilizzabile solamente con una configurazione su database");
  87.         }
  88.         this.op2Properties = OpenSPCoop2Properties.getInstance();
  89.     }
  90.     
  91.     private boolean rateLimitingGestioneCluster = false;
  92.     public boolean isRateLimitingGestioneCluster() {
  93.         return this.rateLimitingGestioneCluster;
  94.     }
  95.     public void setRateLimitingGestioneCluster(boolean rateLimitingGestioneCluster) {
  96.         this.rateLimitingGestioneCluster = rateLimitingGestioneCluster;
  97.     }
  98.     
  99.     private int identificativoNumerico = -1;
  100.     public int getIdentificativoNumerico() {
  101.         return this.identificativoNumerico;
  102.     }
  103.     
  104.     private String getSuffixMessageUpdate(int row) {
  105.         return " nella tabella '"+CostantiDB.CONFIG_NODI_RUNTIME+"' (update-row: "+row+")";
  106.     }
  107.     
  108.     public void register(Logger log) throws CoreException {
  109.         Connection con = null;
  110.         int oldTransactionIsolation = -1;
  111.         try {
  112.             con = this.driverConfigurazioneDB.getConnection("DynamicClusterManager.register");
  113.             
  114.             boolean autoCommit = false;
  115.             con.setAutoCommit(autoCommit);
  116.             
  117.             /*
  118.               Viene realizzato con livello di isolamento SERIALIZABLE, per essere sicuri
  119.               che esecuzioni parallele non leggano dati inconsistenti.
  120.               Con il livello SERIALIZABLE, se ritorna una eccezione, deve essere riprovato
  121.               La sincronizzazione e' necessaria per via del possibile accesso simultaneo del servizio Gop
  122.               e del servizio che si occupa di eliminare destinatari di messaggi
  123.              */
  124.             // setAutoCommit e livello Isolamento
  125.             try{
  126.                 oldTransactionIsolation = con.getTransactionIsolation();
  127.                 JDBCUtilities.setTransactionIsolationSerializable(this.driverConfigurazioneDB.getTipoDB(), con);
  128.             } catch(Exception er) {
  129.                 throw new CoreException("(setIsolation) "+er.getMessage(),er);
  130.             }

  132.             boolean updateEffettuato = false;
  133.             
  134.             long gestioneSerializableDBattesaAttiva = this.op2Properties.getGestioneSerializableDBAttesaAttiva();
  135.             int gestioneSerializableDBcheckInterval = this.op2Properties.getGestioneSerializableDBCheckInterval();
  136.             long scadenzaWhile = DateManager.getTimeMillis() + gestioneSerializableDBattesaAttiva;
  137.             
  138.             Exception eLast = null;
  139.             
  140.             while(!updateEffettuato && DateManager.getTimeMillis() < scadenzaWhile){

  142.                 try{
  143.                     this.registerEngine(con, log);

  145.                     updateEffettuato = true;

  147.                 } 
  148.                 catch(MaxReachedException maxReached) {
  149.                     throw maxReached;
  150.                 }
  151.                 catch(Exception e) {
  152.                     eLast = e;
  153.                     /**System.out.println("Serializable error:"+e.getMessage());*/
  154.                 }

  156.                 if(!updateEffettuato){
  157.                     // Per aiutare ad evitare conflitti
  158.                     try{
  159.                         Utilities.sleep((ServicesUtils.getRandom()).nextInt(gestioneSerializableDBcheckInterval)); // random da 0ms a checkIntervalms
  160.                     }catch(Exception eRandom){
  161.                         // ignore
  162.                     }
  163.                 }
  164.             }
  165.                         
  166.             if(!updateEffettuato){
  167.                 throw new CoreException("Registrazione fallita: "+eLast.getMessage(), eLast);
  168.             }
  169.         }
  170.         catch(Exception e) {
  171.             throw new CoreException("[DynamicClusterManager.register] failed: "+e.getMessage(), e);
  172.         }
  173.         finally {
  174.             // Ripristino Transazione
  175.             try{
  176.                 con.setTransactionIsolation(oldTransactionIsolation);
  177.             } catch(Exception er) {
  178.                 if(log!=null) {
  179.                     log.error("(ripristinoIsolation) "+er.getMessage(),er);
  180.                 }
  181.                 else {
  182.                     LoggerWrapperFactory.getLogger(DynamicClusterManager.class).error("(ripristinoIsolation) "+er.getMessage(),er);
  183.                 }
  184.             }
  185.             try{
  186.                 con.setAutoCommit(true);
  187.             }catch(Exception eRollback){
  188.                 /**if(log!=null) {
  189.                     log.error("(setAutoCommit) "+eRollback.getMessage(),eRollback);
  190.                 }
  191.                 else {
  192.                     LoggerWrapperFactory.getLogger(DynamicClusterManager.class).error("(setAutoCommit) "+eRollback.getMessage(),eRollback);
  193.                 }*/
  194.             }
  195.             try {
  196.                 if(con!=null) {
  197.                     this.driverConfigurazioneDB.releaseConnection(con);
  198.                 }
  199.             }catch(Exception eClose) {
  200.                 // close
  201.             }
  202.         }
  203.     }
  204.     
  205.     private void registerEngine(Connection con, Logger log) throws MaxReachedException, SQLException, SQLQueryObjectException {
  206.         try {
  207.             boolean find = registerExistsId(con);
  208.             
  209.             if(find) {
  210.                 
  211.                 // Update
  212.                 registerUpdate(con, log);
  213.                 
  214.             }
  215.             else {
  216.                 
  217.                 // Cerco idNumerico disponibile
  218.                 /**if(this.op2Properties.isClusterIdNumericoDinamico()) { FIX: va sempre calcolato per l'unique del db*/
  219.                 this.identificativoNumerico = this.getNextIdNumerico(con, log);
  220.                 
  221.                 // Insert
  222.                 registerInsert(con, log);
  223.             }
  224.             
  225.             con.commit();
  226.         }
  227.         catch(Exception e) {
  228.             try{
  229.                 con.rollback();
  230.             } catch(Exception er) {
  231.                 // ignore
  232.             }
  233.             throw e;
  234.         }
  235.     }
  236.     private boolean registerExistsId(Connection con) throws SQLException, SQLQueryObjectException {
  237.         PreparedStatement pstmt = null;
  238.         ResultSet rs = null;
  239.         try {
  240.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  241.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_NODI_RUNTIME);
  242.             sqlQueryObject.addSelectField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_ID_NUMERICO);
  243.             sqlQueryObject.setANDLogicOperator(true);
  244.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_HOSTNAME+"=?");
  245.             String query = sqlQueryObject.createSQLQuery();
  246.             pstmt = con.prepareStatement(query);
  247.             int index = 1;
  248.             pstmt.setString(index++, this.op2Properties.getClusterHostname());
  249.             rs = pstmt.executeQuery();
  250.             boolean find = rs.next();
  251.             if(find) {
  252.                 this.identificativoNumerico = rs.getInt(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_ID_NUMERICO);
  253.             }
  254.             return find;
  255.         }
  256.         finally {
  257.             try {
  258.                 if(rs!=null) {
  259.                     rs.close();
  260.                 }
  261.             }catch(Exception eClose) {
  262.                 // close
  263.             }
  264.             try {
  265.                 if(pstmt!=null) {
  266.                     pstmt.close();
  267.                 }
  268.             }catch(Exception eClose) {
  269.                 // close
  270.             }
  271.         }
  272.     }
  273.     private void registerInsert(Connection con, Logger log) throws SQLException, SQLQueryObjectException {
  274.         PreparedStatement pstmt = null;
  275.         try {
  276.             // Insert
  277.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  278.             sqlQueryObject.addInsertTable(CostantiDB.CONFIG_NODI_RUNTIME);
  279.             sqlQueryObject.addInsertField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_HOSTNAME, "?");
  280.             sqlQueryObject.addInsertField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_GRUPPO, "?");
  281.             sqlQueryObject.addInsertField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_DATA_REGISTRAZIONE, "?");
  282.             sqlQueryObject.addInsertField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_DATA_REFRESH, "?");
  283.             sqlQueryObject.addInsertField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_ID_NUMERICO, "?");
  284.             String insert = sqlQueryObject.createSQLInsert();
  285.             pstmt = con.prepareStatement(insert);
  286.             int index = 1;
  287.             pstmt.setString(index++, this.op2Properties.getClusterHostname());
  288.             pstmt.setString(index++, this.op2Properties.getGroupId(this.rateLimitingGestioneCluster));
  289.             Timestamp now = DateManager.getTimestamp();
  290.             pstmt.setTimestamp(index++, now);
  291.             pstmt.setTimestamp(index++, now);
  292.             pstmt.setInt(index++, this.identificativoNumerico);
  293.             int row = pstmt.executeUpdate();
  294.             
  295.             String msg = "Registrato hostname '"+this.op2Properties.getClusterHostname()+"'"+getSuffixMessageUpdate(row);
  296.             log.debug(msg);
  297.         }
  298.         finally {
  299.             try {
  300.                 if(pstmt!=null) {
  301.                     pstmt.close();
  302.                 }
  303.             }catch(Exception eClose) {
  304.                 // close
  305.             }
  306.         }
  307.     }
  308.     private void registerUpdate(Connection con, Logger log) throws SQLException, SQLQueryObjectException {
  309.         PreparedStatement pstmt = null;
  310.         try {
  311.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  312.             sqlQueryObject.addUpdateTable(CostantiDB.CONFIG_NODI_RUNTIME);
  313.             sqlQueryObject.addUpdateField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_GRUPPO, "?");
  314.             sqlQueryObject.addUpdateField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_DATA_REGISTRAZIONE, "?");
  315.             sqlQueryObject.addUpdateField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_DATA_REFRESH, "?");
  316.             sqlQueryObject.setANDLogicOperator(true);
  317.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_HOSTNAME+"=?");
  318.             String update = sqlQueryObject.createSQLUpdate();
  319.             pstmt = con.prepareStatement(update);
  320.             int index = 1;
  321.             pstmt.setString(index++, this.op2Properties.getGroupId(this.rateLimitingGestioneCluster));
  322.             Timestamp now = DateManager.getTimestamp();
  323.             pstmt.setTimestamp(index++, now);
  324.             pstmt.setTimestamp(index++, now);
  325.             pstmt.setString(index++, this.op2Properties.getClusterHostname());
  326.             int row = pstmt.executeUpdate();
  327.             
  328.             String msg = "Registrato con aggiormanento hostname '"+this.op2Properties.getClusterHostname()+"'"+getSuffixMessageUpdate(row);
  329.             log.debug(msg);
  330.         }
  331.         finally {
  332.             try {
  333.                 if(pstmt!=null) {
  334.                     pstmt.close();
  335.                 }
  336.             }catch(Exception eClose) {
  337.                 // close
  338.             }
  339.         }
  340.     }
  341.     private int getNextIdNumerico(Connection con, Logger log) throws MaxReachedException, SQLException, SQLQueryObjectException {
  342.         PreparedStatement pstmt = null;
  343.         ResultSet rs = null;
  344.         try {
  345.             // Cerco idNumerico disponibile
  346.             int idNumerico = -1;
  347.             int max = getMax();
  348.             
  349.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  350.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_NODI_RUNTIME);
  351.             sqlQueryObject.setANDLogicOperator(true);
  352.             sqlQueryObject.addSelectCountField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_ID_NUMERICO, "countid");
  353.             sqlQueryObject.addSelectMaxField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_ID_NUMERICO, "maxid");
  354.             sqlQueryObject.setANDLogicOperator(true);
  355.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_GRUPPO+"=?");
  356.             String query = sqlQueryObject.createSQLQuery();
  357.             pstmt = con.prepareStatement(query);
  358.             int index = 1;
  359.             pstmt.setString(index++, this.op2Properties.getGroupId(this.rateLimitingGestioneCluster));
  360.             rs = pstmt.executeQuery();
  361.             if(rs.next()) {
  362.                 int countid = rs.getInt("countid");
  363.                 int findId = rs.getInt("maxid");
  364.                 if(countid == 0) {
  365.                     idNumerico = 0; // primo id numerico
  366.                 }
  367.                 else if((findId+1)<=max) {
  368.                     idNumerico = findId+1;
  369.                 }
  370.             }
  371.             else {
  372.                 idNumerico = 0; // primo id numerico
  373.             }
  374.             rs.close(); rs = null;
  375.             pstmt.close(); pstmt = null;
  376.             
  377.             if(idNumerico<0) {
  378.                 try {
  379.                     idNumerico = getIdNumerico(con, max);
  380.                 }catch(MaxReachedException maxReached) {
  381.                     // provo a forzare svecchiamento
  382.                     try {
  383.                         deleteOldHostnames(con, log);
  384.                     }catch(Exception e) {
  385.                         // ignore e rilancio eccezione originale
  386.                         throw maxReached;
  387.                     }
  388.                     // riprovo a calcolarlo
  389.                     idNumerico = getIdNumerico(con, max);
  390.                 }
  391.             }

  393.             return idNumerico;
  394.         }
  395.         finally {
  396.             try {
  397.                 if(rs!=null) {
  398.                     rs.close();
  399.                 }
  400.             }catch(Exception eClose) {
  401.                 // close
  402.             }
  403.             try {
  404.                 if(pstmt!=null) {
  405.                     pstmt.close();
  406.                 }
  407.             }catch(Exception eClose) {
  408.                 // close
  409.             }
  410.         }
  411.     }
  412.     private int getMax() {
  413.         int cifre = this.op2Properties.getClusterDinamicoIdNumericoCifre(this.rateLimitingGestioneCluster);
  414.         StringBuilder sbCifre = new StringBuilder();
  415.         for (int i = 0; i < cifre; i++) {
  416.             sbCifre.append("9");
  417.         }
  418.         // int max
  419.         return Integer.parseInt(sbCifre.toString());
  420.     }
  421.     private int getIdNumerico(Connection con, int max) throws MaxReachedException, SQLException, SQLQueryObjectException {
  422.         PreparedStatement pstmt = null;
  423.         ResultSet rs = null;
  424.         int idNumerico = -1;
  425.         try {
  426.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  427.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_NODI_RUNTIME);
  428.             sqlQueryObject.addSelectField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_ID_NUMERICO);
  429.             sqlQueryObject.setANDLogicOperator(true);
  430.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_GRUPPO+"=?");
  431.             sqlQueryObject.addOrderBy(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_ID_NUMERICO, true);
  432.             String query = sqlQueryObject.createSQLQuery();
  433.             pstmt = con.prepareStatement(query);
  434.             int index = 1;
  435.             pstmt.setString(index++, this.op2Properties.getGroupId(this.rateLimitingGestioneCluster));
  436.             rs = pstmt.executeQuery();
  437.             int search = 0;
  438.             while(rs.next()) {
  439.                 int idNumericoExists = rs.getInt(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_ID_NUMERICO);
  440.                 if(search!=idNumericoExists) {
  441.                     idNumerico = search;
  442.                     break;
  443.                 }
  444.                 search++;
  445.                 if(search>max) {
  446.                     throw new MaxReachedException("Numero massimo di nodi registrabili ("+(max+1)+") raggiunto");
  447.                 }
  448.             }
  449.         }
  450.         finally {
  451.             try {
  452.                 if(rs!=null) {
  453.                     rs.close();
  454.                 }
  455.             }catch(Exception eClose) {
  456.                 // close
  457.             }
  458.             try {
  459.                 if(pstmt!=null) {
  460.                     pstmt.close();
  461.                 }
  462.             }catch(Exception eClose) {
  463.                 // close
  464.             }
  465.         }
  466.         return idNumerico;
  467.     }
  468.     
  469.     public void unregister(Logger log) throws CoreException {
  470.         unregister(log, this.op2Properties.getClusterHostname());
  471.     }
  472.     private void unregister(Logger log, String hostname) throws CoreException {
  473.         Connection con = null;
  474.         try {
  475.             con = this.driverConfigurazioneDB.getConnection("DynamicClusterManager.unregister");
  476.             
  477.             unregister(con, log, hostname);
  478.             
  479.             if(!con.getAutoCommit()) {
  480.                 con.commit();
  481.             }

  483.         }
  484.         catch(Exception e) {
  485.             
  486.             try {
  487.                 if(con!=null && !con.getAutoCommit()) {
  488.                     con.rollback();
  489.                 }
  490.             }catch(Exception eClose) {
  491.                 // close
  492.             }
  493.             
  494.             throw new CoreException("[DynamicClusterManager.unregister] failed: "+e.getMessage(), e);
  495.         }
  496.         finally {
  497.             try {
  498.                 if(con!=null) {
  499.                     this.driverConfigurazioneDB.releaseConnection(con);
  500.                 }
  501.             }catch(Exception eClose) {
  502.                 // close
  503.             }
  504.         }
  505.     }
  506.     private void unregister(Connection con, Logger log, String hostname) throws CoreException {
  507.         PreparedStatement pstmt = null;
  508.         try {
  509.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  510.             sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_NODI_RUNTIME);
  511.             sqlQueryObject.setANDLogicOperator(true);
  512.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_HOSTNAME+"=?");
  513.             String query = sqlQueryObject.createSQLDelete();
  514.             pstmt = con.prepareStatement(query);
  515.             int index = 1;
  516.             pstmt.setString(index++, hostname);
  517.             int row = pstmt.executeUpdate();
  518.             pstmt.close(); pstmt = null;
  519.             
  520.             String msg = "Eliminato hostname '"+this.op2Properties.getClusterHostname()+"' dalla tabella '"+CostantiDB.CONFIG_NODI_RUNTIME+"' (update-row: "+row+")";
  521.             log.debug(msg);
  522.         }
  523.         catch(Exception e) {
  524.             throw new CoreException("[DynamicClusterManager.unregister] failed: "+e.getMessage(), e);
  525.         }
  526.         finally {
  527.             try {
  528.                 if(pstmt!=null) {
  529.                     pstmt.close();
  530.                 }
  531.             }catch(Exception eClose) {
  532.                 // close
  533.             }
  534.         }
  535.     }
  536.     
  537.     public void refresh(Logger log) throws CoreException {
  538.         Connection con = null;
  539.         PreparedStatement pstmt = null;
  540.         try {
  541.             con = this.driverConfigurazioneDB.getConnection("DynamicClusterManager.refresh");
  542.             
  543.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  544.             sqlQueryObject.addUpdateTable(CostantiDB.CONFIG_NODI_RUNTIME);
  545.             sqlQueryObject.addUpdateField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_DATA_REFRESH, "?");
  546.             sqlQueryObject.setANDLogicOperator(true);
  547.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_HOSTNAME+"=?");
  548.             String update = sqlQueryObject.createSQLUpdate();
  549.             pstmt = con.prepareStatement(update);
  550.             int index = 1;
  551.             Timestamp now = DateManager.getTimestamp();
  552.             pstmt.setTimestamp(index++, now);
  553.             pstmt.setString(index++, this.op2Properties.getClusterHostname());
  554.             int row = pstmt.executeUpdate();
  555.             pstmt.close(); pstmt = null;
  556.             
  557.             if(!con.getAutoCommit()) {
  558.                 con.commit();
  559.             }
  560.             
  561.             String msg = "Aggiornato hostname '"+this.op2Properties.getClusterHostname()+"'"+getSuffixMessageUpdate(row);
  562.             log.debug(msg);
  563.         }
  564.         catch(Exception e) {
  565.             
  566.             try {
  567.                 if(con!=null && !con.getAutoCommit()) {
  568.                     con.rollback();
  569.                 }
  570.             }catch(Exception eClose) {
  571.                 // close
  572.             }
  573.             
  574.             throw new CoreException("[DynamicClusterManager.refresh] failed: "+e.getMessage(), e);
  575.         }
  576.         finally {
  577.             try {
  578.                 if(pstmt!=null) {
  579.                     pstmt.close();
  580.                 }
  581.             }catch(Exception eClose) {
  582.                 // close
  583.             }
  584.             try {
  585.                 if(con!=null) {
  586.                     this.driverConfigurazioneDB.releaseConnection(con);
  587.                 }
  588.             }catch(Exception eClose) {
  589.                 // close
  590.             }
  591.         }
  592.     }
  593.     
  594.     
  595.     
  596.     public void deleteOldHostnames(Logger log) throws CoreException {
  597.         
  598.         Connection con = null;
  599.         try {
  600.             con = this.driverConfigurazioneDB.getConnection("DynamicClusterManager.deleteOldHostnames");
  601.                         
  602.             deleteOldHostnames(con, log);
  603.             
  604.             if(!con.getAutoCommit()) {
  605.                 con.commit();
  606.             }
  607.         }
  608.         catch(Exception e) {
  609.             
  610.             try {
  611.                 if(con!=null && !con.getAutoCommit()) {
  612.                     con.rollback();
  613.                 }
  614.             }catch(Exception eClose) {
  615.                 // close
  616.             }
  617.             
  618.             if(e instanceof CoreException) {
  619.                 throw (CoreException) e;
  620.             }
  621.             else {
  622.                 throw new CoreException("[DynamicClusterManager.deleteOldHostnames] failed: "+e.getMessage(), e);
  623.             }
  624.         }
  625.         finally {
  626.             try {
  627.                 if(con!=null) {
  628.                     this.driverConfigurazioneDB.releaseConnection(con);
  629.                 }
  630.             }catch(Exception eClose) {
  631.                 // close
  632.             }
  633.         }
  634.         
  635.     }
  636.     private void deleteOldHostnames(Connection con, Logger log) throws CoreException {
  637.         
  638.         String gruppo = null;
  639.         String oldData = null;
  640.         try {
  641.             gruppo = this.op2Properties.getGroupId(this.rateLimitingGestioneCluster);
  642.             Timestamp oldest = getTimestampRefresh(this.op2Properties.getClusterDinamicoRefreshSecondsInterval());
  643.             oldData = DateUtils.getSimpleDateFormatMs().format(oldest);
  644.             
  645.             List<String> listOldHostnames = getHostnames(con, this.driverConfigurazioneDB.getTipoDB(),
  646.                     gruppo, 
  647.                     oldest,
  648.                     true
  649.                     );
  650.             if(!listOldHostnames.isEmpty()) {
  651.                 for (String hostname : listOldHostnames) {
  652.                     unregister(con, log, hostname);
  653.                 }
  654.             }
  655.             
  656.         }
  657.         catch(Exception e) {
  658.             throw new CoreException("[DynamicClusterManager.deleteOldHostnames] (groupId:"+gruppo+" oldestDate:"+oldData+") failed: "+e.getMessage(), e);
  659.         }
  660.         
  661.     }
  662.     
  663.     
  664.     public List<String> getHostnames(Logger log) throws CoreException {
  665.         Connection con = null;
  666.         String gruppo = null;
  667.         String oldData = null;
  668.         try {
  669.             gruppo = this.op2Properties.getGroupId(this.rateLimitingGestioneCluster);
  670.             Timestamp oldest = getTimestampRefresh(this.op2Properties.getClusterDinamicoRefreshSecondsInterval());
  671.             oldData = DateUtils.getSimpleDateFormatMs().format(oldest);
  672.             con = this.driverConfigurazioneDB.getConnection("DynamicClusterManager.refresh");
  673.             
  674.             List<String> l = getHostnames(con, this.driverConfigurazioneDB.getTipoDB(),
  675.                     gruppo, 
  676.                     oldest,
  677.                     false
  678.                     );
  679.             if(l.isEmpty()) {
  680.                 throw new CoreException("nodes not found");
  681.             }
  682.             return l;
  683.         }
  684.         catch(Exception e) {
  685.             if(log!=null) {
  686.                 // per adesso rilancio l'eccezione
  687.             }
  688.             throw new CoreException("[DynamicClusterManager.getHostnames] (groupId:"+gruppo+" oldestDate:"+oldData+") failed: "+e.getMessage(), e);
  689.         }
  690.         finally {
  691.             try {
  692.                 if(con!=null) {
  693.                     this.driverConfigurazioneDB.releaseConnection(con);
  694.                 }
  695.             }catch(Exception eClose) {
  696.                 // close
  697.             }
  698.         }
  699.     }
  700.     
  701.     private static Timestamp getTimestampRefresh(int refreshSecondsInterval) {
  702.         int oldSeconds = refreshSecondsInterval*2; // raddoppio il tempo di refresh
  703.         // aggiungo ancora la metà
  704.         oldSeconds = oldSeconds + (refreshSecondsInterval/2);
  705.         // Timestamp oldest
  706.         return new Timestamp(System.currentTimeMillis()-(oldSeconds*1000));
  707.     }
  708.     
  709.     public static List<String> getHostnames(Connection con, String tipoDB, String gruppo, int refreshSecondsInterval) throws CoreException {
  710.         Timestamp oldest = getTimestampRefresh(refreshSecondsInterval);
  711.         return getHostnames(con, tipoDB, gruppo, oldest, false);
  712.     }
  713.     public static List<String> getHostnames(Connection con, String tipoDB, String gruppo, Timestamp oldest, boolean returnOldHostname) throws CoreException {
  714.         PreparedStatement pstmt = null;
  715.         ResultSet rs = null;
  716.         try {
  717.             List<String> list = new ArrayList<>();
  718.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  719.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_NODI_RUNTIME);
  720.             sqlQueryObject.addSelectField(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_HOSTNAME);
  721.             sqlQueryObject.setANDLogicOperator(true);
  722.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_GRUPPO+"=?");
  723.             if(returnOldHostname) {
  724.                 sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_DATA_REFRESH+"<?");
  725.             }
  726.             else {
  727.                 sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_DATA_REFRESH+">?");
  728.             }
  729.             sqlQueryObject.addOrderBy(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_DATA_REFRESH, true); // parto dal piu' vecchio
  730.             String update = sqlQueryObject.createSQLQuery();
  731.             pstmt = con.prepareStatement(update);
  732.             int index = 1;
  733.             pstmt.setString(index++, gruppo);
  734.             pstmt.setTimestamp(index++, oldest);
  735.             rs = pstmt.executeQuery();
  736.             while(rs.next()) {
  737.                 String hostname = rs.getString(CostantiDB.CONFIG_NODI_RUNTIME_COLUMN_HOSTNAME);
  738.                 list.add(hostname);
  739.             }
  740.             rs.close(); rs = null;
  741.             pstmt.close(); pstmt = null;
  742.             return list;
  743.         }
  744.         catch(Exception e) {
  745.             throw new CoreException("[DynamicClusterManager.refresh] failed: "+e.getMessage(), e);
  746.         }
  747.         finally {
  748.             try {
  749.                 if(rs!=null) {
  750.                     rs.close();
  751.                 }
  752.             }catch(Exception eClose) {
  753.                 // close
  754.             }
  755.             try {
  756.                 if(pstmt!=null) {
  757.                     pstmt.close();
  758.                 }
  759.             }catch(Exception eClose) {
  760.                 // close
  761.             }
  762.         }
  763.     }
  764.     
  765.     public static String hashClusterId(String id) {
  766.         return DigestUtils.sha256Hex(id);
  767.     }
  768.     
  769.     
  770.     
  771.     
  772.     
  773.     
  774.     
  775.     public void registerOperation(Logger log, String descrizione, String operazione) throws CoreException {
  776.         Connection con = null;
  777.         PreparedStatement pstmt = null;
  778.         try {
  779.             if(descrizione==null) {
  780.                 throw new CoreException("Param 'descrizione' undefined");
  781.             }
  782.             if(operazione==null) {
  783.                 throw new CoreException("Param 'operazione' undefined");
  784.             }
  785.             
  786.             con = this.driverConfigurazioneDB.getConnection("DynamicClusterManager.registerOperation");
  787.             
  788.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  789.             sqlQueryObject.addInsertTable(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS);
  790.             sqlQueryObject.addInsertField(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DESCRIZIONE, "?");
  791.             sqlQueryObject.addInsertField(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_OPERAZIONE, "?");
  792.             sqlQueryObject.addInsertField(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DATA_REGISTRAZIONE, "?");
  793.             String insert = sqlQueryObject.createSQLInsert();
  794.             pstmt = con.prepareStatement(insert);
  795.             int index = 1;
  796.             pstmt.setString(index++, descrizione);
  797.             pstmt.setString(index++, operazione);
  798.             Timestamp now = DateManager.getTimestamp();
  799.             pstmt.setTimestamp(index++, now);
  800.             int row = pstmt.executeUpdate();
  801.             
  802.             String msg = "Registrata operazione '"+descrizione+"'"+getSuffixMessageUpdate(row);
  803.             log.debug(msg);
  804.             
  805.             if(!con.getAutoCommit()) {
  806.                 con.commit();
  807.             }
  808.         }
  809.         catch(Exception e) {
  810.             
  811.             try {
  812.                 if(con!=null && !con.getAutoCommit()) {
  813.                     con.rollback();
  814.                 }
  815.             }catch(Exception eClose) {
  816.                 // close
  817.             }
  818.             
  819.             throw new CoreException("[DynamicClusterManager.registerOperation] failed: "+e.getMessage(), e);
  820.         }
  821.         finally {
  822.             try {
  823.                 if(pstmt!=null) {
  824.                     pstmt.close();
  825.                 }
  826.             }catch(Exception eClose) {
  827.                 // close
  828.             }
  829.             try {
  830.                 if(con!=null) {
  831.                     this.driverConfigurazioneDB.releaseConnection(con);
  832.                 }
  833.             }catch(Exception eClose) {
  834.                 // close
  835.             }
  836.         }
  837.     }
  838.     
  839.     
  840.     public List<ProxyOperation> findRemoteOperations(Date dataRegistrazione, Date now, int offset, int limit) throws CoreException {
  841.         Connection con = null;
  842.         PreparedStatement pstmt = null;
  843.         ResultSet rs = null;
  844.         try {
  845.             checkDate(dataRegistrazione, now);
  846.             
  847.             con = this.driverConfigurazioneDB.getConnection("DynamicClusterManager.findRemoteOperations");
  848.             
  849.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  850.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS);
  851.             sqlQueryObject.addSelectField(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DESCRIZIONE);
  852.             sqlQueryObject.addSelectField(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_OPERAZIONE);
  853.             sqlQueryObject.addSelectField(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DATA_REGISTRAZIONE);
  854.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DATA_REGISTRAZIONE+">=?");
  855.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DATA_REGISTRAZIONE+"<?");
  856.             boolean asc = true;
  857.             sqlQueryObject.addOrderBy(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DATA_REGISTRAZIONE, asc);
  858.             sqlQueryObject.setANDLogicOperator(true);
  859.             if(offset>=0) {
  860.                 sqlQueryObject.setOffset(offset);
  861.             }
  862.             if(limit>0) {
  863.                 sqlQueryObject.setLimit(limit);
  864.             }
  865.             
  866.             String query = sqlQueryObject.createSQLQuery();
  867.             
  868.             List<ProxyOperation> list = new ArrayList<>();
  869.             
  870.             pstmt = con.prepareStatement(query);
  871.             int index = 1;
  872.             pstmt.setTimestamp(index++, new Timestamp(dataRegistrazione.getTime()));
  873.             pstmt.setTimestamp(index++, new Timestamp(now.getTime()));
  874.             rs = pstmt.executeQuery();
  875.             while(rs.next()) {
  876.                 list.add(readProxyOperation(rs));
  877.             }
  878.             
  879.             return list;
  880.         }
  881.         catch(Exception e) {
  882.             
  883.             try {
  884.                 if(con!=null && !con.getAutoCommit()) {
  885.                     con.rollback();
  886.                 }
  887.             }catch(Exception eClose) {
  888.                 // close
  889.             }
  890.             
  891.             throw new CoreException("[DynamicClusterManager.findRemoteOperations] failed: "+e.getMessage(), e);
  892.         }
  893.         finally {
  894.             try {
  895.                 if(rs!=null) {
  896.                     rs.close();
  897.                 }
  898.             }catch(Exception eClose) {
  899.                 // close
  900.             }
  901.             try {
  902.                 if(pstmt!=null) {
  903.                     pstmt.close();
  904.                 }
  905.             }catch(Exception eClose) {
  906.                 // close
  907.             }
  908.             try {
  909.                 if(con!=null) {
  910.                     this.driverConfigurazioneDB.releaseConnection(con);
  911.                 }
  912.             }catch(Exception eClose) {
  913.                 // close
  914.             }
  915.         }
  916.     }
  917.     private void checkDate(Date dataRegistrazione, Date now) throws CoreException {
  918.         if(dataRegistrazione==null) {
  919.             throw new CoreException("Param 'dataRegistrazione' undefined");
  920.         }
  921.         if(now==null) {
  922.             throw new CoreException("Param 'now' undefined");
  923.         }
  924.     }
  925.     private ProxyOperation readProxyOperation(ResultSet rs) throws SQLException, CoreException {
  926.         if(rs==null) {
  927.             throw new CoreException("Param 'rs' undefined");
  928.         }
  929.         
  930.         String descrizione = rs.getString(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DESCRIZIONE);
  931.         String operazione = rs.getString(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_OPERAZIONE);
  932.         Date dataRegistrazioneReaded = rs.getTimestamp(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DATA_REGISTRAZIONE);
  933.         ProxyOperation po = new ProxyOperation();
  934.         po.setCommand(operazione);
  935.         po.setDescription(descrizione);
  936.         po.setRegistrationTime(dataRegistrazioneReaded);
  937.         return po;
  938.     }
  939.     
  940.     public int deleteRemoteOperations(Date dataRegistrazione) throws CoreException {
  941.         Connection con = null;
  942.         PreparedStatement pstmt = null;
  943.         try {
  944.             if(dataRegistrazione==null) {
  945.                 throw new CoreException("Param 'dataRegistrazione' undefined");
  946.             }
  947.             
  948.             con = this.driverConfigurazioneDB.getConnection("DynamicClusterManager.deleteRemoteOperations");
  949.             
  950.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driverConfigurazioneDB.getTipoDB());
  951.             sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS);
  952.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_NODI_RUNTIME_OPERATIONS_COLUMN_DATA_REGISTRAZIONE+"<?");
  953.             sqlQueryObject.setANDLogicOperator(true);
  954.             
  955.             String query = sqlQueryObject.createSQLDelete();
  956.             
  957.             pstmt = con.prepareStatement(query);
  958.             int index = 1;
  959.             pstmt.setTimestamp(index++, new Timestamp(dataRegistrazione.getTime()));
  960.             return pstmt.executeUpdate();
  961.         }
  962.         catch(Exception e) {
  963.             
  964.             try {
  965.                 if(con!=null && !con.getAutoCommit()) {
  966.                     con.rollback();
  967.                 }
  968.             }catch(Exception eClose) {
  969.                 // close
  970.             }
  971.             
  972.             throw new CoreException("[DynamicClusterManager.deleteRemoteOperations] failed: "+e.getMessage(), e);
  973.         }
  974.         finally {
  975.             try {
  976.                 if(pstmt!=null) {
  977.                     pstmt.close();
  978.                 }
  979.             }catch(Exception eClose) {
  980.                 // close
  981.             }
  982.             try {
  983.                 if(con!=null) {
  984.                     this.driverConfigurazioneDB.releaseConnection(con);
  985.                 }
  986.             }catch(Exception eClose) {
  987.                 // close
  988.             }
  989.         }
  990.     }
  991. }
Created with JaCoCo 0.8.8.202204050719