Application: gvSIG desktop » gvSIG scripting

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

package org.gvsig.scripting.app.extension;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.nio.file.FileVisitOption;

import static java.nio.file.FileVisitOption.FOLLOW_LINKS;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributes;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.List;

import java.util.function.Predicate;

import java.util.logging.Level;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingLocator;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.scripting.ScriptingUnit;

import org.gvsig.scripting.app.extension.messagewait.MessageWait;

import org.gvsig.scripting.swing.api.JScriptingComposer;

import org.gvsig.scripting.swing.api.ScriptingSwingLocator;

import org.gvsig.scripting.swing.api.ScriptingUIManager;

import static org.gvsig.scripting.swing.api.ScriptingUIManager.SCRIPT_COMPOSER_AUTORUN;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.impl.windowmanager.DefaultWindowManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.Invocable;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

public class ScriptingExtension extends Extension {

    private static final Logger logger = LoggerFactory.getLogger(ScriptingExtension.class);

    private PluginServices plugin = null;

    private static final String SKIP_AUTORUNS = "skipAutoruns";

    /*

     * la funcion log y las constantes estan pensadas para usarlas desde los scripts.

     */

    public static final int INFO = 0;

    public static final int TRACE = 1;

    public static final int WARN = 2;

    public static final int ERROR = 3;

    private static boolean composer_initialized = false;

    private boolean executingAutorunScripts = true;

    private MessageWait message;

    public static void log(String message) {

        log(INFO, message, null);

    }

    public static void log(int level, String message) {

        log(level, message, null);

    }

    public static void log(int level, String message, Throwable th) {

        switch( level ) {

        case TRACE:

            logger.trace(message, th);

            break;

        case ERROR:

            logger.error(message, th);

            break;

        case WARN:

            logger.warn(message, th);

            break;

        default:

        case INFO:

            logger.info(message, th);

            break;

        }

    }

    @Override

    public PluginServices getPlugin() {

        if( this.plugin == null ) {

            this.plugin = PluginsLocator.getManager().getPlugin(ScriptingExtension.class);

        }

        return this.plugin;

    }

    @Override

    public void execute(String actionCommand) {

        this.execute(actionCommand, null);

    }

    @Override

    public void execute(String command, Object[] args) {

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

        WindowManager winmanager = ToolsSwingLocator.getWindowManager();

        if( "tools-scripting-launcher".equalsIgnoreCase(command) ) {

            winmanager.showWindow(uimanager.createLauncher().asJComponent(), uimanager.getTranslation("Scripting_Launcher"), WindowManager.MODE.TOOL);

        } else if( "tools-scripting-composer".equalsIgnoreCase(command) ) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            message.showMessage(

                i18n.getTranslation("_notice"),

                i18n.getTranslation("_Initializing_the_scripting_plugin_Xhorizontal_ellipsisX") + "\n" + 

                    i18n.getTranslation("_Waiting_to_terminate"), 

                new MessageWait.WaitingCondition() {

                    private Thread th = null;

                    @Override

                    public boolean stopWaiting() {

                        if( executingAutorunScripts ) {

                            return false;

                        }

                        if( composer_initialized ) {

                            return true;

                        }

                        if( th == null ) {

                            th = new Thread(new StartupScriptingComposer(), "StartupScriptingComposer");

                            th.start();

                        }

                        return false;

                    }

                },

                new Runnable() {

                    @Override

                    public void run() {

                            showScriptingComposer();

                    }

                }

            );

        } else {

            ScriptingBaseScript script = uimanager.getManager().getScript(command);

            if( script != null ) {

                script.run(args);

            } else {

                ApplicationManager application = ApplicationLocator.getManager();

                application.messageDialog(

                        "Can't locate script '" + command + "'.", 

                        "ScriptLaunch", 

                        JOptionPane.OK_OPTION

                );

            }

        }

    }

    private void showScriptingComposer() {

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

        WindowManager winmanager = ToolsSwingLocator.getWindowManager();

        DynObject preferences = getPlugin().getPluginProperties();

        Boolean composerUseHisWindowManager = (Boolean) preferences.getDynValue("ComposerUseHisWindowManager");

        ScriptingUIManager uiManager = ScriptingSwingLocator.getUIManager();

        if( composerUseHisWindowManager ) {

            winmanager = new DefaultWindowManager();

            uiManager.setWindowManager(winmanager);

        }

        JScriptingComposer composer = uimanager.createComposer();

        uiManager.showWindow(

            composer.asJComponent(),

            uimanager.getTranslation("Scripting_Composer")

        );

    }

    private class StartupScriptingComposer implements Runnable {

        @Override

        public void run() {            

            SimpleTaskStatus status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Script composer startup");

            status.setIndeterminate();

            status.setAutoremove(true);

            status.add();

            final ApplicationManager application = ApplicationLocator.getManager();

            final I18nManager i18nManager = ToolsLocator.getI18nManager();            

            try {

                logger.info("Searching autorun scripts...");

                application.message(

                    i18nManager.getTranslation("_Searching_autorun_scripts_Xhorizontal_ellipsisX"),

                    JOptionPane.INFORMATION_MESSAGE

                );

                ScriptingManager manager = ScriptingLocator.getManager();

                final List<ScriptingScript> autoruns = new ArrayList<>();

                Visitor visitor = new Visitor() {

                    @Override

                    public void visit(Object o) throws VisitCanceledException, BaseException {

                        ScriptingUnit unit = (ScriptingUnit) o;

                        if( unit instanceof ScriptingScript && SCRIPT_COMPOSER_AUTORUN.equalsIgnoreCase(unit.getId()) ) {

                            ScriptingScript autorun = (ScriptingScript) unit;

                            if( autorun.isEnabled() ) {

                                autoruns.add(autorun);

                            } else {

                                logger.info("Skip scautorun script '" + autorun.getFile().getAbsolutePath() + "'.");

                            }

                        }

                    }

                };

                manager.getSystemFolder().accept(visitor);

                manager.getUserFolder().accept(visitor, new Predicate<ScriptingUnit>() {

                    @Override

                    public boolean test(ScriptingUnit unit) {

                        if( unit instanceof ScriptingFolder ) {

                            return !BooleanUtils.toBoolean(unit.getProperty(SKIP_AUTORUNS));

                        }

                        return false;

                    }

                });

                if( !autoruns.isEmpty() ) {

                    status.setRangeOfValues(0, autoruns.size());

                    int n=0;

                    for (ScriptingScript autorun : autoruns) {

                        status.setCurValue(n++);

                        try {

                            logger.info("running autorun script '" + autorun.getFile().getAbsolutePath() + ".");

                            application.message(

                                i18nManager.getTranslation(

                                    "_Running_autorun_script_from_XnameX",

                                    new String[]{

                                            autorun.getFile().getParentFile().getName()}

                                ),

                                JOptionPane.INFORMATION_MESSAGE

                            );

                        } catch (Exception ex) {

                            // Ignore it

                        }

                        try {

                            autorun.run();

                        } catch (Exception ex) {

                            logger.warn("Can't execute autorun from '" + autorun.getFile().getAbsolutePath() + "'.", ex);

                        }

                    }

                }

            } catch(Throwable th) {

            } finally {

                logger.info("Running autorun scripts terminated.");

                application.message("", JOptionPane.INFORMATION_MESSAGE);

                status.terminate();

                composer_initialized = true;

            }

        }

    }

    @Override

    public void initialize() {

        IconThemeHelper.registerIcon("action", "tools-scripting-launcher", this);

        IconThemeHelper.registerIcon("action", "tools-scripting-composer", this);

        IconThemeHelper.registerIcon("action", "tools-scripting-console-jython", this);

        this.message = new MessageWait();

        initPaths();

        Thread th = new Thread(new Runnable() {

            @Override

            public void run() {

                preloadPythonEngine();

            }

        }, "ScriptEnginesInitializer");

        th.start();

        try {

            th.join(3000); // force change to other thread

        } catch (InterruptedException ex) {

            // Ignore.

        }

    }

    private void preloadPythonEngine() {

        ScriptingManager manager = (ScriptingManager) ScriptingLocator.getManager();

        synchronized (manager) {

            String respath = "/scripting/langs/python/preload.py";

            InputStream res = this.getClass().getResourceAsStream(respath);

            if( res != null ) {

                logger.info("Scan for script engines");

                List<String> lines;

                try {

                    lines = IOUtils.readLines(res);

                    String code = StringUtils.join(lines, "\n");

                    logger.info("Preload python script engine");

                    Script script = manager.createScript(

                        "preload",

                        code,

                        ScriptingManager.PYTHON_LANGUAGE_NAME

                    );

                    logger.info("Preload python modules");

                    script.invokeFunction("main", null);

                } catch (Exception ex) {

                    logger.warn("Can't run preload script for python.", ex);

                }

                logger.info("Preload of script engines finished");

            }

        }

    }

    private File getScriptsHomeFolder() {

        PluginsManager pluginManager = PluginsLocator.getManager();

        File pluginHomeFolder = this.getPlugin().getPluginHomeFolder();

        File scriptsHomeFolder = null;

        File f = FileUtils.getFile(pluginHomeFolder, "scripts-folder.txt");

        if( f.exists() ) {

            try {

                List<String> lines = FileUtils.readLines(f);

                for( String line : lines ) {

                    line = line.trim();

                    if( !line.startsWith("#") ) {

                        scriptsHomeFolder = new File(line);

                        if( !scriptsHomeFolder.isAbsolute() ) {

                            scriptsHomeFolder = new File(pluginHomeFolder, line);

                        }

                        scriptsHomeFolder = new File(

                            FilenameUtils.normalizeNoEndSeparator(

                                scriptsHomeFolder.getAbsolutePath(),

                                true

                            )

                        );

                        if( scriptsHomeFolder.exists() ) {

                            return scriptsHomeFolder;

                        }

                    }

                }

            } catch (IOException ex) {

            }

        } else {

            try {

                FileUtils.touch(f);

            } catch (IOException ex) {

            }

        }

        String gvsigversion = pluginManager.getApplicationVersion().format("%M.%m.0") ;

        scriptsHomeFolder = FileUtils.getFile(pluginHomeFolder, gvsigversion) ;

        return scriptsHomeFolder;

    }

    private void initPaths() {

        PluginsManager pluginManager = PluginsLocator.getManager();

        ScriptingManager manager = ScriptingLocator.getManager();

        manager.setHomeFolder(getScriptsHomeFolder());

        ScriptingFolder folder = manager.createLink(

            "Common",

            manager.getUserFolder(), 

            "../../scripts"

        );

        folder.setProperty(SKIP_AUTORUNS, BooleanUtils.toStringTrueFalse(true));

        folder.save();

//        manager.createLink(

//            "Previous version",

//            manager.getUserFolder(), 

//            "../../../org.gvsig.scripting.app.extension/scripts"

//        );

        List<File> pluginsFolders = new ArrayList<>();

        for( File f : pluginManager.getPluginsFolders() ) {

            pluginsFolders.addAll(Arrays.asList(f.listFiles()));

        }

        for( File pluginFolder : pluginsFolders ) {

            File scriptsFolder = new File(pluginFolder, "scripting/scripts");

            if( scriptsFolder.exists() ) {

                manager.registerSystemFolder(pluginFolder.getName(), scriptsFolder);

            }

            File libFolder = new File(pluginFolder, "scripting/lib");

            if( libFolder.exists() ) {

                manager.addLibFolder(libFolder);

            }

        }

        manager.setPackagesFolder(pluginManager.getInstallFolder());

        File localAddonRepositoryFolder = new File(manager.getRootUserFolder(), "addons");

        if( !localAddonRepositoryFolder.exists() ) {

            try {

                FileUtils.forceMkdir(localAddonRepositoryFolder);

            } catch (IOException ex) {

                logger.info("Can't create addons folder in '" + localAddonRepositoryFolder.getAbsolutePath() + "'.", ex);

            }

        }

        File initAddonFile = new File(localAddonRepositoryFolder, "__init__.py");

        if( !initAddonFile.exists() ) {

            try {

                FileUtils.touch(initAddonFile);

            } catch (IOException ex) {

                logger.info("Can't create addons __init__ file in '" + localAddonRepositoryFolder.getAbsolutePath() + "'.", ex);

            }

        }

    }

    @Override

    public void postInitialize() {

        super.postInitialize();

        PluginsManager pluginManager = PluginsLocator.getManager();

        pluginManager.addStartupTask(

            "ExecuteAutorunScripts",

            new ExecuteAutorunScriptsOnStartup(),

            true,

            600

        );

        Invocable initializer = new ScriptsInstallerInitializer();

        initializer.call(this.getPlugin().getPluginName());

    }

    @Override

    public boolean isEnabled() {

        return true;

    }

    @Override

    public boolean isVisible() {

        return true;

    }

    private class ExecuteAutorunScriptsOnStartup implements Runnable {

        @Override

        public void run() {

            Thread th = new Thread(new ExecuteAutorunScripts());

            th.start();

        }

    }

    private class ExecuteAutorunScripts implements Runnable {

        @Override

        public void run() {

            final ApplicationManager application = ApplicationLocator.getManager();

            executingAutorunScripts = true;

            try {

                final ScriptingManager manager = ScriptingLocator.getManager();

                manager.loadEngines();

                final PluginsManager pluginManager = PluginsLocator.getManager();

                final I18nManager i18nManager = ToolsLocator.getI18nManager();

                final List<ScriptingBaseScript> autoruns = new ArrayList<>();

                List<File> pluginsFolders = new ArrayList<>();

                for( File f : pluginManager.getPluginsFolders() ) {

                    pluginsFolders.addAll(Arrays.asList(f.listFiles()));

                }

                application.message(

                    i18nManager.getTranslation("_Searching_autorun_scripts_Xhorizontal_ellipsisX"),

                    JOptionPane.INFORMATION_MESSAGE

                );

                for( File pluginFolder : pluginsFolders ) {

                    File autorun_file = new File(pluginFolder, "scripting/scripts/autorun.inf");

                    if( autorun_file.exists() ) {

                        ScriptingBaseScript autorun = manager.getScript(autorun_file);

                        if( autorun.isEnabled() ) {

                            autoruns.add(autorun);

                        } else {

                            logger.info("Skip autorun script '" + autorun_file.getAbsolutePath() + "'.");

                        }

                    }

                }

                SimpleFileVisitor<Path> visitor = new SimpleFileVisitor<Path>() {

                    @Override

                    public FileVisitResult visitFile(Path path, BasicFileAttributes bfa) throws IOException {

                        File file = path.toFile();

                        if( "autorun.inf".equalsIgnoreCase(file.getName()) ) {

                            if( file.exists() ) {

                                ScriptingBaseScript autorun = manager.getScript(file);

                                if( autorun.isEnabled() ) {

                                    autoruns.add(autorun);

                                } else {

                                    logger.info("Skip autorun script '" + file.getAbsolutePath() + "'.");

                                }

                            }

                        }

                        return FileVisitResult.CONTINUE;

                    }

                };

                try {

                    EnumSet<FileVisitOption> opts = EnumSet.of(FOLLOW_LINKS);

                    Files.walkFileTree(Paths.get(manager.getRootUserFolder().toURI()), opts, Integer.MAX_VALUE, visitor);

                    List<ScriptingFolder> folders = manager.getAlternativeUserFolders();

                    for( ScriptingFolder folder : folders ) {

                        Files.walkFileTree(Paths.get(folder.getFile().toURI()), opts, Integer.MAX_VALUE, visitor);

                    }

                } catch (Exception ex) {

                    logger.warn("Can't execute autoruns in home.", ex);

                }

                Collections.sort(autoruns, new Comparator<ScriptingBaseScript>() {

                    @Override

                    public int compare(ScriptingBaseScript o1, ScriptingBaseScript o2) {

                        return getScriptOrderKey(o2).compareToIgnoreCase(getScriptOrderKey(o1));

                    }

                });

                for( ScriptingBaseScript autorun : autoruns ) {

                    try {

                        logger.info("running autorun script '" + autorun.getFile().getAbsolutePath() + "' (" + getScriptOrderKey(autorun) + ", " + autorun.getIsolationGroup() + ").");

                        application.message(

                            i18nManager.getTranslation(

                                "_Running_autorun_script_from_XnameX",

                                new String[]{

                                        autorun.getFile().getParentFile().getName()}

                            ),

                            JOptionPane.INFORMATION_MESSAGE

                        );

                    } catch (Exception ex) {

                        // Ignore it

                    }

                    try {

                        autorun.run();

                    } catch (Exception ex) {

                        logger.warn("Can't execute autorun from '" + autorun.getFile().getAbsolutePath() + "'.", ex);

                    }

                }

            } finally {

                logger.info("Running autorun scripts terminated.");

                application.message("", JOptionPane.INFORMATION_MESSAGE);

                executingAutorunScripts = false;

            }

        }

        private String getScriptOrderKey(ScriptingBaseScript o) {

            int groupOrder = 500;

            String groupName = "default";

            int scriptOrder = 500;

            String s = o.getProperty("autorun.group.order");

            if( s != null ) {

                try {

                    groupOrder = Integer.parseInt(s);

                } catch (Exception ex) {

                    // Do nothing.

                }

            }

            s = o.getProperty("autorun.group.name");

            if( s != null ) {

                groupName = s;

            }

            s = o.getProperty("autorun.order");

            if( s != null ) {

                try {

                    scriptOrder = Integer.parseInt(s);

                } catch (Exception ex) {

                    // Do nothing.

                }

            }

            String key = MessageFormat.format(

                "{0,number,000000}.{1}.{2,number,000000}",

                groupOrder,

                groupName,

                scriptOrder

            );

            return key;

        }

    }

}