com.xebialabs.overthere.util.OverthereUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of overthere Show documentation
Show all versions of overthere Show documentation
Remote file manipulation and process execution framework for Java
/*
* Copyright (c) 2008-2014, XebiaLabs B.V., All rights reserved.
*
*
* Overthere is licensed under the terms of the GPLv2
* , like most XebiaLabs Libraries.
* There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
* this software, see the FLOSS License Exception
* .
*
* 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; version 2
* of the License.
*
* 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, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
package com.xebialabs.overthere.util;
import com.xebialabs.overthere.ConnectionOptions;
import com.xebialabs.overthere.OverthereFile;
import com.xebialabs.overthere.RuntimeIOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Random;
import static com.xebialabs.overthere.ConnectionOptions.TEMPORARY_FILE_CREATION_RETRIES;
import static com.xebialabs.overthere.ConnectionOptions.TEMPORARY_FILE_CREATION_RETRIES_DEFAULT;
import static java.lang.String.format;
/**
* Contains a number of static helper methods.
*/
public class OverthereUtils {
private static final Logger logger = LoggerFactory.getLogger(OverthereUtils.class);
/**
* Reads the contents of an {@link OverthereFile} into a byte array.
*
* @param from the file to read from.
* @return the byte array.
*/
public static byte[] read(final OverthereFile from) {
InputStream is = from.getInputStream();
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
int nRead;
byte[] bytes = new byte[1024];
while ((nRead = is.read(bytes, 0, bytes.length)) != -1) {
os.write(bytes, 0, nRead);
}
return os.toByteArray();
} catch (IOException exc) {
throw new RuntimeException(exc);
} finally {
closeQuietly(is);
}
}
/**
* Reads the contents of an {@link OverthereFile} into a string.
*
* @param from the file to read from.
* @param charsetName the {@link java.nio.charset.Charset charset} to use.
* @return the string.
*/
public static String read(final OverthereFile from, final String charsetName) {
InputStream is = from.getInputStream();
try {
InputStreamReader isr = new InputStreamReader(is, charsetName);
StringBuilder b = new StringBuilder();
int nRead;
char[] chars = new char[1024];
while ((nRead = isr.read(chars, 0, chars.length)) != -1) {
b.append(chars, 0, nRead);
}
return b.toString();
} catch (IOException exc) {
throw new RuntimeException(exc);
} finally {
closeQuietly(is);
}
}
/**
* Writes the contents of a byte array to an {@link OverthereFile}.
*
* @param from the byte array to copy from.
* @param to the file to write to.
*/
public static void write(final byte[] from, final OverthereFile to) {
new ByteArrayFile(to.getPath(), from).copyTo(to);
}
/**
* Writes the contents of an {@link java.io.InputStream} to an {@link OverthereFile}.
*
* @param from the {@link java.io.InputStream} to read from.
* @param to the file to write to.
*/
public static void write(final InputStream from, final OverthereFile to) {
OutputStream toStream = to.getOutputStream();
try {
write(from, toStream);
} finally {
closeQuietly(toStream);
}
}
/**
* Writes the contents of an {@link java.io.InputStream} to an {@link java.io.OutputStream}.
*
* @param from the {@link java.io.InputStream} to read from.
* @param to the {@link java.io.OutputStream} to write to.
*/
public static void write(InputStream from, OutputStream to) {
try {
byte[] bytes = new byte[1024];
int nRead;
while ((nRead = from.read(bytes, 0, bytes.length)) != -1) {
to.write(bytes, 0, nRead);
}
} catch (IOException ioe) {
throw new RuntimeIOException(ioe);
}
}
/**
* Writes the contents of a {@link String} to an {@link OverthereFile}.
*
* @param from the string to copy from.
* @param charsetName the {@link java.nio.charset.Charset charset} to use.
* @param to the file to write to.
*/
public static void write(final String from, final String charsetName, final OverthereFile to) {
try {
write(from.getBytes(charsetName), to);
} catch (UnsupportedEncodingException exc) {
throw new RuntimeIOException("Cannot write string to " + to, exc);
}
}
/**
* Returns the name component of a path. The name component is the part after the last slash or backslash.
*
* @param path the path
* @return the name component.
*/
public static String getName(String path) {
int lastSlash = path.lastIndexOf('/');
if (lastSlash >= 0) {
return path.substring(lastSlash + 1);
}
int lastBackslash = path.lastIndexOf('\\');
if (lastBackslash >= 0) {
return path.substring(lastBackslash + 1);
}
return path;
}
/**
* Returns the base name of a name (not a path). The base name is the part before the last dot.
*
* @param name the name
* @return the base name.
*/
public static String getBaseName(String name) {
int dot = name.lastIndexOf('.');
if (dot >= 0) {
return name.substring(0, dot);
}
return name;
}
/**
* Returns the extension of a name (not a path). The extension is the part from the last dot in a name onwards.
* If there is no dot character in the name, this will return an empty string.
*
* @param name the name
* @return the extension.
*/
public static String getExtension(String name) {
int dot = name.lastIndexOf('.');
if (dot >= 0) {
return name.substring(dot);
}
return "";
}
/**
* Construct a new (host) path from a parent directory, and a child.
*
* @param parent The parent directory
* @param child The path that should be appended to the parent.
* @return A newly constructed path.
*/
public static String constructPath(final OverthereFile parent, final String child) {
return parent.getPath() + parent.getConnection().getHostOperatingSystem().getFileSeparator() + child;
}
public static void closeQuietly(Closeable c) {
if (c == null) return;
try {
c.close();
} catch (IOException e) {
logger.warn("IOException while closing closeable", e);
// Will not happen because of true...
}
}
public static void checkArgument(boolean expression, String errorMessage, Object... messageParams) {
if (!expression) {
throw new IllegalArgumentException(format(errorMessage, messageParams));
}
}
public static void checkState(boolean expression, String errorMessage, Object... messageParams) {
if (!expression) {
throw new IllegalStateException(format(errorMessage, messageParams));
}
}
public static T checkNotNull(T t, String errorMessage, Object... messageParams) {
if (t == null) {
throw new NullPointerException(format(errorMessage, messageParams));
}
return t;
}
public static String mkString(List strings, char sep) {
return mkString(strings, String.valueOf(sep));
}
public static String mkString(List strings, String sep) {
if (strings.isEmpty()) return "";
StringBuilder b = new StringBuilder(strings.get(0));
for (int i = 1; i < strings.size(); i++) {
b.append(sep).append(strings.get(i));
}
return b.toString();
}
/**
* Generates unique directory inside the specified base directory.
* @param baseDir directory where unique directory will be situated
* @return generated unique directory in the base directory
*/
public static OverthereFile getUniqueFolder(OverthereFile baseDir) {
String temporaryFileHolderDirectoryNamePrefix = "ot-" + (new SimpleDateFormat("yyyyMMdd'T'HHmmssSSS")).format(new Date());
return getUniqueFolder(baseDir, temporaryFileHolderDirectoryNamePrefix);
}
/**
* Generates unique directory with the directoryNameBase as prefix inside of specified base directory.
* @param baseDir directory where unique directory will be situated
* @param directoryNameBase The basename the directory.
* @return generated unique directory in the base directory
*/
public static OverthereFile getUniqueFolder(OverthereFile baseDir, String directoryNameBase) {
ConnectionOptions options = baseDir.getConnection().getOptions();
int temporaryFileCreationRetries = options.getInteger(TEMPORARY_FILE_CREATION_RETRIES, TEMPORARY_FILE_CREATION_RETRIES_DEFAULT);
RuntimeException originalExc = null;
int salt = new Random().nextInt(10000);
for (int i = 0; i <= temporaryFileCreationRetries; i++) {
salt += 1;
OverthereFile holder = baseDir.getFile(directoryNameBase + "." + salt);
if (!holder.exists()) {
logger.trace("Creating unique directory {}", holder);
try {
holder.mkdir();
return holder;
} catch(RuntimeException exc) {
originalExc = exc;
logger.debug(format("Failed to create holder directory %s - Trying with the next suffix", holder), exc);
}
}
}
String errorText = "Cannot generate a unique directory on " + baseDir.getConnection();
if(originalExc != null) {
throw new RuntimeIOException(errorText, originalExc);
} else {
throw new RuntimeIOException(errorText);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy