FileSystemUtilities.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.resources;

  24. import java.io.ByteArrayOutputStream;
  25. import java.io.File;
  26. import java.io.FileInputStream;
  27. import java.io.FileNotFoundException;
  28. import java.io.FileOutputStream;
  29. import java.io.IOException;
  30. import java.io.InputStream;
  31. import java.io.OutputStream;
  32. import java.nio.charset.Charset;
  33. import java.nio.file.Files;
  34. import java.nio.file.Path;

  36. import org.openspcoop2.utils.Utilities;
  37. import org.openspcoop2.utils.UtilsException;


  40. /**
  41.  * Classe utilizzabile per raccogliere utility su operazioni effettuate su file system
  42.  *
  43.  * @author Andrea Poli (apoli@link.it)
  44.  * @author $Author$
  45.  * @version $Rev$, $Date$
  46.  */
  47. public class FileSystemUtilities {
  48.     
  49.     private FileSystemUtilities() {}

  51.     public static File createTempFile(String prefix, String suffix) throws IOException{
  52.         Path p = createTempPath(prefix, suffix);
  53.         if(p==null) {
  54.             throw new IOException("Creation failed");
  55.         }
  56.         return p.toFile();
  57.     }
  58.     public static Path createTempPath(String prefix, String suffix) throws IOException{
  59.         return Utilities.createTempPath(prefix, suffix);
  60.     }
  61.     
  62.     public static File createTempFile(File dir, String prefix, String suffix) throws IOException{
  63.         Path p = createTempPath(dir.toPath(), prefix, suffix);
  64.         if(p==null) {
  65.             throw new IOException("Creation failed");
  66.         }
  67.         return p.toFile();
  68.     }
  69.     public static Path createTempPath(Path dir, String prefix, String suffix) throws IOException{
  70.         return Utilities.createTempPath(dir, prefix, suffix);
  71.     }
  72.     
  73.     public static void copy(File in, File out) throws IOException {
  74.         FileSystemUtilities.copy(in.getAbsolutePath(),out.getAbsolutePath());
  75.     }
  76.     public static void copy(String in, String out) 
  77.     throws IOException {
  78.         try(FileInputStream fin = new FileInputStream(in);
  79.             FileOutputStream fout = new FileOutputStream(out);){
  80.             FileSystemUtilities.copy(fin,fout);
  81.             fout.flush();
  82.         }
  83.     }
  84.     public static void copy(InputStream in, OutputStream out) 
  85.     throws IOException {

  87.         byte[] buffer = new byte[256];
  88.         while (true) {
  89.             int bytesRead = in.read(buffer);
  90.             if (bytesRead == -1) break;
  91.             out.write(buffer, 0, bytesRead);
  92.         }

  94.     } 

  96.     public static void copyDirectory(String srcPath, String dstPath)
  97.     throws IOException{
  98.         FileSystemUtilities.copyDirectory(new File(srcPath), new File(dstPath));
  99.     }
  100.     public static void copyDirectory(File srcPath, File dstPath)
  101.     throws IOException{

  103.         if (srcPath.isDirectory()){
  104.             if (!dstPath.exists()){
  105.                 dstPath.mkdir();
  106.             }

  108.             String[] files = srcPath.list();
  109.             if(files!=null) {
  110.                 for(int i = 0; i < files.length; i++){
  111.                         FileSystemUtilities.copyDirectory(new File(srcPath, files[i]), 
  112.                                 new File(dstPath, files[i]));
  113.                 }
  114.             }
  115.         }
  116.         else{
  117.             if(!srcPath.exists()){
  118.                 /** System.out.println("File or directory does not exist."); */
  119.             }
  120.             else {
  121.                 try (InputStream in = new FileInputStream(srcPath);
  122.                     OutputStream out = new FileOutputStream(dstPath);){ 
  123.                     // Transfer bytes from in to out
  124.                     byte[] buf = new byte[1024];
  125.                     int len;
  126.                     while ((len = in.read(buf)) > 0) {
  127.                         out.write(buf, 0, len);
  128.                     }
  129.                     out.flush();
  130.                 }
  131.             }
  132.         }
  133.         /** System.out.println("Directory copied."); */
  134.     }
  135.     
  136.     
  137.     public static String readFile(String f) throws UtilsException, FileNotFoundException{
  138.         return FileSystemUtilities.readFile(new File(f));
  139.     }
  140.     public static String readFile(File f) throws UtilsException, FileNotFoundException{
  141.         return readFileEngine(f, null, null);
  142.     }
  143.     public static String readFile(String f, String charsetName) throws UtilsException, FileNotFoundException{
  144.         return FileSystemUtilities.readFile(new File(f),charsetName);
  145.     }
  146.     public static String readFile(File f, String charsetName) throws UtilsException, FileNotFoundException{
  147.         return readFileEngine(f, charsetName, null);
  148.     }
  149.     public static String readFile(String f, Charset charset) throws UtilsException, FileNotFoundException{
  150.         return FileSystemUtilities.readFile(new File(f), charset);
  151.     }
  152.     public static String readFile(File f, Charset charset) throws UtilsException, FileNotFoundException{
  153.         return readFileEngine(f, null, charset);
  154.     }
  155.     private static String readFileEngine(File f, String charsetName, Charset charset) throws UtilsException, FileNotFoundException{
  156.         try (FileInputStream fis =new FileInputStream(f);
  157.             ByteArrayOutputStream byteInputBuffer = new ByteArrayOutputStream();){
  158.             byte [] readB = new byte[8192];
  159.             int readByte = 0;
  160.             while((readByte = fis.read(readB))!= -1){
  161.                 byteInputBuffer.write(readB,0,readByte);
  162.             }
  163.             byteInputBuffer.flush();
  164.             
  165.             if(charsetName!=null) {
  166.                 return  byteInputBuffer.toString(charsetName);
  167.             }
  168.             else if(charset!=null) {
  169.                 return  byteInputBuffer.toString(charset);
  170.             }
  171.             else {
  172.                 return  byteInputBuffer.toString();
  173.             }
  174.         }
  175.         catch(FileNotFoundException notFound) {
  176.             throw notFound;
  177.         }
  178.         catch(Exception e) {
  179.             throw new UtilsException(e.getMessage(),e);
  180.         }
  181.     }
  182.     
  183.     public static byte[] readBytesFromFile(String f) throws UtilsException, FileNotFoundException{
  184.         return FileSystemUtilities.readBytesFromFile(new File(f));
  185.     }
  186.     public static byte[] readBytesFromFile(File f) throws UtilsException, FileNotFoundException{    
  187.         try (FileInputStream fis =new FileInputStream(f);
  188.             ByteArrayOutputStream byteInputBuffer = new ByteArrayOutputStream();){
  189.             byte [] readB = new byte[8192];
  190.             int readByte = 0;
  191.             while((readByte = fis.read(readB))!= -1){
  192.                 byteInputBuffer.write(readB,0,readByte);
  193.             }
  194.             byteInputBuffer.flush();
  195.             
  196.             return  byteInputBuffer.toByteArray();
  197.         }
  198.         catch(FileNotFoundException notFound) {
  199.             throw notFound;
  200.         }
  201.         catch(Exception e) {
  202.             throw new UtilsException(e.getMessage(),e);
  203.         }
  204.     }
  205.     
  206.     
  207.     public static void writeFile(String f,byte[] contenuto)throws UtilsException{
  208.         FileSystemUtilities.writeFile(new File(f), contenuto);
  209.     }
  210.     public static void writeFile(File f,byte[] contenuto)throws UtilsException{
  211.         try (FileOutputStream fos = new FileOutputStream(f);){
  212.             fos.write(contenuto);
  213.             fos.flush();
  214.         }
  215.         catch(Exception e) {
  216.             throw new UtilsException(e.getMessage(),e);
  217.         }
  218.     }
  219.     public static void writeFile(String f,byte[] ... args)throws UtilsException{
  220.         FileSystemUtilities.writeFile(new File(f), args);
  221.     }
  222.     public static void writeFile(File f,byte[] ... args)throws UtilsException{
  223.         if(args!=null){
  224.             try (FileOutputStream fos = new FileOutputStream(f);){
  225.                 for(int i=0; i<args.length; i++){
  226.                     fos.write(args[i]);
  227.                 }
  228.                 fos.flush();
  229.             }
  230.             catch(Exception e) {
  231.                 throw new UtilsException(e.getMessage(),e);
  232.             }
  233.         }
  234.     }
  235.     
  236.     public static void copyFileAndReplaceAllKeywords(String read,String write,String keyword,String values) throws UtilsException, FileNotFoundException{
  237.         FileSystemUtilities.copyFileAndReplaceAllKeywords(new File(read),new File(write),keyword,values);
  238.     }
  239.     public static void copyFileAndReplaceAllKeywords(File read,File write,String keyword,String values) throws UtilsException, FileNotFoundException{
  240.         String[]k = new String[1];
  241.         k[0] = keyword;
  242.         String[]v = new String[1];
  243.         v[0] = values;
  244.         FileSystemUtilities.copyFileAndReplaceAllKeywords(read, write, k, v);
  245.     }
  246.     public static void copyFileAndReplaceAllKeywords(String read,String write,String[] keyword,String[] values) throws UtilsException, FileNotFoundException{
  247.         FileSystemUtilities.copyFileAndReplaceAllKeywords(new File(read),new File(write),keyword,values);
  248.     }
  249.     public static void copyFileAndReplaceAllKeywords(File read,File write,String[] keyword,String[] values) throws UtilsException, FileNotFoundException{
  250.         String file = FileSystemUtilities.readFile(read);
  251.         for(int i=0; i<keyword.length; i++){
  252.             
  253.             /** System.out.println("FILE ["+file+"] contains ["+keyword[i]+"] (value:"+file.indexOf(keyword[i])+")"); */
  254.             int indexOf = file.indexOf(keyword[i]);
  255.             while(indexOf>=0){
  256.                 /** System.out.println("REPLACE ["+keyword[i]+"] ["+values[i]+"]"); */
  257.                 file = file.replace(keyword[i], values[i]);
  258.                 indexOf = file.indexOf(keyword[i],indexOf+values[i].length());
  259.                 /** System.out.println("INDEX OF ["+indexOf+"]"); */
  260.             }
  261.         }
  262.         FileSystemUtilities.writeFile(write, file.getBytes());
  263.     }
  264.     
  265.     public static void copyFileAndReplaceKeywords(String read,String write,String keyword,String values) throws UtilsException, FileNotFoundException{
  266.         FileSystemUtilities.copyFileAndReplaceKeywords(new File(read),new File(write),keyword,values);
  267.     }
  268.     public static void copyFileAndReplaceKeywords(File read,File write,String keyword,String values) throws UtilsException, FileNotFoundException{
  269.         String[]k = new String[1];
  270.         k[0] = keyword;
  271.         String[]v = new String[1];
  272.         v[0] = values;
  273.         FileSystemUtilities.copyFileAndReplaceKeywords(read, write, k, v);
  274.     }
  275.     
  276.     public static void copyFileAndReplaceKeywords(String read,String write,String[] keyword,String[] values) throws UtilsException, FileNotFoundException{
  277.         FileSystemUtilities.copyFileAndReplaceKeywords(new File(read),new File(write),keyword,values);
  278.     }
  279.     public static void copyFileAndReplaceKeywords(File read,File write,String[] keyword,String[] values) throws UtilsException, FileNotFoundException{
  280.         String file = FileSystemUtilities.readFile(read);
  281.         for(int i=0; i<keyword.length; i++){
  282.             file = file.replace(keyword[i], values[i]);
  283.         }
  284.         FileSystemUtilities.writeFile(write, file.getBytes());
  285.     }


  288.     public static boolean emptyDir(String dir) {
  289.         File d = new File(dir);
  290.         if(!d.exists()){
  291.             return true;
  292.         }
  293.         return FileSystemUtilities.emptyDir(d);
  294.     }
  295.     
  296.     public static boolean emptyDir(File dir) {

  298.         if (dir.isDirectory()) {
  299.             String[] children = dir.list();
  300.             if(children!=null && children.length>0) {
  301.                 for (int i=0; i<children.length; i++) {
  302.                     boolean success = FileSystemUtilities.deleteDir(new File(dir, children[i]));
  303.                     if (!success) {
  304.                         return false;
  305.                     }
  306.                 }
  307.             }
  308.         }
  309.         
  310.         return true;
  311.     }
  312.     
  313.     public static boolean deleteDirNotEmpty(String dir, int maxChilds) {
  314.         return deleteDirNotEmpty(new File(dir), maxChilds);
  315.     }
  316.     public static boolean deleteDirNotEmpty(File dir, int maxChilds) {
  317.         return deleteDirNotEmpty(dir, maxChilds , 0);
  318.     }
  319.     private static boolean deleteDirNotEmpty(File dir, int maxChilds, int level) {
  320.         if (emptyDir(dir)) {
  321.             deleteDir(dir);
  322.             return true;
  323.         }
  324.         else {
  325.             if(maxChilds==level) {
  326.                 return false;
  327.             }
  328.             File [] childs = dir.listFiles();
  329.             if(childs!=null && childs.length>0) {
  330.                 return deleteDirNotEmpty(childs, maxChilds, level);
  331.             }
  332.             return true;
  333.         }
  334.     }
  335.     private static boolean deleteDirNotEmpty(File [] childs, int maxChilds, int level) {
  336.         boolean ok = true;
  337.         for (File file : childs) {
  338.             if(file.isDirectory()) {
  339.                 boolean v = deleteDirNotEmpty(file, maxChilds , level+1);
  340.                 if(!v) {
  341.                     ok = false;
  342.                 }
  343.             }
  344.             else {
  345.                 try {
  346.                     Files.delete(file.toPath());
  347.                 }catch(Exception e) {
  348.                     ok = false;
  349.                 }
  350.             }
  351.         }
  352.         return ok;
  353.     }
  354.     
  355.     public static boolean deleteDir(String dir) {
  356.         File d = new File(dir);
  357.         if(!d.exists()){
  358.             return true;
  359.         }
  360.         return FileSystemUtilities.deleteDir(d);
  361.     }
  362.     
  363.     public static boolean deleteDir(File dir) {

  365.         if (!emptyDir(dir)) {
  366.             return false;
  367.         }

  369.         // The directory is now empty so now it can be smoked
  370.         try {
  371.             Files.delete(dir.toPath());
  372.             return true;
  373.         }catch(Exception e) {
  374.             return false;
  375.         }
  376.     }
  377.     
  378.     public static void deleteFile(File f) {
  379.         try {
  380.             if(f!=null) {
  381.                 java.nio.file.Files.delete(f.toPath());
  382.             }
  383.         }catch(Exception e) {
  384.             // ignore
  385.         }
  386.     }
  387.     
  388.     public static void clearFile(File f) {
  389.         try {
  390.             if(f!=null) {
  391.                 try(FileOutputStream fos = new FileOutputStream(f);){
  392.                     byte[] emptyBytes = new byte[0];
  393.                     fos.write(emptyBytes);
  394.                     fos.flush();
  395.                 }
  396.             }
  397.         }catch(Exception e) {
  398.             // ignore
  399.         }
  400.     }
  401.     
  402.     public static boolean moveToDir(String src,String destDir){
  403.          // File (or directory) to be moved
  404.         File file = new File(src);
  405.         
  406.         // Destination directory
  407.         File dir = new File(destDir);
  408.         
  409.         return FileSystemUtilities.moveToDir(file,dir);
  410.     }
  411.     public static boolean moveToDir(File src,File destDir){

  413.         // Move file to new directory
  414.         return src.renameTo(new File(destDir, src.getName()));

  416.     }
  417.     
  418.     public static boolean moveToFile(String src,String destFile){
  419.      // File (or directory) to be moved
  420.        File file = new File(src);
  421.        
  422.        // Destination directory
  423.        File dir = new File(destFile);
  424.        
  425.        return FileSystemUtilities.moveToDir(file,dir);
  426.    }
  427.    public static boolean moveToFile(File src,File destFile){

  429.        // Move file to new directory
  430.        return src.renameTo(destFile);
  431.    }
  432.    
  433.    public static void mkdirParentDirectory(File file) throws UtilsException {
  434.        FileSystemUtilities.mkdirParentDirectory(file.getAbsolutePath());
  435.    }
  436.    public static void mkdirParentDirectory(File file,
  437.            Boolean readable, Boolean readableOwnerOnly,
  438.            Boolean writable, Boolean writableOwnerOnly,
  439.            Boolean executable, Boolean executableOwnerOnly) throws UtilsException {
  440.        FileSystemUtilities.mkdirParentDirectory(file.getAbsolutePath(),
  441.                readable, readableOwnerOnly,
  442.                writable, writableOwnerOnly,
  443.                executable, executableOwnerOnly);
  444.    }
  445.    public static void mkdirParentDirectory(String file) throws UtilsException {
  446.        mkdirParentDirectory(file,
  447.                null, null,
  448.                null, null,
  449.                null, null);
  450.    }
  451.    public static void mkdirParentDirectory(String file,
  452.            Boolean readable, Boolean readableOwnerOnly,
  453.            Boolean writable, Boolean writableOwnerOnly,
  454.            Boolean executable, Boolean executableOwnerOnly) throws UtilsException {
  455.         try{
  456.             File p = new File(file);
  457.             if(p.getParentFile()==null){
  458.                 return;
  459.             }
  460.             if(p.getParentFile().exists()){
  461.                 return;
  462.             }
  463.             FileSystemUtilities.mkdirParentDirectory(p.getParentFile().getAbsolutePath());
  464.             if(!p.getParentFile().mkdir()){
  465.                 throw new UtilsException(DIRECTORY_PREFIX_MSG+p.getParentFile().getAbsolutePath()+"] non esistente e creazione non riuscita");
  466.             }
  467.             else {
  468.                 setRWX(p,
  469.                         readable, readableOwnerOnly,
  470.                         writable, writableOwnerOnly,
  471.                         executable, executableOwnerOnly);
  472.             }
  473.         }catch(Exception e){
  474.             throw new UtilsException("mkdirParentDirectory non riuscito: "+e.getMessage(),e);
  475.         }
  476.    }
  477.    private static void setRWX(File p,
  478.            Boolean readable, Boolean readableOwnerOnly,
  479.            Boolean writable, Boolean writableOwnerOnly,
  480.            Boolean executable, Boolean executableOwnerOnly) {
  481.        setParentR(p, readable, readableOwnerOnly);
  482.        setParentW(p, writable, writableOwnerOnly);
  483.        setParentX(p, executable, executableOwnerOnly);
  484.    }
  485.    private static void setParentR(File p, Boolean readable, Boolean readableOwnerOnly) {
  486.        if(readable!=null) {
  487.             if(readableOwnerOnly!=null) {
  488.                 if(!p.getParentFile().setReadable(readable, readableOwnerOnly)) {
  489.                     // ignore
  490.                 }
  491.             }
  492.             else {
  493.                 if(!p.getParentFile().setReadable(readable)) {
  494.                     // ignore
  495.                 }
  496.             }
  497.        }
  498.    }
  499.    private static void setParentW(File p, Boolean writable, Boolean writableOwnerOnly) {
  500.        if(writable!=null) {
  501.             if(writableOwnerOnly!=null) {
  502.                 if(!p.getParentFile().setWritable(writable, writableOwnerOnly)) {
  503.                     // ignore
  504.                 }
  505.             }
  506.             else {
  507.                 if(!p.getParentFile().setWritable(writable)) {
  508.                     // ignore
  509.                 }
  510.             }
  511.         }
  512.    }
  513.    private static void setParentX(File p, Boolean executable, Boolean executableOwnerOnly) {
  514.         if(executable!=null) {
  515.             if(executableOwnerOnly!=null) {
  516.                 if(!p.getParentFile().setExecutable(executable, executableOwnerOnly)) {
  517.                     // ignore
  518.                 }
  519.             }
  520.             else {
  521.                 if(!p.getParentFile().setExecutable(executable)) {
  522.                     // ignore
  523.                 }
  524.             }
  525.         }
  526.    }
  527.    
  528.    public static void mkdir(String f) throws UtilsException{
  529.        mkdir(f, new FileSystemMkdirConfig());
  530.    }
  531.    public static void mkdir(String f,
  532.            Boolean readable, Boolean readableOwnerOnly,
  533.            Boolean writable, Boolean writableOwnerOnly,
  534.            Boolean executable, Boolean executableOwnerOnly) throws UtilsException{
  535.        mkdir(f, new FileSystemMkdirConfig(),
  536.                new FileRWXConfig(readable, readableOwnerOnly,
  537.                        writable, writableOwnerOnly,
  538.                        executable, executableOwnerOnly));
  539.    }
  540.    public static void mkdir(String f,
  541.            FileRWXConfig rwxConfig) throws UtilsException{
  542.        mkdir(f, new FileSystemMkdirConfig(), rwxConfig);
  543.    }
  544.    public static void mkdir(String f, FileSystemMkdirConfig config) throws UtilsException{
  545.        File dir = new File(f);
  546.        mkdir(dir, config);
  547.    }
  548.    public static void mkdir(String f, FileSystemMkdirConfig config,
  549.            FileRWXConfig rwxConfig) throws UtilsException{
  550.        File dir = new File(f);
  551.        mkdir(dir, config, rwxConfig);
  552.    }
  553.    
  554.    public static void mkdir(File dir) throws UtilsException{
  555.        mkdir(dir, new FileSystemMkdirConfig());
  556.    }
  557.    public static void mkdir(File dir,
  558.            Boolean readable, Boolean readableOwnerOnly,
  559.            Boolean writable, Boolean writableOwnerOnly,
  560.            Boolean executable, Boolean executableOwnerOnly) throws UtilsException{
  561.        mkdir(dir, new FileSystemMkdirConfig(),
  562.                new FileRWXConfig(readable, readableOwnerOnly,
  563.                        writable, writableOwnerOnly,
  564.                        executable, executableOwnerOnly));
  565.    }
  566.    public static void mkdir(File dir, FileRWXConfig rwxConfig) throws UtilsException{
  567.        mkdir(dir, new FileSystemMkdirConfig(), rwxConfig);
  568.    }
  569.    public static void mkdir(File dir, FileSystemMkdirConfig config) throws UtilsException{
  570.        mkdir(dir, config, null);
  571.    }
  572.    public static void mkdir(File dir, FileSystemMkdirConfig config,
  573.            FileRWXConfig rwxConfig) throws UtilsException{
  574.        
  575.        Boolean readable = null;
  576.        Boolean readableOwnerOnly = null;
  577.        Boolean writable = null;
  578.        Boolean writableOwnerOnly = null;
  579.        Boolean executable = null;
  580.        Boolean executableOwnerOnly = null;
  581.        if(rwxConfig!=null) {
  582.            readable = rwxConfig.getReadable();
  583.            readableOwnerOnly = rwxConfig.getReadableOwnerOnly();
  584.            writable = rwxConfig.getWritable();
  585.            writableOwnerOnly = rwxConfig.getWritableOwnerOnly();
  586.            executable = rwxConfig.getExecutable();
  587.            executableOwnerOnly = rwxConfig.getExecutableOwnerOnly();
  588.        }
  589.        
  590.        if(dir.exists()){
  591.            checkDir(dir, config);
  592.         }
  593.         else{
  594.             if(dir.getParentFile()!=null) {
  595.                 File parent = dir.getParentFile();
  596.                 if(!parent.exists() &&
  597.                     config.crateParentIfNotExists) {
  598.                     mkdirParentDirectory(dir,
  599.                             readable, readableOwnerOnly,
  600.                             writable, writableOwnerOnly,
  601.                             executable, executableOwnerOnly);
  602.                 }
  603.             }
  604.             if(!dir.mkdir()){
  605.                 throw new UtilsException("Creazione directory ["+dir.getAbsolutePath()+"] non riuscita");
  606.             }
  607.             else {
  608.                 setR(dir, readable, readableOwnerOnly);
  609.                 setW(dir, writable, writableOwnerOnly);
  610.                 setX(dir, executable, executableOwnerOnly);
  611.             }
  612.         }
  613.    }
  614.    private static void checkDir(File dir, FileSystemMkdirConfig config) throws UtilsException {
  615.        if(!dir.isDirectory()){
  616.             throw new UtilsException("File ["+dir.getAbsolutePath()+"] is not directory");
  617.         }
  618.         if(config.isCheckCanRead() &&
  619.             !dir.canRead()){
  620.             throw new UtilsException(DIRECTORY_PREFIX_MSG+dir.getAbsolutePath()+"] cannot read");
  621.         }
  622.         if(config.isCheckCanWrite() &&
  623.             !dir.canWrite()){
  624.             throw new UtilsException(DIRECTORY_PREFIX_MSG+dir.getAbsolutePath()+"] cannot write");
  625.         }
  626.         if(config.isCheckCanExecute() &&
  627.             !dir.canExecute()){
  628.             throw new UtilsException(DIRECTORY_PREFIX_MSG+dir.getAbsolutePath()+"] cannot execute");
  629.         }
  630.    }
  631.    private static void setR(File dir, Boolean readable, Boolean readableOwnerOnly) {
  632.        if(readable!=null) {
  633.             if(readableOwnerOnly!=null) {
  634.                 if(!dir.setReadable(readable, readableOwnerOnly)) {
  635.                     // ignore
  636.                 }
  637.             }
  638.             else {
  639.                 if(!dir.setReadable(readable)) {
  640.                     // ignore
  641.                 }
  642.             }
  643.         }
  644.    }
  645.    private static void setW(File dir, Boolean writable, Boolean writableOwnerOnly) {
  646.        if(writable!=null) {
  647.             if(writableOwnerOnly!=null) {
  648.                 if(!dir.setWritable(writable, writableOwnerOnly)) {
  649.                     // ignore
  650.                 }
  651.             }
  652.             else {
  653.                 if(!dir.setWritable(writable)) {
  654.                     // ignore
  655.                 }
  656.             }
  657.         }
  658.    }
  659.    private static void setX(File dir, Boolean executable, Boolean executableOwnerOnly) {
  660.        if(executable!=null) {
  661.             if(executableOwnerOnly!=null) {
  662.                 if(!dir.setExecutable(executable, executableOwnerOnly)) {
  663.                     // ignore
  664.                 }
  665.             }
  666.             else {
  667.                 if(!dir.setExecutable(executable)) {
  668.                     // ignore
  669.                 }
  670.             }
  671.         }
  672.    }
  673.    
  674.    private static final String DIRECTORY_PREFIX_MSG = "Directory [";
  675. }
Created with JaCoCo 0.8.8.202204050719