IDSerialGenerator_alphanumeric.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.id.ApacheGeneratorConfiguration;
  36. import org.openspcoop2.utils.id.ApacheIdentifierGenerator;
  37. import org.openspcoop2.utils.id.apache.serial.EnumTypeGenerator;
  38. import org.openspcoop2.utils.id.apache.serial.MaxReachedException;
  39. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  40. import org.openspcoop2.utils.sql.ISQLQueryObject;
  41. import org.openspcoop2.utils.sql.SQLObjectFactory;
  42. import org.slf4j.Logger;

  44. /**
  45.  * IDSerialGenerator_alphanumeric
  46.  *
  47.  * @author Andrea Poli (apoli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public class IDSerialGenerator_alphanumeric {
  52.     
  53.     private static SecureRandom _rnd = null;
  54.     private static synchronized void initRandom() {
  55.         if(_rnd==null) {
  56.             _rnd = new SecureRandom();
  57.         }
  58.     }
  59.     private static java.util.Random getRandom() {
  60.         if(_rnd==null) {
  61.             initRandom();
  62.         }
  63.         return _rnd;
  64.     }

  66.     
  67.     public static String generate(Connection conDB,TipiDatabase tipoDatabase,
  68.             IDSerialGeneratorParameter param,Logger log,InfoStatistics infoStatistics) throws UtilsException{
  69.         
  70.         ApacheGeneratorConfiguration generatorConfig = new ApacheGeneratorConfiguration();
  71.         generatorConfig.setEnableLowerCaseLetter(true);
  72.         generatorConfig.setEnableUpperCaseLetter(true);
  73.         generatorConfig.setWrap(param.isWrap());
  74.         generatorConfig.setType(EnumTypeGenerator.ALPHANUMERIC);
  75.         
  76.         
  77.         long attesaAttivaJDBC = param.getSerializableTimeWaitMs();
  78.         int checkIntervalloJDBC = param.getSerializableNextIntervalTimeMs();
  79.         String protocollo = param.getProtocollo();
  80.         
  81.         String progressivoTmp = null;
  82.         
  83.         boolean idBuildOK = false;

  85.         long scadenzaWhile = DateManager.getTimeMillis()
  86.                 + attesaAttivaJDBC;

  88.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  89.         PrintStream ps = new PrintStream(out);
  90.         
  91.         int iteration = 0;
  92.         
  93.         List<String> messageException = new ArrayList<>();
  94.         
  95.         String table = param.getTableName();
  96.         if(table==null){
  97.             if(param.getInformazioneAssociataAlProgressivo()!=null){
  98.                 table = Constants.TABELLA_ID_RELATIVO_AS_STRING;
  99.             }
  100.             else{
  101.                 table = Constants.TABELLA_ID_AS_STRING;
  102.             }
  103.         }
  104.         
  105.         String columnInfoAssociata = param.getColumnRelativeInfo();
  106.         if(columnInfoAssociata==null){
  107.             columnInfoAssociata = Constants.TABELLA_ID_COLONNA_INFO_ASSOCIATA;
  108.         }
  109.         
  110.         String columnPrg = param.getColumnPrg();
  111.         if(columnPrg==null){
  112.             columnPrg = Constants.TABELLA_ID_COLONNA_PROGRESSIVO;
  113.         }
  114.         
  115.         String columnProtocollo = param.getColumnProtocol();
  116.         if(columnProtocollo==null){
  117.             columnProtocollo = Constants.TABELLA_ID_COLONNA_PROTOCOLLO;
  118.         }
  119.         
  120.         
  121. //      String columnCondition = "";
  122. //      String columnValueCondition = "";
  123. //      String condition = "";
  124. //      if(param.getInformazioneAssociataAlProgressivo()!=null){
  125. //          condition = " AND "+columnInfoAssociata+"=?";
  126. //          columnCondition = ","+columnInfoAssociata;
  127. //          columnValueCondition = ",?";
  128. //      }
  129.         
  130.         boolean maxValueAndWrapDisabled = false;
  131.         
  132.         List<String> valuesGenerated = new ArrayList<>();
  133.         
  134.         boolean rowNotExistsAndSerializableLevelNotFound = false;
  135.         
  136.         while(maxValueAndWrapDisabled==false && rowNotExistsAndSerializableLevelNotFound==false && idBuildOK==false && 
  137.                 DateManager.getTimeMillis() < scadenzaWhile){

  139.             valuesGenerated = new ArrayList<>();
  140.             
  141.             iteration++;
  142.             
  143.             // Prima provo ad utilizzare il buffer (può darsi che un altro thread l'abbia riempito)
  144.             if(param.getSizeBuffer()>1){
  145.                 String valueFromBuffer = IDSerialGeneratorBuffer.nextValue(IDSerialGenerator_alphanumeric.class,param.getInformazioneAssociataAlProgressivo());
  146.                 if(valueFromBuffer!=null){
  147.                     //System.out.println("GET ["+valueFromBuffer+"] FROM BUFFER");
  148.                     return valueFromBuffer;
  149.                 }
  150.             }
  151.             
  152.             //log.info("ancoraImbustamento interval["+checkInterval+"]   secondi "+(scadenzaWhile-DateManager.getTimeMillis())/1000);

  154.             progressivoTmp = null;
  155.             PreparedStatement pstmt = null;
  156.             PreparedStatement pstmtInsert = null;
  157.             ResultSet rs = null;
  158.             try{
  159.                 // Lettura attuale valore
  160.                 ISQLQueryObject sqlGet = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  161.                 sqlGet.addSelectField(columnPrg);
  162.                 sqlGet.addFromTable(table);
  163.                 sqlGet.setANDLogicOperator(true);
  164.                 sqlGet.addWhereCondition(columnProtocollo+"=?");
  165.                 if(param.getInformazioneAssociataAlProgressivo()!=null){
  166.                     sqlGet.addWhereCondition(columnInfoAssociata+"=?");
  167.                 }
  168.                 sqlGet.setSelectForUpdate(true);
  169.                 
  170.                 StringBuilder query = new StringBuilder();
  171. //              query.append("SELECT "+columnPrg+" FROM ");
  172. //              query.append(table);
  173. //              query.append(" WHERE "+columnProtocollo+"=?");
  174. //              query.append(condition);
  175. //              query.append(" FOR UPDATE");
  176.                 query.append(sqlGet.createSQLQuery());
  177.                 //System.out.println("SELECT ["+query.toString()+"]");
  178.                 pstmt = conDB.prepareStatement(query.toString());
  179.                 pstmt.setString(1, protocollo);
  180.                 if(param.getInformazioneAssociataAlProgressivo()!=null){
  181.                     pstmt.setString(2, param.getInformazioneAssociataAlProgressivo());
  182.                 }
  183.                 rs = pstmt.executeQuery();
  184.                 if(rs == null) {
  185.                     pstmt.close();
  186.                     log.error("Creazione serial non riuscita: ResultSet is null?");
  187.                     throw new UtilsException("Creazione serial non riuscita: ResultSet is null?");      
  188.                 }
  189.                 boolean exist = rs.next();
  190.                 if(!exist) {
  191.                     if(JDBCUtilities.isTransactionIsolationSerializable(conDB.getTransactionIsolation(), tipoDatabase)==false) {
  192.                         rowNotExistsAndSerializableLevelNotFound = true;
  193.                         continue;
  194.                     }
  195.                 }

  197.                 // incremento se esiste
  198.                 if(exist){
  199.                     progressivoTmp = rs.getString(columnPrg);
  200.                     for (int i = 0; i < param.getSizeBuffer(); i++) {
  201.                         try{
  202.                             ApacheIdentifierGenerator generator = new ApacheIdentifierGenerator();
  203.                             generatorConfig.setInitialStringValue(progressivoTmp);
  204.                             generator.initialize(generatorConfig);
  205.                             progressivoTmp = generator.newID().getAsString();
  206.                             valuesGenerated.add(progressivoTmp);
  207.                         }catch(Exception eMaxRaggiunto){
  208.                             if(valuesGenerated.size()<=0){
  209.                                 throw eMaxRaggiunto;
  210.                             }
  211.                             else{
  212.                                 break; // utilizzo gli identificativi che ho generato fino ad ora.
  213.                             }
  214.                         }
  215.                     }
  216.                 }       
  217.                 rs.close();
  218.                 pstmt.close();

  220.                 if(exist==false){
  221.                     // First Value
  222.                     ApacheIdentifierGenerator generator = new ApacheIdentifierGenerator();
  223.                     generatorConfig.setSize(param.getSize());
  224.                     generator.initialize(generatorConfig);
  225.                     progressivoTmp = generator.newID().getAsString();
  226.                     // CREO PRIMO COUNT!
  227.                     StringBuilder queryInsert = new StringBuilder();
  228.                     ISQLQueryObject sqlInsert = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  229.                     sqlInsert.addInsertTable(table);
  230.                     sqlInsert.addInsertField(columnPrg, "?");
  231.                     sqlInsert.addInsertField(columnProtocollo, "?");
  232.                     if(param.getInformazioneAssociataAlProgressivo()!=null){
  233.                         sqlInsert.addInsertField(columnInfoAssociata, "?");
  234.                     }
  235. //                  queryInsert.append("INSERT INTO "+table+" ("+columnPrg+","+columnProtocollo+columnCondition+") ");
  236. //                  queryInsert.append(" VALUES ( ? , ? "+columnValueCondition+")");
  237.                     queryInsert.append(sqlInsert.createSQLInsert());
  238.                     //System.out.println("INSERT ["+queryInsert.toString()+"]");
  239.                     pstmtInsert = conDB.prepareStatement(queryInsert
  240.                             .toString());
  241.                     pstmtInsert.setString(1, progressivoTmp);
  242.                     pstmtInsert.setString(2, protocollo);
  243.                     if(param.getInformazioneAssociataAlProgressivo()!=null){
  244.                         pstmtInsert.setString(3, param.getInformazioneAssociataAlProgressivo());
  245.                     }
  246.                     pstmtInsert.execute();
  247.                     pstmtInsert.close();
  248.                     
  249.                     valuesGenerated.add(progressivoTmp);
  250.                     
  251.                 }else{
  252.                     // Incremento!
  253.                     StringBuilder queryUpdate = new StringBuilder();
  254.                     ISQLQueryObject sqlUpdate = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  255.                     sqlUpdate.addUpdateTable(table);
  256.                     sqlUpdate.addUpdateField(columnPrg, "?");
  257.                     sqlUpdate.setANDLogicOperator(true);
  258.                     sqlUpdate.addWhereCondition(columnProtocollo+"=?");
  259.                     if(param.getInformazioneAssociataAlProgressivo()!=null){
  260.                         sqlUpdate.addWhereCondition(columnInfoAssociata+"=?");
  261.                     }
  262. //                  queryUpdate.append("UPDATE ");
  263. //                  queryUpdate.append(table);
  264. //                  queryUpdate.append(" SET "+columnPrg+" = ? WHERE "+columnProtocollo+"=?"+condition);
  265.                     queryUpdate.append(sqlUpdate.createSQLUpdate());
  266.                     //System.out.println("UPDATE ["+queryInsert.toString()+"]");
  267.                     pstmtInsert = conDB.prepareStatement(queryUpdate
  268.                             .toString());
  269.                     pstmtInsert.setString(1, progressivoTmp);
  270.                     pstmtInsert.setString(2, protocollo);
  271.                     if(param.getInformazioneAssociataAlProgressivo()!=null){
  272.                         pstmtInsert.setString(3, param.getInformazioneAssociataAlProgressivo());
  273.                     }
  274.                     pstmtInsert.execute();
  275.                     pstmtInsert.close();
  276.                 }

  278.                 // Chiusura Transazione
  279.                 conDB.commit();

  281.                 // ID Costruito
  282.                 idBuildOK = true;

  284.             } catch(Throwable e) {
  285.                 ps.append("********* Exception Iteration ["+iteration+"] **********\n");
  286.                 String msg = e.getMessage(); // per evitare out of memory
  287.                 if(msg==null){
  288.                     msg = "NULL-MESSAGE";
  289.                 }
  290.                 if(messageException.contains(msg)){
  291.                     ps.append("Message already occurs: "+msg);
  292.                 }
  293.                 else{
  294.                     e.printStackTrace(ps);
  295.                     messageException.add(msg);
  296.                 }
  297.                 ps.append("\n\n");
  298.                 
  299.                 if(infoStatistics!=null){
  300.                     infoStatistics.addErrorSerializableAccess(e);
  301.                 }
  302.                 
  303.                 if(e!=null && Utilities.existsInnerException(e, MaxReachedException.class)){
  304.                     maxValueAndWrapDisabled = true;
  305.                 }
  306.                 
  307.                 //System.out.println("ERRORE: "+e.getMessage());
  308.                 //log.info("ERROR GET SERIAL SQL ["+e.getMessage()+"]");
  309.                 try{
  310.                     if( rs != null )
  311.                         rs.close();
  312.                 } catch(Exception er) {}
  313.                 try{
  314.                     if( pstmt != null )
  315.                         pstmt.close();
  316.                 } catch(Exception er) {}
  317.                 try{
  318.                     if( pstmtInsert != null )
  319.                         pstmtInsert.close();
  320.                 } catch(Exception er) {}
  321.                 try{
  322.                     conDB.rollback();
  323.                 } catch(Exception er) {}
  324.             }

  326.             if(idBuildOK == false){
  327.                 // Per aiutare ad evitare conflitti
  328.                 try{
  329.                     int intervalloDestro = checkIntervalloJDBC;
  330.                     if(param.isSerializableNextIntervalTimeMsIncrementMode()){
  331.                         intervalloDestro = intervalloDestro + (iteration*param.getSerializableNextIntervalTimeMsIncrement());
  332.                         if(intervalloDestro>param.getMaxSerializableNextIntervalTimeMs()){
  333.                             intervalloDestro = param.getMaxSerializableNextIntervalTimeMs();
  334.                         }
  335.                     }
  336.                     
  337.                     int sleep = getRandom().nextInt(intervalloDestro);
  338.                     //System.out.println("Sleep: "+sleep);
  339.                     Utilities.sleep(sleep); // random
  340.                 }catch(Exception eRandom){}
  341.             }
  342.         }

  344.         try{
  345.             if( ps != null ){
  346.                 ps.flush();
  347.             }
  348.         } catch(Exception er) {}
  349.         try{
  350.             if( out != null ){
  351.                 out.flush();
  352.             }
  353.         } catch(Exception er) {}
  354.         try{
  355.             if( ps != null ){
  356.                 ps.close();
  357.             }
  358.         } catch(Exception er) {}
  359.         try{
  360.             if( out != null ){
  361.                 out.close();
  362.             }
  363.         } catch(Exception er) {}
  364.         
  365.         if(maxValueAndWrapDisabled){
  366.             String msgError = "Max Value of identifier has been reached";
  367.             log.error(msgError+": "+out.toString()); // in out è presente l'intero stackTrace
  368.             throw new UtilsException(msgError); 
  369.         }
  370.         
  371.         if(rowNotExistsAndSerializableLevelNotFound){
  372.             String msgError = "Raw not exists and serializable level is disabled";
  373.             log.error(msgError); // in out è presente l'intero stackTrace
  374.             throw new UtilsException(msgError); 
  375.         }
  376.         
  377.         if(idBuildOK==false || progressivoTmp==null){
  378.             String msgError = "Creazione serial non riuscita: l'accesso serializable non ha permesso la creazione del numero sequenziale";
  379.             log.error(msgError+": "+out.toString()); // in out è presente l'intero stackTrace
  380.             throw new UtilsException(msgError); 
  381.         }

  383.         String vRet = valuesGenerated.remove(0);
  384.         
  385.         if(valuesGenerated.size()>0){
  386.             IDSerialGeneratorBuffer.putAll(valuesGenerated,IDSerialGenerator_alphanumeric.class,param.getInformazioneAssociataAlProgressivo());
  387.         }
  388.         
  389.         //System.out.println("GET ["+vRet+"] AND SET BUFFER AT SIZE ["+valuesGenerated.size()+"]");
  390.         
  391.         return vRet;
  392.         
  393.     }
  394.     
  395. }
Created with JaCoCo 0.8.8.202204050719