GestoreJNDI.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.utils.resources;

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

  28. import javax.naming.Context;
  29. import javax.naming.InitialContext;
  30. import javax.naming.NameNotFoundException;

  32. import org.openspcoop2.utils.SemaphoreLock;
  33. import org.openspcoop2.utils.UtilsException;
  34. import org.slf4j.Logger;

  36. /**
  37.  * Classe dove sono forniti metodi per effettuare operazioni sull'albero JNDI 
  38.  *
  39.  *
  40.  * @author Poli Andrea (apoli@link.it)
  41.  * @author $Author$
  42.  * @version $Rev$, $Date$
  43.  */

  45. public class GestoreJNDI {

  47.     private java.util.Properties contextProperties;

  49.         
  50.     /**
  51.      * Costruttore
  52.      *
  53.      * @param contextP Proprieta' del contesto JNDI
  54.      */
  55.     public GestoreJNDI(java.util.Properties contextP){
  56.         this.contextProperties = contextP;
  57.     }
  58.     /**
  59.      * Costruttore
  60.      *
  61.      */
  62.     public GestoreJNDI(){
  63.         this.contextProperties = new java.util.Properties();
  64.     }

  66.     
  67.     private static org.openspcoop2.utils.Semaphore semaphore = new org.openspcoop2.utils.Semaphore("GestoreJNDI");
  68.     private static Map<String, Object> localTreeJNDI = new ConcurrentHashMap<>();
  69.     public static final String LOCAL_TREE_JNDI_PREFIX = "local:/openspcoop2/";


  72.     /**
  73.      * Ritorna l'oggetto registrato nell'albero JNDI con nome <var>fullPath</var>, se presente.
  74.      *
  75.      * @param fullPath Nome dell'oggetto da ricercare nell'albero JNDI
  76.      */
  77.     public Object lookup(String fullPath) throws UtilsException {
  78.         
  79.         if(fullPath!=null && fullPath.startsWith(LOCAL_TREE_JNDI_PREFIX)){
  80.         
  81.             /**System.out.println("-------------------------------- LOCAL LOOKUP ["+fullPath+"]");*/
  82.             
  83.             Object o = null;
  84.             SemaphoreLock lock = semaphore.acquireThrowRuntime("lookup");
  85.             try {
  86.                 o = localTreeJNDI.get(fullPath);
  87.             }finally {
  88.                 semaphore.release(lock, "lookup");
  89.             }
  90.             if(o==null){
  91.                 throw new UtilsException("LocalResource ["+fullPath+"] not found");
  92.             }
  93.             return o;
  94.             
  95.         }
  96.         
  97.         // Inizializzo Contesto
  98.         InitialContext ctx = null;
  99.         try{
  100.             if(this.contextProperties!=null && this.contextProperties.size() > 0){
  101.                 ctx = new InitialContext(this.contextProperties);
  102.             }else{
  103.                 ctx = new InitialContext();
  104.             }
  105.             // Lookup Object
  106.             return ctx.lookup(fullPath);
  107.         }catch(Exception e){
  108.             throw new UtilsException(e.getMessage(),e);
  109.         }
  110.         finally{
  111.             try{
  112.                 if(ctx!=null)
  113.                     ctx.close();
  114.             }catch(Exception eClose){
  115.                 // close
  116.             }
  117.         }
  118.     }




  123.     /**
  124.      * Elimina la registrazione di un oggetto con nome JNDI <var>fullPath</var> dall'albero JNDI 
  125.      *
  126.      * @param fullPath Nome dell'oggetto da eliminare nell'albero JNDI
  127.      * @return true se l'eliminazione ha successo, false altrimenti
  128.      */
  129.     public boolean unbind(String fullPath) {
  130.         return unbind(fullPath, null, null);
  131.     }
  132.     public boolean unbind(String fullPath,Logger log) {
  133.         return unbind(fullPath, log, null);
  134.     }
  135.     public boolean unbind(String fullPath,Logger log,Logger logConsole) {
  136.         
  137.         if(fullPath!=null && fullPath.startsWith(LOCAL_TREE_JNDI_PREFIX)){
  138.             
  139.             /**System.out.println("-------------------------------- LOCAL UNBIND ["+fullPath+"]");*/
  140.             
  141.             Object o = null;
  142.             SemaphoreLock lock = semaphore.acquireThrowRuntime("unbind");
  143.             try {
  144.                 o = localTreeJNDI.remove(fullPath);
  145.             }finally {
  146.                 semaphore.release(lock, "unbind");
  147.             }
  148.             String msg = "LocalResource ["+fullPath+"] not found";
  149.             if(log!=null)
  150.                 log.warn(msg);
  151.             if(logConsole!=null)
  152.                 logConsole.warn(msg);
  153.             return o!=null;
  154.             
  155.         }
  156.         
  157.         Context currentContext = null;
  158.         try{
  159.             currentContext = new InitialContext() ;
  160.             final String name = currentContext.composeName(fullPath,currentContext.getNameInNamespace() ) ;
  161.             if(log!=null) {
  162.                 String msg = "Unbind  fullname " + name;
  163.                 log.debug(msg) ;
  164.             }
  165.             try{
  166.                 currentContext.unbind( name ) ;
  167.                 /**System.out.println( "eraser" ) ;*/
  168.             }catch( final NameNotFoundException ignored ){
  169.                 if(log!=null)
  170.                     log.error( "Errore durante l'unbind (Ignored) ["+ignored+"]",ignored);
  171.                 if(logConsole!=null)
  172.                     logConsole.error( "Errore durante l'unbind (Ignored) ["+ignored+"]",ignored);
  173.                 return false;       

  175.             }
  176.             //          L'unbind fatto in questa maniera ricerca il componente sulla "root" dell albero
  177.             //          non sul corretto sottoalbero come dovrebbe
  178.             //          
  179.             /**         final String[] components = name.split( "/" ) ;
  180.             //          for( int ix = components.length-1 ; ix >=0 ; ix-- ){
  181.             //              final String nextPath = components[ix] ;
  182.             //              log.debug( "Unbind  component \"" + nextPath + "\" in context " + currentContext ) ;
  183.             //              try{
  184.             //                  currentContext.unbind( nextPath ) ;
  185.             //                  //System.out.println( "eraser" ) ;
  186.             //              }catch( final NameNotFoundException ignored ){
  187.             //                  log.error( "Errore durante l'unbind (Ignored) ["+ignored+"]",ignored);
  188.             //                  logConsole.error( "Errore durante l'unbind (Ignored) ["+ignored+"]",ignored);
  189.             //                  return false;       
  190.             //                  
  191.             //              }
  192.             //          }*/
  193.             return true;

  195.         }catch(Exception e){
  196.             if(log!=null)
  197.                 log.error( "Errore durante l'unbind ["+e+"]",e);
  198.             if(logConsole!=null)
  199.                 logConsole.error( "Errore durante l'unbind ["+e+"]",e);
  200.             return false;
  201.         }finally{
  202.             try{
  203.                 if(currentContext!=null)
  204.                     currentContext.close();
  205.             }catch(Exception eClose){
  206.                 // close
  207.             }
  208.         }
  209.     }


  212.     /**
  213.      * Effettua la registrazione di un oggetto con nome JNDI <var>fullPath</var> nell'albero JNDI 
  214.      *
  215.      * @param fullPath Nome dell'oggetto da registrare nell'albero JNDI
  216.      * @return true se l'eliminazione ha successo, false altrimenti
  217.      */
  218.     public boolean bind(String fullPath,Object toBind) {
  219.         return bind(fullPath, toBind, null, null);
  220.     }
  221.     public boolean bind(String fullPath,Object toBind,Logger log) {
  222.         return bind(fullPath, toBind, log, null);
  223.     }
  224.     public boolean bind(String fullPath,Object toBind,Logger log,Logger logConsole) {
  225.         
  226.         if(fullPath!=null && fullPath.startsWith(LOCAL_TREE_JNDI_PREFIX)){
  227.             
  228.             /**System.out.println("-------------------------------- LOCAL BIND ["+fullPath+"]");*/
  229.             
  230.             SemaphoreLock lock = semaphore.acquireThrowRuntime("bind");
  231.             try {
  232.                 
  233.                 if(localTreeJNDI.containsKey(fullPath)){
  234.                     String msg = "LocalResource ["+fullPath+"] already exists";
  235.                     if(log!=null)
  236.                         log.warn(msg);
  237.                     if(logConsole!=null)
  238.                         logConsole.warn(msg);
  239.                     return false;
  240.                 }
  241.                 
  242.                 localTreeJNDI.put(fullPath, toBind);
  243.                 return true;
  244.             }finally {
  245.                 semaphore.release(lock, "bind");
  246.             }
  247.             
  248.         }
  249.         
  250.         
  251.         Context currentContext = null;
  252.         try{

  254.             /**System.out.println("Attempting to bind object " + toBind + " to context path \"" + fullPath + "\"" ) ;*/

  256.             currentContext = new InitialContext() ;
  257.             final String name = currentContext.composeName(fullPath,currentContext.getNameInNamespace() ) ;
  258.             final String[] components = name.split( "/" ) ;

  260.             // the last item in the array refers to the object itself.
  261.             // we don't want to create a (sub)Context for that; we
  262.             // want to bind the object to it
  263.             final int stop = components.length - 1 ;        
  264.             for( int ix = 0 ; ix < stop ; ++ix ){
  265.                 final String nextPath = components[ix] ;
  266.                 /**System.out.println( "Looking up subcontext named \"" + nextPath + "\" in context " + currentContext ) ;*/
  267.                 try{
  268.                     currentContext = (Context) currentContext.lookup( nextPath ) ;
  269.                     /**System.out.println( "found" ) ;*/
  270.                 }catch( final NameNotFoundException ignored ){
  271.                     /**System.out.println( "not found; creating subcontext" ) ;*/
  272.                     currentContext = currentContext.createSubcontext( nextPath ) ;
  273.                     /**System.out.println( "done" ) ;*/             
  274.                 }   
  275.             }

  277.             // by this point, we've built up the entire context path leading up
  278.             // to the desired bind point... so we can bind the object itself
  279.             currentContext.bind( components[stop] , toBind ) ;
  280.             String msg = "binding ["+fullPath+"] to " + currentContext;
  281.             if(log!=null)
  282.                 log.info(msg) ;
  283.             if(logConsole!=null)
  284.                 logConsole.info(msg) ;

  286.             return true;

  288.         }catch(Exception e){
  289.             if(log!=null)
  290.                 log.error( "Errore durante il bind ["+e+"]",e);
  291.             if(logConsole!=null)
  292.                 logConsole.error( "Errore durante il bind ["+e+"]",e);
  293.             return false;
  294.         }   finally{
  295.             try{
  296.                 if(currentContext!=null)
  297.                     currentContext.close();
  298.             }catch(Exception eClose){
  299.                 // close
  300.             }
  301.         }
  302.     } 

  304. }




Created with JaCoCo 0.8.8.202204050719