source: trunk/gsdl3/src/java/org/greenstone/gsdl3/service/ServiceModule.java@ 3222

package org.greenstone.gsdl3.service;

// greenstone classes
import org.greenstone.gsdl3.util.*;
import org.greenstone.gsdl3.core.*;

// xml classes
import org.w3c.dom.Node; 
import org.w3c.dom.Element; 
import org.w3c.dom.Document; 
import org.xml.sax.InputSource;
import javax.xml.parsers.*;
import org.apache.xpath.XPathAPI;

// general java classes
import java.io.Reader;
import java.io.StringReader;
import java.io.File;
import java.util.HashMap;

/**
 * ServiceModule - abstract base class 
 *
 * A ServiceModule provides Services to a collection/system. 
 * It may provide more than one Service. for eg
 * MGGDBMServiceModule may support "DocRetrieve", "TextQuery", "MetadataRetrieve" services
 *
 */
public abstract class ServiceModule 
    implements ModuleInterface
{
    /** the absolute address of the site home */
    protected String site_home_ =null;
    /** the name of the collection directory that this service belongs to -
    if any */ 
    protected String collection_name_ = null;

    /** some services can talk back to the message router */
    protected ModuleInterface router_ = null;

    /** a converter class to create Documents etc */
    protected XMLConverter converter_ = null;

    /** XML element for describe requests - the container doc */
    protected Document doc_ = null;

    /** XML element for describe requests - list of supported services */
    protected Element short_service_info_ = null;

    /** XML element for describe requests - map of service name to full 
    description */
    protected HashMap service_info_map_ = null;

    public void setCollectionName(String coll_name) {
    collection_name_ = coll_name;
    }
    
    public void setSiteHome(String site_home) {
    site_home_ = site_home;
    }

    public void setMessageRouter(ModuleInterface m) {
       router_ = m;
    }

    public ServiceModule() {
    converter_ = new XMLConverter();
    doc_ = converter_.newDOM();
    short_service_info_ = doc_.createElement("serviceList");
    service_info_map_ = new HashMap();
    }
    
    /**
     * Configure the object. - default method for service modules
     *
     * reads either collection (if a collection name has been set), or system 
     * configuration file, and configures itself
     * this calls configure(Element) with the XML element node from the config
     * file.
     * configure(Element) should be used if the config file has already been 
     * parsed.  This method will work with any subclass.
     * 
     * @return true if configure successful, false otherwise.
     */
    public boolean configure(){
    
    if (site_home_==null) {
        System.err.println("setSiteHome() must be called before configure()");
        return false;
    }

    File config_file=null;
    if (collection_name_ !=null) {
        
        config_file = GSFile.collectionBuildConfigFile(site_home_, collection_name_);
    }
    else {
        config_file = GSFile.siteConfigFile(site_home_);
    }

    if (config_file.exists() ) {
        
        Document doc = converter_.getDOM(config_file);
        
        try {
        // get the service list and look for own service
        // Note: XPathAPI is slow apparently
        String xpath = "//ServiceModule[@name='"+this.getClass().getName()+"']";
        System.out.println("xpath="+xpath);
        Node n = XPathAPI.selectSingleNode(doc, xpath);
        if (n !=null) {
            return this.configure((Element)n);
        }
        } catch (Exception e) {
        System.err.println("ServiceModule configure exception: "+e.getMessage());
        return false;
        }
    }
    System.err.println("ServiceModule error: unable to configure ServiceModule " + this.getClass().getName() );
    return false;
    
    
    } 

    /** The configure method that does the real work
     *
     * @param info the XML node <serviceModule name="XXX"/> with name equal
     * to the class name (of the subclass)
     *
     * must initialise short_service_info_ and service_info_map_
     * @return true if configured ok
     * must be implemented in subclasses
     */
    abstract public boolean configure(Element info); 

    /**
     * Process an XML document - convenience method that uses Strings rather than Nodes. just calls process(Node).
     *
     * @param xml_in the Document to process - a string
     * @return the resultant document as a string - contains any error messages
     * @see String
     */
    public String process(String xml_in) {
    
    Document doc = converter_.getDOM(xml_in);
    
    Node res = process(doc);
    return converter_.getString(res);
    
    }

    /** process an XML request in DOM form
     *
     * @param xml_in the Element node containing the request
     * should be <request> or maybe <multipleRequest>?? if more than one 
     * request coming at once
     * @return an Element with the result XML
     * @see Element
     */
    public Node process(Node xml_in) {

    // check if request is Element or Document - we want to work 
    // with an Element
    Element request=null;

    short node_type = xml_in.getNodeType();
    if (node_type == Node.DOCUMENT_NODE) {
        request = ((Document)xml_in).getDocumentElement();
    } else if (node_type == Node.ELEMENT_NODE) {
        request = (Element)xml_in;
    } else {
        System.err.println("ServiceModule:process error: input should be an Element or Document!");
    }

    String req = request.getNodeName();
    if (!req.equals("request")) {
        System.err.println("ServiceModule:process - should have been passed a request element, instead was given a "+req+" element!");
        return null;
    }

    String type = request.getAttribute("type");
    String to = GSPath.getFirstLink(request.getAttribute("to"));
    String info = request.getAttribute("info");
    if (type.equals("describe")) { // process here, not by subclass
        if (to.equals("")) { // to="", look at info
        if (info.equals("serviceList")) {
            return short_service_info_;
        } 
        // else error in info field
        System.err.println("ServiceModule describe request: error in 'info' field, info='"+info+"'.");
        return null;
        } else { // describe a particular service
        if (service_info_map_.containsKey(to)) {
            return (Element)service_info_map_.get(to);
        }
        // else error in to field
        System.err.println("ServiceModule describe request: error in 'to' field, to='"+to+"'.");
        return null;
        }
    } else { // other type of request, must be processed by the subclass - 
        // send to the service method
        if (service_info_map_.containsKey(to)) { 
        return processService(to, request);
        }
        else {
        // else error in to field
        System.err.println("ServiceModule describe request: error in 'to' field, to='"+to+"'.");
        return null;
        }
    }
    
    }

    /** process method for specific services - must be implemented by all
     * subclasses
     * should implement all services supported by the serviceModule except
     * for describe, which is implemented by this base class
     *
     */
    abstract protected Element processService(String service, Element request);


}