common-smartgears/src/main/java/org/gcube/smartgears/utils/Utils.java

231 lines
6.0 KiB
Java
Raw Normal View History

package org.gcube.smartgears.utils;
import static org.gcube.smartgears.Constants.ghn_home_env;
import static org.gcube.smartgears.Constants.ghn_home_property;
import static org.gcube.smartgears.handlers.application.request.RequestError.application_error;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.Flushable;
import java.io.IOException;
import java.util.Collection;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.gcube.common.authorization.library.provider.ServiceIdentifier;
import org.gcube.common.authorization.library.provider.ServiceInfo;
import org.gcube.smartgears.context.application.ApplicationContext;
import org.gcube.smartgears.handlers.application.request.RequestError;
import org.gcube.smartgears.handlers.application.request.RequestException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Library-wide utils.
*
* @author Fabio Simeoni
*
*/
public class Utils {
private static final Logger log = LoggerFactory.getLogger(Utils.class);
public static final ScheduledExecutorService scheduledServicePool = Executors.newScheduledThreadPool(10);
public static RuntimeException unchecked(Throwable t) {
return (t instanceof RuntimeException) ? RuntimeException.class.cast(t) : new RuntimeException(t.getMessage(),
t);
}
public static String smartgearsVersion() {
return "1.0.0"; // @TODO
}
public static void rethrowUnchecked(Throwable t) throws RuntimeException {
throw unchecked(t);
}
public static void closeSafely(Closeable c) {
if (c != null) {
try {
if (c instanceof Flushable)
Flushable.class.cast(c).flush();
c.close();
} catch (IOException e) {
log.error("could not close {} due to error {}: msg{}", c, e.getClass().getSimpleName(), e.getMessage());
}
}
}
public static void valid(String name, Object[] o) throws IllegalArgumentException {
notNull(name, o);
}
public static void notNull(Object[] o) throws IllegalArgumentException {
notNull("argument", o);
}
public static void notNull(String name, Object o) throws IllegalArgumentException {
if (o == null)
throw new IllegalArgumentException(name + " is null");
}
public static void notEmpty(String name, String o) throws IllegalArgumentException {
notNull(name, o);
if (o.isEmpty())
throw new IllegalArgumentException(name + " is empty");
}
public static void notEmpty(String name, Object[] o) throws IllegalArgumentException {
notNull(name, o);
if (o.length == 0)
throw new IllegalArgumentException(name + " is empty");
}
public static void notEmpty(String name, Collection<?> o) throws IllegalArgumentException {
notNull(name, o);
if (o.isEmpty())
throw new IllegalArgumentException(name + " is empty");
}
public static void valid(String name, String o) throws IllegalArgumentException {
notNull(name, o);
notEmpty(name, o);
}
public static String home() {
String home = System.getenv(ghn_home_env);
if (home == null)
home = System.getProperty(ghn_home_property);
return home;
}
public static void handleError(HttpServletRequest request, HttpServletResponse response, Throwable t)
throws IOException {
RequestError error = t instanceof RequestException ? RequestException.class.cast(t).error() : application_error;
if (error == application_error) {
response.getWriter().write("Error (" + error.code() + ") : " + t.getMessage() + "\nStacktrace:\n");
t.printStackTrace(response.getWriter());
response.setStatus(error.code());
} else
response.sendError(error.code(), t.getMessage());
}
public static interface ModeClause {
File toRead();
File toWrite();
}
public static ModeClause fileAt(final String path) {
notNull("file path",path);
return new ModeClause() {
@Override
public File toWrite() {
return file(path,true);
}
@Override
public File toRead() {
return file(path,false);
}
};
}
private static File file(String path, boolean writeMode) throws IllegalArgumentException {
File file = new File(path);
if (!writeMode)
if (!file.exists() || file.length() == 0 || !file.canRead()) {
File backup = new File(file.getAbsolutePath() + ".backup");
if (backup.exists())
if (!backup.renameTo(file)) {
log.warn("accessing directly backup {} as it cannot be renamed to {}", backup.getAbsolutePath(), file.getAbsolutePath());
return backup; //bets effort:read from backup
}
else {
log.info("cannot read {} but can access its backup {}", backup.getAbsolutePath(), file.getAbsolutePath());
return file;
}
}
if (file.isDirectory())
throw new IllegalArgumentException(path + " cannot be used in write mode because it's folder");
//create folder structure it does not exist
if (!file.getParentFile().exists())
file.getParentFile().mkdirs();
else
if (file.exists())
try (
BufferedReader reader = new BufferedReader(new FileReader(file));
BufferedWriter writer = new BufferedWriter(new FileWriter(new File(file.getAbsolutePath() + ".backup")));
)
{
String line;
while ((line = reader.readLine()) != null)
writer.write(line);
}
catch (Exception e) {
log.warn("cannot back up "+file.getAbsolutePath()+" on writing ", e);
}
return file;
}
public static ServiceInfo getServiceInfo(ApplicationContext application){
String hostedin = String.format("%s_%d", application.container().configuration().hostname(), application.container().configuration().port());
return
new ServiceInfo(new ServiceIdentifier(application.configuration().serviceClass(), application.configuration().name(), hostedin));
}
public static Throwable getCause(Throwable e) {
Throwable cause = null;
Throwable result = e;
while(null != (cause = result.getCause()) && (result != cause) ) {
result = cause;
}
return result;
}
}