source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.common.utils;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *  http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import org.slf4j.Logger;
  22 import org.slf4j.LoggerFactory;
  23
  24 import java.io.IOException;
  25 import java.io.UncheckedIOException;
  26 import java.nio.charset.Charset;
  27 import java.nio.file.Files;
  28 import java.nio.file.Path;
  29 import java.nio.file.Paths;
  30 import java.nio.file.StandardOpenOption;
  31 import java.util.Comparator;
  32 import java.util.Optional;
  33
  34 /**
  35  *
  36  * Utility class for file manipulation
  37  *
  38  * @author Martin Stockhammer <martin_s@apache.org>
  39  */
  40 public class FileUtils
  41 {
  42     private static final Logger log = LoggerFactory.getLogger( FileUtils.class );
  43     /**
  44      * Deletes the directory recursively and quietly.
  45      *
  46      * @param dir
  47      */
  48     public static void deleteQuietly(Path dir) {
  49         try
  50         {
  51             Files.walk(dir)
  52                 .sorted( Comparator.reverseOrder())
  53                 .forEach( file ->  {
  54                     try
  55                     {
  56                         Files.delete( file );
  57                     }
  58                     catch ( IOException e )
  59                     {
  60                         // Ignore this
  61                     }
  62
  63                 });
  64         }
  65         catch ( IOException e )
  66         {
  67             // Ignore this
  68         }
  69
  70
  71     }
  72
  73     public static void deleteDirectory( Path dir ) throws IOException
  74     {
  75         if (!Files.exists(dir)) {
  76             return;
  77         }
  78         if (!Files.isDirectory( dir )) {
  79             throw new IOException("Given path is not a directory "+dir);
  80         }
  81         boolean result = true;
  82         try
  83         {
  84             result = Files.walk( dir )
  85                 .sorted( Comparator.reverseOrder( ) )
  86                 .map( file ->
  87                 {
  88                     try
  89                     {
  90                         Files.delete( file );
  91                         return Optional.of( Boolean.TRUE );
  92                     }
  93                     catch ( UncheckedIOException | IOException e )
  94                     {
  95                         log.warn( "File could not be deleted {}", file );
  96                         return Optional.empty( );
  97                     }
  98
  99                 } ).allMatch( Optional::isPresent );
 100         } catch (UncheckedIOException e) {
 101             throw new IOException("File deletion failed ", e);
 102         }
 103         if (!result) {
 104             throw new IOException("Error during recursive delete of "+dir.toAbsolutePath());
 105         }
 106     }
 107
 108     public static String readFileToString( Path file, Charset encoding)
 109     {
 110         try
 111         {
 112             return new String(Files.readAllBytes( file ), encoding  );
 113         }
 114         catch ( IOException e )
 115         {
 116             log.error("Could not read from file {}", file);
 117             return "";
 118         }
 119     }
 120
 121     public static void writeStringToFile( Path file, Charset encoding, String value )
 122     {
 123         try
 124         {
 125             Files.write( file,  value.getBytes( encoding ), StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
 126         }
 127         catch ( IOException e )
 128         {
 129             log.error("Could not write to file {}", file);
 130         }
 131     }
 132
 133     /**
 134      * Return the base directory
 135      * @return
 136      */
 137     public static String getBasedir()
 138     {
 139         String basedir = System.getProperty( "basedir" );
 140         if ( basedir == null )
 141         {
 142             basedir = Paths.get("").toAbsolutePath().toString();
 143         }
 144
 145         return basedir;
 146     }
 147 }