Laboratoire ICAR » Plateforme TXM

<?xml version="1.0" encoding="UTF-8"?>

<?eclipse version="3.4"?>

<plugin>

   <extension

         point="org.eclipse.core.runtime.preferences">

      <initializer

            class="org.txm.statsengine.r.core.preferences.RPreferences">

      </initializer>

   </extension>

</plugin>

eclipse.preferences.version=1

org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled

org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6

org.eclipse.jdt.core.compiler.compliance=1.6

org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

org.eclipse.jdt.core.compiler.problem.enumIdentifier=error

org.eclipse.jdt.core.compiler.source=1.6

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>

	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: R Statistics Engine Core

Bundle-SymbolicName: org.txm.statsengine.r.core;singleton:=true

Bundle-Version: 1.0.0.qualifier

Require-Bundle: org.txm.libs.colt;bundle-version="1.0.0";visibility:=reexport,

 org.txm.libs.rserve;bundle-version="0.0.0";visibility:=reexport,

 org.txm.statsengine.core;bundle-version="1.0.0";visibility:=reexport,

 org.txm.core;bundle-version="0.7.0",

 org.eclipse.core.runtime

Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Bundle-ActivationPolicy: lazy

Export-Package: org.txm.statsengine.r.core,

 org.txm.statsengine.r.core.data,

 org.txm.statsengine.r.core.exceptions,

 org.txm.statsengine.r.core.messages,

 org.txm.statsengine.r.core.preferences,

 org.txm.statsengine.r.core.rcolt

Bundle-Vendor: Textometrie.org

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>org.txm.statsengine.r.core</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform 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 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform 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 the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.statsengine.r.core;

import org.rosuda.REngine.REXP;

import org.rosuda.REngine.RList;

import org.rosuda.REngine.Rserve.RConnection;

// TODO: Auto-generated Javadoc

/**

 * The Class ConnectToRserve.

 */

// not used? class of test?

class ConnectToRserve {

	/**

	 * The main method.

	 *

	 * @param args the arguments

	 */

	public static void main(String args[]) {

		try {

			RConnection c = new RConnection();

			String userhome = System.getProperty("user.home"); //$NON-NLS-1$

			RList ret = c.eval("source('"+userhome+"/Bureau/R/Rdata')").asList(); //$NON-NLS-1$ //$NON-NLS-2$

			System.out.println("source ret : "+ret.get(1)); //$NON-NLS-1$

			System.out.println(ret);

			REXP ret2 = c.eval("print(lexicaltable)"); //$NON-NLS-1$

			System.out.println("lexicaltable :"+ret2); //$NON-NLS-1$

		}

		catch(Exception e) {

			org.txm.utils.logger.Log.printStackTrace(e);

		}

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform 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 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform 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 the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2013-05-06 17:38:43 +0200 (Mon, 06 May 2013) $

// $LastChangedRevision: 2386 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.statsengine.r.core.rcolt;

import cern.colt.function.IntIntDoubleFunction;

import cern.colt.matrix.DoubleMatrix2D;

// TODO: Auto-generated Javadoc

/**

 * Method for transformation of colt matrix into various array.

 * 

 * @author sloiseau

 * 

 */

public final class RColt {

	/**

	 * Double matrix2 d2 int int array.

	 *

	 * @param matrix the matrix

	 * @return the int[][]

	 */

	public final static int[][] doubleMatrix2D2IntIntArray(DoubleMatrix2D matrix) {

		int rows = matrix.rows();

		int columns = matrix.columns();

		int[][] values = new int[rows][columns];

		for (int row = rows; --row >= 0;) {

			int[] currentRow = values[row];

			for (int column = columns; --column >= 0;) {

				currentRow[column] = (int) matrix.getQuick(row, column);

			}

		}

		return values;

		// final IntIntDoubleFunction fun = new CreateIntIntArray(matrix.rows(),

		// matrix.columns());

		// matrix.forEachNonZero(fun);

		// return ((CreateIntIntArray)fun).getIntIntArray();

	}

	/**

	 * Double matrix2 d2 double double array.

	 *

	 * @param matrix the matrix

	 * @return the double[][]

	 */

	public final static double[][] doubleMatrix2D2DoubleDoubleArray(

			DoubleMatrix2D matrix) {

		matrix.trimToSize();

		return matrix.toArray();

	}

	/*

	 * public final static int[][] intMatrix2D2IntIntArray (IntMatrix2D matrix)

	 * { matrix.trimToSize(); return matrix.toArray(); }

	 */

	/**

	 * Transform a Colt {@link DoubleMatrix2D} into an array of <code>int</code>

	 * .

	 * 

	 * The value of the matrix are stored by column (the values of the first

	 * column, then the values of the second column, etc.)

	 *

	 * @param matrix the matrix

	 * @return an array of <code>int</code>

	 * @todo use {@link DoubleMatrix2D#trimToSize()} and

	 * {@link DoubleMatrix2D#toArray()}

	 */

	public final static int[] doubleMatrix2D2IntArray(DoubleMatrix2D matrix) {

		final IntIntDoubleFunction fun = new CreateIntArray(matrix.rows(),

				matrix.columns());

		matrix.forEachNonZero(fun);

		return ((CreateIntArray) fun).getIntArray();

	}

	// public final static REXP DoubleMatrix2D2REXP(DoubleMatrix2D matrix,

	// Rengine engine, String varName) {

	// final IntIntDoubleFunction fun = new CreateIntIntArray(matrix.rows(),

	// matrix.columns());

	// matrix.forEachNonZero(fun);

	// int[][] m = ((CreateIntIntArray)fun).getIntIntArray();

	// engine.assign(varName, m);

	// return ((CreateIntIntArray)fun).getIntIntArray();

	// }

	/**

	 * The Class CreateIntIntArray.

	 */

	static class CreateIntIntArray implements IntIntDoubleFunction {

		/** The array. */

		private final int[][] array;

		/**

		 * Instantiates a new creates the int int array.

		 *

		 * @param rows the rows

		 * @param columns the columns

		 */

		public CreateIntIntArray(int rows, int columns) {

			array = new int[rows][columns];

			for (int i = 0; i < array.length; i++) {

				for (int j = 0; j < array[i].length; j++) {

					array[i][j] = 0;

				}

			}

		}

		/* (non-Javadoc)

		 * @see cern.colt.function.IntIntDoubleFunction#apply(int, int, double)

		 */

		@Override

		public double apply(int row, int col, double value) {

			array[row][col] = (int) value;

			return value;

		}

		/**

		 * Gets the int int array.

		 *

		 * @return the int int array

		 */

		public int[][] getIntIntArray() {

			return array;

		}

	}

	/**

	 * The Class CreateIntArray.

	 */

	static class CreateIntArray implements IntIntDoubleFunction {

		/** The array. */

		private final int[] array;

		/** The rows. */

		private final int rows;

		/**

		 * Instantiates a new creates the int array.

		 *

		 * @param rows the rows

		 * @param columns the columns

		 */

		public CreateIntArray(int rows, int columns) {

			array = new int[rows * columns];

			for (int i = 0; i < array.length; i++) {

				array[i] = 0;

			}

			this.rows = rows;

		}

		/* (non-Javadoc)

		 * @see cern.colt.function.IntIntDoubleFunction#apply(int, int, double)

		 */

		@Override

		public double apply(int row, int col, double value) {

			array[(col * rows) + row] = (int) value;

			return value;

		}

		/**

		 * Gets the int array.

		 *

		 * @return the int array

		 */

		public int[] getIntArray() {

			return array;

		}

	}

}

<html>

<body>

<p>Converting colt data structure into data structure suited for the R language (mainly vectorized version of matrix).</p>

</body>

</html>

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform 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 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform 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 the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.statsengine.r.core;

import org.txm.statsengine.r.core.exceptions.RWorkspaceException;

import org.txm.utils.Watcher;

// TODO: Auto-generated Javadoc

/**

 * The Class RserveWatcher.

 */

//FIXME: not used ?

public class RserveWatcher extends Watcher	{

	/**

	 * Instantiates a new rserve watcher.

	 */

	public RserveWatcher()

	{

		this.processname = "RSERVE"; //$NON-NLS-1$

	}

	/* (non-Javadoc)

	 * @see org.txm.Watcher#check()

	 */

	@Override

	protected boolean check() {

		RWorkspace rw;

		try {

			rw = RWorkspace.getRWorkspaceInstance();

		} catch (RWorkspaceException e1) {

			System.out.println("Rserve watcher encounter an error: "+e1); //$NON-NLS-1$

			return false;

		}

		if (rw == null)

		{

			return false;

		}

		else

		{

			try {

				rw.eval("print(\"test\")"); //$NON-NLS-1$

			} catch (Exception e) {

				System.out.println("Rserve watcher encounter an error: "+e); //$NON-NLS-1$

				return false;

			}

		}

		return true;

	}

	/* (non-Javadoc)

	 * @see org.txm.Watcher#restart()

	 */

	@Override

	protected boolean restart() {

		return Toolbox.restartStatEngine(true);

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform 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 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform 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 the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2015-06-15 15:29:16 +0200 (Mon, 15 Jun 2015) $

// $LastChangedRevision: 2989 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.statsengine.r.core;

import java.io.File;

import org.rosuda.REngine.Rserve.RConnection;

import org.txm.statsengine.r.core.messages.RCoreMessages;

import org.txm.utils.OSDetector;

import org.txm.utils.StreamHog;

import org.txm.utils.logger.Log;

// TODO: Auto-generated Javadoc

/**

 * Helper class that consumes output of a process. In addition, it filter output

 * of the REG command on Windows to look for InstallPath registry entry which

 * specif ies the location of R.

 * 

 * @author RServe library

 */

/**

 * simple class that start Rserve locally if it's not running already - see

 * mainly <code>checkLocalRserve</code> method. It spits out quite some

 * debugging outout of the console, so feel free to modif y it for your

 * application if desired.

 * <p>

 * <i>Important:</i> All applications should shutdown every Rserve that they

 * started! Never leave Rserve running if you started it after your application

 * quits since it may pose a security risk. Inform the user if you started an

 * Rserve instance.

 */

public class StartRserve {

	/** shortcut to <code>launchRserve(cmd, "--no-save --slave", "--no-save --slave", false)</code>. */

	public static Process Rserveprocess;

	/**

	 * Launch rserve.

	 *

	 * @param cmd the cmd

	 * @param options 

	 * @return true, if successful

	 */

	protected static boolean launchRserve(String cmd, int port, boolean debug, String rArgs, String rServeArgs) {

		if (new File(cmd).exists() && !new File(cmd).isDirectory()

				&& new File(cmd).canExecute())

			return launchRserve(cmd,

					"--no-save --slave --encoding utf8 "+rArgs, "--RS-encoding utf8 --no-save --slave --encoding utf8 "+rServeArgs, port, debug); //$NON-NLS-1$ //$NON-NLS-2$

		return false;

	}

	/**

	 * attempt to start Rserve. Note: parameters are <b>not</b> quoted, so avoid

	 * using any quotes in arguments

	 *

	 * @param cmd command necessary to start R

	 * @param rargs arguments are are to be passed to R

	 * @param rsrvargs arguments to be passed to Rserve

	 * @param debug the debug

	 * @return <code>true</code> if Rserve is running or was successfully

	 * started, <code>false</code> otherwise.

	 */

	protected static boolean launchRserve(String cmd, String rargs,

			String rsrvargs, int port, boolean debug) {

		//System.out.println("LAUNCH R SERVER "+cmd+" "+port+" "+debug);

		try {

			String[] cmdline = null;

			// FIXME: don't forget to remove this Window dedicated code if we manage to use http_proxy command line argument

			boolean isWindows = false;

			// Windows OS

			if (OSDetector.isFamilyWindows()) {

				isWindows = true; /* Windows startup */

				// TODO: old tests for setting proxy in R

				//Windows : set --internet2 option to manage proxy if any

//				// set Proxy configuration using Eclipse RCP stored values

//				String proxy_conf = "";

//				ProxyConf conf = new ProxyConf(RWorkspace.getRWorkspaceInstance());

//				if (conf.mustSetProxyConfiguration()) {

//					proxy_conf = "http_proxy="+conf.getHttpProxyUrl();

//					rsrvargs += " "+proxy_conf; // add the http_proxy parameter

//					Log.info("Run Rserve with proxy configuration: "+proxy_conf);

//				}

				cmdline = new String[] {

						cmd,

						rargs, 

						"-e", //$NON-NLS-1$

						"library(Rserve);Rserve(" //$NON-NLS-1$ 

						+ (debug ? "TRUE" : "FALSE")  //$NON-NLS-1$ //$NON-NLS-2$

						+ ",port=" + port + "" //$NON-NLS-1$ //$NON-NLS-2$

						+ ",args='" //$NON-NLS-1$

						+ rsrvargs + "')\" " //$NON-NLS-1$

				};	

			}

			// Mac, Linux

			else {

				cmdline = new String[] {

						"/bin/sh", //$NON-NLS-1$

						"-c", //$NON-NLS-1$

						"echo 'library(Rserve);Rserve(" //$NON-NLS-1$

						+ (debug ? "TRUE" : "FALSE") //$NON-NLS-1$ //$NON-NLS-2$

						+ ",port="+port+"" //$NON-NLS-1$ //$NON-NLS-2$

						+ ",args=\"" + rsrvargs //$NON-NLS-1$

						+ "\")'|" + cmd //$NON-NLS-1$ 

						+ " " + rargs }; //$NON-NLS-1$

			}

//			ProcessBuilder builder = new ProcessBuilder(cmdline);

//			Rserveprocess = builder.start();

			Runtime runtime = Runtime.getRuntime();

			Rserveprocess = runtime.exec(cmdline);

			//Log.info(Messages.StartRserve_0+Arrays.toString(cmdline));

			StreamHog errStream = new StreamHog(Rserveprocess.getErrorStream(), debug);

			StreamHog inStream = new StreamHog(Rserveprocess.getInputStream(), debug);

			RWorkspace.getRWorkspaceInstance().registerLogger(errStream, inStream);

			if (!debug && !isWindows)

				Rserveprocess.waitFor();

			// System.out.println("call terminated, let us try to connect ...");

		} catch (Exception x) {

			System.err.println(RCoreMessages.StartRserve_21 + x.getMessage());

			return false;

		}

		System.err.print(RCoreMessages.StartRserve_22);

		try {

			Thread.sleep(200);

		} catch (InterruptedException ix) { }

		int attempts = 20;

		while (attempts > 0) {

			try {

				System.out.print("."); //$NON-NLS-1$

				RConnection c = new RConnection("127.0.0.1", port); //$NON-NLS-1$

				c.close();

				return true;

			} catch (Exception e2) {

				try {

					Thread.sleep(2000);

				} catch (InterruptedException ix) { }

			}

			attempts--;

		}

		System.out.println(""); //$NON-NLS-1$

		return false;

	}

	/**

	 * checks whether Rserve is running and if that's not the case it attempts

	 * to start it using the defaults for the platform where it is run on. This

	 * method is meant to be set-and-forget and cover most default setups. For

	 * special setups you may get more control over R with <

	 * <code>launchRserve</code> instead.

	 * @param rServeArgs 

	 * @param rargs 

	 *

	 * @return true, if successful

	 */

	protected static boolean checkLocalRserve(int port, boolean debug, String rargs, String rServeArgs) {

		Log.info(RCoreMessages.StartRserve_2);

		if (isRserveRunning(port)) {

			Log.info(RCoreMessages.StartRserve_3+port);

			return true;

		}

		// Windows OS

		if (OSDetector.isFamilyWindows()) {

			// System.out.println("Windows: query registry to find where R is installed ...");

			String installPath = null;

			try {

				Process rp = Runtime.getRuntime().exec(

						"reg query HKLM\\Software\\R-core\\R"); //$NON-NLS-1$

				StreamHog regHog = new StreamHog(rp.getInputStream(), true);

				rp.waitFor();

				regHog.join();

				installPath = regHog.getInstallPath();

			} catch (Exception rge) {

				System.err.println(RCoreMessages.StartRserve_28 + rge);

				return false;

			}

			if (installPath == null) {

				System.err.println(RCoreMessages.StartRserve_29);

				return false;

			}

			// System.out.println(" Found R in : "+installPath +

			// "\\bin\\R.exe");

			return launchRserve(installPath + "\\bin\\R.exe", port, debug, rargs, rServeArgs); //$NON-NLS-1$

		}

		Log.info(RCoreMessages.StartRserve_4);

		if (launchRserve("R", port, debug, rargs, rServeArgs)) return true; //$NON-NLS-1$

		// R not in the PATH env, try with R common paths

		String[] paths = {

				"/Library/Frameworks/R.framework/Resources/bin/R", //$NON-NLS-1$

				"/usr/local/lib/R/bin/R", //$NON-NLS-1$

				"/usr/lib/R/bin/R", //$NON-NLS-1$

				"/sw/bin/R", //$NON-NLS-1$

				"/usr/common/bin/R", //$NON-NLS-1$

		"/opt/bin/R" }; //$NON-NLS-1$

		for (String path : paths) {

			Log.info(RCoreMessages.StartRserve_6+path);

			if (new File(path).exists() && launchRserve(path, port, debug, rargs, rServeArgs)) return true;

		}

		return false;

		//			

		//		return (launchRserve("R", port, debug) //$NON-NLS-1$

		//				|| /* try some common unix locations of R */

		//				(( && launchRserve("/Library/Frameworks/R.framework/Resources/bin/R", port, debug)) //$NON-NLS-1$

		//				|| ((new File("/usr/local/lib/R/bin/R")).exists() && launchRserve("/usr/local/lib/R/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$

		//				|| ((new File("/usr/lib/R/bin/R")).exists() && launchRserve("/usr/lib/R/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$

		//				|| ((new File("/usr/local/bin/R")).exists() && launchRserve("/usr/local/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$

		//				|| ((new File("/sw/bin/R")).exists() && launchRserve("/sw/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$

		//				|| ((new File("/usr/common/bin/R")).exists() && launchRserve("/usr/common/bin/R")) || ((new File( //$NON-NLS-1$ //$NON-NLS-2$

		//				"/opt/bin/R")).exists() && launchRserve("/opt/bin/R"))); //$NON-NLS-1$ //$NON-NLS-2$

	}

	/**

	 * check whether Rserve is currently running (on local machine and default

	 * port).

	 * 

	 * @return <code>true</code> if local Rserve instance is running,

	 *         <code>false</code> otherwise

	 */

	protected static boolean isRserveRunning(int port) {

		try {

			new RConnection("127.0.0.1", port); //$NON-NLS-1$

			// System.out.println("Rserve is running.");

			// c.close();

			return true;

		} catch (Exception e) {

			// System.out.println("First connect try failed with: "+

			// e.getMessage());

		}

		return false;

	}

	public static void main(String[] args) {

		System.out.println("result=" + checkLocalRserve(8212, false, "", ""));

		try {

			System.out.println("Start RServe");

			RConnection c = new RConnection("localhost", 8212);

			System.out.println("Stop RServe");

			c.eval("print(1+1)");

			c.eval("2+2");

			c.shutdown();

			System.out.println("Done");

		} catch (Exception x) {

			x.printStackTrace();

		}

	}

}

package org.txm.statsengine.r.core;

import java.io.IOException;

import org.txm.core.preferences.TXMPreferences;

import org.txm.statsengine.r.core.exceptions.RWorkspaceException;

import org.txm.statsengine.r.core.messages.RCoreMessages;

import org.txm.statsengine.r.core.preferences.RPreferences;

import org.txm.utils.OSDetector;

import org.txm.utils.logger.Log;

/**

 * R statistics engine. Contains methods to start, stop, kill, etc. the R and RServe process.

 * 

 * @author mdecorde

 * @author sjacquot

 *

 */

public class RStatsEngine {

	/** The state of the stats engine. */

	private static boolean started = false;

	private static boolean mandatory = false;

	private RStatsEngine() {

		// no instantiation

	}

	/**

	 * start the statengine if the engine is not remote then launch Rserve.

	 *

	 * @return true, if successful

	 */

	public static boolean start() {

		try {

			if (TXMPreferences.getBoolean(RPreferences.PREFERENCES_NODE, RPreferences.DISABLE)) {

				System.err.println("Warning, Statistics Engine is disabled.");

				return false;

			}

			Log.warning("Starting Statistics Engine.");

			// try launching R server and connecting to it

			int port = TXMPreferences.getInt(RPreferences.PREFERENCES_NODE, RPreferences.PORT);

			String user = TXMPreferences.getString(RPreferences.PREFERENCES_NODE, RPreferences.USER);

			String password = TXMPreferences.getString(RPreferences.PREFERENCES_NODE, RPreferences.PASSWORD);

			boolean remote = TXMPreferences.getBoolean(RPreferences.PREFERENCES_NODE, RPreferences.REMOTE);

			boolean debug = TXMPreferences.getBoolean(RPreferences.PREFERENCES_NODE, RPreferences.DEBUG);

			mandatory = TXMPreferences.getBoolean(RPreferences.PREFERENCES_NODE, RPreferences.IS_MANDATORY);

			Log.info(RCoreMessages.Log_STARTING_STATS_ENGINE + user + RCoreMessages.Log_REMOTE + remote + RCoreMessages.Log_PORT + port + RCoreMessages.Log_DEBUG + debug);

			// System.out.println("test remote :" + R_PATH_TO_EXECUTABLE + ":" + properties.getProperty(R_PATH_TO_EXECUTABLE));

			if (!remote) {

				// start Rserve executable

				started = RWorkspace.startExec(

						TXMPreferences.getString(RPreferences.PREFERENCES_NODE, RPreferences.PATH_TO_EXECUTABLE), 

						port, 

						debug, 

						TXMPreferences.getString(RPreferences.PREFERENCES_NODE, RPreferences.RARGS),

						TXMPreferences.getString(RPreferences.PREFERENCES_NODE, RPreferences.RSERVEARGS));

				if (started) { // try connecting to R witout login

					started = RWorkspace.connect("127.0.0.1", port); //$NON-NLS-1$

				}

			} else { // try connecting to R, with login and password

				started = RWorkspace.connect(TXMPreferences.getString(RPreferences.PREFERENCES_NODE, RPreferences.SERVER_ADDRESS), port, user, password);

			}

			if (started) { // post configuration of R

				String rPackagesPath = TXMPreferences.getString(RPreferences.PREFERENCES_NODE, RPreferences.PACKAGES_PATH);

				started = RWorkspace.getRWorkspaceInstance().postConfiguration(rPackagesPath);

			}

			//System.out.println("try to set R_FILE_TRANSFERT to " + TXMPreferences.getBoolean(RPreferences.PREFERENCES_NODE, RPreferences.R_FILE_TRANSFERT));

			RWorkspace.setUseFileCommunication(TXMPreferences.getBoolean(RPreferences.PREFERENCES_NODE, RPreferences.FILE_TRANSFERT));

			//	System.out.println("success");

			//System.out.println("file transfert ? "+RWorkspace.isFileTranfert());

		} catch (RWorkspaceException e) {

			System.err.println(RCoreMessages.Error_CONNECTION_FAILED_2); 

			started = false;

		}

		return started;

	}

	/**

	 * kill Rserve process.

	 */

	public static void kill() {

		if (!TXMPreferences.getBoolean(RPreferences.PREFERENCES_NODE, RPreferences.REMOTE))	{

			// Windows OS

			if (OSDetector.isFamilyWindows()) {

				try {

					Process p = Runtime.getRuntime().exec(

							//"taskkill /IM Rserve.exe /F"); //$NON-NLS-1$

							"cmd /c FOR /F \"tokens=5 delims= \" %P IN ('netstat -ano ^| findstr :6330 ^| findstr LISTENING') DO taskkill /F /PID %P"); //$NON-NLS-1$

					p.waitFor();

					started = false;

				} catch (IOException e) {

					Log.severe(RCoreMessages.Error_FAILED_TO_KILL_RSERVE+Log.toString(e));

					System.out.println(RCoreMessages.Error_FAILED_TO_KILL_RSERVE+Log.toString(e));

					try {

						Process p = Runtime.getRuntime().exec(

								//"tskill Rserve.exe"); //$NON-NLS-1$

								"cmd /c FOR /F \"tokens=5 delims= \" %P IN ('netstat -ano ^| findstr :6330 ^| findstr LISTENING') DO tskill %P"); //$NON-NLS-1$

						p.waitFor();

						started = false;

					} catch (IOException e2) {

						Log.severe(RCoreMessages.Error_FAILED_TO_KILL_RSERVE_2+Log.toString(e2));

						System.out.println(RCoreMessages.Error_FAILED_TO_KILL_RSERVE_2+Log.toString(e2));

						Log.printStackTrace(e2);

					} catch (InterruptedException e3) {

						Log.severe(Log.toString(e3));

						System.out.println(Log.toString(e3));

						org.txm.utils.logger.Log.printStackTrace(e3);

					}

				} catch (InterruptedException e) {

					Log.severe("Error while closing R: " + e.getLocalizedMessage());

					System.out.println(Log.toString(e));

					org.txm.utils.logger.Log.printStackTrace(e);

				}

			}

			// Mac, Linux

			else {

				try {

					Process p = Runtime.getRuntime().exec(

							"kill -9 `lsof -t -a -c Rserve-bin.so -i : " + TXMPreferences.getInt(RPreferences.PREFERENCES_NODE, RPreferences.PORT) + "`"); //$NON-NLS-1$ //$NON-NLS-2$

					p.waitFor();

					started = false;

				} catch (IOException e) {

					Log.severe(RCoreMessages.Error_FAILED_TO_KILL_RSERVE_3 + Log.toString(e));

					System.out.println(RCoreMessages.Error_FAILED_TO_KILL_RSERVE_3 + Log.toString(e));

					org.txm.utils.logger.Log.printStackTrace(e);

				} catch (InterruptedException e) {

					Log.severe("Error while closing R: " + e.getLocalizedMessage());

					System.out.println(Log.toString(e));

					org.txm.utils.logger.Log.printStackTrace(e);

				}

			}

		}

	}

	/**

	 * Shut the stats engine down.

	 */

	public static void shutdown() {

		try {

			RWorkspace.shutdown();

			RStatsEngine.kill();

			started = false;

		} catch (Exception e) {

			Log.severe("Error while closing R: " + e.getLocalizedMessage());

		}

	}

	/**

	 * Retuns the running state of the stats engine.

	 */

	public static boolean isStarted()	{

		return started;

	}

	/**

	 * @return the mandatory

	 */

	public static boolean isMandatory() {

		return mandatory;

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform 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 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform 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 the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2015-05-22 09:06:15 +0200 (Fri, 22 May 2015) $

// $LastChangedRevision: 2973 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.statsengine.r.core;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import org.txm.statsengine.r.core.exceptions.RWorkspaceException;

import org.txm.utils.OSDetector;

// TODO: Auto-generated Javadoc

/**

 * The Class RFileCommunication.

 */

public class RFileCommunication {

	/** The transfertfile. */

	File transfertfile;

	/** The transfertfilepath. */

	String transfertfilepath;

	/**

	 * Instantiates a new r file communication.

	 *

	 * @throws IOException Signals that an I/O exception has occurred.

	 */

	public RFileCommunication() throws IOException

	{

		createTempFile();

	}

	/**

	 * Creates the temp file.

	 *

	 * @throws IOException Signals that an I/O exception has occurred.

	 */

	public void createTempFile() throws IOException

	{

		transfertfile = File.createTempFile("Rtransfert","file"); //$NON-NLS-1$ //$NON-NLS-2$

		//transfertfile = new File("~/Bureau/RTRANSFERT.txt");

		transfertfilepath = transfertfile.getAbsolutePath();

		if (OSDetector.isFamilyWindows()) //$NON-NLS-1$ //$NON-NLS-2$

		{

			//System.out.println("patch path");

			transfertfilepath = transfertfilepath.replace("\\", "\\\\"); //$NON-NLS-1$ //$NON-NLS-2$

		}

		//System.out.println("Transfert file: "+transfertfilepath);

	}

	/**

	 * Assign.

	 *

	 * @param variablename the variablename

	 * @param matrix the matrix

	 * @param nrow the nrow

	 * @param ncol the ncol

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void assign(String variablename, int[] matrix, int nrow, int ncol) throws RWorkspaceException

	{

		writeVector(matrix);

		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$

		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- matrix(vectorint, nrow="+nrow+", ncol="+ncol+", byrow=T);"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	}

	/**

	 * Assign.

	 *

	 * @param variablename the variablename

	 * @param matrix the matrix

	 * @param nrow the nrow

	 * @param ncol the ncol

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void assign(String variablename, double[] matrix, int nrow, int ncol) throws RWorkspaceException

	{

		writeVector(matrix);

		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$

		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- matrix(vectordouble, nrow="+nrow+", ncol="+ncol+", byrow=T);"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	}

	/**

	 * Assign.

	 *

	 * @param variablename the variablename

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void assign(String variablename, int[] vector) throws RWorkspaceException

	{

		//System.out.println("assign vector "+variablename+" size "+vector.length);

		writeVector(vector);

		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$

		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- vectorint;"); //$NON-NLS-1$

	}

	/**

	 * Assign.

	 *

	 * @param variablename the variablename

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void assign(String variablename, double[] vector) throws RWorkspaceException

	{

		//System.out.println("assign vector "+variablename+" size "+vector.length);

		writeVector(vector);

		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$

		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- vectordouble;"); //$NON-NLS-1$

	}

	/**

	 * Assign.

	 *

	 * @param variablename the variablename

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void assign(String variablename, String[] vector) throws RWorkspaceException

	{

		//System.out.println("assign vector "+variablename+" size "+vector.length);

		writeVector(vector);

		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$

		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- vectorstr;"); //$NON-NLS-1$

	}

	/*

	public boolean writeMatrix(int[][] matrix)

	{

		//System.out.println("WRITE MATRIX");

		try {

			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));

			for(int i = 0 ; i < matrix.length ; i++)

			{

				StringBuffer str = new StringBuffer();

				for(int j = 0 ; j < matrix[i].length ; j++)

					if (j == matrix[i].length -1)

						str.append(matrix[i][j]);

					else

						str.append(""+matrix[i][j]+"\t");

				writer.write(str.toString()+"\n");

			}

			writer.close();

		} catch (IOException e) {

			org.txm.utils.logger.Log.printStackTrace(e);

			return false;

		}

		return true;

	}

	public boolean writeMatrix(double[][] matrix)

	{

		//System.out.println("WRITE MATRIX");

		try {

			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));

			for(int i = 0 ; i < matrix.length ; i++)

			{

				StringBuffer str = new StringBuffer();

				for(int j = 0 ; j < matrix[i].length ; j++)

					if (j == matrix[i].length -1)

						str.append(matrix[i][j]);

					else

						str.append(""+matrix[i][j]+"\t");

				writer.write(str.toString()+"\n");

			}

			writer.close();

		} catch (IOException e) {

			org.txm.utils.logger.Log.printStackTrace(e);

			return false;

		}

		return true;

	}

*/

	/**

	 * Write vector.

	 *

	 * @param vector the vector

	 * @return true, if successful

	 */

	private boolean writeVector(String[] vector) {

		//System.out.println("WRITE VECTOR");

		try {

			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));

			StringBuffer str = new StringBuffer();

			str.append("vectorstr <- c("); //$NON-NLS-1$

			for(int j = 0 ; j < vector.length ; j++)

				if (j == vector.length -1)

					str.append("\""+vector[j]+"\""); //$NON-NLS-1$ //$NON-NLS-2$

				else

					str.append("\""+vector[j]+"\", "); //$NON-NLS-1$ //$NON-NLS-2$

			str.append(");"); //$NON-NLS-1$

			writer.write(str.toString());

			writer.close();

		} catch (IOException e) {

			org.txm.utils.logger.Log.printStackTrace(e);

			return false;

		}

		return true;

	}

	/**

	 * Write vector.

	 *

	 * @param vector the vector

	 * @return true, if successful

	 */

	public boolean writeVector(int[] vector)

	{

		//System.out.println("WRITE VECTOR");

		try {

			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));

			StringBuffer str = new StringBuffer();

			str.append("vectorint <- as.integer(c("); //$NON-NLS-1$

			for(int j = 0 ; j < vector.length ; j++)

				if (j == vector.length -1)

					str.append(vector[j]);

				else

					str.append(""+vector[j]+", "); //$NON-NLS-1$ //$NON-NLS-2$

			str.append("));"); //$NON-NLS-1$

			writer.write(str.toString());

			writer.close();

		} catch (IOException e) {

			org.txm.utils.logger.Log.printStackTrace(e);

			return false;

		}

		return true;

	}

	/**

	 * Write vector.

	 *

	 * @param vector the vector

	 * @return true, if successful

	 */

	public boolean writeVector(double[] vector)

	{

		//System.out.println("WRITE VECTOR");

		try {

			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));

			StringBuffer str = new StringBuffer();

			str.append("vectordouble <- c("); //$NON-NLS-1$

			for(int j = 0 ; j < vector.length ; j++)

			{

				if (j == vector.length -1)

					str.append(vector[j]);

				else

					str.append(""+vector[j]+", "); //$NON-NLS-1$ //$NON-NLS-2$

			}

			str.append(");"); //$NON-NLS-1$

			writer.write(str.toString());

			writer.close();

		} catch (IOException e) {

			org.txm.utils.logger.Log.printStackTrace(e);

			return false;

		}

		return true;

	}

	/**

	 * The main method.

	 *

	 * @param args the arguments

	 */

	public static void main(String[] args)

	{

		double[][] matrix ={{1,2,3}, {4,5,6}, {7,8,9}};

		RFileCommunication comm;

		try {

			comm = new RFileCommunication();

		} catch (IOException e) {

			org.txm.utils.logger.Log.printStackTrace(e);

			return;

		}

		//comm.writeMatrix(matrix);

	}

}

package org.txm.statsengine.r.core.messages;

import org.eclipse.osgi.util.NLS;

import org.txm.utils.messages.Utf8NLS;

public class RCoreMessages extends NLS {

	private static final String BUNDLE_NAME = "org.txm.statsengine.r.core.messages.messages"; //$NON-NLS-1$

	public static String Error_STATS_ENGINE_NOT_READY_CANCELING_COMMAND;

	public static String Log_STARTING_STATS_ENGINE;

	public static String Log_REMOTE;

	public static String Log_PORT;

	public static String Log_DEBUG;

	public static String Error_CONNECTION_FAILED_2;

	public static String Error_FAILED_TO_KILL_RSERVE;

	public static String Error_FAILED_TO_KILL_RSERVE_2;

	public static String Error_FAILED_TO_KILL_RSERVE_3;

	public static String StartRserve_2;

	public static String StartRserve_21;

	public static String StartRserve_22;

	public static String StartRserve_28;

	public static String StartRserve_29;

	public static String StartRserve_3;

	public static String StartRserve_4;

	public static String StartRserve_6;

	public static String RWorkspace_0;

	public static String RWorkspace_1;

	public static String RWorkspace_10;

	public static String RWorkspace_11;

	public static String RWorkspace_2;

	public static String RWorkspace_3;

	public static String RWorkspace_6;

	public static String RWorkspace_7;

	public static String RWorkspace_8;

	public static String LIBRARY_NOT_LOADED;

	public static String RException_0;

	public static String RException_1;

	public static String RException_2;

	public static String RSERVE_PATH_NOT_SET_ERROR;

	public static String RSERVE_PATH_SET_ERROR;

	public static String CONNECTED_TO_STATS_MODULE;

	public static String CHAR_VECTOR_ADDED_TO_WORKSPACE;

	public static String CONNECTION_OK;

	public static String ERROR_EXTRACT_ITEM;

	public static String REQUESTED_OBJECT_NOT_FOUND_IN_R;

	// FIXME: unused keys

	public static String StartRserve_0;

	public static String RWorkspace_21;

	public static String RSERVE_ACTIVATED;

	public static String R_EXPR;

	public static String R_READ_CONSOLE;

	public static String R_SAVE_HISTORY;

	public static String R_SHOW_MESSAGE;

	public static String R_WRITE_CONSOLE;

	//end of fixme

	static {

		// initialize resource bundle

		Utf8NLS.initializeMessages(BUNDLE_NAME, RCoreMessages.class);

	}

	private RCoreMessages() {

	}

}

Error_CONNECTION_FAILED_2                      = ** Error while connecting to the stat engine.

Error_FAILED_TO_KILL_RSERVE                    = Failed to exec 'taskkill /IM Rserve.exe /F': 

Error_FAILED_TO_KILL_RSERVE_2                  = Failed to exec 'tskill Rserve.exe': 

Error_FAILED_TO_KILL_RSERVE_3                  = Failed to exec 'killall -9 Rserve-bin.so': 

Error_STATS_ENGINE_NOT_READY_CANCELING_COMMAND = Statistics Engine is not ready, canceling command.

LIBRARY_NOT_LOADED = Failed to load the {0} library: {1}

Log_DEBUG                 = debug:

Log_PORT                  = \ port: 

Log_REMOTE                = \ remote:

Log_STARTING_STATS_ENGINE = Starting Statistics Engine: user: 

RException_0 = ** R error: "

RException_1 = "

RException_2 = \nwhile evaluating: 

RSERVE_ACTIVATED          = Statistics Engine running 

RSERVE_PATH_NOT_SET_ERROR = ** The Statistics Engine program path is not set and we could not find it

RSERVE_PATH_SET_ERROR     = ** The Statistics Engine program path is set but we couldn't find it

RWorkspace_0  = ** Failed to connect to the R Workspace 

RWorkspace_1  = ** Evaluation Error: 

RWorkspace_10 = Starting R using path: 

RWorkspace_11 = Last safeeval: 

RWorkspace_2  = try : connect to R at 

RWorkspace_21 = Full command: 

RWorkspace_3  = Saving graphic in file 

RWorkspace_6  = ** Failed to initialize file transfert: 

RWorkspace_7  = Matrix is empty

RWorkspace_8  = Failed to start RServe : 

R_EXPR                    = Expression sent to the Statistics Engine for evaluation: {0}.

R_READ_CONSOLE            = The Statistics Engine waits for something to read from the console ({0}, {1}).

R_SAVE_HISTORY            = The Statistics Engine has saved an history ({0}).

R_SHOW_MESSAGE            = The Statistics Engine displayed this message: {0}.

R_WRITE_CONSOLE           = The Statistics Engine displayed this message in the console: {0}.

StartRserve_0  = Starting R with command line: 

StartRserve_2  = No R path given, trying to find it...

StartRserve_21 = ** Failed to start Rserve with command: 

StartRserve_22 = Statistical Engine launched

StartRserve_28 = ** Failed to run REG to find the location of R program: 

StartRserve_29 = \ You need the 'R' software and you need to configure in the 'Tools/Preferences' window the correct path to it.

StartRserve_3  = Rserve already running on port 

StartRserve_4  = try R path : 'R'

StartRserve_6  = try R path : 

CHAR_VECTOR_ADDED_TO_WORKSPACE = Vector "{1}" ({0,number,integer} "character") has been transmited to the Statistics Engine.

CONNECTED_TO_STATS_MODULE = connected.

CONNECTION_OK = Connected to the Statistics Engine.

ERROR_EXTRACT_ITEM = ** Error extracting list item: 

REQUESTED_OBJECT_NOT_FOUND_IN_R = The requested object ({0}) was not found in the R workspace.