Java Code Examples for com.jcraft.jsch.ChannelExec#getExitStatus()

/**
 *
 * @param command SSH command to execute
 * @return the exit code
 */
public int execute( String command, boolean waitForCompletion ) {

    try {
        this.command = command;

        execChannel = (ChannelExec) session.openChannel("exec");

        execChannel.setCommand(command);
        execChannel.setInputStream(null);
        execChannel.setPty(true); // Allocate a Pseudo-Terminal. Thus it supports login sessions. (eg. /bin/bash
                                  // -l)

        execChannel.connect(); // there is a bug in the other method channel.connect( TIMEOUT );

        stdoutThread = new StreamReader(execChannel.getInputStream(), execChannel, "STDOUT");
        stderrThread = new StreamReader(execChannel.getErrStream(), execChannel, "STDERR");
        stdoutThread.start();
        stderrThread.start();

        if (waitForCompletion) {

            stdoutThread.getContent();
            stderrThread.getContent();
            return execChannel.getExitStatus();
        }

    } catch (Exception e) {

        throw new JschSshClientException(e.getMessage(), e);
    } finally {

        if (waitForCompletion && execChannel != null) {
            execChannel.disconnect();
        }
    }

    return -1;
}
 

/**
 * Reads std and error remote output which are then wrapped inside {@link RemoteCommandReturnInfo}
 *
 * @param channelExec the channel where the command is sent for execution
 * @param timeout the length of time in ms in which the method waits for a available byte(s) as a result of command
 * @return {@link RemoteCommandReturnInfo}
 */
private RemoteCommandReturnInfo getExecRemoteCommandReturnInfo(final ChannelExec channelExec, final long timeout)
        throws IOException, JSchException {

    final String output = scrubberService.scrub(readExecRemoteOutput(channelExec, timeout));
    LOGGER.debug("remote output = {}", output);

    String errorOutput = null;

    // wait for the channel to close before checking the exit status
    final long startTime = System.currentTimeMillis();
    while (!channelExec.isClosed()) {
        if ((System.currentTimeMillis() - startTime) > CHANNEL_EXEC_CLOSE_TIMEOUT) {
            errorOutput = MessageFormat.format("Wait for channel to close timeout! Timeout = {0} ms",
                    CHANNEL_EXEC_CLOSE_TIMEOUT);
            LOGGER.error(errorOutput);
            break;
        }
    }

    LOGGER.debug("Channel exec exit status = {}", channelExec.getExitStatus());

    if (channelExec.getExitStatus() != 0 && channelExec.getExitStatus() != -1) {
        errorOutput = readExecRemoteOutput(channelExec, timeout);
        LOGGER.debug("remote error output = {}", errorOutput);
    }

    return new RemoteCommandReturnInfo(channelExec.getExitStatus(), output, errorOutput);
}
 

/**
 * check for existence of file or dir on target system
 *
 * @param filePath
 *            to the object to check
 * @param session
 *            to use
 * @return true: object exists, false otherwise
 */
private boolean checkExistence(String filePath, Session session) throws IOException {
    Message.debug("SShRepository: checkExistence called: " + filePath);
    ChannelExec channel = null;
    channel = getExecChannel(session);
    String fullCmd = replaceArgument(existCommand, filePath);
    channel.setCommand(fullCmd);
    StringBuilder stdOut = new StringBuilder();
    StringBuilder stdErr = new StringBuilder();
    readSessionOutput(channel, stdOut, stdErr);
    return channel.getExitStatus() == 0;
}
 

/**
 * Executes a command and returns the (standard) output through a StringBuilder.
 *
 * @param command The command
 * @param output  The output
 * @return The exit code of the command
 * @throws JSchException       if a JSch error is detected.
 * @throws FileSystemException if a session cannot be created.
 * @throws IOException         if an I/O error is detected.
 */
private int executeCommand(final String command, final StringBuilder output) throws JSchException, IOException {
    final ChannelExec channel = (ChannelExec) getSession().openChannel("exec");
    try {
        channel.setCommand(command);
        channel.setInputStream(null);
        try (final InputStreamReader stream = new InputStreamReader(channel.getInputStream())) {
            channel.setErrStream(System.err, true);
            channel.connect(connectTimeoutMillis);

            // Read the stream
            final char[] buffer = new char[EXEC_BUFFER_SIZE];
            int read;
            while ((read = stream.read(buffer, 0, buffer.length)) >= 0) {
                output.append(buffer, 0, read);
            }
        }

        // Wait until the command finishes (should not be long since we read the output stream)
        while (!channel.isClosed()) {
            try {
                Thread.sleep(SLEEP_MILLIS);
            } catch (final Exception ee) {
                // TODO: swallow exception, really?
            }
        }
    } finally {
        channel.disconnect();
    }
    return channel.getExitStatus();
}
 

/**
 *
 * {@link  org.apache.commons.vfs2.provider.sftp.SftpFileSystem#executeCommand(java.lang.String, java.lang.StringBuilder) }
 */
private int executeCommand( String command, StringBuilder output ) throws JSchException, IOException {
  this.ensureSession();
  ChannelExec channel = (ChannelExec) this.session.openChannel( "exec" );
  channel.setCommand( command );
  channel.setInputStream( (InputStream) null );
  InputStreamReader stream = new InputStreamReader( channel.getInputStream() );
  channel.setErrStream( System.err, true );
  channel.connect();
  char[] buffer = new char[128];

  int read;
  while ( ( read = stream.read( buffer, 0, buffer.length ) ) >= 0 ) {
    output.append( buffer, 0, read );
  }

  stream.close();

  while ( !channel.isClosed() ) {
    try {
      Thread.sleep( 100L );
    } catch ( Exception exc ) {
      log.logMinimal( "Warning: Error session closing. " + exc.getMessage() );
    }
  }

  channel.disconnect();
  return channel.getExitStatus();
}
 

/**
 * Seems there are bad naming in the library the sysout is in
 * channel.getInputStream(); the syserr is in
 * ((ChannelExec)channel).setErrStream(os);
 *
 * @param channel
 *            the channel
 * @return the response on singe request
 */
public ResponseOnSingeRequest executeAndGenResponse(ChannelExec channel) {
    ResponseOnSingeRequest sshResponse = new ResponseOnSingeRequest();

    InputStream in = null;
    OutputStream outputStreamStdErr = new ByteArrayOutputStream();
    StringBuilder sbStdOut = new StringBuilder();
    try {

        in = channel.getInputStream();
        channel.setErrStream(outputStreamStdErr);

        byte[] tmp = new byte[ParallecGlobalConfig.sshBufferSize];
        while (true) {
            while (in.available() > 0) {
                int i = in.read(tmp, 0, ParallecGlobalConfig.sshBufferSize);
                if (i < 0)
                    break;
                sbStdOut.append(new String(tmp, 0, i));

            }

            if (channel.isClosed()) {
                if (in.available() > 0)
                    continue;
                sshResponse.setFailObtainResponse(false);

                // exit 0 is good
                int exitStatus = channel.getExitStatus();
                sshResponse.setStatusCodeInt(exitStatus);
                sshResponse.setStatusCode(Integer.toString(exitStatus));
                break;
            }

            Thread.sleep(ParallecGlobalConfig.sshSleepMIllisBtwReadBuffer);
        }

        sshResponse.setResponseBody(sbStdOut.toString());
        sshResponse.setErrorMessage(outputStreamStdErr.toString());
        sshResponse.setReceiveTimeNow();
    } catch (Exception t) {
        throw new RuntimeException(t);
    }

    return sshResponse;
}