OpenSPCoopState.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.core.state;

  23. import java.sql.Connection;
  24. import java.util.List;

  26. import org.openspcoop2.core.id.IDSoggetto;
  27. import org.openspcoop2.pdd.config.DBConsegneMessageBoxManager;
  28. import org.openspcoop2.pdd.config.DBConsegnePreseInCaricoManager;
  29. import org.openspcoop2.pdd.config.DBManager;
  30. import org.openspcoop2.pdd.config.Resource;
  31. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  32. import org.openspcoop2.pdd.mdb.GenericMessage;
  33. import org.openspcoop2.protocol.sdk.state.IState;
  34. import org.openspcoop2.protocol.sdk.state.StateMessage;
  35. import org.openspcoop2.protocol.sdk.state.StatelessMessage;
  36. import org.openspcoop2.utils.UtilsException;
  37. import org.slf4j.Logger;

  39. /**
  40.  * Oggetto che rappresenta lo stato di una richiesta/risposta all'interno della PdD
  41.  *
  42.  * @author Poli Andrea (apoli@link.it)
  43.  * @author Fabio Tronci (tronci@link.it)
  44.  * @author $Author$
  45.  * @version $Rev$, $Date$
  46.  */
  47. public abstract class OpenSPCoopState implements IOpenSPCoopState {
  48.     
  49.     /* ---------- Logger ---------*/
  50.     protected Logger logger = null;
  51.     
  52.     /* ---------- Connessione al database ---------------- */
  53.     protected OpenSPCoopStateDBManager dbManager = null;
  54.     /** DBManager */
  55.     protected DBManager dbManager_runtime= null;
  56.     /** DBManager */
  57.     protected DBConsegnePreseInCaricoManager dbManager_consegnePreseInCarico = null;
  58.     /** DBManager */
  59.     protected DBConsegneMessageBoxManager dbManager_consegneMessageBox = null;
  60.     /** Resource */
  61.     protected Resource resourceDB = null;
  62.     /** Connessione al database */
  63.     protected Connection connectionDB = null;
  64.     /** Connessione inizializzata */
  65.     protected boolean connessioneInizializzata = false;
  66.     
  67.     /* ----------- Altre informazioni ------------*/
  68.     /** Identita PdD */
  69.     protected IDSoggetto identitaPdD = null;
  70.     /** Identita Modulo */
  71.     protected String idModulo = null;
  72.     /** GenericMessage LIB */
  73.     protected GenericMessage messageLib;
  74.     /** Identificativo della sessione */
  75.     protected String IDMessaggioSessione;
  76.     
  77.     /* ---------- Stato ------------ */
  78.     protected StateMessage richiestaStato = null;
  79.     protected StateMessage rispostaStato = null;
  80.     
  81.     /* ---------- Indicazione se lavorare come stateful (utilizzare la connessione) o come stateless (operazioni NOP) -------------- */
  82.     protected boolean useConnection;
  83.     
  84.     
  85.     
  86.     
  87.     
  88.     
  89.     /* ----------- Convertitori ------------*/
  90.     public static OpenSPCoopStateless toStateless(OpenSPCoopStateful stateful,boolean useConnection){
  91.         OpenSPCoopStateless stateless = new OpenSPCoopStateless();
  92.         stateless.connectionDB = stateful.connectionDB;
  93.         stateless.dbManager = stateful.dbManager;
  94.         stateless.dbManager_runtime = stateful.dbManager_runtime;
  95.         stateless.dbManager_consegnePreseInCarico = stateful.dbManager_consegnePreseInCarico;
  96.         stateless.dbManager_consegneMessageBox = stateful.dbManager_consegneMessageBox;
  97.         stateless.IDMessaggioSessione = stateful.IDMessaggioSessione;
  98.         stateless.identitaPdD = stateful.identitaPdD;
  99.         stateless.idModulo = stateful.idModulo;
  100.         stateless.logger = stateful.logger;
  101.         stateless.messageLib = stateful.messageLib;
  102.         stateless.resourceDB = stateful.resourceDB;
  103.         stateless.richiestaStato = stateful.richiestaStato;
  104.         stateless.rispostaStato = stateful.rispostaStato;
  105.         stateless.useConnection = useConnection;
  106.         stateless.connessioneInizializzata = stateful.connessioneInizializzata;
  107.         
  108.         StatelessMessage tempRichiesta = new StatelessMessage(stateful.getConnectionDB(),stateful.logger);
  109.         if(stateful.getStatoRichiesta()!=null) {
  110.             tempRichiesta.setPreparedStatement(((StateMessage) stateful.getStatoRichiesta()).getPreparedStatement());
  111.         }
  112.         stateless.setStatoRichiesta(new StatelessMessage(tempRichiesta));
  113.         
  114.         StatelessMessage tempRisposta = new StatelessMessage(stateful.getConnectionDB(),stateful.logger);
  115.         if(stateful.getStatoRisposta()!=null) {
  116.             tempRisposta.setPreparedStatement(((StateMessage) stateful.getStatoRisposta()).getPreparedStatement());
  117.         }
  118.         stateless.setStatoRisposta(new StatelessMessage(tempRisposta));
  119.         
  120.         return stateless;
  121.     }
  122.     
  123.     
  124.     


  127.     

  129.     /* ----------- Init resource ------------*/

  131.     public abstract void updateStatoRichiesta() throws UtilsException ;
  132.     public abstract void updateStatoRisposta() throws UtilsException ;
  133.         
  134.     @Override
  135.     public void initResource(IDSoggetto identitaPdD,String idModulo,String idTransazione)throws OpenSPCoopStateException{
  136.         initResource(identitaPdD,idModulo,idTransazione, OpenSPCoopStateDBManager.runtime);
  137.     }
  138.     @Override
  139.     public void initResource(IDSoggetto identitaPdD,String idModulo,String idTransazione, OpenSPCoopStateDBManager dbManager)throws OpenSPCoopStateException{
  140.         
  141.         this.dbManager = dbManager; // per update
  142.         
  143.         // Check parametri
  144.         if(identitaPdD==null){
  145.             throw new OpenSPCoopStateException("IdentitaPdD non presente");
  146.         }
  147.         this.identitaPdD = identitaPdD;
  148.         if(idModulo==null){
  149.             throw new OpenSPCoopStateException("IDModulo non presente");
  150.         }
  151.         this.idModulo = idModulo;
  152.         
  153.         // Logger
  154.         this.logger = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  155.         
  156.         if(this.useConnection){
  157.             
  158.             // Get Connessione
  159.             if(dbManager!=null) {
  160.                 switch (dbManager) {
  161.                 case runtime:
  162.                     this.dbManager_runtime = DBManager.getInstance();
  163.                     break;
  164.                 case smistatoreMessaggiPresiInCarico:
  165.                     this.dbManager_consegnePreseInCarico = DBConsegnePreseInCaricoManager.getInstanceSmistatore();
  166.                     break;
  167.                 case consegnePreseInCarico:
  168.                     this.dbManager_consegnePreseInCarico = DBConsegnePreseInCaricoManager.getInstanceRuntime();
  169.                     break;
  170.                 case messageBox:
  171.                     this.dbManager_consegneMessageBox = DBConsegneMessageBoxManager.getInstanceRuntime();
  172.                     break;
  173.                 }
  174.             }
  175.             else {
  176.                 this.dbManager_runtime = DBManager.getInstance();
  177.             }
  178.             try{
  179.                 if(this.dbManager_runtime!=null) {
  180.                     this.resourceDB = this.dbManager_runtime.getResource(identitaPdD,this.idModulo,idTransazione);
  181.                 }
  182.                 else if(this.dbManager_consegnePreseInCarico!=null) {
  183.                     this.resourceDB = this.dbManager_consegnePreseInCarico.getResource(identitaPdD,this.idModulo,idTransazione);
  184.                 }
  185.                 else {
  186.                     this.resourceDB = this.dbManager_consegneMessageBox.getResource(identitaPdD,this.idModulo,idTransazione);
  187.                 }
  188.             }catch(Exception e){
  189.                 throw new OpenSPCoopStateException("Riscontrato errore durante la richiesta di una connessione al DB",e);
  190.             }
  191.             if(this.resourceDB==null){
  192.                 throw new OpenSPCoopStateException("Riscontrato errore durante la richiesta di una connessione al DB (Risorsa is null).");
  193.             }
  194.             if(this.resourceDB.getResource() == null){
  195.                     throw new OpenSPCoopStateException("Riscontrato errore durante la richiesta di una connessione al DB (Connessione is null)."); 
  196.             }
  197.             this.connectionDB = (Connection) this.resourceDB.getResource();
  198.             
  199.             // Stato
  200.             try{
  201.                 this.updateStatoRichiesta();
  202.                 this.updateStatoRisposta();
  203.             }catch(Exception e){
  204.                 this.logger.error("Update stato richiesta/risposta non riuscito",e);
  205.                 if(this.dbManager_runtime!=null) {
  206.                     this.dbManager_runtime.releaseResource(this.identitaPdD,this.idModulo,this.resourceDB);
  207.                 }
  208.                 else if(this.dbManager_consegnePreseInCarico!=null) {
  209.                     this.dbManager_consegnePreseInCarico.releaseResource(this.identitaPdD,this.idModulo,this.resourceDB);
  210.                 }
  211.                 else {
  212.                     this.dbManager_consegneMessageBox.releaseResource(this.identitaPdD,this.idModulo,this.resourceDB);
  213.                 }
  214.                 throw new OpenSPCoopStateException("Update stato richiesta/risposta non riuscito",e);
  215.             }
  216.             
  217.             this.connessioneInizializzata = true;
  218.         }
  219.     } 
  220.     
  221.     @Override
  222.     public void updateResource(String idTransazione) throws OpenSPCoopStateException{
  223.         if( this.useConnection ){
  224.             try{
  225.                 if(this.dbManager!=null) {
  226.                     switch (this.dbManager) {
  227.                     case runtime:
  228.                         if(this.dbManager_runtime==null) {
  229.                             this.dbManager_runtime = DBManager.getInstance();
  230.                         }
  231.                         break;
  232.                     case smistatoreMessaggiPresiInCarico:
  233.                         if(this.dbManager_consegnePreseInCarico==null) {
  234.                             this.dbManager_consegnePreseInCarico = DBConsegnePreseInCaricoManager.getInstanceSmistatore();
  235.                         }
  236.                         break;
  237.                     case consegnePreseInCarico:
  238.                         if(this.dbManager_consegnePreseInCarico==null) {
  239.                             this.dbManager_consegnePreseInCarico = DBConsegnePreseInCaricoManager.getInstanceRuntime();
  240.                         }
  241.                         break;
  242.                     case messageBox:
  243.                         if(this.dbManager_consegneMessageBox==null) {
  244.                             this.dbManager_consegneMessageBox = DBConsegneMessageBoxManager.getInstanceRuntime();
  245.                         }
  246.                         break;
  247.                     }
  248.                 }
  249.                 else {
  250.                     if(this.dbManager_runtime==null) {
  251.                         this.dbManager_runtime = DBManager.getInstance();
  252.                     }
  253.                 }
  254.                 
  255.                 if(this.dbManager_runtime!=null) {
  256.                     this.resourceDB = this.dbManager_runtime.getResource(this.identitaPdD,this.idModulo,idTransazione);
  257.                 }
  258.                 else if(this.dbManager_consegnePreseInCarico!=null) {
  259.                     this.resourceDB = this.dbManager_consegnePreseInCarico.getResource(this.identitaPdD,this.idModulo,idTransazione);
  260.                 }
  261.                 else {
  262.                     this.resourceDB = this.dbManager_consegneMessageBox.getResource(this.identitaPdD,this.idModulo,idTransazione);
  263.                 }
  264.             }catch(Exception e){
  265.                 throw new OpenSPCoopStateException("Riscontrato errore durante la richiesta di una connessione al DB",e);
  266.             }
  267.             if(this.resourceDB==null){
  268.                 throw new OpenSPCoopStateException("Riscontrato errore durante la richiesta di una connessione al DB (Risorsa is null).");
  269.             }
  270.             if(this.resourceDB.getResource() == null){
  271.                 throw new OpenSPCoopStateException("Riscontrato errore durante la richiesta di una connessione al DB (Connessione is null)."); 
  272.             }
  273.             this.connectionDB = (Connection) this.resourceDB.getResource();
  274.             
  275.             this.richiestaStato.updateConnection(this.connectionDB);
  276.             this.rispostaStato.updateConnection(this.connectionDB);
  277.             
  278.             this.connessioneInizializzata = true;
  279.         }
  280.     }
  281.     
  282.     @Override
  283.     public void releaseResource() {
  284.         if(this.useConnection && this.connessioneInizializzata){
  285.             try{
  286.                 if(this.richiestaStato!=null && this.richiestaStato.getPreparedStatement()!=null){
  287.                     if(this.richiestaStato.getPreparedStatement().size()>0){
  288.                         List<String> l = this.richiestaStato.getPreparedStatement().keys();
  289.                         if(l!=null && !l.isEmpty()) {
  290.                             for (String key : l) {
  291.                                 this.logger.error("PREPARED STATEMENT NON CHIUSA (RICHIESTA): "+key);
  292.                             }
  293.                         }
  294.                         this.richiestaStato.closePreparedStatement();
  295.                     }
  296.                 }
  297.             }catch (Exception e) {  
  298.                 this.logger.error("Chiusure prepared statement della richiesta non riuscita",e);
  299.             }
  300.             try{
  301.                 if(this.rispostaStato!=null && this.rispostaStato.getPreparedStatement()!=null){
  302.                     if(this.rispostaStato.getPreparedStatement().size()>0){
  303.                         List<String> l = this.rispostaStato.getPreparedStatement().keys();
  304.                         if(l!=null && !l.isEmpty()) {
  305.                             for (String key : l) {
  306.                                 this.logger.error("PREPARED STATEMENT NON CHIUSA (RISPOSTA): "+key);
  307.                             }
  308.                         }
  309.                         this.rispostaStato.closePreparedStatement();
  310.                     }
  311.                 }
  312.             }catch (Exception e) {  
  313.                 this.logger.error("Chiusure prepared statement della risposta non riuscita",e);
  314.             }
  315.             try{
  316.                 if(this.resourceDB!=null){
  317.                     if(this.dbManager_runtime!=null) {
  318.                         this.dbManager_runtime.releaseResource(this.identitaPdD,this.idModulo,this.resourceDB);
  319.                     }
  320.                     else if(this.dbManager_consegnePreseInCarico!=null) {
  321.                         this.dbManager_consegnePreseInCarico.releaseResource(this.identitaPdD,this.idModulo,this.resourceDB);
  322.                     }
  323.                     else {
  324.                         this.dbManager_consegneMessageBox.releaseResource(this.identitaPdD,this.idModulo,this.resourceDB);
  325.                     }
  326.                 }
  327.                 if(this.richiestaStato!=null) {
  328.                     this.richiestaStato.updateConnection(null);
  329.                 }
  330.                 if(this.rispostaStato!=null) {
  331.                     this.rispostaStato.updateConnection(null);
  332.                 }
  333.             }catch (Exception e) {  
  334.                 this.logger.error("Rilasciate risorse con errore: "+e.getMessage(),e);
  335.                 OpenSPCoop2Logger.getLoggerOpenSPCoopConsole().error("Rilasciate risorse con errore: "+e.getMessage());
  336.             }
  337.             this.connessioneInizializzata = false;
  338.         }
  339.     }
  340.     
  341.     @Override
  342.     public boolean resourceReleased(){
  343.         return !this.connessioneInizializzata;
  344.     }
  345.     
  346.     public void forceFinallyReleaseResource() {
  347.         if(this.connessioneInizializzata){
  348.             this.useConnection = true; // force
  349.             //System.out.println("Force close ...");
  350.             this.releaseResource();
  351.         }
  352.     }
  353.     
  354.     
  355.     
  356.     
  357.     
  358.     
  359.     /* ----------- Commit / Close ------------*/
  360.     
  361.     @Override
  362.     public void commit() throws OpenSPCoopStateException{
  363.         if(this.useConnection){
  364.             if(   (this.richiestaStato!=null && this.richiestaStato.getPreparedStatement()!=null && this.richiestaStato.getPreparedStatement().size()>0)  ||
  365.                   (this.rispostaStato!=null && this.rispostaStato.getPreparedStatement()!=null && this.rispostaStato.getPreparedStatement().size()>0)
  366.             ){
  367.                 try{
  368.                     this.connectionDB.setAutoCommit(false);
  369.                     
  370. //                  System.out.println("PREPARED STATEMENT (RICHIESTA)");
  371. //                  Enumeration<String> en = this.richiestaStato.getPreparedStatement().keys();
  372. //                  while(en.hasMoreElements()){
  373. //                      String key = en.nextElement();
  374. //                      System.out.println("PREPARED STATEMENT (RICHIESTA): "+key);
  375. //                  }           
  376.                     if(this.richiestaStato!=null) {
  377.                         this.richiestaStato.executePreparedStatement();
  378.                     }
  379.                     
  380. //                  System.out.println("PREPARED STATEMENT (RISPOSTA)");
  381. //                  en = this.rispostaStato.getPreparedStatement().keys();
  382. //                  while(en.hasMoreElements()){
  383. //                      String key = en.nextElement();
  384. //                      System.out.println("PREPARED STATEMENT (RISPOSTA): "+key);
  385. //                  }   
  386.                     if(this.rispostaStato!=null) {
  387.                         this.rispostaStato.executePreparedStatement();
  388.                     }
  389.                     
  390.                     this.connectionDB.commit();
  391.                     this.connectionDB.setAutoCommit(true);
  392.                     
  393.                 }catch (Exception e) {
  394.                     // Chiudo eventuali prepared statement non chiuse
  395.                     try{
  396.                         if(this.richiestaStato!=null) {
  397.                             this.richiestaStato.closePreparedStatement();
  398.                         }
  399.                     }catch(Exception eClose){}
  400.                     try{
  401.                         if(this.rispostaStato!=null) {
  402.                             this.rispostaStato.closePreparedStatement();
  403.                         }
  404.                     }catch(Exception eClose){}
  405.                     //  Rollback quanto effettuato (se l'errore e' avvenuto sul commit, o prima nell'execute delle PreparedStatement)
  406.                     try{
  407.                         this.connectionDB.rollback();
  408.                     }catch(Exception er){}
  409.                     // Ripristino connessione
  410.                     try{
  411.                         this.connectionDB.setAutoCommit(true);
  412.                     }catch(Exception er){}
  413.                     // Rilancio l'eccezione: sara' catturata dal catch seguente, che chiudera' le preparedStatement, 
  414.                     // chiude la connessione al DB ed effettua il Rollback dell'MDB(a meno del profilo sincrono).
  415.                     throw new OpenSPCoopStateException(e.getMessage(),e);
  416.                 }
  417.             }
  418.         }
  419.     }
  420.     
  421.     
  422.     
  423.     
  424.     
  425.     
  426.     
  427.     
  428.     /* ----------- GET / SET ------------*/
  429.     @Override
  430.     public GenericMessage getMessageLib() {
  431.         return this.messageLib;
  432.     }

  434.     public void setMessageLib(GenericMessage messageLib) {
  435.         this.messageLib = messageLib;
  436.     }

  438.     @Override
  439.     public String getIDMessaggioSessione() {
  440.         return this.IDMessaggioSessione;
  441.     }

  443.     public void setIDMessaggioSessione(String idSessione) {
  444.         this.IDMessaggioSessione = idSessione;
  445.     }
  446.     
  447.     @Override
  448.     public IState getStatoRichiesta(){
  449.         return this.richiestaStato;
  450.     }
  451.     @Override
  452.     public void setStatoRichiesta(IState statoRichiesta){
  453.         this.richiestaStato = (StateMessage) statoRichiesta;
  454.     }
  455.     @Override
  456.     public IState getStatoRisposta(){
  457.         return this.rispostaStato;
  458.     }
  459.     @Override
  460.     public void setStatoRisposta(IState statoRisposta){
  461.         this.rispostaStato = (StateMessage) statoRisposta;
  462.     }
  463.     public Connection getConnectionDB() {
  464.         return this.connectionDB;
  465.     }
  466.     public void setConnectionDB(Connection connectionDB) {
  467.         this.connectionDB = connectionDB;
  468.     }
  469.     
  470.     public boolean isUseConnection() {
  471.         return this.useConnection;
  472.     }

  474.     public void setUseConnection(boolean useConnection) {
  475.         this.useConnection = useConnection;
  476.     }

  478. }
Created with JaCoCo 0.8.8.202204050719