TimerGestoreChiaviPDNDLib.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.timers.pdnd;


  24. import java.sql.Connection;
  25. import java.util.Date;

  27. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  28. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  29. import org.openspcoop2.core.eventi.Evento;
  30. import org.openspcoop2.core.eventi.constants.TipoSeverita;
  31. import org.openspcoop2.core.eventi.utils.SeveritaConverter;
  32. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  33. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  34. import org.openspcoop2.pdd.core.CostantiPdD;
  35. import org.openspcoop2.pdd.core.GestoreMessaggi;
  36. import org.openspcoop2.pdd.core.eventi.GestoreEventi;
  37. import org.openspcoop2.pdd.core.keystore.KeystoreException;
  38. import org.openspcoop2.pdd.core.keystore.RemoteStore;
  39. import org.openspcoop2.pdd.core.keystore.RemoteStoreProviderDriverUtils;
  40. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  41. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  42. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  43. import org.openspcoop2.pdd.timers.TimerException;
  44. import org.openspcoop2.pdd.timers.TimerLock;
  45. import org.openspcoop2.pdd.timers.TimerLockNotAvailableException;
  46. import org.openspcoop2.pdd.timers.TimerMonitoraggioRisorseThread;
  47. import org.openspcoop2.pdd.timers.TimerState;
  48. import org.openspcoop2.pdd.timers.TipoLock;
  49. import org.openspcoop2.utils.TipiDatabase;
  50. import org.openspcoop2.utils.Utilities;
  51. import org.openspcoop2.utils.UtilsException;
  52. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  53. import org.openspcoop2.utils.date.DateManager;
  54. import org.openspcoop2.utils.id.serial.InfoStatistics;
  55. import org.openspcoop2.utils.semaphore.Semaphore;
  56. import org.openspcoop2.utils.semaphore.SemaphoreConfiguration;
  57. import org.openspcoop2.utils.semaphore.SemaphoreMapping;
  58. import org.slf4j.Logger;


  61. /**     
  62.  * TimerGestoreChiaviPDNDLib
  63.  *
  64.  * @author Poli Andrea (poli@link.it)
  65.  * @author $Author$
  66.  * @version $Rev$, $Date$
  67.  */
  68. public class TimerGestoreChiaviPDNDLib {

  70.     private static TimerState state = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  71.     public static TimerState getState() {
  72.         return state;
  73.     }
  74.     public static void setState(TimerState stateParam) {
  75.         state = stateParam;
  76.     }
  77.     
  78.     private OpenSPCoop2Properties op2Properties;
  79.     private String tipoDatabase = null;
  80.     
  81.     private Logger logCore = null;
  82.     private Logger logTimer = null;
  83.     private MsgDiagnostico msgDiag = null;
  84.     
  85.     private void logCoreInfo(String msg) {
  86.         if(this.logCore!=null) {
  87.             this.logCore.info(msg);
  88.         }
  89.     }
  90.     private void logCoreError(String msgErrore, Throwable e) {
  91.         if(this.logCore!=null) {
  92.             this.logCore.error(msgErrore,e);
  93.         }
  94.     }
  95.     
  96.     private void logTimerError(String msgErrore, Throwable e) {
  97.         if(this.logTimer!=null) {
  98.             this.logTimer.error(msgErrore,e);
  99.         }
  100.     }
  101.     private void logTimerError(String msgErrore) {
  102.         if(this.logTimer!=null) {
  103.             this.logTimer.error(msgErrore);
  104.         }
  105.     }
  106.     private void logTimerInfo(String msg) {
  107.         if(this.logTimer!=null) {
  108.             this.logTimer.info(msg);
  109.         }
  110.     }
  111.     private void logTimerInfo(String msg, Exception e) {
  112.         if(this.logTimer!=null) {
  113.             this.logTimer.info(msg, e);
  114.         }
  115.     }
  116.     
  117.     private RemoteStoreConfig remoteStore;
  118.     private String urlCheckEventi;
  119.     
  120.     private String parameterLastEventId;
  121.     private String parameterLimit;
  122.     private int limit;
  123.     
  124.     private int timeoutSeconds = -1;

  126.     /** Timer */
  127.     private TimerLock timerLock = null;

  129.     /** Semaforo */
  130.     private Semaphore semaphore = null;
  131.     private InfoStatistics semaphoreStatistics;
  132.     
  133.     /** Costruttore */
  134.     public TimerGestoreChiaviPDNDLib(Logger logTimer, MsgDiagnostico msgDiag, RemoteStoreConfig remoteStore, 
  135.             String urlCheckEventi, int timeoutSeconds) throws TimerException{
  136.         
  137.         this.op2Properties = OpenSPCoop2Properties.getInstance();
  138.         this.tipoDatabase = this.op2Properties.getDatabaseType();
  139.         if(this.tipoDatabase==null){
  140.             throw new TimerException("Tipo Database non definito");
  141.         }
  142.         
  143.         boolean debug = this.op2Properties.isGestoreChiaviPDNDDebug();
  144.         
  145.         this.logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreChiaviPDND(debug);
  146.         this.logTimer = logTimer;
  147.         this.msgDiag = msgDiag;
  148.         
  149.         this.remoteStore = remoteStore;
  150.         this.urlCheckEventi = urlCheckEventi;
  151.         
  152.         this.timeoutSeconds = timeoutSeconds;
  153.         
  154.         try {
  155.             this.parameterLastEventId = this.op2Properties.getGestoreChiaviPDNDeventsKeysParameterLastEventId();
  156.             this.parameterLimit = this.op2Properties.getGestoreChiaviPDNDeventsKeysParameterLimit();
  157.             this.limit = this.op2Properties.getGestoreChiaviPDNDeventsKeysLimit();
  158.         }catch(Exception e) {
  159.             throw new TimerException(e.getMessage(),e);
  160.         }
  161.         
  162.         this.timerLock = new TimerLock(TipoLock.GESTORE_CHIAVI_PDND); 
  163.         
  164.         if(this.op2Properties.isTimerLockByDatabase()) {
  165.             this.semaphoreStatistics = new InfoStatistics();

  167.             SemaphoreConfiguration config = GestoreMessaggi.newSemaphoreConfiguration(this.op2Properties.getGestoreChiaviPDNDTimerLockMaxLife(), 
  168.                     this.op2Properties.getGestoreChiaviPDNDTimerLockIdleTime());

  170.             TipiDatabase databaseType = TipiDatabase.toEnumConstant(this.tipoDatabase);
  171.             try {
  172.                 this.semaphore = new Semaphore(this.semaphoreStatistics, SemaphoreMapping.newInstance(this.timerLock.getIdLock()), 
  173.                         config, databaseType, this.logTimer);
  174.             }catch(Exception e) {
  175.                 throw new TimerException(e.getMessage(),e);
  176.             }
  177.         }
  178.     }
  179.     
  180.     public void check() throws TimerException {
  181.         
  182.         // Controllo che il sistema non sia andando in shutdown
  183.         if(OpenSPCoop2Startup.contextDestroyed){
  184.             this.logTimerError("["+TimerGestoreChiaviPDND.ID_MODULO+"] Rilevato sistema in shutdown");
  185.             return;
  186.         }

  188.         // Controllo che l'inizializzazione corretta delle risorse sia effettuata
  189.         if(!OpenSPCoop2Startup.initialize){
  190.             this.msgDiag.logFatalError("inizializzazione di OpenSPCoop non effettuata", "Check Inizializzazione");
  191.             String msgErrore = "Riscontrato errore: inizializzazione del Timer o di OpenSPCoop non effettuata";
  192.             this.logTimerError(msgErrore);
  193.             throw new TimerException(msgErrore);
  194.         }

  196.         // Controllo risorse di sistema disponibili
  197.         if( !TimerMonitoraggioRisorseThread.isRisorseDisponibili()){
  198.             this.logTimerError("["+TimerGestoreChiaviPDND.ID_MODULO+"] Risorse di sistema non disponibili: "+TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile().getMessage(),TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile());
  199.             return;
  200.         }
  201.         if( !MsgDiagnostico.gestoreDiagnosticaDisponibile){
  202.             this.logTimerError("["+TimerGestoreChiaviPDND.ID_MODULO+"] Sistema di diagnostica non disponibile: "+MsgDiagnostico.motivoMalfunzionamentoDiagnostici.getMessage(),MsgDiagnostico.motivoMalfunzionamentoDiagnostici);
  203.             return;
  204.         }
  205.         
  206.         boolean enabled = TimerState.ENABLED.equals(TimerGestoreChiaviPDNDLib.state);
  207.         if(!enabled) {
  208.             this.msgDiag.addKeyword(CostantiPdD.KEY_REMOTE_STORE, "-");
  209.             emitDiagnosticLog("disabilitato");
  210.             return;
  211.         }
  212.         
  213.         emitDiagnosticLog("letturaEventi");

  215.         long startControlloTimer = DateManager.getTimeMillis();
  216.             
  217.         DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection = null;
  218.         try{
  219.             Object oConfig = ConfigurazionePdDReader.getDriverConfigurazionePdD();
  220.             if(oConfig instanceof DriverConfigurazioneDB) {
  221.                 driverConfigurazioneDbGestoreConnection = (DriverConfigurazioneDB) oConfig;
  222.             }
  223.             else {
  224.                 throw new TimerException("Gestore utilizzabile solamente con una configurazione su database");
  225.             }
  226.         }
  227.         catch (Exception e) {
  228.             this.msgDiag.logErroreGenerico(e,TimerGestoreChiaviPDND.ID_MODULO);
  229.             this.logTimerError("Riscontrato errore durante la gestione eventi per le chiavi della PDND: "+ e.getMessage(),e);
  230.             return;
  231.         }
  232.         
  233.         try{

  235.             String causa = "Gestione chiavi PDND";
  236.             try {
  237.                 
  238.                 acquireLock(driverConfigurazioneDbGestoreConnection, causa);
  239.                 
  240.                 process(driverConfigurazioneDbGestoreConnection);
  241.                 
  242.             }finally{
  243.                 releaseSafeLock(driverConfigurazioneDbGestoreConnection, causa);
  244.             }
  245.             
  246.             // end
  247.             long endControlloTimer = DateManager.getTimeMillis();
  248.             long diff = (endControlloTimer-startControlloTimer);
  249.             this.logTimerInfo("Gestione eventi per le chiavi della PDND terminata in "+Utilities.convertSystemTimeIntoStringMillisecondi(diff, true));
  250.             
  251.             
  252.         }
  253.         catch(TimerLockNotAvailableException t) {
  254.             // msg diagnostico emesso durante l'emissione dell'eccezione
  255.             this.logTimerInfo(t.getMessage(),t);
  256.         }
  257.         catch (Exception e) {
  258.             this.msgDiag.logErroreGenerico(e,TimerGestoreChiaviPDND.ID_MODULO);
  259.             this.logTimerError("Riscontrato errore durante la gestione eventi per le chiavi della PDND: "+ e.getMessage(),e);
  260.         }
  261.             
  262.     }

  264.     private void acquireLock(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection, String causa) throws DriverConfigurazioneException, TimerException, UtilsException, TimerLockNotAvailableException {
  265.         Connection conConfigurazione = null;
  266.         String method = TimerGestoreChiaviPDND.ID_MODULO+".acquireLock";
  267.         try{

  269.             conConfigurazione = driverConfigurazioneDbGestoreConnection.getConnection(method);
  270.             if(conConfigurazione == null) {
  271.                 throw new TimerException(TimerGestoreChiaviPDND.CONNESSIONE_NON_DISPONIBILE);   
  272.             }
  273.             
  274.             GestoreMessaggi.acquireLock(
  275.                     this.semaphore, conConfigurazione, this.timerLock,
  276.                     this.msgDiag, causa, 
  277.                     this.op2Properties.getGestoreChiaviPDNDTimerLockAttesaAttiva(), 
  278.                     this.op2Properties.getGestoreChiaviPDNDTimerLockCheckInterval());
  279.         }
  280.         finally{
  281.             try{
  282.                 if(conConfigurazione!=null)
  283.                     driverConfigurazioneDbGestoreConnection.releaseConnection(method, conConfigurazione);
  284.             }catch(Exception eClose){
  285.                 // ignore
  286.             }
  287.         }
  288.     }
  289.     private void releaseSafeLock(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection, String causa)  {
  290.         Connection conConfigurazione = null;
  291.         String method = TimerGestoreChiaviPDND.ID_MODULO+".releaseSafeLock";
  292.         try{

  294.             conConfigurazione = driverConfigurazioneDbGestoreConnection.getConnection(method);
  295.             if(conConfigurazione == null) {
  296.                 throw new TimerException(TimerGestoreChiaviPDND.CONNESSIONE_NON_DISPONIBILE);   
  297.             }
  298.             
  299.             GestoreMessaggi.releaseSafeLock(
  300.                     this.semaphore, conConfigurazione, this.timerLock,
  301.                     this.msgDiag, causa);
  302.             
  303.         }
  304.         catch(Exception e) {
  305.             this.msgDiag.logErroreGenerico(e,TimerGestoreChiaviPDND.ID_MODULO);
  306.         }
  307.         finally{
  308.             try{
  309.                 if(conConfigurazione!=null)
  310.                     driverConfigurazioneDbGestoreConnection.releaseConnection(method, conConfigurazione);
  311.             }catch(Exception eClose){
  312.                 // ignore
  313.             }
  314.         }
  315.     }
  316.     
  317.     
  318.     private long lastEventId = 0;
  319.         
  320.     private void process(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection) throws KeystoreException {
  321.         
  322.         // Recupero id del Remote Store
  323.         boolean created = readRemoteStoreDbImage(driverConfigurazioneDbGestoreConnection);
  324.         
  325.         TimerGestoreChiaviPDNDUtilities pdndUtilities = new TimerGestoreChiaviPDNDUtilities(this.remoteStore, this.urlCheckEventi, this.parameterLastEventId, this.parameterLimit, this.limit);
  326.         
  327.         this.msgDiag.addKeyword(CostantiPdD.KEY_LIMIT, this.limit+"");
  328.         
  329.         boolean updateLasteEventId = false;
  330.         
  331.         if(created || this.remoteStoreDbImage.getLastEvent()==null) {
  332.             // Initialize
  333.             updateLasteEventId = initialize(driverConfigurazioneDbGestoreConnection, pdndUtilities);
  334.         }
  335.         else {
  336.             // Verifico ultima data di aggiornamento
  337.             
  338.             long now = DateManager.getTimeMillis();
  339.             int msTimeout = this.timeoutSeconds * 1000;
  340.             Date check = new Date(now-msTimeout);
  341.             if(check.before(this.remoteStoreDbImage.getDataAggiornamento())) {
  342.                 emitDiagnosticLog("letturaEventi.nonNecessaria");
  343.                 return;
  344.             }
  345.             
  346.             // leggo lastEventId
  347.             long lastEventIdDbImage = Long.parseLong(this.remoteStoreDbImage.getLastEvent());
  348.             this.lastEventId = lastEventIdDbImage;
  349.             
  350.             int letti = 1;
  351.             long prec = 0; 
  352.             while(letti > 0) {
  353.                 prec = this.lastEventId; 
  354.                 letti = gestione(driverConfigurazioneDbGestoreConnection, pdndUtilities, true);
  355.                 if(this.lastEventId<=prec) {
  356.                     // l'ultima gestione non ha aggiornato lastEventId
  357.                     break;
  358.                 }
  359.             }
  360.             
  361.             if(this.lastEventId>lastEventIdDbImage) {
  362.                 updateLasteEventId = true;
  363.             }

  365.         }
  366.                 
  367.         // aggiorno lastEventId sul database
  368.         if(updateLasteEventId) {
  369.             updateRemoteStore(driverConfigurazioneDbGestoreConnection,  this.remoteStoreDbImage.getId(), this.lastEventId+"");
  370.         }
  371.         
  372.     }
  373.     private boolean initialize(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection, TimerGestoreChiaviPDNDUtilities pdndUtilities) {
  374.         
  375.         boolean updateLasteEventId = false;
  376.         
  377.         emitDiagnosticLog("inizializzazione.inCorso");
  378.         try {
  379.             int letti = 1;
  380.             long prec = 0; 
  381.             while(letti > 0) {
  382.                 prec = this.lastEventId; 
  383.                 letti = gestione(driverConfigurazioneDbGestoreConnection, pdndUtilities, false);
  384.                 if(this.lastEventId<=prec) {
  385.                     // l'ultima gestione non ha aggiornato lastEventId
  386.                     break;
  387.                 }
  388.             }
  389.             
  390.             if(letti==-1) {
  391.                 throw new TimerException("Recupero eventi dalla PDND non riuscito");
  392.             }
  393.                             
  394.             this.msgDiag.addKeyword(CostantiPdD.KEY_OFFSET, this.lastEventId+"");
  395.             emitDiagnosticLog("inizializzazione.effettuata");
  396.             
  397.             updateLasteEventId = true;
  398.             
  399.         }catch(Exception e) {
  400.             this.msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  401.             emitDiagnosticLog("inizializzazione.fallita");
  402.         }
  403.         
  404.         return updateLasteEventId;
  405.     }
  406.     
  407.     private RemoteStore remoteStoreDbImage = null;
  408.     private boolean readRemoteStoreDbImage(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection) throws KeystoreException {
  409.         Connection conConfigurazione = null;
  410.         String method = TimerGestoreChiaviPDND.ID_MODULO+".readRemoteStoreDbImage";
  411.         try{

  413.             conConfigurazione = driverConfigurazioneDbGestoreConnection.getConnection(method);
  414.             if(conConfigurazione == null) {
  415.                 throw new TimerException(TimerGestoreChiaviPDND.CONNESSIONE_NON_DISPONIBILE);   
  416.             }
  417.             
  418.             return readRemoteStoreDbImage(conConfigurazione);
  419.         }
  420.         catch (Exception e) {
  421.             throw new KeystoreException("readRemoteStoreDbImage failed: "+e.getMessage());
  422.         }finally{
  423.             try{
  424.                 if(conConfigurazione!=null)
  425.                     driverConfigurazioneDbGestoreConnection.releaseConnection(method, conConfigurazione);
  426.             }catch(Exception eClose){
  427.                 // ignore
  428.             }
  429.         }
  430.     }
  431.     private boolean readRemoteStoreDbImage(Connection conConfigurazione) throws KeystoreException {
  432.         this.remoteStoreDbImage = RemoteStoreProviderDriverUtils.getRemoteStore(conConfigurazione, this.tipoDatabase, this.remoteStore, false);
  433.         boolean created = false;
  434.         if(this.remoteStoreDbImage==null) {
  435.             // lo creo
  436.             try {
  437.                 RemoteStoreProviderDriverUtils.createRemoteStore(conConfigurazione, this.tipoDatabase, this.remoteStore);
  438.                 created = true;
  439.             }catch(KeystoreException e) {
  440.                 // un errore potrebbe essere dovuto ad un altro thread su un altro nodo che ha creato l'entry
  441.                 // provo a recuperare l'id prima di lanciare l'eccezione
  442.                 this.remoteStoreDbImage = RemoteStoreProviderDriverUtils.getRemoteStore(conConfigurazione, this.tipoDatabase, this.remoteStore, false);
  443.                 if(this.remoteStoreDbImage==null) {
  444.                     throw e;
  445.                 }
  446.             }
  447.             
  448.             if(this.remoteStoreDbImage==null) {
  449.                 this.remoteStoreDbImage = RemoteStoreProviderDriverUtils.getRemoteStore(conConfigurazione, this.tipoDatabase, this.remoteStore, true); // ora dovrebbe esistere
  450.             }
  451.         }
  452.         return created;
  453.     }
  454.     
  455.     private String getEventPrefix(TimerGestoreChiaviPDNDEvent event) {
  456.         return "Evento '"+event.getEventId()+"' ";
  457.     }
  458.     
  459.     private int gestione(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection, TimerGestoreChiaviPDNDUtilities pdndUtilities, boolean gestioneEvento) {
  460.         try {
  461.             long startGenerazione = DateManager.getTimeMillis();
  462.             
  463.             int letti = 0;
  464.             
  465.             this.msgDiag.addKeyword(CostantiPdD.KEY_OFFSET, this.lastEventId+"");
  466.             emitDiagnosticLog("gestioneEventi.inCorso");
  467.             
  468.             TimerGestoreChiaviPDNDEvents events = pdndUtilities.readNextEvents(this.lastEventId);
  469.             if(events==null || events.getEvents()==null || events.getEvents().isEmpty()) {
  470.                 letti = 0;
  471.             }
  472.             else {
  473.                 letti = events.getEvents().size();
  474.             }
  475.             this.msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_EVENTI, letti+"");
  476.             emitDiagnosticLog("gestioneEventi.analisi");
  477.             
  478.             if(letti>0) {
  479.                 for (TimerGestoreChiaviPDNDEvent event : events.getEvents()) {                  
  480.                     if(event.getEventId()>this.lastEventId) {
  481.                         this.lastEventId = event.getEventId();
  482.                         if(gestioneEvento) {
  483.                             gestioneEvento(driverConfigurazioneDbGestoreConnection, event);
  484.                         }
  485.                     }
  486.                     else {
  487.                         emitLog(getEventPrefix(event)+"con un identificativo precedente o uguale all'ultimo evento gestito '"+this.lastEventId+"' (tipo di operazione: '"+event.getObjectType()+"'; tipo di evento: '"+event.getEventType()+"')");
  488.                     }
  489.                 }
  490.             }
  491.             
  492.             long endGenerazione = DateManager.getTimeMillis();
  493.             String tempoImpiegato = Utilities.convertSystemTimeIntoStringMillisecondi((endGenerazione-startGenerazione), true);
  494.             this.msgDiag.addKeyword(CostantiPdD.KEY_TEMPO_GESTIONE, tempoImpiegato);
  495.             emitDiagnosticLog("gestioneEventi.effettuata");
  496.             
  497.             return letti;
  498.             
  499.         }catch(Exception e) {
  500.             this.msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  501.             emitDiagnosticLog("gestioneEventi.fallita");
  502.             return -1;
  503.         }
  504.     }
  505.     
  506.     private void gestioneEvento(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection, TimerGestoreChiaviPDNDEvent event) throws KeystoreException, TimerException {
  507.         if(TimerGestoreChiaviPDNDEvent.OBJECT_TYPE_KEY.equals(event.getObjectType()) &&
  508.             (
  509.                     TimerGestoreChiaviPDNDEvent.EVENT_TYPE_DELETED.equals(event.getEventType())
  510.                     ||
  511.                     TimerGestoreChiaviPDNDEvent.EVENT_TYPE_UPDATED.equals(event.getEventType())
  512.             )
  513.         ) {
  514.             
  515.             this.msgDiag.addKeyword(CostantiPdD.KEY_ID_EVENTO, event.getEventId()+"");
  516.             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_EVENTO, event.getEventType());
  517.             
  518.             String kid = null;
  519.             if(event.getObjectId()!=null) {
  520.                 String details = event.getObjectId().toString();
  521.                 this.msgDiag.addKeyword(CostantiPdD.KEY_DETTAGLI_EVENTO, details);
  522.                 
  523.                 kid = event.getObjectId().get("kid");
  524.             }
  525.             else {
  526.                 String details = "object id undefined";
  527.                 this.msgDiag.addKeyword(CostantiPdD.KEY_DETTAGLI_EVENTO, details);
  528.             }
  529.                         
  530.             if(kid!=null) {
  531.                 gestioneEvento(driverConfigurazioneDbGestoreConnection, event, kid);
  532.             }
  533.             
  534.             emitDiagnosticLog("gestioneEventi.evento");
  535.         }
  536.         else {
  537.             if(TimerGestoreChiaviPDNDEvent.OBJECT_TYPE_KEY.equals(event.getObjectType())){
  538.                 emitLog(getEventPrefix(event)+"relativo ad una chiave; tipo di evento '"+event.getEventType()+"' ignorato");
  539.             }
  540.             else {
  541.                 emitLog(getEventPrefix(event)+"relativo ad un tipo di operazione '"+event.getObjectType()+"' non gestita; (tipo di evento '"+event.getEventType()+"')");
  542.             }
  543.         }
  544.     }
  545.     private void gestioneEvento(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection, TimerGestoreChiaviPDNDEvent event, String kid) throws KeystoreException, TimerException {
  546.         Connection conConfigurazione = null;
  547.         String method = TimerGestoreChiaviPDND.ID_MODULO+".gestioneEvento_"+kid;
  548.         try{

  550.             conConfigurazione = driverConfigurazioneDbGestoreConnection.getConnection(method);
  551.             if(conConfigurazione == null) {
  552.                 throw new TimerException(TimerGestoreChiaviPDND.CONNESSIONE_NON_DISPONIBILE);   
  553.             }
  554.             
  555.             gestioneEvento(conConfigurazione, event, kid);
  556.         }
  557.         catch (Exception e) {
  558.             throw new KeystoreException("gestioneEvento failed: "+e.getMessage());
  559.         }finally{
  560.             try{
  561.                 if(conConfigurazione!=null)
  562.                     driverConfigurazioneDbGestoreConnection.releaseConnection(method, conConfigurazione);
  563.             }catch(Exception eClose){
  564.                 // ignore
  565.             }
  566.         }
  567.     }
  568.     private void gestioneEvento(Connection conConfigurazione, TimerGestoreChiaviPDNDEvent event, String kid) throws KeystoreException, TimerException {
  569.         Evento evento = null;
  570.         if(TimerGestoreChiaviPDNDEvent.EVENT_TYPE_DELETED.equals(event.getEventType())) {
  571.             int deleted = RemoteStoreProviderDriverUtils.deleteRemoteStoreKey(conConfigurazione, this.tipoDatabase, this.remoteStoreDbImage.getId(), kid);
  572.             if(deleted>0 && this.op2Properties.isGestoreChiaviPDNDEventiDelete()) {
  573.                 // significa che la chiave era stata registrata sulla base dati
  574.                 evento = buildEvento(event.getEventType(), kid, "La chiave è stata eliminata dal repository locale");
  575.             }
  576.         }
  577.         else {
  578.             int updated = RemoteStoreProviderDriverUtils.invalidRemoteStoreKey(conConfigurazione, this.tipoDatabase, this.remoteStoreDbImage.getId(), kid);
  579.             if(updated>0 && this.op2Properties.isGestoreChiaviPDNDEventiUpdate()) {
  580.                 // significa che la chiave era stata registrata sulla base dati
  581.                 evento = buildEvento(event.getEventType(), kid, "La chiave è stata invalidata sul repository locale");
  582.             }
  583.         }
  584.         if(evento!=null) {
  585.             try {
  586.                 GestoreEventi.getInstance().log(evento);
  587.             }catch(Exception e) {
  588.                 String msgError = "Registrazione evento per kid '"+kid+"' (eventType:"+event.getEventType()+") non riuscita: "+e.getMessage();
  589.                 this.logCoreError(msgError,e);
  590.                 this.logTimerError(msgError,e);
  591.             }
  592.         }
  593.     }
  594.     
  595.     private void updateRemoteStore(DriverConfigurazioneDB driverConfigurazioneDbGestoreConnection, long idStore, String lastEventId) throws KeystoreException {
  596.         Connection conConfigurazione = null;
  597.         String method = TimerGestoreChiaviPDND.ID_MODULO+".updateRemoteStore_"+idStore+"_"+lastEventId;
  598.         try{

  600.             conConfigurazione = driverConfigurazioneDbGestoreConnection.getConnection(method);
  601.             if(conConfigurazione == null) {
  602.                 throw new TimerException(TimerGestoreChiaviPDND.CONNESSIONE_NON_DISPONIBILE);   
  603.             }
  604.             
  605.             RemoteStoreProviderDriverUtils.updateRemoteStore(conConfigurazione, this.tipoDatabase, this.remoteStoreDbImage.getId(), this.lastEventId+"");
  606.         }
  607.         catch (Exception e) {
  608.             throw new KeystoreException("updateRemoteStore failed: "+e.getMessage());
  609.         }finally{
  610.             try{
  611.                 if(conConfigurazione!=null)
  612.                     driverConfigurazioneDbGestoreConnection.releaseConnection(method, conConfigurazione);
  613.             }catch(Exception eClose){
  614.                 // ignore
  615.             }
  616.         }
  617.     }
  618.     
  619.     private void emitDiagnosticLog(String code) {
  620.         this.msgDiag.logPersonalizzato(code);
  621.         String msg = this.msgDiag.getMessaggio_replaceKeywords(code);
  622.         emitLog(msg);
  623.     }
  624.     private void emitLog(String msg) {
  625.         this.logCoreInfo(msg);
  626.         this.logTimerInfo(msg);
  627.     }
  628.     
  629.     public static Evento buildEvento(String eventType, String objectDetail, String descrizione) throws TimerException{
  630.         Evento evento = new Evento();
  631.         evento.setTipo("GestioneChiaviPDND");
  632.         if(TimerGestoreChiaviPDNDEvent.EVENT_TYPE_ADDED.equals(eventType)) {
  633.             evento.setCodice(TIPO_EVENTO_ADD);
  634.         }
  635.         else if(TimerGestoreChiaviPDNDEvent.EVENT_TYPE_UPDATED.equals(eventType)) {
  636.             evento.setCodice(TIPO_EVENTO_UPDATED);
  637.         }
  638.         else if(TimerGestoreChiaviPDNDEvent.EVENT_TYPE_DELETED.equals(eventType)) {
  639.             evento.setCodice(TIPO_EVENTO_DELETED);
  640.         }
  641.         else {
  642.             evento.setCodice(eventType);
  643.         }
  644.         if(objectDetail!=null){
  645.             evento.setIdConfigurazione(objectDetail);
  646.         }       
  647.         evento.setDescrizione(descrizione);
  648.         evento.setOraRegistrazione(DateManager.getDate());
  649.         try {
  650.             evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  651.         }catch(Exception e) {
  652.             throw new TimerException(e.getMessage(),e);
  653.         }
  654.         evento.setClusterId(OpenSPCoop2Properties.getInstance().getClusterId(false));
  655.         return evento;
  656.     }
  657.     
  658.     private static final String TIPO_EVENTO_ADD = "Add";
  659.     private static final String TIPO_EVENTO_DELETED = "Delete";
  660.     private static final String TIPO_EVENTO_UPDATED = "Update";
  661. }
Created with JaCoCo 0.8.8.202204050719