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

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;
	}

}