debug/org.eclipse.cdt.debug.mi.core/src/org/eclipse/cdt/debug/mi/core/MISession.java - cdt/org.eclipse.cdt - Git at Google

 /*
  * (c) Copyright QNX Software Systems Ltd. 2002.
  * All Rights Reserved.
  */
 package org.eclipse.cdt.debug.mi.core;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
 import java.util.Observable;

 import org.eclipse.cdt.debug.mi.core.command.Command;
 import org.eclipse.cdt.debug.mi.core.command.CommandFactory;
 import org.eclipse.cdt.debug.mi.core.command.MIGDBExit;
 import org.eclipse.cdt.debug.mi.core.command.MIGDBSet;
 import org.eclipse.cdt.debug.mi.core.event.MIEvent;
 import org.eclipse.cdt.debug.mi.core.event.MIGDBExitEvent;
 import org.eclipse.cdt.debug.mi.core.output.MIOutput;
 import org.eclipse.cdt.debug.mi.core.output.MIParser;
 import org.eclipse.cdt.utils.pty.PTY;

 /**
  * Represents a GDB/MI session.
  * Note that on GNU/Linux the target stream is not
  * preceded by the token '@' until this is fix, on GNU/Linux
  * there a good change to confuse the parser.
  */
 public class MISession extends Observable {

 	/**
 	 * Normal program debuging.
 	 */
 	public final static int PROGRAM = 0;
 	/**
 	 * Attach to a running process debuging.
 	 */
 	public final static int ATTACH = 1;
 	/**
 	 * PostMortem analysis.
 	 */
 	public final static int CORE = 2;

 	boolean terminated;

 	// hold the type of the session(post-mortem, attach etc ..)
 	int sessionType;

 	Process sessionProcess;
 	Process gdbProcess;
 	InputStream inChannel;
 	OutputStream outChannel;

 	TxThread txThread;
 	RxThread rxThread;
 	EventThread eventThread;

 	CommandQueue txQueue;
 	CommandQueue rxQueue;
 	Queue eventQueue;

 	PipedInputStream miInConsolePipe;
 	PipedOutputStream miOutConsolePipe;
 	PipedInputStream miInLogPipe;
 	PipedOutputStream miOutLogPipe;


 	CommandFactory factory;

 	MIParser parser;

 	long cmdTimeout;

 	MIInferior inferior;

 	/**
 	 * Create the gdb session.
 	 *
 	 * @param Process gdb Process.
 	 * @param pty Terminal to use for the inferior.
 	 * @param timeout time in milliseconds to wait for command response.
 	 * @param type the type of debugin session.
 	 */
 	public MISession(Process process, PTY pty, int timeout, int type, int launchTimeout) throws MIException {

 		gdbProcess = process;
 		inChannel = process.getInputStream();
 		outChannel = process.getOutputStream();

 		cmdTimeout = timeout;

 		sessionType = type;

 		factory = new CommandFactory();

 		parser = new MIParser();

 		inferior = new MIInferior(this, pty);

 		txQueue = new CommandQueue();
 		rxQueue = new CommandQueue();
 		eventQueue = new Queue();

 		// The Process may have terminated earlier because
 		// of bad arguments etc .. check this here and bail out.
 		try {
 			process.exitValue();
 			InputStream err = process.getErrorStream();
 			BufferedReader reader = new BufferedReader(new InputStreamReader(err));
 			String line = null;
 			try {
 				line = reader.readLine();
 				reader.close();
 			} catch (Exception e) {
 				// the reader may throw a NPE.
 			}
 			if (line == null) {
 				line = "Process Terminated";
 			}
 			throw new MIException(line);
 		} catch (IllegalThreadStateException e) {
 			// Ok, it means the process is alive.
 		}

 		txThread = new TxThread(this);
 		rxThread = new RxThread(this);
 		eventThread = new EventThread(this);

 		txThread.start();
 		rxThread.start();
 		eventThread.start();

 		// Disable a certain number of irritations from gdb.
 		// Like confirmation and screen size.

 		try {
 			MIGDBSet confirm = new MIGDBSet(new String[]{"confirm", "off"});
 			postCommand(confirm, launchTimeout);
 			confirm.getMIInfo();

 			MIGDBSet width = new MIGDBSet(new String[]{"width", "0"});
 			postCommand(width, launchTimeout);
 			confirm.getMIInfo();

 			MIGDBSet height = new MIGDBSet(new String[]{"height", "0"});
 			postCommand(height, launchTimeout);
 			confirm.getMIInfo();

 		} catch (MIException exc) {
 			// Kill the Transmition thread.
 			if (txThread.isAlive()) {
 				txThread.interrupt();
 			}
 			// Kill the Receiving Thread.
 			if (rxThread.isAlive()) {
 				rxThread.interrupt();
 			}
 			// Kill the event Thread.
 			if (eventThread.isAlive()) {
 				eventThread.interrupt();
 			}
 			// rethrow up the exception.
 			throw exc;
 		}
 	}

 	/**
 	 * get MI Console Stream.
 	 * The parser will make available the MI console stream output.
 	 */
 	public InputStream getMIConsoleStream() {
 		if (miInConsolePipe == null) {
 			try {
 				miOutConsolePipe = new PipedOutputStream();
 				miInConsolePipe = new PipedInputStream(miOutConsolePipe);
 			} catch (IOException e) {
 			}
 		}
 		return miInConsolePipe;
 	}

 	/**
 	 * get MI Console Stream.
 	 * The parser will make available the MI console stream output.
 	 */
 	public InputStream getMILogStream() {
 		if (miInLogPipe == null) {
 			try {
 				miOutLogPipe = new PipedOutputStream();
 				miInLogPipe = new PipedInputStream(miOutLogPipe);
 			} catch (IOException e) {
 			}
 		}
 		return miInLogPipe;
 	}

 	/**
 	 * For example the CDI/MI bridge uses the command
 	 * factory to create MI commands this allow overloading.
 	 */
 	public CommandFactory getCommandFactory() {
 		return factory;
 	}

 	/**
 	 * Set a new factory to use for command.
 	 */
 	public void setCommandFactory(CommandFactory f) {
 		factory = f;
 	}

 	/**
 	 * Return the MI parser.
 	 */
 	public MIParser getMIParser() {
 		return parser;
 	}

 	/**
 	 * Reset the MI parser.
 	 */
 	public void setMIParser(MIParser p) {
 		parser = p;
 	}

 	/**
 	 * Set the type of session this is.
 	 * Certain action will base on that, for example
 	 * the inferior will not try to kill/destroy a
 	 * attach session disconnected.
 	 */
 	public int getSessionType() {
 		return sessionType;
 	}

 	public void setSessionType(int type) {
 		sessionType = type;
 	}

 	/**
 	 * The debug session is a program being debug.
 	 */
 	public boolean isProgramSession() {
 		return sessionType == PROGRAM;
 	}

 	/**
 	 * The debug session is a program being attach to.
 	 */
 	public boolean isAttachSession() {
 		return sessionType == ATTACH;
 	}

 	/**
 	 * The debug session is a core being analysed.
 	 */
 	public boolean isCoreSession() {
 		return sessionType == CORE;
 	}

 	/**
 	 * Reset the default Command Timeout.
 	 */
 	public void setCommandTimeout(long timeout) {
 		cmdTimeout = timeout;
 	}

 	/**
 	 * Return the default Command Timeout, default 10 secs.
 	 */
 	public long getCommandTimeout() {
 		return cmdTimeout;
 	}

 	/**
 	 * equivalent to:
 	 * postCommand(cmd, cmdTimeout)
 	 */
 	public void postCommand(Command cmd) throws MIException {
 		postCommand(cmd, cmdTimeout);
 	}

 	/**
 	 * Sends a command to gdb, and wait(timeout) for a response.
 	 */
 	public synchronized void postCommand(Command cmd, long timeout) throws MIException {

 		// Test if we are in a sane state.
 		if (!txThread.isAlive() || !rxThread.isAlive()) {
 			throw new MIException("{R,T}xThread terminated");
 		}

 		// Test if we are in the right state?
 		if (inferior.isRunning()) {
 			// REMINDER: if we support -exec-interrupt
 			// Let it throught:
 			// if (cmd instanceof MIExecInterrupt) { }
 			// else
 			throw new MIException("Target is not suspended");
 		}

 		if (isTerminated()) {
 			throw new MIException("Session terminated");
 		}

 		// TRACING: print the command;
 		MIPlugin.getDefault().debugLog(cmd.toString());

 		txQueue.addCommand(cmd);

 		// Wait for the response or timedout
 		synchronized (cmd) {
 			// RxThread will set the MIOutput on the cmd
 			// when the response arrive.
 			while (cmd.getMIOutput() == null) {
 				try {
 					cmd.wait(timeout);
 					if (cmd.getMIOutput() == null) {
 						throw new MIException("Target is not responding (timed out)");
 					}
 				} catch (InterruptedException e) {
 				}
 			}
 		}
 	}

 	/**
 	 * Return the inferior "Process".
 	 */
 	public MIInferior getMIInferior() {
 		return inferior;
 	}

 	/**
 	 * Return the "gdb" Process.
 	 */
 	public Process getGDBProcess() {
 		return gdbProcess;
 	}

 	/**
 	 * Return a "fake" Process that will
 	 * encapsulate the call input/output of gdb.
 	 */
 	public Process getSessionProcess() {
 		if (sessionProcess == null) {
 			sessionProcess = new SessionProcess(this);
 		}
 		return sessionProcess;
 	}

 	/**
 	 * Check if the gdb session is terminated.
 	 */
 	public boolean isTerminated() {
 		return terminated;
 	}

 	/**
 	 * Terminate the MISession.
 	 */
 	public void terminate() {

 		// Sanity check.
 		if (isTerminated()) {
 			return;
 		}

 		terminated = true;

 		// Destroy any MI Inferior(Process) and streams.
 		inferior.destroy();

 		// {in,out}Channel is use as predicate/condition
 		// in the {RX,TX,Event}Thread to detect termination
 		// and bail out.  So they are set to null.
 		InputStream inGDB = inChannel;
 		inChannel = null;
 		OutputStream outGDB = outChannel;
 		outChannel = null;

 		// Although we will close the pipe().  It is cleaner
 		// to give a chance to gdb to cleanup.
 		// send the exit(-gdb-exit).
 		MIGDBExit exit = factory.createMIGDBExit();
 		txQueue.addCommand(exit);

 		// Wait for the response
 		synchronized (exit) {
 			// RxThread will set the MIOutput on the cmd
 			// when the response arrive.
 			try {
 				exit.wait(2000);
 			} catch (InterruptedException e) {
 			}
 		}

 		// Make sure gdb is killed.
 		// FIX: the destroy() must be call before closing gdb streams
 		// on windows if the order is not follow the close() will hang.
 		if (gdbProcess != null) {
 			gdbProcess.destroy();
 		}

 		// Close the input GDB prompt
 		try {
 			if (inGDB != null)
 				inGDB.close();
 		} catch (IOException e) {
 		}

 		// Close the output GDB prompt
 		try {
 			if (outGDB != null)
 				outGDB.close();
 		} catch (IOException e) {
 		}

 		// Destroy the MI console stream.
 		try {
 			miInConsolePipe = null;
 			if (miOutConsolePipe != null) {
 				miOutConsolePipe.close();
 			}
 		} catch (IOException e) {
 		}

 		// Destroy the MI log stream.
 		try {
 			miInLogPipe = null;
 			if (miOutLogPipe != null) {
 				miOutLogPipe.close();
 			}
 		} catch (IOException e) {
 		}

 		// Kill the Transmition thread.
 		try {
 			if (txThread.isAlive()) {
 				txThread.interrupt();
 				txThread.join(cmdTimeout);
 			}
 		} catch (InterruptedException e) {
 		}

 		// Kill the Receiving Thread.
 		try {
 			if (rxThread.isAlive()) {
 				rxThread.interrupt();
 				rxThread.join(cmdTimeout);
 			}
 		} catch (InterruptedException e) {
 		}

 		// Allow (10 secs) for the EventThread  to finish processing the queue.
 		Queue queue = getEventQueue();
 		for (int i = 0; !queue.isEmpty() && i < 5; i++) {
 			try {
 				java.lang.Thread.sleep(2000);
 			} catch (InterruptedException e) {
 			}
 		}

 		// Kill the event Thread.
 		try {
 			if (eventThread.isAlive()) {
 				eventThread.interrupt();
 				eventThread.join(cmdTimeout);
 			}
 		} catch (InterruptedException e) {
 		}

 		// Tell the observers that the session is terminated
 		notifyObservers(new MIGDBExitEvent(0));
 	}

 	/**
 	 * Notify the observers of new MI OOB events.
 	 */
 	public void notifyObservers(Object arg) {
 		setChanged();
 		super.notifyObservers(arg);
 	}


 	OutputStream getConsolePipe() {
 		return miOutConsolePipe;
 	}

 	OutputStream getLogPipe() {
 		return miOutLogPipe;
 	}

 	CommandQueue getTxQueue() {
 		return txQueue;
 	}

 	CommandQueue getRxQueue() {
 		return rxQueue;
 	}

 	Queue getEventQueue() {
 		return eventQueue;
 	}

 	RxThread getRxThread() {
 		return rxThread;
 	}

 	InputStream getChannelInputStream() {
 		return inChannel;
 	}

 	OutputStream getChannelOutputStream() {
 		return outChannel;
 	}

 	MIOutput parse(String buffer) {
 		return parser.parse(buffer);
 	}

 	public void fireEvents(MIEvent[] events) {
 		if (events != null && events.length > 0) {
 			for (int i = 0; i < events.length; i++) {
 				fireEvent(events[i]);
 			}
 		}
 	}

 	public void fireEvent(MIEvent event) {
 		if (event != null) {
 			getEventQueue().addItem(event);
 		}
 	}

 }
	/*
	* (c) Copyright QNX Software Systems Ltd. 2002.
	* All Rights Reserved.
	*/
	package org.eclipse.cdt.debug.mi.core;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.OutputStream;
	import java.io.PipedInputStream;
	import java.io.PipedOutputStream;
	import java.util.Observable;

	import org.eclipse.cdt.debug.mi.core.command.Command;
	import org.eclipse.cdt.debug.mi.core.command.CommandFactory;
	import org.eclipse.cdt.debug.mi.core.command.MIGDBExit;
	import org.eclipse.cdt.debug.mi.core.command.MIGDBSet;
	import org.eclipse.cdt.debug.mi.core.event.MIEvent;
	import org.eclipse.cdt.debug.mi.core.event.MIGDBExitEvent;
	import org.eclipse.cdt.debug.mi.core.output.MIOutput;
	import org.eclipse.cdt.debug.mi.core.output.MIParser;
	import org.eclipse.cdt.utils.pty.PTY;

	/**
	* Represents a GDB/MI session.
	* Note that on GNU/Linux the target stream is not
	* preceded by the token '@' until this is fix, on GNU/Linux
	* there a good change to confuse the parser.
	*/
	public class MISession extends Observable {

	/**
	* Normal program debuging.
	*/
	public final static int PROGRAM = 0;
	/**
	* Attach to a running process debuging.
	*/
	public final static int ATTACH = 1;
	/**
	* PostMortem analysis.
	*/
	public final static int CORE = 2;

	boolean terminated;

	// hold the type of the session(post-mortem, attach etc ..)
	int sessionType;

	Process sessionProcess;
	Process gdbProcess;
	InputStream inChannel;
	OutputStream outChannel;

	TxThread txThread;
	RxThread rxThread;
	EventThread eventThread;

	CommandQueue txQueue;
	CommandQueue rxQueue;
	Queue eventQueue;

	PipedInputStream miInConsolePipe;
	PipedOutputStream miOutConsolePipe;
	PipedInputStream miInLogPipe;
	PipedOutputStream miOutLogPipe;


	CommandFactory factory;

	MIParser parser;

	long cmdTimeout;

	MIInferior inferior;

	/**
	* Create the gdb session.
	*
	* @param Process gdb Process.
	* @param pty Terminal to use for the inferior.
	* @param timeout time in milliseconds to wait for command response.
	* @param type the type of debugin session.
	*/
	public MISession(Process process, PTY pty, int timeout, int type, int launchTimeout) throws MIException {

	gdbProcess = process;
	inChannel = process.getInputStream();
	outChannel = process.getOutputStream();

	cmdTimeout = timeout;

	sessionType = type;

	factory = new CommandFactory();

	parser = new MIParser();

	inferior = new MIInferior(this, pty);

	txQueue = new CommandQueue();
	rxQueue = new CommandQueue();
	eventQueue = new Queue();

	// The Process may have terminated earlier because
	// of bad arguments etc .. check this here and bail out.
	try {
	process.exitValue();
	InputStream err = process.getErrorStream();
	BufferedReader reader = new BufferedReader(new InputStreamReader(err));
	String line = null;
	try {
	line = reader.readLine();
	reader.close();
	} catch (Exception e) {
	// the reader may throw a NPE.
	}
	if (line == null) {
	line = "Process Terminated";
	}
	throw new MIException(line);
	} catch (IllegalThreadStateException e) {
	// Ok, it means the process is alive.
	}

	txThread = new TxThread(this);
	rxThread = new RxThread(this);
	eventThread = new EventThread(this);

	txThread.start();
	rxThread.start();
	eventThread.start();

	// Disable a certain number of irritations from gdb.
	// Like confirmation and screen size.

	try {
	MIGDBSet confirm = new MIGDBSet(new String[]{"confirm", "off"});
	postCommand(confirm, launchTimeout);
	confirm.getMIInfo();

	MIGDBSet width = new MIGDBSet(new String[]{"width", "0"});
	postCommand(width, launchTimeout);
	confirm.getMIInfo();

	MIGDBSet height = new MIGDBSet(new String[]{"height", "0"});
	postCommand(height, launchTimeout);
	confirm.getMIInfo();

	} catch (MIException exc) {
	// Kill the Transmition thread.
	if (txThread.isAlive()) {
	txThread.interrupt();
	}
	// Kill the Receiving Thread.
	if (rxThread.isAlive()) {
	rxThread.interrupt();
	}
	// Kill the event Thread.
	if (eventThread.isAlive()) {
	eventThread.interrupt();
	}
	// rethrow up the exception.
	throw exc;
	}
	}

	/**
	* get MI Console Stream.
	* The parser will make available the MI console stream output.
	*/
	public InputStream getMIConsoleStream() {
	if (miInConsolePipe == null) {
	try {
	miOutConsolePipe = new PipedOutputStream();
	miInConsolePipe = new PipedInputStream(miOutConsolePipe);
	} catch (IOException e) {
	}
	}
	return miInConsolePipe;
	}

	/**
	* get MI Console Stream.
	* The parser will make available the MI console stream output.
	*/
	public InputStream getMILogStream() {
	if (miInLogPipe == null) {
	try {
	miOutLogPipe = new PipedOutputStream();
	miInLogPipe = new PipedInputStream(miOutLogPipe);
	} catch (IOException e) {
	}
	}
	return miInLogPipe;
	}

	/**
	* For example the CDI/MI bridge uses the command
	* factory to create MI commands this allow overloading.
	*/
	public CommandFactory getCommandFactory() {
	return factory;
	}

	/**
	* Set a new factory to use for command.
	*/
	public void setCommandFactory(CommandFactory f) {
	factory = f;
	}

	/**
	* Return the MI parser.
	*/
	public MIParser getMIParser() {
	return parser;
	}

	/**
	* Reset the MI parser.
	*/
	public void setMIParser(MIParser p) {
	parser = p;
	}

	/**
	* Set the type of session this is.
	* Certain action will base on that, for example
	* the inferior will not try to kill/destroy a
	* attach session disconnected.
	*/
	public int getSessionType() {
	return sessionType;
	}

	public void setSessionType(int type) {
	sessionType = type;
	}

	/**
	* The debug session is a program being debug.
	*/
	public boolean isProgramSession() {
	return sessionType == PROGRAM;
	}

	/**
	* The debug session is a program being attach to.
	*/
	public boolean isAttachSession() {
	return sessionType == ATTACH;
	}

	/**
	* The debug session is a core being analysed.
	*/
	public boolean isCoreSession() {
	return sessionType == CORE;
	}

	/**
	* Reset the default Command Timeout.
	*/
	public void setCommandTimeout(long timeout) {
	cmdTimeout = timeout;
	}

	/**
	* Return the default Command Timeout, default 10 secs.
	*/
	public long getCommandTimeout() {
	return cmdTimeout;
	}

	/**
	* equivalent to:
	* postCommand(cmd, cmdTimeout)
	*/
	public void postCommand(Command cmd) throws MIException {
	postCommand(cmd, cmdTimeout);
	}

	/**
	* Sends a command to gdb, and wait(timeout) for a response.
	*/
	public synchronized void postCommand(Command cmd, long timeout) throws MIException {

	// Test if we are in a sane state.
	if (!txThread.isAlive() \|\| !rxThread.isAlive()) {
	throw new MIException("{R,T}xThread terminated");
	}

	// Test if we are in the right state?
	if (inferior.isRunning()) {
	// REMINDER: if we support -exec-interrupt
	// Let it throught:
	// if (cmd instanceof MIExecInterrupt) { }
	// else
	throw new MIException("Target is not suspended");
	}

	if (isTerminated()) {
	throw new MIException("Session terminated");
	}

	// TRACING: print the command;
	MIPlugin.getDefault().debugLog(cmd.toString());

	txQueue.addCommand(cmd);

	// Wait for the response or timedout
	synchronized (cmd) {
	// RxThread will set the MIOutput on the cmd
	// when the response arrive.
	while (cmd.getMIOutput() == null) {
	try {
	cmd.wait(timeout);
	if (cmd.getMIOutput() == null) {
	throw new MIException("Target is not responding (timed out)");
	}
	} catch (InterruptedException e) {
	}
	}
	}
	}

	/**
	* Return the inferior "Process".
	*/
	public MIInferior getMIInferior() {
	return inferior;
	}

	/**
	* Return the "gdb" Process.
	*/
	public Process getGDBProcess() {
	return gdbProcess;
	}

	/**
	* Return a "fake" Process that will
	* encapsulate the call input/output of gdb.
	*/
	public Process getSessionProcess() {
	if (sessionProcess == null) {
	sessionProcess = new SessionProcess(this);
	}
	return sessionProcess;
	}

	/**
	* Check if the gdb session is terminated.
	*/
	public boolean isTerminated() {
	return terminated;
	}

	/**
	* Terminate the MISession.
	*/
	public void terminate() {

	// Sanity check.
	if (isTerminated()) {
	return;
	}

	terminated = true;

	// Destroy any MI Inferior(Process) and streams.
	inferior.destroy();

	// {in,out}Channel is use as predicate/condition
	// in the {RX,TX,Event}Thread to detect termination
	// and bail out. So they are set to null.
	InputStream inGDB = inChannel;
	inChannel = null;
	OutputStream outGDB = outChannel;
	outChannel = null;

	// Although we will close the pipe(). It is cleaner
	// to give a chance to gdb to cleanup.
	// send the exit(-gdb-exit).
	MIGDBExit exit = factory.createMIGDBExit();
	txQueue.addCommand(exit);

	// Wait for the response
	synchronized (exit) {
	// RxThread will set the MIOutput on the cmd
	// when the response arrive.
	try {
	exit.wait(2000);
	} catch (InterruptedException e) {
	}
	}

	// Make sure gdb is killed.
	// FIX: the destroy() must be call before closing gdb streams
	// on windows if the order is not follow the close() will hang.
	if (gdbProcess != null) {
	gdbProcess.destroy();
	}

	// Close the input GDB prompt
	try {
	if (inGDB != null)
	inGDB.close();
	} catch (IOException e) {
	}

	// Close the output GDB prompt
	try {
	if (outGDB != null)
	outGDB.close();
	} catch (IOException e) {
	}

	// Destroy the MI console stream.
	try {
	miInConsolePipe = null;
	if (miOutConsolePipe != null) {
	miOutConsolePipe.close();
	}
	} catch (IOException e) {
	}

	// Destroy the MI log stream.
	try {
	miInLogPipe = null;
	if (miOutLogPipe != null) {
	miOutLogPipe.close();
	}
	} catch (IOException e) {
	}

	// Kill the Transmition thread.
	try {
	if (txThread.isAlive()) {
	txThread.interrupt();
	txThread.join(cmdTimeout);
	}
	} catch (InterruptedException e) {
	}

	// Kill the Receiving Thread.
	try {
	if (rxThread.isAlive()) {
	rxThread.interrupt();
	rxThread.join(cmdTimeout);
	}
	} catch (InterruptedException e) {
	}

	// Allow (10 secs) for the EventThread to finish processing the queue.
	Queue queue = getEventQueue();
	for (int i = 0; !queue.isEmpty() && i < 5; i++) {
	try {
	java.lang.Thread.sleep(2000);
	} catch (InterruptedException e) {
	}
	}

	// Kill the event Thread.
	try {
	if (eventThread.isAlive()) {
	eventThread.interrupt();
	eventThread.join(cmdTimeout);
	}
	} catch (InterruptedException e) {
	}

	// Tell the observers that the session is terminated
	notifyObservers(new MIGDBExitEvent(0));
	}

	/**
	* Notify the observers of new MI OOB events.
	*/
	public void notifyObservers(Object arg) {
	setChanged();
	super.notifyObservers(arg);
	}


	OutputStream getConsolePipe() {
	return miOutConsolePipe;
	}

	OutputStream getLogPipe() {
	return miOutLogPipe;
	}

	CommandQueue getTxQueue() {
	return txQueue;
	}

	CommandQueue getRxQueue() {
	return rxQueue;
	}

	Queue getEventQueue() {
	return eventQueue;
	}

	RxThread getRxThread() {
	return rxThread;
	}

	InputStream getChannelInputStream() {
	return inChannel;
	}

	OutputStream getChannelOutputStream() {
	return outChannel;
	}

	MIOutput parse(String buffer) {
	return parser.parse(buffer);
	}

	public void fireEvents(MIEvent[] events) {
	if (events != null && events.length > 0) {
	for (int i = 0; i < events.length; i++) {
	fireEvent(events[i]);
	}
	}
	}

	public void fireEvent(MIEvent event) {
	if (event != null) {
	getEventQueue().addItem(event);
	}
	}

	}