SemaphoreEngine.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.semaphore;

  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.sql.Timestamp;
  29. import java.text.SimpleDateFormat;
  30. import java.util.ArrayList;
  31. import java.util.List;

  33. import org.openspcoop2.utils.TipiDatabase;
  34. import org.openspcoop2.utils.Utilities;
  35. import org.openspcoop2.utils.UtilsException;
  36. import org.openspcoop2.utils.date.DateManager;
  37. import org.openspcoop2.utils.date.DateUtils;
  38. import org.openspcoop2.utils.id.serial.InfoStatistics;
  39. import org.openspcoop2.utils.jdbc.JDBCParameterUtilities;
  40. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  41. import org.openspcoop2.utils.sql.ISQLQueryObject;
  42. import org.openspcoop2.utils.sql.SQLObjectFactory;
  43. import org.slf4j.Logger;

  45. /**
  46.  * Semaphore
  47.  *
  48.  * @author Andrea Poli (apoli@link.it)
  49.  * @author $Author$
  50.  * @version $Rev$, $Date$
  51.  */
  52. public class SemaphoreEngine {

  54.     private static SecureRandom _rnd = null;
  55.     private static synchronized void initRandom() {
  56.         if(_rnd==null) {
  57.             _rnd = new SecureRandom();
  58.         }
  59.     }
  60.     private static java.util.Random getRandom() {
  61.         if(_rnd==null) {
  62.             initRandom();
  63.         }
  64.         return _rnd;
  65.     }
  66.     
  67.     protected static SemaphoreEngine getSemaphore(SemaphoreMapping mapping, SemaphoreConfiguration config, TipiDatabase databaseType, Logger log) throws UtilsException {
  68.         return new SemaphoreEngine(mapping, config, databaseType, log);
  69.     }
  70.     
  71.     private SemaphoreMapping mapping;
  72.     private SemaphoreConfiguration config;
  73.     private TipiDatabase databaseType;
  74.     private JDBCParameterUtilities jdbcParameterUtils;
  75.     private Logger log;
  76.     
  77.     public SemaphoreEngine(SemaphoreMapping mapping, SemaphoreConfiguration config, TipiDatabase databaseType, Logger log) throws UtilsException {
  78.         this.mapping = mapping;
  79.         this.config = config;
  80.         this.databaseType = databaseType;
  81.         this.log = log;
  82.         
  83.         // Check
  84.         if(this.mapping.getTable()==null) {
  85.             throw new UtilsException("Table name not defined in SemaphoreMapping");
  86.         }
  87.         if(this.mapping.getIdNode()==null) {
  88.             throw new UtilsException("IdNode column name not defined in SemaphoreMapping");
  89.         }
  90.         if(this.mapping.getLockDate()==null) {
  91.             throw new UtilsException("Lock Date column name not defined in SemaphoreMapping");
  92.         }
  93.         if(this.mapping.getUpdateDate()==null) {
  94.             throw new UtilsException("Update Date column name not defined in SemaphoreMapping");
  95.         }
  96.         if(this.databaseType==null) {
  97.             throw new UtilsException("Database Type not defined");
  98.         }
  99.         try {
  100.             this.jdbcParameterUtils = new JDBCParameterUtilities(this.databaseType);
  101.         }catch(Exception e) {
  102.             throw new UtilsException(e.getMessage(),e);
  103.         }
  104.     }

  106.     protected boolean createEmptyLock(Connection conDB, boolean throwExceptionIfExists) throws UtilsException{
  107.         
  108.         String table = this.mapping.getTable();
  109.         
  110.         PreparedStatement pstmt = null;
  111.         ResultSet rs = null;
  112.         
  113.         boolean exist = false;
  114.         try{
  115.             // Lettura attuale valore
  116.             ISQLQueryObject sqlGet = SQLObjectFactory.createSQLQueryObject(this.databaseType);
  117.             sqlGet.addFromTable(table);
  118.             sqlGet.setANDLogicOperator(true);
  119.             if(this.mapping.sizeUniqueConditionValues()>0) {
  120.                 for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  121.                     Object o = this.mapping.getUniqueConditionValue(i);
  122.                     if(o!=null) {
  123.                         sqlGet.addWhereCondition(this.mapping.getUniqueConditionColumnName(i)+"=?");
  124.                     }
  125.                     else {
  126.                         sqlGet.addWhereIsNullCondition(this.mapping.getUniqueConditionColumnName(i));
  127.                     }
  128.                 }
  129.             }
  130.             
  131.             //System.out.println("SELECT ["+sqlGet.createSQLQuery()+"]");
  132.             pstmt = conDB.prepareStatement(sqlGet.createSQLQuery());
  133.             int index = 1;
  134.             if(this.mapping.sizeUniqueConditionValues()>0) {
  135.                 for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  136.                     Object o = this.mapping.getUniqueConditionValue(i);
  137.                     if(o!=null) {
  138.                         this.jdbcParameterUtils.setParameter(pstmt, index++, 
  139.                                 this.mapping.getUniqueConditionValue(i), 
  140.                                 this.mapping.getUniqueConditionType(i));
  141.                     }
  142.                 }
  143.             }
  144.             rs = pstmt.executeQuery();
  145.             if(rs == null) {
  146.                 pstmt.close();
  147.                 this.log.error("Creazione empty lock non riuscita: ResultSet is null?");
  148.                 throw new UtilsException("Creazione empty lock non riuscita: ResultSet is null?");      
  149.             }
  150.             exist = rs.next();
  151.         } catch(Throwable e) {
  152.             this.log.error("Creazione empty lock non riuscita: "+e.getMessage(),e);
  153.             throw new UtilsException("Creazione empty lock non riuscita: "+e.getMessage(),e);       
  154.         } finally {
  155.             try{
  156.                 if( rs != null )
  157.                     rs.close();
  158.             } catch(Exception er) {}
  159.             try{
  160.                 if( pstmt != null )
  161.                     pstmt.close();
  162.             } catch(Exception er) {
  163.                 // close
  164.             }
  165.         }
  166.             
  167.         if(exist) {
  168.             if(throwExceptionIfExists) {
  169.                 throw new UtilsException("Entry already exists");
  170.             }
  171.             return false;
  172.         }
  173.         else {
  174.             try{
  175.                 // INSERT
  176.                 ISQLQueryObject sqlGet = SQLObjectFactory.createSQLQueryObject(this.databaseType);
  177.                 sqlGet.addInsertTable(table);
  178.                 if(this.mapping.sizeUniqueConditionValues()>0) {
  179.                     for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  180.                         sqlGet.addInsertField(this.mapping.getUniqueConditionColumnName(i),"?");
  181.                     }
  182.                 }
  183.                 
  184.                 //System.out.println("INSERT ["+sqlGet.createSQLInsert()+"]");
  185.                 pstmt = conDB.prepareStatement(sqlGet.createSQLInsert());
  186.                 int index = 1;
  187.                 if(this.mapping.sizeUniqueConditionValues()>0) {
  188.                     for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  189.                         Object o = this.mapping.getUniqueConditionValue(i);
  190.                         if(o!=null) {
  191.                             this.jdbcParameterUtils.setParameter(pstmt, index++, 
  192.                                     this.mapping.getUniqueConditionValue(i), 
  193.                                     this.mapping.getUniqueConditionType(i));
  194.                         }
  195.                     }
  196.                 }
  197.                 int n = pstmt.executeUpdate();
  198.                 return n>0;
  199.             } catch(Throwable e) {
  200.                 this.log.error("Creazione empty lock non riuscita: "+e.getMessage(),e);
  201.                 throw new UtilsException("Creazione empty lock non riuscita: "+e.getMessage(),e);       
  202.             } finally {
  203.                 try{
  204.                     if( pstmt != null )
  205.                         pstmt.close();
  206.                 } catch(Exception er) {
  207.                     // close
  208.                 }
  209.             }
  210.         }
  211.         
  212.     }
  213.     
  214.     protected boolean lock(Connection conDB, String details, InfoStatistics infoStatistics,SemaphoreOperationType operationType) throws UtilsException{
  215.                 
  216.         boolean operazioneConclusaConSuccesso = false; 
  217.         // nel caso di newLock, termina con successo se si ottiene il lock.
  218.         // nel caso di updateLock, termina con successo se cmq il lock è sempre in possesso del nodo cluster
  219.         // nel caso di releaseLock termina sempre con successo.
  220.         
  221.         long attesaAttivaJDBC = this.config.getSerializableTimeWaitMs();
  222.         int checkIntervalloJDBC = this.config.getSerializableNextIntervalTimeMs();
  223.         
  224.         boolean processOK = false;

  226.         long scadenzaWhile = DateManager.getTimeMillis()
  227.                 + attesaAttivaJDBC;

  229.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  230.         PrintStream ps = new PrintStream(out);
  231.         
  232.         int iteration = 0;
  233.         
  234.         List<String> messageException = new ArrayList<>();
  235.         
  236.         String table = this.mapping.getTable();
  237.         String columnIdNode = this.mapping.getIdNode();
  238.         String columnLockDate = this.mapping.getLockDate();
  239.         String columnUpdateDate = this.mapping.getUpdateDate();
  240.         String columnDetails = this.mapping.getDetails();

  242.         boolean rowNotExistsAndSerializableLevelNotFound = false;
  243.         
  244.         while(processOK==false && rowNotExistsAndSerializableLevelNotFound==false && 
  245.                 DateManager.getTimeMillis() < scadenzaWhile){

  247.             iteration++;

  249.             //log.info("process interval["+checkInterval+"]   secondi "+(scadenzaWhile-DateManager.getTimeMillis())/1000);

  251.             operazioneConclusaConSuccesso = false;
  252.             PreparedStatement pstmt = null;
  253.             PreparedStatement pstmtInsert = null;
  254.             ResultSet rs = null;
  255.             try{
  256.                 // Lettura attuale valore
  257.                 ISQLQueryObject sqlGet = SQLObjectFactory.createSQLQueryObject(this.databaseType);
  258.                 sqlGet.addSelectField(columnIdNode);
  259.                 sqlGet.addSelectField(columnLockDate);
  260.                 sqlGet.addSelectField(columnUpdateDate);
  261.                 sqlGet.addFromTable(table);
  262.                 sqlGet.setANDLogicOperator(true);
  263.                 if(this.mapping.sizeUniqueConditionValues()>0) {
  264.                     for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  265.                         Object o = this.mapping.getUniqueConditionValue(i);
  266.                         if(o!=null) {
  267.                             sqlGet.addWhereCondition(this.mapping.getUniqueConditionColumnName(i)+"=?");
  268.                         }
  269.                         else {
  270.                             sqlGet.addWhereIsNullCondition(this.mapping.getUniqueConditionColumnName(i));
  271.                         }
  272.                     }
  273.                 }
  274.                 sqlGet.setSelectForUpdate(true);
  275.                 
  276.                 //System.out.println("SELECT ["+sqlGet.createSQLQuery()+"]");
  277.                 pstmt = conDB.prepareStatement(sqlGet.createSQLQuery());
  278.                 int index = 1;
  279.                 if(this.mapping.sizeUniqueConditionValues()>0) {
  280.                     for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  281.                         Object o = this.mapping.getUniqueConditionValue(i);
  282.                         if(o!=null) {
  283.                             this.jdbcParameterUtils.setParameter(pstmt, index++, 
  284.                                     this.mapping.getUniqueConditionValue(i), 
  285.                                     this.mapping.getUniqueConditionType(i));
  286.                         }
  287.                     }
  288.                 }
  289.                 rs = pstmt.executeQuery();
  290.                 if(rs == null) {
  291.                     pstmt.close();
  292.                     this.log.error("Creazione serial non riuscita: ResultSet is null?");
  293.                     throw new UtilsException("Creazione serial non riuscita: ResultSet is null?");      
  294.                 }
  295.                 boolean exist = rs.next();
  296.                 String idNode = null;
  297.                 Timestamp lockDate = null;
  298.                 Timestamp updateDate = null;
  299.                 if(exist){
  300.                     idNode = rs.getString(columnIdNode);
  301.                     lockDate = rs.getTimestamp(columnLockDate);
  302.                     updateDate = rs.getTimestamp(columnUpdateDate);
  303.                 }       
  304.                 rs.close();
  305.                 pstmt.close();

  307.                 if(!exist) {
  308.                     if(JDBCUtilities.isTransactionIsolationSerializable(conDB.getTransactionIsolation(), this.databaseType)==false) {
  309.                         rowNotExistsAndSerializableLevelNotFound = true;
  310.                         continue;
  311.                     }
  312.                 }
  313.                 
  314.                 Timestamp now = DateManager.getTimestamp();
  315.                 
  316.                 SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  317.                 StringBuilder statoLock = new StringBuilder("Lock per tabella ["+table+"]");
  318.                 if(this.mapping.sizeUniqueConditionValues()>0) {
  319.                     for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  320.                         statoLock.append(" ["+this.mapping.getUniqueConditionColumnName(i)+"="+this.mapping.getUniqueConditionValue(i)+"]");
  321.                     }
  322.                 }
  323.                 statoLock.append("\n");
  324.                 if(exist && idNode!=null){
  325.                     statoLock.append("OldIdNode["+idNode+"] OldcreateTime["+dateformat.format(lockDate)+"] OldupdateTime["+dateformat.format(updateDate)+"]");
  326.                     statoLock.append("\n");
  327.                 }
  328.                 statoLock.append("IdNode["+this.config.getIdNode()+"] ");
  329.                 statoLock.append("Now["+dateformat.format(now)+"]");
  330.                 if(details!=null) {
  331.                     statoLock.append(" Details["+details+"]");
  332.                 }
  333.                 
  334.                 SemaphoreEvent semaphoreEvent = new SemaphoreEvent();
  335.                 semaphoreEvent.setDate(now);
  336.                 semaphoreEvent.setOperationType(operationType);
  337.                 semaphoreEvent.setIdNode(this.config.getIdNode());
  338.                 boolean emitSemaphoreEvent = false;
  339.                 
  340.                 if(SemaphoreOperationType.NEW.equals(operationType)) {
  341.                 
  342.                     if(!exist){
  343.     
  344.                         // CREO ENTRY
  345.                         ISQLQueryObject sqlInsert = SQLObjectFactory.createSQLQueryObject(this.databaseType);
  346.                         sqlInsert.addInsertTable(table);
  347.                         sqlInsert.addInsertField(columnIdNode, "?");
  348.                         sqlInsert.addInsertField(columnLockDate, "?");
  349.                         sqlInsert.addInsertField(columnUpdateDate, "?");
  350.                         sqlInsert.addInsertField(columnDetails, "?");
  351.                         if(this.mapping.sizeUniqueConditionValues()>0) {
  352.                             for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  353.                                 sqlInsert.addInsertField(this.mapping.getUniqueConditionColumnName(i),"?");
  354.                             }
  355.                         }
  356.                         //System.out.println("INSERT ["+sqlInsert.createSQLInsert()+"]");
  357.                         pstmtInsert = conDB.prepareStatement(sqlInsert.createSQLInsert());
  358.                         index = 1;
  359.                         pstmtInsert.setString(index++, this.config.getIdNode());
  360.                         pstmtInsert.setTimestamp(index++, now);
  361.                         pstmtInsert.setTimestamp(index++, now);
  362.                         this.jdbcParameterUtils.setParameter(pstmtInsert, index++, details, String.class);
  363.                         if(this.mapping.sizeUniqueConditionValues()>0) {
  364.                             for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  365.                                 this.jdbcParameterUtils.setParameter(pstmtInsert, index++, 
  366.                                         this.mapping.getUniqueConditionValue(i), 
  367.                                         this.mapping.getUniqueConditionType(i));
  368.                             }
  369.                         }
  370.                         pstmtInsert.execute();
  371.                         pstmtInsert.close();
  372.                         
  373.                         operazioneConclusaConSuccesso = true;
  374.                         
  375.                         if(this.config.isEmitEvent()) {
  376.                             
  377.                             semaphoreEvent.setDetails(statoLock.toString());
  378.                             semaphoreEvent.setSeverity(SemaphoreEventSeverity.INFO);
  379.                             semaphoreEvent.setLock(operazioneConclusaConSuccesso);
  380.                             emitSemaphoreEvent = true;
  381.                         }
  382.                                                                     
  383.                     }else{
  384.                             
  385.                         String errore = null;
  386.                         
  387.                         if(idNode==null) {
  388.                             
  389.                             // non esiste un altro thread che possiede il lock, lo prendo
  390.                             operazioneConclusaConSuccesso = true;
  391.                             
  392.                         }
  393.                         else {
  394.                                                         
  395.                             // Controllo idleTime
  396.                             if(this.config.getMaxIdleTime()>0) {
  397.                                 
  398.                                 long diff = now.getTime() - updateDate.getTime();
  399.                                 if(diff>this.config.getMaxIdleTime()) {
  400.                                     errore = "Idle Time ("+this.config.getMaxIdleTime()+"ms) exceeded (actual: "+diff+"ms). Lock obtained for idNode '"+this.config.getIdNode()+"'";
  401.                                     operazioneConclusaConSuccesso = true;
  402.                                 }
  403.                                 
  404.                             }
  405.                             if(errore==null) {
  406.                                 // Controllo MaxLife
  407.                                 if(this.config.getMaxLife()>0) {
  408.                                     
  409.                                     long diff = now.getTime() - lockDate.getTime();
  410.                                     if(diff>this.config.getMaxLife()) {
  411.                                         errore = "Max Life Time ("+this.config.getMaxLife()+"ms) exceeded (actual: "+diff+"ms). Lock obtained for idNode '"+this.config.getIdNode()+"'";
  412.                                         operazioneConclusaConSuccesso = true;
  413.                                     }
  414.                                     
  415.                                 }
  416.                             }
  417.                             
  418.                             if(errore!=null) {
  419.                                 String dettaglioErrore = statoLock.toString()+"\n"+errore;
  420.                                 this.log.warn(dettaglioErrore);
  421.                             }
  422.                             
  423.                         }
  424.                         
  425.                         if(operazioneConclusaConSuccesso) {
  426.                             
  427.                             ISQLQueryObject sqlUpdate = SQLObjectFactory.createSQLQueryObject(this.databaseType);
  428.                             sqlUpdate.addUpdateTable(table);
  429.                             sqlUpdate.addUpdateField(columnIdNode, "?");
  430.                             sqlUpdate.addUpdateField(columnLockDate, "?");
  431.                             sqlUpdate.addUpdateField(columnUpdateDate, "?");
  432.                             sqlUpdate.addUpdateField(columnDetails, "?");
  433.                             sqlUpdate.setANDLogicOperator(true);
  434.                             if(this.mapping.sizeUniqueConditionValues()>0) {
  435.                                 for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  436.                                     Object o = this.mapping.getUniqueConditionValue(i);
  437.                                     if(o!=null) {
  438.                                         sqlUpdate.addWhereCondition(this.mapping.getUniqueConditionColumnName(i)+"=?");
  439.                                     }
  440.                                     else {
  441.                                         sqlUpdate.addWhereIsNullCondition(this.mapping.getUniqueConditionColumnName(i));
  442.                                     }
  443.                                 }
  444.                             }
  445.                             //System.out.println("UPDATE ["+sqlUpdate.createSQLUpdate()+"]");
  446.                             pstmtInsert = conDB.prepareStatement(sqlUpdate.createSQLUpdate());
  447.                             index = 1;
  448.                             pstmtInsert.setString(index++, this.config.getIdNode());
  449.                             pstmtInsert.setTimestamp(index++, now);
  450.                             pstmtInsert.setTimestamp(index++, now);
  451.                             this.jdbcParameterUtils.setParameter(pstmtInsert, index++, details, String.class);
  452.                             if(this.mapping.sizeUniqueConditionValues()>0) {
  453.                                 for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  454.                                     Object o = this.mapping.getUniqueConditionValue(i);
  455.                                     if(o!=null) {
  456.                                         this.jdbcParameterUtils.setParameter(pstmtInsert, index++, 
  457.                                                 this.mapping.getUniqueConditionValue(i), 
  458.                                                 this.mapping.getUniqueConditionType(i));
  459.                                     }
  460.                                 }
  461.                             }
  462.                             pstmtInsert.executeUpdate();
  463.                             pstmtInsert.close();
  464.                             
  465.                             if(this.config.isEmitEvent()) {
  466.                                 if(errore!=null) {
  467.                                     semaphoreEvent.setDetails(errore+"\n"+statoLock.toString()); // non e' un errore vero, ma la spiegazione del perche' ho levato il lock ad un altro
  468.                                 }
  469.                                 else {
  470.                                     semaphoreEvent.setDetails(statoLock.toString());
  471.                                 }
  472.                                 semaphoreEvent.setSeverity(SemaphoreEventSeverity.INFO);
  473.                                 semaphoreEvent.setLock(operazioneConclusaConSuccesso);
  474.                                 emitSemaphoreEvent = true;
  475.                             }
  476.                         }
  477.                     }

  479.                 }
  480.                 else if(SemaphoreOperationType.UPDATE.equals(operationType)
  481.                         ||
  482.                         SemaphoreOperationType.RELEASE.equals(operationType)) {
  483.                     
  484.                     if(idNode!=null && idNode.equals(this.config.getIdNode())) {
  485.                         
  486.                         // update valore della colonna di update 
  487.                         ISQLQueryObject sqlUpdate = SQLObjectFactory.createSQLQueryObject(this.databaseType);
  488.                         sqlUpdate.addUpdateTable(table);
  489.                         if(SemaphoreOperationType.UPDATE.equals(operationType)){
  490.                             sqlUpdate.addUpdateField(columnUpdateDate, "?");
  491.                             sqlUpdate.addUpdateField(columnDetails, "?");
  492.                         }
  493.                         else {
  494.                             sqlUpdate.addUpdateField(columnIdNode, "?");
  495.                             sqlUpdate.addUpdateField(columnLockDate, "?");
  496.                             sqlUpdate.addUpdateField(columnUpdateDate, "?");
  497.                             sqlUpdate.addUpdateField(columnDetails, "?");
  498.                         }
  499.                         sqlUpdate.setANDLogicOperator(true);
  500.                         if(this.mapping.sizeUniqueConditionValues()>0) {
  501.                             for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  502.                                 Object o = this.mapping.getUniqueConditionValue(i);
  503.                                 if(o!=null) {
  504.                                     sqlUpdate.addWhereCondition(this.mapping.getUniqueConditionColumnName(i)+"=?");
  505.                                 }
  506.                                 else {
  507.                                     sqlUpdate.addWhereIsNullCondition(this.mapping.getUniqueConditionColumnName(i));
  508.                                 }
  509.                             }
  510.                         }
  511.                         //System.out.println("UPDATE ["+sqlUpdate.createSQLUpdate()+"]");
  512.                         pstmtInsert = conDB.prepareStatement(sqlUpdate.createSQLUpdate());
  513.                         index = 1;
  514.                         if(SemaphoreOperationType.UPDATE.equals(operationType)){
  515.                             pstmtInsert.setTimestamp(index++, now);
  516.                             this.jdbcParameterUtils.setParameter(pstmtInsert, index++, details, String.class);
  517.                         }
  518.                         else {
  519.                             this.jdbcParameterUtils.setParameter(pstmtInsert, index++, null, String.class);
  520.                             this.jdbcParameterUtils.setParameter(pstmtInsert, index++, null, Timestamp.class);
  521.                             this.jdbcParameterUtils.setParameter(pstmtInsert, index++, null, Timestamp.class);
  522.                             this.jdbcParameterUtils.setParameter(pstmtInsert, index++, null, String.class);
  523.                         }
  524.                         if(this.mapping.sizeUniqueConditionValues()>0) {
  525.                             for (int i = 0; i < this.mapping.sizeUniqueConditionValues(); i++) {
  526.                                 Object o = this.mapping.getUniqueConditionValue(i);
  527.                                 if(o!=null) {
  528.                                     this.jdbcParameterUtils.setParameter(pstmtInsert, index++, 
  529.                                             this.mapping.getUniqueConditionValue(i), 
  530.                                             this.mapping.getUniqueConditionType(i));
  531.                                 }
  532.                             }
  533.                         }
  534.                         pstmtInsert.executeUpdate();
  535.                         pstmtInsert.close();
  536.                         
  537.                         operazioneConclusaConSuccesso = true;
  538.                         
  539.                         if(this.config.isEmitEvent()) {
  540.                             semaphoreEvent.setDetails(statoLock.toString());
  541.                             semaphoreEvent.setSeverity(SemaphoreEventSeverity.DEBUG);
  542.                             semaphoreEvent.setLock(operazioneConclusaConSuccesso);
  543.                             emitSemaphoreEvent = true;
  544.                         }

  546.                     }
  547.                     else {
  548.                         
  549.                         // if idCluster e' null o diverso dal mio 
  550.                         // Puo' darsi che qualche altro batch si e' preso il lock perchè era scaduto il tempo, e poi addirittura l'ha anche rilascato
  551.                         String msgErrore = "IdNode is null, lock without owner";
  552.                         if(idNode!=null) {
  553.                             msgErrore = "IdNode owner ["+idNode+"] different";
  554.                         }
  555.                         
  556.                         operazioneConclusaConSuccesso = false;
  557.                         
  558.                         if(this.config.isEmitEvent()) {
  559.                             semaphoreEvent.setDetails(statoLock.toString()+"\n"+msgErrore);
  560.                             //semaphoreEvent.setSeverity(SemaphoreEventSeverity.ERROR);
  561.                             semaphoreEvent.setSeverity(SemaphoreEventSeverity.WARN);
  562.                             semaphoreEvent.setLock(operazioneConclusaConSuccesso);
  563.                             emitSemaphoreEvent = true;
  564.                         }
  565.                                                 
  566.                     }
  567.                 
  568.                 }
  569.                 

  571.                 // Chiusura Transazione
  572.                 conDB.commit();

  574.                 // Emetto evento dopo il commit
  575.                 if(emitSemaphoreEvent) {
  576.                     this.config.getEventGenerator().emitEvent(conDB, semaphoreEvent);
  577.                 }
  578.                 
  579.                 // Analisi Lock effettuata
  580.                 processOK = true;

  582.             } catch(Throwable e) {
  583.                 ps.append("********* Exception Iteration ["+iteration+"] **********\n");
  584.                 String msg = e.getMessage(); // per evitare out of memory
  585.                 if(msg==null){
  586.                     msg = "NULL-MESSAGE";
  587.                 }
  588.                 if(messageException.contains(msg)){
  589.                     ps.append("Message already occurs: "+msg);
  590.                 }
  591.                 else{
  592.                     e.printStackTrace(ps);
  593.                     messageException.add(msg);
  594.                 }
  595.                 ps.append("\n\n");
  596.                 
  597.                 if(infoStatistics!=null){
  598.                     infoStatistics.addErrorSerializableAccess(e);
  599.                 }
  600.                 
  601.                 //System.out.println("ERRORE ["+operationType+"] Iteration ["+iteration+"]: "+e.getMessage());
  602.                 //this.log.info("ERROR ["+operationType+"] Iteration ["+iteration+"] GET SERIAL SQL ["+e.getMessage()+"]");
  603.                 try{
  604.                     if( rs != null )
  605.                         rs.close();
  606.                 } catch(Exception er) {}
  607.                 try{
  608.                     if( pstmt != null )
  609.                         pstmt.close();
  610.                 } catch(Exception er) {}
  611.                 try{
  612.                     if( pstmtInsert != null )
  613.                         pstmtInsert.close();
  614.                 } catch(Exception er) {}
  615.                 try{
  616.                     conDB.rollback();
  617.                 } catch(Exception er) {}
  618.             }

  620.             if(processOK == false){
  621.                 // Per aiutare ad evitare conflitti
  622.                 try{
  623.                     int intervalloDestro = checkIntervalloJDBC;
  624.                     if(this.config.isSerializableNextIntervalTimeMsIncrementMode()){
  625.                         intervalloDestro = intervalloDestro + (iteration*this.config.getSerializableNextIntervalTimeMsIncrement());
  626.                         if(intervalloDestro>this.config.getMaxSerializableNextIntervalTimeMs()){
  627.                             intervalloDestro = this.config.getMaxSerializableNextIntervalTimeMs();
  628.                         }
  629.                     }
  630.                     
  631.                     int sleep = getRandom().nextInt(intervalloDestro);
  632.                     //System.out.println("Sleep: "+sleep);
  633.                     Utilities.sleep(sleep); // random
  634.                 }catch(Exception eRandom){}
  635.             }
  636.         }

  638.         try{
  639.             if( ps != null ){
  640.                 ps.flush();
  641.             }
  642.         } catch(Exception er) {}
  643.         try{
  644.             if( out != null ){
  645.                 out.flush();
  646.             }
  647.         } catch(Exception er) {}
  648.         try{
  649.             if( ps != null ){
  650.                 ps.close();
  651.             }
  652.         } catch(Exception er) {}
  653.         try{
  654.             if( out != null ){
  655.                 out.close();
  656.             }
  657.         } catch(Exception er) {}
  658.         
  659.         if(rowNotExistsAndSerializableLevelNotFound){
  660.             String msgError = "Raw not exists and serializable level is disabled";
  661.             this.log.error(msgError); // in out è presente l'intero stackTrace
  662.             throw new UtilsException(msgError); 
  663.         }
  664.         
  665.         if(processOK==false){
  666.             String msgError = "Lock process failed: l'accesso serializable non ha permesso il recupero del lock";
  667.             this.log.error(msgError+": "+out.toString()); // in out è presente l'intero stackTrace
  668.             
  669.             if(this.config.isEmitEvent()) {
  670.                 SemaphoreEvent event = new SemaphoreEvent();
  671.                 event.setDate(DateManager.getDate());
  672.                 event.setOperationType(operationType);
  673.                 event.setDetails(msgError);
  674.                 event.setSeverity(SemaphoreEventSeverity.ERROR);
  675.                 event.setLock(false);
  676.                 this.config.getEventGenerator().emitEvent(conDB, event);
  677.             }
  678.             
  679.             throw new UtilsException(msgError); 
  680.         }

  682.         //System.out.println("TERMINO ["+operationType+"] (attesaWhile:"+attesaAttivaJDBC+"): "+operazioneConclusaConSuccesso);
  683.         
  684.         return operazioneConclusaConSuccesso;
  685.                 
  686.     }
  687.     
  688. }
Created with JaCoCo 0.8.8.202204050719