JMSReceiver.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.core;

  25. import java.util.HashMap;
  26. import java.util.Map;

  28. import javax.jms.JMSException;
  29. import javax.jms.ObjectMessage;
  30. import javax.jms.MessageConsumer;
  31. import javax.jms.Queue;

  33. import org.slf4j.Logger;
  34. import org.openspcoop2.core.id.IDSoggetto;
  35. import org.openspcoop2.pdd.config.JMSObject;
  36. import org.openspcoop2.pdd.config.QueueManager;
  37. import org.openspcoop2.pdd.config.Resource;
  38. import org.openspcoop2.utils.Utilities;

  40. /**
  41.  * Classe utilizzata per ricevere messaggi JMS dai componenti dell'architettura di OpenSPCoop.
  42.  *
  43.  * @author Poli Andrea (apoli@link.it)
  44.  * @author $Author$
  45.  * @version $Rev$, $Date$
  46.  */

  48. public class JMSReceiver {

  50.     
  51.     /** QueueManager */
  52.     private QueueManager qmanager;
  53.     /** Indicazione sul modulo che utilizza il Sender  */
  54.     private String idModulo = null;
  55.     /** Indicazione sul codice porta del Sender */
  56.     private IDSoggetto codicePorta = null;

  58.     /** Object Ricevuto */
  59.     private Object received;
  60.     /** Proprieta' Ricevute */
  61.     private Map<String,java.io.Serializable> propertiesReceived;
  62.     /** motivo di un eventuale errore */
  63.     private String errore;
  64.     /** ID JMS presente nell'header del messaggio ricevuto */
  65.     private String idHeaderJMS;
  66.     
  67.     /** Indicazione se deve essere utilizzata una singola connessione JMS */
  68.     private boolean singleConnection;
  69.     
  70.     /** Logger */
  71.     private Logger log;

  73.     /** IDTransazione */
  74.     private String idTransazione;
  75.     

  77.     /**
  78.      * Costruttore
  79.      *
  80.      * @param aCodicePorta Codice del dominio che sta gestendo la richiesta.
  81.      * @param aIDModulo Identificativo del Receiver.
  82.      * @param singleConnection Indicazione se deve essere utilizzata una singola connessione JMS
  83.      * 
  84.      */
  85.     public JMSReceiver(IDSoggetto aCodicePorta,String aIDModulo,boolean singleConnection,Logger log,String idTransazione) throws Exception {
  86.         this.codicePorta = aCodicePorta;
  87.         this.idModulo = "JMSReceiver."+aIDModulo;
  88.         this.singleConnection = singleConnection;
  89.         this.qmanager = QueueManager.getInstance();
  90.         this.log = log;
  91.         this.idTransazione = idTransazione;
  92.     }

  94.     /**
  95.      * Ricezione di un messaggio  (Serve per filtrare una coda con un messaggio)
  96.      *
  97.      * @param destinatario Nodo destinatario per cui effettuare la ricezione. 
  98.      * @param msgSelector Filtro da utilizzare per la ricezione
  99.      * @return true se la ricezione JMS e' andata a buon fine, false altrimenti.
  100.      * 
  101.      */
  102.     public boolean clean(String destinatario,String msgSelector){
  103.         return receive(destinatario,msgSelector,1,1);
  104.     }
  105.     
  106.     /**
  107.      * Ricezione di un messaggio  
  108.      *
  109.      * @param destinatario Nodo destinatario per cui effettuare la ricezione. 
  110.      * @param timeout Timeout sulla ricezione
  111.      * @param checkInterval Intervallo di check sulla coda
  112.      * @return true se la ricezione JMS e' andata a buon fine, false altrimenti.
  113.      * 
  114.      */
  115.     public boolean receive(String destinatario,long timeout,long checkInterval){
  116.         return receive(destinatario,null,timeout,checkInterval);
  117.     }
  118.     /**
  119.      * Ricezione di un messaggio  
  120.      *
  121.      * @param destinatario Nodo destinatario per cui effettuare la ricezione. 
  122.      * @param msgSelector Filtro da utilizzare per la ricezione
  123.      * @param timeout Timeout sulla ricezione
  124.      * @param checkInterval Intervallo di check sulla coda
  125.      * @return true se la ricezione JMS e' andata a buon fine, false altrimenti.
  126.      * 
  127.      */
  128.     @SuppressWarnings("resource")
  129.     public boolean receive(String destinatario,String msgSelector,long timeout,long checkInterval){

  131.         Resource resource = null;
  132.         MessageConsumer receiver = null;
  133.         try{

  135.             JMSObject jmsObject = null;
  136.             try{
  137.                 resource = this.qmanager.getResource(this.codicePorta,this.idModulo,this.idTransazione);
  138.                 if(resource == null)
  139.                     throw new JMSException("Resource is null");
  140.                 if(resource.getResource() == null)
  141.                     throw new JMSException("JMSObject is null");
  142.                 jmsObject = (JMSObject) resource.getResource();
  143.                 if(jmsObject.getConnection()==null)
  144.                     throw new Exception("Connessione is null");
  145.                 if(jmsObject.getSession()==null)
  146.                     throw new Exception("Sessione is null");
  147.             }catch(Exception e){
  148.                 this.log.error("JMSObject non ottenibile dal Pool: "+e.getMessage(),e);
  149.                 this.errore ="JMSObject non ottenibile dal Pool: "+e.getMessage();
  150.                 return false;
  151.             }
  152.             
  153.             if(destinatario == null){
  154.                 this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  155.                 return false; // non deve essere ricevuto nulla ??.
  156.             }
  157.                 
  158.             // Get Coda
  159.             Queue queue = this.qmanager.getQueue(destinatario);
  160.             if(queue == null){
  161.                 this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  162.                 this.errore="La coda ["+destinatario+"] non e' tra quelle registrate per OpenSPCoop";
  163.                 return false;
  164.             }

  166.             //  Start connection
  167.             try{
  168.                 jmsObject.getConnection().start();
  169.             }catch(javax.jms.JMSException e){
  170.                 this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  171.                 this.errore = "Riscontrato errore durante lo start della connessione ["+destinatario+"] :"+e.getMessage();
  172.                 return false;
  173.             }
  174.             
  175.             // Receiver
  176.             try{
  177.                 if(msgSelector != null)
  178.                     receiver = jmsObject.getSession().createConsumer(queue,msgSelector);
  179.                 else
  180.                     receiver = jmsObject.getSession().createConsumer(queue);
  181.             }catch(javax.jms.JMSException e){
  182.                 this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  183.                 this.log.error("Riscontrato errore durante la creazione del receiver ["+destinatario+"] :"+e.getMessage(),e);
  184.                 this.errore = "Riscontrato errore durante la creazione del receiver ["+destinatario+"] :"+e.getMessage();
  185.                 return false;
  186.             }

  188.             // Ricezione Oggetto
  189.             ObjectMessage receivedMsg = null;
  190.             long attesa = 0;
  191.             while(attesa<timeout){
  192.                 
  193.                 //System.out.println("WHILE ["+this.idModulo+"]");
  194.                 
  195.                 receivedMsg = (ObjectMessage) receiver.receive(checkInterval);
  196.                 attesa = attesa + checkInterval;
  197.                 if(receivedMsg==null){
  198.                     
  199.                     //  rilascio e riprendo la connessione JMS ogni checkInterval fino ad un timeout o alla ricezione di un oggetto
  200.                     if(this.singleConnection==false){
  201.                         //System.out.println("Rilascio ["+this.idModulo+"]");
  202.                         receiver.close();
  203.                         this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  204.                     }
  205.                     
  206.                     Utilities.sleep(checkInterval);
  207.                     attesa = attesa + checkInterval;
  208.                     
  209.                     if(this.singleConnection==false){
  210.                         try{
  211.                             resource = this.qmanager.getResource(this.codicePorta,this.idModulo,this.idTransazione);
  212.                             if(resource == null)
  213.                                 throw new JMSException("Resource is null");
  214.                             if(resource.getResource() == null)
  215.                                 throw new JMSException("JMSObject is null");
  216.                             jmsObject = (JMSObject) resource.getResource();
  217.                         }catch(Exception e){
  218.                             this.log.error("JMSObject non ottenibile dal Pool: "+e.getMessage(),e);
  219.                             this.errore ="JMSObject non ottenibile dal Pool: "+e.getMessage();
  220.                             return false;
  221.                         }
  222.                         //System.out.println("Inizializzo ["+this.idModulo+"] ["+msgSelector+"]");
  223.                         //  Start connection
  224.                         try{
  225.                             jmsObject.getConnection().start();
  226.                         }catch(javax.jms.JMSException e){
  227.                             this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  228.                             this.log.error("Riscontrato errore durante lo start della connessione ["+destinatario+"] :"+e.getMessage(),e);
  229.                             this.errore = "Riscontrato errore durante lo start della connessione ["+destinatario+"] :"+e.getMessage();
  230.                             return false;
  231.                         }   
  232.                         // Reinizializzo Receiver
  233.                         try{
  234.                             if(msgSelector != null){
  235.                                 //System.out.println("MSG SELECTOR ["+msgSelector+"]");
  236.                                 receiver = jmsObject.getSession().createConsumer(queue,msgSelector);
  237.                             }else{
  238.                                 receiver = jmsObject.getSession().createConsumer(queue);
  239.                             }
  240.                         }catch(javax.jms.JMSException e){
  241.                             this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  242.                             this.log.error("Riscontrato errore durante la creazione del receiver ["+destinatario+"] :"+e.getMessage(),e);
  243.                             this.errore = "Riscontrato errore durante la creazione del receiver ["+destinatario+"] :"+e.getMessage();
  244.                             return false;
  245.                         }
  246.                     }
  247.                 }else{
  248.                     //System.out.println("TROVATO ["+this.idModulo+"]");
  249.                     break;
  250.                 }
  251.             }
  252.             if(receivedMsg == null){
  253.                 this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  254.                 this.errore = "Riscontrato errore durante ricezione del messaggio: Messaggio non ricevuto";
  255.                 receiver.close();
  256.                 return false;
  257.             }

  259.             // LetturaOggetto interno
  260.             this.received = receivedMsg.getObject();
  261.             this.idHeaderJMS = receivedMsg.getJMSMessageID();

  263.             // Lettura Proprieta'
  264.             this.propertiesReceived = new HashMap<String,java.io.Serializable>();
  265.             try{
  266.                 // IDMessaggio
  267.                 String idMessaggio = receivedMsg.getStringProperty("ID");
  268.                 this.propertiesReceived.put("ID",idMessaggio);
  269.             }   catch(javax.jms.JMSException e){}
  270.             try{
  271.                 // ContenutoRispostaPresente
  272.                 boolean contenutoRisposta = receivedMsg.getBooleanProperty("ContenutoRispostaPresente");
  273.                 this.propertiesReceived.put("ContenutoRispostaPresente",Boolean.valueOf(contenutoRisposta));
  274.             }   catch(javax.jms.JMSException e){}
  275.             // ......
  276.             
  277.             // Rilascio producer
  278.             receiver.close();
  279.         
  280.             this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  281.             return true;

  283.         }catch(Exception e){
  284.             //  Rilascio producer
  285.             try{
  286.                 if(receiver!=null)
  287.                     receiver.close();
  288.             }catch(Exception eClose){}
  289.             if(resource!=null){
  290.                 try{
  291.                     this.qmanager.releaseResource(this.codicePorta,this.idModulo,resource);
  292.                 }catch(Exception eClose){}  
  293.             }
  294.             this.log.error("Riscontrato errore durante la ricezione da una coda :"+e.getMessage(),e);
  295.             this.errore = "Riscontrato errore durante la ricezione da una coda :"+e.getMessage();   
  296.             return false;
  297.         }

  299.     }






  306.     /**
  307.      * In caso di avvenuto errore in fase di consegna, questo metodo ritorna il motivo dell'errore.
  308.      *
  309.      * @return motivo dell'errore (se avvenuto in fase di consegna).
  310.      * 
  311.      */
  312.     public String getErrore(){
  313.         return this.errore;
  314.     }
  315.     /**
  316.      * In caso di ricezione con successo, questo metodo ritorna l'oggetto ricevuto.
  317.      *
  318.      * @return Oggetto ricevuto.
  319.      * 
  320.      */
  321.     public Object getObjectReceived(){
  322.         return this.received;
  323.     }
  324.     /**
  325.      * In caso di ricezione con successo, questo metodo ritorna le proprieta' ricevute.
  326.      *
  327.      * @return Proprieta' ricevute.
  328.      * 
  329.      */
  330.     public Map<String,java.io.Serializable> getPropertiesReceived(){
  331.         return this.propertiesReceived;
  332.     }

  334.     /**
  335.      * ID JMS presente nell'header del messaggio ricevuto
  336.      *
  337.      * @return ID JMS presente nell'header del messaggio ricevuto
  338.      * 
  339.      */
  340.     public String getIdHeaderJMS(){
  341.         return this.idHeaderJMS;
  342.     }
  343. }




Created with JaCoCo 0.8.8.202204050719