EDIT

/**

* Copyright (C) 2020 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.drush;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Scanner;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.SystemUtils;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

/**

 * @author a.kohlbecker

 * @since Jul 31, 2020

 */

public class DrushExecuter {

    public static final Logger logger = Logger.getLogger(DrushExecuter.class);

    public URI getSiteURI() {

        return siteURI;

    }

    public void setSiteURI(URI siteURI) {

        this.siteURI = siteURI;

    }

    public File getDrupalRoot() {

        return drupalRoot;

    }

    public void setDrupalRoot(File drupalRoot) {

        this.drupalRoot = drupalRoot;

    }

    public URI siteURI = null;

    public File drupalRoot = null;

    public DrushExecuter() throws IOException, InterruptedException {

       findDrushCommand();

    }

    /**

     * List indexes returned from <code>DrushExecuter.execute(DrushCommand cmd, String... value)</code>:

     *

     * <ol>

     * <li>major</li>

     * <li>minor</li>

     * <li>patch</li>

     * <ol>

     */

    public static DrushCommand version = new DrushCommand(Arrays.asList("--version"), "Drush Version\\s+:\\s+(?<major>\\d+)\\.(?<minor>\\d+)\\.(?<patch>\\d+)", null);

    public static DrushCommand help = new DrushCommand(Arrays.asList("help"), null, null);

    public static DrushCommand coreStatus = new DrushCommand(Arrays.asList("core-status"), null, null);

    /**

     * List indexes returned from <code>DrushExecuter.execute(DrushCommand cmd, String... value)</code>:

     * Multiple matches are possible:

     * <ol>

     * <li>value</li>

     * <li>value</li>

     * <li>value</li>

     * <ol>

     */

    public static DrushCommand variableGet = new DrushCommand(Arrays.asList("vget", "%s"), ".*:\\s+'(?<value>.*)'", null);

    /**

     * List indexes returned from <code>DrushExecuter.execute(DrushCommand cmd, String... value)</code>:

     * Multiple matches are possible:

     * <ol>

     * <li>value</li>

     * <li>status</li>

     * <ol>

     */

    public static DrushCommand variableSet = new DrushCommand(Arrays.asList("--yes", "vset", "%s", "%s"), null,  "[^\\\"]*\\\"(?<value>.*)\\\"\\.\\s+\\[(?<status>\\w+)\\]");

    /**

     * @throws IOException if an I/O error occurs in the ProcessBuilder

     * @throws InterruptedException if the Process was interrupted

     */

    private void findDrushCommand() throws IOException, InterruptedException {

        if(SystemUtils.IS_OS_WINDOWS) {

            throw new RuntimeException("not yet implmented for Windows");

        }

        List<String> matches = execute(version);

        assert !matches.get(0).isEmpty() : "No suitable drush command found in the system";

        String majorVersion = matches.get(0);

        if(Integer.valueOf(majorVersion) < 8) {

            throw new RuntimeException("drush version >= 8 required");

        }

    }

    /**

     * @throws IOException if an I/O error occurs in the ProcessBuilder

     * @throws InterruptedException if the Process was interrupted

     */

    public List<String> execute(DrushCommand cmd, String ...value ) throws IOException, InterruptedException {

        List<String> executableWithArgs = new ArrayList<>();

        executableWithArgs.add("drush");

        if(drupalRoot != null) {

            executableWithArgs.add("--root="+drupalRoot.toString());

        }

        if(siteURI != null) {

            executableWithArgs.add("--uri=" + siteURI.toString());

        }

        int commandSubstitutions = 0;

        for(String arg  : cmd.args) {

            if(arg.contains("%s")) {

                executableWithArgs.add(String.format(arg, value[commandSubstitutions]));

                commandSubstitutions++;

            } else {

                executableWithArgs.add(arg);

            }

        }

        List<String> matches = new ArrayList<>();

        ProcessBuilder pb = new ProcessBuilder(executableWithArgs);

        logger.debug("Command: " + pb.command().toString());

        Process process = pb.start();

        int exitCode = process.waitFor();

        if(exitCode == 0) {

            String out = readExecutionResponse(matches, process.getInputStream(), cmd.outRegex);

            String error = readExecutionResponse(matches, process.getErrorStream(), cmd.errRegex);

            if(out != null && !out.isEmpty()) {

                logger.error(error);

            }

            if(error != null && !error.isEmpty()) {

                logger.error(error);

            }

        } else {

            throw new RuntimeException(IOUtils.toString(process.getErrorStream()));

        }

        return matches;

    }

    protected String readExecutionResponse(List<String> matches, InputStream stream, Pattern regex) throws IOException {

        String out;

        if(regex != null) {

            Scanner scanner = new Scanner(stream);

            while(true) {

                out = scanner.findWithinHorizon(regex, 0);

                if(out == null) {

                    break;

                }

                if(out != null) {

                    Matcher m = regex.matcher(out);

                    int patternMatchCount = 0;

                    while(m.find()) {

                        patternMatchCount++;

                        if(m.groupCount() > 0) {

                            for(int g = 1 ; g <= m.groupCount(); g++) {

                                matches.add(m.group(g));

                                logger.debug("match[" + patternMatchCount + "."+ g + "]: " + m.group(g));

                            }

                        } else {

                            matches.add(m.group(0));

                            logger.debug("entire pattern match[" + patternMatchCount + ".0]: " + m.group(0));

                        }

                    }

                }

            }

            scanner.close();

            return null;

        } else {

            out = IOUtils.toString(stream);

            logger.debug(out);

            return out;

        }

    }

    public static class DrushCommand {

        Pattern outRegex;

        Pattern errRegex;

        List<String> args = new ArrayList<>();

        public DrushCommand(List<String> args, String outRegex, String errRegex) {

            this.args = args;

            if(outRegex != null) {

                this.outRegex = Pattern.compile(outRegex, Pattern.MULTILINE);

            }

            if(errRegex != null) {

                this.errRegex = Pattern.compile(errRegex, Pattern.MULTILINE);

            }

        }

    }

    public static void main(String[] args) throws URISyntaxException  {

        DrushExecuter.logger.setLevel(Level.DEBUG);

        try {

            DrushExecuter dex = new DrushExecuter();

            dex.setDrupalRoot(new File("/home/andreas/workspaces/www/drupal-7"));

            dex.setSiteURI(new URI("http://edit.test/d7/caryophyllales/"));

//            dex.execute(coreStatus);

//            dex.execute(help);

//            dex.execute(variableGet, "cdm_webservice_url");

            dex.execute(variableSet, "cdm_webservice_url", "http://api.cybertaxonomy.org/cyprus/");

        } catch (IOException | InterruptedException | AssertionError e) {

            e.printStackTrace();

        }

    }

}