Merge pull request #20 from subes/master

Support for adding writers to capture matlab process output for debugging purposes

Author: nedtwigg

src/matlabcontrol/MatlabProxyFactoryOptions.java

@@ -6,6 +6,7 @@
 package matlabcontrol;
 
 import java.io.File;
+import java.io.Writer;
 import java.util.concurrent.atomic.AtomicLong;
 
 import matlabcontrol.MatlabProxyFactory.CopyPasteCallback;
@@ -32,6 +33,8 @@ public class MatlabProxyFactoryOptions {
 	private final String _licenseFile;
 	private final boolean _useSingleCompThread;
 	private final int _port;
+	private final Writer _outputWriter;
+	private final Writer _errorWriter;
 
 	private MatlabProxyFactoryOptions(Builder options) {
 		_matlabLocation = options._matlabLocation;
@@ -46,6 +49,8 @@ private MatlabProxyFactoryOptions(Builder options) {
 		_licenseFile = options._licenseFile;
 		_useSingleCompThread = options._useSingleCompThread;
 		_port = options._port;
+		_outputWriter = options._outputWriter;
+		_errorWriter = options._errorWriter;
 	}
 
 	String getMatlabLocation() {
@@ -96,6 +101,14 @@ int getPort() {
 		return _port;
 	}
 
+	Writer getOutputWriter() {
+		return _outputWriter;
+	}
+
+	Writer getErrorWriter() {
+		return _errorWriter;
+	}
+
 	/**
 	 * Creates instances of {@link MatlabProxyFactoryOptions}. Any and all of these properties may be left unset, if so
 	 * then a default will be used. Depending on how the factory operates, not all properties may be used. Currently all
@@ -127,6 +140,8 @@ public static class Builder {
 		private volatile String _licenseFile = null;
 		private volatile boolean _useSingleCompThread = false;
 		private volatile int _port = 2100;
+		private volatile Writer _outputWriter = null;
+		private volatile Writer _errorWriter = null;
 
 		//Assigning to a long is not atomic, so use an AtomicLong so that a thread always sees an intended value
 		private final AtomicLong _proxyTimeout = new AtomicLong(180000L);
@@ -387,6 +402,30 @@ public final Builder setPort(int port) {
 			return this;
 		}
 
+		/**
+		 * Sets the output writer where the standard output of the created matlab process is written to.
+		 * This is only used when an actual process is spawned for the matlab proxy instance.
+		 * 
+		 * @param outputWriter
+		 */
+		public final Builder setOutputWriter(Writer outputWriter) {
+			_outputWriter = outputWriter;
+
+			return this;
+		}
+
+		/**
+		 * Sets the error writer where the error output of the created matlab process is written to. 
+		 * This is only used when an actual process is spawned for the matlab proxy instance.
+		 * 
+		 * @param errorWriter
+		 */
+		public final Builder setErrorWriter(Writer errorWriter) {
+			_errorWriter = errorWriter;
+
+			return this;
+		}
+
 		/**
 		 * Builds a {@code MatlabProxyFactoryOptions} instance.
 		 * 
@@ -396,4 +435,5 @@ public final MatlabProxyFactoryOptions build() {
 			return new MatlabProxyFactoryOptions(this);
 		}
 	}
+
 }

src/matlabcontrol/RemoteMatlabProxyFactory.java

@@ -7,6 +7,10 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.charset.Charset;
 import java.rmi.AlreadyBoundException;
 import java.rmi.NoSuchObjectException;
 import java.rmi.NotBoundException;
@@ -270,8 +274,8 @@ private Process createProcess(RemoteRequestReceiver receiver) throws MatlabConne
 
 			//If running under UNIX and MATLAB is hidden these streams need to be read so that MATLAB does not block
 			if (_options.getHidden() && !Configuration.isWindows()) {
-				new ProcessStreamDrainer(process.getInputStream(), "Input").start();
-				new ProcessStreamDrainer(process.getErrorStream(), "Error").start();
+				new ProcessStreamDrainer(process.getInputStream(), "Output", _options.getOutputWriter()).start();
+				new ProcessStreamDrainer(process.getErrorStream(), "Error", _options.getErrorWriter()).start();
 			}
 
 			return process;
@@ -309,10 +313,12 @@ private String getRunArg(RemoteRequestReceiver receiver) throws MatlabConnection
 	 * blocking.
 	 */
 	private static class ProcessStreamDrainer extends Thread {
-		private final InputStream _stream;
+		private final Reader _reader;
+		private final Writer _writer;
 
-		private ProcessStreamDrainer(InputStream stream, String type) {
-			_stream = stream;
+		private ProcessStreamDrainer(InputStream stream, String type, Writer writer) {
+			_reader = new InputStreamReader(stream, Charset.defaultCharset());
+			_writer = writer;
 
 			this.setDaemon(true);
 			this.setName("ProcessStreamDrainer - " + type);
@@ -321,14 +327,23 @@ private ProcessStreamDrainer(InputStream stream, String type) {
 		@Override
 		public void run() {
 			try {
-				byte[] buffer = new byte[1024];
-				while (_stream.read(buffer) != -1)
-					;
+				char[] buffer = new char[1024];
+				if (_writer != null) {
+					int len = 0;
+					while ((len = _reader.read(buffer)) != -1) {
+						_writer.write(buffer, 0, len);
+						_writer.flush();
+					}
+				} else {
+					while (_reader.read(buffer) != -1)
+						;
+				}
 			} catch (IOException e) {
 				e.printStackTrace();
 				throw new RuntimeException(e);
 			}
 		}
+
 	}
 
 	/**