SSHHandlerTarget.java

package com.atsebak.embeddedlinuxjvm.protocol.ssh;

import com.atsebak.embeddedlinuxjvm.commandline.JavaStatusChecker;
import com.atsebak.embeddedlinuxjvm.commandline.LinuxCommand;
import com.atsebak.embeddedlinuxjvm.console.EmbeddedLinuxJVMConsoleView;
import com.atsebak.embeddedlinuxjvm.localization.EmbeddedLinuxJVMBundle;
import com.atsebak.embeddedlinuxjvm.protocol.ssh.jsch.EmbeddedSSHClient;
import com.atsebak.embeddedlinuxjvm.protocol.ssh.jsch.SFTPHandler;
import com.atsebak.embeddedlinuxjvm.runner.data.EmbeddedLinuxJVMRunConfigurationRunnerParameters;
import com.atsebak.embeddedlinuxjvm.utils.FileUtilities;
import com.intellij.execution.configurations.RuntimeConfigurationException;
import com.intellij.execution.ui.ConsoleViewContentType;
import com.intellij.notification.Notification;
import com.intellij.notification.NotificationType;
import com.intellij.notification.Notifications;
import com.intellij.openapi.application.ApplicationManager;
import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import lombok.Builder;
import lombok.SneakyThrows;
import org.jetbrains.annotations.NotNull;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Vector;

@Builder
public class SSHHandlerTarget {
    public static final String NEW_LINE = System.getProperty("line.separator");
    private static final String OUTPUT_LOCATION = "IdeaProjects";
    private static final String EMBEDDED_LINUX_HOME = "home";
    private EmbeddedLinuxJVMRunConfigurationRunnerParameters params;
    private EmbeddedLinuxJVMConsoleView consoleView;
    private EmbeddedSSHClient ssh;

    /**
     * Uploads Java application output folders
     *
     * @param compileOutput Output directory folder where to store the java application
     * @param cmd           The command to execute on the java files
     * @throws IOException
     * @throws ClassNotFoundException
     * @throws RuntimeConfigurationException
     */
    public void uploadAndRunJavaApp(@NotNull final File compileOutput, @NotNull final String cmd)
            throws IOException, ClassNotFoundException, RuntimeConfigurationException {
        final String remoteDir = FileUtilities.SEPARATOR + EMBEDDED_LINUX_HOME + FileUtilities.SEPARATOR
                + params.getUsername() + FileUtilities.SEPARATOR + OUTPUT_LOCATION;
        String deploymentPath = remoteDir + FileUtilities.SEPARATOR + consoleView.getProject().getName();
        genericUpload(deploymentPath, compileOutput);
        runJavaApp(deploymentPath, cmd);
    }

    /**
     * Generic SSh Ftp uploader
     *
     * @param deploymentPath the remote location storing the compressed file
     * @param fileToUpload   files to upload
     * @throws IOException
     * @throws RuntimeConfigurationException
     */
    public void genericUpload(@NotNull final String deploymentPath, @NotNull final File fileToUpload) throws IOException, RuntimeConfigurationException {
        forceCreateDirectories(deploymentPath);
        Session session = connect(ssh.get());
        try {
            SFTPHandler sftpHandler = new SFTPHandler(consoleView);
            sftpHandler.upload(session, fileToUpload, deploymentPath);
        } catch (Exception e) {
            setErrorOnUI(e.getMessage());
        }
    }


    /**
     * Force create directories, if it exists it won't do anything
     *
     * @param path
     * @throws IOException
     * @throws RuntimeConfigurationException
     */
    private void forceCreateDirectories(@NotNull final String path) throws IOException, RuntimeConfigurationException {
        Session session = connect(ssh.get());
        try {
            ChannelExec channelExec = (ChannelExec) session.openChannel("exec");
            List<String> commands = Arrays.asList(
                    String.format("mkdir -p %s", path),
                    String.format("cd %s", path),
                    String.format("mkdir -p %s", FileUtilities.CLASSES),
                    String.format("mkdir -p %s", FileUtilities.LIB),
                    String.format("cd %s", path + FileUtilities.SEPARATOR + FileUtilities.CLASSES),
                    "rm -rf *"
            );
            for (String command : commands) {
                consoleView.print(EmbeddedLinuxJVMBundle.getString("pi.deployment.command") + command + NEW_LINE, ConsoleViewContentType.SYSTEM_OUTPUT);
            }
            channelExec.setCommand(LinuxCommand.builder().commands(commands).build().toString());
            channelExec.connect();
            channelExec.disconnect();
        } catch (JSchException e) {
            setErrorOnUI(e.getMessage());
        }
    }

    /**
     * Runs that java app with the specified command and then takes the console output from target to host machine
     *
     * @param path
     * @param cmd
     * @throws IOException
     */
    private void runJavaApp(@NotNull final String path, @NotNull final String cmd) throws IOException, RuntimeConfigurationException {
        consoleView.print(NEW_LINE + EmbeddedLinuxJVMBundle.getString("pi.deployment.build") + NEW_LINE + NEW_LINE, ConsoleViewContentType.SYSTEM_OUTPUT);
        Session session = connect(ssh.get());
        consoleView.setSession(session);
        try {
            ChannelExec channelExec = (ChannelExec) session.openChannel("exec");
            channelExec.setOutputStream(System.out, true);
            channelExec.setErrStream(System.err, true);
            List<String> commands = Arrays.asList(
                    String.format("%s kill -9 $(ps -efww | grep \"%s\"| grep -v grep | tr -s \" \"| cut -d\" \" -f2)", params.isRunAsRoot() ? "sudo" : "", params.getMainclass()),
                    String.format("cd %s", path),
                    String.format("tar -xvf %s.tar", consoleView.getProject().getName()),
                    "rm *.tar",
                    cmd);
            for (String command : commands) {
                consoleView.print(EmbeddedLinuxJVMBundle.getString("pi.deployment.command") + command + NEW_LINE, ConsoleViewContentType.SYSTEM_OUTPUT);
            }
            channelExec.setCommand(LinuxCommand.builder().commands(commands).build().toString());
            channelExec.connect();
            checkOnProcess(channelExec);
        } catch (JSchException e) {
            setErrorOnUI(e.getMessage());
        }
    }

    /**
     * Checks if command is done running
     */
    private void checkOnProcess(@NotNull final ChannelExec channelExec) {
        ApplicationManager.getApplication().executeOnPooledThread(new JavaStatusChecker(channelExec, consoleView));
    }

    public Vector getAlreadyDeployedLibraries() throws JSchException {
        final String remoteDir = FileUtilities.SEPARATOR + EMBEDDED_LINUX_HOME + FileUtilities.SEPARATOR
                + params.getUsername() + FileUtilities.SEPARATOR + OUTPUT_LOCATION;
        String path = remoteDir + FileUtilities.SEPARATOR + consoleView.getProject().getName();
        String jarsPath = path + FileUtilities.SEPARATOR + FileUtilities.LIB;
        SFTPHandler handler = new SFTPHandler();
        Session session = connect(ssh.get());
        return handler.getFiles(session, jarsPath);
    }

    /**
     * Authenticates and connects to remote target via ssh protocol
     * @param session
     * @return
     */
    @SneakyThrows({RuntimeConfigurationException.class})
    private Session connect(Session session) {
        if (!session.isConnected()) {
            session = EmbeddedSSHClient.builder()
                    .username(params.getUsername())
                    .password(params.getPassword())
                    .hostname(params.getHostname())
                    .port(params.getSshPort())
                    .build().get();
            if (!session.isConnected()) {
                setErrorOnUI(EmbeddedLinuxJVMBundle.getString("ssh.remote.error"));
                throw new RuntimeConfigurationException(EmbeddedLinuxJVMBundle.getString("ssh.remote.error"));
            } else {
                return session;
            }
        }
        return session;
    }

    /**
     * Sets errors on the UI
     *
     * @param message
     */
    private void setErrorOnUI(@NotNull final String message) {
        final Notification notification = new Notification(
                com.atsebak.embeddedlinuxjvm.utils.Notifications.GROUPDISPLAY_ID,
                EmbeddedLinuxJVMBundle.getString("pi.ssh.connection.error"), message,
                NotificationType.INFORMATION);
        Notifications.Bus.notify(notification);
    }
}