Subversion Repositories DevTools

/**	This class handles remote execution of programs

 *  It is only used by the build daemons

 *  It is not used in Escrow

 *  

 *  It is used by the master build thread as well as the ABT instance created

 *  by the master build thread.

 * 

 */

package com.erggroup.buildtool.abt;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.util.Properties;

import com.sshtools.net.SocketTransport;

import com.sshtools.ssh.PasswordAuthentication;

import com.sshtools.ssh.SshAuthentication;

import com.sshtools.ssh.SshClient;

import com.sshtools.ssh.SshConnector;

import com.sshtools.ssh.SshSession;

import com.sshtools.ssh2.Ssh2Context;

public class RemoteExecution {

	/**

	 * 	Interface to assist in logging the output of the remote executor

	 * 	Required as the class is called in two contexts

	 * 		1) By the build daemon - where logging is to an mLogger

	 * 		2) Within ABT - where logging is via ant

	 */

	public interface LogOutput{

	    void data(String message);		// Log data from the command

	    void info(String message);		// Log Info from the class

	    void fatal(String message);		// Log fatal messages

	}

	/**

	 * Name or Address of the target machine

	 * 

	 */

	private String mTargetMachine;

	/**

	 * User name

	 */

	private String mUserName;

	/**

	 * Password

	 */

	private String mPassword;

	/** Logger

	 * 

	 */

	LogOutput mLogger;

	/**

	 * Constructor

	 * @param logger 

	 */

	public RemoteExecution(LogOutput logger)

	{

		mLogger = logger;

	}

	/**Determine the connection credentials

	 * These are held in a properties file

	 * 

	 * @return true - we have credentials

	 */

	public boolean getCredentials()

	{

		InputStream input;

		Properties prop;

		String credentialsFile = System.getenv("GBE_DPKG_SSH_PROPERTIES");

		if (credentialsFile == null)

		{

			mLogger.fatal("Packager Server SSH credendials. Location Not specified");

			return false;

		}

		File propFile = new File(credentialsFile);

		if (!propFile.isFile())

		{

			mLogger.fatal("Packager Server SSH credendials. Is not a file: " + credentialsFile);

			return false;

		}

		try {

			input = new FileInputStream(propFile);

			prop = new Properties();

			prop.load(input);

		} catch (IOException e) {

			mLogger.fatal("Packager Server SSH credendials. Cannot open: " + credentialsFile + ". Error: " + e.getMessage());

			return false;

		}

		mTargetMachine = prop.getProperty("ssh_server");

		mUserName = prop.getProperty("ssh_user");

		mPassword = prop.getProperty("ssh_password");

		if ( mTargetMachine == null || mUserName == null || mPassword == null )

		{

			mLogger.fatal("Packager Server SSH credendials. Not all properties found");

			return false;

		}

		return true;

	}

	/**

	 * Test the connection to the target machine

	 * Used each build cycle to report if the target machine is not

	 * available.

	 * @param mLogger 		- Logger to use for notification of errors

	 * 

	 *  @return	true - if the connection was successfully established

	 */

	public boolean testConnection()

	{

		int	exitCode = -1;

		mLogger.info("Test remote execution authentication");

		exitCode = execute(null);

		mLogger.info("Test remote execution authentication complete");

		return exitCode == 0;

	}

	/**

	 * Execute command

	 * @param   command	- Command string to be processed. May be null or of zero length

	 * 

	 * @return  command exit code if positive

	 *          <br>internal exist code if negative

	 *          <br>zero - command executed correctly

	 * 

	 */

	public int execute(final String command)

	{

		int	exitCode = -1;

		if (getCredentials())

		{

			try {

				/**

				 * Create an SshConnector instance

				 */

				SshConnector con = SshConnector.createInstance();

				con.getContext().setPreferredPublicKey(Ssh2Context.PUBLIC_KEY_SSHDSS);

				/**

				 * Connect to the host

				 */

				final SshClient ssh = con.connect(new SocketTransport(mTargetMachine, 22), mUserName, true);

				/**

				 * Authenticate the user using password authentication

				 */

				PasswordAuthentication pwd = new PasswordAuthentication();

				pwd.setPassword(mPassword);

				if( ssh.authenticate(pwd) != SshAuthentication.COMPLETE && ssh.isConnected())

				{

					mLogger.fatal("Connection to \"" + mTargetMachine + "\" not authenticated");

					return -1;

				}

				/**

				 * Start a session send a command and read the commands output

				 */

				if (ssh.isAuthenticated()) {

					exitCode = 0;

					if ( command != null && command.length() > 0)

					{

						final SshSession session = ssh.openSessionChannel();

						session.executeCommand(command);

						//	Create two thread

						//	One to read stdout and one to read stderr

						//

						Thread t1 = new Thread(new Runnable(){

							public void run(){

								try {

									BufferedReader in = new BufferedReader(new InputStreamReader(session.getInputStream()));

									String line = null;

									while((line = in.readLine()) != null) {

										mLogger.data(line);

									}

								} catch (IOException e) {

								}

							}

						});

						Thread t2 = new Thread(new Runnable(){

							public void run(){

								try {

									BufferedReader in = new BufferedReader(new InputStreamReader(session.getStderrInputStream()));

									String line = null;

									while((line = in.readLine()) != null) {

										mLogger.data("[ERR]" + line);

									}

								} catch (IOException e) {

								}

							}

						});

						//	Start both threads

						//	Then wait for them to complete

						//	They will complete when the input is exhausted

						t1.start();

						t2.start();

						t1.join();

						t2.join();

		                session.close();

		                exitCode = session.exitCode();

		                if (exitCode ==  SshSession.EXITCODE_NOT_RECEIVED )

		                {

		                    mLogger.info("Exit Code not received. Force zero");

		                    exitCode = 0;

		                }

						mLogger.info("Exit Code:" + exitCode);

					}

				}

				ssh.disconnect();

			} catch (Throwable t) {

				t.printStackTrace();

				mLogger.info("Remote connection exception: " + t.getMessage());

				return -2;

			}

		}

		return exitCode;

	}

}