/*
* Syncany, www.syncany.org
* Copyright (C) 2011-2016 Philipp C. Heckel <philipp.heckel@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.syncany.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileLock;
import java.nio.file.Files;
import java.nio.file.InvalidPathException;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.DosFileAttributes;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
/**
* A file utility class
*
* @author Philipp C. Heckel <philipp.heckel@gmail.com>
*/
public class FileUtil {
public static String getRelativePath(File base, File file) {
return removeTrailingSlash(base.toURI().relativize(file.toURI()).getPath());
}
public static String getRelativeDatabasePath(File base, File file) {
String relativeFilePath = getRelativePath(base, file);
return getDatabasePath(relativeFilePath);
}
public static String getDatabasePath(String filePath) {
// Note: This is more important than it seems. Unix paths may contain backslashes
// so that 'black\white.jpg' is a perfectly valid file path. Windows file names
// may never contain backslashes, so that '\' can be safely transformed to the
// '/'-separated database path!
if (EnvironmentUtil.isWindows()) {
return filePath.toString().replaceAll("\\\\", "/");
}
else {
return filePath;
}
}
public static String removeTrailingSlash(String filename) {
if (filename.endsWith("/")) {
return filename.substring(0, filename.length() - 1);
}
else {
return filename;
}
}
public static File getCanonicalFile(File file) {
try {
return file.getCanonicalFile();
}
catch (IOException ex) {
return file;
}
}
public static byte[] createChecksum(File filename, String digestAlgorithm) throws NoSuchAlgorithmException, IOException {
FileInputStream fis = new FileInputStream(filename);
byte[] buffer = new byte[1024];
MessageDigest complete = MessageDigest.getInstance(digestAlgorithm);
int numRead;
do {
numRead = fis.read(buffer);
if (numRead > 0) {
complete.update(buffer, 0, numRead);
}
} while (numRead != -1);
fis.close();
return complete.digest();
}
public static boolean isFileLocked(File file) {
if (!file.exists()) {
return false;
}
if (file.isDirectory()) {
return false;
}
if (isSymlink(file)) {
return false;
}
RandomAccessFile randomAccessFile = null;
boolean fileLocked = false;
try {
// Test 1 missing permissions or locked file parts. If File is not readable == locked
randomAccessFile = new RandomAccessFile(file, "r");
randomAccessFile.close();
}
catch (Exception e) {
fileLocked = true;
}
if (!fileLocked && file.canWrite()) {
try {
// Test 2:Locked file parts
randomAccessFile = new RandomAccessFile(file, "rw");
// Test 3: Set lock and release it again
FileLock fileLock = randomAccessFile.getChannel().tryLock();
if (fileLock == null) {
fileLocked = true;
}
else {
try {
fileLock.release();
}
catch (Exception e) { /* Nothing */
}
}
}
catch (Exception e) {
fileLocked = true;
}
if (randomAccessFile != null) {
try {
randomAccessFile.close();
}
catch (IOException e) { /* Nothing */
}
}
}
return fileLocked;
}
public static boolean isSymlink(File file) {
return Files.isSymbolicLink(Paths.get(file.getAbsolutePath()));
}
public static String readSymlinkTarget(File file) {
try {
return Files.readSymbolicLink(Paths.get(file.getAbsolutePath())).toString();
}
catch (IOException e) {
return null;
}
}
public static void createSymlink(String targetPathStr, File symlinkFile) throws Exception {
Path targetPath = Paths.get(targetPathStr);
Path symlinkPath = Paths.get(symlinkFile.getPath());
Files.createSymbolicLink(symlinkPath, targetPath);
}
public static String dosAttrsToString(DosFileAttributes dosFileAttributes) {
return LimitedDosFileAttributes.toString(dosFileAttributes);
}
public static LimitedDosFileAttributes dosAttrsFromString(String dosFileAttributes) {
return new LimitedDosFileAttributes(dosFileAttributes);
}
/**
* Replaces the <tt>exists()</tt> method in the <tt>File</tt> class by taking symlinks into account.
* The method returns <tt>true</tt> if the file exists, <tt>false</tt> otherwise.
*
* <p>Note: The method returns <tt>true</tt>, if a symlink exists, but points to a
* non-existing target. This behavior is different from the classic
* {@link #exists(File) exists()}-method in the <tt>File</tt> class.
*
* @param file A file
* @return Returns <tt>true</tt> if a file exists (even if its symlink target does not), <tt>false</tt> otherwise
*/
public static boolean exists(File file) {
try {
return Files.exists(Paths.get(file.getAbsolutePath()), LinkOption.NOFOLLOW_LINKS);
}
catch (InvalidPathException e) {
return false;
}
}
public static boolean isDirectory(File file) {
try {
return Files.isDirectory(Paths.get(file.getAbsolutePath()), LinkOption.NOFOLLOW_LINKS);
}
catch (InvalidPathException e) {
return false;
}
}
public static String formatFileSize(long size) {
if (size <= 0) {
return "0";
}
final String[] units = new String[] { "B", "KB", "MB", "GB", "TB" };
int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
return new DecimalFormat("#,##0.#").format(size / Math.pow(1024, digitGroups)) + " " + units[digitGroups];
}
}