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


  22. package org.openspcoop2.utils.properties;

  24. import java.lang.reflect.Method;
  25. import java.util.ArrayList;
  26. import java.util.Collections;
  27. import java.util.Enumeration;
  28. import java.util.List;
  29. import java.util.Properties;
  30. import java.util.concurrent.ConcurrentMap;

  32. import org.slf4j.Logger;
  33. import org.openspcoop2.utils.LoggerWrapperFactory;
  34. import org.openspcoop2.utils.Utilities;
  35. import org.openspcoop2.utils.UtilsException;



  39. /**
  40. * InstanceProperties
  41. *
  42. * @author Andrea Poli (apoli@link.it)
  43. * @author $Author$
  44. * @version $Rev$, $Date$
  45. */

  47. public abstract class InstanceProperties {

  49.     private PropertiesReader propertiesOriginale;
  50.     private CollectionProperties propertiesRidefinitoFile;
  51.     private PropertiesReader propertiesRidefinitoObject;
  52.     protected Logger log;
  53.     private String openspcoop2LocalHome;
  54.     private boolean readCallsNotSynchronized;
  55.     
  56.     protected InstanceProperties(String openspcoop2LocalHome,Properties propertiesOriginale,Logger log) {
  57.         this(openspcoop2LocalHome, propertiesOriginale, log, true);
  58.     }
  59.     protected InstanceProperties(String openspcoop2LocalHome,Properties propertiesOriginale,Logger log, boolean readCallsNotSynchronized) {
  60.         this.propertiesOriginale = new PropertiesReader(propertiesOriginale,readCallsNotSynchronized);
  61.         this.log = log;
  62.         if(this.log==null){
  63.             this.log = LoggerWrapperFactory.getLogger(InstanceProperties.class);
  64.         }
  65.         this.openspcoop2LocalHome = openspcoop2LocalHome;
  66.         this.readCallsNotSynchronized = readCallsNotSynchronized;
  67.     }
  68.     
  69.     private void logError(String msg, Exception e) {
  70.         this.log.error(msg, e);
  71.     }
  72.     
  73.     public void setLocalFileImplementation(String variable,String path,String confDirectory){
  74.         CollectionProperties prop = PropertiesUtilities.searchLocalImplementation(this.openspcoop2LocalHome,this.log, variable, path, confDirectory, this.readCallsNotSynchronized);
  75.         if(prop!=null)
  76.             this.propertiesRidefinitoFile = prop;
  77.     }
  78.     
  79.     public void setLocalFileImplementation(CollectionProperties prop){
  80.         this.propertiesRidefinitoFile = prop;
  81.     }
  82.     
  83.     public void setLocalObjectImplementation(Properties prop){
  84.         this.propertiesRidefinitoObject = new PropertiesReader(prop,this.readCallsNotSynchronized);
  85.     }
  86.     
  87.     // RIDEFINIZIONE METODI PROPERTIES READER
  88.     
  89.     public String getValue(String key) throws UtilsException{
  90.         return getValueEngine(key, false);
  91.     }
  92.         
  93.     public String getValueConvertEnvProperties(String key)throws UtilsException{
  94.         return getValueEngine(key, true);
  95.     }
  96.         
  97.     public java.util.Properties readProperties (String prefix)throws UtilsException{
  98.         return readPropertiesEngine(prefix, false);
  99.     }
  100.     
  101.     public java.util.Properties readPropertiesConvertEnvProperties (String prefix)throws UtilsException{
  102.         return readPropertiesEngine(prefix, true);
  103.     }
  104.     
  105.     public ConcurrentMap<String, String> readPropertiesAsConcurrentHashMap (String prefix)throws UtilsException{
  106.         return Utilities.convertToConcurrentHashMap(readProperties(prefix));
  107.     }
  108.     
  109.     public ConcurrentMap<String, String> readPropertiesAsConcurrentHashMapConvertEnvProperties (String prefix)throws UtilsException{
  110.         return Utilities.convertToConcurrentHashMap(readPropertiesConvertEnvProperties(prefix));
  111.     }
  112.     
  113.     public java.util.Map<String, String> readPropertiesAsHashMap (String prefix)throws UtilsException{
  114.         return Utilities.convertToHashMap(readProperties(prefix));
  115.     }
  116.     
  117.     public java.util.Map<String, String> readPropertiesAsHashMapConvertEnvProperties (String prefix)throws UtilsException{
  118.         return Utilities.convertToHashMap(readPropertiesConvertEnvProperties(prefix));
  119.     }
  120.     
  121.     public String convertEnvProperties(String value)throws UtilsException{
  122.         return this.propertiesOriginale.convertEnvProperties(value);
  123.     }
  124.     
  125.     public java.util.Enumeration<String> propertyNames(){
  126.         
  127.         java.util.Enumeration<?> enumProp = this.propertiesOriginale.propertyNames();
  128.         List<String> object = new ArrayList<>();
  129.         while(enumProp.hasMoreElements()){
  130.             object.add((String)enumProp.nextElement());     
  131.         }
  132.         
  133.         if(this.propertiesRidefinitoFile!=null){
  134.             java.util.Enumeration<?> enumPropRidefinito = this.propertiesRidefinitoFile.propertyNames();
  135.             while(enumPropRidefinito!=null && enumPropRidefinito.hasMoreElements()){
  136.                 String ridefinito = (String)enumPropRidefinito.nextElement();
  137.                 if(!object.contains(ridefinito)){
  138.                     object.add(ridefinito);     
  139.                 }
  140.             }
  141.         }
  142.         
  143.         if(this.propertiesRidefinitoObject!=null){
  144.             java.util.Enumeration<?> enumPropRidefinito = this.propertiesRidefinitoObject.propertyNames();
  145.             while(enumPropRidefinito!=null && enumPropRidefinito.hasMoreElements()){
  146.                 String ridefinito = (String)enumPropRidefinito.nextElement();
  147.                 if(!object.contains(ridefinito)){
  148.                     object.add(ridefinito);     
  149.                 }
  150.             }
  151.         }
  152.         
  153.         return Collections.enumeration(object);
  154.     }


  157.     
  158.     
  159.     
  160.     
  161.     /* ------------ UTILITY INTERNE ----------------- */
  162.     private String getValueEngine(String key,boolean convertEnvProperties) throws UtilsException{
  163.         
  164.         // NOTA: La logica di append "+," vale solo rispetto agli elementi PropertiesOriginale, CollectionProperties, PropertiesObject
  165.         //       Mentre il valore indicato per una proprietà dei files locali all'interno del CollectionProperties non va in append, ma viene utilizzato solamente il primo incontrato (che poi sarà utilizzato per come valore del 2. File).
  166.                 
  167.         try{
  168.                     
  169.             // 1. Object
  170.             String [] addObject = null;
  171.             boolean appendObject = false;
  172.             String tmpObject = null;
  173.             if(this.propertiesRidefinitoObject!=null){
  174.                 if(convertEnvProperties){
  175.                     tmpObject = this.propertiesRidefinitoObject.getValue_convertEnvProperties(key);
  176.                 }else{
  177.                     tmpObject = this.propertiesRidefinitoObject.getValue(key);
  178.                 }
  179.             }
  180.             if(tmpObject!=null){
  181.                 tmpObject = tmpObject.trim();
  182.                 String add = null;
  183.                 if(tmpObject.startsWith("+")){
  184.                     appendObject = true;
  185.                     add = tmpObject.substring(1);
  186.                     add = add.trim();
  187.                 }
  188.                 if(add!=null){
  189.                     if(add.startsWith(",") && add.length()>1){
  190.                         addObject = add.substring(1).split(",");
  191.                         if(addObject!=null && addObject.length>0){
  192.                             for (int i = 0; i < addObject.length; i++) {
  193.                                 addObject[i] = addObject[i].trim();
  194.                             }
  195.                         }else{
  196.                             // valore strano, lo ritorno
  197.                             addObject = new String[1];
  198.                             addObject[0] = tmpObject;
  199.                         }
  200.                     }
  201.                 }else{
  202.                     addObject = new String[1];
  203.                     addObject[0] = tmpObject;
  204.                 }
  205.             }
  206.             
  207.             
  208.             // 2. File
  209.             String [] addFile = null;
  210.             boolean appendFile = false;
  211.             String tmpFile = null;
  212.             if(this.propertiesRidefinitoFile!=null){
  213.                 if(convertEnvProperties){
  214.                     tmpFile = this.propertiesRidefinitoFile.getValue_convertEnvProperties(key);
  215.                 }else{
  216.                     tmpFile = this.propertiesRidefinitoFile.getValue(key);
  217.                 }
  218.             }
  219.             if(tmpFile!=null){
  220.                 tmpFile = tmpFile.trim();
  221.                 String add = null;
  222.                 if(tmpFile.startsWith("+")){
  223.                     appendFile = true;
  224.                     add = tmpFile.substring(1);
  225.                     add = add.trim();
  226.                 }
  227.                 if(add!=null){
  228.                     if(add.startsWith(",") && add.length()>1){
  229.                         addFile = add.substring(1).split(",");
  230.                         if(addFile!=null && addFile.length>0){
  231.                             for (int i = 0; i < addFile.length; i++) {
  232.                                 addFile[i] = addFile[i].trim();
  233.                             }
  234.                         }else{
  235.                             // valore strano, lo ritorno
  236.                             addFile = new String[1];
  237.                             addFile[0] = tmpFile;
  238.                         }
  239.                     }
  240.                 }else{
  241.                     addFile = new String[1];
  242.                     addFile[0] = tmpFile;
  243.                 }
  244.             }
  245.             
  246.             
  247.             // 3. Originale
  248.             String tmp = null;
  249.             if(tmp==null){
  250.                 if(convertEnvProperties){
  251.                     tmp = this.propertiesOriginale.getValue_convertEnvProperties(key);
  252.                 }else{
  253.                     tmp = this.propertiesOriginale.getValue(key);
  254.                 }
  255.             }
  256.             
  257.             
  258.             // 4. Gestione valore ritornato
  259.             if(addObject==null && addFile==null){
  260.                 return tmp;
  261.             }
  262.             if(!appendObject && !appendFile){
  263.                 // Tecnica append non utilizzato
  264.                 // Ritorno il primo valore disponibile rispetto all'ordine
  265.                 if(addObject!=null){
  266.                     return addObject[0];
  267.                 }
  268.                 else if(addFile!=null){
  269.                     return addFile[0];
  270.                 }
  271.                 else{
  272.                     return tmp;
  273.                 }
  274.             }
  275.             
  276.             
  277.             // 5. Se sono state fornite proprieta' con il + le gestisco.
  278.             // In caso di valori uguali utilizzo quelli dell'object, poi quelli del file e infine quelli dell'originale
  279.             StringBuilder bf = new StringBuilder();
  280.             List<String> valoriAggiunti = new ArrayList<>();
  281.             if(addObject!=null){
  282.                 for (int i = 0; i < addObject.length; i++) {
  283.                     if(!valoriAggiunti.contains(addObject[i])){
  284.                         if(bf.length()>0){
  285.                             bf.append(",");
  286.                         }
  287.                         bf.append(addObject[i]);
  288.                         valoriAggiunti.add(addObject[i]);
  289.                     }
  290.                 }
  291.             }
  292.             if(addFile!=null){
  293.                 for (int i = 0; i < addFile.length; i++) {
  294.                     if(!valoriAggiunti.contains(addFile[i])){
  295.                         if(bf.length()>0){
  296.                             bf.append(",");
  297.                         }
  298.                         bf.append(addFile[i]);
  299.                         valoriAggiunti.add(addFile[i]);
  300.                     }
  301.                 }
  302.             }
  303.             if(tmp!=null &&
  304.                 !valoriAggiunti.contains(tmp)){
  305.                 if(bf.length()>0){
  306.                     bf.append(",");
  307.                 }
  308.                 bf.append(tmp);
  309.                 valoriAggiunti.add(tmp);
  310.             }
  311.             
  312.             return bf.toString();
  313.             
  314.         }catch(Exception e){
  315.             this.logError("Errore durante la lettura della proprieta' ["+key+"]("+convertEnvProperties+")",e);
  316.             throw new UtilsException(e.getMessage(),e);
  317.         }
  318.         
  319.     }
  320.     
  321.     private java.util.Properties readPropertiesEngine(String prefix,boolean convertEnvProperties)throws UtilsException{
  322.         
  323.         java.util.Properties tmp = null;
  324.         try{
  325.         
  326.             if(convertEnvProperties){
  327.                 tmp = this.propertiesOriginale.readProperties_convertEnvProperties(prefix);
  328.             }else{
  329.                 tmp = this.propertiesOriginale.readProperties(prefix);
  330.             }
  331.             
  332.             if(this.propertiesRidefinitoFile!=null){
  333.                 java.util.Properties tmp2 = null;
  334.                 if(convertEnvProperties){
  335.                     tmp2 = this.propertiesRidefinitoFile.readProperties_convertEnvProperties(prefix);
  336.                 }else{
  337.                     tmp2 = this.propertiesRidefinitoFile.readProperties(prefix);
  338.                 }
  339.                 if(tmp2!=null){
  340.                     Enumeration<?> keys = tmp2.keys();
  341.                     while (keys.hasMoreElements()) {
  342.                         String key = (String) keys.nextElement();
  343.                         if(tmp.containsKey(key)){
  344.                             tmp.remove(key);
  345.                         }
  346.                         tmp.put(key, tmp2.get(key));
  347.                     }
  348.                 }
  349.             }
  350.             
  351.             if(this.propertiesRidefinitoObject!=null){
  352.                 java.util.Properties tmp3 = null;
  353.                 if(convertEnvProperties){
  354.                     tmp3 = this.propertiesRidefinitoObject.readProperties_convertEnvProperties(prefix);
  355.                 }else{
  356.                     tmp3 = this.propertiesRidefinitoObject.readProperties(prefix);
  357.                 }
  358.                 if(tmp3!=null){
  359.                     Enumeration<?> keys = tmp3.keys();
  360.                     while (keys.hasMoreElements()) {
  361.                         String key = (String) keys.nextElement();
  362.                         if(tmp.containsKey(key)){
  363.                             tmp.remove(key);
  364.                         }
  365.                         tmp.put(key, tmp3.get(key));
  366.                     }
  367.                 }
  368.             }
  369.             
  370.         }catch(Exception e){
  371.             this.logError("Errore durante la lettura delle proprieta' con prefix ["+prefix+"]("+convertEnvProperties+")",e);
  372.             throw new UtilsException(e.getMessage(),e);
  373.         }
  374.         
  375.         return tmp;
  376.     }
  377.     
  378.     
  379.     public static String readConfDirFromGovWayProperties() {
  380.         try {
  381.             Class<?> cOp2Props = Class.forName("org.openspcoop2.pdd.config.OpenSPCoop2Properties");
  382.             Method cOp2PropsMethodGetInstance = cOp2Props.getMethod("getInstance");
  383.             Object op2Props = cOp2PropsMethodGetInstance.invoke(null);
  384.             if(op2Props!=null) {
  385.                 Method rootDirMethod = op2Props.getClass().getMethod("getRootDirectory");
  386.                 Object rootDir = rootDirMethod.invoke(op2Props);
  387.                 if(rootDir instanceof String) {
  388.                     return (String) rootDir;
  389.                 }
  390.             }
  391.         }catch(Exception t) {
  392.             // ignore
  393.         }
  394.         return null;
  395.     }
  396.     
  397. }
Created with JaCoCo 0.8.8.202204050719