source: main/trunk/gli/src/org/greenstone/gatherer/greenstone/Plugins.java@ 31776

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * Author: Michael Dewsnip, NZDL Project, University of Waikato
 *
 * Copyright (C) 2006 New Zealand Digital Library Project
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.greenstone;

import java.io.*;
import java.util.*;
import javax.swing.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.cdm.Argument;
import org.greenstone.gatherer.cdm.Plugin;
import org.greenstone.gatherer.remote.RemoteGreenstoneServer;
import org.greenstone.gatherer.util.SafeProcess;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.util.XMLTools;
import org.w3c.dom.*;
import org.xml.sax.*;


/** This class is for maintaining a list of known plug-ins, and importing new plugins using the parser. */
public class Plugins
{
    // A list of all the plugins in the core Greenstone "perllib/plugins" folder (arguments may not be loaded)
    static private ArrayList core_greenstone_plugins_list = null;
    // The name of the loaded collection
    static private String collection_name = null;
    // A list of all the plugins in the loaded collection's "perllib/plugins" folder (arguments may not be loaded)
    static private ArrayList collection_specific_plugins_list = new ArrayList();


    static public Plugin getPlugin(String plugin_name, boolean arguments_required)
    {
    Plugin plugin = null;
    boolean collection_specific = false;

    // Check the collection-specific plugins first
    for (int i = 0; i < collection_specific_plugins_list.size(); i++) {
        Plugin collection_specific_plugin = (Plugin) collection_specific_plugins_list.get(i);
        if (collection_specific_plugin.getName().equals(plugin_name)) {
        plugin = collection_specific_plugin;
        collection_specific = true;
        break;
        }
    }

    // Try the core Greenstone plugins if necessary
    if (plugin == null) {
        for (int i = 0; i < core_greenstone_plugins_list.size(); i++) {
        Plugin core_greenstone_plugin = (Plugin) core_greenstone_plugins_list.get(i);
        if (core_greenstone_plugin.getName().equals(plugin_name)) {
            plugin = core_greenstone_plugin;
            break;
        }
        }
    }

    // If we've found the plugin, load its arguments now, if required
    if (plugin != null && arguments_required) {
        if (!plugin.hasLoadedOptions()) {
        loadPluginInfo(plugin, collection_specific);
        }
        else {
        DebugStream.println("Already loaded arguments for " + plugin_name + "!");
        }
    }

    return plugin;
    }


    /** Returns a new list from merging the collection-specific and the core Greenstone plugins. */
    static public ArrayList getPluginsList()
    {
    ArrayList plugins_list = new ArrayList();
    plugins_list.addAll(collection_specific_plugins_list);

    // Add in the core Greenstone plugins, taking care not to overwrite any collection-specific ones
    for (int i = 0; i < core_greenstone_plugins_list.size(); i++) {
        Plugin core_greenstone_plugin = (Plugin) core_greenstone_plugins_list.get(i);

        boolean found = false;
        for (int j = 0; j < collection_specific_plugins_list.size(); j++) {
        Plugin collection_specific_plugin = (Plugin) collection_specific_plugins_list.get(j);
        if (core_greenstone_plugin.getName().equals(collection_specific_plugin.getName())) {
            found = true;
            break;
        }
        }

        if (!found) {
        plugins_list.add(core_greenstone_plugin);
        }
    }

    return plugins_list;
    }


    static private void loadPluginInfo(Plugin plugin, boolean collection_specific)
    {
    DebugStream.println("Loading arguments for " + plugin.getName() + "...");

    // Run pluginfo.pl to get the list of plugins
    try {
        String pluginfo_xml = null;
        if (Gatherer.isGsdlRemote) {
        String pluginfo_options = "&plugin=" + plugin;
        if (collection_specific) {
            pluginfo_options += "&collection=" + collection_name;
        }
        pluginfo_xml = Gatherer.remoteGreenstoneServer.getScriptOptions("pluginfo.pl", pluginfo_options);
        }
        else {
        ArrayList args = new ArrayList();
        args.add(Configuration.perl_path);
        args.add("-S");
        args.add(LocalGreenstone.getBinScriptDirectoryPath() + "pluginfo.pl");
        args.add("-gs_version");
        if (Gatherer.GS3) {
            args.add("3");
        } else {
            args.add("2");
        }
        if (collection_specific) {
            args.add("-collection");
            args.add(collection_name);
            if (Gatherer.GS3) {
              args.add("-site");
              args.add(Configuration.site_name);
            }           
        }
        args.add("-xml");
        args.add("-language");
        args.add(Configuration.getLanguage());
        args.add(plugin.getName());

        // Run the pluginfo.pl process:
        // Create the process.
        SafeProcess process = new SafeProcess((String[]) args.toArray(new String[] { }));
        process.setSplitStdErrorNewLines(true);

        // run the SafeProcess
        int exitVal = process.runProcess();
        if(exitVal != 0) {
            throw new Exception("*** Error running pluginfo.pl loadPlugInfo, process exited with: "
                    + exitVal);
        }
        // get the result: We expect XML to have come out of the process std error stream.
        pluginfo_xml = process.getStdError();
        // make sure to have parsed out any lines preceding the XML content
        pluginfo_xml = XMLTools.readXMLStream(pluginfo_xml).toString();
        ///System.err.println("*********\nPluginInfo, got:\n" + pluginfo_xml + "\n**********\n");
        }

        // Check the XML output was obtained successfully
        if (pluginfo_xml == null || pluginfo_xml.length() == 0) {
        plugin.setHasLoadedOptions(false); // failure to load options
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.PlugInManager.PlugIn_XML_Parse_Failed", plugin.getName()), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        return;
        } else {
        plugin.setHasLoadedOptions(true);
        }

        parsePluginInfoXML(plugin, pluginfo_xml);
    }
    catch (Exception exception) {
        DebugStream.printStackTrace(exception);
    }
    }


    static public void loadPluginsList(String collection_name_arg)
    {
    DebugStream.println("In loadPluginsList()...");

    // If we're getting the collection-specific plugins, clear the old list no matter what
    if (collection_name_arg != null) {
        collection_name = collection_name_arg;
        collection_specific_plugins_list = new ArrayList();
    }

    // Run pluginfo.pl to get the list of plugins
    try {
        String xml = null;
        if (Gatherer.isGsdlRemote) {
        String pluginfo_options = "&listall";
        if (collection_name != null) {
            pluginfo_options += "&collection=" + collection_name;
        }
        String pluginfo_output = Gatherer.remoteGreenstoneServer.getScriptOptions("pluginfo.pl", pluginfo_options);
        xml = pluginfo_output;
        }
        else {
        ArrayList args = new ArrayList();
        args.add(Configuration.perl_path);
        args.add("-S");     
        args.add(LocalGreenstone.getBinScriptDirectoryPath() + "pluginfo.pl");
        args.add("-gs_version");
        if (Gatherer.GS3) {
            args.add("3");
        } else {
            args.add("2");
        }
        if (collection_name != null) {
            args.add("-collection");
            args.add(collection_name);
            if (Gatherer.GS3) {
              args.add("-site");
              args.add(Configuration.site_name);
            }
        }
        args.add("-listall");
        args.add("-xml");
        
        // Run the pluginfo.pl process:
        // Create the process.
        SafeProcess process = new SafeProcess((String[]) args.toArray(new String[] { }));
        process.setSplitStdErrorNewLines(true);

        // run the SafeProcess
        int exitVal = process.runProcess();
        if(exitVal != 0) {
            throw new Exception("*** Error running pluginfo.pl loadPluginsList, process exited with: "
                    + exitVal);
        }
        // get the result: We expect XML to have come out of the process std error stream.  
        xml = process.getStdError();
        // make sure to parse out any lines before the XML content, else running "gli -debug" results in an XML error:
        // for pluginfo.pl -listall, we see a "AutoloadConverters" (PDFBox) message
        // before actual XML output, which breaks XML parsing. 
        // This gets rid of output before "<?xml" in the way that the code did before the change to SafeProcess
        // Then we can call the same from method RemoteGreenstoneServer.java, so that running "client-gli -debug"
        // will work too.
        xml = XMLTools.readXMLStream(xml).toString();
        
        ///System.err.println("*********\nPluginsList, got:\n" + xml + "\n**********\n");
        }

        // Check the XML output was obtained successfully
        if (xml == null || xml.length() == 0) {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.PluginManager.Plugin_List_XML_Parse_Failed"), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        return;
        }

        if (collection_name != null) {
        collection_specific_plugins_list = parsePluginsListXML(xml);
        }
        else {
        core_greenstone_plugins_list = parsePluginsListXML(xml);
        }
    }
    catch (Exception exception) {
        DebugStream.printStackTrace(exception);
    }
    }


    static private void parsePluginInfoXML(Plugin plugin, String xml)
    {
    Document document = XMLTools.parseXML(new StringReader(xml));
    if (document == null) {
        plugin.setHasLoadedOptions(false); // failure to load the options/failed plugin
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.PlugInManager.PlugIn_XML_Parse_Failed", plugin.getName()), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        return;
    } else {
        plugin.setHasLoadedOptions(true);
    }

    parsePluginInfoXMLNode(plugin, document.getDocumentElement());
    }


    static private void parsePluginInfoXMLNode(Plugin plugin, Node root_node)
    {
    for (Node node = root_node.getFirstChild(); node != null; node = node.getNextSibling()) {
        String node_name = node.getNodeName();

        if (node_name.equalsIgnoreCase("Name")) {
        plugin.setName(XMLTools.getValue(node));
        }
        else if (node_name.equals("Desc")) {
        plugin.setDescription(XMLTools.getValue(node));
        }
        else if (node_name.equals("Abstract")) {
        plugin.setIsAbstract(XMLTools.getValue(node).equalsIgnoreCase(StaticStrings.YES_STR));
        }
        else if (node_name.equalsIgnoreCase("Explodes")) {
        plugin.setDoesExplodeMetadataDatabases(XMLTools.getValue(node).equalsIgnoreCase(StaticStrings.YES_STR));
        }
        else if (node_name.equalsIgnoreCase("SourceReplaceable")) { // looking for <SourceReplaceable> tag
        plugin.setDoesReplaceSrcDocsWithHtml(XMLTools.getValue(node).equalsIgnoreCase(StaticStrings.YES_STR));
        }
        else if (node_name.equalsIgnoreCase("Processes")) {
        plugin.setDefaultProcessExpression(XMLTools.getValue(node));
        }
        else if (node_name.equalsIgnoreCase("Blocks")) {
        plugin.setDefaultBlockExpression(XMLTools.getValue(node));
        }
        // Parse the plugin arguments
        else if (node_name.equalsIgnoreCase("Arguments")) {
        for (Node argument_node = node.getFirstChild(); argument_node != null; argument_node = argument_node.getNextSibling()) {
            // An option
            if (argument_node.getNodeName().equalsIgnoreCase("Option")) {
            Argument argument = new Argument();
            argument.parseXML((Element) argument_node);
            plugin.addArgument(argument);
            }
        }
        }
        // A super plugin class
        else if (node_name.equalsIgnoreCase("PlugInfo")) {
        Plugin super_plugin = new Plugin();
        parsePluginInfoXMLNode(super_plugin, node);
        plugin.setSuper(super_plugin);
        }
    }
    }


    static private ArrayList parsePluginsListXML(String xml)
    {
    ArrayList plugins_list = new ArrayList();
    
    Document document = XMLTools.parseXML(new StringReader(xml));
    Node root = document.getDocumentElement();
    for (Node node = root.getFirstChild(); node != null; node = node.getNextSibling()) {
        String node_name = node.getNodeName();

        if (node_name.equals("PlugInfo")) {
        Plugin plugin = new Plugin();
        parsePluginInfoXMLNode(plugin, node);
        plugins_list.add(plugin);
        }
    }

    return plugins_list;
    }
}