source: java/main/src/main/java/com/framsticks/running/ExternalProcess.java @ 193

package com.framsticks.running;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

import com.framsticks.params.EventListener;
import com.framsticks.params.EventListeners;
import com.framsticks.params.ParamFlags;
import com.framsticks.params.annotations.AutoAppendAnnotation;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.structure.messages.ValueChange;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.dispatching.AbstractJoinable;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.util.dispatching.Joinable;
import com.framsticks.util.dispatching.JoinableParent;
import com.framsticks.util.dispatching.JoinableState;
import com.framsticks.util.dispatching.RunAt;
import com.framsticks.util.dispatching.Thread;
import com.framsticks.util.dispatching.ThrowExceptionHandler;
import com.framsticks.util.io.Encoding;
import com.framsticks.util.lang.Strings;

@FramsClassAnnotation
public class ExternalProcess extends AbstractJoinable implements JoinableParent {
        private static final Logger log = LogManager.getLogger(ExternalProcess.class);

        protected List<String> arguments = new ArrayList<>();
        protected Process process;
        protected Thread<ExternalProcess> readerThread = new Thread<ExternalProcess>();

        protected PrintWriter input;
        protected BufferedReader output;
        protected Integer exitCode;
        protected String echoInput;
        protected String directory;
        protected String host;

        protected final EventListeners<ValueChange> listeners = new EventListeners<>();

        @AutoAppendAnnotation
        @ParamAnnotation(id = "line_output")
        public void addOutputListener(EventListener<ValueChange> listener) {
                synchronized (listeners) {
                        listeners.add(listener);
                }
        }

        @ParamAnnotation(id = "line_output")
        public void removeOutputListener(EventListener<ValueChange> listener) {
                synchronized (listeners) {
                        listeners.remove(listener);
                }
        }

        /**
         *
         */
        public ExternalProcess() {
                super();
                setName("process");
                arguments.add(null);
        }

        /**
         * @return the command
         */
        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
        public String getCommand() {
                return arguments.get(0);
        }

        /**
         * @param command the command to set
         */
        @ParamAnnotation
        public void setCommand(String command) {
                arguments.set(0, command);
        }

        protected void readerTask() {

                log.debug("reading output from " + this);
                String line;
                try {
                        try {
                                while ((line = output.readLine()) != null) {
                                        log.trace("read line: {}", line);
                                        synchronized (listeners) {
                                                listeners.actionForAll(new ValueChange(line));
                                        }
                                }
                        } catch (IOException e) {
                                throw new FramsticksException().msg("failed to read line from output of process").cause(e);
                        }
                        try {
                                exitCode = process.waitFor();
                        } catch (InterruptedException e) {
                                throw new FramsticksException().msg("failed to wait for process").cause(e);
                        }
                        log.info("process ended {}", this);
                        // process = null;
                } catch (FramsticksException e) {
                        log.error("exception caught in process {}", this, e);
                }
                interruptJoinable();
                // finish();
        }

        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
        public void setDirectory(String directory) {
                this.directory = directory;
        }

        /**
         * @return the host
         */
        public String getHost() {
                return host;
        }

        /**
         * @param host the host to set
         */
        public void setHost(String host) {
                this.host = host;
        }

        @ParamAnnotation
        public String getDirectory() {
                return Strings.toStringNullProof(directory, ".");
        }

        @Override
        protected void joinableStart() {

                final ProcessBuilder builder = new ProcessBuilder();

                builder.redirectErrorStream(true);
                if (host == null) {
                        setDirectory(System.getProperties().get("user.home") + "/" + getDirectory());
                        setCommand(getDirectory() + "/" + getCommand());
                        builder.directory(new File(getDirectory()));
                } else {
                        StringBuilder b = new StringBuilder();
                        setCommand("./" + getCommand());
                        for (String a : arguments) {
                                b.append(" '").append(a).append("'");
                        }
                        arguments = Arrays.asList("ssh", host, "-tt", ("cd " + getDirectory() + " &&" + b.toString()));
                }
                log.info("running process {}", this);

                builder.command(arguments);
                try {
                        process = builder.start();
                        input = new PrintWriter(new OutputStreamWriter(process.getOutputStream(), Encoding.getDefaultCharset()));
                        output = new BufferedReader(new InputStreamReader(process.getInputStream(), Encoding.getDefaultCharset()));

                } catch (IOException e) {
                        throw new FramsticksException().msg("failed to start process").cause(e);
                }

                readerThread.dispatch(new RunAt<ExternalProcess>(ThrowExceptionHandler.getInstance()) {

                        @Override
                        protected void runAt() {
                                readerTask();
                        }

                });
                Dispatching.use(readerThread, this);

                if (echoInput != null) {
                        input.println(echoInput);
                        input.flush();
                }
        }

        @Override
        public String toString() {
                return getName() + arguments;
        }

        /**
         * @return the input
         */
        public PrintWriter getInput() {
                return input;
        }

        /**
         * @return the echoInput
         */
        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
        public String getEchoInput() {
                return echoInput;
        }

        /**
         * @param echoInput the echoInput to set
         */
        @ParamAnnotation
        public void setEchoInput(String echoInput) {
                this.echoInput = echoInput;
        }

        @Override
        protected void joinableInterrupt() {
                process.destroy();
                Dispatching.drop(readerThread, this);
                // finish();
        }

        @Override
        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
        public String getName() {
                return readerThread.getName();
        }

        /**
         * @param name the name to set
         */
        @ParamAnnotation
        public void setName(String name) {
                readerThread.setName(name);
        }

        @Override
        protected void joinableFinish() {

        }

        @Override
        protected void joinableJoin() throws InterruptedException {
                Dispatching.join(readerThread);
        }

        @Override
        public void childChangedState(Joinable joinable, JoinableState state) {
                proceedToState(state);
        }



}