QueueManager.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.  */



  23. package org.openspcoop2.pdd.config;

  25. import java.util.Map;
  26. import java.util.concurrent.ConcurrentHashMap;

  28. import javax.jms.Connection;
  29. import javax.jms.ConnectionFactory;
  30. import javax.jms.JMSException;
  31. import javax.jms.Queue;
  32. import javax.jms.Session;

  34. import org.openspcoop2.core.commons.CoreException;
  35. import org.openspcoop2.core.commons.IMonitoraggioRisorsa;
  36. import org.openspcoop2.core.id.IDSoggetto;
  37. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  38. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  39. import org.openspcoop2.pdd.mdb.Imbustamento;
  40. import org.openspcoop2.pdd.mdb.ImbustamentoRisposte;
  41. import org.openspcoop2.pdd.mdb.InoltroBuste;
  42. import org.openspcoop2.pdd.mdb.InoltroRisposte;
  43. import org.openspcoop2.pdd.mdb.Sbustamento;
  44. import org.openspcoop2.pdd.mdb.SbustamentoRisposte;
  45. import org.openspcoop2.pdd.services.core.RicezioneBuste;
  46. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativi;
  47. import org.openspcoop2.utils.UtilsException;
  48. import org.openspcoop2.utils.date.DateManager;
  49. import org.openspcoop2.utils.resources.GestoreJNDI;


  52. /**
  53.  * Contiene la gestione delle connessioni al broker delle code JMS.
  54.  * Il nome della risorsa JNDI da cui e' possibili attingere connessioni verso il Provider JMS, 
  55.  * viene selezionato attraverso le impostazioni lette dal file 'govway.properties'
  56.  * e gestite attraverso l'utilizzo della classe  {@link org.openspcoop2.pdd.config.OpenSPCoop2Properties}.
  57.  *
  58.  *
  59.  * @author Poli Andrea (apoli@link.it)
  60.  * @author $Author$
  61.  * @version $Rev$, $Date$
  62.  */

  64. public class QueueManager implements IMonitoraggioRisorsa{

  66.     private static final String ID_MODULO = "QueueManager";

  68.     /** Coda su cui il webService 'RicezioneContenutiApplicativi_XXX' sta' attendendo una risposta */
  69.     private static Queue queueRicezioneContenutiApplicativi;
  70.     /** Coda su cui il webService 'RicezioneBuste_XXX' sta' attendendo una risposta */
  71.     private static Queue queueRicezioneBuste;
  72.     /** Coda su cui l'MDB 'Imbustamento' sta' attendendo un messaggio */
  73.     private static Queue queueImbustamento;
  74.     /** Coda su cui l'MDB 'ImbustamentoRisposte' sta' attendendo un messaggio */
  75.     private static Queue queueImbustamentoRisposte;
  76.     /** Coda su cui l'MDB 'Sbustamento' sta' attendendo un messaggio */
  77.     private static Queue queueSbustamento;
  78.     /** Coda su cui l'MDB 'SbustamentoRisposte' sta' attendendo un messaggio */
  79.     private static Queue queueSbustamentoRisposte;
  80.     /** Coda su cui l'MDB 'InoltroBuste' sta' attendendo un messaggio */
  81.     private static Queue queueInoltroBuste;
  82.     /** Coda su cui l'MDB 'InoltroRisposte' sta' attendendo un messaggio */
  83.     private static Queue queueInoltroRisposte;
  84.     /** Coda su cui l'MDB 'ConsegnaMessaggi' sta' attendendo un messaggio */
  85.     private static Queue queueConsegnaContenutiApplicativi;

  87.     
  88.     /** OpenSPCoopProperties */
  89.     private static OpenSPCoop2Properties openspcoopProperties = OpenSPCoop2Properties.getInstance();
  90.     
  91.     /** Informazione sui proprietari che hanno richiesto una connessione */
  92.     protected static Map<String,Resource> risorseInGestione = new ConcurrentHashMap<>();
  93.     
  94.     public static String[] getStatoRisorse() {
  95.         
  96.         String[] sNull = null;
  97.         Object[] o = QueueManager.risorseInGestione.values().toArray(new Resource[0]);
  98.         if(! (o instanceof Resource[]))
  99.             return sNull;
  100.         Resource[] resources = (Resource[]) o;
  101.         if(resources.length<=0)
  102.             return sNull;
  103.     
  104.         String [] r = new String[resources.length];
  105.         for(int i=0; i<resources.length; i++){
  106.             Resource rr = resources[i];
  107.             r[i] = rr.getIdentificativoPorta()+"."+rr.getModuloFunzionale();
  108.             if(rr.getIdTransazione()!=null){
  109.                 r[i] = r[i] +"."+rr.getIdTransazione();
  110.             }
  111.             r[i] = r[i] +" ("+rr.getDate().toString()+")";
  112.         }
  113.         return r;
  114.     }


  117.     /** QueueManager */
  118.     private static QueueManager manager = null;

  120.     /**
  121.      * Il Metodo si occupa di inizializzare il QueueManager 
  122.      *
  123.      * @param jndiName Nome JNDI del QueueConnectionFactory
  124.      * @param contextFactory Contesto JNDI da utilizzare per la connection factory/openSPCoopQueueManager
  125.      * @throws OpenSPCoop2ConfigurationException 
  126.      * 
  127.      */
  128.     public static void initialize(String jndiName,
  129.             java.util.Properties contextFactory) throws OpenSPCoop2ConfigurationException {

  131.         // Provo ad ottenere un QueueManager
  132.         QueueManager.manager = new QueueManager(jndiName,contextFactory);

  134.     }
  135.     
  136.     /**
  137.      * Il Metodo si occupa di inizializzare le code di ricezione 
  138.      *
  139.      * @param contextQueue Contesto JNDI da utilizzare per le code interne
  140.      * @throws UtilsException 
  141.      * 
  142.      */
  143.     public static void initializeQueueNodeReceiver(java.util.Properties contextQueue) throws UtilsException {

  145.         // Tabella per i nomi jndi delle code
  146.         java.util.Map<String,String> nomiJndi = 
  147.             OpenSPCoop2Properties.getInstance().getJNDIQueueName(true,false);
  148.             
  149.         // Inizializzazione Code
  150.         GestoreJNDI jndiQueue = new GestoreJNDI(contextQueue);
  151.         QueueManager.queueRicezioneContenutiApplicativi = 
  152.             (Queue) jndiQueue.lookup(nomiJndi.get(RicezioneContenutiApplicativi.ID_MODULO));
  153.         QueueManager.queueRicezioneBuste= 
  154.             (Queue) jndiQueue.lookup(nomiJndi.get(RicezioneBuste.ID_MODULO));

  156.     }


  159.     /**
  160.      * Il Metodo si occupa di inizializzare le code di spedizione 
  161.      *
  162.      * @param contextQueue Contesto JNDI da utilizzare per le code interne
  163.      * @throws UtilsException 
  164.      * 
  165.      */
  166.     public static void initializeQueueNodeSender(java.util.Properties contextQueue) throws UtilsException {

  168.         // Tabella per i nomi jndi delle code
  169.         java.util.Map<String,String> nomiJndi = OpenSPCoop2Properties.getInstance().getJNDIQueueName(false,true);
  170.         
  171.         // Inizializzazione Code
  172.         GestoreJNDI jndiQueue = new GestoreJNDI(contextQueue);
  173.         QueueManager.queueImbustamento= 
  174.             (Queue) jndiQueue.lookup(nomiJndi.get(Imbustamento.ID_MODULO));
  175.         QueueManager.queueImbustamentoRisposte= 
  176.             (Queue) jndiQueue.lookup(nomiJndi.get(ImbustamentoRisposte.ID_MODULO));
  177.         QueueManager.queueSbustamento= 
  178.             (Queue) jndiQueue.lookup(nomiJndi.get(Sbustamento.ID_MODULO));
  179.         QueueManager.queueSbustamentoRisposte= 
  180.             (Queue) jndiQueue.lookup(nomiJndi.get(SbustamentoRisposte.ID_MODULO));
  181.         QueueManager.queueInoltroBuste= 
  182.             (Queue) jndiQueue.lookup(nomiJndi.get(InoltroBuste.ID_MODULO));
  183.         QueueManager.queueInoltroRisposte= 
  184.             (Queue) jndiQueue.lookup(nomiJndi.get(InoltroRisposte.ID_MODULO));
  185.         QueueManager.queueConsegnaContenutiApplicativi= 
  186.             (Queue) jndiQueue.lookup(nomiJndi.get(ConsegnaContenutiApplicativi.ID_MODULO));
  187.     }
  188.     
  189.     
  190.     
  191.     
  192.     /**
  193.      * Ritorna l'istanza di questo QueueManager
  194.      *
  195.      * @return Istanza di QueueManager
  196.      * 
  197.      */
  198.     public static QueueManager getInstance(){
  199.         if(QueueManager.manager==null) {
  200.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  201.             synchronized (QueueManager.class) {
  202.                 return QueueManager.manager;
  203.             }
  204.         }
  205.         return QueueManager.manager;
  206.     }

  208.     
  209.     /**
  210.      * Restituisce la coda associata al nodo con identificativo <var>nomeNodo</var>.
  211.      *
  212.      * @param idNodo Identificatore del nodo.
  213.      * 
  214.      */
  215.     public Queue getQueue(String idNodo) {
  216.         if(idNodo.startsWith(RicezioneContenutiApplicativi.ID_MODULO))
  217.             return QueueManager.queueRicezioneContenutiApplicativi;
  218.         else if(idNodo.startsWith(RicezioneBuste.ID_MODULO))
  219.             return QueueManager.queueRicezioneBuste;
  220.         else if(Imbustamento.ID_MODULO.equals(idNodo))
  221.             return QueueManager.queueImbustamento;
  222.         else if(ImbustamentoRisposte.ID_MODULO.equals(idNodo))
  223.             return QueueManager.queueImbustamentoRisposte;
  224.         else if(Sbustamento.ID_MODULO.equals(idNodo))
  225.             return QueueManager.queueSbustamento;
  226.         else if(SbustamentoRisposte.ID_MODULO.equals(idNodo))
  227.             return QueueManager.queueSbustamentoRisposte;
  228.         else if(InoltroBuste.ID_MODULO.equals(idNodo))
  229.             return QueueManager.queueInoltroBuste;
  230.         else if(InoltroRisposte.ID_MODULO.equals(idNodo))
  231.             return QueueManager.queueInoltroRisposte;
  232.         else if(ConsegnaContenutiApplicativi.ID_MODULO.equals(idNodo))
  233.             return QueueManager.queueConsegnaContenutiApplicativi;
  234.         else 
  235.             return null;
  236.     }
  237.     
  238.     
  239.     
  240.     
  241.     
  242.     /** ConnectionFactory dove attingere connessioni */
  243.     private ConnectionFactory qcf = null;
  244.     /** MsgDiagnostico */
  245.     private MsgDiagnostico msgDiag = null;
  246.     
  247.     /**
  248.      * Costruttore
  249.      *
  250.      * @param jndiName Nome JNDI del QueueConnectionFactory
  251.      * @param context Contesto JNDI da utilizzare
  252.      * 
  253.      */
  254.     private QueueManager(String jndiName,java.util.Properties context) throws OpenSPCoop2ConfigurationException{

  256.         this.msgDiag = MsgDiagnostico.newInstance("WrapperQueueManager");
  257.         try {
  258.             GestoreJNDI jndi = new GestoreJNDI(context);

  260.             // ConnectionFactory
  261.             this.qcf = (ConnectionFactory) jndi.lookup(jndiName);
  262.         }
  263.         catch(Exception e) {
  264.             throw new OpenSPCoop2ConfigurationException("WrapperQueueManager: "+e.getMessage(),e);
  265.         }

  267.     }





  273.     /**
  274.      * Ritorna un JMSObject che contiene una connessione/sessione al JMS Broker
  275.      *
  276.      * @param idPDD Identificatore della porta di dominio.
  277.      * @param modulo Modulo che richiede una connessione.
  278.      * @return JMSObject.
  279.      * 
  280.      */
  281.     public Resource getResource(IDSoggetto idPDD,String modulo,String idTransazione) throws OpenSPCoop2ConfigurationException{
  282.         
  283.         Resource risorsa = new Resource();
  284.         try {
  285.             Connection con = this.qcf.createConnection();
  286.             checkConnection(con);

  288.             // Sessione
  289.             Session s = con.createSession(false,QueueManager.openspcoopProperties.getAcknowledgeModeSessioneConnectionFactory());
  290.             if(s == null){
  291.                 con.close();
  292.                 throw new OpenSPCoop2ConfigurationException("SessioneNonDisponibile");
  293.             }

  295.             // Object JMS
  296.             
  297.             JMSObject jms = new JMSObject();
  298.             jms.setConnection(con);
  299.             jms.setSession(s); 
  300.             
  301.             String idUnivoco = Resource.generaIdentificatoreUnivoco(idPDD, modulo);
  302.             risorsa.setId(idUnivoco);
  303.             risorsa.setDate(DateManager.getDate());
  304.             risorsa.setIdentificativoPorta(idPDD);
  305.             risorsa.setModuloFunzionale(modulo);
  306.             risorsa.setResource(jms);
  307.             risorsa.setResourceType(JMSObject.class.getName());
  308.             risorsa.setIdTransazione(idTransazione);
  309.                 
  310.             QueueManager.risorseInGestione.put(idUnivoco, risorsa);
  311.             
  312.             return risorsa;

  314.         }
  315.         catch(Exception e) {
  316.             this.msgDiag.aggiornaFiltri();
  317.             this.msgDiag.setDominio(idPDD);
  318.             this.msgDiag.setFunzione("QueueManager."+modulo);
  319.             this.msgDiag.logFatalError(e, "Richiesta connessione al QueueManager");
  320.             throw new OpenSPCoop2ConfigurationException("getJMSObject: "+e.getMessage());
  321.         }
  322.     }
  323.     private static void checkConnection(Connection con) throws OpenSPCoop2ConfigurationException {
  324.         if(con == null)
  325.             throw new OpenSPCoop2ConfigurationException("ConnessioneNonDisponibile");
  326.     }
  327.     /**
  328.      * Restituisce un JMSObject al pool
  329.      *
  330.      * @param idPDD Identificatore della porta di dominio.
  331.      * @param modulo Modulo che richiede una connessione.
  332.      * @param resource JMSObject.
  333.      * 
  334.      */
  335.     public void releaseResource(IDSoggetto idPDD,String modulo,Resource resource) throws OpenSPCoop2ConfigurationException{
  336.         try {
  337.             if(resource!=null){
  338.                 if(resource.getResource()!=null){
  339.                     JMSObject jms = (JMSObject) resource.getResource();
  340.                     // Controllo dell'oggetto ricevuto
  341.                     if(jms == null){
  342.                         throw new OpenSPCoop2ConfigurationException("PassivateObject[JMSObjectNull]");
  343.                     }
  344.                     if(jms.getConnection()==null){
  345.                         throw new OpenSPCoop2ConfigurationException("PassivateObject[ConnectionNull]");
  346.                     }
  347.                     if(jms.getSession()==null){
  348.                         throw new OpenSPCoop2ConfigurationException("PassivateObject[SessionNull]");
  349.                     }

  351.                     // rilascio
  352.                     close(jms);
  353.                     
  354.                 }
  355.                 if(QueueManager.risorseInGestione.containsKey(resource.getId()))
  356.                     QueueManager.risorseInGestione.remove(resource.getId());
  357.             }
  358.         }
  359.         catch(Exception e) {
  360.             this.msgDiag.aggiornaFiltri();
  361.             this.msgDiag.setDominio(idPDD);
  362.             this.msgDiag.setFunzione("QueueManager."+modulo);
  363.             this.msgDiag.logFatalError(e, "Rilasciata connessione al QueueManager");
  364.             throw new OpenSPCoop2ConfigurationException("releaseJMSObject: "+e.getMessage());
  365.         }
  366.     }
  367.     private void close(JMSObject jms) throws JMSException {
  368.         try{
  369.             jms.getSession().close();
  370.         }catch(Exception e){
  371.             jms.getConnection().close();
  372.             throw e;
  373.         }
  374.         jms.getConnection().close();
  375.     }
  376.     
  377.     




  382.     /**
  383.      * Metodo che verica la connessione ad una risorsa.
  384.      * Se la connessione non e' presente, viene lanciata una eccezione che contiene il motivo della mancata connessione
  385.      * 
  386.      * @throws DriverException eccezione che contiene il motivo della mancata connessione
  387.      */
  388.     @Override
  389.     public void isAlive() throws CoreException{
  390.         Resource resource = null;
  391.         IDSoggetto idSoggettAlive = new IDSoggetto();
  392.         idSoggettAlive.setCodicePorta(ID_MODULO);
  393.         idSoggettAlive.setTipo(ID_MODULO);
  394.         idSoggettAlive.setNome(ID_MODULO);
  395.         try{
  396.             resource = this.getResource(idSoggettAlive, "CheckIsAlive", null);
  397.             if(resource == null)
  398.                 throw new CoreException("Resource is null");
  399.             if(resource.getResource() == null)
  400.                 throw new CoreException("JMSObject is null");
  401.             JMSObject jmsObject = (JMSObject) resource.getResource();
  402.             if(jmsObject.getConnection()==null)
  403.                 throw new CoreException("Connessione is null");
  404.             if(jmsObject.getSession()==null)
  405.                 throw new CoreException("Sessione is null");
  406.             Connection connectionJMS = jmsObject.getConnection();
  407.             // test
  408.             connectionJMS.getClientID();
  409.         }catch(Exception e){
  410.             throw new CoreException("Connessione al broker JMS non disponibile: "+e.getMessage(),e);
  411.         }finally{
  412.             try{
  413.                 this.releaseResource(idSoggettAlive, "CheckIsAlive" ,resource);
  414.             }catch(Exception e){
  415.                 // close
  416.             }
  417.         }
  418.     }
  419. }
Created with JaCoCo 0.8.8.202204050719