IDSerialGenerator_numeric.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.utils.id.serial;

  22. import java.io.ByteArrayOutputStream;
  23. import java.io.PrintStream;
  24. import java.security.SecureRandom;
  25. import java.sql.Connection;
  26. import java.sql.PreparedStatement;
  27. import java.sql.ResultSet;
  28. import java.util.ArrayList;
  29. import java.util.List;

  31. import org.openspcoop2.utils.TipiDatabase;
  32. import org.openspcoop2.utils.Utilities;
  33. import org.openspcoop2.utils.UtilsException;
  34. import org.openspcoop2.utils.date.DateManager;
  35. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  36. import org.openspcoop2.utils.sql.ISQLQueryObject;
  37. import org.openspcoop2.utils.sql.SQLObjectFactory;
  38. import org.slf4j.Logger;

  40. /**
  41.  * IDSerialGenerator_numeric
  42.  *
  43.  * @author Andrea Poli (apoli@link.it)
  44.  * @author $Author$
  45.  * @version $Rev$, $Date$
  46.  */
  47. public class IDSerialGenerator_numeric {

  49.     private static SecureRandom _rnd = null;
  50.     private static synchronized void initRandom() {
  51.         if(_rnd==null) {
  52.             _rnd = new SecureRandom();
  53.         }
  54.     }
  55.     private static java.util.Random getRandom() {
  56.         if(_rnd==null) {
  57.             initRandom();
  58.         }
  59.         return _rnd;
  60.     }
  61.     
  62.     
  63.     public static String generate(Connection conDB,TipiDatabase tipoDatabase,
  64.             IDSerialGeneratorParameter param,Logger log, InfoStatistics infoStatistics) throws UtilsException{
  65.                 
  66.         long attesaAttivaJDBC = param.getSerializableTimeWaitMs();
  67.         int checkIntervalloJDBC = param.getSerializableNextIntervalTimeMs();
  68.         String protocollo = param.getProtocollo();
  69.         
  70.         long counterTmp = -1;
  71.         
  72.         boolean idBuildOK = false;

  74.         long scadenzaWhile = DateManager.getTimeMillis()
  75.                 + attesaAttivaJDBC;

  77.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  78.         PrintStream ps = new PrintStream(out);
  79.         
  80.         int iteration = 0;
  81.         
  82.         List<String> messageException = new ArrayList<>();
  83.         
  84.         String table = param.getTableName();
  85.         if(table==null){
  86.             if(param.getInformazioneAssociataAlProgressivo()!=null){
  87.                 table = Constants.TABELLA_ID_RELATIVO_AS_LONG;
  88.             }
  89.             else{
  90.                 table = Constants.TABELLA_ID_AS_LONG;
  91.             }
  92.         }
  93.         
  94.         String columnInfoAssociata = param.getColumnRelativeInfo();
  95.         if(columnInfoAssociata==null){
  96.             columnInfoAssociata = Constants.TABELLA_ID_COLONNA_INFO_ASSOCIATA;
  97.         }
  98.         
  99.         String columnPrg = param.getColumnPrg();
  100.         if(columnPrg==null){
  101.             columnPrg = Constants.TABELLA_ID_COLONNA_COUNTER;
  102.         }
  103.         
  104.         String columnProtocollo = param.getColumnProtocol();
  105.         if(columnProtocollo==null){
  106.             columnProtocollo = Constants.TABELLA_ID_COLONNA_PROTOCOLLO;
  107.         }
  108.         
  109. //      String columnCondition = "";
  110. //      String columnValueCondition = "";
  111. //      String condition = "";
  112. //      if(param.getInformazioneAssociataAlProgressivo()!=null){
  113. //          condition = " AND "+columnInfoAssociata+"=?";
  114. //          columnCondition = ","+columnInfoAssociata;
  115. //          columnValueCondition = ",?";
  116. //      }
  117.         
  118.         boolean maxValueAndWrapDisabled = false;
  119.         
  120.         List<String> valuesGenerated = new ArrayList<>();
  121.         
  122.         boolean rowNotExistsAndSerializableLevelNotFound = false;
  123.         
  124.         while(maxValueAndWrapDisabled==false && rowNotExistsAndSerializableLevelNotFound==false && idBuildOK==false && 
  125.                 DateManager.getTimeMillis() < scadenzaWhile){

  127.             valuesGenerated = new ArrayList<>();
  128.             
  129.             iteration++;

  131.             // Prima provo ad utilizzare il buffer (può darsi che un altro thread l'abbia riempito)
  132.             if(param.getSizeBuffer()>1){
  133.                 String valueFromBuffer = IDSerialGeneratorBuffer.nextValue(IDSerialGenerator_numeric.class,param.getInformazioneAssociataAlProgressivo());
  134.                 if(valueFromBuffer!=null){
  135.                     //System.out.println("GET ["+valueFromBuffer+"] FROM BUFFER");
  136.                     return valueFromBuffer;
  137.                 }
  138.             }
  139.             
  140.             //log.info("ancoraImbustamento interval["+checkInterval+"]   secondi "+(scadenzaWhile-DateManager.getTimeMillis())/1000);

  142.             counterTmp = -1;
  143.             PreparedStatement pstmt = null;
  144.             PreparedStatement pstmtInsert = null;
  145.             ResultSet rs = null;
  146.             try{
  147.                 // Lettura attuale valore
  148.                 ISQLQueryObject sqlGet = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  149.                 sqlGet.addSelectField(columnPrg);
  150.                 sqlGet.addFromTable(table);
  151.                 sqlGet.setANDLogicOperator(true);
  152.                 sqlGet.addWhereCondition(columnProtocollo+"=?");
  153.                 if(param.getInformazioneAssociataAlProgressivo()!=null){
  154.                     sqlGet.addWhereCondition(columnInfoAssociata+"=?");
  155.                 }
  156.                 sqlGet.setSelectForUpdate(true);
  157.                 
  158.                 StringBuilder query = new StringBuilder();
  159. //              query.append("SELECT "+columnPrg+" FROM ");
  160. //              query.append(table);
  161. //              query.append(" WHERE "+columnProtocollo+"=?");
  162. //              query.append(condition);
  163. //              query.append(" FOR UPDATE");
  164.                 query.append(sqlGet.createSQLQuery());
  165.                 //System.out.println("SELECT ["+query.toString()+"]");
  166.                 pstmt = conDB.prepareStatement(query.toString());
  167.                 pstmt.setString(1, protocollo);
  168.                 if(param.getInformazioneAssociataAlProgressivo()!=null){
  169.                     pstmt.setString(2, param.getInformazioneAssociataAlProgressivo());
  170.                 }
  171.                 rs = pstmt.executeQuery();
  172.                 if(rs == null) {
  173.                     pstmt.close();
  174.                     log.error("Creazione serial non riuscita: ResultSet is null?");
  175.                     throw new UtilsException("Creazione serial non riuscita: ResultSet is null?");      
  176.                 }
  177.                 boolean exist = rs.next();
  178.                 if(!exist) {
  179.                     if(JDBCUtilities.isTransactionIsolationSerializable(conDB.getTransactionIsolation(), tipoDatabase)==false) {
  180.                         rowNotExistsAndSerializableLevelNotFound = true;
  181.                         continue;
  182.                     }
  183.                 }
  184.                 
  185.                 // incremento se esiste
  186.                 if(exist){
  187.                     counterTmp = rs.getLong(columnPrg);
  188.                     for (int i = 0; i < param.getSizeBuffer(); i++) {
  189.                         if ((counterTmp + 1) > param.getMaxValue()) {
  190.                             if(param.isWrap()){
  191.                                 counterTmp = 0;
  192.                             }else{
  193.                                 if(valuesGenerated.size()<=0){
  194.                                     maxValueAndWrapDisabled = true;
  195.                                     throw new Exception("Max Value of identifier has been reached");
  196.                                 }
  197.                                 else{
  198.                                     break; // utilizzo gli identificativi che ho generato fino ad ora.
  199.                                 }
  200.                             }
  201.                         } 
  202.                         counterTmp++;
  203.                         valuesGenerated.add(counterTmp+"");
  204.                     }
  205.                 }       
  206.                 rs.close();
  207.                 pstmt.close();

  209.                 if(exist==false){
  210.                     counterTmp = 1;
  211.                     // CREO PRIMO COUNT!
  212.                     StringBuilder queryInsert = new StringBuilder();
  213.                     ISQLQueryObject sqlInsert = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  214.                     sqlInsert.addInsertTable(table);
  215.                     sqlInsert.addInsertField(columnPrg, "?");
  216.                     sqlInsert.addInsertField(columnProtocollo, "?");
  217.                     if(param.getInformazioneAssociataAlProgressivo()!=null){
  218.                         sqlInsert.addInsertField(columnInfoAssociata, "?");
  219.                     }
  220. //                  queryInsert.append("INSERT INTO "+table+" ("+columnPrg+","+columnProtocollo+columnCondition+") ");
  221. //                  queryInsert.append(" VALUES ( ? , ? "+columnValueCondition+")");
  222.                     queryInsert.append(sqlInsert.createSQLInsert());
  223.                     //System.out.println("INSERT ["+queryInsert.toString()+"]");
  224.                     pstmtInsert = conDB.prepareStatement(queryInsert
  225.                             .toString());
  226.                     pstmtInsert.setLong(1, 1);
  227.                     pstmtInsert.setString(2, protocollo);
  228.                     if(param.getInformazioneAssociataAlProgressivo()!=null){
  229.                         pstmtInsert.setString(3, param.getInformazioneAssociataAlProgressivo());
  230.                     }
  231.                     pstmtInsert.execute();
  232.                     pstmtInsert.close();
  233.                     
  234.                     valuesGenerated.add(counterTmp+"");
  235.                     
  236.                 }else{
  237.                     // Incremento!
  238.                     StringBuilder queryUpdate = new StringBuilder();
  239.                     ISQLQueryObject sqlUpdate = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  240.                     sqlUpdate.addUpdateTable(table);
  241.                     sqlUpdate.addUpdateField(columnPrg, "?");
  242.                     sqlUpdate.setANDLogicOperator(true);
  243.                     sqlUpdate.addWhereCondition(columnProtocollo+"=?");
  244.                     if(param.getInformazioneAssociataAlProgressivo()!=null){
  245.                         sqlUpdate.addWhereCondition(columnInfoAssociata+"=?");
  246.                     }
  247. //                  queryUpdate.append("UPDATE ");
  248. //                  queryUpdate.append(table);
  249. //                  queryUpdate.append(" SET "+columnPrg+" = ? WHERE "+columnProtocollo+"=?"+condition);
  250.                     queryUpdate.append(sqlUpdate.createSQLUpdate());
  251.                     //System.out.println("UPDATE ["+queryUpdate.toString()+"]");
  252.                     pstmtInsert = conDB.prepareStatement(queryUpdate
  253.                             .toString());
  254.                     pstmtInsert.setLong(1, counterTmp);
  255.                     pstmtInsert.setString(2, protocollo);
  256.                     if(param.getInformazioneAssociataAlProgressivo()!=null){
  257.                         pstmtInsert.setString(3, param.getInformazioneAssociataAlProgressivo());
  258.                     }
  259.                     pstmtInsert.execute();
  260.                     pstmtInsert.close();
  261.                 }

  263.                 // Chiusura Transazione
  264.                 conDB.commit();

  266.                 // ID Costruito
  267.                 idBuildOK = true;

  269.             } catch(Throwable e) {
  270.                 ps.append("********* Exception Iteration ["+iteration+"] **********\n");
  271.                 String msg = e.getMessage(); // per evitare out of memory
  272.                 if(msg==null){
  273.                     msg = "NULL-MESSAGE";
  274.                 }
  275.                 if(messageException.contains(msg)){
  276.                     ps.append("Message already occurs: "+msg);
  277.                 }
  278.                 else{
  279.                     e.printStackTrace(ps);
  280.                     messageException.add(msg);
  281.                 }
  282.                 ps.append("\n\n");
  283.                 
  284.                 if(infoStatistics!=null){
  285.                     infoStatistics.addErrorSerializableAccess(e);
  286.                 }
  287.                 
  288.                 //System.out.println("ERRORE: "+e.getMessage());
  289.                 //log.info("ERROR GET SERIAL SQL ["+e.getMessage()+"]");
  290.                 try{
  291.                     if( rs != null )
  292.                         rs.close();
  293.                 } catch(Exception er) {}
  294.                 try{
  295.                     if( pstmt != null )
  296.                         pstmt.close();
  297.                 } catch(Exception er) {}
  298.                 try{
  299.                     if( pstmtInsert != null )
  300.                         pstmtInsert.close();
  301.                 } catch(Exception er) {}
  302.                 try{
  303.                     conDB.rollback();
  304.                 } catch(Exception er) {}
  305.             }

  307.             if(idBuildOK == false){
  308.                 // Per aiutare ad evitare conflitti
  309.                 try{
  310.                     int intervalloDestro = checkIntervalloJDBC;
  311.                     if(param.isSerializableNextIntervalTimeMsIncrementMode()){
  312.                         intervalloDestro = intervalloDestro + (iteration*param.getSerializableNextIntervalTimeMsIncrement());
  313.                         if(intervalloDestro>param.getMaxSerializableNextIntervalTimeMs()){
  314.                             intervalloDestro = param.getMaxSerializableNextIntervalTimeMs();
  315.                         }
  316.                     }
  317.                     
  318.                     int sleep = getRandom().nextInt(intervalloDestro);
  319.                     //System.out.println("Sleep: "+sleep);
  320.                     Utilities.sleep(sleep); // random
  321.                 }catch(Exception eRandom){}
  322.             }
  323.         }

  325.         try{
  326.             if( ps != null ){
  327.                 ps.flush();
  328.             }
  329.         } catch(Exception er) {}
  330.         try{
  331.             if( out != null ){
  332.                 out.flush();
  333.             }
  334.         } catch(Exception er) {}
  335.         try{
  336.             if( ps != null ){
  337.                 ps.close();
  338.             }
  339.         } catch(Exception er) {}
  340.         try{
  341.             if( out != null ){
  342.                 out.close();
  343.             }
  344.         } catch(Exception er) {}
  345.         
  346.         if(maxValueAndWrapDisabled){
  347.             String msgError = "Max Value ["+param.getMaxValue()+"] of identifier has been reached";
  348.             log.error(msgError+": "+out.toString()); // in out è presente l'intero stackTrace
  349.             throw new UtilsException(msgError); 
  350.         }
  351.                 
  352.         if(rowNotExistsAndSerializableLevelNotFound){
  353.             String msgError = "Raw not exists and serializable level is disabled";
  354.             log.error(msgError); // in out è presente l'intero stackTrace
  355.             throw new UtilsException(msgError); 
  356.         }
  357.         
  358.         if(idBuildOK==false || counterTmp<=0){
  359.             String msgError = "Creazione serial non riuscita: l'accesso serializable non ha permesso la creazione del numero sequenziale";
  360.             log.error(msgError+": "+out.toString()); // in out è presente l'intero stackTrace
  361.             throw new UtilsException(msgError); 
  362.         }

  364.         String vRet = valuesGenerated.remove(0);
  365.         
  366.         if(valuesGenerated.size()>0){
  367.             IDSerialGeneratorBuffer.putAll(valuesGenerated,IDSerialGenerator_numeric.class,param.getInformazioneAssociataAlProgressivo());
  368.         }
  369.         
  370.         //System.out.println("GET ["+vRet+"] AND SET BUFFER AT SIZE ["+valuesGenerated.size()+"]");
  371.         
  372.         return vRet;
  373.     }
  374.     
  375. }
Created with JaCoCo 0.8.8.202204050719