PropertiesUtilities.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.io.File;
  25. import java.io.FileInputStream;
  26. import java.io.InputStream;
  27. import java.util.ArrayList;
  28. import java.util.List;
  29. import java.util.Properties;
  30. import java.util.Scanner;

  32. import org.openspcoop2.utils.Costanti;
  33. import org.openspcoop2.utils.SortedMap;
  34. import org.openspcoop2.utils.UtilsException;
  35. import org.slf4j.Logger;


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

  46. public class PropertiesUtilities {

  48.     /*
  49.      * // RICERCA
  50.         // 1. VARIABILE DI SISTEMA che identifica il singolo file di properties (es. OPENSPCOOP_PROPERTIES o OPENSPCOOP_LOGGER_PROPERTIES)
  51.         // 2. PROPRIETA' JAVA che identifica il singolo file di properties (es. OPENSPCOOP_PROPERTIES o OPENSPCOOP_LOGGER_PROPERTIES)
  52.         // 3. VARIABILE DI SISTEMA: OPENSPCOOP_HOME dove deve essere specificata una directory in cui verra' cercato il file path
  53.         // 4. PROPRIETA' JAVA (es. ApplicationServer o Java con -D): OPENSPCOOP_HOME dove deve essere specificata una directory in cui verra' cercato il file path
  54.         // 5. CLASSPATH con nome path
  55.         // 6. (DIRECTORY DI CONFIGURAZIONE)/path
  56.     */
  57.     public static CollectionProperties searchLocalImplementation(String OPENSPCOOP2_LOCAL_HOME, Logger log,String variabile,String path,String confDirectory){  
  58.         return searchLocalImplementation(OPENSPCOOP2_LOCAL_HOME, log, variabile, path, confDirectory, true);
  59.     }
  60.     public static CollectionProperties searchLocalImplementation(String OPENSPCOOP2_LOCAL_HOME, Logger log,String variabile,String path,String confDirectory,boolean readCallsNotSynchronized){ 
  61.         
  62.         CollectionProperties cp = new CollectionProperties();
  63.         
  64.         String envP = System.getenv(Costanti.OPENSPCOOP2_FORCE_CONFIG_FILE);
  65.         if(envP!=null && "true".equalsIgnoreCase(envP)) {
  66.             cp.setForceConfigDir(true);
  67.         }
  68.         else {
  69.             String javaP = System.getProperty(Costanti.OPENSPCOOP2_FORCE_CONFIG_FILE);
  70.             if(javaP!=null && "true".equalsIgnoreCase(javaP)) {
  71.                 cp.setForceConfigDir(true);
  72.             }
  73.         }
  74.         
  75.         
  76.         Properties p1 = PropertiesUtilities.examineStep1(log,variabile);
  77.         if(p1!=null){
  78.             cp.setSystemVariable(new PropertiesReader(p1,readCallsNotSynchronized));
  79.         }
  80.         
  81.         Properties p2 = PropertiesUtilities.examineStep2(log,variabile);
  82.         if(p2!=null){
  83.             cp.setJavaVariable(new PropertiesReader(p2,readCallsNotSynchronized));
  84.         }
  85.         
  86.         Properties p3 = PropertiesUtilities.examineStep3(OPENSPCOOP2_LOCAL_HOME,log,path);
  87.         if(p3!=null){
  88.             cp.setSystemOpenSPCoopHome(new PropertiesReader(p3,readCallsNotSynchronized));
  89.         }
  90.         
  91.         Properties p4 = PropertiesUtilities.examineStep4(OPENSPCOOP2_LOCAL_HOME,log,path);
  92.         if(p4!=null){
  93.             cp.setJavaOpenSPCoopHome(new PropertiesReader(p4,readCallsNotSynchronized));
  94.         }
  95.             
  96.         Properties p5 = PropertiesUtilities.examineStep5(log,path);
  97.         if(p5!=null){
  98.             cp.setClasspath(new PropertiesReader(p5,readCallsNotSynchronized));
  99.         }
  100.                 
  101.         File fConfDirectory = null;
  102.         if(confDirectory!=null){
  103.             fConfDirectory = new File(confDirectory);
  104.         }
  105.         if(fConfDirectory!=null && fConfDirectory.exists() && fConfDirectory.isDirectory() ){
  106.             Properties p6 = PropertiesUtilities.examineStep6(log,path,fConfDirectory);
  107.             if(p6!=null){
  108.                 cp.setConfigDir(new PropertiesReader(p6,readCallsNotSynchronized));
  109.             }
  110.         }
  111.             
  112.         return cp;
  113.     }
  114.     
  115.     private static Properties examineStep1(Logger log,String variabile){
  116.         /*
  117.         System.out.println("--------- ENV --------------");
  118.         java.util.Map<String, String> env = System.getenv();
  119.         for (java.util.Iterator<String> iterator = env.keySet().iterator(); iterator.hasNext();) {
  120.             String key = (String) iterator.next();
  121.             System.out.println("\t["+key+"]=["+env.get(key)+"]");           
  122.         }
  123.         System.out.println("--------- ENV --------------");
  124.         */
  125.         String file = System.getenv(variabile);
  126.         String subject =  "Variabile di sistema "+variabile;
  127.         if(file!=null){
  128.             File ffile = new File(file);
  129.             if(ffile.exists()==false){
  130.                 log.error("["+subject+"] File non esistente: "+ffile.getAbsolutePath());
  131.                 return null;
  132.             }
  133.             if(ffile.canRead()==false){
  134.                 log.error("["+subject+"] File non accessibile: "+ffile.getAbsolutePath());
  135.                 return null;
  136.             }
  137.             InputStream is = null;
  138.             try{
  139.                 is = new FileInputStream(ffile);
  140.                 return PropertiesUtilities.getPropertiesReader(log,is,subject);
  141.             }catch(java.io.IOException e) {
  142.                 log.error("["+subject+"] file di properties non utilizzabile: "+e.getMessage(),e);
  143.             }finally{
  144.                 try{
  145.                     if(is!=null) {
  146.                         is.close();
  147.                     }
  148.                 }catch(Exception eClose){
  149.                     // close
  150.                 }
  151.             }
  152.         }
  153.         return null;
  154.     }
  155.     
  156.     private static Properties examineStep2(Logger log,String variabile){
  157.         /*
  158.         System.out.println("--------- ENV --------------");
  159.         java.util.Map<String, String> env = System.getenv();
  160.         for (java.util.Iterator<String> iterator = env.keySet().iterator(); iterator.hasNext();) {
  161.             String key = (String) iterator.next();
  162.             System.out.println("\t["+key+"]=["+env.get(key)+"]");           
  163.         }
  164.         System.out.println("--------- ENV --------------");
  165.         */
  166.         String file = System.getProperty(variabile);
  167.         String subject =  "Proprieta' di sistema "+variabile;
  168.         if(file!=null){
  169.             File ffile = new File(file);
  170.             if(ffile.exists()==false){
  171.                 log.error("["+subject+"] File non esistente: "+ffile.getAbsolutePath());
  172.                 return null;
  173.             }
  174.             if(ffile.canRead()==false){
  175.                 log.error("["+subject+"] File non accessibile: "+ffile.getAbsolutePath());
  176.                 return null;
  177.             }
  178.             InputStream is = null;
  179.             try{
  180.                 is = new FileInputStream(ffile);
  181.                 return PropertiesUtilities.getPropertiesReader(log,is,subject);
  182.             }catch(java.io.IOException e) {
  183.                 log.error("["+subject+"] file di properties non utilizzabile: "+e.getMessage(),e);
  184.             }finally{
  185.                 try{
  186.                     if(is!=null) {
  187.                         is.close();
  188.                     }
  189.                 }catch(Exception eClose){
  190.                     // close
  191.                 }
  192.             }
  193.         }
  194.         return null;
  195.     }
  196.     
  197.     private static Properties examineStep3(String OPENSPCOOP2_LOCAL_HOME,Logger log,String path){
  198.         /*
  199.         System.out.println("--------- ENV --------------");
  200.         java.util.Map<String, String> env = System.getenv();
  201.         for (java.util.Iterator<String> iterator = env.keySet().iterator(); iterator.hasNext();) {
  202.             String key = (String) iterator.next();
  203.             System.out.println("\t["+key+"]=["+env.get(key)+"]");           
  204.         }
  205.         System.out.println("--------- ENV --------------");
  206.         */
  207.         String dir = System.getenv(OPENSPCOOP2_LOCAL_HOME);
  208.         String subject =  "Variabile di sistema "+OPENSPCOOP2_LOCAL_HOME;
  209.         if(dir!=null){
  210.             File fDir = new File(dir);
  211.             if(fDir.exists()==false){
  212.                 log.error("["+subject+"] Directory non esistente: "+fDir.getAbsolutePath());
  213.                 return null;
  214.             }
  215.             if(fDir.canRead()==false){
  216.                 log.error("["+subject+"] Directory non accessibile: "+fDir.getAbsolutePath());
  217.                 return null;
  218.             }
  219.             return PropertiesUtilities.getPropertiesReader(log,fDir.getAbsolutePath()+File.separatorChar+path,subject);
  220.         }
  221.         return null;
  222.     }
  223.     
  224.     private static Properties examineStep4(String OPENSPCOOP2_LOCAL_HOME,Logger log,String path){
  225.         /*  
  226.         System.out.println("--------- PROPERTIES --------------");
  227.         java.util.Properties properties = System.getProperties();
  228.         java.util.Enumeration<?> enumProperties = properties.keys();
  229.         while (enumProperties.hasMoreElements()) {
  230.             Object object = (Object) enumProperties.nextElement();
  231.             System.out.println("\t["+object+"]=["+properties.get(object)+"]");          
  232.         }
  233.         System.out.println("--------- PROPERTIES --------------");
  234.         */
  235.         String dir = System.getProperty(OPENSPCOOP2_LOCAL_HOME);
  236.         String subject =  "Proprieta' di sistema "+OPENSPCOOP2_LOCAL_HOME;
  237.         if(dir!=null){
  238.             File fDir = new File(dir);
  239.             if(fDir.exists()==false){
  240.                 log.error("["+subject+"] Directory non esistente: "+fDir.getAbsolutePath());
  241.                 return null;
  242.             }
  243.             if(fDir.canRead()==false){
  244.                 log.error("["+subject+"] Directory non accessibile: "+fDir.getAbsolutePath());
  245.                 return null;
  246.             }
  247.             return PropertiesUtilities.getPropertiesReader(log,fDir.getAbsolutePath()+File.separatorChar+path,subject);
  248.         }
  249.         return null;
  250.     }
  251.     
  252.     private static Properties examineStep5(Logger log,String path){
  253.         return PropertiesUtilities.getPropertiesReader(log, PropertiesUtilities.class.getResourceAsStream("/"+path), "CLASSPATH: "+path);
  254.     }
  255.     
  256.     private static Properties examineStep6(Logger log,String path,File fConfDirectory){
  257.         File f = new File(fConfDirectory,path);
  258.         if(f.exists()){
  259.             return PropertiesUtilities.getPropertiesReader(log,f.getAbsolutePath(), "CONFIG_DIR_OPENSPCOOP/"+path);
  260.         }
  261.         return null;
  262.     }
  263.     
  264.     private static Properties getPropertiesReader(Logger log,String path,String subject){
  265.         if(path!=null){
  266.             File f = new File(path);
  267.             if(!f.exists()){
  268.                 // NON DEVO SEGNALARE L'ERRORE log.error("["+subject+"] file di properties non esistente: "+f.getAbsolutePath());
  269.                 return null;
  270.             }
  271.             if(!f.canRead()){
  272.                 log.error("["+subject+"] file di properties non accessibile: "+f.getAbsolutePath());
  273.                 return null;
  274.             }
  275.             InputStream is = null;
  276.             try{
  277.                 is = new FileInputStream(f);
  278.                 return PropertiesUtilities.getPropertiesReader(log,is,subject);
  279.             }catch(java.io.IOException e) {
  280.                 log.error("["+subject+"] file di properties non utilizzabile: "+e.getMessage(),e);
  281.             }finally{
  282.                 try{
  283.                     if(is!=null) {
  284.                         is.close();
  285.                     }
  286.                 }catch(Exception eClose){
  287.                     // close
  288.                 }
  289.             }
  290.         }
  291.         return null;
  292.     }
  293.     private static Properties getPropertiesReader(Logger log,InputStream is,String subject){
  294.         if(is!=null){
  295.             Properties propertiesReader = null;
  296.             try{  
  297.                 propertiesReader = new Properties();
  298.                 propertiesReader.load(is);
  299.             }catch(java.io.IOException e) {
  300.                 propertiesReader = null;
  301.                 log.error("["+subject+"] file di properties non utilizzabile: "+e.getMessage(),e);
  302.             }finally{
  303.                 try{
  304.                     if(is!=null) {
  305.                         is.close();
  306.                     }
  307.                 }catch(Exception eClose){
  308.                     // close
  309.                 }
  310.             }
  311.                 
  312.             if(propertiesReader!=null){
  313.                 return propertiesReader;
  314.             }
  315.             return null;
  316.         }
  317.         return null;
  318.     }

  320.     
  321.     
  322.     public static Properties convertTextToProperties(String text) {
  323.         Scanner scanner = new Scanner(text);
  324.         Properties properties = new Properties();
  325.         try {
  326.             while (scanner.hasNextLine()) {
  327.                 String line = scanner.nextLine();
  328.                 if(line==null || line.trim().equals("")) {
  329.                     continue;
  330.                 }
  331.                 line = line.trim();
  332.                 if(line!=null && line.startsWith("#")) {
  333.                     continue;
  334.                 }
  335.                 if(line!=null && line.contains("=") && !line.startsWith("=")) {
  336.                     String key = line.split("=")[0];
  337.                     key = key.trim();
  338.                     int valueIndex = line.indexOf("=");
  339.                     String value = "";
  340.                     if(valueIndex<line.length()) {
  341.                         value = line.substring(valueIndex+1);
  342.                         value = value.trim();
  343.                     }
  344.                     properties.put(key, value);
  345.                 }
  346.             }
  347.         }finally {
  348.             scanner.close();
  349.         }
  350.         return properties;
  351.     }
  352.     
  353.     private static String EMPTY_COMMENT_VALUE = " "; // non uso "" senno su oracle non viene serializzato essendo null
  354.     private static String KEY_COMMENT_UNIQUE = "#C_ID#_";
  355.     private static String getKeyComment(int index) {
  356.         return KEY_COMMENT_UNIQUE.replace("ID", index+"");
  357.     }
  358.     private static String removeKeyComment(String keyComment, int index) {
  359.         String prefix = KEY_COMMENT_UNIQUE.replace("ID", index+"");
  360.         return keyComment.replace(prefix,"");
  361.     }
  362.     public static SortedMap<String> convertTextToSortedMap(String text) throws UtilsException {
  363.         return convertTextToSortedMap(text, false);
  364.     }
  365.     @SuppressWarnings("unchecked")
  366.     public static SortedMap<String> convertTextToSortedMap(String text, boolean addCommentAsEntry) throws UtilsException {
  367.         return (SortedMap<String>) _convertTextToSortedMap(text, addCommentAsEntry, false);
  368.     }
  369.     public static SortedMap<List<String>> convertTextToSortedListMap(String text) throws UtilsException {
  370.         return convertTextToSortedListMap(text, false);
  371.     }
  372.     @SuppressWarnings("unchecked")
  373.     public static SortedMap<List<String>> convertTextToSortedListMap(String text, boolean addCommentAsEntry) throws UtilsException {
  374.         return (SortedMap<List<String>>) _convertTextToSortedMap(text, addCommentAsEntry, true);
  375.     }
  376.     private static SortedMap<?> _convertTextToSortedMap(String text, boolean addCommentAsEntry, boolean listEnabled) throws UtilsException {
  377.         Scanner scanner = new Scanner(text);
  378.         SortedMap<String> propertiesString = null;
  379.         SortedMap<List<String>> propertiesList = null;
  380.         if(listEnabled) {
  381.             propertiesList = new SortedMap<List<String>>();
  382.         }
  383.         else {
  384.             propertiesString = new SortedMap<String>();
  385.         }
  386.         try {
  387.             int index = 0;
  388.             while (scanner.hasNextLine()) {
  389.                 String line = scanner.nextLine();
  390.                 if(line==null || line.trim().equals("")) {
  391.                     continue;
  392.                 }
  393.                 line = line.trim();
  394.                 if(line.startsWith("#")) {
  395.                     if(addCommentAsEntry) {
  396.                         String key = getKeyComment(index)+line;
  397.                         //System.out.println("ADD COMMENT '"+key+"'");
  398.                         if(listEnabled) {
  399.                             List<String> l = new ArrayList<>();
  400.                             l.add(EMPTY_COMMENT_VALUE);
  401.                             propertiesList.add(key, l);
  402.                         }
  403.                         else {
  404.                             propertiesString.add(key, EMPTY_COMMENT_VALUE);
  405.                         }
  406.                         index++;
  407.                     }
  408.                     continue;
  409.                 }
  410.                 if(line.contains("=")) {
  411.                     String key = line.split("=")[0];
  412.                     key = key.trim();
  413.                     int valueIndex = line.indexOf("=");
  414.                     String value = "";
  415.                     if(valueIndex<line.length()) {
  416.                         value = line.substring(valueIndex+1);
  417.                         value = value.trim();
  418.                     }
  419.                     if(listEnabled) {
  420.                         List<String> l = propertiesList.get(key);
  421.                         if(l==null) {
  422.                             l = new ArrayList<>();
  423.                             propertiesList.add(key, l);
  424.                         }
  425.                         l.add(value);
  426.                     }
  427.                     else {
  428.                         propertiesString.add(key, value);
  429.                     }
  430.                 }
  431.             }
  432.         }finally {
  433.             scanner.close();
  434.         }
  435.         return listEnabled ? propertiesList : propertiesString;
  436.     }
  437.     
  438.     public static String convertSortedMapToText(SortedMap<String> map) throws UtilsException {
  439.         return convertSortedMapToText(map, false);
  440.     }
  441.     public static String convertSortedMapToText(SortedMap<String> map, boolean commentAsEntry) throws UtilsException {
  442.         return _convertSortedMapToText(map, commentAsEntry, false);
  443.     }
  444.     public static String convertSorteListdMapToText(SortedMap<List<String>> map) throws UtilsException {
  445.         return convertSortedListMapToText(map, false);
  446.     }
  447.     public static String convertSortedListMapToText(SortedMap<List<String>> map, boolean commentAsEntry) throws UtilsException {
  448.         return _convertSortedMapToText(map, commentAsEntry, true);
  449.     }
  450.     private static String _convertSortedMapToText(SortedMap<?> map, boolean commentAsEntry, boolean listEnabled) throws UtilsException {
  451.         StringBuilder sb = new StringBuilder();
  452.         if(map!=null && !map.isEmpty()) {
  453.             int index = 0;
  454.             for (String key : map.keys()) {
  455.                 
  456.                 if(key==null) {
  457.                     continue;
  458.                 }
  459.                                 
  460.                 if(key.startsWith("#") && commentAsEntry) {
  461.                     
  462.                     if(sb.length() >0)
  463.                         sb.append("\n");
  464.                     
  465.                     //System.out.println("READ COMMENT '"+key+"'");
  466.                     String keyComment = getKeyComment(index);
  467.                     if(key.startsWith(keyComment)) {
  468.                         String line = removeKeyComment(key, index);
  469.                         //System.out.println("READ ADD COMMENT '"+line+"'");
  470.                         sb.append(line);
  471.                         index++;
  472.                     }
  473.                     else {
  474.                         //System.out.println("READ ADD ORIGINAL '"+key+"'");
  475.                         sb.append(key);
  476.                     }
  477.                     continue;
  478.                 }
  479.                                 
  480.                 if(listEnabled) {
  481.                     @SuppressWarnings("unchecked")
  482.                     List<String> values = (List<String>) map.get(key);
  483.                     if(values!=null && !values.isEmpty()) {
  484.                         for (String value : values) {
  485.                             if(sb.length() >0)
  486.                                 sb.append("\n");
  487.                             sb.append(key).append("=").append(value);
  488.                         }
  489.                     }
  490.                 }else {
  491.                     if(sb.length() >0)
  492.                         sb.append("\n");
  493.                     String value = (String) map.get(key);
  494.                     sb.append(key).append("=").append(value);
  495.                 }
  496.             }   
  497.         }
  498.         return sb.toString();
  499.     }
  500. }
Created with JaCoCo 0.8.8.202204050719