Changeset 24221


Ignore:
Timestamp:
2011-07-04T10:49:50+12:00 (10 years ago)
Author:
sjm84
Message:

Added more functionality to ArchiveRetrieve, added an additonal parameter to printXMLNode in GSXML that controls whether text nodes are to be printed or not and also made the infodb type of collections more easily accessible

Location:
main/trunk/greenstone3/src/java/org/greenstone/gsdl3
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/LibraryServlet.java

    r24118 r24221  
    588588        }
    589589       
    590         //GSXML.printXMLNode(xml_message);
    591590        Node xml_result = this.recept.process(xml_message);
    592591        encodeURLs (xml_result, response);
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/collection/Collection.java

    r24203 r24221  
    11/*
    2  *    Collection.java
    3  *    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
    4  *
    5  *    This program is free software; you can redistribute it and/or modify
    6  *    it under the terms of the GNU General Public License as published by
    7  *    the Free Software Foundation; either version 2 of the License, or
    8  *    (at your option) any later version.
    9  *
    10  *    This program is distributed in the hope that it will be useful,
    11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
    12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13  *    GNU General Public License for more details.
    14  *
    15  *    You should have received a copy of the GNU General Public License
    16  *    along with this program; if not, write to the Free Software
    17  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    18  */
     2*    Collection.java
     3*    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
     4*
     5*    This program is free software; you can redistribute it and/or modify
     6*    it under the terms of the GNU General Public License as published by
     7*    the Free Software Foundation; either version 2 of the License, or
     8*    (at your option) any later version.
     9*
     10*    This program is distributed in the hope that it will be useful,
     11*    but WITHOUT ANY WARRANTY; without even the implied warranty of
     12*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13*    GNU General Public License for more details.
     14*
     15*    You should have received a copy of the GNU General Public License
     16*    along with this program; if not, write to the Free Software
     17*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     18*/
    1919package org.greenstone.gsdl3.collection;
    2020
     
    4949
    5050/**
    51  * Represents a collection in Greenstone. A collection is an extension of
    52  * a ServiceCluster - it has local data that the services use.
    53  *
    54  * @author <a href="mailto:kjdon@cs.waikato.ac.nz">Katherine Don</a>
    55  * @see ModuleInterface
    56  */
     51* Represents a collection in Greenstone. A collection is an extension of
     52* a ServiceCluster - it has local data that the services use.
     53*
     54* @author <a href="mailto:kjdon@cs.waikato.ac.nz">Katherine Don</a>
     55* @see ModuleInterface
     56*/
    5757public class Collection
    58     extends ServiceCluster {
    59 
    60     static Logger logger = Logger.getLogger(org.greenstone.gsdl3.collection.Collection.class.getName());
    61 
    62     /** is this collection being tidied */
    63     protected boolean useBook = false;
    64     /** is this collection public or private */
    65     protected boolean is_public = true;
    66 
    67     /** does this collection provide the OAI service */
    68     protected boolean has_oai = true;
    69     /** time when this collection was built */
    70     protected long lastmodified = 0;
    71     /** earliestDatestamp of this collection. Necessary for OAI */
    72     protected long earliestDatestamp = 0;
    73 
    74 
    75     /** An element containing the serviceRackList element of buildConfig.xml, used to determine whether it contains
    76      *  the OAIPMH serviceRack
    77      */
    78     //protected Element service_rack_list = null;
    79    
    80     protected XMLTransformer transformer = null;
    81     /** same as setClusterName */
    82     public void setCollectionName(String name) {
    83     setClusterName(name);
    84     }
    85 
    86     public Collection() {
    87     super();
    88     this.description = this.doc.createElement(GSXML.COLLECTION_ELEM);
     58extends ServiceCluster {
     59
     60    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.collection.Collection.class.getName());
     61
     62    /** is this collection being tidied */
     63    protected boolean useBook = false;
     64    /** is this collection public or private */
     65    protected boolean is_public = true;
     66
     67    /** does this collection provide the OAI service */
     68    protected boolean has_oai = true;
     69    /** time when this collection was built */
     70    protected long lastmodified = 0;
     71    /** earliestDatestamp of this collection. Necessary for OAI */
     72    protected long earliestDatestamp = 0;
     73
     74
     75    /** An element containing the serviceRackList element of buildConfig.xml, used to determine whether it contains
     76    *  the OAIPMH serviceRack
     77    */
     78    //protected Element service_rack_list = null;
    8979   
    90     }
     80    protected XMLTransformer transformer = null;
     81    /** same as setClusterName */
     82    public void setCollectionName(String name) {
     83        setClusterName(name);
     84    }
     85
     86    public Collection() {
     87        super();
     88        this.description = this.doc.createElement(GSXML.COLLECTION_ELEM);
     89       
     90    }
    9191   
    92     /**
    93      * Configures the collection.
    94      *
    95      * gsdlHome and collectionName must be set before configure is called.
    96      *
    97      * the file buildcfg.xml is located in gsdlHome/collect/collectionName
    98      * collection metadata is obtained, and services loaded.
    99      *
    100      * @return true/false on success/fail
    101      */
    102     public boolean configure() {
     92    /**
     93    * Configures the collection.
     94    *
     95    * gsdlHome and collectionName must be set before configure is called.
     96    *
     97    * the file buildcfg.xml is located in gsdlHome/collect/collectionName
     98    * collection metadata is obtained, and services loaded.
     99    *
     100    * @return true/false on success/fail
     101    */
     102    public boolean configure() {
     103       
     104        if (this.site_home == null || this.cluster_name== null) {
     105            logger.error("Collection: site_home and collection_name must be set before configure called!");
     106            return false;
     107        }
     108       
     109        Element coll_config_xml = loadCollConfigFile();
     110        Element build_config_xml = loadBuildConfigFile();
     111       
     112        if (coll_config_xml==null||build_config_xml==null) {
     113            return false;
     114        }
     115       
     116        // get the collection type attribute
     117        Element search = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.SEARCH_ELEM);
     118        if(search != null) {
     119            col_type = search.getAttribute(GSXML.TYPE_ATT);
     120        }
     121       
     122        Element browse = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.INFODB_ELEM);
     123        if(browse != null) {
     124            db_type = browse.getAttribute(GSXML.TYPE_ATT);
     125        }
     126        else
     127        {
     128            db_type = "gdbm"; //The default
     129        }
     130        System.err.println("DB_TYPE = "  + db_type);
     131       
     132        // process the metadata and display items
     133        findAndLoadInfo(coll_config_xml, build_config_xml);
     134       
     135        // now do the services
     136        configureServiceRacks(coll_config_xml, build_config_xml);
     137
     138        return true;
     139       
     140    }
     141
     142    public boolean useBook() {
     143        return useBook;
     144    }
    103145   
    104     if (this.site_home == null || this.cluster_name== null) {
    105         logger.error("Collection: site_home and collection_name must be set before configure called!");
    106         return false;
     146    public boolean isPublic() {
     147        return is_public;
     148    }
     149    // Not used anymore by the OAIReceptionist to find out the earliest datestamp
     150    // amongst all oai collections in the repository. May be useful generally.
     151    public long getLastmodified() {
     152        return lastmodified;
     153    }
     154    //used by the OAIReceptionist to find out the earliest datestamp amongst all oai collections in the repository
     155    public long getEarliestDatestamp() {
     156        return earliestDatestamp;
     157    }
     158
     159    /** whether the service_map in ServiceCluster.java contains the service 'OAIPMH'
     160    *  11/06/2007 xiao
     161    */
     162    public boolean hasOAI() {
     163        return has_oai;
     164    }
     165    /**
     166    * load in the collection config file into a DOM Element
     167    */   
     168    protected Element loadCollConfigFile() {
     169
     170        File coll_config_file = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name));
     171       
     172        if (!coll_config_file.exists()) {
     173            logger.error("Collection: couldn't configure collection: "+this.cluster_name+", "+coll_config_file+" does not exist");
     174            return null;
     175        }
     176        // get the xml for both files
     177        Document coll_config_doc = this.converter.getDOM(coll_config_file, CONFIG_ENCODING);
     178        Element coll_config_elem = null;
     179        if (coll_config_doc != null) {
     180            coll_config_elem = coll_config_doc.getDocumentElement();
     181        }
     182        return coll_config_elem;
     183
    107184    }
    108185   
    109     Element coll_config_xml = loadCollConfigFile();
    110     Element build_config_xml = loadBuildConfigFile();
    111    
    112     if (coll_config_xml==null||build_config_xml==null) {
    113         return false;
    114     }
    115    
    116     // get the collection type attribute
    117     Element search = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.SEARCH_ELEM);
    118     if(search!=null) {
    119       col_type = search.getAttribute(GSXML.TYPE_ATT);
    120     }
    121    
    122     // process the metadata and display items
    123     findAndLoadInfo(coll_config_xml, build_config_xml);
    124    
    125     // now do the services
    126     configureServiceRacks(coll_config_xml, build_config_xml);
    127 
    128     return true;
    129    
    130     }
    131 
    132     public boolean useBook() {
    133         return useBook;
    134     }
    135    
    136     public boolean isPublic() {
    137     return is_public;
    138     }
    139     // Not used anymore by the OAIReceptionist to find out the earliest datestamp
    140     // amongst all oai collections in the repository. May be useful generally.
    141     public long getLastmodified() {
    142       return lastmodified;
    143     }
    144     //used by the OAIReceptionist to find out the earliest datestamp amongst all oai collections in the repository
    145     public long getEarliestDatestamp() {
    146     return earliestDatestamp;
    147     }
    148 
    149     /** whether the service_map in ServiceCluster.java contains the service 'OAIPMH'
    150      *  11/06/2007 xiao
    151      */
    152     public boolean hasOAI() {
    153       return has_oai;
    154     }
    155     /**
    156      * load in the collection config file into a DOM Element
    157      */   
    158     protected Element loadCollConfigFile() {
    159 
    160     File coll_config_file = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name));
    161    
    162     if (!coll_config_file.exists()) {
    163         logger.error("Collection: couldn't configure collection: "+this.cluster_name+", "+coll_config_file+" does not exist");
    164         return null;
    165     }
    166     // get the xml for both files
    167     Document coll_config_doc = this.converter.getDOM(coll_config_file, CONFIG_ENCODING);
    168     Element coll_config_elem = null;
    169     if (coll_config_doc != null) {
    170         coll_config_elem = coll_config_doc.getDocumentElement();
    171     }
    172     return coll_config_elem;
    173 
    174     }
    175    
    176     /**
    177      * load in the collection build config file into a DOM Element
    178      */       
    179     protected Element loadBuildConfigFile() {
    180    
    181     File build_config_file = new File(GSFile.collectionBuildConfigFile(this.site_home, this.cluster_name));
    182     if (!build_config_file.exists()) {
    183         logger.error("Collection: couldn't configure collection: "+this.cluster_name+", "+build_config_file+" does not exist");
    184         return null;
    185     }
    186     Document build_config_doc = this.converter.getDOM(build_config_file, CONFIG_ENCODING);
    187     Element build_config_elem = null;
    188     if (build_config_doc != null) {
    189         build_config_elem = build_config_doc.getDocumentElement();
    190     }
    191 
    192     lastmodified = build_config_file.lastModified();
    193  
    194     return build_config_elem;
    195     }
    196 
    197     /**
    198      * find the metadata and display elems from the two config files and add it to the appropriate lists
    199      */
    200     protected boolean findAndLoadInfo(Element coll_config_xml,
    201                       Element build_config_xml){
    202              
    203       // metadata
    204       Element meta_list = (Element)GSXML.getChildByTagName(coll_config_xml, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
    205       addMetadata(meta_list);
    206       meta_list = (Element)GSXML.getChildByTagName(build_config_xml, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
    207       addMetadata(meta_list);
    208      
    209       meta_list = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
    210       GSXML.addMetadata(this.doc, meta_list, "httpPath", this.site_http_address+"/collect/"+this.cluster_name);
    211       addMetadata(meta_list);
    212      
    213       // display stuff
    214       Element display_list = (Element)GSXML.getChildByTagName(coll_config_xml, GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER);
    215       if (display_list != null) {
    216         resolveMacros(display_list);
    217         addDisplayItems(display_list);
    218       }
    219      
    220       //check whether the html are tidy or not
    221       Element import_list = (Element)GSXML.getChildByTagName(coll_config_xml, GSXML.IMPORT_ELEM);
    222       if (import_list != null) {
    223         Element plugin_list = (Element)GSXML.getChildByTagName(import_list, GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
    224         addPlugins(plugin_list);
    225         if (plugin_list != null){
    226           Element plugin_elem = (Element)GSXML.getNamedElement(plugin_list, GSXML.PLUGIN_ELEM, GSXML.NAME_ATT, "HTMLPlugin");
    227           if (plugin_elem != null) {
    228             //get the option
    229             Element option_elem = (Element)GSXML.getNamedElement(plugin_elem, GSXML.PARAM_OPTION_ELEM, GSXML.NAME_ATT, "-use_realistic_book");
    230             if (option_elem != null) {
    231               useBook = true;
    232             }
    233           }
    234         }
    235       }
    236       meta_list = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
    237       if (useBook == true)
    238         GSXML.addMetadata(this.doc, meta_list, "tidyoption", "tidy");
    239       else
    240         GSXML.addMetadata(this.doc, meta_list, "tidyoption", "untidy");
    241       addMetadata(meta_list);
    242      
    243       // check whether we are public or not
    244       if (meta_list != null) {
    245         Element meta_elem = (Element) GSXML.getNamedElement(metadata_list, GSXML.METADATA_ELEM, GSXML.NAME_ATT, "public");
    246         if (meta_elem != null) {
    247           String value = GSXML.getValue(meta_elem).toLowerCase().trim();
    248           if (value.equals("false")) {
    249             is_public = false;
    250           }
    251         }
    252       }
    253       return true;
    254 
    255     }
    256 
    257   protected boolean configureServiceRacks(Element coll_config_xml,
    258                       Element build_config_xml){
    259     clearServices();
    260     Element service_list = (Element)GSXML.getChildByTagName(build_config_xml, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
    261     configureServiceRackList(service_list, coll_config_xml);
    262        
    263     // collection Config may also contain manually added service racks
    264     service_list = (Element)GSXML.getChildByTagName(coll_config_xml, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
    265     if (service_list != null) {
    266       configureServiceRackList(service_list, build_config_xml);
    267      
    268       // Check for oai
    269       Element oai_service_rack = GSXML.getNamedElement(service_list, GSXML.SERVICE_CLASS_ELEM, OAIXML.NAME, OAIXML.OAIPMH);
    270       if (oai_service_rack == null) {
    271     has_oai = false;
    272     logger.info("No oai for collection: " + this.cluster_name);
    273    
    274       } else {
    275     has_oai = true;
    276    
    277     // extract earliestDatestamp from the buildconfig.xml for OAI
    278     Element metadata_list = (Element)GSXML.getChildByTagName(build_config_xml, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
    279 
    280     if(metadata_list != null) {
    281         NodeList children = metadata_list.getElementsByTagName(GSXML.METADATA_ELEM);
    282                // can't do getChildNodes(), because whitespace, such as newlines, creates Text nodes
    283         for (int i = 0; i < children.getLength(); i++) {
    284         Element metadata = (Element)children.item(i);
    285         if(metadata.getAttribute(GSXML.NAME_ATT).equals(OAIXML.EARLIEST_DATESTAMP)) {
    286             String earliestDatestampStr = GSXML.getValue(metadata);
    287             if(!earliestDatestampStr.equals("")) {
    288             earliestDatestamp = Long.parseLong(earliestDatestampStr);
    289             }
    290             break; // found a metadata element with name=earliestDatestamp in buildconfig
    291         }
    292         }
    293     }
    294    
    295     // If at the end of this, there is no value for earliestDatestamp, print out a warning
    296     logger.warn("No earliestDatestamp in buildConfig.xml for collection: " + this.cluster_name + ". Defaulting to 0.");
    297 
    298       }
    299     } else { // no list of services (no ServiceRackList), so no oai_service_rack either
    300     // explicitly set has_oai to false here, since it's initialised to true by default
    301     has_oai = false;
    302     }
    303     return true;
    304   }
    305  
    306   protected boolean resolveMacros(Element display_list) {
    307     if (display_list==null) return false;
    308     NodeList displaynodes = display_list.getElementsByTagName(GSXML.DISPLAY_TEXT_ELEM);
    309     if (displaynodes.getLength()>0) {
    310         String http_site = this.site_http_address;
    311         String http_collection = this.site_http_address +"/collect/"+this.cluster_name;
    312         for(int k=0; k<displaynodes.getLength(); k++) {
    313         Element d = (Element) displaynodes.item(k);
    314         String text = GSXML.getNodeText(d);
    315         text = StringUtils.replace(text, "_httpsite_", http_site);
    316         text = StringUtils.replace(text, "_httpcollection_", http_collection);
    317         GSXML.setNodeText(d, text);
    318         }
    319     }
    320     return true;
    321     }
    322     /**
    323      * do a configure on only part of the collection
    324      */
    325     protected boolean configureSubset(String subset) {
    326 
    327     // need the coll config files
    328     Element coll_config_elem = loadCollConfigFile();
    329     Element build_config_elem = loadBuildConfigFile();
    330     if (coll_config_elem == null||build_config_elem == null) {
    331         // wont be able to do any of the requests
    332         return false;
    333     }   
    334    
    335     if (subset.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
    336       return configureServiceRacks(coll_config_elem, build_config_elem);
     186    /**
     187    * load in the collection build config file into a DOM Element
     188    */       
     189    protected Element loadBuildConfigFile() {
     190       
     191        File build_config_file = new File(GSFile.collectionBuildConfigFile(this.site_home, this.cluster_name));
     192        if (!build_config_file.exists()) {
     193            logger.error("Collection: couldn't configure collection: "+this.cluster_name+", "+build_config_file+" does not exist");
     194            return null;
     195        }
     196        Document build_config_doc = this.converter.getDOM(build_config_file, CONFIG_ENCODING);
     197        Element build_config_elem = null;
     198        if (build_config_doc != null) {
     199            build_config_elem = build_config_doc.getDocumentElement();
     200        }
     201
     202        lastmodified = build_config_file.lastModified();
     203
     204        return build_config_elem;
     205    }
     206
     207    /**
     208    * find the metadata and display elems from the two config files and add it to the appropriate lists
     209    */
     210    protected boolean findAndLoadInfo(Element coll_config_xml,
     211    Element build_config_xml){
     212       
     213        // metadata
     214        Element meta_list = (Element)GSXML.getChildByTagName(coll_config_xml, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
     215        addMetadata(meta_list);
     216        meta_list = (Element)GSXML.getChildByTagName(build_config_xml, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
     217        addMetadata(meta_list);
     218       
     219        meta_list = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
     220        GSXML.addMetadata(this.doc, meta_list, "httpPath", this.site_http_address+"/collect/"+this.cluster_name);
     221        addMetadata(meta_list);
     222       
     223        // display stuff
     224        Element display_list = (Element)GSXML.getChildByTagName(coll_config_xml, GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER);
     225        if (display_list != null) {
     226            resolveMacros(display_list);
     227            addDisplayItems(display_list);
     228        }
     229       
     230        //check whether the html are tidy or not
     231        Element import_list = (Element)GSXML.getChildByTagName(coll_config_xml, GSXML.IMPORT_ELEM);
     232        if (import_list != null) {
     233            Element plugin_list = (Element)GSXML.getChildByTagName(import_list, GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
     234            addPlugins(plugin_list);
     235            if (plugin_list != null){
     236                Element plugin_elem = (Element)GSXML.getNamedElement(plugin_list, GSXML.PLUGIN_ELEM, GSXML.NAME_ATT, "HTMLPlugin");
     237                if (plugin_elem != null) {
     238                    //get the option
     239                    Element option_elem = (Element)GSXML.getNamedElement(plugin_elem, GSXML.PARAM_OPTION_ELEM, GSXML.NAME_ATT, "-use_realistic_book");
     240                    if (option_elem != null) {
     241                        useBook = true;
     242                    }
     243                }
     244            }
     245        }
     246        meta_list = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
     247        if (useBook == true)
     248        GSXML.addMetadata(this.doc, meta_list, "tidyoption", "tidy");
     249        else
     250        GSXML.addMetadata(this.doc, meta_list, "tidyoption", "untidy");
     251        addMetadata(meta_list);
     252       
     253        // check whether we are public or not
     254        if (meta_list != null) {
     255            Element meta_elem = (Element) GSXML.getNamedElement(metadata_list, GSXML.METADATA_ELEM, GSXML.NAME_ATT, "public");
     256            if (meta_elem != null) {
     257                String value = GSXML.getValue(meta_elem).toLowerCase().trim();
     258                if (value.equals("false")) {
     259                    is_public = false;
     260                }
     261            }
     262        }
     263        return true;
     264
     265    }
     266
     267    protected boolean configureServiceRacks(Element coll_config_xml,
     268    Element build_config_xml){
     269        clearServices();
     270        Element service_list = (Element)GSXML.getChildByTagName(build_config_xml, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
     271        configureServiceRackList(service_list, coll_config_xml);
     272       
     273        // collection Config may also contain manually added service racks
     274        service_list = (Element)GSXML.getChildByTagName(coll_config_xml, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
     275        if (service_list != null) {
     276            configureServiceRackList(service_list, build_config_xml);
     277           
     278            // Check for oai
     279            Element oai_service_rack = GSXML.getNamedElement(service_list, GSXML.SERVICE_CLASS_ELEM, OAIXML.NAME, OAIXML.OAIPMH);
     280            if (oai_service_rack == null) {
     281                has_oai = false;
     282                logger.info("No oai for collection: " + this.cluster_name);
     283               
     284            } else {
     285                has_oai = true;
     286               
     287                // extract earliestDatestamp from the buildconfig.xml for OAI
     288                Element metadata_list = (Element)GSXML.getChildByTagName(build_config_xml, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
     289
     290                if(metadata_list != null) {
     291                    NodeList children = metadata_list.getElementsByTagName(GSXML.METADATA_ELEM);
     292                    // can't do getChildNodes(), because whitespace, such as newlines, creates Text nodes
     293                    for (int i = 0; i < children.getLength(); i++) {
     294                        Element metadata = (Element)children.item(i);
     295                        if(metadata.getAttribute(GSXML.NAME_ATT).equals(OAIXML.EARLIEST_DATESTAMP)) {
     296                            String earliestDatestampStr = GSXML.getValue(metadata);
     297                            if(!earliestDatestampStr.equals("")) {
     298                                earliestDatestamp = Long.parseLong(earliestDatestampStr);
     299                            }
     300                            break; // found a metadata element with name=earliestDatestamp in buildconfig
     301                        }
     302                    }
     303                }
     304               
     305                // If at the end of this, there is no value for earliestDatestamp, print out a warning
     306                logger.warn("No earliestDatestamp in buildConfig.xml for collection: " + this.cluster_name + ". Defaulting to 0.");
     307
     308            }
     309        } else { // no list of services (no ServiceRackList), so no oai_service_rack either
     310            // explicitly set has_oai to false here, since it's initialised to true by default
     311            has_oai = false;
     312        }
     313        return true;
     314    }
     315
     316    protected boolean resolveMacros(Element display_list) {
     317        if (display_list==null) return false;
     318        NodeList displaynodes = display_list.getElementsByTagName(GSXML.DISPLAY_TEXT_ELEM);
     319        if (displaynodes.getLength()>0) {
     320            String http_site = this.site_http_address;
     321            String http_collection = this.site_http_address +"/collect/"+this.cluster_name;
     322            for(int k=0; k<displaynodes.getLength(); k++) {
     323                Element d = (Element) displaynodes.item(k);
     324                String text = GSXML.getNodeText(d);
     325                text = StringUtils.replace(text, "_httpsite_", http_site);
     326                text = StringUtils.replace(text, "_httpcollection_", http_collection);
     327                GSXML.setNodeText(d, text);
     328            }
     329        }
     330        return true;
     331    }
     332    /**
     333    * do a configure on only part of the collection
     334    */
     335    protected boolean configureSubset(String subset) {
     336
     337        // need the coll config files
     338        Element coll_config_elem = loadCollConfigFile();
     339        Element build_config_elem = loadBuildConfigFile();
     340        if (coll_config_elem == null||build_config_elem == null) {
     341            // wont be able to do any of the requests
     342            return false;
     343        }   
     344       
     345        if (subset.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
     346            return configureServiceRacks(coll_config_elem, build_config_elem);
     347        }
     348
     349        if (subset.equals(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER) || subset.equals(GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER) || subset.equals(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER)) {
     350            return findAndLoadInfo(coll_config_elem, build_config_elem);
     351           
     352        }
     353       
     354        logger.error("Collection: cant process system request, configure "+subset);
     355        return false;
    337356    }
    338357
    339     if (subset.equals(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER) || subset.equals(GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER) || subset.equals(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER)) {
    340         return findAndLoadInfo(coll_config_elem, build_config_elem);
    341        
    342     }
    343    
    344     logger.error("Collection: cant process system request, configure "+subset);
    345     return false;
    346     }
    347 
    348  /** handles requests made to the ServiceCluster itself
    349      *
    350      * @param req - the request Element- <request>
    351      * @return the result Element - should be <response>
    352      */
    353     protected Element processMessage(Element request) {
    354 
    355     Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
    356     response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
    357     String type = request.getAttribute(GSXML.TYPE_ATT);
    358     String lang = request.getAttribute(GSXML.LANG_ATT);
    359     response.setAttribute(GSXML.TYPE_ATT, type);
    360 
    361     logger.error("Collection received a message, attempting to process");
    362 
    363     if (type.equals(GSXML.REQUEST_TYPE_FORMAT_STRING)) {
    364         logger.error("Received format string request");
    365 
    366         String subaction = request.getAttribute("subaction");
    367         logger.error("Subaction is " + subaction);
    368 
    369         String service = request.getAttribute("service");
    370         logger.error("Service is " + service);
    371 
    372         String classifier = null;
    373         if(service.equals("ClassifierBrowse"))
    374         {
    375             classifier = request.getAttribute("classifier");
    376             logger.error("Classifier is " + classifier);
    377         }
    378 
    379         Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM);
    380         //String format_string = GSXML.getNodeText(format_element);
    381         Element format_statement = (Element) format_element.getFirstChild();
    382 
    383         //logger.error("Format string: " + format_string);
    384         logger.error("Config file location = " + GSFile.collectionConfigFile(this.site_home, this.cluster_name));
    385 
    386         // check for version file
    387 
    388         String directory = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name)).getParent() + File.separator;
    389         logger.error("Directory is " + directory);
    390 
    391         String version_filename = "";
    392         if(service.equals("ClassifierBrowse"))
    393             version_filename = directory + "browse_"+classifier+"_format_statement_version.txt";
    394         else
    395             version_filename = directory + "query_format_statement_version.txt";
    396 
    397         File version_file = new File(version_filename);
    398         logger.error("Version filename is " + version_filename);
    399 
    400 
    401         if(subaction.equals("update"))
    402         {
    403             String version_number = "1";
    404             BufferedWriter writer;
    405 
    406             try{
    407 
    408                 if(version_file.exists())
    409                 {
    410                     // Read version
    411                     BufferedReader reader = new BufferedReader(new FileReader(version_filename));
    412                     version_number = reader.readLine();
    413                     int aInt = Integer.parseInt(version_number) + 1;
    414                     version_number = Integer.toString(aInt);
    415                     reader.close();
    416                 }
    417                 else{
    418                     // Create
    419                     version_file.createNewFile();
    420                     writer = new BufferedWriter(new FileWriter(version_filename));
    421                     writer.write(version_number);
    422                     writer.close();
    423                 }
    424 
    425                 // Write version file
    426                 String format_statement_filename = "";
    427 
    428                 if(service.equals("ClassifierBrowse"))
    429                     format_statement_filename = directory + "browse_"+classifier+"_format_statement_v" + version_number + ".txt";
    430                 else
    431                     format_statement_filename = directory + "query_format_statement_v" + version_number + ".txt";
    432 
    433                 logger.error("Format statement filename is " + format_statement_filename);
    434 
    435                 // Write format statement
    436                 String format_string = this.converter.getString(format_statement); //GSXML.xmlNodeToString(format_statement);
    437                 writer = new BufferedWriter(new FileWriter(format_statement_filename));
    438                 writer.write(format_string);
    439                 writer.close();
    440 
    441                 // Update version number
    442                 writer = new BufferedWriter(new FileWriter(version_filename));
    443                 writer.write(version_number);
    444                 writer.close();
    445 
    446             } catch (IOException e) {
    447                 logger.error("IO Exception "+e);
    448             }
    449         }
    450 
    451         if(subaction.equals("save"))
    452         {
    453             logger.error("SAVE format statement");
    454 
    455             try{
    456 
    457                 // Convert format string to a document
    458                 //DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    459                 //DocumentBuilder builder = factory.newDocumentBuilder();
    460                 //String input = "<html><head><title></title></head><body>" + format_string + "</body></html>";
    461                 //String input = format_string.substring(0,format_string.length()-1)+"</xml>";
    462                 //logger.error(input);
    463                 //InputSource is = new InputSource( new StringReader( input ) );
    464                 //logger.error("About to parse format string");
    465                 //Document format_statement = (Document) builder.parse( is );
    466                 //logger.error("Done parsing format string");
    467 
    468                 // open collectionConfig.xml and read in to w3 Document
    469                 String collection_config = directory + "collectionConfig.xml";
    470                 Document config = this.converter.getDOM(new File(collection_config), "UTF-8");
    471            
    472                 //String tag_name = "";
    473                 int k;
    474                 int index;
    475                 Element elem;
    476                 // Try importing entire tree to this.doc so we can add and remove children at ease
    477                 //Node current_node = this.doc.importNode(GSXML.getChildByTagName(config, "CollectionConfig"),true);
    478                 Node current_node = GSXML.getChildByTagName(config, "CollectionConfig");
    479                 NodeList current_node_list;
    480    
    481                 logger.error("Service is "+service);
    482 
    483                 if(service.equals("ClassifierBrowse"))
    484                 {
    485                     //tag_name = "browse";
    486                     // if CLX then need to look in <classifier> X then <format>
    487                     // default is <browse><format>
    488 
    489                     logger.error("Looking for browse");
    490                     current_node = GSXML.getChildByTagName(current_node, "browse");
    491 
    492                     // find CLX
    493                     if(classifier != null)
    494                     {
    495                         logger.error("Classifier is not null");
    496                         logger.error("Classifier is "+classifier);
    497                         current_node_list = GSXML.getChildrenByTagName(current_node, "classifier");
    498                         index = Integer.parseInt(classifier.substring(2)) - 1;
    499                         logger.error("classifier index is "+index);
    500                         // index should be given by X-1
    501                         current_node = current_node_list.item(index);
    502                         // what if classifier does not have a format tag?
    503                         if(GSXML.getChildByTagName(current_node, "format") == null)
    504                         {
    505                             logger.error("ERROR: valid classifier but does not have a format child");
    506                             // well then create a format tag
    507                             Element format_tag = config.createElement("format");
    508                             current_node = (Node) current_node.appendChild(format_tag);
    509                             //current_node = (Node) format_tag;
    510                         }
    511                        
    512                         else{
    513                             current_node = GSXML.getChildByTagName(current_node, "format");
    514                         }
    515 
    516                     }
    517                     else{
    518                         logger.error("Classifier is null");
    519                         // To support all classifiers, set classifier to null?  There is the chance here that the format tag does not exist
    520                         if(GSXML.getChildByTagName(current_node, "format") == null)
    521                         {
    522                             logger.error("ERROR: classifier does not have a format child");
    523                             // well then create a format tag
    524                             Element format_tag = config.createElement("format");
    525                             current_node = (Node) current_node.appendChild(format_tag);
    526                             //current_node = (Node) format_tag;
    527                         }
    528                         else
    529                             current_node = GSXML.getChildByTagName(current_node, "format");
    530                     }
    531                 }
    532                 else if(service.equals("AllClassifierBrowse"))
    533                 {
    534                     logger.error("Looking for browse");
    535                     current_node = GSXML.getChildByTagName(current_node, "browse");
    536                     if(GSXML.getChildByTagName(current_node, "format") == null)
    537                     {
    538                         logger.error("ERROR AllClassifierBrowse: all classifiers do not have a format child");
    539                         // well then create a format tag
    540                         Element format_tag = config.createElement("format");
    541                         current_node = (Node) current_node.appendChild(format_tag);
    542                         //current_node = (Node) format_tag;
    543                     }
    544                     else
    545                         current_node = GSXML.getChildByTagName(current_node, "format");
    546                 }
    547                 else
    548                 {
    549                     // look in <format> with no attributes
    550                     logger.error("I presume this is search");
    551            
    552                     current_node_list = GSXML.getChildrenByTagName(current_node, "search");
    553                     for(k=0; k<current_node_list.getLength(); k++)
    554                     {
    555                         current_node = current_node_list.item(k);
    556                         // if current_node has no attributes then break
    557                         elem = (Element) current_node;
    558                         if(elem.hasAttribute("name")==false)
    559                             break;
    560                     }
    561                 }
    562 
    563                 // Current_node should be a format tag
    564                 elem = (Element) current_node;
    565    
    566                 logger.error("*Current_node = " + elem.getNodeName());
    567 
    568                 // seems we want to remove current child/ren and replace with format_statement's child/ren?
    569 
    570                 // remove existing
    571                 current_node_list = elem.getChildNodes();
    572                 logger.error("About to remove old children");
    573                 for(k=0; k<current_node_list.getLength(); k++)
    574                 {
    575                     current_node = elem.removeChild(current_node_list.item(k));
    576                 }
    577 
    578                 logger.error("old nodes removed");
    579 
    580                 // append new but we have a string!
    581                 //GSXML.setNodeText(elem, "THIS IS A TEST");
    582                 //GSXML.setNodeText(elem, format_string);
    583 
    584                 current_node_list = format_statement.getChildNodes();
    585                 for(k=0; k<current_node_list.getLength(); k++)
    586                 {
    587                     //if(transformed.getNodeType() == Node.DOCUMENT_NODE)
    588                     //transformed = ((Document)transformed).getDocumentElement();
    589                     //logger.error("Node type: "+current_node_list.item(k).getNodeType());
    590                     if(current_node_list.item(k).getNodeType() != Node.PROCESSING_INSTRUCTION_NODE)
    591                         elem.appendChild(config.importNode(current_node_list.item(k),true));
    592                 }
    593                 logger.error("new nodes added");
    594 
    595                 //String text = GSXML.getNodeText(elem);
    596                 //logger.error(text);
    597                 //text = text.replaceAll("_httpsite_", http_site);
    598                 //text = text.replaceAll("_httpcollection_", http_collection);
    599                 //GSXML.setNodeText(d, text);
    600 
    601                 // Now convert config document to string for writing to file
    602                 logger.error("Convert config to string");
    603                 String new_config = this.converter.getString(config);
    604 
    605                 new_config = StringUtils.replace(new_config, "&lt;", "<");
    606                 new_config = StringUtils.replace(new_config, "&gt;", ">");
    607                 new_config = StringUtils.replace(new_config, "&quot;", "\"");
    608    
    609                 // Write to file (not original! for now)
    610                 BufferedWriter writer = new BufferedWriter(new FileWriter(collection_config+".new"));
    611                 writer.write(new_config);
    612                 writer.close();
    613                 logger.error("All is happy with collection");
    614 
    615              } catch( Exception ex ) {
    616                 logger.error("There was an exception "+ex);
    617 
    618                 StringWriter sw = new StringWriter();
    619                 PrintWriter pw = new PrintWriter(sw, true);
    620                 ex.printStackTrace(pw);
    621                 pw.flush();
    622                 sw.flush();
    623                 logger.error(sw.toString());
    624             }
    625 
    626         }
    627     }
    628     else { // unknown type
    629         return super.processMessage(request);
    630 
    631     }
    632     return response;
    633     }
     358    /** handles requests made to the ServiceCluster itself
     359    *
     360    * @param req - the request Element- <request>
     361    * @return the result Element - should be <response>
     362    */
     363    protected Element processMessage(Element request) {
     364
     365        Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
     366        response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
     367        String type = request.getAttribute(GSXML.TYPE_ATT);
     368        String lang = request.getAttribute(GSXML.LANG_ATT);
     369        response.setAttribute(GSXML.TYPE_ATT, type);
     370
     371        logger.error("Collection received a message, attempting to process");
     372
     373        if (type.equals(GSXML.REQUEST_TYPE_FORMAT_STRING)) {
     374            logger.error("Received format string request");
     375
     376            String subaction = request.getAttribute("subaction");
     377            logger.error("Subaction is " + subaction);
     378
     379            String service = request.getAttribute("service");
     380            logger.error("Service is " + service);
     381
     382            String classifier = null;
     383            if(service.equals("ClassifierBrowse"))
     384            {
     385                classifier = request.getAttribute("classifier");
     386                logger.error("Classifier is " + classifier);
     387            }
     388
     389            Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM);
     390            //String format_string = GSXML.getNodeText(format_element);
     391            Element format_statement = (Element) format_element.getFirstChild();
     392
     393            //logger.error("Format string: " + format_string);
     394            logger.error("Config file location = " + GSFile.collectionConfigFile(this.site_home, this.cluster_name));
     395
     396            // check for version file
     397
     398            String directory = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name)).getParent() + File.separator;
     399            logger.error("Directory is " + directory);
     400
     401            String version_filename = "";
     402            if(service.equals("ClassifierBrowse"))
     403            version_filename = directory + "browse_"+classifier+"_format_statement_version.txt";
     404            else
     405            version_filename = directory + "query_format_statement_version.txt";
     406
     407            File version_file = new File(version_filename);
     408            logger.error("Version filename is " + version_filename);
     409
     410
     411            if(subaction.equals("update"))
     412            {
     413                String version_number = "1";
     414                BufferedWriter writer;
     415
     416                try{
     417
     418                    if(version_file.exists())
     419                    {
     420                        // Read version
     421                        BufferedReader reader = new BufferedReader(new FileReader(version_filename));
     422                        version_number = reader.readLine();
     423                        int aInt = Integer.parseInt(version_number) + 1;
     424                        version_number = Integer.toString(aInt);
     425                        reader.close();
     426                    }
     427                    else{
     428                        // Create
     429                        version_file.createNewFile();
     430                        writer = new BufferedWriter(new FileWriter(version_filename));
     431                        writer.write(version_number);
     432                        writer.close();
     433                    }
     434
     435                    // Write version file
     436                    String format_statement_filename = "";
     437
     438                    if(service.equals("ClassifierBrowse"))
     439                    format_statement_filename = directory + "browse_"+classifier+"_format_statement_v" + version_number + ".txt";
     440                    else
     441                    format_statement_filename = directory + "query_format_statement_v" + version_number + ".txt";
     442
     443                    logger.error("Format statement filename is " + format_statement_filename);
     444
     445                    // Write format statement
     446                    String format_string = this.converter.getString(format_statement); //GSXML.xmlNodeToString(format_statement);
     447                    writer = new BufferedWriter(new FileWriter(format_statement_filename));
     448                    writer.write(format_string);
     449                    writer.close();
     450
     451                    // Update version number
     452                    writer = new BufferedWriter(new FileWriter(version_filename));
     453                    writer.write(version_number);
     454                    writer.close();
     455
     456                } catch (IOException e) {
     457                    logger.error("IO Exception "+e);
     458                }
     459            }
     460
     461            if(subaction.equals("save"))
     462            {
     463                logger.error("SAVE format statement");
     464
     465                try{
     466
     467                    // Convert format string to a document
     468                    //DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     469                    //DocumentBuilder builder = factory.newDocumentBuilder();
     470                    //String input = "<html><head><title></title></head><body>" + format_string + "</body></html>";
     471                    //String input = format_string.substring(0,format_string.length()-1)+"</xml>";
     472                    //logger.error(input);
     473                    //InputSource is = new InputSource( new StringReader( input ) );
     474                    //logger.error("About to parse format string");
     475                    //Document format_statement = (Document) builder.parse( is );
     476                    //logger.error("Done parsing format string");
     477
     478                    // open collectionConfig.xml and read in to w3 Document
     479                    String collection_config = directory + "collectionConfig.xml";
     480                    Document config = this.converter.getDOM(new File(collection_config), "UTF-8");
     481                   
     482                    //String tag_name = "";
     483                    int k;
     484                    int index;
     485                    Element elem;
     486                    // Try importing entire tree to this.doc so we can add and remove children at ease
     487                    //Node current_node = this.doc.importNode(GSXML.getChildByTagName(config, "CollectionConfig"),true);
     488                    Node current_node = GSXML.getChildByTagName(config, "CollectionConfig");
     489                    NodeList current_node_list;
     490
     491                    logger.error("Service is "+service);
     492
     493                    if(service.equals("ClassifierBrowse"))
     494                    {
     495                        //tag_name = "browse";
     496                        // if CLX then need to look in <classifier> X then <format>
     497                        // default is <browse><format>
     498
     499                        logger.error("Looking for browse");
     500                        current_node = GSXML.getChildByTagName(current_node, "browse");
     501
     502                        // find CLX
     503                        if(classifier != null)
     504                        {
     505                            logger.error("Classifier is not null");
     506                            logger.error("Classifier is "+classifier);
     507                            current_node_list = GSXML.getChildrenByTagName(current_node, "classifier");
     508                            index = Integer.parseInt(classifier.substring(2)) - 1;
     509                            logger.error("classifier index is "+index);
     510                            // index should be given by X-1
     511                            current_node = current_node_list.item(index);
     512                            // what if classifier does not have a format tag?
     513                            if(GSXML.getChildByTagName(current_node, "format") == null)
     514                            {
     515                                logger.error("ERROR: valid classifier but does not have a format child");
     516                                // well then create a format tag
     517                                Element format_tag = config.createElement("format");
     518                                current_node = (Node) current_node.appendChild(format_tag);
     519                                //current_node = (Node) format_tag;
     520                            }
     521                           
     522                            else{
     523                                current_node = GSXML.getChildByTagName(current_node, "format");
     524                            }
     525
     526                        }
     527                        else{
     528                            logger.error("Classifier is null");
     529                            // To support all classifiers, set classifier to null?  There is the chance here that the format tag does not exist
     530                            if(GSXML.getChildByTagName(current_node, "format") == null)
     531                            {
     532                                logger.error("ERROR: classifier does not have a format child");
     533                                // well then create a format tag
     534                                Element format_tag = config.createElement("format");
     535                                current_node = (Node) current_node.appendChild(format_tag);
     536                                //current_node = (Node) format_tag;
     537                            }
     538                            else
     539                            current_node = GSXML.getChildByTagName(current_node, "format");
     540                        }
     541                    }
     542                    else if(service.equals("AllClassifierBrowse"))
     543                    {
     544                        logger.error("Looking for browse");
     545                        current_node = GSXML.getChildByTagName(current_node, "browse");
     546                        if(GSXML.getChildByTagName(current_node, "format") == null)
     547                        {
     548                            logger.error("ERROR AllClassifierBrowse: all classifiers do not have a format child");
     549                            // well then create a format tag
     550                            Element format_tag = config.createElement("format");
     551                            current_node = (Node) current_node.appendChild(format_tag);
     552                            //current_node = (Node) format_tag;
     553                        }
     554                        else
     555                        current_node = GSXML.getChildByTagName(current_node, "format");
     556                    }
     557                    else
     558                    {
     559                        // look in <format> with no attributes
     560                        logger.error("I presume this is search");
     561                       
     562                        current_node_list = GSXML.getChildrenByTagName(current_node, "search");
     563                        for(k=0; k<current_node_list.getLength(); k++)
     564                        {
     565                            current_node = current_node_list.item(k);
     566                            // if current_node has no attributes then break
     567                            elem = (Element) current_node;
     568                            if(elem.hasAttribute("name")==false)
     569                            break;
     570                        }
     571                    }
     572
     573                    // Current_node should be a format tag
     574                    elem = (Element) current_node;
     575                   
     576                    logger.error("*Current_node = " + elem.getNodeName());
     577
     578                    // seems we want to remove current child/ren and replace with format_statement's child/ren?
     579
     580                    // remove existing
     581                    current_node_list = elem.getChildNodes();
     582                    logger.error("About to remove old children");
     583                    for(k=0; k<current_node_list.getLength(); k++)
     584                    {
     585                        current_node = elem.removeChild(current_node_list.item(k));
     586                    }
     587
     588                    logger.error("old nodes removed");
     589
     590                    // append new but we have a string!
     591                    //GSXML.setNodeText(elem, "THIS IS A TEST");
     592                    //GSXML.setNodeText(elem, format_string);
     593
     594                    current_node_list = format_statement.getChildNodes();
     595                    for(k=0; k<current_node_list.getLength(); k++)
     596                    {
     597                        //if(transformed.getNodeType() == Node.DOCUMENT_NODE)
     598                        //transformed = ((Document)transformed).getDocumentElement();
     599                        //logger.error("Node type: "+current_node_list.item(k).getNodeType());
     600                        if(current_node_list.item(k).getNodeType() != Node.PROCESSING_INSTRUCTION_NODE)
     601                        elem.appendChild(config.importNode(current_node_list.item(k),true));
     602                    }
     603                    logger.error("new nodes added");
     604
     605                    //String text = GSXML.getNodeText(elem);
     606                    //logger.error(text);
     607                    //text = text.replaceAll("_httpsite_", http_site);
     608                    //text = text.replaceAll("_httpcollection_", http_collection);
     609                    //GSXML.setNodeText(d, text);
     610
     611                    // Now convert config document to string for writing to file
     612                    logger.error("Convert config to string");
     613                    String new_config = this.converter.getString(config);
     614
     615                    new_config = StringUtils.replace(new_config, "&lt;", "<");
     616                    new_config = StringUtils.replace(new_config, "&gt;", ">");
     617                    new_config = StringUtils.replace(new_config, "&quot;", "\"");
     618                   
     619                    // Write to file (not original! for now)
     620                    BufferedWriter writer = new BufferedWriter(new FileWriter(collection_config+".new"));
     621                    writer.write(new_config);
     622                    writer.close();
     623                    logger.error("All is happy with collection");
     624
     625                } catch( Exception ex ) {
     626                    logger.error("There was an exception "+ex);
     627
     628                    StringWriter sw = new StringWriter();
     629                    PrintWriter pw = new PrintWriter(sw, true);
     630                    ex.printStackTrace(pw);
     631                    pw.flush();
     632                    sw.flush();
     633                    logger.error(sw.toString());
     634                }
     635
     636            }
     637        }
     638        else { // unknown type
     639            return super.processMessage(request);
     640
     641        }
     642        return response;
     643    }
    634644
    635645}
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/collection/ServiceCluster.java

    r24213 r24221  
    11/*
    2  *    ServiceCluster.java
    3  *    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
    4  *
    5  *    This program is free software; you can redistribute it and/or modify
    6  *    it under the terms of the GNU General Public License as published by
    7  *    the Free Software Foundation; either version 2 of the License, or
    8  *    (at your option) any later version.
    9  *
    10  *    This program is distributed in the hope that it will be useful,
    11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
    12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13  *    GNU General Public License for more details.
    14  *
    15  *    You should have received a copy of the GNU General Public License
    16  *    along with this program; if not, write to the Free Software
    17  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    18  */
     2*    ServiceCluster.java
     3*    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
     4*
     5*    This program is free software; you can redistribute it and/or modify
     6*    it under the terms of the GNU General Public License as published by
     7*    the Free Software Foundation; either version 2 of the License, or
     8*    (at your option) any later version.
     9*
     10*    This program is distributed in the hope that it will be useful,
     11*    but WITHOUT ANY WARRANTY; without even the implied warranty of
     12*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13*    GNU General Public License for more details.
     14*
     15*    You should have received a copy of the GNU General Public License
     16*    along with this program; if not, write to the Free Software
     17*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     18*/
    1919// leave the package name as is for now - should be changed to something better
    2020// cluster? groups?
     
    4141
    4242/* ServiceCluster - a groups of services that are related in some way
    43  * Implements ModuleInterface. Contains a list of services provided by the cluster, along with metadata about the cluster itself.
    44  * a collection is a special type of cluster
    45  *  @author <a href="mailto:kjdon@cs.waikato.ac.nz">Katherine Don</a>
    46  *  @version $Revision$
    47  *  @see ModuleInterface
    48  */
     43* Implements ModuleInterface. Contains a list of services provided by the cluster, along with metadata about the cluster itself.
     44* a collection is a special type of cluster
     45*  @author <a href="mailto:kjdon@cs.waikato.ac.nz">Katherine Don</a>
     46*  @version $Revision$
     47*  @see ModuleInterface
     48*/
    4949public class ServiceCluster 
    50     implements ModuleInterface {
    51 
    52     static Logger logger = Logger.getLogger(org.greenstone.gsdl3.collection.ServiceCluster.class.getName());
    53 
    54     protected static final String CONFIG_ENCODING = "utf-8";
    55 
    56     protected static final String DEFAULT_LANG = "en"; // hack for now, should be read from the coll cfg file? or site cfg file for cluster
    57    
    58     /** base directory for the site that this cluster belongs to*/
    59     protected String site_home = null;
    60     /** http address of the site that this cluster belongs to */
    61     protected String site_http_address = null;
    62     /** The name of the cluster - for a collection, this is the collection name*/
    63     protected String cluster_name = null;
    64     /** collection type : mg or mgpp */
    65     protected String col_type = "";
    66 
    67     /** a reference to the message router */
    68     protected MessageRouter router = null;
    69     /** The map of services.
    70      *
    71      * Maps Services to ServiceRack objects
    72      * @see ServiceRack
    73      *
    74      */
    75     protected HashMap service_map=null;
    76     /** maps pseudo service names to real service names - needed if we have two services with the same name for one collection */
    77     protected HashMap service_name_map=null;
    78    
    79     /** XML converter for String to DOM and vice versa */
    80     protected XMLConverter converter=null;
    81 
    82     /** container doc for description elements */
    83     protected Document doc = null;
    84     /** list of services */
    85     protected Element service_list = null;
    86     /** list of metadata - all metadata, regardless of language goes in here */
    87     protected Element metadata_list = null;
    88     /** language specific stuff */
    89     //protected Element lang_specific_metadata_list = null;
    90     protected Element display_item_list = null;
    91     /** the element that will have any descriptions passed back in */
    92     protected Element description = null;
    93 
    94     /** list of plugin */
    95     protected Element plugin_item_list = null;
    96    
    97     public void setSiteHome(String home) {
    98     this.site_home = home;
    99     }
    100 
    101     public void setSiteAddress(String address) {
    102     this.site_http_address = address;
    103     }
    104 
    105     public void cleanUp() {
    106     Iterator i = this.service_map.values().iterator();
    107     while (i.hasNext()) {
    108         ServiceRack s = (ServiceRack)i.next();
    109         s.cleanUp();
    110     }
    111     }
    112     public void setClusterName(String name) {
    113     this.cluster_name = name;   
    114     this.description.setAttribute(GSXML.NAME_ATT, name);
    115     }
    116 
    117     public void setMessageRouter(MessageRouter m) {
    118     this.router = m;
    119     }
    120 
    121     public ServiceCluster() {
    122     this.service_map = new HashMap();
    123     this.service_name_map = new HashMap();
    124     this.converter = new XMLConverter();
    125     this.doc = this.converter.newDOM();
    126     this.description = this.doc.createElement(GSXML.CLUSTER_ELEM);
    127     this.display_item_list = this.doc.createElement(GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER);
    128     this.metadata_list = this.doc.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
    129     this.plugin_item_list = this.doc.createElement(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
    130     }
    131 
    132     /**
    133      * Configures the cluster.
    134      *
    135      * gsdlHome and clusterName must be set before configure is called.
    136      *
    137      * reads the site configuration file, and configures itself
    138      * this calls configure(Element) with the XML element node from the config
    139      * file.
    140      * configure(Element) should be used if the config file has already been
    141      * parsed.  This method will work with any subclass.
    142      *
    143      * @return true if configure successful, false otherwise.
    144      */
    145     public boolean configure() {
    146 
    147     if (this.site_home == null || this.cluster_name== null) {
    148         logger.error("site_home and cluster_name must be set before configure called!");
    149         return false;
    150     }
    151     logger.info("configuring service cluster");
    152     // read the site configuration file
    153     File config_file = new File(GSFile.siteConfigFile(this.site_home));
    154 
    155     if (!config_file.exists()) {
    156         logger.error("couldn't configure cluster: "+this.cluster_name +", "+config_file+" does not exist");
    157         return false;
    158     }
    159 
    160     Document doc = this.converter.getDOM(config_file, CONFIG_ENCODING);
    161     if (doc == null) {
    162         logger.error("couldn't parse config file "+config_file.getPath());
    163         return false;
    164     }
    165    
    166     // get the appropriate service cluster element
    167     Element cluster_list = (Element)GSXML.getChildByTagName(doc.getDocumentElement(), GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER);
    168     Element sc = GSXML.getNamedElement(cluster_list, GSXML.CLUSTER_ELEM,
    169                        GSXML.NAME_ATT, this.cluster_name);
    170    
    171     return this.configure(sc);
    172     }
    173    
    174    
    175     public boolean configure(Element service_cluster_info) {
    176    
    177     // get the metadata - for now just add it to the list
    178     Element meta_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
    179     if (meta_list !=null) {
    180         if (!addMetadata(meta_list)) {
    181        
    182         logger.error(" couldn't configure the metadata");
    183         }
    184     }
    185    
    186     // get the display info
    187     Element display_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER);
    188     if (display_list !=null) {
    189         if (!addDisplayItems(display_list)) {
    190        
    191         logger.error("couldn't configure the display items");
    192         }
    193     }
    194    
    195     //get the plugin info
    196     Element import_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.IMPORT_ELEM);
    197     if (import_list != null)
    198     {
    199         Element plugin_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
    200         if (plugin_list !=null) {
    201             if (!addPlugins(plugin_list)) {
    202        
    203                 logger.error("couldn't configure the plugins");
    204                 }
    205         }
    206     }   
    207    
    208     // do the service racks
    209     // empty the service map in case this is a reconfigure
    210     clearServices();
    211     Element service_rack_list = (Element)GSXML.getChildByTagName(service_cluster_info, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
    212     if (service_rack_list == null) {
    213         // is this an error? could you ever have a service cluster
    214         // without service racks???
    215         logger.error("cluster has no service racks!!");
    216     } else {
    217        
    218         if (!configureServiceRackList(service_rack_list, null)) {
    219         logger.error("couldn't configure the  service racks!!");
    220         return false;
    221         }
    222     }
    223 
    224     return true;
    225     }
    226    
    227     /** adds metadata from a metadataList into the metadata_list xml
    228      */
    229     protected boolean addMetadata(Element metadata_list) {
    230     if (metadata_list == null) return false;
    231     NodeList metanodes = metadata_list.getElementsByTagName(GSXML.METADATA_ELEM);
    232     if (metanodes.getLength()>0) { 
    233         for(int k=0; k<metanodes.getLength(); k++) {
    234         this.metadata_list.appendChild(this.doc.importNode(metanodes.item(k), true));
    235         }
    236     }
    237    
    238     return true;
    239     }
    240 
    241     protected boolean addDisplayItems(Element display_list) {
    242    
    243     if (display_list==null) return false;
    244     NodeList displaynodes = display_list.getElementsByTagName(GSXML.DISPLAY_TEXT_ELEM);
    245     if (displaynodes.getLength()>0) {   
    246         for(int k=0; k<displaynodes.getLength(); k++) {
    247         Element d = (Element) displaynodes.item(k);
    248         String lang = d.getAttribute(GSXML.LANG_ATT);
    249         if (lang==null||lang.equals("")) {
    250             //set the lang to teh default
    251             d.setAttribute(GSXML.LANG_ATT, DEFAULT_LANG);
    252         }
    253         String name = d.getAttribute(GSXML.NAME_ATT);
    254         Element this_item = GSXML.getNamedElement(this.display_item_list, GSXML.DISPLAY_TEXT_ELEM, GSXML.NAME_ATT, name);
    255         if (this_item==null) {
    256             this_item = this.doc.createElement(GSXML.DISPLAY_TEXT_ELEM);
    257             this_item.setAttribute(GSXML.NAME_ATT, name);
    258             this.display_item_list.appendChild(this_item);
    259         }
    260        
    261         this_item.appendChild(this.doc.importNode(d, true));
    262         }
    263     }
    264    
    265     return true;
    266     }
    267    
    268     protected boolean addPlugins(Element plugin_list) {
    269         if (plugin_list == null) return false;
    270     NodeList pluginNodes = plugin_list.getElementsByTagName(GSXML.PLUGIN_ELEM);
    271     if (pluginNodes.getLength() > 0) {
    272         for (int k = 0; k < pluginNodes.getLength(); k++)
     50implements ModuleInterface {
     51
     52    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.collection.ServiceCluster.class.getName());
     53
     54    protected static final String CONFIG_ENCODING = "utf-8";
     55
     56    protected static final String DEFAULT_LANG = "en"; // hack for now, should be read from the coll cfg file? or site cfg file for cluster
     57   
     58    /** base directory for the site that this cluster belongs to*/
     59    protected String site_home = null;
     60    /** http address of the site that this cluster belongs to */
     61    protected String site_http_address = null;
     62    /** The name of the cluster - for a collection, this is the collection name*/
     63    protected String cluster_name = null;
     64    /** collection type : mg, mgpp or lucene */
     65    protected String col_type = "";
     66    /** database type : gdbm, jdbm or sqlite*/
     67    protected String db_type = "";
     68   
     69    /** a reference to the message router */
     70    protected MessageRouter router = null;
     71    /** The map of services.
     72    *
     73    * Maps Services to ServiceRack objects
     74    * @see ServiceRack
     75    *
     76    */
     77    protected HashMap service_map=null;
     78    /** maps pseudo service names to real service names - needed if we have two services with the same name for one collection */
     79    protected HashMap service_name_map=null;
     80   
     81    /** XML converter for String to DOM and vice versa */
     82    protected XMLConverter converter=null;
     83
     84    /** container doc for description elements */
     85    protected Document doc = null;
     86    /** list of services */
     87    protected Element service_list = null;
     88    /** list of metadata - all metadata, regardless of language goes in here */
     89    protected Element metadata_list = null;
     90    /** language specific stuff */
     91    //protected Element lang_specific_metadata_list = null;
     92    protected Element display_item_list = null;
     93    /** the element that will have any descriptions passed back in */
     94    protected Element description = null;
     95
     96    /** list of plugin */
     97    protected Element plugin_item_list = null;
     98   
     99    public void setSiteHome(String home) {
     100        this.site_home = home;
     101    }
     102
     103    public void setSiteAddress(String address) {
     104        this.site_http_address = address;
     105    }
     106
     107    public void cleanUp() {
     108        Iterator i = this.service_map.values().iterator();
     109        while (i.hasNext()) {
     110            ServiceRack s = (ServiceRack)i.next();
     111            s.cleanUp();
     112        }
     113    }
     114    public void setClusterName(String name) {
     115        this.cluster_name = name;   
     116        this.description.setAttribute(GSXML.NAME_ATT, name);
     117    }
     118
     119    public void setMessageRouter(MessageRouter m) {
     120        this.router = m;
     121    }
     122
     123    public ServiceCluster() {
     124        this.service_map = new HashMap();
     125        this.service_name_map = new HashMap();
     126        this.converter = new XMLConverter();
     127        this.doc = this.converter.newDOM();
     128        this.description = this.doc.createElement(GSXML.CLUSTER_ELEM);
     129        this.display_item_list = this.doc.createElement(GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER);
     130        this.metadata_list = this.doc.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
     131        this.plugin_item_list = this.doc.createElement(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
     132    }
     133
     134    /**
     135    * Configures the cluster.
     136    *
     137    * gsdlHome and clusterName must be set before configure is called.
     138    *
     139    * reads the site configuration file, and configures itself
     140    * this calls configure(Element) with the XML element node from the config
     141    * file.
     142    * configure(Element) should be used if the config file has already been
     143    * parsed.  This method will work with any subclass.
     144    *
     145    * @return true if configure successful, false otherwise.
     146    */
     147    public boolean configure() {
     148
     149        if (this.site_home == null || this.cluster_name== null) {
     150            logger.error("site_home and cluster_name must be set before configure called!");
     151            return false;
     152        }
     153        logger.info("configuring service cluster");
     154        // read the site configuration file
     155        File config_file = new File(GSFile.siteConfigFile(this.site_home));
     156
     157        if (!config_file.exists()) {
     158            logger.error("couldn't configure cluster: "+this.cluster_name +", "+config_file+" does not exist");
     159            return false;
     160        }
     161
     162        Document doc = this.converter.getDOM(config_file, CONFIG_ENCODING);
     163        if (doc == null) {
     164            logger.error("couldn't parse config file "+config_file.getPath());
     165            return false;
     166        }
     167       
     168        // get the appropriate service cluster element
     169        Element cluster_list = (Element)GSXML.getChildByTagName(doc.getDocumentElement(), GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER);
     170        Element sc = GSXML.getNamedElement(cluster_list, GSXML.CLUSTER_ELEM,
     171        GSXML.NAME_ATT, this.cluster_name);
     172       
     173        return this.configure(sc);
     174    }
     175   
     176   
     177    public boolean configure(Element service_cluster_info) {
     178       
     179        // get the metadata - for now just add it to the list
     180        Element meta_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
     181        if (meta_list !=null) {
     182            if (!addMetadata(meta_list)) {
     183               
     184                logger.error(" couldn't configure the metadata");
     185            }
     186        }
     187       
     188        // get the display info
     189        Element display_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER);
     190        if (display_list !=null) {
     191            if (!addDisplayItems(display_list)) {
     192               
     193                logger.error("couldn't configure the display items");
     194            }
     195        }
     196       
     197        //get the plugin info
     198        Element import_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.IMPORT_ELEM);
     199        if (import_list != null)
    273200        {
    274             this.plugin_item_list.appendChild(this.doc.importNode(pluginNodes.item(k), true));
    275         }
    276     }
    277    
    278     return true;
    279     }
    280 
    281    
    282   protected void clearServices() {
    283     service_map.clear();
    284     this.service_list = this.doc.createElement(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER);
    285   }
    286     /** creates and configures all the services - extra_info is some more xml
     201            Element plugin_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
     202            if (plugin_list !=null) {
     203                if (!addPlugins(plugin_list)) {
     204                   
     205                    logger.error("couldn't configure the plugins");
     206                }
     207            }
     208        }   
     209       
     210        // do the service racks
     211        // empty the service map in case this is a reconfigure
     212        clearServices();
     213        Element service_rack_list = (Element)GSXML.getChildByTagName(service_cluster_info, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
     214        if (service_rack_list == null) {
     215            // is this an error? could you ever have a service cluster
     216            // without service racks???
     217            logger.error("cluster has no service racks!!");
     218        } else {
     219           
     220            if (!configureServiceRackList(service_rack_list, null)) {
     221                logger.error("couldn't configure the  service racks!!");
     222                return false;
     223            }
     224        }
     225
     226        return true;
     227    }
     228   
     229    /** adds metadata from a metadataList into the metadata_list xml
     230    */
     231    protected boolean addMetadata(Element metadata_list) {
     232        if (metadata_list == null) return false;
     233        NodeList metanodes = metadata_list.getElementsByTagName(GSXML.METADATA_ELEM);
     234        if (metanodes.getLength()>0) { 
     235            for(int k=0; k<metanodes.getLength(); k++) {
     236                this.metadata_list.appendChild(this.doc.importNode(metanodes.item(k), true));
     237            }
     238        }
     239       
     240        return true;
     241    }
     242
     243    protected boolean addDisplayItems(Element display_list) {
     244       
     245        if (display_list==null) return false;
     246        NodeList displaynodes = display_list.getElementsByTagName(GSXML.DISPLAY_TEXT_ELEM);
     247        if (displaynodes.getLength()>0) {   
     248            for(int k=0; k<displaynodes.getLength(); k++) {
     249                Element d = (Element) displaynodes.item(k);
     250                String lang = d.getAttribute(GSXML.LANG_ATT);
     251                if (lang==null||lang.equals("")) {
     252                    //set the lang to teh default
     253                    d.setAttribute(GSXML.LANG_ATT, DEFAULT_LANG);
     254                }
     255                String name = d.getAttribute(GSXML.NAME_ATT);
     256                Element this_item = GSXML.getNamedElement(this.display_item_list, GSXML.DISPLAY_TEXT_ELEM, GSXML.NAME_ATT, name);
     257                if (this_item==null) {
     258                    this_item = this.doc.createElement(GSXML.DISPLAY_TEXT_ELEM);
     259                    this_item.setAttribute(GSXML.NAME_ATT, name);
     260                    this.display_item_list.appendChild(this_item);
     261                }
     262               
     263                this_item.appendChild(this.doc.importNode(d, true));
     264            }
     265        }
     266       
     267        return true;
     268    }
     269   
     270    protected boolean addPlugins(Element plugin_list) {
     271        if (plugin_list == null) return false;
     272        NodeList pluginNodes = plugin_list.getElementsByTagName(GSXML.PLUGIN_ELEM);
     273        if (pluginNodes.getLength() > 0) {
     274            for (int k = 0; k < pluginNodes.getLength(); k++)
     275            {
     276                this.plugin_item_list.appendChild(this.doc.importNode(pluginNodes.item(k), true));
     277            }
     278        }
     279       
     280        return true;
     281    }
     282
     283   
     284    protected void clearServices() {
     285        service_map.clear();
     286        this.service_list = this.doc.createElement(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER);
     287    }
     288    /** creates and configures all the services - extra_info is some more xml
    287289that is passed to teh service  - eg used for coll config files for Collection
    288     */
    289     protected boolean configureServiceRackList(Element service_rack_list,
    290                        Element extra_info) {
    291 
    292     // create all the services
    293     NodeList nodes = service_rack_list.getElementsByTagName(GSXML.SERVICE_CLASS_ELEM);
    294     if (nodes.getLength()==0) {
    295         logger.error("ServiceCluster configuration error: cluster "+this.cluster_name+" has no service modules!");
    296         return false;
    297     }
    298 
    299     for(int i=0; i<nodes.getLength(); i++) {
    300    
    301         // the xml request to send to the serviceRack to query what
    302         // services it provides
    303         Element message = this.doc.createElement(GSXML.MESSAGE_ELEM);
    304         Element request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE, "", "", "");
    305         message.appendChild(request);
    306 
    307         Element n = (Element)nodes.item(i);
    308         String servicetype = n.getAttribute(GSXML.NAME_ATT);
    309        
    310         ServiceRack s = null;
    311        
    312         try {
    313         // try for a default service in standard package
    314         s = (ServiceRack)Class.forName("org.greenstone.gsdl3.service."+servicetype).newInstance();
    315        
    316         } catch (Exception e) {}
    317         if (s == null) {
    318         try {
    319             // name as is, in case package is already specified
    320             s = (ServiceRack)Class.forName(servicetype).newInstance();
    321         } catch (Exception e) {}
    322         }
    323 
    324         if (s == null) {
    325         logger.error("Couldn't get an instance of class "+servicetype+", or org.greenstone.gsdl3.service."+servicetype);
    326         continue;
    327         }
    328 
    329        
    330         s.setSiteHome(this.site_home);
    331         s.setSiteAddress(this.site_http_address);
    332         s.setClusterName(this.cluster_name);
    333         s.setMessageRouter(this.router);
    334         // pass the xml node to the service for configuration
    335         if (s.configure(n, extra_info)) {
    336        
    337         // find out the supported service types for this service module
    338         Node types = s.process(message);
    339         NodeList typenodes = ((Element)types).getElementsByTagName(GSXML.SERVICE_ELEM);   
    340        
    341         for (int j=0; j<typenodes.getLength();j++) {
    342             String service = ((Element) typenodes.item(j)).getAttribute(GSXML.NAME_ATT);       
    343             if (service_map.get(service)!=null) {
    344             char extra = '0';
    345             String new_service = service+extra;   
    346            
    347             while (service_map.get(new_service)!=null) {
    348                 extra++;
    349                 new_service = service+extra;
    350             }
    351             this.service_name_map.put(new_service, service);
    352             service=new_service;
    353             ((Element) typenodes.item(j)).setAttribute(GSXML.NAME_ATT, service);
    354             }
    355             this.service_map.put(service, s);
    356             // also add info to the ServiceInfo XML element
    357             this.service_list.appendChild(this.doc.importNode(typenodes.item(j), true));
    358         }
    359         }
     290    */
     291    protected boolean configureServiceRackList(Element service_rack_list,
     292    Element extra_info) {
     293
     294        // create all the services
     295        NodeList nodes = service_rack_list.getElementsByTagName(GSXML.SERVICE_CLASS_ELEM);
     296        if (nodes.getLength()==0) {
     297            logger.error("ServiceCluster configuration error: cluster "+this.cluster_name+" has no service modules!");
     298            return false;
     299        }
     300
     301        for(int i=0; i<nodes.getLength(); i++) {
     302           
     303            // the xml request to send to the serviceRack to query what
     304            // services it provides
     305            Element message = this.doc.createElement(GSXML.MESSAGE_ELEM);
     306            Element request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE, "", "", "");
     307            message.appendChild(request);
     308
     309            Element n = (Element)nodes.item(i);
     310            String servicetype = n.getAttribute(GSXML.NAME_ATT);
     311           
     312            ServiceRack s = null;
     313           
     314            try {
     315                // try for a default service in standard package
     316                s = (ServiceRack)Class.forName("org.greenstone.gsdl3.service."+servicetype).newInstance();
     317               
     318            } catch (Exception e) {}
     319            if (s == null) {
     320                try {
     321                    // name as is, in case package is already specified
     322                    s = (ServiceRack)Class.forName(servicetype).newInstance();
     323                } catch (Exception e) {}
     324            }
     325
     326            if (s == null) {
     327                logger.error("Couldn't get an instance of class "+servicetype+", or org.greenstone.gsdl3.service."+servicetype);
     328                continue;
     329            }
     330
     331           
     332            s.setSiteHome(this.site_home);
     333            s.setSiteAddress(this.site_http_address);
     334            s.setClusterName(this.cluster_name);
     335            s.setMessageRouter(this.router);
     336            // pass the xml node to the service for configuration
     337            if (s.configure(n, extra_info)) {
     338               
     339                // find out the supported service types for this service module
     340                Node types = s.process(message);
     341                NodeList typenodes = ((Element)types).getElementsByTagName(GSXML.SERVICE_ELEM);   
     342               
     343                for (int j=0; j<typenodes.getLength();j++) {
     344                    String service = ((Element) typenodes.item(j)).getAttribute(GSXML.NAME_ATT);       
     345                    if (service_map.get(service)!=null) {
     346                        char extra = '0';
     347                        String new_service = service+extra;   
     348                       
     349                        while (service_map.get(new_service)!=null) {
     350                            extra++;
     351                            new_service = service+extra;
     352                        }
     353                        this.service_name_map.put(new_service, service);
     354                        service=new_service;
     355                        ((Element) typenodes.item(j)).setAttribute(GSXML.NAME_ATT, service);
     356                    }
     357                    this.service_map.put(service, s);
     358                    // also add info to the ServiceInfo XML element
     359                    this.service_list.appendChild(this.doc.importNode(typenodes.item(j), true));
     360                }
     361            }
     362        }
     363       
     364        return true;
     365       
     366       
     367    }
     368
     369
     370    /**
     371    * Process an XML document - uses Strings
     372    *  just calls process(Node).
     373    *
     374    * @param in the Document to process - a string
     375    * @return the resultant document as a string - contains any error messages
     376    * @see String
     377    */
     378    public String process(String in) {
     379
     380        Document doc = this.converter.getDOM(in);
     381       
     382        Node res = process(doc);
     383        return this.converter.getString(res);
     384       
     385    }
     386   
     387    /** process XML as Node
     388    *
     389    */
     390    public Node process(Node message_node) {
     391
     392        Element message = this.converter.nodeToElement(message_node);
     393
     394        NodeList requests = message.getElementsByTagName(GSXML.REQUEST_ELEM);
     395        Document mess_doc = message.getOwnerDocument();
     396        Element mainResult = this.doc.createElement(GSXML.MESSAGE_ELEM);
     397        if (requests.getLength()==0) {
     398            logger.error("no requests for cluster:"+this.cluster_name);
     399            // no requests
     400            return mainResult; // for now
     401        }
     402        for (int i=0; i<requests.getLength(); i++) {
     403            Element request = (Element)requests.item(i);
     404            String to = request.getAttribute(GSXML.TO_ATT);
     405
     406            // the cluster name should be first, check, then remove
     407            String clustername = GSPath.getFirstLink(to);
     408            if (!clustername.equals(this.cluster_name)){
     409                logger.error("cluster name wrong! was "+clustername+" should have been "+this.cluster_name);
     410                continue; // ignore this request
     411            }
     412            to = GSPath.removeFirstLink(to);
     413            request.setAttribute(GSXML.TO_ATT, to);
     414           
     415            if (to.equals("")) { // this command is for me
     416                Element response = processMessage(request);
     417                mainResult.appendChild(response);
     418               
     419            } else { // the request is for one of my services
     420                String service = GSPath.getFirstLink(to);
     421               
     422                if (!this.service_map.containsKey(service)) {
     423                    logger.error("non-existant service, "+service+", specified!");
     424                    continue;
     425                }
     426                String real_service = service;
     427                if (this.service_name_map.containsKey(service)) {
     428                    real_service = (String)this.service_name_map.get(service);
     429                    // need to change the to att in the request - give the real service name
     430                    to = request.getAttribute(GSXML.TO_ATT);
     431                    String old_to = to;
     432                    to = GSPath.replaceFirstLink(to, real_service);
     433                    request.setAttribute(GSXML.TO_ATT, to);
     434                }
     435                // have to pass the request to the service
     436                Element single_message = mess_doc.createElement(GSXML.MESSAGE_ELEM);
     437                single_message.appendChild(request);
     438                Node response_message = ((ModuleInterface)this.service_map.get(service)).process(single_message);
     439                if (response_message != null) {
     440                    Element response = (Element) GSXML.getChildByTagName(response_message, GSXML.RESPONSE_ELEM);
     441                    String from = response.getAttribute(GSXML.FROM_ATT);
     442                    if (!real_service.equals(service)) {
     443                        // replace the real service name with the pseudo service name
     444                        from = GSPath.replaceFirstLink(from, service);
     445                        // also need to do it in the service itself
     446                        // shoudl this be done here??
     447                        Element service_elem = (Element) GSXML.getChildByTagName(response, GSXML.SERVICE_ELEM);
     448                        if (service_elem!= null) {
     449                            service_elem.setAttribute(GSXML.NAME_ATT, service);
     450                        }
     451                    }
     452                    from = GSPath.prependLink(from, this.cluster_name);
     453                    response.setAttribute(GSXML.FROM_ATT, from);
     454                    mainResult.appendChild(this.doc.importNode(response, true));
     455                }
     456               
     457            } // else
     458           
     459           
     460        } // for each request
     461        return mainResult;
     462    }
     463
     464    /** handles requests made to the ServiceCluster itself
     465    *
     466    * @param req - the request Element- <request>
     467    * @return the result Element - should be <response>
     468    */
     469    protected Element processMessage(Element request) {
     470
     471        Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
     472        response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
     473        String type = request.getAttribute(GSXML.TYPE_ATT);
     474        String lang = request.getAttribute(GSXML.LANG_ATT);
     475        response.setAttribute(GSXML.TYPE_ATT, type);
     476       
     477        if (type.equals(GSXML.REQUEST_TYPE_DESCRIBE)) {
     478            // create the collection element
     479            Element description = (Element)this.description.cloneNode(false);
     480            // set collection type : mg or mgpp
     481            description.setAttribute(GSXML.TYPE_ATT, col_type);
     482            description.setAttribute(GSXML.DB_TYPE_ATT, db_type);
     483
     484            response.appendChild(description);
     485            // check the param list
     486            Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     487            if (param_list == null) {               
     488                addAllDisplayInfo(description, lang);               
     489                description.appendChild(this.service_list);
     490                description.appendChild(this.metadata_list);
     491                description.appendChild(this.plugin_item_list);
     492                return response;
     493            }
     494           
     495            // go through the param list and see what components are wanted
     496            NodeList params = param_list.getElementsByTagName(GSXML.PARAM_ELEM);
     497            for (int i=0; i<params.getLength(); i++) {     
     498               
     499                Element param = (Element)params.item(i);               
     500                // Identify the structure information desired
     501                if (param.getAttribute(GSXML.NAME_ATT).equals(GSXML.SUBSET_PARAM)) {
     502                    String info = param.getAttribute(GSXML.VALUE_ATT);
     503                    if (info.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
     504                        description.appendChild(this.service_list);
     505                    } else if (info.equals(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER)) {
     506                        description.appendChild(metadata_list);
     507                    } else if (info.equals(GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER)) {
     508                        addAllDisplayInfo(description, lang);
     509                    } else if (info.equals(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER)) {
     510                        description.appendChild(plugin_item_list);
     511                    }
     512                }
     513            }
     514            return response;
     515        }
     516        /*
     517    if (type.equals(GSXML.REQUEST_TYPE_FORMAT_STRING)) {
     518        logger.error("Received format string request");
     519        String service = request.getAttribute("service");
     520        logger.error("Service is " + service);
     521        String classifier = null;
     522        if(service.equals("ClassifierBrowse"))
     523        {
     524            classifier = request.getAttribute("classifier");
     525            logger.error("Classifier is " + classifier);
     526        }
     527        Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM);
     528        String format_string = GSXML.getNodeText(format_element);
     529        logger.error("Format string: " + format_string);
     530        logger.error("Config file location = " + GSFile.collectionConfigFile(this.site_home, this.cluster_name));
     531
     532        // check for version file
     533
     534        String directory = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name)).getParent() + File.pathSeparator;
     535        logger.error("Directory is " + directory);
     536
     537        String version_filename = "";
     538
     539        if(service.equals("ClassifierBrowse"))
     540            version_filename = directory + "browse_"+classifier+"_format_statement_version.txt";
     541        else
     542            version_filename = directory + "query_format_statement_version.txt";
     543
     544        File version_file = new File(version_filename);
     545        logger.error("Version filename is " + version_filename);
     546
     547        String version_number = "1";
     548        BufferedWriter writer; // = new BufferedWriter(new FileWriter(version_filename));
     549        //RandomAccessFile version_file_random_access;
     550
     551        try{
     552
     553            if(version_file.exists())
     554            {
     555                // Read version
     556                BufferedReader reader = new BufferedReader(new FileReader(version_filename));
     557                //version_file_random_access = new RandomAccessFile(version_file, "r");
     558                //logger.error("
     559                //version_number = version_file_random_access.readInt();
     560                version_number = reader.readLine();
     561                int aInt = Integer.parseInt(version_number) + 1;
     562                version_number = Integer.toString(aInt);
     563                reader.close();
     564                //version_file_random_access.close();
     565            }
     566            else{
     567                // Create
     568                version_file.createNewFile();
     569                // write 1 to file
     570                writer = new BufferedWriter(new FileWriter(version_filename));
     571                //version_file_random_access = new RandomAccessFile(version_file, "w");
     572                //version_file_random_access.writeInt(version_number);
     573                writer.write(version_number);
     574                writer.close();
     575                //version_file_random_access.close();
     576            }
     577
     578            // Write version file
     579            String format_statement_filename = "";
     580
     581            if(service.equals("ClassifierBrowse"))
     582                format_statement_filename = directory + "browse_"+classifier+"_format_statement_v" + version_number + ".txt";
     583            else
     584                format_statement_filename = directory + "query_format_statement_v" + version_number + ".txt";
     585
     586            logger.error("Format statement filename is " + format_statement_filename);
     587
     588            writer = new BufferedWriter(new FileWriter(format_statement_filename));
     589            writer.write(format_string);
     590            writer.close();
     591
     592            // Update version number
     593            //version_file_random_access = new RandomAccessFile(version_file, "w");
     594            //version_file_random_access.writeInt(version_number);
     595            //version_file_random_access.close();
     596
     597            writer = new BufferedWriter(new FileWriter(version_filename));
     598            //version_file_random_access = new RandomAccessFile(version_file, "w");
     599            //version_file_random_access.writeInt(version_number);
     600            writer.write(version_number);
     601            writer.close();
     602
     603
     604
     605        } catch (IOException e) {
     606            logger.error("IO Exception "+e);
     607            //System.exit(1);
     608        }
     609
     610
     611    }*/
     612        if (type.equals(GSXML.REQUEST_TYPE_SYSTEM)) {
     613            response = processSystemRequest(request);
     614        } else { // unknown type
     615            logger.error("cant handle request of type "+ type);
     616           
     617        }
     618        return response;
     619    }
     620
     621    protected Element processSystemRequest(Element request) {
     622
     623        Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
     624        response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
     625        response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_SYSTEM);
     626
     627        // a list of system requests - should put any error messages
     628        // or success messages into response
     629        NodeList commands = request.getElementsByTagName(GSXML.SYSTEM_ELEM);
     630        String message=null;   
     631        for (int i=0; i<commands.getLength(); i++) {
     632            // all the commands should be Elements
     633            Element elem = (Element)commands.item(i);
     634            String action = elem.getAttribute(GSXML.TYPE_ATT);
     635            if (action.equals(GSXML.SYSTEM_TYPE_CONFIGURE)) {
     636                String subset = elem.getAttribute(GSXML.SYSTEM_SUBSET_ATT);
     637                if (subset.equals("")) {
     638                    // need to reconfigure the service cluster
     639                   
     640                    if (this.configure()) {
     641                        Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " reconfigured");
     642                        response.appendChild(s);
     643                       
     644                    } else {
     645                        Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " could not be reconfigured");
     646                        response.appendChild(s);
     647                    }
     648                } else if (this.configureSubset(subset)) {
     649                    Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " "+subset+" reconfigured");
     650                    response.appendChild(s);
     651                } else {
     652                    Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " "+subset + " could not be reconfigured");
     653                    response.appendChild(s);
     654                }
     655                continue;
     656            } // configure action
     657           
     658            String module_name = elem.getAttribute(GSXML.SYSTEM_MODULE_NAME_ATT);
     659            String module_type = elem.getAttribute(GSXML.SYSTEM_MODULE_TYPE_ATT);
     660            if (action.equals(GSXML.SYSTEM_TYPE_ACTIVATE)) {
     661                Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, "activate action not yet implemented - does it even make sense in this context??");
     662                response.appendChild(s);
     663            } else if (action.equals(GSXML.SYSTEM_TYPE_DEACTIVATE)) {
     664                if (module_type.equals(GSXML.SERVICE_ELEM)) {
     665                    // deactivate the service
     666                    // remove from service_map
     667                    this.service_map.remove(module_name);
     668                    Element service_elem = GSXML.getNamedElement(this.service_list, GSXML.SERVICE_ELEM, GSXML.NAME_ATT, module_name);
     669                    service_list.removeChild(service_elem);         
     670                    message = module_type+": "+module_name+" deactivated";
     671                } else {
     672                    message = "can't deactivate "+module_type+" type modules!";}
     673                Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, message);
     674                response.appendChild(s);
     675            } else {
     676                logger.error("cant process system request, action "+action);
     677                continue;
     678            }
     679        } // for each command
     680        return response;
     681    }
     682
     683    /**
     684    * do a configure on only part of the collection
     685    */
     686    protected boolean configureSubset(String subset) {
     687       
     688        File configFile = new File(GSFile.siteConfigFile(this.site_home));
     689        if (!configFile.exists() ) {
     690            logger.error("site config file: "+configFile.getPath()+" not found!");
     691            // wont be able to do any of the requests
     692            return false;
     693           
     694        }
     695       
     696        Document site_config_doc  = this.converter.getDOM(configFile);
     697        if (site_config_doc == null) {
     698            logger.error("could not read in site config file: "+configFile.getPath());
     699            return false;
     700        }
     701       
     702        Element site_config_elem = site_config_doc.getDocumentElement();
     703        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);
     704        if (cluster_config_elem == null) {
     705            logger.error("site config file: "+configFile.getPath()+" has no element for cluster "+this.cluster_name);
     706            // wont be able to do any of teh requests
     707            return false;
     708           
     709        }
     710        if (subset.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
     711            Element service_rack_list = (Element)GSXML.getChildByTagName(cluster_config_elem, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
     712            clearServices();
     713            return configureServiceRackList(service_rack_list, null);
     714        } else if (subset.equals(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER)) {
     715            this.metadata_list = this.doc.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
     716            Element metadata_list = (Element)GSXML.getChildByTagName(cluster_config_elem, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
     717            return addMetadata(metadata_list);
     718        } else if (subset.equals(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER)) {
     719            this.plugin_item_list = this.doc.createElement(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
     720            Element import_list = (Element)GSXML.getChildByTagName(cluster_config_elem,GSXML.IMPORT_ELEM);
     721            if (import_list != null)
     722            {
     723                Element plugin_item_list = (Element)GSXML.getChildByTagName(cluster_config_elem,GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
     724                return addPlugins(plugin_item_list);
     725            }
     726            else
     727            return false;
     728        } else {
     729            logger.error("cannot process system request, configure "+subset);
     730            return false;
     731        }
     732
    360733    }
    361    
    362     return true;
    363    
    364    
    365     }
    366 
    367 
    368     /**
    369      * Process an XML document - uses Strings
    370      *  just calls process(Node).
    371      *
    372      * @param in the Document to process - a string
    373      * @return the resultant document as a string - contains any error messages
    374      * @see String
    375      */
    376     public String process(String in) {
    377 
    378     Document doc = this.converter.getDOM(in);
    379    
    380     Node res = process(doc);
    381     return this.converter.getString(res);
    382    
    383     }
    384    
    385     /** process XML as Node
    386      *
    387      */
    388     public Node process(Node message_node) {
    389 
    390     Element message = this.converter.nodeToElement(message_node);
    391 
    392     NodeList requests = message.getElementsByTagName(GSXML.REQUEST_ELEM);
    393     Document mess_doc = message.getOwnerDocument();
    394     Element mainResult = this.doc.createElement(GSXML.MESSAGE_ELEM);
    395     if (requests.getLength()==0) {
    396         logger.error("no requests for cluster:"+this.cluster_name);
    397         // no requests
    398         return mainResult; // for now
    399     }
    400     for (int i=0; i<requests.getLength(); i++) {
    401         Element request = (Element)requests.item(i);
    402         String to = request.getAttribute(GSXML.TO_ATT);
    403 
    404         // the cluster name should be first, check, then remove
    405         String clustername = GSPath.getFirstLink(to);
    406         if (!clustername.equals(this.cluster_name)){
    407         logger.error("cluster name wrong! was "+clustername+" should have been "+this.cluster_name);
    408         continue; // ignore this request
    409         }
    410         to = GSPath.removeFirstLink(to);
    411         request.setAttribute(GSXML.TO_ATT, to);
    412        
    413         if (to.equals("")) { // this command is for me
    414         Element response = processMessage(request);
    415         mainResult.appendChild(response);
    416        
    417         } else { // the request is for one of my services
    418         String service = GSPath.getFirstLink(to);
    419        
    420         if (!this.service_map.containsKey(service)) {
    421             logger.error("non-existant service, "+service+", specified!");
    422             continue;
    423         }
    424         String real_service = service;
    425         if (this.service_name_map.containsKey(service)) {
    426             real_service = (String)this.service_name_map.get(service);
    427             // need to change the to att in the request - give the real service name
    428             to = request.getAttribute(GSXML.TO_ATT);
    429             String old_to = to;
    430             to = GSPath.replaceFirstLink(to, real_service);
    431             request.setAttribute(GSXML.TO_ATT, to);
    432         }
    433         // have to pass the request to the service
    434         Element single_message = mess_doc.createElement(GSXML.MESSAGE_ELEM);
    435         single_message.appendChild(request);
    436         Node response_message = ((ModuleInterface)this.service_map.get(service)).process(single_message);
    437         if (response_message != null) {
    438             Element response = (Element) GSXML.getChildByTagName(response_message, GSXML.RESPONSE_ELEM);
    439             String from = response.getAttribute(GSXML.FROM_ATT);
    440             if (!real_service.equals(service)) {
    441             // replace the real service name with the pseudo service name
    442             from = GSPath.replaceFirstLink(from, service);
    443             // also need to do it in the service itself
    444             // shoudl this be done here??
    445             Element service_elem = (Element) GSXML.getChildByTagName(response, GSXML.SERVICE_ELEM);
    446             if (service_elem!= null) {
    447                 service_elem.setAttribute(GSXML.NAME_ATT, service);
    448             }
    449             }
    450             from = GSPath.prependLink(from, this.cluster_name);
    451             response.setAttribute(GSXML.FROM_ATT, from);
    452             mainResult.appendChild(this.doc.importNode(response, true));
    453         }
    454          
    455         } // else
    456        
    457        
    458     } // for each request
    459     return mainResult;
    460     }
    461 
    462     /** handles requests made to the ServiceCluster itself
    463      *
    464      * @param req - the request Element- <request>
    465      * @return the result Element - should be <response>
    466      */
    467     protected Element processMessage(Element request) {
    468 
    469     Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
    470     response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
    471     String type = request.getAttribute(GSXML.TYPE_ATT);
    472     String lang = request.getAttribute(GSXML.LANG_ATT);
    473     response.setAttribute(GSXML.TYPE_ATT, type);
    474    
    475     if (type.equals(GSXML.REQUEST_TYPE_DESCRIBE)) {
    476         // create the collection element
    477         Element description = (Element)this.description.cloneNode(false);
    478         // set collection type : mg or mgpp
    479         description.setAttribute(GSXML.TYPE_ATT, col_type);
    480 
    481         response.appendChild(description);
    482         // check the param list
    483         Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    484         if (param_list == null) {               
    485         addAllDisplayInfo(description, lang);               
    486         description.appendChild(this.service_list);
    487         description.appendChild(this.metadata_list);
    488         description.appendChild(this.plugin_item_list);
    489         return response;
    490         }
    491        
    492         // go through the param list and see what components are wanted
    493         NodeList params = param_list.getElementsByTagName(GSXML.PARAM_ELEM);
    494         for (int i=0; i<params.getLength(); i++) {     
    495        
    496         Element param = (Element)params.item(i);               
    497         // Identify the structure information desired
    498         if (param.getAttribute(GSXML.NAME_ATT).equals(GSXML.SUBSET_PARAM)) {
    499             String info = param.getAttribute(GSXML.VALUE_ATT);
    500             if (info.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
    501             description.appendChild(this.service_list);
    502             } else if (info.equals(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER)) {
    503             description.appendChild(metadata_list);
    504             } else if (info.equals(GSXML.DISPLAY_TEXT_ELEM+GSXML.LIST_MODIFIER)) {
    505             addAllDisplayInfo(description, lang);
    506             } else if (info.equals(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER)) {
    507                 description.appendChild(plugin_item_list);
    508             }
    509         }
    510         }
    511         return response;
    512     }
    513     /*
    514     if (type.equals(GSXML.REQUEST_TYPE_FORMAT_STRING)) {
    515         logger.error("Received format string request");
    516         String service = request.getAttribute("service");
    517         logger.error("Service is " + service);
    518         String classifier = null;
    519         if(service.equals("ClassifierBrowse"))
    520         {
    521             classifier = request.getAttribute("classifier");
    522             logger.error("Classifier is " + classifier);
    523         }
    524         Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM);
    525         String format_string = GSXML.getNodeText(format_element);
    526         logger.error("Format string: " + format_string);
    527         logger.error("Config file location = " + GSFile.collectionConfigFile(this.site_home, this.cluster_name));
    528 
    529         // check for version file
    530 
    531         String directory = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name)).getParent() + File.pathSeparator;
    532         logger.error("Directory is " + directory);
    533 
    534         String version_filename = "";
    535 
    536         if(service.equals("ClassifierBrowse"))
    537             version_filename = directory + "browse_"+classifier+"_format_statement_version.txt";
    538         else
    539             version_filename = directory + "query_format_statement_version.txt";
    540 
    541         File version_file = new File(version_filename);
    542         logger.error("Version filename is " + version_filename);
    543 
    544         String version_number = "1";
    545         BufferedWriter writer; // = new BufferedWriter(new FileWriter(version_filename));
    546         //RandomAccessFile version_file_random_access;
    547 
    548         try{
    549 
    550             if(version_file.exists())
    551             {
    552                 // Read version
    553                  BufferedReader reader = new BufferedReader(new FileReader(version_filename));
    554                  //version_file_random_access = new RandomAccessFile(version_file, "r");
    555                  //logger.error("
    556                  //version_number = version_file_random_access.readInt();
    557                  version_number = reader.readLine();
    558                  int aInt = Integer.parseInt(version_number) + 1;
    559                  version_number = Integer.toString(aInt);
    560                  reader.close();
    561                  //version_file_random_access.close();
    562             }
    563             else{
    564                 // Create
    565                 version_file.createNewFile();
    566                 // write 1 to file
    567                 writer = new BufferedWriter(new FileWriter(version_filename));
    568                 //version_file_random_access = new RandomAccessFile(version_file, "w");
    569                 //version_file_random_access.writeInt(version_number);
    570                 writer.write(version_number);
    571                 writer.close();
    572                 //version_file_random_access.close();
    573             }
    574 
    575             // Write version file
    576             String format_statement_filename = "";
    577 
    578             if(service.equals("ClassifierBrowse"))
    579                 format_statement_filename = directory + "browse_"+classifier+"_format_statement_v" + version_number + ".txt";
    580             else
    581                 format_statement_filename = directory + "query_format_statement_v" + version_number + ".txt";
    582 
    583             logger.error("Format statement filename is " + format_statement_filename);
    584 
    585             writer = new BufferedWriter(new FileWriter(format_statement_filename));
    586             writer.write(format_string);
    587             writer.close();
    588 
    589             // Update version number
    590             //version_file_random_access = new RandomAccessFile(version_file, "w");
    591             //version_file_random_access.writeInt(version_number);
    592             //version_file_random_access.close();
    593 
    594             writer = new BufferedWriter(new FileWriter(version_filename));
    595             //version_file_random_access = new RandomAccessFile(version_file, "w");
    596             //version_file_random_access.writeInt(version_number);
    597             writer.write(version_number);
    598             writer.close();
    599 
    600 
    601 
    602         } catch (IOException e) {
    603             logger.error("IO Exception "+e);
    604             //System.exit(1);
    605         }
    606 
    607 
    608     }*/
    609     if (type.equals(GSXML.REQUEST_TYPE_SYSTEM)) {
    610         response = processSystemRequest(request);
    611     } else { // unknown type
    612         logger.error("cant handle request of type "+ type);
    613        
    614     }
    615     return response;
    616     }
    617 
    618     protected Element processSystemRequest(Element request) {
    619 
    620     Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
    621     response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
    622     response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_SYSTEM);
    623 
    624     // a list of system requests - should put any error messages
    625     // or success messages into response
    626     NodeList commands = request.getElementsByTagName(GSXML.SYSTEM_ELEM);
    627     String message=null;   
    628     for (int i=0; i<commands.getLength(); i++) {
    629         // all the commands should be Elements
    630         Element elem = (Element)commands.item(i);
    631         String action = elem.getAttribute(GSXML.TYPE_ATT);
    632         if (action.equals(GSXML.SYSTEM_TYPE_CONFIGURE)) {
    633         String subset = elem.getAttribute(GSXML.SYSTEM_SUBSET_ATT);
    634         if (subset.equals("")) {
    635             // need to reconfigure the service cluster
    636            
    637             if (this.configure()) {
    638             Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " reconfigured");
    639             response.appendChild(s);
    640            
    641             } else {
    642             Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " could not be reconfigured");
    643             response.appendChild(s);
    644             }
    645         } else if (this.configureSubset(subset)) {
    646             Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " "+subset+" reconfigured");
    647             response.appendChild(s);
    648         } else {
    649             Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " "+subset + " could not be reconfigured");
    650             response.appendChild(s);
    651         }
    652         continue;
    653         } // configure action
    654        
    655         String module_name = elem.getAttribute(GSXML.SYSTEM_MODULE_NAME_ATT);
    656         String module_type = elem.getAttribute(GSXML.SYSTEM_MODULE_TYPE_ATT);
    657         if (action.equals(GSXML.SYSTEM_TYPE_ACTIVATE)) {
    658         Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, "activate action not yet implemented - does it even make sense in this context??");
    659         response.appendChild(s);
    660         } else if (action.equals(GSXML.SYSTEM_TYPE_DEACTIVATE)) {
    661         if (module_type.equals(GSXML.SERVICE_ELEM)) {
    662             // deactivate the service
    663             // remove from service_map
    664             this.service_map.remove(module_name);
    665             Element service_elem = GSXML.getNamedElement(this.service_list, GSXML.SERVICE_ELEM, GSXML.NAME_ATT, module_name);
    666             service_list.removeChild(service_elem);         
    667             message = module_type+": "+module_name+" deactivated";
    668         } else {
    669             message = "can't deactivate "+module_type+" type modules!";}
    670         Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, message);
    671         response.appendChild(s);
    672         } else {
    673         logger.error("cant process system request, action "+action);
    674         continue;
    675         }
    676     } // for each command
    677     return response;
    678     }
    679 
    680     /**
    681      * do a configure on only part of the collection
    682      */
    683     protected boolean configureSubset(String subset) {
    684    
    685     File configFile = new File(GSFile.siteConfigFile(this.site_home));
    686     if (!configFile.exists() ) {
    687         logger.error("site config file: "+configFile.getPath()+" not found!");
    688         // wont be able to do any of the requests
    689         return false;
    690        
    691     }
    692    
    693     Document site_config_doc  = this.converter.getDOM(configFile);
    694     if (site_config_doc == null) {
    695         logger.error("could not read in site config file: "+configFile.getPath());
    696         return false;
    697     }
    698    
    699     Element site_config_elem = site_config_doc.getDocumentElement();
    700     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);
    701     if (cluster_config_elem == null) {
    702         logger.error("site config file: "+configFile.getPath()+" has no element for cluster "+this.cluster_name);
    703         // wont be able to do any of teh requests
    704         return false;
    705        
    706     }
    707     if (subset.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
    708         Element service_rack_list = (Element)GSXML.getChildByTagName(cluster_config_elem, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
    709         clearServices();
    710         return configureServiceRackList(service_rack_list, null);
    711     } else if (subset.equals(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER)) {
    712         this.metadata_list = this.doc.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
    713         Element metadata_list = (Element)GSXML.getChildByTagName(cluster_config_elem, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
    714         return addMetadata(metadata_list);
    715     } else if (subset.equals(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER)) {
    716         this.plugin_item_list = this.doc.createElement(GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
    717         Element import_list = (Element)GSXML.getChildByTagName(cluster_config_elem,GSXML.IMPORT_ELEM);
    718         if (import_list != null)
    719         {
    720             Element plugin_item_list = (Element)GSXML.getChildByTagName(cluster_config_elem,GSXML.PLUGIN_ELEM+GSXML.LIST_MODIFIER);
    721             return addPlugins(plugin_item_list);
    722             }
    723         else
    724             return false;
    725     } else {
    726         logger.error("cannot process system request, configure "+subset);
    727         return false;
    728     }
    729 
    730     }
    731 
    732 
    733     protected boolean addAllDisplayInfo(Element description, String lang) {
    734    
    735     NodeList items = this.display_item_list.getChildNodes();
    736     for (int i=0; i<items.getLength(); i++) { // for each key
    737         Element m = (Element) items.item(i);
    738         // find the child with the correct language
    739         Element new_m = GSXML.getNamedElement(m, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, lang);
    740         if (new_m==null && lang != DEFAULT_LANG) {
    741         // use the default lang
    742         new_m = GSXML.getNamedElement(m, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, DEFAULT_LANG);
    743         }
    744         if (new_m==null) {
    745         // just get the first one
    746         new_m = (Element)GSXML.getChildByTagName(m, GSXML.DISPLAY_TEXT_ELEM);
    747         }
    748         description.appendChild(new_m.cloneNode(true));
    749     }
    750     return true;
    751    
    752     }
    753 
    754    
    755     protected Element getDisplayTextElement(String key, String lang) {
    756    
    757     Element this_item = GSXML.getNamedElement(this.display_item_list, GSXML.DISPLAY_TEXT_ELEM, GSXML.NAME_ATT, key);
    758     if (this_item == null) {
    759         return null;
    760     }
    761 
    762     Element this_lang = GSXML.getNamedElement(this_item, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, lang);
    763     if (this_lang == null && lang != DEFAULT_LANG) {
    764         // try the default
    765         this_lang = GSXML.getNamedElement(this_item, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, DEFAULT_LANG);
    766     }
    767     if (this_lang == null) {
    768         // just return the first one
    769         return GSXML.getFirstElementChild(this_item);//(Element)this_item.getFirstChild().cloneNode(true);
    770     }
    771     return (Element)this_lang.cloneNode(true);
    772    
    773     }
    774     public HashMap getServiceMap() {
    775         return service_map;
    776     }
     734
     735
     736    protected boolean addAllDisplayInfo(Element description, String lang) {
     737       
     738        NodeList items = this.display_item_list.getChildNodes();
     739        for (int i=0; i<items.getLength(); i++) { // for each key
     740            Element m = (Element) items.item(i);
     741            // find the child with the correct language
     742            Element new_m = GSXML.getNamedElement(m, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, lang);
     743            if (new_m==null && lang != DEFAULT_LANG) {
     744                // use the default lang
     745                new_m = GSXML.getNamedElement(m, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, DEFAULT_LANG);
     746            }
     747            if (new_m==null) {
     748                // just get the first one
     749                new_m = (Element)GSXML.getChildByTagName(m, GSXML.DISPLAY_TEXT_ELEM);
     750            }
     751            description.appendChild(new_m.cloneNode(true));
     752        }
     753        return true;
     754       
     755    }
     756
     757   
     758    protected Element getDisplayTextElement(String key, String lang) {
     759       
     760        Element this_item = GSXML.getNamedElement(this.display_item_list, GSXML.DISPLAY_TEXT_ELEM, GSXML.NAME_ATT, key);
     761        if (this_item == null) {
     762            return null;
     763        }
     764
     765        Element this_lang = GSXML.getNamedElement(this_item, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, lang);
     766        if (this_lang == null && lang != DEFAULT_LANG) {
     767            // try the default
     768            this_lang = GSXML.getNamedElement(this_item, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, DEFAULT_LANG);
     769        }
     770        if (this_lang == null) {
     771            // just return the first one
     772            return GSXML.getFirstElementChild(this_item);//(Element)this_item.getFirstChild().cloneNode(true);
     773        }
     774        return (Element)this_lang.cloneNode(true);
     775       
     776    }
     777    public HashMap getServiceMap() {
     778        return service_map;
     779    }
    777780}
    778781
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/service/ArchiveRetrieve.java

    r24211 r24221  
    11/*
    2 *    AbstractDocumentRetrieve.java
     2*    ArchiveRetrieve.java
    33*    a base class for retrieval services
    44
     
    2121package org.greenstone.gsdl3.service;
    2222
     23import org.greenstone.gsdl3.util.DBInfo;
    2324import org.greenstone.gsdl3.util.GSPath;
    2425import org.greenstone.gsdl3.util.GSXML;
     
    3132import java.io.File;
    3233import java.util.HashMap;
    33 
    34 /** Abstract class for Document Retrieval Services
    35 *
    36 * @author <a href="mailto:greenstone@cs.waikato.ac.nz">Katherine Don</a>
    37 */
    38 
    39 public class ArchiveRetrieve extends ServiceRack {
    40 
     34import java.util.Vector;
     35
     36public class ArchiveRetrieve extends ServiceRack
     37{
    4138    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.service.ArchiveRetrieve.class.getName());
    4239
    43     protected static final String ARCHIVE_FILE_PATH_RETRIEVE_SERVICE = "ArchiveFilePathRetrieve";
     40    protected static final String DOCUMENT_FILE_PATH_RETRIEVE_SERVICE = "DocumentFilePathRetrieve";
     41    protected static final String ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE = "AssociatedImportFilesRetrieve";
     42    protected static final String SOURCE_FILE_OID_RETRIEVE = "SourceFileOIDRetrieve";
    4443   
    4544    protected SimpleCollectionDatabase coll_db = null;
    46    
    47     /** constructor */
    48     public ArchiveRetrieve()
    49     {
    50     }
    5145
    5246    /** configure this service */
    5347    public boolean configure(Element info, Element extra_info)
    5448    {
    55         if (!super.configure(info, extra_info)){
     49        if (!super.configure(info, extra_info))
     50        {
    5651            return false;
    5752        }
     
    6055        this.config_info = info;
    6156       
    62         Element archiveFilePathRetrieveService = this.doc.createElement(GSXML.SERVICE_ELEM);
    63         archiveFilePathRetrieveService.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
    64         archiveFilePathRetrieveService.setAttribute(GSXML.NAME_ATT, ARCHIVE_FILE_PATH_RETRIEVE_SERVICE);
    65         this.short_service_info.appendChild(archiveFilePathRetrieveService);
     57        Element documentFilePathRetrieveService = this.doc.createElement(GSXML.SERVICE_ELEM);
     58        documentFilePathRetrieveService.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     59        documentFilePathRetrieveService.setAttribute(GSXML.NAME_ATT, DOCUMENT_FILE_PATH_RETRIEVE_SERVICE);
     60        this.short_service_info.appendChild(documentFilePathRetrieveService);
     61       
     62        Element associatedImportFilesRetrieveService = this.doc.createElement(GSXML.SERVICE_ELEM);
     63        associatedImportFilesRetrieveService.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     64        associatedImportFilesRetrieveService.setAttribute(GSXML.NAME_ATT, ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE);
     65        this.short_service_info.appendChild(associatedImportFilesRetrieveService);
     66       
     67        Element sourceFileDocIDRetrieveService = this.doc.createElement(GSXML.SERVICE_ELEM);
     68        sourceFileDocIDRetrieveService.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     69        sourceFileDocIDRetrieveService.setAttribute(GSXML.NAME_ATT, SOURCE_FILE_OID_RETRIEVE);
     70        this.short_service_info.appendChild(sourceFileDocIDRetrieveService);
    6671       
    6772        return true;
     
    7075    protected Element getServiceDescription(String service_id, String lang, String subset)
    7176    {
    72         Element service_elem = this.doc.createElement(GSXML.SERVICE_ELEM);
    73         service_elem.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
    74         service_elem.setAttribute(GSXML.NAME_ATT, ARCHIVE_FILE_PATH_RETRIEVE_SERVICE);
    75         return service_elem;
    76     }
    77    
    78     protected Element processArchiveFilePathRetrieve(Element request)
     77        if (service_id.equals(DOCUMENT_FILE_PATH_RETRIEVE_SERVICE))
     78        {
     79            Element service_elem = this.doc.createElement(GSXML.SERVICE_ELEM);
     80            service_elem.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     81            service_elem.setAttribute(GSXML.NAME_ATT, DOCUMENT_FILE_PATH_RETRIEVE_SERVICE);
     82            return service_elem;
     83        }
     84        else if (service_id.equals(ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE))
     85        {
     86            Element service_elem = this.doc.createElement(GSXML.SERVICE_ELEM);
     87            service_elem.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     88            service_elem.setAttribute(GSXML.NAME_ATT, ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE);
     89            return service_elem;
     90        }
     91        else if (service_id.equals(SOURCE_FILE_OID_RETRIEVE))
     92        {
     93            Element service_elem = this.doc.createElement(GSXML.SERVICE_ELEM);
     94            service_elem.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     95            service_elem.setAttribute(GSXML.NAME_ATT, SOURCE_FILE_OID_RETRIEVE);
     96            return service_elem;
     97        }
     98        return null;
     99    }
     100   
     101    protected Element processDocumentFilePathRetrieve(Element request)
    79102    {
    80103        // Create a new (empty) result message
    81104        Element result = this.doc.createElement(GSXML.RESPONSE_ELEM);
    82         result.setAttribute(GSXML.FROM_ATT, ARCHIVE_FILE_PATH_RETRIEVE_SERVICE);
     105        result.setAttribute(GSXML.FROM_ATT, DOCUMENT_FILE_PATH_RETRIEVE_SERVICE);
    83106        result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
    84107       
     
    89112        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    90113        if (param_list == null) {
    91             GSXML.addError(this.doc, result, "DocumentMetadataRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
     114            GSXML.addError(this.doc, result, "DocumentFilePathRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
    92115            return result; 
    93116        }
    94117        HashMap params = GSXML.extractParams(param_list, false);
    95118       
    96         String docID = (String) params.get("docID");
     119        String oid = (String) params.get("oid");
    97120        String collection = (String) params.get("c");
    98121       
    99         String assocFilePath = getAssocFilePathFromDocID(docID, collection, lang, uid);
     122        String assocFilePath = getAssocFilePathFromDocID(oid, collection, lang, uid);
    100123       
    101124        String docFilePath = this.site_home + File.separatorChar +
     
    105128            assocFilePath + File.separatorChar +
    106129            "doc.xml";
    107        
    108         Element metaElem = this.doc.createElement(GSXML.METADATA_ELEM);
    109         metaElem.setAttribute("name", "docFilePath");
    110         metaElem.setAttribute("value", docFilePath);
    111        
    112         logger.error("DOCFILEPATH = " + docFilePath);
    113        
    114         result.appendChild(metaElem);
     130
     131        Element metadataList = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
     132        metadataList.appendChild(createMetadataElement("docfilepath", docFilePath));
     133        result.appendChild(metadataList);
    115134       
    116135        return result;
    117136    }
    118137   
    119     protected Element processArchiveAssociatedImportFilesRetrieve(Element request)
    120     {
    121         // find out what kind of database we have
    122         //Element database_type_elem = (Element) GSXML.getChildByTagName(this.config_info, GSXML.DATABASE_TYPE_ELEM);
    123         //String database_type = "jdbm";
    124         /*if (database_type_elem != null) {
    125             database_type = database_type_elem.getAttribute(GSXML.NAME_ATT);
    126         }
    127         if (database_type == null || database_type.equals("")) {
    128             database_type = "gdbm"; // the default
    129         }
    130        
    131         String db_ext = null;
    132         if (database_type.equalsIgnoreCase("jdbm")) {
    133             db_ext = ".jdb";
    134         } else {
    135             db_ext = ".gdb"; // assume gdbm
    136         }
    137        
    138        
    139                 coll_db = new SimpleCollectionDatabase(database_type);
    140         if (!coll_db.databaseOK()) {
    141             logger.error("Couldn't create the collection database of type "+database_type);
     138    protected Element processSourceFileOIDRetrieveService(Element request)
     139    {
     140        //Create a new (empty) result message
     141        Element result = this.doc.createElement(GSXML.RESPONSE_ELEM);
     142        result.setAttribute(GSXML.FROM_ATT, SOURCE_FILE_OID_RETRIEVE);
     143        result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
     144       
     145        String lang = request.getAttribute(GSXML.LANG_ATT);
     146        String uid = request.getAttribute(GSXML.USER_ID_ATT);
     147       
     148        // Get the parameters of the request
     149        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     150        if (param_list == null)
     151        {
     152            GSXML.addError(this.doc, result, "DocumentFilePathRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
     153            return result; 
     154        }
     155        HashMap params = GSXML.extractParams(param_list, false);
     156       
     157        String srcFile = (String) params.get("srcfile");
     158        String collection = (String) params.get("c");
     159       
     160        //Find out what kind of database we have
     161        String databaseType = getDatabaseTypeFromCollection(collection, lang, uid);
     162        if (databaseType == null || databaseType.equals(""))
     163        {
     164            databaseType = "gdbm"; // the default
     165        }
     166       
     167        String dbExt = null;
     168        if (databaseType.equalsIgnoreCase("jdbm"))
     169        {
     170            dbExt = ".jdb";
     171        }
     172        else
     173        {
     174            dbExt = ".gdb"; // assume gdbm
     175        }
     176       
     177        coll_db = new SimpleCollectionDatabase(databaseType);
     178        if (!coll_db.databaseOK())
     179        {
     180            logger.error("Couldn't create the collection database of type "+databaseType);
    142181            return null;
    143182        }
    144         */
    145    
    146             /*coll_db.openDatabase(
     183
     184        coll_db.openDatabase
     185        (
    147186            this.site_home + File.separatorChar +
    148187            "collect" + File.separatorChar +
    149188            collection + File.separatorChar +
    150189            "archives" + File.separatorChar +
    151             "archiveinf-doc" + db_ext,
    152             SimpleCollectionDatabase.READ);
    153        
    154         logger.error("STUFF " + coll_db.getInfo(docID));
    155        
    156         coll_db.getInfo(docID);*/
    157         return null;
    158     }
    159    
    160     public String getAssocFilePathFromDocID(String docID, String collection, String lang, String uid)
     190            "archiveinf-src" + dbExt,
     191            SimpleCollectionDatabase.READ
     192        );
     193       
     194        DBInfo info = coll_db.getInfo(srcFile);
     195       
     196        if (info == null)
     197        {
     198            return result;
     199        }
     200       
     201        String oid = info.getInfo("oid");
     202       
     203        Element metadataList = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
     204        metadataList.appendChild(createMetadataElement("oid", oid));
     205        result.appendChild(metadataList);
     206       
     207        return result;
     208    }
     209   
     210    protected Element processAssociatedImportFilesRetrieve(Element request)
     211    {
     212        //Create a new (empty) result message
     213        Element result = this.doc.createElement(GSXML.RESPONSE_ELEM);
     214        result.setAttribute(GSXML.FROM_ATT, ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE);
     215        result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
     216       
     217        String lang = request.getAttribute(GSXML.LANG_ATT);
     218        String uid = request.getAttribute(GSXML.USER_ID_ATT);
     219       
     220        // Get the parameters of the request
     221        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     222        if (param_list == null)
     223        {
     224            GSXML.addError(this.doc, result, "AssociatedImportFilesRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
     225            return result; 
     226        }
     227        HashMap params = GSXML.extractParams(param_list, false);
     228       
     229        String oid = (String) params.get("oid");
     230        String collection = (String) params.get("c");
     231       
     232        String databaseType = getDatabaseTypeFromCollection(collection, lang, uid);
     233        if (databaseType == null || databaseType.equals(""))
     234        {
     235            databaseType = "gdbm"; // the default
     236        }
     237       
     238        String dbExt = null;
     239        if (databaseType.equalsIgnoreCase("jdbm"))
     240        {
     241            dbExt = ".jdb";
     242        }
     243        else
     244        {
     245            dbExt = ".gdb"; // assume gdbm
     246        }
     247       
     248        coll_db = new SimpleCollectionDatabase(databaseType);
     249        if (!coll_db.databaseOK())
     250        {
     251            logger.error("Couldn't create the collection database of type "+databaseType);
     252            return null;
     253        }
     254
     255        coll_db.openDatabase
     256        (
     257            this.site_home + File.separatorChar +
     258            "collect" + File.separatorChar +
     259            collection + File.separatorChar +
     260            "archives" + File.separatorChar +
     261            "archiveinf-doc" + dbExt,
     262            SimpleCollectionDatabase.READ
     263        );
     264       
     265        DBInfo info = coll_db.getInfo(oid);
     266       
     267        if (info == null)
     268        {
     269            return result;
     270        }
     271       
     272        String srcFile = info.getInfo("src-file");
     273        Vector data = info.getMultiInfo("assoc-file");
     274       
     275        Element metadataList = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
     276        metadataList.appendChild(createMetadataElement("srcfile", srcFile));
     277       
     278        for (int i = 0; i < data.size(); i++)
     279        {
     280            metadataList.appendChild(createMetadataElement("assocfile", (String)data.get(i)));
     281        }
     282       
     283        result.appendChild(metadataList);
     284       
     285        return result;
     286    }
     287   
     288    public Element createMetadataElement(String name, String value)
     289    {
     290        Element metaElem = this.doc.createElement(GSXML.METADATA_ELEM);
     291        metaElem.setAttribute("name", name);
     292        metaElem.setAttribute("value", value);
     293        return metaElem;
     294    }
     295   
     296    public String getAssocFilePathFromDocID(String oid, String collection, String lang, String uid)
    161297    {
    162298        Element mr_query_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
     
    165301       
    166302        Element paramList = this.doc.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    167 
    168         Element assocParam = this.doc.createElement(GSXML.PARAM_ELEM);
    169         assocParam.setAttribute("name", "metadata");
    170         assocParam.setAttribute("value", "assocfilepath");
    171         paramList.appendChild(assocParam);
     303        paramList.appendChild(createMetadataElement("metadata", "assocfilepath"));
    172304       
    173305        mr_query_request.appendChild(paramList);
    174306
    175         Element docList = this.doc.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
    176         Element doc = this.doc.createElement(GSXML.DOC_NODE_ELEM);
    177         doc.setAttribute(GSXML.NODE_ID_ATT, docID);
    178         docList.appendChild(doc);
    179         mr_query_request.appendChild(docList);
     307        Element docListElem = this.doc.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
     308        Element docElem = this.doc.createElement(GSXML.DOC_NODE_ELEM);
     309        docElem.setAttribute(GSXML.NODE_ID_ATT, oid);
     310        docListElem.appendChild(docElem);
     311        mr_query_request.appendChild(docListElem);
    180312
    181313        Element response = (Element) this.router.process(mr_query_message);
     
    189321        return metadataElem.getFirstChild().getNodeValue();
    190322    }
     323   
     324    public String getDatabaseTypeFromCollection(String collection, String lang, String uid)
     325    {
     326        //Find out what kind of database we have
     327        Element dbTypeMessage = this.doc.createElement(GSXML.MESSAGE_ELEM);
     328        Element dbTypeRequest = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE, collection, lang, uid);
     329        dbTypeMessage.appendChild(dbTypeRequest);
     330        Element dbTypeResponse = (Element)this.router.process(dbTypeMessage);
     331       
     332        String path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.COLLECTION_ELEM);
     333        Element collectionElem = (Element) GSXML.getNodeByPath(dbTypeResponse, path);
     334       
     335        if (collectionElem != null)
     336        {
     337            return collectionElem.getAttribute(GSXML.DB_TYPE_ATT);
     338        }
     339        return null;
     340    }
    191341}   
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/service/BerryBasket.java

    r23814 r24221  
    287287    // Get the parameters of the request
    288288    Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    289        
    290         //GSXML.printXMLNode(param_list);
    291289
    292290    if (param_list == null) {
     
    336334    // Get the parameters of the request
    337335    Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    338        
    339         //GSXML.printXMLNode(param_list);
    340336
    341337    if (param_list == null) {
     
    375371
    376372    protected Element processItemNum(Element request){
    377         // GSXML.printXMLNode(request);
    378373    Hashtable docsMap = updateDocMap(request);
    379374
     
    489484        // Get the parameters of the request
    490485        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    491        
    492         GSXML.printXMLNode(param_list);
    493486       
    494487        if (param_list == null) {
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/util/GSXML.java

    r24214 r24221  
    8585  public static final String DOC_TYPE_ELEM = "docType";
    8686  public static final String SEARCH_ELEM = "search";
     87  public static final String INFODB_ELEM = "infodb";
    8788  public static final String INDEX_ELEM = "index";
    8889  public static final String INDEX_STEM_ELEM = "indexStem";
     
    125126  public static final String LANG_ATT = "lang";
    126127  public static final String TYPE_ATT = "type";
     128  public static final String DB_TYPE_ATT = "dbType";
    127129  public static final String VALUE_ATT = "value";
    128130  public static final String DEFAULT_ATT = "default";
     
    920922  }
    921923 
    922   public static void printXMLNode(Node e) {
    923     printXMLNode(e, 0) ;
     924  public static void printXMLNode(Node e, boolean printText) {
     925    printXMLNode(e, 0, printText) ;
    924926  }
    925927 
     
    977979  }
    978980 
    979   public static void printXMLNode(Node e, int depth) { //recursive method call using DOM API...
    980    
     981  public static void printXMLNode(Node e, int depth, boolean printText) { //recursive method call using DOM API...
     982   
     983    if(e == null){return;}
     984   
    981985    for (int i=0 ; i<depth ; i++)
    982986      System.out.print(' ') ;
    983987   
    984988    if (e.getNodeType() == Node.TEXT_NODE){
    985       // shouldn't we actually print the text here????
    986       System.out.println("text") ;
     989      if(printText){
     990        System.out.println(e.getNodeValue());
     991      }
     992      else {
     993        System.out.println("text");
     994      }
    987995      return ;
    988996    }
     
    10141022      int len = children.getLength();
    10151023      for (int i = 0; i < len; i++) {
    1016         printXMLNode(children.item(i), depth + 1);
     1024        printXMLNode(children.item(i), depth + 1, printText);
    10171025      }
    10181026     
Note: See TracChangeset for help on using the changeset viewer.