Changeset 9874 for trunk/gsdl3/src

trunk/gsdl3/src/java/org/greenstone/gsdl3/SOAPServer.java.in

-              r8081
+              r9874
  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 package org.greenstone.gsdl3;
 import org.greenstone.gsdl3.core.*;
+import org.greenstone.gsdl3.util.GSXML;
 import org.w3c.dom.Element;
 import java.io.File;
 …
+ *
  * @author <a href="mailto:[email protected]">Katherine Don</a>
- * @version $Revision$
  * @see <a href="http://www.w3.org/TR/SOAP/">Simple Object Access Protocol (SOAP) 1.1 </a>
  */
+public class SOAPServer
+    implements ModuleInterface {
+public class SOAPServerlocalsite
+{
     private String config_file_name = "SOAPServer.cfg";
 …
   /** The no-args constructor */
     public SOAPServer() {
+    public SOAPServer@sitename@() {
     // find out gsdl3home
     URL url = ClassLoader.getSystemResource(config_file_name);
 …
         return;
+    }
     String site_home=gsdl3_home+File.separator+"web"+File.separator+"sites"+File.separator+"@sitename@";
+    String site_home=gsdl3_home+File.separator+"web"+File.separator+"sites"+File.separator+"localsite";
     File site_file = new File(site_home);
 …
+    }
+    /** Process a String request */
+    public String process(String xml_in) {
+    return mr_.process(xml_in);
+    }
+    /** Process an Element request  */
+    public Element process(Element xml_in) {
+    return mr_.process(xml_in);
+    public Element [] process (Element [] xml_in) {
+    Element [] result = new Element[xml_in.length];
+    for (int i=0; i<xml_in.length; i++) {
+        Element req = xml_in[i];
+        // get rid of the obligatory namespace that axis needs
+        String tag_name = req.getTagName();
+        String namespace="";
+        if (tag_name.indexOf(':')!= -1) {
+        namespace = tag_name.substring(0, tag_name.indexOf(':'));
+        tag_name = tag_name.substring(tag_name.indexOf(':')+1);
+        }
+        Element new_req = GSXML.duplicateWithNewName(req.getOwnerDocument(), req, tag_name, true);
+        Element r = mr_.process(new_req);
+        // add the namespace back on
+        //Element new_res = r;
+        //if (!namespace.equals("")) {
+        //  new_res = GSXML.duplicateWithNewName(r.getOwnerDocument(), r, namespace+r.getTagName(), true);
+        //}
+        result[i] = r;
+    }
+    return result;
+    }
 …
     return null;
+    }
+}

trunk/gsdl3/src/java/org/greenstone/gsdl3/action/Action.java

-              r8832
+              r9874
     public String process(String xml_in) {
+    Element message = this.converter.getDOM(xml_in).getDocumentElement();
+    Element result = process(message);
+    Document message_doc = this.converter.getDOM(xml_in);
+    if (message_doc == null) {
+        System.err.println("Action.process(String) Error: Couldn't parse request");
+        System.err.println(xml_in);
+        return null;
+    }
+    Element result = process(message_doc.getDocumentElement());
     return this.converter.getString(result);
+    }
 …
+    }
+    protected boolean processErrorElements(Element message, Element page) {
+    NodeList error_nodes = message.getElementsByTagName(GSXML.ERROR_ELEM);
+    if (error_nodes.getLength()==0) {
+        return false;
+    }
+    Document owner = page.getOwnerDocument();
+    for (int i=0; i<error_nodes.getLength(); i++) {
+        page.appendChild(owner.importNode(error_nodes.item(i), true));
+    }
+    return true;
+    }
+}

trunk/gsdl3/src/java/org/greenstone/gsdl3/action/DocumentAction.java

-              r9007
+              r9874
         // Process the document structure retrieve message
         Element ds_response_message = (Element) this.mr.process(ds_message);
+        if (processErrorElements(ds_response_message, page_response)) {
+        return result;
+        }
         // get the info and print out
         String path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
 …
     doc_list.appendChild(doc_node);
     Element dm_response_message = (Element) this.mr.process(dm_message);
+    if (processErrorElements(dm_response_message, page_response)) {
+        return result;
+    }
     String path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
 …
     System.err.println("request = "+converter.getString(dc_message));
     Element dc_response_message = (Element) this.mr.process(dc_message);
+    if (processErrorElements(dc_response_message, page_response)) {
+        return result;
+    }
     Element dc_response_doc_list = (Element) GSXML.getNodeByPath(dc_response_message, path);
 …
     HashMap params = GSXML.extractParams(cgi_param_list, false);
+    String service_name = (String)((HashMap)params.get("p")).get(GSParams.SERVICE);
+    HashMap previous_params = (HashMap)params.get("p");
+    if (previous_params == null) {
+        return dc_response_doc_content;
+    }
+        String service_name = (String)previous_params.get(GSParams.SERVICE);
     if (service_name == null || !service_name.endsWith("Query")) { // hack for now - we only do highlighting if we were in a query last - ie not if we were in a browse thingy
         System.err.println("DocumentAction: invalid service, not doing highlighting");

trunk/gsdl3/src/java/org/greenstone/gsdl3/action/GS2BrowseAction.java

-              r8575
+              r9874
         horizontal_at_top = true;
+    }
+    if (top_id.equals(classifier_node) && horizontal_at_top) {
+    // *** TODO need to fix this
+    //if (top_id.equals(classifier_node) && horizontal_at_top) {
         // we have asked for a top node - if the first list is horizontal, we will select the first element of that list
         // this is a hack. also it craps out if the classifier really isn't horizontalAtTop.
         classifier_node = classifier_node+".1";
+        // this is a hack. also it craps out if the classifier really isn't horizontalAtTop. -
+        //classifier_node = classifier_node+".1";
+    }
+    //}
     // get the browse structure for the selected node

trunk/gsdl3/src/java/org/greenstone/gsdl3/action/QueryAction.java

-              r9264
+              r9874
     String to = GSPath.appendLink(collection, service_name);
+    // part of the response is the service description
+    // for now get this again from the service.
+    // this will probably need to be cached somehow later on.
+    Element mr_info_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
+    Element mr_info_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE,  to, lang, uid);
+    mr_info_message.appendChild(mr_info_request);
+    if (request_type.indexOf("d")!=-1) {
+        // we have been asked for the service description
+        Element mr_info_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
+        Element mr_info_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE,  to, lang, uid);
+        mr_info_message.appendChild(mr_info_request);
+        // process the message
+        Element mr_info_response = (Element) this.mr.process(mr_info_message);
+        // the response
+        Element service_response = (Element)GSXML.getChildByTagName(mr_info_response, GSXML.RESPONSE_ELEM);
+        Element service_description = (Element)this.doc.importNode(GSXML.getChildByTagName(service_response, GSXML.SERVICE_ELEM), true);
+        page_response.appendChild(service_description);
+    }
+    if (request_type.indexOf("r") == -1) {
+        // just a display request, no actual processing to do
+        return page_response;
+    }
+    // check that we have some service params
+    HashMap service_params = (HashMap)params.get("s1");
+    if (service_params == null) { // no query
+        return page_response;
+    }
+    // create the query request
+    Element mr_query_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
+    Element mr_query_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_PROCESS, to, lang, uid);
+    mr_query_message.appendChild(mr_query_request);
+    Element query_param_list = this.doc.createElement(GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER);
+    GSXML.addParametersToList(this.doc, query_param_list, service_params);
+    mr_query_request.appendChild(query_param_list);
     // also get the format stuff now if there is some
     Element format_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_FORMAT, to, lang, uid);
+    mr_info_message.appendChild(format_request);
+    // process the messages
+    Element mr_info_response = (Element) this.mr.process(mr_info_message);
+    // the two responses
+    NodeList responses = mr_info_response.getElementsByTagName(GSXML.RESPONSE_ELEM);
+    Element service_response = (Element)responses.item(0);
+    Element format_response = (Element)responses.item(1);
+    Element service_description = (Element)this.doc.importNode(GSXML.getChildByTagName(service_response, GSXML.SERVICE_ELEM), true);
+    page_response.appendChild(service_description);
+    if (request_type.equals("d")) {// just a display request
+        return page_response;
+    }
+    mr_query_message.appendChild(format_request);
+    // do the query
+        Element mr_query_response = (Element)this.mr.process(mr_query_message);
+    // check for errors
+    if (processErrorElements(mr_query_response, page_response)) {
+        return page_response;
+    }
+    NodeList responses = mr_query_response.getElementsByTagName(GSXML.RESPONSE_ELEM);
+    Element query_response = (Element) responses.item(0);
+    Element format_response = (Element) responses.item(1);
+    Element query_result_metadata_list = (Element) GSXML.getChildByTagName(query_response, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
+    if (query_result_metadata_list == null) {
+        System.err.println("QueryAction: Warning: No query result metadata.\n");
+    } else { // add it into the page response
+        page_response.appendChild(this.doc.importNode(query_result_metadata_list, true));
+    }
+    Element query_term_info_list = (Element) GSXML.getChildByTagName(query_response, GSXML.TERM_ELEM+GSXML.LIST_MODIFIER);
+    if (query_term_info_list == null) {
+        System.err.println("QueryAction: Warning: No query term information.\n");
+    } else { // add it into the page response
+        page_response.appendChild(this.doc.importNode(query_term_info_list, true));
+    }
+    // check that there are some documents - for now check the list, but later should use a numdocs metadata elem
+    Element document_list = (Element)GSXML.getChildByTagName(query_response, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
+    // documentList not present if no docs found
+    if (document_list == null) {
+        return page_response;
+    }
+    // now we check to see if there is metadata already - some search services return predefined metadata. if there is some, don't do a metadata request
+    NodeList doc_metadata = document_list.getElementsByTagName(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
+    if (doc_metadata.getLength()>0) {
+        System.err.println("have already found metadata!");
+        // append the doc list to the result
+        page_response.appendChild(this.doc.importNode(document_list, true));
+        return page_response;
+    }
+    // get the metadata elements needed from the format statement if any
     HashSet metadata_names = new HashSet();
     metadata_names.add("Title");
 …
         extractMetadataNames(format_elem, metadata_names);
+    }
-    // do the query
-    Element mr_query_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
-    Element mr_query_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_PROCESS, to, lang, uid);
-    mr_query_message.appendChild(mr_query_request);
-    // paramList
-    HashMap service_params = (HashMap)params.get("s1");
-    if (service_params == null) { // no query
-        return page_response;
+    }
-    Element query_param_list = this.doc.createElement(GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER);
-    GSXML.addParametersToList(this.doc, query_param_list, service_params);
-    ///ystem.out.println("service params are "+this.converter.getString(query_param_list));
-    mr_query_request.appendChild(query_param_list);
-    // do the query
-        Element mr_query_response = (Element)this.mr.process(mr_query_message);
-    //. check for errors
-    String path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.ERROR_ELEM);
-    Element error_elem = (Element) GSXML.getNodeByPath(mr_query_response, path);
-    if (error_elem != null) {
-        // should we continue?? perhaps have a kind of error - information vs fatal??
-        System.err.println("found an error elem");
-        page_response.appendChild(this.doc.importNode(error_elem, true));
-        return page_response;
+    }
-    path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
-    Element query_result_metadata_list = (Element) GSXML.getNodeByPath(mr_query_response, path);
-    if (query_result_metadata_list == null) {
-        System.err.println("QueryAction: Warning: No query result metadata.\n");
-    } else { // add it into the page response
-        page_response.appendChild(this.doc.importNode(query_result_metadata_list, true));
+    }
-    path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.TERM_ELEM+GSXML.LIST_MODIFIER);
-    Element query_term_info_list = (Element) GSXML.getNodeByPath(mr_query_response, path);
-    if (query_term_info_list == null) {
-        System.err.println("QueryAction: Warning: No query term information.\n");
-    } else { // add it into the page response
-        page_response.appendChild(this.doc.importNode(query_term_info_list, true));
+    }
-    // check that there are some documents - for now check the list, but later should use a numdocs metadata elem
-    path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
-    Element document_list = (Element)GSXML.getNodeByPath(mr_query_response,
-                                 path);
-    // documentList not present if no docs found
-    if (document_list == null) {
-        return page_response;
+    }
     // paging of the results is done here - we filter the list to remove unwanted entries before retrieving metadata
+    Element filtered_doc_list = filterDocList(params, service_description, document_list);
+    // now we check to see if there is metadata already - some search services return predefined metadata. if there is some, don't do a metadata request
+    NodeList doc_metadata = document_list.getElementsByTagName(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
+    if (doc_metadata.getLength()>0) {
+        System.err.println("have already found metadata!");
+        // append the doc list to the result
+        page_response.appendChild(this.doc.importNode(document_list, true));
+        return page_response;
+    }
+    Element filtered_doc_list = filterDocList(params, service_params, document_list);
     // do the metadata request on the filtered list
     Element mr_metadata_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
 …
     mr_metadata_request.appendChild(dm_param_list);
     // add in the doc node list too
     mr_metadata_request.appendChild(filtered_doc_list);
     Element mr_metadata_response = (Element) this.mr.process(mr_metadata_message);
+    path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
+    Element query_result_document_list = (Element) GSXML.getNodeByPath(mr_metadata_response, path);
+    // check for errors
+    processErrorElements(mr_metadata_response, page_response);
+    Element metadata_response = (Element) GSXML.getChildByTagName(mr_metadata_response, GSXML.RESPONSE_ELEM);
+    Element query_result_document_list = (Element) GSXML.getChildByTagName(metadata_response, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
     if (query_result_document_list != null) {
         page_response.appendChild(this.doc.importNode(query_result_document_list, true));
+    }
     System.out.println("Query page:\n" + this.converter.getPrettyString(page_response));
+    ///ystem.out.println("Query page:\n" + this.converter.getPrettyString(page_response));
     return page_response;
+    }
     /** this filters out some of the doc results for result paging */
+    protected Element filterDocList(HashMap params, Element service_description, Element orig_doc_list) {
+    // check in the service descripiton to see if hitsPerpage is a param
+    Element service_p_list = (Element)GSXML.getChildByTagName(service_description, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
+    Element hits_param = GSXML.getNamedElement(service_p_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, "hitsPerPage");
+    boolean service_paging = false;
+    if (hits_param != null) {
+        service_paging = true;
+    }
+    if (service_paging) {
+        // the service is doing the paging, so we want to display all of teh returned docs
+    protected Element filterDocList(HashMap params, HashMap service_params, Element orig_doc_list) {
+    // check the hits_per_page param - is it a service param??
+    String hits_pp = (String) service_params.get("hitsPerPage");
+    if (hits_pp != null) {
+        // the service is doing the paging, so we want to display all of the returned docs
         return (Element)this.doc.importNode(orig_doc_list, true);
+    }
     String hits_pp = (String)params.get("hitsPerPage");
+    hits_pp = (String)params.get("hitsPerPage");
     int hits = 20;
     if (hits_pp != null && !hits_pp.equals("")) {

trunk/gsdl3/src/java/org/greenstone/gsdl3/collection/Collection.java

-              r5403
+              r9874
+    }
     // get the xml for both files
+    Element coll_config_elem = this.converter.getDOM(coll_config_file, CONFIG_ENCODING).getDocumentElement();
+    Document coll_config_doc = this.converter.getDOM(coll_config_file, CONFIG_ENCODING);
+    Element coll_config_elem = null;
+    if (coll_config_doc != null) {
+        coll_config_elem = coll_config_doc.getDocumentElement();
+    }
     return coll_config_elem;
 …
         return null;
+    }
+    Element build_config_elem = this.converter.getDOM(build_config_file, CONFIG_ENCODING).getDocumentElement();
+    Document build_config_doc = this.converter.getDOM(build_config_file, CONFIG_ENCODING);
+    Element build_config_elem = null;
+    if (build_config_doc != null) {
+        build_config_elem = build_config_doc.getDocumentElement();
+    }
     return build_config_elem;
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/collection/ServiceCluster.java

-              r9433
+              r9874
 import java.io.File;
 import java.util.HashMap;
+import java.util.Iterator;
 /* ServiceCluster - a groups of services that are related in some way
 …
+    }
+    public void cleanUp() {
+    Iterator i = this.service_map.values().iterator();
+    while (i.hasNext()) {
+        ServiceRack s = (ServiceRack)i.next();
+        s.cleanUp();
+    }
+    }
     public void setClusterName(String name) {
     this.cluster_name = name;
 …
     Document doc = this.converter.getDOM(config_file, CONFIG_ENCODING);
+    if (doc == null) {
+        System.err.println("ServiceCluster: couldn't parse config file "+config_file.getPath());
+        return false;
+    }
     // get the appropriate service cluster element
 …
     return this.configure(sc);
+    }
     public boolean configure(Element service_cluster_info) {
 …
+        }
+    }
     // get the display info
     Element display_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER);
 …
+    }
+    Element site_config_elem  = this.converter.getDOM(configFile).getDocumentElement();
+    Document site_config_doc  = this.converter.getDOM(configFile);
+    if (site_config_doc == null) {
+        System.err.println("ServiceCluster: could not read in site config file: "+configFile.getPath());
+        return false;
+    }
+    Element site_config_elem = site_config_doc.getDocumentElement();
     Element cluster_config_elem = GSXML.getNamedElement((Element)GSXML.getChildByTagName(site_config_elem, GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER), GSXML.CLUSTER_ELEM, GSXML.NAME_ATT, this.cluster_name);
     if (cluster_config_elem == null) {

trunk/gsdl3/src/java/org/greenstone/gsdl3/comms/Communicator.java

r4035	r9874
48	48	converter_ = new XMLConverter();
49	49	}
	50	public void cleanUp() {}
50	51
51	52	public void setLocalSiteName(String name) {

trunk/gsdl3/src/java/org/greenstone/gsdl3/comms/SOAPCommunicator.java

-              r4035
+              r9874
 import java.net.MalformedURLException;
 import java.util.Vector;
+import org.apache.soap.SOAPException;
+import org.apache.soap.Fault;
+import org.apache.soap.Constants;
+import org.apache.soap.rpc.Call;
+import org.apache.soap.rpc.Parameter;
+import org.apache.soap.rpc.Response;
+// import org.apache.soap.SOAPException;
+// import org.apache.soap.Fault;
+// import org.apache.soap.Constants;
+// import org.apache.soap.rpc.Call;
+// import org.apache.soap.rpc.Parameter;
+// import org.apache.soap.rpc.Response;
+import org.apache.axis.client.Call;
+import org.apache.axis.client.Service;
+import org.apache.axis.message.SOAPBodyElement;
+import javax.xml.namespace.QName;
 import org.w3c.dom.Node;
 …
     public SOAPCommunicator() {
+    call_ = new Call();
     // Set Encoding Style to standard SOAP encoding
     //call_.setEncodingStyleURI(Constants.NS_URI_SOAP_ENC);
     // set Encoding Style to use literal XML
     call_.setEncodingStyleURI(Constants.NS_URI_LITERAL_XML);
+    //call_.setEncodingStyleURI(Constants.NS_URI_LITERAL_XML);
+    }
     public boolean configure(Element site_elem) {
     String type = site_elem.getAttribute(GSXML.TYPE_ATT);
     if (!type.equals(GSXML.COMM_TYPE_SOAP_JAVA)) {
 …
         return false;
+    }
+    call_.setTargetObjectURI(remote_site_name_);
+    call_.setMethodName("process");
+    try {
+        Service service = new Service();
+        call_ = (Call) service.createCall();
+        //call_.setTargetObjectURI(remote_site_name_);
+        //call_.setMethodName("process");
+        call_.setTargetEndpointAddress( new java.net.URL(remote_site_address_) );
+        //      call_.setOperationStyle(org.apache.axis.enum.Style.MESSAGE_STR);
+        //call_.setOperationUse(org.apache.axis.enum.Use.LITERAL_STR);
+        //call_.setOperationName(new QName("http://soapinterop.org/", "process"));
+    } catch (Exception e) {
+        System.err.println("SOAPCommunicator.configure() Error: Exception occurred "+e);
+        return false;
+    }
     return true;
+    }
     public Element process(Element message) {
     NodeList requests = message.getElementsByTagName(GSXML.REQUEST_ELEM);
     if (requests.getLength()==0) {
 …
         return null;
+    }
     // if the communicator is part of a site, it needs to edit the to and from fields, otherwise it just passes the message on, as is
     // for now, use local_site_name_ as the flag.
 …
+        }
+    }
+    // else do nothing to the requests, just pass it on
+    // the soap impl needs a namespace for the top level element
+    Element message_to_send = message;
+    if (message.getNamespaceURI() == null) {
+        message_to_send = GSXML.duplicateWithNewNameNS(message.getOwnerDocument(), message, "gs3:"+message.getTagName(), "urn:foo", true);
+        //System.err.println("**"+new XMLConverter().getPrettyString(new_message));
+    }
+    // do the soap query
+    Element result = null;
+    try {
+        SOAPBodyElement[] input = new SOAPBodyElement[1];
+        input[0] = new SOAPBodyElement(message_to_send);
+        Vector output = (Vector) call_.invoke( input );
+        SOAPBodyElement elem = (SOAPBodyElement) output.get(0);
+        result = elem.getAsDOM();
+    } catch (Exception e) {
+        e.printStackTrace();
+        return null;
+    }
+    if (local_site_name_ != null) {// have to modify the from field
+        NodeList responses = result.getElementsByTagName(GSXML.RESPONSE_ELEM);
+        for (int i=0;i<responses.getLength(); i++) {
+        Element e = (Element)responses.item(i);
+        String from = e.getAttribute(GSXML.FROM_ATT);
+        from = GSPath.prependLink(from, remote_site_name_);
+        e.setAttribute(GSXML.FROM_ATT, from);
+        }
+    } // else return as is
+    return result;
+    }
+    public static void main (String [] args) {
+    SOAPCommunicator comm = new SOAPCommunicator();
+    XMLConverter converter = new XMLConverter();
+    String message = "<site name=\"localsite\" address=\"http://kanuka.cs.waikato.ac.nz:7070/axis/services/localsite\" type=\"soap\"/>";
+    Element site_elem = converter.getDOM(message).getDocumentElement();
+    comm.configure(site_elem);
+    message = "<message><request type=\"describe\" to=\"\" lang=\"en\"/></message>";
+    //message = "<message><request type=\"describe\" to=\"\" lang=\"en\"/></message>";
+    Element request_elem = converter.getDOM(message).getDocumentElement();
+    Element response = comm.process(request_elem);
+    System.err.println("response was "+converter.getPrettyString(response));
+    }
+    /*
+    public Element process(Element message) {
+    NodeList requests = message.getElementsByTagName(GSXML.REQUEST_ELEM);
+    if (requests.getLength()==0) {
+        // no requests
+        return null;
+    }
+    // if the communicator is part of a site, it needs to edit the to and from fields, otherwise it just passes the message on, as is
+    // for now, use local_site_name_ as the flag.
+    if (local_site_name_!=null) { // no local site
+        for (int i=0;i<requests.getLength(); i++) {
+        Element e = (Element)requests.item(i);
+        String to = e.getAttribute(GSXML.TO_ATT);
+        to = GSPath.removeFirstLink(to); // remove the server name, should check that it is present
+        e.setAttribute(GSXML.TO_ATT, to);
+        String from = e.getAttribute(GSXML.FROM_ATT);
+        from = GSPath.appendLink(from, local_site_name_);
+        e.setAttribute(GSXML.FROM_ATT, from);
+        }
+    }
     // else do nothing to the message, just pass it on
 …
         // Set Method Parameters - use literal xml
         Parameter param = new Parameter("xml_in",
                         org.w3c.dom.Element.class,
                         message,
                         Constants.NS_URI_LITERAL_XML);
+//      Parameter param = new Parameter("xml_in",
+//                      org.w3c.dom.Element.class,
+//                      message,
+//                      Constants.NS_URI_LITERAL_XML);
         Vector param_list = new Vector ();
         param_list.addElement (param);
         call_.setParams (param_list);
         //  Set the URL for the Web Service
         URL url = new URL(remote_site_address_);
+//      Vector param_list = new Vector ();
+//      param_list.addElement (param);
+//      call_.setParams (param_list);
+//      //  Set the URL for the Web Service
+//      URL url = new URL(remote_site_address_);
         // Invoke the Service
 …
+    }
+    }
+    */
+}

trunk/gsdl3/src/java/org/greenstone/gsdl3/core/DefaultReceptionist.java

-              r7825
+              r9874
     Element page_request = (Element)GSXML.getChildByTagName(page, GSXML.PAGE_REQUEST_ELEM);
+    // if it is a system request, then we don't bother with this.
+    String action = page_request.getAttribute(GSXML.ACTION_ATT);
+    if (action.equals("s")) {
+        System.err.println("HACK: don't ask for coll info if system action");
+        return;
+    }
     ///ystem.out.println("add extra info, page request="+this.converter.getString(page_request));
     // is a collection defined?
 …
         Element coll_about_response_message = this.mr.process(coll_about_message);
         Element coll_about_response = (Element)GSXML.getChildByTagName(coll_about_response_message, GSXML.RESPONSE_ELEM);
+        if (coll_about_response == null) {
+        return;
+        }
         coll_description = (Element)GSXML.getChildByTagName(coll_about_response, GSXML.COLLECTION_ELEM);
         if (coll_description==null) { // may be a cluster

trunk/gsdl3/src/java/org/greenstone/gsdl3/core/MessageRouter.java

-              r9276
+              r9874
     this.converter = new XMLConverter();
     this.doc = this.converter.newDOM();
+    }
+    }
+    public void cleanUp() {
+    if (this.module_map != null) {
+        Iterator i = this.module_map.values().iterator();
+        while (i.hasNext()) {
+        ((ModuleInterface)i.next()).cleanUp();
+        }
+    }
+    }
     /** site_home must be set before configure called */
     public void setSiteHome(String home) {
 …
     this.module_map = new HashMap();
+    Element config = this.converter.getDOM(configFile).getDocumentElement();
+    Element local_site_name = (Element)GSXML.getChildByTagName(config, GSXML.SITE_NAME_ELEM);
+    Document config_doc = this.converter.getDOM(configFile);
+    if (config_doc == null) {
+System.err.println("MessageRouter: couldn't parse site config file: "+configFile.getPath());
+        return false;
+    }
+    Element config_elem = config_doc.getDocumentElement();
+    Element local_site_name = (Element)GSXML.getChildByTagName(config_elem, GSXML.SITE_NAME_ELEM);
     if (local_site_name == null) {
         System.err.println("MessageRouter configure error:no site name in config file");
 …
+    }
     Element http_address = (Element)GSXML.getChildByTagName(config, GSXML.SITE_HTTP_ADDRESS_ELEM);
+    Element http_address = (Element)GSXML.getChildByTagName(config_elem, GSXML.SITE_HTTP_ADDRESS_ELEM);
     if (http_address == null) {
         System.err.println("MessageRouter configure error: no http address  in config file");
 …
+    }
     Element proxy = (Element)GSXML.getChildByTagName(config, "proxy");
+    Element proxy = (Element)GSXML.getChildByTagName(config_elem, "proxy");
     if (proxy != null) {
         String host = proxy.getAttribute("host");
 …
     // load up the services
     Element service_rack_list = (Element)GSXML.getChildByTagName(config, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
+    Element service_rack_list = (Element)GSXML.getChildByTagName(config_elem, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
     configureServices(service_rack_list);
     // load up the service clusters
     Element cluster_list = (Element)GSXML.getChildByTagName(config, GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER);
+    Element cluster_list = (Element)GSXML.getChildByTagName(config_elem, GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER);
     configureClusters(cluster_list);
 …
     // load up the external sites - this also adds their services/clusters/collections to the other lists - so must be done last
     Element site_list = (Element)GSXML.getChildByTagName(config, GSXML.SITE_ELEM+GSXML.LIST_MODIFIER);
+    Element site_list = (Element)GSXML.getChildByTagName(config_elem, GSXML.SITE_ELEM+GSXML.LIST_MODIFIER);
     configureSites(site_list);
 …
                     continue;
+                }
+                site_config_elem  = this.converter.getDOM(configFile).getDocumentElement();
+                Document site_config_doc = this.converter.getDOM(configFile);
+                if (site_config_doc == null) {
+                    System.err.println("MessageRouter: couldn't parse site config file: "+configFile.getPath());
+                    continue;
+                }
+                site_config_elem  = site_config_doc.getDocumentElement();
+                }
                 if (subset.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
 …
     File init_file = new File(GSFile.collectionInitFile(this.site_home, col_name));
     if (init_file.exists()) {
+        Element init_elem = this.converter.getDOM(init_file).getDocumentElement();
+        String coll_class_name = init_elem.getAttribute("class");
+        if (coll_class_name.equals("")) {
+        c = new Collection();
+        } else {
+        try {
+            c = (Collection)Class.forName("org.greenstone.gsdl3.collection."+coll_class_name).newInstance();
+        } catch (Exception e) {
+            System.out.println("MessageRouter: couldn't create a new collection, type "+coll_class_name+", defaulting to class Collection");
+            c = new Collection();
+        }
+        }
+    } else {
+        // use the defualt collection
+        Document init_doc = this.converter.getDOM(init_file);
+        if (init_doc != null) {
+        Element init_elem = init_doc.getDocumentElement();
+        if (init_elem != null) {
+            String coll_class_name = init_elem.getAttribute("class");
+            if (!coll_class_name.equals("")) {
+            try {
+                c = (Collection)Class.forName("org.greenstone.gsdl3.collection."+coll_class_name).newInstance();
+            } catch (Exception e) {
+                System.out.println("MessageRouter: couldn't create a new collection, type "+coll_class_name+", defaulting to class Collection");
+            }
+            }
+        }
+        }
+    }
+    if (c==null) { // we haven't found anpther classname to use
         c = new Collection();
+    }
     c.setCollectionName(col_name);
     c.setSiteHome(this.site_home);
 …
+    }
     protected boolean activateSite(String site_name) {
     System.out.println("MessageRouter:Activating site: "+site_name+".");
 …
         return false;
+    }
+    Element config = this.converter.getDOM(configFile).getDocumentElement();
+    Element site_list = (Element)GSXML.getChildByTagName(config, GSXML.SITE_ELEM+GSXML.LIST_MODIFIER);
+    Document config_doc = this.converter.getDOM(configFile);
+    if (config_doc == null) {
+        System.err.println("MessageRouter: couldn't parse site config file: "+configFile.getPath());
+        return false;
+    }
+    Element config_elem = config_doc.getDocumentElement();
+    Element site_list = (Element)GSXML.getChildByTagName(config_elem, GSXML.SITE_ELEM+GSXML.LIST_MODIFIER);
     if (site_list ==null ) {
         System.err.println("MessageRouter:activateSite, no sites found");
 …
         System.out.println("MessageRouter: deactivating "+name);
         this.module_map.remove(name);
+        ModuleInterface m = (ModuleInterface)this.module_map.remove(name);
+        m.cleanUp(); // clean up any open files/connections etc - can cause trouble on windows
         // also remove the xml bit from description list
         if (type.equals(GSXML.COLLECTION_ELEM)) {

trunk/gsdl3/src/java/org/greenstone/gsdl3/core/ModuleInterface.java

-              r3502
+              r9874
    */
     abstract public Element process(Element xml_in);
+    /**
+     * Do any clean up necessary for deactivating the module, eg
+     * close any open file handles (gdbm in particular) or windows
+     * holds locks on them.
+     */
+    abstract public void cleanUp();
+}

trunk/gsdl3/src/java/org/greenstone/gsdl3/core/Receptionist.java

-              r8921
+              r9874
+    }
+    public void cleanUp() {}
     public void setParams(GSParams params) {
     this.params = params;
 …
+    }
+    Element config_doc = this.converter.getDOM(interface_config_file).getDocumentElement();
+    String base_interface = config_doc.getAttribute("baseInterface");
+    Document config_doc = this.converter.getDOM(interface_config_file);
+    if (config_doc == null) {
+        System.err.println("Receptionist: could not parse interface config file: "+interface_config_file.getPath());
+        return false;
+    }
+    Element config_elem = config_doc.getDocumentElement();
+    String base_interface = config_elem.getAttribute("baseInterface");
     setUpBaseInterface(base_interface);
     setUpInterfaceOptions(config_doc);
+    setUpInterfaceOptions(config_elem);
     // load up the actions
     Element action_list = (Element)GSXML.getChildByTagName(config_doc, GSXML.ACTION_ELEM+GSXML.LIST_MODIFIER);
+    Element action_list = (Element)GSXML.getChildByTagName(config_elem, GSXML.ACTION_ELEM+GSXML.LIST_MODIFIER);
     NodeList actions = action_list.getElementsByTagName(GSXML.ACTION_ELEM);
 …
+    }
     this.language_list = (Element)GSXML.getChildByTagName(config_doc, "languageList");
+    this.language_list = (Element)GSXML.getChildByTagName(config_elem, "languageList");
     if (language_list == null) {
         System.err.println("Receptionist: didn't find a language list in the config file!!");
 …
         base_interfaces.add(base_interface);
         // now see if this has a base interface
+        Element config_doc = this.converter.getDOM(base_interface_config_file).getDocumentElement();
+        base_interface = config_doc.getAttribute("baseInterface");
+        Document config_doc = this.converter.getDOM(base_interface_config_file);
+        if (config_doc == null) {
+        System.err.println("Receptionist: could not parse base interface config file: "+base_interface_config_file.getPath());
+        return false;
+        }
+        Element config_elem = config_doc.getDocumentElement();
+        base_interface = config_elem.getAttribute("baseInterface");
+    }
     return true;
+    }
     protected boolean setUpInterfaceOptions(Element config_doc) {
     Element option_list = (Element)GSXML.getChildByTagName(config_doc, "optionList");
+    protected boolean setUpInterfaceOptions(Element config_elem) {
+    Element option_list = (Element)GSXML.getChildByTagName(config_elem, "optionList");
     if (option_list != null) {
         System.err.println("found an option list");

trunk/gsdl3/src/java/org/greenstone/gsdl3/core/TransformingReceptionist.java

-              r9405
+              r9874
         return false;
+    }
+    Element config_doc = this.converter.getDOM(interface_config_file, "utf-8").getDocumentElement();
+    String base_interface = config_doc.getAttribute("baseInterface");
+    Document config_doc = this.converter.getDOM(interface_config_file, "utf-8");
+    if (config_doc == null) {
+        System.err.println("TransformingReceptionist: could not parse interface config file: "+interface_config_file.getPath());
+        return false;
+    }
+    Element config_elem = config_doc.getDocumentElement();
+    String base_interface = config_elem.getAttribute("baseInterface");
     setUpBaseInterface(base_interface);
     setUpInterfaceOptions(config_doc);
     Element action_list = (Element)GSXML.getChildByTagName(config_doc, GSXML.ACTION_ELEM+GSXML.LIST_MODIFIER);
+    setUpInterfaceOptions(config_elem);
+    Element action_list = (Element)GSXML.getChildByTagName(config_elem, GSXML.ACTION_ELEM+GSXML.LIST_MODIFIER);
     NodeList actions = action_list.getElementsByTagName(GSXML.ACTION_ELEM);
 …
+    }
     Element lang_list = (Element)GSXML.getChildByTagName(config_doc, "languageList");
+    Element lang_list = (Element)GSXML.getChildByTagName(config_elem, "languageList");
     if (lang_list == null) {
         System.err.println("TransformingReceptionist: didn't find a language list in the config file!!");
 …
+    }
     Document style_doc = this.converter.getDOM(new File(xslt_file), "UTF-8");
+    if (style_doc == null) {
+        System.err.println("TransformingReceptionist: cant parse the xslt file needed, so returning the original page!");
+        return page;
+    }
     // look for the format element in the page response
 …
         // need to transform the format info
         String stylesheet_file = GSFile.stylesheetFile((String)this.config_params.get(GSConstants.GSDL3_HOME), (String)this.config_params.get(GSConstants.SITE_NAME), collection, (String)this.config_params.get(GSConstants.INTERFACE_NAME), base_interfaces,   "config_format.xsl");
+        Document stylesheet = this.converter.getDOM(new File(stylesheet_file));
+        Document format_doc = this.converter.newDOM();
+        format_doc.appendChild(format_doc.importNode(format_elem, true));
+        Element new_format = (Element)this.transformer.transform(stylesheet, format_doc);
+        Document stylesheet_doc = this.converter.getDOM(new File(stylesheet_file));
+        if (stylesheet_doc != null) {
+        Document format_doc = this.converter.newDOM();
+        format_doc.appendChild(format_doc.importNode(format_elem, true));
+        Element new_format = (Element)this.transformer.transform(stylesheet_doc, format_doc);
         ///ystem.err.println("new format elem="+this.converter.getPrettyString(new_format));
         // add it in to the main stylesheet
+        GSXSLT.mergeStylesheets(style_doc, new_format);
+        GSXSLT.mergeStylesheets(style_doc, new_format);
+        } else {
+        System.err.println("TransformingReceptionist: couldn't parse the config_format stylesheet, adding the format info as is");
+        GSXSLT.mergeStylesheets(style_doc, format_elem);
+        }
         ///ystem.out.println("the converted stylesheet is:");
         ///ystem.out.println(this.converter.getPrettyString(style_doc.getDocumentElement()));

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/CollectionManager.java

-              r8969
+              r9874
       GS3SQLSelect select = new GS3SQLSelect("build");
       select.addField("*");
+      this.database.execute(select.toString());
+      ResultSet results = this.database.getResultSet();
+      if (results != null &&
+      results.first()) {
+      Statement statement = this.database.createStatement();
+      ResultSet results = statement.executeQuery(select.toString());
+      if (results.first()) {
     System.out.println("Reading all keys");
     do {
 …
     } while (results.next());
+      }
+      statement.close();
+    }
     catch (SQLException ex)
 …
     // Update build date information
+    GS3SQLDelete remove = new GS3SQLDelete("build");
+    //    GS3SQLWhere where = new GS3SQLWhere(new GS3SQLWhereItem("buildKey", "=", "NextSeqNo"));
+    //    rem
+    this.database.execute(remove.toString());
+    GS3SQLInsert insert = new GS3SQLInsert("build");
+    insert.addValue("buildKey", "NextSeqNo");
+    insert.addValue("buildValue", Integer.toString(this.buildDocNo));
+    this.database.execute(insert.toString());
+    insert = new GS3SQLInsert("build");
+    insert.addValue("buildKey", "lastBuildDate");
+    insert.addValue("buildValue", getDateString(this.lastBuildDate));
+    this.database.execute(insert.toString());
+    try {
+      GS3SQLDelete remove = new GS3SQLDelete("build");
+      //    GS3SQLWhere where = new GS3SQLWhere(new GS3SQLWhereItem("buildKey", "=", "NextSeqNo"));
+      //    rem
+      Statement statement = this.database.createStatement();
+      statement.execute(remove.toString());
+      GS3SQLInsert insert = new GS3SQLInsert("build");
+      insert.addValue("buildKey", "NextSeqNo");
+      insert.addValue("buildValue", Integer.toString(this.buildDocNo));
+      statement.execute(insert.toString());
+      insert = new GS3SQLInsert("build");
+      insert.addValue("buildKey", "lastBuildDate");
+      insert.addValue("buildValue", getDateString(this.lastBuildDate));
+      statement.execute(insert.toString());
+      statement.close();
+    } catch (SQLException e) {
+    System.err.println("CollectionManager.endBuild(): Can't update build information: "+e);
+    }
     // Do tail of build output
     Date startDate = this.lastBuildDate.getTime();

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/Create.java

r8497	r9874
48	48
49	49	System.err.println("New collection created in "+coll_home);
50		System.err.println("Put source documents into import, set the collection's configuration in etc/collectionConfig.xml, then run gs3-build.sh to build the collection");
	50	System.err.println("Put source documents into import, set the collection's configuration in etc/collectionConfig.xml, then run gs3-build.sh (linux) or gs3-build (windows) to build the collection");
51	51	}
52	52

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/classifier/AZListClassifier.java

-              r8742
+              r9874
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import org.xml.sax.XMLReader;
 …
     select.setWhere(where);
-    connection.execute(select.toString());
     try {
+      ResultSet results = connection.getResultSet();
+      if (results != null && results.first()) {
+      Statement statement = connection.createStatement();
+      ResultSet results = statement.executeQuery(select.toString());
+      if (results.first()) {
     GS3SQLUpdate update = new GS3SQLUpdate("classifiers");
     update.setWhere(where);
 …
     action = insert;
+    classifyRef = -1;
+      }
       action.addValue("ClassifyID", label);
 …
       action.addValue("NumLeafDocs", Integer.toString(noOfLeafDocs), GS3SQLField.INTEGER_TYPE);
+      connection.execute(action.toString());
+      classifyRef = -1;
+    }
+    catch (SQLException sqlEx) {
+      System.err.println(sqlEx);
+      return -1;
+    }
+    // get the ClassifyRef if we don't already have it (have done a
+    // insert action above)...
+    if (classifyRef == -1) {
+      connection.execute(select.toString());
+      try {
+    ResultSet results = connection.getResultSet();
+    if (results == null || !results.first()) {
+      // do the update/insert
+      statement.execute(action.toString());
+      // get the ClassifyRef if we don't already have it (have done a
+      // insert action above)...
+      if (classifyRef == -1) {
+    results = statement.executeQuery(select.toString());
+    if (!results.first()) {
       return -1;
+    }
 …
     classifyRef = results.getInt("ClassifyRef");
+      }
+      catch (SQLException sqlEx) {
+    System.err.println(sqlEx);
+      statement.close();
+    }  catch (SQLException sqlEx) {
+    System.err.println("AZListClassifier.writeSQLClassifyNode(): "+sqlEx);
     return -1;
+      }
+    }
+    }
     return classifyRef;
 …
+    }
+    try {
+    Statement statement = connection.createStatement();
     List children;
 …
         Iterator iterator = childDocs.iterator();
     int childOrder = 1;
+    //St
     while (iterator.hasNext()) {
       AZDocumentItem documentItem = (AZDocumentItem) iterator.next();
 …
       insert.addValue("DocOrder", Integer.toString(childOrder), GS3SQLField.INTEGER_TYPE);
       connection.execute(insert.toString());
+      statement.execute(insert.toString());
       childOrder ++;
 …
+    }
     /*
     else {
 …
       delete.setWhere(where);
       connection.execute(delete.toString());
+      statement.execute(delete.toString());
+    }
 …
+    }
     */
+    statement.close();
+    } catch (SQLException e) {
+    System.err.println("AZListClassifier.writeSQL(): "+e);
+    return false;
+    }
     return true;

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/classifier/AbstractHierarchyNode.java

-              r8742
+              r9874
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import org.greenstone.gsdl3.gs3build.doctypes.DocumentID;
 …
     GS3SQLInsert insert;
+    Statement statement;
+    // can we connect to the database?
+    try {
+    statement = connection.createStatement();
+    } catch (SQLException e) {
+    System.err.println("AbstractHierarchyNode.writeSQL(): "+e);
+    return false;
+    }
     // Get own full id
     String fullId = this.id.length() > 0 ? this.prefix+"."+this.id : this.prefix;
 …
     select.setWhere(where);
-    connection.execute(select.toString());
     // update or insert the classifier as required
     try {
       ResultSet results = connection.getResultSet();
       if (results != null && results.first()) {
+      ResultSet results = statement.executeQuery(select.toString());
+      if (results.first()) {
     GS3SQLUpdate update = new GS3SQLUpdate("classifiers");
     update.setWhere(where);
 …
     action = insert;
+    classifyRef = -1;
+      }
       action.addValue("ClassifyID", fullId);
 …
       action.addValue("NumLeafDocs", Integer.toString(this.noOfLeafDocs()), GS3SQLField.INTEGER_TYPE);
+      connection.execute(action.toString());
+      classifyRef = -1;
+      statement.execute(action.toString());
+    }
     catch (SQLException sqlEx) {
       if (action == null) {
     System.err.println(sqlEx);
+    System.err.println("AbstractHierarchyNode.writeSQL(): "+sqlEx);
+      }
       else {
     System.err.println(sqlEx + " " + action.toString());
+    System.err.println("AbstractHierarchyNode.writeSQL(): "+sqlEx + " " + action.toString());
+      }
       return false;
 …
     // insert action above)...
     if (classifyRef == -1) {
-      connection.execute(select.toString());
       try {
+    ResultSet results = connection.getResultSet();
+    if (results == null || !results.first()) {
+      return false;
+        ResultSet results = statement.executeQuery(select.toString());
+    if (!results.first()) {
+        statement.close();
+        return false;
+    }
     classifyRef = results.getInt("ClassifyRef");
+      }
       catch (SQLException sqlEx) {
     System.err.println(sqlEx);
+    System.err.println("AbstractHierarchyNode.writeSQL(): "+sqlEx);
     return false;
+      }
 …
       GS3SQLDelete delete = new GS3SQLDelete("classdocuments");
       delete.setWhere(where);
+      connection.execute(delete.toString());
+    }
+      try {
+      statement.execute(delete.toString());
+      } catch (SQLException e) {
+      System.err.println("AbstractHierarchyNode.writeSQL(): "+e);
+      return false;
+      }
+    }
     // post the child nodes...
     Iterator iterator = this.childNodes.iterator();
 …
       if (!childNode.writeSQL(connection)) {
       System.out.println("Failed to write " );
     return false;
+      return false;
+      }
+    }
 …
       insert.addValue("DocID", docId.toString());
       insert.addValue("DocOrder", Integer.toString(order), GS3SQLField.INTEGER_TYPE);
+      connection.execute(insert.toString());
+      try {
+      statement.execute(insert.toString());
+      } catch (SQLException e) {
+      System.err.println("AbstractHierarchyNode.writeSQL(): "+e);
+      return false;
+      }
       order ++;
+    }
+    // close the statment
+    try {
+    statement.close();
+    } catch (SQLException e) {
+    System.err.println("AbstractHierarchyNode.writeSQL(): "+e);
+    }
     return true;
+  }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/database/GS3SQLConnection.java

-              r8773
+              r9874
+{
     public GS3SQLConnection(java.sql.Connection connection)
+    public GS3SQLConnection(java.sql.Connection connection, String database)
+    {
     super(connection);
+    super(connection, database);
+    }
 …
+  }
+    public GS3SQLConnection cloneConnection() {
+    GS3SQLConnection conn = GS3SQLConnectionFactory.getGS3SQLConnection(this.database);
+    return conn;
+    }
   /**
    *  Initialise a collection for use.
 …
     try {
       statement = this.connection.createStatement();
+      Statement statement = this.connection.createStatement();
       // create build history table
 …
       statement.execute(classData.toString());
+      statement.close();
       //
       // END OF GSDL TABLES

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/database/GS3SQLConnectionFactory.java

r8745	r9874
32	32	return null;
33	33	}
34		return new SQLConnection(c);
	34	return new SQLConnection(c, database);
35	35	}
36	36
…	…
42	42	return null;
43	43	}
44		return new GS3SQLConnection(c);
	44	return new GS3SQLConnection(c, database);
45	45	}
46	46

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/database/SQLConnection.java

-              r8745
+              r9874
+{
     protected Connection connection;
+    protected Statement  statement;
+    public SQLConnection(java.sql.Connection connection)
+    protected String database;
+    public SQLConnection(java.sql.Connection connection, String database)
+    {
     this.connection = connection;
+    this.database = database;
+    }
 …
     if (this.connection!=null) {
         try {
         this.connection.close();
+        this.connection.close();
         } catch (Exception e) {}
+        this.connection = null;
+    }
+    }
+    this.connection = null;
+    }
+    public boolean execute(String sql)
+    {
+    try {
+        this.statement = this.connection.createStatement();
+        this.statement.execute(sql);
+    }
+    catch (SQLException ex) {
+        System.out.println(ex);
+        return false;
+    }
+    return true;
+    public void close() {
+    finalize();
+    }
     public Statement createStatement()
+    public Statement createStatement() throws SQLException
+    {
+    try {
+        return this.connection.createStatement();
+    }
+    catch (SQLException ex) {
+        return null;
+    }
+    }
+    public Statement getStatement()
+    {
+    return this.statement;
+    }
+    public ResultSet getResultSet()
+    {
+    try {
+        return this.statement.getResultSet();
+    }
+    catch (SQLException ex) {
+        return null;
+    }
+    return this.connection.createStatement();
+    }
     public boolean connectToDatabase(String database) {
+    if (this.connection != null) {
+        try {
+        this.connection.close();
+        } catch (Exception e) {}
+    }
     this.connection = GS3SQLConnectionFactory.getConnection(database);
     if (this.connection == null) {
         return false;
+    }
+    this.database = database;
     return true;
+    }
 …
     public boolean dropDatabase(String database) {
     try {
+        this.statement = this.connection.createStatement();
+        this.statement.execute("DROP DATABASE "+database+";");
+        Statement statement = this.connection.createStatement();
+        statement.execute("DROP DATABASE "+database+";");
+        statement.close();
+    }
     catch (SQLException ex){
 …
     try {
         String command = "CREATE DATABASE " + database;
+        this.statement = this.connection.createStatement();
+        this.statement.execute(command);
+        Statement statement = this.connection.createStatement();
+        statement.execute(command);
+        statement.close();
     } catch (Exception e) {
         System.err.println(e);

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/doctypes/AbstractDocument.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 import java.sql.Timestamp;
 …
     // Query for documents using the same file...
     String query = "SELECT DocID FROM files INNER JOIN filegroups ON files.FileGroupRef=filegroups.FileGroupRef WHERE (filegroups.FileGroupId=\"default\" AND files.FileLocation=\"" + this.fileSet.getFile(0).getLocation().toString() + "\")";
-    connection.execute(query);
-    List docs = new ArrayList();
-    ResultSet results = connection.getResultSet();
     try {
+      if (results != null &&
+      results.first())
+      { do {
+          String value = results.getString("DocID");
+      docs.add(value);
+        } while (results.next());
+        Iterator docIterator = docs.iterator();
+    while (docIterator.hasNext()) {
+      String docId = docIterator.next().toString();
+      String innerQuery = "SELECT * FROM document WHERE DocID=\"" + docId + "\"";
+      connection.execute(innerQuery);
+      ResultSet innerSet = connection.getResultSet();
+      if (innerSet != null && innerSet.first()) {
+        String docType = innerSet.getString("DocType");
+        if (docType.equals(this.getDocumentType())) {
+          return docId;
+    Statement statement = connection.createStatement();
+    ResultSet results = statement.executeQuery(query);
+    List docs = new ArrayList();
+    if (results.first()) {
+        do {
+        String value = results.getString("DocID");
+        docs.add(value);
+        } while (results.next());
+        Iterator docIterator = docs.iterator();
+        while (docIterator.hasNext()) {
+        String docId = docIterator.next().toString();
+        String innerQuery = "SELECT * FROM document WHERE DocID=\"" + docId + "\"";
+        results = statement.executeQuery(innerQuery);
+        if (results.first()) {
+            String docType = results.getString("DocType");
+            if (docType.equals(this.getDocumentType())) {
+            return docId;
+            }
+        }
+        }
+      }
+    }
+      }
+    statement.close();
+    }
     catch (java.sql.SQLException sqlEx) {
       System.err.println(sqlEx);
+      System.err.println("AbstractDocument.getDuplicateID(): "+sqlEx);
+    }
 …
    *  Obtain a document from the SQL database
    */
   public static AbstractDocument readSQL(GS3SQLConnection connection, ResultSet sqlResult)
+    public static AbstractDocument readSQL(GS3SQLConnection connection, ResultSet sqlResult)
   { try {
       DocumentID id = new DocumentID(sqlResult.getString("DocID"));
 …
       // Use a factory method to create the correct subtype...
       AbstractDocument document = DocumentFactory.createDocument(type, id);
       // Append the document date information
       document.indexDate    = sqlResult.getTimestamp("IndexedDate");
 …
+    }
     catch (SQLException sqlEx) {
       System.out.println("Failure to load document: " + sqlEx);
+      System.err.println("AbstractDocument.readSQL(): Failure to load document: " + sqlEx);
+    }
     return null;

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/doctypes/DocumentFactory.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 import java.net.URL;
 …
+  {
     String query = "SELECT * FROM document WHERE DocID=\""+id.toString()+"\";";
-    connection.execute(query);
     try {
+      ResultSet results = connection.getResultSet();
+      if (results != null && results.first()) {
+    return AbstractDocument.readSQL(connection, results);
+      }
+    Statement statement = connection.createStatement();
+    ResultSet results = statement.executeQuery(query);
+    DocumentInterface di = null;
+    if (results.first()) {
+        di = AbstractDocument.readSQL(connection, results);
+    }
+    statement.close();
+    return di;
+    }
     catch (SQLException sqlEx) {
       System.err.println(sqlEx);
+      System.err.println("AbstractDocument.readSQLDocument():"+sqlEx);
+    }
     return null;

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/doctypes/DocumentList.java

-              r8861
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
     select.setWhere(where);
+    this.connection.execute(select.toString());
+    ResultSet results = this.connection.getResultSet();
+    if (results != null) {
+      select = new GS3SQLSelect("filegroups");
+      select.addField("DocID");
+      select.setDistinct(true);
+      where = new GS3SQLWhere();
+      where.setCondition(GS3SQLWhere.OR_CONDITION);
+      GS3SQLWhereItem whereItem = null;
+      try {
+    results.first();
+    try {
+    Statement statement = connection.createStatement();
+    ResultSet results = statement.executeQuery(select.toString());
+    select = new GS3SQLSelect("filegroups");
+    select.addField("DocID");
+    select.setDistinct(true);
+    where = new GS3SQLWhere();
+    where.setCondition(GS3SQLWhere.OR_CONDITION);
+    GS3SQLWhereItem whereItem = null;
+        results.first();
     do {
       int fileGroupRef = results.getInt("FileGroupRef");
 …
     while (results.next());
     select.setWhere(where);
+    results.close();
+    this.connection.execute(select.toString());
+    results = this.connection.getResultSet();
+    results = statement.executeQuery(select.toString());
     results.first();
     do {
 …
       reply.add(docId);
     } while (results.next());
+      }
+      catch (SQLException sqlEx)
+      { System.err.println(sqlEx);
+      }
+    }
+    statement.close();
+    }
+    catch (SQLException sqlEx) {
+    System.err.println("DocumentList.getDocumentIdsWithFile(): "+sqlEx);
+    }
     return reply;
+  }
 …
+  }
+  private List findDocumentIdsUsingFileQuery(String query)
+  { this.connection.execute(query);
+    try {
+      ResultSet results = this.connection.getResultSet();
+      if (results == null ||
+      !results.first()) {
+    return null;
+      }
+    private List findDocumentIdsUsingFileQuery(String query) {
+    try {
+    Statement statement = connection.createStatement();
+    ResultSet results = statement.executeQuery(query);
+    if (!results.first()) {
+        statement.close();
+        return null;
+    }
       // get a list of group ids first and turn it into a query on filegroups
 …
       // structures...recreating new filegroup queries as necessary
       while (queryBuffer.length() > 0) {
     connection.execute(queryBuffer.toString());
     results = this.connection.getResultSet();
     if (results == null || !results.first()) {
       return null;
+    results = statement.executeQuery(queryBuffer.toString());
+    if (!results.first()) {
+        statement.close();
+        return null;
+    }
 …
       // execute the division query
+      this.connection.execute(queryBuffer.toString());
+      results = this.connection.getResultSet();
+      if (results == null ||
+      !results.first()) {
+    return null;
+      results = statement.executeQuery(queryBuffer.toString());
+      if (!results.first()) {
+      statement.close();
+      return null;
+      }
 …
     reply.add(results.getString("DocID"));
       } while (results.next());
+      statement.close();
       return reply;
+    }
     catch (SQLException ex) {
       System.err.println(ex);
+      System.err.println("DocumentList.findDocumentIdsUsingFileQuery()"+ ex);
+    }
     return null;
 …
     select.addField("*");
-    ResultSet documents;
     try {
       connection.execute(select.toString());
       documents = connection.getResultSet();
+      if (documents.first())
+      { do
     { DocumentInterface document = AbstractDocument.readSQL(connection, documents);
+          list.addDocument(document);
+    }
     while (documents.next());
+      }
+    }
     catch (java.sql.SQLException ex)
     { System.out.println(ex);
       return null;
+    Statement statement = connection.createStatement();
+    ResultSet documents = statement.executeQuery(select.toString());
+    if (documents.first()) {
+        do {
+        DocumentInterface document = AbstractDocument.readSQL(connection, documents);
+        list.addDocument(document);
+        }
+        while (documents.next());
+    }
+    statement.close();
+    }
+    catch (java.sql.SQLException ex) {
+    System.out.println("DocumentList.writeSQLDocuments(): "+ex);
+    return null;
+    }
 …
+{
   private boolean hasNext;
+  private Statement statement;
   private ResultSet resultSet;
   private GS3SQLConnection connection;
 …
     try {
       connection.execute(select.toString());
       this.resultSet = connection.getResultSet();
+    this.statement = connection.createStatement();
+      this.resultSet = statement.executeQuery(select.toString());
       this.hasNext = this.resultSet.first();
     } catch (SQLException ex) {
+      System.err.println("DocumentListIterator(): "+ex);
       this.hasNext = false;
+    }
 …
       if (!this.hasNext) {
     this.resultSet.close(); // be a good citizen & close used result sets
+      this.statement.close(); // be a good citizen & close used statement
+      }
     } catch (SQLException ex) {
+    System.err.println("DocumentList.iterator.next(): "+ex);
       this.hasNext = false;
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/doctypes/DocumentSQLWriter.java

-              r8742
+              r9874
     update.addDate("IndexedDate", new java.sql.Timestamp(touchTime));
     update.addDate("ModifiedDate", new java.sql.Timestamp(modTime));
+    connection.execute(update.toString());
+    try {
+    Statement statement = connection.createStatement();
+    statement.execute(update.toString());
+    statement.close();
+    } catch (SQLException e) {
+    System.err.println("DocumentSQLWriter.touchDocument() Error: "+ e);
+    return false;
+    }
     System.out.println(update.toString());
     return true;
 …
     select.addField("*");
     select.setWhere(new GS3SQLWhere(new GS3SQLWhereItem("DocID", "=", document.getID().toString())));
-    connection.execute(select.toString());
+    ResultSet results = connection.getResultSet();
+    if (results == null ||
+        !results.first())
+    { GS3SQLInsert insert = new GS3SQLInsert("document");
+    Statement statement = connection.createStatement();
+    ResultSet results = statement.executeQuery(select.toString());
+    if (!results.first()) { // empty result
+      GS3SQLInsert insert = new GS3SQLInsert("document");
       insert.addValue("DocID", document.getID().toString());
       insert.addValue("DocType", document.getDocumentType());
 …
       insert.addDate("ModifiedDate", new java.sql.Timestamp(document.getModifiedDatestamp()));
       connection.execute(insert.toString());
+      statement.execute(insert.toString());
+    }
     else {
 …
       //      connection.execute(update.toString());
+    }
+    statement.close();
+      }
     } catch (Exception ex) {
     System.out.println(ex);
+    } catch (SQLException ex) {
+    System.out.println("DocumentSQLWriter.writeDocument() Error:"+ex);
+    }
     //    output.println(tag);

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/doctypes/HTMLDocument.java

r8929	r9874
279	279	public Document getDOMDocument()
280	280	{
281		if (this.domDocument == null) {
	281	if (this.domDocument == null) {
282	282	URL url =(URL) this.fileSet.getFile(0).getLocation();
283	283	this.loadDocument(url);

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/indexers/MGPPIndexer.java

-              r9006
+              r9874
+    {
     if (this.pass == 0) {
         document.removeAllMetadata("gsdl3", "mgppseqno");
+        document.removeAllMetadata("gsdl3", "mgseqno");
+    }
 …
     String docText = null;
+    int startSeqNo = this.sectionSeqNo;
+    this.sectionSeqNo ++;
+    //int startSeqNo = this.sectionSeqNo;
+    //this.sectionSeqNo ++;
+    int startSeqNo = this.documentSeqNo;
     Document domDocument = document.getDOMDocument();
     if (domDocument != null) {
 …
     if (this.pass == 0) {
         document.addDocumentMetadata("gsdl3", "mgppseqno", "dtx."+Integer.toString(startSeqNo));
+    }
     this.documentSeqNo += 1;
+        document.addDocumentMetadata("gsdl3", "mgseqno", "dtx."+Integer.toString(startSeqNo));
+    }
+    this.documentSeqNo++;
 //  try {
 …
     this.firstDocument = true;
     this.documentSeqNo = 1;
+    this.sectionSeqNo = 1;
     this.mgppPasses = new MGPPPassesWrapper();
     this.indexBuffer = new StringBuffer();
 …
         System.out.println("Compressed dictionary successfully written");
         } else {
+        System.err.println("Error from mg_compression_dict: " + exit_value);
+        index.setError(true);
+        System.err.println("Error from mgpp_compression_dict: " + exit_value);
+        //index.setError(true);
         return false;
+        }
 …
         } else {
         System.err.println("Unable to build the perfect hash");
         index.setError(true);
+        //index.setError(true);
         return false;
+        }
 …
         } else {
         System.err.println("Unable to create weights file");
         index.setError(true);
+        //index.setError(true);
         return false;
+        }
 …
         } else {
         System.out.println("Unable to create inverted dictionary file");
         index.setError(true);
+        //index.setError(true);
         return false;
+        }
 …
         } else {
         System.out.println("Unable to create stemmed index 1");
         index.setError(true);
+        //index.setError(true);
         return false;
+        }
 …
         } else {
         System.out.println("Unable to create stemmed index 2");
         index.setError(true);
+        //index.setError(true);
         return false;
+        }
 …
         } else {
         System.out.println("Unable to create stemmed index 3");
         index.setError(true);
+        //index.setError(true);
         return false;
+        }
 …
     Element default_index = doc.createElement("defaultIndex");
     default_index.setAttribute(GSXML.NAME_ATT, def_index);
     Element base_index_name = doc.createElement("baseIndexPrefix");
+    base_index_name.setAttribute(GSXML.NAME_ATT, "index");  //overallName);
+    base_index_name.setAttribute(GSXML.NAME_ATT, "dtx");  //overallName);
     Element index_stem = doc.createElement("indexStem");
     index_stem.setAttribute(GSXML.NAME_ATT, "index");
 …
     Element retrieve_service_elem = doc.createElement(GSXML.SERVICE_CLASS_ELEM);
     Element default_level = doc.createElement("defaultLevel");
+    default_index.setAttribute(GSXML.NAME_ATT, "Document");
+    default_level.setAttribute(GSXML.NAME_ATT, "Document");
+    Element level_list = doc.createElement("levelList");
+    Element level = doc.createElement("level");
+    level.setAttribute(GSXML.NAME_ATT, "Document");
+    level_list.appendChild(level);
+    Element field_list = doc.createElement("fieldList");
+    Element field = doc.createElement("field");
+    field.setAttribute(GSXML.NAME_ATT, "ZZ");
+    field_list.appendChild(field);
     service_rack_list.appendChild(search_service_elem);
     service_rack_list.appendChild(retrieve_service_elem);
 …
     search_service_elem.appendChild(index_list);
     search_service_elem.appendChild(default_index);
+    search_service_elem.appendChild(level_list);
     search_service_elem.appendChild(default_level);
+search_service_elem.appendChild(field_list); // do we need this??
     search_service_elem.appendChild(base_index_name);
     search_service_elem.appendChild(index_stem);

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSDescriptive.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
         } else {
         // TODO: raise an error!
         System.out.println("Error: METSDescriiptive: unrecognised tag "+childName);
+        System.out.println("Error: METSDescriptive: unrecognised tag "+childName);
+        }
+    }
 …
     select.setWhere(where);
-    connection.execute(select.toString());
     try {
+        Statement statement = connection.createStatement();
+        ResultSet resultSet = statement.executeQuery(select.toString());
         GS3SQLAction action;
+        ResultSet resultSet = connection.getResultSet();
+        if (resultSet != null &&
+        resultSet.first()) {
+        if (resultSet.first()) {
         // the node already exists - no need to do anything as such
         GS3SQLUpdate update = new GS3SQLUpdate("metadata");
 …
         action = update;
+        }
+        else
+        { // Set result set to null, just in case next() didn't work above...
+            resultSet = null;
+            // It is a new node and needs writing
+            action = new GS3SQLInsert("metadata");
+            action.addValue("DocID", document.getID().toString());
+            action.addValue("MetaID", this.ID);
+        }
+        else { // Set result set to null, just in case first() didn't work above...
+        // It is a new node and needs writing
+        action = new GS3SQLInsert("metadata");
+        action.addValue("DocID", document.getID().toString());
+        action.addValue("MetaID", this.ID);
+        }
         // always set the group identifier
 …
         // execute the action as required
+        connection.execute(action.toString());
+        // create a new resultset if necessary
+        if (resultSet == null) {
+        // now execute the select statement again to get the new identifier
+        // 'MetadataRef'
+        // System.out.println(select.toString());
+        connection.execute(select.toString());
+        resultSet = connection.getResultSet();
+        resultSet.first();
+        }
+        // get the reference for this item...
+        sqlId = resultSet.getInt("MetadataRef");
+        statement.execute(action.toString());
+        // get the resultSet again
+        // now execute the select statement again to get the new identifier
+        // 'MetadataRef'
+        // System.out.println(select.toString());
+        resultSet = statement.executeQuery(select.toString());
+        if (resultSet.first()) {
+        // get the reference for this item...
+        sqlId = resultSet.getInt("MetadataRef");
+        }
+        statement.close();
+    }
     catch (SQLException sql){
+        System.out.println(sql);
+        System.err.println("METSDescriptive.writeSQL(): "+sql);
+    }
+    if (sqlId == -1) {
+        return false;
+    }
 …
         select.setWhere(where);
+        connection.execute(select.toString());
+        // parse through the namespaces, calling the namespace class to create instances
+        // as it will
+        ResultSet namespaceSet = connection.getResultSet();
+        if (namespaceSet != null && namespaceSet.first()) {
+        Statement statement = connection.createStatement();
+        ResultSet namespaceSet = statement.executeQuery(select.toString());
+        // parse through the namespaces, calling the namespace class to create instances as it will
+        if (namespaceSet.first()) {
         do {
             METSNamespace namespace = METSNamespace.readSQL(connection, namespaceSet);
 …
+            }
             else {
             System.out.println("Null namespace output");
+            System.err.println("Null namespace output");
+            }
+        }
         while (namespaceSet.next());
+        }
+        statement.close();
         return descriptive;
+    }
     catch (SQLException sqlEx){
         System.out.println(sqlEx);
+        System.err.println("METSDescriptive.readSQL(): "+sqlEx);
         System.exit(1);
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSDescriptiveSet.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
     GS3SQLWhereItem whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
     select.setWhere(new GS3SQLWhere(whereItem));
+    connection.execute(select.toString());
     // start going through the matching metadata blocks
     try {
+        ResultSet resultSet = connection.getResultSet();
+        resultSet.first();
+        do {
+        METSDescriptive descriptive = METSDescriptive.readSQL(document, connection, resultSet);
+        if (descriptive != null) {
+            set.addDescriptive(descriptive);
+        }
+        else {
+            System.out.println("Null descriptive");
+        }
+        } while (resultSet.next());
+        Statement statement = connection.createStatement();
+        ResultSet resultSet = statement.executeQuery(select.toString());
+        if (resultSet.first()) {
+        do {
+            METSDescriptive descriptive = METSDescriptive.readSQL(document, connection, resultSet);
+            if (descriptive != null) {
+            set.addDescriptive(descriptive);
+            }
+            else {
+            System.out.println("Null descriptive");
+            }
+        } while (resultSet.next());
+        }
+        statement.close();
+    }
     catch (SQLException sqlEx) {
         System.out.println(sqlEx);
+        System.err.println("METSDescriptiveSet.readSQL(): "+sqlEx);
         System.exit(1);
+    }
     return set;
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSDivision.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
     select.setWhere(where);
+    connection.execute(select.toString());
+    Statement statement = null;
+    ResultSet resultSet = null;
     // Do the actual writing
     GS3SQLAction action;
-    ResultSet resultSet = connection.getResultSet();
     try {
         if (resultSet == null ||
         !resultSet.first()) {
         resultSet = null;
+        statement = connection.createStatement();
+        resultSet = statement.executeQuery(select.toString());
+        if (!resultSet.first()) {
         GS3SQLInsert insert = new GS3SQLInsert("divisions");
 …
         GS3SQLUpdate update = new GS3SQLUpdate("divisions");
         GS3SQLWhere  updateWhere =
+            new GS3SQLWhere(new GS3SQLWhereItem("DivisionRef", "=", Integer.toString(sqlRef),
+                            GS3SQLField.INTEGER_TYPE));
+            new GS3SQLWhere(new GS3SQLWhereItem("DivisionRef", "=", Integer.toString(sqlRef), GS3SQLField.INTEGER_TYPE));
         update.setWhere(updateWhere);
         action = update;
 …
     action.addValue("UserLabel", this.userLabel);
+    if (!connection.execute(action.toString())){
+    try {
+        statement.execute(action.toString());
+    } catch (SQLException e) {
+        System.err.println("METSDivision.writeSQL(): "+e);
         return false;
+    }
     // if doing a fresh item, get the new structure reference...
     if (resultSet == null){
+    if (sqlRef == -1){
         // get the new structure reference
-        connection.execute(select.toString());
-        // get the sql reference for the division
         try {
         // read in the structure reference
         resultSet = connection.getResultSet();
         if (resultSet == null) {
             return false;
+        resultSet = statement.executeQuery(select.toString());
+        if (resultSet.first()) {
+            sqlRef = resultSet.getInt("DivisionRef");
+        }
-        resultSet.first();
-        sqlRef = resultSet.getInt("DivisionRef");
-        resultSet.close();
-        resultSet = null;
+        }
         catch (SQLException sqlex) {
         System.err.println("Unable to retrieve reference for Division " + sqlex);
+        System.err.println("METSDIVISION.writeSQL(): Unable to retrieve reference for Division " + sqlex);
         return false;
+        }
+    }
-    // close the open resultSet, as we don't need it any longer...
-    else {
-        try {
-        resultSet.close();
+        }
-        catch (SQLException sql) {
-        System.err.println(sql + " " + select.toString());
+        }
+    }
     // delete the old file/metadata references
+    GS3SQLWhere referenceWhere =
+        new GS3SQLWhere(new GS3SQLWhereItem("DivisionRef", "=", Integer.toString(sqlRef),
+                        GS3SQLField.INTEGER_TYPE));
+    GS3SQLDelete delete = new GS3SQLDelete("divisionfilerefs");
+    delete.setWhere(referenceWhere);
+    connection.execute(delete.toString());
+    delete = new GS3SQLDelete("divisionmetarefs");
+    delete.setWhere(referenceWhere);
+    connection.execute(delete.toString());
+    // write the new file references
+    if (this.fileRefs.size() > 0){
+        Iterator iterator = this.fileRefs.iterator();
+        while (iterator.hasNext()) {
+        GS3SQLInsert fileinsert = new GS3SQLInsert("divisionfilerefs");
+        fileinsert.addValue("DocID", docId.toString());
+        fileinsert.addValue("DivisionRef", Integer.toString(sqlRef), GS3SQLField.INTEGER_TYPE);
+        fileinsert.addValue("DivisionType", "Group");
+        fileinsert.addValue("FileID", iterator.next().toString());
+        connection.execute(fileinsert.toString());
+        }
+    }
+    // write the metadata references
+    if (this.metadataRefs.size() > 0){
+        Iterator iterator = this.metadataRefs.iterator();
+        while (iterator.hasNext()) {
+        GS3SQLInsert metainsert = new GS3SQLInsert("divisionmetarefs");
+        metainsert.addValue("DocID", docId.toString());
+        metainsert.addValue("DivisionRef", Integer.toString(sqlRef), GS3SQLField.INTEGER_TYPE);
+        metainsert.addValue("DivisionType", "Group");
+        metainsert.addValue("MetaID", iterator.next().toString());
+        connection.execute(metainsert.toString());
+        }
+    }
+    try {
+        GS3SQLWhere referenceWhere =
+        new GS3SQLWhere(new GS3SQLWhereItem("DivisionRef", "=", Integer.toString(sqlRef),
+                            GS3SQLField.INTEGER_TYPE));
+        GS3SQLDelete delete = new GS3SQLDelete("divisionfilerefs");
+        delete.setWhere(referenceWhere);
+        statement.execute(delete.toString());
+        delete = new GS3SQLDelete("divisionmetarefs");
+        delete.setWhere(referenceWhere);
+        statement.execute(delete.toString());
+        // write the new file references
+        if (this.fileRefs.size() > 0){
+        Iterator iterator = this.fileRefs.iterator();
+        while (iterator.hasNext()) {
+            GS3SQLInsert fileinsert = new GS3SQLInsert("divisionfilerefs");
+            fileinsert.addValue("DocID", docId.toString());
+            fileinsert.addValue("DivisionRef", Integer.toString(sqlRef), GS3SQLField.INTEGER_TYPE);
+            fileinsert.addValue("DivisionType", "Group");
+            fileinsert.addValue("FileID", iterator.next().toString());
+            statement.execute(fileinsert.toString());
+        }
+        }
+        // write the metadata references
+        if (this.metadataRefs.size() > 0){
+        Iterator iterator = this.metadataRefs.iterator();
+        while (iterator.hasNext()) {
+            GS3SQLInsert metainsert = new GS3SQLInsert("divisionmetarefs");
+            metainsert.addValue("DocID", docId.toString());
+            metainsert.addValue("DivisionRef", Integer.toString(sqlRef), GS3SQLField.INTEGER_TYPE);
+            metainsert.addValue("DivisionType", "Group");
+            metainsert.addValue("MetaID", iterator.next().toString());
+            statement.execute(metainsert.toString());
+        }
+        }
+        statement.close();
+    } catch (SQLException e) {
+        System.err.println("METSDIVISION.writeSQL(): "+e);
+        return false;
+    }
     // write out any children in turn
     Iterator groups = this.children.values().iterator();
 …
         select.setWhere(where);
+        connection.execute(select.toString());
+        Statement statement = connection.createStatement();
+        ResultSet childSet = statement.executeQuery(select.toString());
         // circulate through to obtain further children
-        ResultSet childSet = connection.getResultSet();
         if (childSet.first())
+        {
 …
             while (childSet.next());
+        }
         select = new GS3SQLSelect("divisionfilerefs");
         select.addField("*");
 …
         select.setWhere(where);
+        connection.execute(select.toString());
+        ResultSet fileSet = connection.getResultSet();
+        if (fileSet != null && fileSet.first()){
+        ResultSet fileSet = statement.executeQuery(select.toString());
+        if (fileSet.first()){
         do {
             String reference = fileSet.getString("FileID");
 …
         while (fileSet.next());
+        }
         select = new GS3SQLSelect("divisionmetarefs");
         select.addField("*");
 …
         select.setWhere(where);
+        connection.execute(select.toString());
+        ResultSet metaSet = connection.getResultSet();
+        if (metaSet != null && metaSet.first()){
+        ResultSet metaSet = statement.executeQuery(select.toString());
+        if (metaSet.first()){
         do {
             String reference = metaSet.getString("MetaID");
 …
+        }
+        statement.close();
         return division;
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSFile.java

-              r8742
+              r9874
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import org.w3c.dom.Document;
 …
     where.add(whereItem);
     select.setWhere(where);
+    connection.execute(select.toString());
+    Statement statement = null;
     // if not, then make an insert action
     try {
         ResultSet results = connection.getResultSet();
         if (results == null ||
         !results.first()){
+        statement = connection.createStatement();
+        ResultSet results = statement.executeQuery(select.toString());
+        if (!results.first()){
         GS3SQLInsert insert = new GS3SQLInsert("files");
 …
+    }
     catch (SQLException ex){
         System.err.println(ex);
+        System.err.println("METSFile.writeSQL(): "+ex);
         return false;
+    }
 …
     action.addValue("MIMEType", this.MIMEType);
+    return connection.execute(action.toString());
+    try {
+        statement.execute(action.toString());
+        statement.close();
+    } catch (SQLException e) {
+        System.err.println("METSFile.writeSQL():"+e);
+        return false;
+    }
+    return true;
+    }
 …
+    }
     catch (SQLException ex){
         System.out.println(ex);
+        System.out.println("METSFile.readSQL(): "+ex);
+    }
     catch (java.net.MalformedURLException urlEx){
         System.out.println(urlEx);
+        System.out.println("METSFile.readSQL(): "+urlEx);
+    }
     return null;
 …
     } catch (java.net.MalformedURLException ex) {
         // TODO: raise error
         System.err.println(ex);
+        System.err.println("METSFile.parse_flocateXML(): "+ex);
+    }
     return thisFilePos;

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSFileGroup.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
+    {
     int sqlId = -1;
     // check if this node is in the database already
     GS3SQLSelect select = new GS3SQLSelect("filegroups");
 …
     select.setWhere(where);
+    connection.execute(select.toString());
+    ResultSet selectResult = connection.getResultSet();
+    ResultSet results = null;
+    Statement statement = null;
     try {
+        if (selectResult == null ||
+        !selectResult.first()) {
+        statement = connection.createStatement();
+        results = statement.executeQuery(select.toString());
+        if (!results.first()) {
         GS3SQLInsert insert = new GS3SQLInsert("filegroups");
 …
         insert.addValue("ParentType", parentIsSection ? SECTION_PARENT : GROUP_PARENT);
+        if (!connection.execute(insert.toString())) {
+            return false;
+        }
+        statement.execute(insert.toString());
+        }
         else {
 …
+    }
     catch (SQLException ex){
         System.err.println(ex);
+        System.err.println("METSFileGroup.writeSQL(): "+ex);
         return false;
+    }
     // get the filegroup reference now
-    connection.execute(select.toString());
     try {
+        ResultSet results = connection.getResultSet();
+        if (results == null) {
+        results = statement.executeQuery(select.toString());
+        if (results.first()) {
+        sqlId = results.getInt("FileGroupRef");
+        } else {
+        statement.close();
         return false;
+        }
+        results.first();
+        sqlId = results.getInt("FileGroupRef");
+    }
+    catch (SQLException sqlex) {
+        System.out.println(sqlex);
+        statement.close();
+    } catch (SQLException sqlex) {
+        System.err.println("METSFileGroup.writeSQL(): "+sqlex);
         return false;
+    }
     // iterate over the child groups
     Iterator childIter = childGroups.iterator();
 …
         if (!fileGroup.writeSQL(document, Integer.toString(sqlId), false, connection)){
+        System.err.println("METSFileGroup.writeSQL(): Couldn't write FileGroup");
         return false;
+        }
 …
     childIter = children.iterator();
     while (childIter.hasNext()){
+        METSFile file = (METSFile) childIter.next();
+        METSFile file = (METSFile) childIter.next();
         if (!file.writeSQL(sqlId, connection)){
+        System.err.println("METSFileGroup.writeSQL(): Couldn't write File");
         return false;
+        }
 …
         select.setWhere(where);
         connection.execute(select.toString());
+        Statement statement = connection.createStatement();
         // parse through the child groups
         ResultSet childSet = connection.getResultSet();
+        ResultSet childSet = statement.executeQuery(select.toString());
         if (childSet.first()) {
         do {
 …
         while (childSet.next());
+        }
         // now scan for file members
         select = new GS3SQLSelect("files");
         select.addField("*");
+        whereItem = new GS3SQLWhereItem("FileGroupRef", "=", Integer.toString(groupRef),
+                        GS3SQLField.INTEGER_TYPE);
+        whereItem = new GS3SQLWhereItem("FileGroupRef", "=", Integer.toString(groupRef), GS3SQLField.INTEGER_TYPE);
         where = new GS3SQLWhere(whereItem);
         select.setWhere(where);
+        connection.execute(select.toString());
+        ResultSet childFileSet = connection.getResultSet();
+        if (childFileSet != null && childFileSet.first()) {
+        ResultSet childFileSet = statement.executeQuery(select.toString());
+        if (childFileSet.first()) {
         do {
             METSFile file = METSFile.readSQL(connection, childFileSet);
 …
         while (childFileSet.next());
+        }
+        statement.close();
         return group;
+    }
     catch (SQLException sqlEx){
         System.out.println(sqlEx);
+        System.err.println("METSFileGroup.readSQL(): "+sqlEx);
         System.exit(1);
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSFileSet.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
         insert.addValue("FileSecID", "test"); // TODO: remove magic string
+        if (!connection.execute(insert.toString())){
+        Statement statement = null;
+        try {
+        statement = connection.createStatement();
+        statement.execute(insert.toString());
+        } catch (SQLException e) {
+        System.err.println("METSFileSet.writeSQL(): "+e);
         return false;
+        }
 …
         try {
         connection.execute(select.toString());
         ResultSet set = connection.getResultSet();
         set.first();
         int sectionRef = set.getInt("FileSectionRef");
         this.reference = Integer.toString(sectionRef);
+        ResultSet set = statement.executeQuery(select.toString());
+        if (set.first()) {
+            int sectionRef = set.getInt("FileSectionRef");
+            this.reference = Integer.toString(sectionRef);
+        }
+        statement.close();
+        }
         catch (SQLException ex){
         System.out.println(ex);
+        System.out.println("METSFileSet.writeSQL(): "+ex);
         return false;
+        }
+    }
+    if (this.reference == null) {
+        return false;
+    }
     // write out the children
     while (groups.hasNext()){
 …
     GS3SQLWhereItem whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
     select.setWhere(new GS3SQLWhere(whereItem));
+    connection.execute(select.toString());
+    Statement statement = null;
     // Get the identifier for this file set, etc.
+    ResultSet sections = connection.getResultSet();
+    int fileSetRef;
+    int fileSetRef = -1;
     try {
+        sections.first();
+        fileSetRef     = sections.getInt("FileSectionRef");
+        set.reference = Integer.toString(fileSetRef);
+        statement = connection.createStatement();
+        ResultSet sections = statement.executeQuery(select.toString());
+        if (sections.first()) {
+        fileSetRef = sections.getInt("FileSectionRef");
+        set.reference = Integer.toString(fileSetRef);
+        } else {
+        statement.close();
+        return null;
+        }
+    }
     catch (SQLException ex){
         System.out.println(ex);
+        System.err.println("METSFileSet.readSQL() "+ex);
         return null;
+    }
     // Get child file groups
     select = new GS3SQLSelect("filegroups");
 …
     where.add(whereItem);
     select.setWhere(where);
-    connection.execute(select.toString());
     // start going through the matching file groups
     try {
+        ResultSet resultSet = connection.getResultSet();
+        resultSet.first();
+        do {
+        METSFileGroup filegroup = METSFileGroup.readSQL(document, connection, resultSet);
+        if (filegroup != null) {
+            set.addGroup(filegroup);
+        }
+        } while (resultSet.next());
+        ResultSet resultSet = statement.executeQuery(select.toString());
+        if (resultSet.first()) {
+        do {
+            METSFileGroup filegroup = METSFileGroup.readSQL(document, connection, resultSet);
+            if (filegroup != null) {
+            set.addGroup(filegroup);
+            }
+        } while (resultSet.next());
+        }
+        statement.close();
+    }
     catch (SQLException sqlEx) {
         System.out.println(sqlEx);
+        System.out.println("METSFileSet.readSQL(): "+sqlEx);
         System.exit(1);
+    }
     return set;
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSNamespace.java

-              r8742
+              r9874
 import java.util.Iterator;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
     // Execute the action
+    connection.execute(action.toString());
+    Statement statement = null;
+    try {
+        statement = connection.createStatement();
+        statement.execute(action.toString());
+    } catch (SQLException e) {
+        System.err.println("METSNamespace.writeSQL(): "+e);
+        return false;
+    }
     // then get the namespace reference number if needsbe...
     if (this.id == null) {
 …
         where.add(where);
         try {
         connection.execute(select.toString());
         ResultSet result = connection.getResultSet();
         result.last();
         this.id = Integer.toString(result.getInt("NamespaceRef"));
+        ResultSet result  = statement.executeQuery(select.toString());
+            if (result.last()) {
+            this.id = Integer.toString(result.getInt("NamespaceRef"));
+        }
+        statement.close();
+        }
         catch (SQLException sqlex){
         this.id = null;
         System.err.println(sqlex);
+        System.err.println("METSNamespace.writeSQL(): "+sqlex);
         return false;
+        }
 …
         select.setWhere(where);
+        connection.execute(select.toString());
+        ResultSet valuesSet = connection.getResultSet();
+        if (valuesSet != null && valuesSet.first()) {
+        Statement statement = connection.createStatement();
+        ResultSet valuesSet = statement.executeQuery(select.toString());
+        if (valuesSet.first()) {
         do {
             String label = valuesSet.getString("Label");
 …
         while (valuesSet.next());
+        }
+        statement.close();
         return namespace;
+    }
     catch (java.net.MalformedURLException urlEx){
         System.out.println(urlEx);
+        System.err.println("METSNamespace.readSQL(): "+urlEx);
+    }
     catch (SQLException sqlEx){
         System.out.println(sqlEx);
+        System.err.println("METSNamespace.readSQL(): "+sqlEx);
+    }
     return null;

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSStructure.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
+    {
     int sqlRef = -1;
+    ResultSet results;
+    ResultSet results = null;
+    Statement statement = null;
     // Prepare query to see if this structure has already been written
     GS3SQLSelect select = new GS3SQLSelect("structure");
 …
     where.add(item);
     select.setWhere(where);
     // attempt to execute the query & get the current structure's reference
     try {
+        connection.execute(select.toString());
+        results = connection.getResultSet();
+        if (results != null &&
+        results.first()){
+        statement = connection.createStatement();
+        results = statement.executeQuery(select.toString());
+        if (results.first()){
         sqlRef = results.getInt("structureRef");
+        }
-        else {
-        results = null;
+        }
-        if (results != null) {
-        results.close();
+        }
+    }
     catch (SQLException sqlEx) {
         System.err.print(sqlEx);
+        System.err.print("METSStructure.writeSQL(): "+sqlEx);
         return false;
+    }
     // insert a new structure if it wasn't there previously
     if (results == null) {
+    if (sqlRef == -1) {
         GS3SQLInsert insert = new GS3SQLInsert("structure");
         insert.addValue("DocID", document.getID().toString());
 …
         insert.addValue("Label", this.label);
+        if (!connection.execute(insert.toString())) {
+        try {
+        statement.execute(insert.toString());
+        // get the new structure reference by re-running the original select object
+        results = statement.executeQuery(select.toString());
+        if (results.first()) {
+            sqlRef = results.getInt("StructureRef");
+        }
+        } catch (SQLException sqlEx) {
+        System.err.print("METSStructure.writeSQL(): "+sqlEx);
         return false;
+        }
-        // get the new structure reference by re-running the original select object
-        connection.execute(select.toString());
-        try {
-        results = connection.getResultSet();
-        results.first();
-        sqlRef = results.getInt("StructureRef");
+        }
-        catch (SQLException sql) {
-        System.err.println(sql);
-        return false;
+        }
+    }
     else {
 …
         update.addValue("Label", this.label);
+        connection.execute(update.toString());
+    }
+        try {
+        statement.execute(update.toString());
+        } catch (SQLException sqlEx) {
+        System.err.print("METSStructure.writeSQL(): "+sqlEx);
+        return false;
+        }
+    }
+    // close the statement
+    try {
+        statement.close();
+    } catch (SQLException e) {
+        System.err.println("METSStructure.writeSQL(): "+e);
+    }
     // write out the child groups (Divisions) now...
     Iterator groups = this.children.values().iterator();
 …
         select.setWhere(where);
+        connection.execute(select.toString());
+        Statement statement = connection.createStatement();
+        ResultSet divisionSet = statement.executeQuery(select.toString());
         // parse through the divisions
+        ResultSet divisionSet = connection.getResultSet();
+        if (divisionSet != null && divisionSet.first()) {
+        if (divisionSet.first()) {
         do {
             METSDivision division = METSDivision.readSQL(connection, divisionSet);
 …
         while (divisionSet.next());
+        }
+        statement.close();
         return structure;
+    }
     catch (SQLException sqlEx)
         { System.out.println(sqlEx + " " + select.toString());
+    catch (SQLException sqlEx) {
+        System.err.println("METSStructure.readSQL(): "+ sqlEx + " " + select.toString());
         System.exit(1);
+        }
+    }
     return null;
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSStructureSet.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
     GS3SQLWhereItem whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
     select.setWhere(new GS3SQLWhere(whereItem));
+    connection.execute(select.toString());
     // start going through the matching metadata blocks
     try {
+        ResultSet resultSet = connection.getResultSet();
+        resultSet.first();
+        do {
+        METSStructure structure = METSStructure.readSQL(document, connection, resultSet);
+        if (structure != null) {
+            set.addStructure(structure);
+        }
+        } while (resultSet.next());
+        Statement statement = connection.createStatement();
+        ResultSet resultSet = statement.executeQuery(select.toString());
+        if (resultSet.first()) {
+        do {
+            METSStructure structure = METSStructure.readSQL(document, connection, resultSet);
+            if (structure != null) {
+            set.addStructure(structure);
+            }
+        } while (resultSet.next());
+        }
+        statement.close();
+    }
     catch (SQLException sqlEx) {
         System.out.println(sqlEx);
+        System.err.println("METSStructureSet.readSQL(): "+sqlEx);
         System.exit(1);
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/SimpleNamespace.java

-              r8742
+              r9874
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.ResultSet;
 …
+    }
+    Statement statement = null;
+    ResultSet results = null;
     try {
+        statement = connection.createStatement();
         if (this.id == null) {
         GS3SQLSelect select = new GS3SQLSelect("namespaces");
         select.setWhere(new GS3SQLWhere(new GS3SQLWhereItem("MetadataRef", "=", Integer.toString(parentId), GS3SQLField.INTEGER_TYPE)));
         select.addField("NamespaceRef");
+        connection.execute(select.toString());
+        ResultSet results = connection.getResultSet();
+        results.first();
+        sqlId = Integer.toString(results.getInt("NamespaceRef"));
+        results = statement.executeQuery(select.toString());
+        if (results.first()) {
+            sqlId = Integer.toString(results.getInt("NamespaceRef"));
+        } else {
+            statement.close();
+            return false;
+        }
+        }
         else {
 …
         GS3SQLWhere where = new GS3SQLWhere(new GS3SQLWhereItem("NamespaceRef", "=", sqlId, GS3SQLField.INTEGER_TYPE));
         delete.setWhere(where);
         connection.execute(delete.toString());
+        statement.execute(delete.toString());
         // write out the metadata for this namespace
 …
             insert.addValue("Label", thisKey);
             insert.addValue("Value", value);
+            connection.execute(insert.toString());
+        }
+        }
+            statement.execute(insert.toString());
+        }
+        }
+        statement.close();
+    }
     catch (SQLException sql) {
         System.out.println(sql);
+        System.out.println("SimpleNamespace.writeSQL(): "+sql);
+    }
     return true;

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/notifier/NotifierManager.java

-              r8869
+              r9874
 public class NotifierManager {
+    public NotifierManager() {
+    }
+    public NotifierManager() {
+    }
+    public void detectEvents(CollectionManager collManager) {
+    String notifyHost = collManager.getNotifyHost();
+    if (notifyHost == null)
+        return;
+    public void detectEvents(CollectionManager collManager) {
+        String notifyHost = collManager.getNotifyHost();
+        if (notifyHost == null)
+            return;
+        System.out.println("detecting events");
+        String collectionName = collManager.getCollectionName();
+        String host = "http://localhost:8080/soap/servlet/rpcrouter";
+        String lastBuild = dateToSqlString(collManager.getBuildDate());
+        System.out.println("last build was " + lastBuild);
+        Statement statement = collManager.getDatabase().createStatement();
+    System.out.println("detecting events");
+    String collectionName = collManager.getCollectionName();
+    String host = "http://localhost:8080/soap/servlet/rpcrouter";
+    String lastBuild = dateToSqlString(collManager.getBuildDate());
+    System.out.println("last build was " + lastBuild);
         try {
+        Statement statement = collManager.getDatabase().createStatement();
             // detect all new documents. A document is new if and only if
             // AccessionDate >= CollectionLastRebuiltDate
+            ResultSet results = statement.executeQuery("SELECT DocID FROM document WHERE DocType != 'GSMETADATA' AND AccessionDate >= " + lastBuild);
+            notify(collectionName, host, notifyHost, results, collManager.getDatabase(), collManager.getBuildDate(), "new_document");
+            // detect modified documents. A document is modified if and only if
+            // AccessionDate < CollectionLastRebuiltDate (ie, it is not new) and
+            // IndexedDate >= CollectionLastRebuiltDate
+            results = statement.executeQuery("SELECT DocID FROM document WHERE DocType != 'GSMETADATA' AND AccessionDate < " + lastBuild + " AND IndexedDate >= " + lastBuild);
+            notify(collectionName, host, notifyHost, results, collManager.getDatabase(), collManager.getBuildDate(), "document_modified");
+            // TODO deleted docs?
+        ResultSet results = statement.executeQuery("SELECT DocID FROM document WHERE DocType != 'GSMETADATA' AND AccessionDate >= " + lastBuild);
+        notify(collectionName, host, notifyHost, results, collManager.getDatabase(), collManager.getBuildDate(), "new_document");
+        // detect modified documents. A document is modified if and only if
+        // AccessionDate < CollectionLastRebuiltDate (ie, it is not new) and
+        // IndexedDate >= CollectionLastRebuiltDate
+        results = statement.executeQuery("SELECT DocID FROM document WHERE DocType != 'GSMETADATA' AND AccessionDate < " + lastBuild + " AND IndexedDate >= " + lastBuild);
+        notify(collectionName, host, notifyHost, results, collManager.getDatabase(), collManager.getBuildDate(), "document_modified");
+        statement.close();
+        // TODO deleted docs?
         } catch (SQLException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
+        // TODO Auto-generated catch block
+        e.printStackTrace();
+        }
+    }
+    }
     /**
      * @param collName
 …
      * @throws SQLException
      */
     private void notify(String collName, String hostURL, String notifyHost, ResultSet results, GS3SQLConnection database, Date date, String eventType) {
         try {
             System.out.println("notifyHost is " + notifyHost);
             URL url = new URL("http://" + notifyHost + "/alerting/service");
             System.out.println("trying to send to " + url);
             while(results.next()) {
                 System.out.println(eventType + ": " + results.getString("DocID"));
+    private void notify(String collName, String hostURL, String notifyHost, ResultSet results, GS3SQLConnection database, Date date, String eventType) {
+    try {
+        System.out.println("notifyHost is " + notifyHost);
+        URL url = new URL("http://" + notifyHost + "/alerting/service");
+        System.out.println("trying to send to " + url);
+        while(results.next()) {
+        System.out.println(eventType + ": " + results.getString("DocID"));
                 String documentID = results.getString("DocID");
                 try {
+        try {
                     HttpURLConnection conn = (HttpURLConnection) url.openConnection(); // TODO what about proxies?
                     conn.setUseCaches(false);
 …
                     e1.printStackTrace();
+                }
+            }
         } catch (SQLException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (MalformedURLException e) {
+        }
+    } catch (SQLException e) {
+        // TODO Auto-generated catch block
+        e.printStackTrace();
+    } catch (MalformedURLException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
+        }
+    }
+    }
     /**
 …
     private String getDocumentTitle(String documentID, GS3SQLConnection database) {
         System.out.println("getting title for document " + documentID + " from database");
-        Statement statement = database.createStatement();
-        ResultSet results;
         try {
+        Statement statement = database.createStatement();
             String sqlString = "SELECT mdvalues.value " +
                     "FROM structure s JOIN divisions d ON (s.structureref = d.parentref) " +
                     "                 JOIN divisionmetarefs USING (divisionref) " +
                     "                 JOIN metadata m USING (metaid) " +
                     "                 JOIN namespaces USING (metadataref) " +
                     "                 JOIN mdvalues USING (namespaceref) " +
                     "  WHERE mdvalues.label = 'Title' AND s.docid = '" + documentID + "'" +
                     "                                 AND s.structureType = 'Whole Document' " +
                     "                                 AND d.parenttype = 'Structure' " +
                     "                                 AND m.docID = s.docid;";
             results = statement.executeQuery(sqlString);
             if (results.next()) {
+        "FROM structure s JOIN divisions d ON (s.structureref = d.parentref) " +
+        "                 JOIN divisionmetarefs USING (divisionref) " +
+        "                 JOIN metadata m USING (metaid) " +
+        "                 JOIN namespaces USING (metadataref) " +
+        "                 JOIN mdvalues USING (namespaceref) " +
+        "  WHERE mdvalues.label = 'Title' AND s.docid = '" + documentID + "'" +
+        "                                 AND s.structureType = 'Whole Document' " +
+        "                                 AND d.parenttype = 'Structure' " +
+        "                                 AND m.docID = s.docid;";
+            ResultSet results = statement.executeQuery(sqlString);
+            if (results.first()) {
                 String title = results.getString("value");
                 System.out.println("title is " + title);
                 return title;
+            }
+        statement.close();
         } catch (SQLException e) {
             e.printStackTrace();

trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/util/HTMLTidy.java

r8710	r9874
93	93	handler.setContentHandler(this);
94	94	handler.setProperty("http://xml.org/sax/properties/lexical-handler", commentHandler);
95		handler.parse(file.toString());
	95	handler.parse(file.toURI().toString());
96	96	}
97	97	catch (java.io.IOException io)
98	98	{
	99	System.out.println(io);
99	100	}
100	101	catch (org.xml.sax.SAXException saxEx)

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/AbstractDocumentRetrieve.java

-              r9288
+              r9874
 // Greenstone classes
 //import org.greenstone.gdbm.*;
+import org.greenstone.gsdl3.core.GSException;
 import org.greenstone.gsdl3.util.GSXML;
 import org.greenstone.gsdl3.util.GSPath;
 …
     Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     if (param_list == null) {
         System.err.println("AbstractDocumentRetrieve, DocumentMetadataRetrieve Error: missing paramList.\n");
         return result;  // Return the empty result
+        GSXML.addError(this.doc, result, "DocumentMetadataRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
+        return result;
+    }
 …
+    }
+    Element node_list = this.doc.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
+    result.appendChild(node_list);
+    // check that there has been some metadata specified
+    if (!all_metadata && metadata_names_list.size()==0) {
+        GSXML.addError(this.doc, result, "DocumentMetadataRetrieve: no metadata names found in the "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
+        return result;
+    }
     // Get the documents
     Element request_node_list = (Element) GSXML.getChildByTagName(request, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
     if (request_node_list == null) {
         System.err.println("Error: DocumentMetadataRetrieve request had no "+GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
+        GSXML.addError(this.doc, result, "DocumentMetadataRetrieve: missing " +GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
         return result;
+    }
+    NodeList request_nodes = request_node_list.getChildNodes();
+    // copy the request doc node list to the response
+    Element response_node_list = (Element) this.doc.importNode(request_node_list, true);
+    result.appendChild(response_node_list);
+    // use the copied list so that we add the metadata into the copy
+    // are we just adding metadata for the top level nodes? or can we accept a hierarchy here???
+    NodeList request_nodes = GSXML.getChildrenByTagName(response_node_list, GSXML.DOC_NODE_ELEM);
+    if (request_nodes.getLength()==0) {
+        GSXML.addError(this.doc, result, "DocumentMetadataRetrieve: no "+GSXML.DOC_NODE_ELEM +" found in the "+ GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
+        return result;
+    }
+    // Whew, now we have checked (almost) all the syntax of the request, now we can process it.
     for (int i = 0; i < request_nodes.getLength(); i++) {
         Element request_node = (Element) request_nodes.item(i);
         String node_id = request_node.getAttribute(GSXML.NODE_ID_ATT);
-        // Add the document to the results list
-        Element new_node = (Element)this.doc.importNode(request_node, false);
-        node_list.appendChild(new_node);
         if (external_id) {
         // can we have .pr etc extensions with external ids?
 …
         continue;
+        }
+        Element metadata_list = getMetadataList(node_id, all_metadata, metadata_names_list);
+        new_node.appendChild(metadata_list);
+        try {
+        Element metadata_list = getMetadataList(node_id, all_metadata, metadata_names_list);
+        request_node.appendChild(metadata_list);
+        } catch (GSException e) {
+        GSXML.addError(this.doc, result, e.getMessage(), e.getType());
+        if (e.getType().equals(GSXML.ERROR_TYPE_SYSTEM)) {
+            // there is no point trying any others
+            return result;
+        }
+        }
+    }
 …
     String lang = request.getAttribute(GSXML.LANG_ATT);
-    Element query_doc_list = (Element) GSXML.getChildByTagName(request, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
-    if (query_doc_list == null) {
-        System.err.println("AbstractDocumentRetrieve Error: DocumentStructureRetrieve request specified no doc nodes.\n");
-        return result;
+    }
     // Get the parameters of the request
     Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     if (param_list == null) {
+        System.err.println("AbstractDocumentRetrieve Error: DocumentStructureRetrieve request had no paramList.");
+        return result;  // Return the empty result
+    }
+        GSXML.addError(this.doc, result, "DocumentStructureRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
+        return result;
+    }
+    // get the documents of the request
+    Element query_doc_list = (Element) GSXML.getChildByTagName(request, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
+    if (query_doc_list == null) {
+        GSXML.addError(this.doc, result, "DocumentStructureRetrieve: missing " +GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
+        return result;
+    }
+    // copy the doc_list to the response
+    Element response_node_list = (Element) this.doc.importNode(query_doc_list, true);
+    result.appendChild(response_node_list);
+    // check that we have some doc nodes specified
+    NodeList node_list = GSXML.getChildrenByTagName(response_node_list, GSXML.DOC_NODE_ELEM);
+    if (node_list.getLength()==0) {
+        GSXML.addError(this.doc, result, "DocumentStructureRetrieve: no "+GSXML.DOC_NODE_ELEM +" found in the "+ GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
+        return result;
+    }
     Element extid_param = GSXML.getNamedElement(param_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, EXTID_PARAM);
     boolean external_id = false;
 …
     if (want_descendants)
         want_children = false;
+    // the document list to hold the results
+    Element doc_list = this.doc.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
+    result.appendChild(doc_list);
+    // Get the documents
+    String[] doc_ids = GSXML.getAttributeValuesFromList(query_doc_list,
+                                GSXML.NODE_ID_ATT);
+    for (int i = 0; i < doc_ids.length; i++) {
+        // Add the document to the list
+        Element doc = this.doc.createElement(GSXML.DOC_NODE_ELEM);
+        doc_list.appendChild(doc);
+        String doc_id = doc_ids[i];
+        doc.setAttribute(GSXML.NODE_ID_ATT, doc_id);
+    for (int i=0; i < node_list.getLength(); i++) {
+        Element doc = (Element) node_list.item(i);
+        String doc_id = doc.getAttribute(GSXML.NODE_ID_ATT);
         if (external_id) {
         doc_id = translateExternalId(doc_id);
 …
+    }
     // Get the parameters of the request - no parameters at this stage
+    // Get the parameters of the request
     Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     Element extid_param = GSXML.getNamedElement(param_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, EXTID_PARAM);
 …
         continue;
+        }
+        Element node_content = getNodeContent(doc_id);
+        doc.appendChild(node_content);
+        try {
+        Element node_content = getNodeContent(doc_id);
+        doc.appendChild(node_content);
+        } catch (GSException e) {
+        GSXML.addError(this.doc, result, e.getMessage());
+        return result;
+        }
+    }
     return result;
 …
+    }
+    /** if id ends in .fc, .pc etc, then translate it to the correct id */
+    abstract protected String translateId(String id);
+    /** if id ends in .fc, .pc etc, then translate it to the correct id
+     * default implementation: just remove the suffix */
+    protected String translateId(String id) {
+    return id.substring(0,id.length());
+    }
     /** if an id is not a greenstone id (an external id) then translate
+    it to a greenstone one*/
+    abstract protected String translateExternalId(String id);
+     * it to a greenstone one
+     * default implementation: return the id */
+    protected String translateExternalId(String id) {
+    return id;
+    }
     /** returns the document type of the doc that the specified node
     belongs to. should be one of
 …
     GSXML.DOC_TYPE_PAGED,
     GSXML.DOC_TYPE_HIERARCHY
+    default implementation: return DOC_TYPE_SIMPLE
     */
+    abstract protected String getDocType(String node_id);
+    /** returns the id of the root node of the document containing node node_id. . may be the same as node_id */
+    abstract protected String getRootId(String node_id);
+    /** returns a list of the child ids in order, null if no children */
+    abstract protected ArrayList getChildrenIds(String node_id);
+    /** returns the node id of the parent node, null if no parent */
+    abstract protected String getParentId(String node_id);
+    protected String getDocType(String node_id) {
+    return GSXML.DOC_TYPE_SIMPLE;
+    }
+    /** returns the id of the root node of the document containing
+     * node node_id. may be the same as node_id
+     * default implemntation: return node_id
+    */
+    protected String getRootId(String node_id) {
+    return node_id;
+    }
+    /** returns a list of the child ids in order, null if no children
+     * default implementation: return null */
+    protected ArrayList getChildrenIds(String node_id) {
+    return null;
+    }
+    /** returns the node id of the parent node, null if no parent
+     * default implementation: return null */
+    protected String getParentId(String node_id) {
+    return null;
+    }
     /** get the metadata for the doc node doc_id
 …
     abstract protected Element getMetadataList(String doc_id,
                            boolean all_metadata,
                            ArrayList metadata_names);
+                           ArrayList metadata_names) throws GSException;
     /** returns the content of a node
      * shoudl return a nodeContent element:
+     * should return a nodeContent element:
      * <nodeContent>text content or other elements</nodeContent>
+     * can return
      */
     abstract protected Element getNodeContent(String doc_id);
+    abstract protected Element getNodeContent(String doc_id) throws GSException;
     /** returns the structural information asked for.

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/AbstractGS2DocumentRetrieve.java

-              r9000
+              r9874
 // Greenstone classes
 import org.greenstone.gdbm.*;
+import org.greenstone.gsdl3.core.GSException;
 import org.greenstone.gsdl3.util.GSXML;
 import org.greenstone.gsdl3.util.GSFile;
 …
 import org.greenstone.gsdl3.util.GS2MacroResolver;
 import org.greenstone.gsdl3.util.GSConstants;
+import org.greenstone.gsdl3.util.GDBMWrapper;
+import org.greenstone.gsdl3.util.DBInfo;
 // XML classes
 import org.w3c.dom.Document;
 …
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.gdbm_src.closeDatabase();
+    }
     /** configure this service */
     public boolean configure(Element info, Element extra_info)
 …
     // assumes only one value per metadata
     protected Element getMetadataList(String node_id, boolean all_metadata,
+                      ArrayList metadata_names) {
+                      ArrayList metadata_names)
+    throws GSException {
     Element metadata_list = this.doc.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
     DBInfo info = this.gdbm_src.getInfo(node_id);
 …
      * <nodeContent>text content or other elements</nodeContent>
      */
     abstract protected Element getNodeContent(String doc_id);
+    abstract protected Element getNodeContent(String doc_id) throws GSException;
     protected String getMetadata(String node_id, DBInfo info,

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/AbstractGS3DocumentRetrieve.java

-              r9000
+              r9874
 // Greenstone classes
+import org.greenstone.gsdl3.core.GSException;
 import org.greenstone.gsdl3.util.GSXML;
 import org.greenstone.gsdl3.util.GSFile;
 …
     // set up a macro resolver
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.database.closeConnection();
+    }
     /** configure this service */
 …
+    }
-    /** if an id is not a greenstone id (an external id) then translate
-    it to a greenstone one*/
-    protected String translateExternalId(String node_id){
-    // dont have this yet
-    return node_id;
+    }
     /** returns the id of the root node of the document containing node node_id. . may be the same as node_id */
     protected String getRootId(String node_id) {
 …
     // assumes only one value per metadata
     protected Element getMetadataList(String node_id, boolean all_metadata,
+                      ArrayList metadata_names) {
+                      ArrayList metadata_names)
+    throws GSException {
     Element metadata_list = this.doc.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
 …
      * <nodeContent>text content or other elements</nodeContent>
      */
     abstract protected Element getNodeContent(String doc_id);
+    abstract protected Element getNodeContent(String doc_id) throws GSException;
+}

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/AbstractMGPPSearch.java

-              r9280
+              r9874
+    {
     this.mgpp_src = new MGPPWrapper();
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.mgpp_src.unloadIndexData();
+    }
 …
     } else if (name.equals(RANK_PARAM)) {
         String [] vals1 = {RANK_PARAM_RANK, RANK_PARAM_NONE };
         String [] vals1_texts = { getTextString("param."+RANK_PARAM+"."+RANK_PARAM_RANK, lang), getTextString("param."+RANK_PARAM+"."+RANK_PARAM_NONE, lang, "MGPPSearch")};
+        String [] vals1_texts = { getTextString("param."+RANK_PARAM+"."+RANK_PARAM_RANK, lang), getTextString("param."+RANK_PARAM+"."+RANK_PARAM_NONE, lang)};
         param = GSXML.createParameterDescription(this.doc, RANK_PARAM, getTextString("param."+RANK_PARAM, lang), GSXML.PARAM_TYPE_ENUM_SINGLE, RANK_PARAM_RANK, vals1, vals1_texts );

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/AbstractMGSearch.java

-              r9280
+              r9874
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.mg_src.unloadIndexData();
+    }
     public boolean configure(Element info, Element extra_info)
+    {
 …
     this.mg_src.runQuery(basedir, textdir, query);
     MGQueryResult mqr = this.mg_src.getQueryResult();
+    if (mqr.isClear()) {
+        // something has gone wrong
+        GSXML.addError(this.doc, result, "Couldn't query the mg database", GSXML.ERROR_TYPE_SYSTEM);
+        return result;
+    }
     long totalDocs = mqr.getTotalDocs();

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GATEServices.java.tmp

-              r6501
+              r9874
         annotated_text = "<nodeContent>" + annotated_text + "</nodeContent>";
+        Element annotated_content = this.converter.getDOM(annotated_text).getDocumentElement();
+        doc_node.replaceChild(doc_node.getOwnerDocument().importNode(annotated_content, true), content);
+    }
+        Document annotated_content_doc = this.converter.getDOM(annotated_text);
+        if (annotated_content_doc != null) {
+        Element annotated_content = annotated_content_doc.getDocumentElement();
+        doc_node.replaceChild(doc_node.getOwnerDocument().importNode(annotated_content, true), content);
+        } else {
+        System.err.println("GATEServices.processGatePOSTag Error: Couldn't parse annotated text for doc node "+i);
+        }
+    }
     result.appendChild(this.doc.importNode(doc_node_list, true));

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2Browse.java

-              r8959
+              r9874
 // Greenstone classes
-import org.greenstone.gdbm.*;
 import org.greenstone.gsdl3.util.OID;
 import org.greenstone.gsdl3.util.GSXML;
 …
 import org.greenstone.gsdl3.util.MacroResolver;
 import org.greenstone.gsdl3.util.GS2MacroResolver;
+import org.greenstone.gsdl3.util.GDBMWrapper;
+import org.greenstone.gsdl3.util.DBInfo;
 // XML classes
 import org.w3c.dom.Document;
 …
     this.gdbm_src = new GDBMWrapper();
     this.macro_resolver = new GS2MacroResolver(this.gdbm_src);
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.gdbm_src.closeDatabase();
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2MGPPRetrieve.java

-              r8959
+              r9874
 // Greenstone classes
 import org.greenstone.mgpp.*;
+import org.greenstone.gsdl3.core.GSException;
 import org.greenstone.gsdl3.util.GSFile;
 import org.greenstone.gsdl3.util.GSXML;
 …
     public GS2MGPPRetrieve() {
     this.mgpp_src = new MGPPWrapper();
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.mgpp_src.unloadIndexData();
+    }
 …
      * <nodeContent>text content or other elements</nodeContent>
      */
     protected Element getNodeContent(String doc_id) {
+    protected Element getNodeContent(String doc_id) throws GSException {
     String lang = "en"; //  **********
     long doc_num = this.gdbm_src.OID2Docnum(doc_id);

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2MGPPSearch.java

-              r9002
+              r9874
 // Greenstone classes
 import org.greenstone.gsdl3.util.*;
-import org.greenstone.gdbm.*;
 // XML classes
 …
+    {
     this.gdbm_src = new GDBMWrapper();
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.gdbm_src.closeDatabase();
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2MGRetrieve.java

-              r8959
+              r9874
 // Greenstone classes
 import org.greenstone.mg.*;
+import org.greenstone.gsdl3.core.GSException;
 import org.greenstone.gsdl3.util.GSFile;
 import org.greenstone.gsdl3.util.GSXML;
 …
     public GS2MGRetrieve() {
     this.mg_src = new MGWrapper();
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.mg_src.unloadIndexData();
+    }
 …
      * <nodeContent>text content or other elements</nodeContent>
      */
     protected Element getNodeContent(String doc_id) {
+    protected Element getNodeContent(String doc_id) throws GSException {
     String lang = "en"; //  **********
     long doc_num = this.gdbm_src.OID2Docnum(doc_id);

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2MGSearch.java

-              r9002
+              r9874
 // Greenstone classes
 import org.greenstone.gsdl3.util.*;
-import org.greenstone.gdbm.*;
 // XML classes
 …
+    {
     this.gdbm_src = new GDBMWrapper();
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.gdbm_src.closeDatabase();
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS3Browse.java

r8959	r9874
52	52	}
53	53
	54	public void cleanUp() {
	55	super.cleanUp();
	56	this.database.closeConnection();
	57	}
	58
54	59	public boolean configure(Element info, Element extra_info)
55	60	{

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS3MGPPRetrieve.java

-              r8959
+              r9874
 // Greenstone classes
 import org.greenstone.mgpp.*;
+import org.greenstone.gsdl3.core.GSException;
 import org.greenstone.gsdl3.util.GSFile;
 import org.greenstone.gsdl3.util.GSXML;
 …
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.mgpp_src.unloadIndexData();
+    }
     /** configure this service */
     public boolean configure(Element info, Element extra_info)
+    {
+    // Do generic configuration
+    if (!super.configure(info, extra_info)) {
+        return false;
+    }
     // Do specific configuration
     System.out.println("Configuring GS3MGPPRetrieve...");
 …
     // The location of the MGPP text files
     mgpp_textdir = GSFile.collectionBaseDir(this.site_home, this.cluster_name) +
         File.separatorChar + GSFile.collectionTextPath(this.cluster_name);
+        File.separatorChar + GSFile.collectionTextPath(this.index_stem);
+    // Do generic configuration
+    return super.configure(info, extra_info);
+    return true;
+    }
 …
      * <nodeContent>text content or other elements</nodeContent>
      */
     protected Element getNodeContent(String doc_id) {
+    protected Element getNodeContent(String doc_id) throws GSException {
     if (GS3OID.isDocTop(doc_id) && database.isHierarchicalDocument(doc_id)) {
         // if we have a whole doc id, and the document is hierarchical,

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS3MGPPSearch.java

r9002	r9874
50	50	{
51	51	this.database = new SQLQuery();
	52	}
	53
	54	public void cleanUp() {
	55	super.cleanUp();
	56	this.database.closeConnection();
52	57	}
53	58

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS3MGRetrieve.java

-              r9001
+              r9874
 // Greenstone classes
 import org.greenstone.mg.*;
+import org.greenstone.gsdl3.core.GSException;
 import org.greenstone.gsdl3.util.GSFile;
 import org.greenstone.gsdl3.util.GSXML;
 …
     private String mg_textdir = null;
     private String default_index = null;
     public GS3MGRetrieve() {
     this.mg_src = new MGWrapper();
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.mg_src.unloadIndexData();
+    }
 …
      * <nodeContent>text content or other elements</nodeContent>
      */
     protected Element getNodeContent(String doc_id) {
+    protected Element getNodeContent(String doc_id) throws GSException {
     if (GS3OID.isDocTop(doc_id) && database.isHierarchicalDocument(doc_id)) {
 …
     } catch (Exception e) {
         System.out.println("exception happended with mg_src.getDocument()");
+        doc_content = "this is the content for section hash id "+ doc_id+", mg doc num "+doc_int+"\n";
+        throw new GSException("Couldn't get document content for id: "+ doc_int+"\n"+e.getMessage());
+        //doc_content = "this is the content for section hash id "+ doc_id+", mg doc num "+doc_int+"\n";
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS3MGSearch.java

r9002	r9874
50	50	{
51	51	this.database = new SQLQuery();
	52	}
	53
	54	public void cleanUp() {
	55	super.cleanUp();
	56	this.database.closeConnection();
52	57	}
53	58

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/IViaProxy.java

-              r8158
+              r9874
 // Greenstone classes
-import org.greenstone.gdbm.*;
 import org.greenstone.gsdl3.util.*;
 …
     doc_node.setAttribute(GSXML.NODE_ID_ATT, doc_id);
+    Element content_element = this.converter.getDOM(processed_content.toString()).getDocumentElement();
+    doc_node.appendChild(this.doc.importNode(content_element, true));
+    Document content_doc = this.converter.getDOM(processed_content.toString());
+    if (content_doc != null) {
+        Element content_element = content_doc.getDocumentElement();
+        doc_node.appendChild(this.doc.importNode(content_element, true));
+    } else {
+        System.err.println("IViaProxy.getDocument Error: Couldn't parse the node content");
+    }
     return doc_node;

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/IViaRetrieve.java

-              r9289
+              r9874
 // Greenstone classes
 import org.greenstone.gdbm.*;
+import org.greenstone.gsdl3.core.GSException;
 import org.greenstone.gsdl3.util.*;
 …
     /** gets a document by sending a request to iVia, then processes it and creates a documentNode around the text */
+    protected Element getNodeContent(String doc_id) {
+    protected Element getNodeContent(String doc_id)
+    throws GSException {
     String url_string = ivia_server_url+"/cgi-bin/view_record?theme=gsdl3&record_id="+doc_id;
 …
     StringBuffer buffer = new StringBuffer();
     try {
         BufferedReader reader = makeConnection(url_string);
+        BufferedReader reader = Misc.makeHttpConnection(url_string);
             String line;
         while((line = reader.readLine())!= null) {
         buffer.append(line);
+        }
+    } catch (Exception e) {
+        System.err.println("IViaRetrieve Error:exception happened");
+        e.printStackTrace();
+    }
+    } catch (java.net.MalformedURLException e) {
+        throw new GSException("Malformed URL: "+url_string, GSXML.ERROR_TYPE_SYSTEM);
+    } catch (java.io.IOException e) {
+        throw new GSException("IOException during connection to "+url_string+": "+e.toString(),GSXML.ERROR_TYPE_SYSTEM);
+    }
     String node_content = buffer.toString();
 …
     processed_content.append("</nodeContent>");
+    Element content_element = this.converter.getDOM(processed_content.toString()).getDocumentElement();
+    Document content_doc = this.converter.getDOM(processed_content.toString());
+    if (content_doc == null) {
+        System.err.println("IViaRetrieve.getNodeContent Error: Couldn't parse node content");
+        System.err.println(processed_content.toString());
+        return null;
+    }
+    Element content_element = content_doc.getDocumentElement();
     return (Element)this.doc.importNode(content_element,true);
 …
+    }
-    protected BufferedReader makeConnection(String url_string) {
-    BufferedReader reader = null;
-    try {
-        URL url = new URL(url_string);
-        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
-        InputStream input = connection.getInputStream();
-        reader = new BufferedReader(new InputStreamReader(input));
-    } catch (java.net.MalformedURLException e) {
-        System.err.println("IViaRetrieve: Malformed URL: "+url_string);
-    } catch (java.io.IOException e) {
-        System.err.println("IViaRetrieve Error: An error occurred during IO to url "+url_string);
+    }
-    return reader;
+    }
     protected String translateId(String oid){
     int p = oid.lastIndexOf('.');
 …
     protected Element getMetadataList (String doc_id,
                        boolean all_metadata,
+                       ArrayList metadata_names){
+                       ArrayList metadata_names)
+    throws GSException {
     Element meta_list = this.doc.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
 …
     String url_string = ivia_server_url+"/cgi-bin/view_record_set?theme=gsdl3&record_id_list="+doc_id+"&field_list="+field_list.toString();
     try {
         BufferedReader reader = makeConnection(url_string);
+        BufferedReader reader = Misc.makeHttpConnection(url_string);
         String line;
         while  ((line = reader.readLine()) != null) {
 …
         GSXML.addMetadata(this.doc, meta_list, name, value);
+        }
+    } catch (Exception e) {
+        System.err.println("IViaRetrieve Error:exception happened");
+        e.printStackTrace();
+    } catch (java.net.MalformedURLException e) {
+        throw new GSException("Malformed URL: "+url_string, GSXML.ERROR_TYPE_SYSTEM);
+    } catch (java.io.IOException e) {
+        throw new GSException("IOException: "+e.toString(), GSXML.ERROR_TYPE_SYSTEM);
+    }
     return meta_list;

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/IViaSearch.java

-              r9273
+              r9874
 // Greenstone classes
-import org.greenstone.gdbm.*;
 import org.greenstone.gsdl3.util.*;
 …
 import java.util.HashMap;
 import java.io.File;
-import java.io.InputStream;
 import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.io.IOException;
-import java.net.HttpURLConnection;
-import java.net.URLConnection;
-import java.net.URL;
 import java.net.Authenticator;
-import java.net.MalformedURLException;
 /**
+ *
  * @author <a href="mailto:[email protected]">Katherine Don</a>
+ * @version $Revision$
+ * Modified by <a href="mailto:[email protected]">Chi-Yu Huang</a>
+ * @author <a href="mailto:[email protected]">Chi-Yu Huang</a>
  */
 …
     String results_num = null;
     String doc_ids = null;
+    BufferedReader reader = null;
     try {
         ///system.err.println("IViaSearch, sending "+url_string);
         BufferedReader reader = makeConnection(url_string);
+        reader = Misc.makeHttpConnection(url_string);
         results_num = reader.readLine();
         doc_ids = reader.readLine();
+    } catch (Exception e) {
+        System.err.println("IViaSearch.TextQuery Error: exception happened during query");
+        e.printStackTrace();
+    } catch (java.net.MalformedURLException e) {
+        GSXML.addError(this.doc, result, "Malformed URL: "+url_string);
+        return result;
+    } catch (java.io.IOException e) {
+        GSXML.addError(this.doc, result, "IOException during connection to "+url_string+": "+e.toString());
         return result;
+    }
 …
     } else {
         System.err.println("IViaSearch.TextQuery Error: badly formatted results line: "+results_num);
+        GSXML.addError(this.doc, result, "Error: badly formatted result from IVia server: "+results_num);
         return result;
+    }
 …
     } else {
         System.err.println("IViaSearch.TextQuery Error: badly formatted docs line: "+doc_ids);
+        GSXML.addError(this.doc, result, "Error: badly formatted result from IVia server: "+doc_ids);
         return result;
+    }
 …
+    }
-    protected BufferedReader makeConnection(String url_string) {
-    BufferedReader reader = null;
-    try {
-        URL url = new URL(url_string);
-        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
-        InputStream input = connection.getInputStream();
-        reader = new BufferedReader(new InputStreamReader(input));
-    } catch (java.net.MalformedURLException e) {
-        System.err.println("IViaSearch Error: Malformed URL: "+url_string);
-    } catch (java.io.IOException e) {
-        System.err.println("IViaSearch Error: An error occurred during IO to url "+url_string);
+    }
-    return reader;
+    }
     /**

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/LuceneSearch.java

r9272	r9874
2	2
3	3	// Greenstone classes
4		~~import org.greenstone.gdbm.*;~~
5	4	import org.greenstone.gsdl3.util.*;
6	5

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/MapRetrieve.java

r6694	r9874
2	2
3	3	// Greenstone classes
4		~~import org.greenstone.gdbm.*;~~
5	4	import org.greenstone.gsdl3.util.*;
6	5

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/MapSearch.java

r9286	r9874
20	20
21	21	// Greenstone classes
22		~~import org.greenstone.gdbm.*;~~
23	22	import org.greenstone.gsdl3.util.*;
24	23

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/ModuleWrapper.java

-              r3621
+              r9874
+  }
+  public void cleanUp() {}
   /** The all-args constructor */
   public ModuleWrapper(String in,String out, ModuleInterface inner){

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/PhindPhraseBrowse.java

-              r6490
+              r9874
     this.mgpp_src.setCase(true);
+    }
+    public void cleanUp() {
+    super.cleanUp();
+    this.mgpp_src.unloadIndexData();
+    }
     /** configure the service module
+     *
 …
     Document dom = this.converter.getDOM(app_info);
+    if (dom==null) {
+        System.err.println("PhindPhraseBrowse.configure Error: Couldn't parse applet info");
+        return false;
+    }
     Element app_elem = dom.getDocumentElement();
     applet_description.appendChild(this.doc.importNode(app_elem, true));
     return true;
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/ServiceRack.java

-              r9426
+              r9874
     setClusterName(coll_name);
+    }
+    public void cleanUp() {}
     /** sets the site home */
 …
     Document doc = this.converter.getDOM(xml_in);
+    if (doc == null) {
+        System.err.println("ServiceRack.process(String) Error: Couldn't parse request");
+        System.err.println(xml_in);
+        return null;
+    }
     Element res = process(doc.getDocumentElement());
     return this.converter.getString(res);

trunk/gsdl3/src/java/org/greenstone/gsdl3/service/Visualizer.java

-              r8347
+              r9874
     Document dom = converter.getDOM(app_info);
+    if (dom == null) {
+        System.err.println("Visualizer.configure Error: Couldn't parse applet info");
+        return false;
+    }
     Element app_elem = dom.getDocumentElement();
     applet_description.appendChild(this.doc.importNode(app_elem, true));

trunk/gsdl3/src/java/org/greenstone/gsdl3/util/Dictionary.java

r9424	r9874
47	47	this.raw = ResourceBundle.getBundle(this.resource, this.locale);
48	48	} catch (Exception e) {
49		System.err.println("Dictionary: couldn't locate a resource bundle for "+resource);
	49	//System.err.println("Dictionary: couldn't locate a resource bundle for "+resource);
50	50	}
51	51	}
…	…
70	70	this.raw = ResourceBundle.getBundle(this.resource, this.locale);
71	71	} catch (Exception ex) {
72		System.err.println("Dictionary: couldn't locate a resource bundle for "+resource);
	72	//System.err.println("Dictionary: couldn't locate a resource bundle for "+resource);
73	73	}
74	74
…	…
129	129	}
130	130	catch (Exception e) {
131		System.err.println("Dictionary Error: couldn't find string for key:" + key +" in resource "+this.resource);
	131	//System.err.println("Dictionary Error: couldn't find string for key:" + key +" in resource "+this.resource);
132	132	return null;
133	133	}

trunk/gsdl3/src/java/org/greenstone/gsdl3/util/GS2MacroResolver.java

r8962	r9874
20	20
21	21	import java.util.ArrayList;
22		~~import org.greenstone.gdbm.GDBMWrapper;~~
23		~~import org.greenstone.gdbm.DBInfo;~~
24	22
25	23	public class GS2MacroResolver

trunk/gsdl3/src/java/org/greenstone/gsdl3/util/GSFile.java

-              r9425
+              r9874
 import java.io.File;
+import org.apache.soap.encoding.soapenc.Base64;
+//import org.apache.soap.encoding.soapenc.Base64;
+import org.apache.axis.encoding.Base64;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 …
     /** text path (for doc retrieval) relative to collectionBaseDir */
     static public String collectionTextPath(String collection_name) {
+    static public String collectionTextPath(String index_stem) {
     return "index"+File.separatorChar+"text"+File.separatorChar+
         collection_name;
+        index_stem;
+    }
     /** index path (for querying) relative to collectionBaseDir */
     static public String collectionIndexPath(String collection_name,
+    static public String collectionIndexPath(String index_stem,
                          String index_name) {
     return "index"+File.separatorChar+index_name+File.separatorChar+
         collection_name;
+        index_stem;
+    }

trunk/gsdl3/src/java/org/greenstone/gsdl3/util/GSXML.java

-              r9261
+              r9874
     public static final String PARAM_IGNORE_POS_ATT = "ignore";
     public static final String CLASSIFIER_CONTENT_ATT = "content";
+    public static final String ERROR_TYPE_ATT = "type";
     // document stuff
     public static final String DOC_TYPE_ATT = "docType";
 …
     public static final String COMM_TYPE_SOAP_JAVA = "soap";
+    // error types
+    public static final String ERROR_TYPE_SYNTAX = "syntax";
+    public static final String ERROR_TYPE_SYSTEM = "system";
+    public static final String ERROR_TYPE_INVALID_ID = "invalid_id";
+    public static final String ERROR_TYPE_OTHER = "other";
     // some system wide param names
     public static final String SUBSET_PARAM = "subset";
 …
+    }
+    /** add an error message, unknown error type */
+    public static boolean addError(Document owner, Element doc, String text) {
+    return addError(owner, doc, text, ERROR_TYPE_OTHER);
+    }
     /** add an error message */
+    public static boolean addError(Document owner, Element doc, String text) {
+    public static boolean addError(Document owner, Element doc, String text,
+                   String error_type) {
     Element content = owner.createElement(ERROR_ELEM);
+    content.setAttribute(ERROR_TYPE_ATT, error_type);
     Text t = owner.createTextNode(text);
     content.appendChild(t);
 …
     /** add an error message */
     public static boolean addError(Document owner, Element doc, Throwable error) {
+      error.printStackTrace();
+      return addError(owner, doc, error.toString());
+      return addError(owner, doc, error, ERROR_TYPE_OTHER);
+    }
+    /** add an error message */
+    public static boolean addError(Document owner, Element doc,
+                   Throwable error, String error_type) {
+    error.printStackTrace();
+    return addError(owner, doc, error.toString(), error_type);
+    }
 …
+    }
+    public static NodeList getChildrenByTagName(Node n, String name) {
+    MyNodeList node_list = new MyNodeList();
+    Node child = n.getFirstChild();
+    while (child!=null) {
+        if (child.getNodeName().equals(name)) {
+        node_list.addNode(child);
+        }
+        child = child.getNextSibling();
+    }
+    return node_list;
+    }
     /** Duplicates an element, but gives it a new name */
 …
                            String element_name, boolean with_attributes)
+    {
+    Element duplicate = owner.createElement(element_name);
+    return duplicateWithNewNameNS(owner, element, element_name, null, with_attributes);
+    }
+    /** Duplicates an element, but gives it a new name */
+    public static Element duplicateWithNewNameNS(Document owner,
+                         Element element,
+                         String element_name,
+                         String namespace_uri,
+                         boolean with_attributes)
+    {
+    Element duplicate;
+    if (namespace_uri == null) {
+        duplicate = owner.createElement(element_name);
+    } else {
+        duplicate = owner.createElementNS(namespace_uri, element_name);
+    }
     // Copy element attributes
     if (with_attributes) {

trunk/gsdl3/src/java/org/greenstone/gsdl3/util/Misc.java

-              r7444
+              r9874
+/*
+ *    Misc.java
+ *    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
+ *
+ *    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.gsdl3.util;
 import java.util.HashMap;
 …
 import java.util.Iterator;
 import java.util.Properties;
+import java.io.InputStream;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
 /** contains miscellaneous functions */
 …
+    }
+    public static BufferedReader makeHttpConnection(String url_string)
+    throws java.net.MalformedURLException, java.io.IOException {
+    BufferedReader reader = null;
+    URL url = new URL(url_string);
+    HttpURLConnection connection = (HttpURLConnection)url.openConnection();
+    InputStream input = connection.getInputStream();
+    reader = new BufferedReader(new InputStreamReader(input));
+    return reader;
+    }
+}

trunk/gsdl3/src/java/org/greenstone/gsdl3/util/SQLQuery.java

-              r8746
+              r9874
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.util.ArrayList;
 …
     public boolean setDatabase(String db_name) {
     try {
         connection = GS3SQLConnectionFactory.getGS3SQLConnection(db_name);
+    connection = GS3SQLConnectionFactory.getGS3SQLConnection(db_name);
+    try {
         // test the connection
         String query = "select * from "+GSSQL.DOCUMENT_TABLE+GSSQL.END;
+        if (!connection.execute(query)) {
+        //connection.close();
+        connection = null;
+        return false;
+        }
+        Statement s = connection.createStatement();
+        s.execute(query);
+        s.close();
         return true;
     } catch (Exception e) {
+        System.err.println("SQLQuery.setDatabase Exception");
+        return false;
+        System.err.println("SQLQuery.setDatabase():"+e);
+    }
+    closeConnection();
+    return false;
+    }
+    public void closeConnection() {
+    if (connection != null) {
+        connection.close();
+        connection=null;
+    }
+    }
 …
         GSSQL.END;
     connection.execute(query);
+    Statement statement = null;
     ResultSet results = null;
     String doc_id = null;
     String meta_id = null;
     try {
+        results = connection.getResultSet();
+        results.first();
+        doc_id = results.getString(GSSQL.DOCUMENT_ID);
+        meta_id = results.getString(GSSQL.METADATA_ID);
+    } catch (java.sql.SQLException e) {
+        System.err.println("SQLQuery.MGNum2OID() Error: "+e.getMessage());
+        return null;
+    }
+    System.out.println("doc id ="+doc_id+", meta id = "+meta_id);
+        statement = connection.createStatement();
+        results = statement.executeQuery(query);
+        if (results.first()) {
+        doc_id = results.getString(GSSQL.DOCUMENT_ID);
+        meta_id = results.getString(GSSQL.METADATA_ID);
+        } else {
+        statement.close();
+        return null;
+        }
+    } catch (java.sql.SQLException e) {
+        System.err.println("SQLQuery.MGNum2OID(): "+e);
+        return null;
+    }
     // now get division label
 …
         GSSQL.END;
     connection.execute(query);
     String short_label = null;
     try {
+        results = connection.getResultSet();
+        results.first();
+        short_label = results.getString(GSSQL.SHORT_LABEL);
+    } catch (java.sql.SQLException e) {
+        results = statement.executeQuery(query);
+        if (results.first()) {
+        short_label = results.getString(GSSQL.SHORT_LABEL);
+        } else {
+        statement.close();
+        return null;
+        }
+        statement.close();
+    } catch (SQLException e) {
         System.err.println("SQLQuery.MGNum2OID() Error: "+e.getMessage());
         return null;
+    }
+    ///ystem.out.println("short label = "+short_label);
+    System.out.println("final doc_id = "+GS3OID.createOID(doc_id, short_label));
     return GS3OID.createOID(doc_id, short_label);
+    }
     public String OID2MGNum(String oid) {
-    System.out.println("converting oid "+oid+" to mg num");
     String id = getDocumentMetadata(oid, "gsdl3.mgseqno");
-    System.out.println("mg id = "+id);
     return id;
 …
         " and "+ GSSQL.STRUCTURE_ID +GSSQL.EQUALS_QUOTE + "Section" + GSSQL.QUOTE +
         GSSQL.END;
+    connection.execute(query);
+    ResultSet results = null;
+    try {
+        results = connection.getResultSet();
+        if (results.next()) {
+        return true;
+        }
+    boolean is_hierarchical = false;
+    try {
+        Statement statement = connection.createStatement();
+        ResultSet results = statement.executeQuery(query);
+        is_hierarchical = results.first();
+        statement.close();
     } catch (java.sql.SQLException e) {
         return false;
+    }
     return false;
+    return is_hierarchical;
+    }
 …
     public String getClassifierMetadata(String oid, String full_meta_name) {
+    if (full_meta_name.equals("Title") || full_meta_name.equals("numleafdocs")) {
+        // get the description
+        String field_name="";
+        if (full_meta_name.equals("Title")) {
+        field_name = GSSQL.DESCRIPTION;
+        } else {
+        field_name = GSSQL.NUM_LEAF_DOCUMENTS;
+        }
+        String query = "select "+ field_name+
+        " from " + GSSQL.CLASSIFIER_TABLE +
+        " where " + GSSQL.CLASSIFIER_ID + GSSQL.EQUALS_QUOTE + oid + GSSQL.QUOTE +
+        GSSQL.END;
+    if (!full_meta_name.equals("Title") && !full_meta_name.equals("numleafdocs")) {
+        return null;
+    }
+    // get the description
+    String field_name="";
+    if (full_meta_name.equals("Title")) {
+        field_name = GSSQL.DESCRIPTION;
+    } else {
+        field_name = GSSQL.NUM_LEAF_DOCUMENTS;
+    }
+    String query = "select "+ field_name+
+        " from " + GSSQL.CLASSIFIER_TABLE +
+        " where " + GSSQL.CLASSIFIER_ID + GSSQL.EQUALS_QUOTE + oid + GSSQL.QUOTE +
+        GSSQL.END;
+    String value = null;
+    try {
+        Statement statement = connection.createStatement();
+        ResultSet results = statement.executeQuery(query);
+        if (results.first()) {
+        value = results.getString(field_name);
+        }
+        statement.close();
+    } catch (java.sql.SQLException e) {
+        connection.execute(query);
+        ResultSet results = null;
+        String value = null;
+        try {
+        results = connection.getResultSet();
+        results.first();
+        value = results.getString(field_name);
+        } catch (java.sql.SQLException e) {
+        System.err.println("SQLQuery.getClassifierMetadata() Error: "+e.getMessage());
+        return null;
+        }
+        return value;
+    }  else return null;
+        System.err.println("SQLQuery.getClassifierMetadata() Error: "+e.getMessage());
+        return null;
+    }
+    return value;
+    }
 …
         section_id = GS3OID.getSectionLabel(oid);
+    }
-    System.out.println("getDocChildren: oid = "+oid+", doc id = "+doc_id+", sec id ="+section_id);
 //      int sep_index = oid.indexOf(".");
 //      if (sep_index != -1) {
 …
         GSSQL.END;
-    connection.execute(query);
     ResultSet results = null;
+    Statement statement = null;
     String div_ref = null;
     try {
+        results = connection.getResultSet();
+        results.first();
+        div_ref = results.getString(GSSQL.DIVISION_REF);
+        statement = connection.createStatement();
+        results = statement.executeQuery(query);
+        if (results.first()) {
+        div_ref = results.getString(GSSQL.DIVISION_REF);
+        } else {
+        statement.close();
+        return null;
+        }
     } catch (java.sql.SQLException e) {
 …
         " and "+GSSQL.PARENT_REF+GSSQL.EQUALS_QUOTE+div_ref+GSSQL.QUOTE+
         GSSQL.END;
+    connection.execute(query);
+    results = null;
+    try {
+        results = connection.getResultSet();
+    try {
+        results = statement.executeQuery(query);
         while (results.next()) {
         String id = results.getString(GSSQL.SHORT_LABEL);
         children.add(GS3OID.createOID(doc_id, id));
+        }
+        statement.close();
     } catch (java.sql.SQLException e) {
 …
         GSSQL.END;
+    connection.execute(query);
+    ResultSet results = null;
+    try {
+        results = connection.getResultSet();
+    try {
+        Statement statement = connection.createStatement();
+        ResultSet results = statement.executeQuery(query);
         while (results.next()) {
         String id = results.getString(GSSQL.CLASSIFIER_ID);
         children.add(id);
+        }
+    } catch (java.sql.SQLException e) {
+        statement.close();
+    } catch (java.sql.SQLException e) {
         System.err.println("SQLQuery.getClassifierChildren Error: "+e.getMessage());
         return null;
 …
     public ArrayList getClassifierDocChildren(String oid) {
-    System.out.println("in getclassifierdocchildren");
     ArrayList children = new ArrayList();
 …
         " order by "+GSSQL.CLASS_DOCUMENT_TABLE+GSSQL.DOT+GSSQL.DOCUMENT_ORDER+
         GSSQL.END;
+    System.out.println("query="+query);
+    connection.execute(query);
+    ResultSet results = null;
+    try {
+        results = connection.getResultSet();
+    try {
+        Statement statement = connection.createStatement();
+        ResultSet results = statement.executeQuery(query);
         while (results.next()) {
         String id = results.getString(GSSQL.DOCUMENT_ID);
 …
         return null;
+    }
-    // now check for documents
     return children;
 …
 //      }
-    System.out.println("get meta for "+oid+", doc id = "+doc_id+"sec id = "+section_id);
     // get the metadata block id
 …
         GSSQL.END;
     connection.execute(query);
+    Statement statement = null;
     ResultSet results = null;
     String meta_id = null;
     try {
+        results = connection.getResultSet();
+        results.first();
+        meta_id = results.getString(GSSQL.METADATA_ID);
+        statement = connection.createStatement();
+        results = statement.executeQuery(query);
+        if (results.first()) {
+        meta_id = results.getString(GSSQL.METADATA_ID);
+        } else {
+        statement.close();
+        return null;
+        }
     } catch (java.sql.SQLException e) {
 …
         return null;
+    }
+    System.err.println("metadata block id = "+meta_id);
     // now get the list of namespace refs for the right namespace
     int sep_index = full_meta_name.indexOf('.');
 …
         meta_name = full_meta_name.substring(sep_index+1);
+    }
-    System.out.println("orig meta = "+full_meta_name+", ns = "+meta_ns+", name="+meta_name);
     query = "select * "+
 …
         " and "+GSSQL.NAMESPACE_TABLE+GSSQL.DOT+GSSQL.NAMESPACE_REF+GSSQL.EQUALS+GSSQL.METADATA_VALUE_TABLE+GSSQL.DOT+GSSQL.NAMESPACE_REF+
         GSSQL.END;
+    System.out.println("query="+query);
+    connection.execute(query);
     String meta_value = null;
     try {
+        results = connection.getResultSet();
+        statement = connection.createStatement();
+        results = statement.executeQuery(query);
         while (results.next()) {
         String m_name = results.getString(GSSQL.LABEL);
 …
+        }
+        }
+        statement.close();
     } catch (java.sql.SQLException e) {

trunk/gsdl3/src/java/org/greenstone/gsdl3/util/XMLConverter.java

-              r8923
+              r9874
     String nodeName = xmlNode.getNodeName();
+    if (nodeType == Node.DOCUMENT_NODE) {
+        return getString(((Document)xmlNode).getDocumentElement(), depth, pretty);
+    }
     // Handle Element nodes
     if (nodeType == Node.ELEMENT_NODE) {

trunk/gsdl3/src/packages/mg/java/org/greenstone/mg/MGQueryResult.java

-              r3794
+              r9874
+    }
+    public boolean isClear() {
+    return (total_num_docs_ == 0 && docs_.isEmpty() && terms_.isEmpty());
+    }
     /** returns the result as a String - useful for printing out results */

trunk/gsdl3/src/packages/mg/jni/MGWrapperImpl.c

-              r8920
+              r9874
   /* Check that the index was loaded successfully */
+  assert(qd != NULL);
+  if (qd==NULL) {
+    return NULL;
+  }
+  /*assert(qd != NULL);*/
   /* Get the document position and length in the text file */
 …
   jthrowable exc;
+  /* Make sure an index has been specified */
+  index_path = data->queryInfo->index;
+  assert(index_path != NULL);
+  /* Obtain C versions of the two string parameters */
+  base_dir = (*j_env)->GetStringUTFChars(j_env, j_base_dir, NULL);
+  if (base_dir == NULL) {
+    return;
+  }
+  text_path = (*j_env)->GetStringUTFChars(j_env, j_text_path, NULL);
+  if (text_path == NULL) {
+    (*j_env)->ReleaseStringUTFChars(j_env, j_base_dir, base_dir);
+    return;
+  }
+  /* Load the appropriate index for satisfying this request */
+  qd = loadIndexData((char*) base_dir, (char*) index_path, (char*) text_path);
+  /* The C text strings are no longer needed */
+  (*j_env)->ReleaseStringUTFChars(j_env, j_base_dir, base_dir);
+  (*j_env)->ReleaseStringUTFChars(j_env, j_text_path, text_path);
+  /* Check that the index was loaded successfully */
+  assert(qd != NULL);
+  /* Remove anything hanging around from last time */
+  FreeQueryDocs(qd);
+  /* First of all, clear the previous result */
   /* The result to write to */
   result_ptr = (*j_env)->GetObjectField(j_env, j_obj, FID_query_result);
 …
     return;
+  }
+  /* Make sure an index has been specified */
+  index_path = data->queryInfo->index;
+  assert(index_path != NULL);
+  /* Obtain C versions of the two string parameters */
+  base_dir = (*j_env)->GetStringUTFChars(j_env, j_base_dir, NULL);
+  if (base_dir == NULL) {
+    return;
+  }
+  text_path = (*j_env)->GetStringUTFChars(j_env, j_text_path, NULL);
+  if (text_path == NULL) {
+    (*j_env)->ReleaseStringUTFChars(j_env, j_base_dir, base_dir);
+    return;
+  }
+  /* Load the appropriate index for satisfying this request */
+  qd = loadIndexData((char*) base_dir, (char*) index_path, (char*) text_path);
+  /* The C text strings are no longer needed */
+  (*j_env)->ReleaseStringUTFChars(j_env, j_base_dir, base_dir);
+  (*j_env)->ReleaseStringUTFChars(j_env, j_text_path, text_path);
+  /* Check that the index was loaded successfully */
+  if (qd == NULL) {
+    return;
+  }
+  /*assert(qd != NULL);*/
+  /* Remove anything hanging around from last time */
+  FreeQueryDocs(qd);
   /* Obtain a C version of the query string */

trunk/gsdl3/src/packages/mg/src/images/WIN32.MAK

-              r3921
+              r9874
 mostlyclean:
+    rm -f *$o _*.c _*.o *._c *._o core core.*
+    if exist *$o del *$o
+    if exist  _*.c del  _*.c
+    if exist _*.o  del  _*.o
+    if exist *._c  del *._c
+    if exist *._o  del *._o
+    if exist core  del  core
+    if exist core.* del  core.*
 clean: mostlyclean
     rm -f $(EXEC)
+    if exist *$e del *$e
 distclean: clean
+    rm -f ansi2knr
+    rm -f Makefile
+    del ansi2knr
 maintainer-clean: distclean
     @echo "This command is intended only for maintainers to use;"

trunk/gsdl3/src/packages/mg/src/text/win32.mak

r7585	r9874
237	237	clean:
238	238	if exist $o del $o
239		if exist ~~$(EXEC) del $(EXEC)~~
	239	if exist $e del $e
240	240	if exist libmgtextin.lib del libmgtextin.lib
241	241	if exist libmgpass.lib del libmgpass.lib

trunk/gsdl3/src/packages/mg/winMake.bat

-              r6416
+              r9874
     cd ..\..
+    cd java\org\greenstone\mg
+    call winMake.bat %1
+    cd ..\..\..\..
     cd jni
     %MAKE% %MAKE_OPTIONS% win32.mak %1
 …
 :done

Context Navigation

Legend:

Download in other formats: