package liquibase.change.core;

 import liquibase.change.AbstractChange;

 import liquibase.change.ChangeMetaData;

 import liquibase.database.Database;

 import liquibase.exception.UnexpectedLiquibaseException;

 import liquibase.exception.ValidationErrors;

 import liquibase.exception.Warnings;

 import liquibase.executor.Executor;

 import liquibase.executor.ExecutorService;

 import liquibase.executor.LoggingExecutor;

 import liquibase.logging.LogFactory;

 import liquibase.sql.Sql;

 import liquibase.statement.SqlStatement;

 import liquibase.statement.core.CommentStatement;

 import liquibase.statement.core.RuntimeStatement;

 import liquibase.util.StreamUtil;

 import liquibase.util.StringUtils;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.List;

 /**

  * Executes a given shell executable.

  */

 public class ExecuteShellCommandChange extends AbstractChange {

     private String executable;

     private List<String> os;

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

     public ExecuteShellCommandChange() {

         super("executeCommand", "Execute Shell Command", ChangeMetaData.PRIORITY_DEFAULT);

     }

     public String getExecutable() {

         return executable;

     }

     public void setExecutable(String executable) {

         this.executable = executable;

     }

     public void addArg(String arg) {

         this.args.add(arg);

     }

     public void setOs(String os) {

         this.os = StringUtils.splitAndTrim(os, ",");

     }

     public List<String> getOs() {

         return os;

     }

     @Override

     public ValidationErrors validate(Database database) {

         return new ValidationErrors();

     }

     @Override

     public Warnings warn(Database database) {

         return new Warnings();

     }

     public SqlStatement[] generateStatements(final Database database) {

         boolean shouldRun = true;

         if (os != null && os.size() > 0) {

             String currentOS = System.getProperty("os.name");

             if (!os.contains(currentOS)) {

                 shouldRun = false;

                 LogFactory.getLogger().info("Not executing on os " + currentOS + " when " + os + " was specified");

             }

         }

         // check if running under not-executed mode (logging output)

         boolean nonExecutedMode = false;

         Executor executor = ExecutorService.getInstance().getExecutor(database);

         if (executor instanceof LoggingExecutor) {

             nonExecutedMode = true;

         }

         if (shouldRun && !nonExecutedMode) {

             return new SqlStatement[] { new RuntimeStatement() {

                 @Override

                 public Sql[] generate(Database database) {

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

                     commandArray.add(executable);

                     commandArray.addAll(args);

                     try {

                         ProcessBuilder pb = new ProcessBuilder(commandArray);

                         pb.redirectErrorStream(true);

                         Process p = pb.start();

                         int returnCode = 0;

                         try {

                             returnCode = p.waitFor();

                         } catch (InterruptedException e) {

                             ;

                         }

                         ByteArrayOutputStream errorStream = new ByteArrayOutputStream();

                         ByteArrayOutputStream inputStream = new ByteArrayOutputStream();

                         StreamUtil.copy(p.getErrorStream(), errorStream);

                         StreamUtil.copy(p.getInputStream(), inputStream);

                         LogFactory.getLogger().severe(errorStream.toString());

                         LogFactory.getLogger().info(inputStream.toString());

                         if (returnCode != 0) {

                             throw new RuntimeException(getCommandString() + " returned an code of " + returnCode);

                         }

                     } catch (IOException e) {

                         throw new UnexpectedLiquibaseException("Error executing command: " + e);

                     }

                     return null;

                 }

             } };

         }

         if (nonExecutedMode) {

             return new SqlStatement[] { new CommentStatement(getCommandString()) };

         }

         return new SqlStatement[0];

     }

     public String getConfirmationMessage() {

         return "Shell command '" + getCommandString() + "' executed";

     }

     private String getCommandString() {

         return executable + " " + StringUtils.join(args, " ");

     }

 }