/*
    * Copyright (C) 2018, Markus Duft <markus.duft@ssi-schaefer.com> and others
    *
    * This program and the accompanying materials are made available under the
    * terms of the Eclipse Distribution License v. 1.0 which is available at
    * https://www.eclipse.org/org/documents/edl-v10.php.
    *
    * SPDX-License-Identifier: BSD-3-Clause
    */
  package org.eclipse.jgit.util;
  
  import java.io.IOException;
  import java.text.MessageFormat;
  import java.util.concurrent.TimeUnit;
  
  import org.eclipse.jgit.annotations.Nullable;
  import org.eclipse.jgit.errors.CommandFailedException;
  import org.eclipse.jgit.internal.JGitText;
  import org.eclipse.jgit.transport.CredentialsProvider;
  import org.eclipse.jgit.transport.RemoteSession;
  import org.eclipse.jgit.transport.SshSessionFactory;
  import org.eclipse.jgit.transport.URIish;
  import org.eclipse.jgit.util.io.MessageWriter;
  import org.eclipse.jgit.util.io.StreamCopyThread;
  
  /**
   * Extra utilities to support usage of SSH.
   *
   * @since 5.0
   */
  public class SshSupport {
  
  	/**
  	 * Utility to execute a remote SSH command and read the first line of
  	 * output.
  	 *
  	 * @param sshUri
  	 *            the SSH remote URI
  	 * @param provider
  	 *            the {@link CredentialsProvider} or <code>null</code>.
  	 * @param fs
  	 *            the {@link FS} implementation passed to
  	 *            {@link SshSessionFactory}
  	 * @param command
  	 *            the remote command to execute.
  	 * @param timeout
  	 *            a timeout in seconds. The timeout may be exceeded in corner
  	 *            cases.
  	 * @return The entire output read from stdout.
  	 * @throws IOException
  	 * @throws CommandFailedException
  	 *             if the ssh command execution failed, error message contains
  	 *             the content of stderr.
  	 */
  	public static String runSshCommand(URIish sshUri,
  			@Nullable CredentialsProvider provider, FS fs, String command,
  			int timeout) throws IOException, CommandFailedException {
  		RemoteSession session = null;
  		Process process = null;
  		StreamCopyThread errorThread = null;
  		StreamCopyThread outThread = null;
  		CommandFailedException failure = null;
  		@SuppressWarnings("resource")
  		MessageWriter stderr = new MessageWriter();
  		@SuppressWarnings("resource")
  		MessageWriter stdout = new MessageWriter();
  		String out;
  		try {
  			long start = System.nanoTime();
  			session = SshSessionFactory.getInstance().getSession(sshUri,
  					provider, fs, 1000 * timeout);
  			int commandTimeout = timeout;
  			if (timeout > 0) {
  				commandTimeout = checkTimeout(command, timeout, start);
  			}
  			process = session.exec(command, commandTimeout);
  			if (timeout > 0) {
  				commandTimeout = checkTimeout(command, timeout, start);
  			}
  			errorThread = new StreamCopyThread(process.getErrorStream(),
  					stderr.getRawStream());
  			errorThread.start();
  			outThread = new StreamCopyThread(process.getInputStream(),
  					stdout.getRawStream());
  			outThread.start();
  			try {
  				boolean finished = false;
  				if (timeout <= 0) {
  					process.waitFor();
  					finished = true;
  				} else {
  					finished = process.waitFor(commandTimeout,
  							TimeUnit.SECONDS);
  				}
  				if (finished) {
  					out = stdout.toString();
  				} else {
  					out = null; // still running after timeout
  				}
 			} catch (InterruptedException e) {
 				out = null; // error
 			}
 		} finally {
 			if (errorThread != null) {
 				try {
 					errorThread.halt();
 				} catch (InterruptedException e) {
 					// Stop waiting and return anyway.
 				} finally {
 					errorThread = null;
 				}
 			}
 			if (outThread != null) {
 				try {
 					outThread.halt();
 				} catch (InterruptedException e) {
 					// Stop waiting and return anyway.
 				} finally {
 					outThread = null;
 				}
 			}
 			if (process != null) {
 				try {
 					if (process.exitValue() != 0) {
 						failure = new CommandFailedException(
 								process.exitValue(),
 								MessageFormat.format(
 										JGitText.get().sshCommandFailed,
 										command, stderr.toString()));
 					}
 					// It was successful after all
 					out = stdout.toString();
 				} catch (IllegalThreadStateException e) {
 					failure = new CommandFailedException(0,
 							MessageFormat.format(
 									JGitText.get().sshCommandTimeout, command,
 									Integer.valueOf(timeout)));
 				}
 				process.destroy();
 			}
 			stderr.close();
 			stdout.close();
 			if (session != null) {
 				SshSessionFactory.getInstance().releaseSession(session);
 			}
 		}
 		if (failure != null) {
 			throw failure;
 		}
 		return out;
 	}
 
 	private static int checkTimeout(String command, int timeout, long since)
 			throws CommandFailedException {
 		long elapsed = System.nanoTime() - since;
 		int newTimeout = timeout
 				- (int) TimeUnit.NANOSECONDS.toSeconds(elapsed);
 		if (newTimeout <= 0) {
 			// All time used up for connecting the session
 			throw new CommandFailedException(0,
 					MessageFormat.format(JGitText.get().sshCommandTimeout,
 							command, Integer.valueOf(timeout)));
 		}
 		return newTimeout;
 	}
 }