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

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.LinkedList;
import java.util.List;


import org.apache.log4j.Logger;

import com.framsticks.params.annotations.AutoAppendAnnotation;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.Misc;
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;

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

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

        protected PrintWriter input;
        protected BufferedReader output;
        protected Integer exitCode;

        protected final List<OutputListener> listeners = new LinkedList<>();

        @AutoAppendAnnotation
        public void addListener(OutputListener listener) {
                synchronized (listeners) {
                        listeners.add(listener);
                }
        }

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

        /**
         * @return the command
         */
        @ParamAnnotation
        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() {

                String line;
                try {
                        try {
                                while ((line = output.readLine()) != null) {
                                        log.trace("read line: " + line);
                                        synchronized (listeners) {
                                                for (OutputListener l : listeners) {
                                                        l.onLineRead(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.debug("process ended " + this);
                        // process = null;
                } catch (FramsticksException e) {
                        log.error("exception caught in process " + this, e);
                }
                interrupt();
                // finish();
        }

        @ParamAnnotation
        public void setDirectory(String directory) {
                builder.directory(new File(directory));
        }

        @ParamAnnotation
        public String getDirectory() {
                return builder.directory().getName();
        }

        @Override
        protected void joinableStart() {
                log.debug("running process with arguments: " + arguments);
                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);
        }

        @Override
        public String toString() {
                return getName() + "[" + Misc.returnNotNull(getCommand(), "?") + "]";
        }

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

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

        @Override
        @ParamAnnotation
        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);
        }



}