Changeset 25090

Show
Ignore:
Timestamp:
15.02.2012 15:01:19 (8 years ago)
Author:
sjm84
Message:

Reformatting this file ahead of some changes

Files:
1 modified

Legend:

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

    r23405 r25090  
    55import org.greenstone.gsdl3.action.*; 
    66// XML classes 
    7 import org.w3c.dom.Node;  
    8 import org.w3c.dom.NodeList;  
    9 import org.w3c.dom.Document;  
    10 import org.w3c.dom.Element;  
     7import org.w3c.dom.Node; 
     8import org.w3c.dom.NodeList; 
     9import org.w3c.dom.Document; 
     10import org.w3c.dom.Element; 
    1111 
    1212// other java classes 
     
    1818import org.apache.log4j.*; 
    1919 
    20 /** the most basic Receptionist, used for interface generation.  
    21  * Receives requests consisting 
    22  * of an xml representation of cgi args, and returns the page of data. The requests are processed by the appropriate action class 
    23  * 
     20/** 
     21 * the most basic Receptionist, used for interface generation. Receives requests 
     22 * consisting of an xml representation of cgi args, and returns the page of 
     23 * data. The requests are processed by the appropriate action class 
     24 *  
    2425 * @see Action 
    2526 */ 
    26 public class Receptionist implements ModuleInterface { 
    27  
    28      static Logger logger = Logger.getLogger(org.greenstone.gsdl3.core.Receptionist.class.getName()); 
    29  
    30     /** the set up variables */ 
    31     protected HashMap config_params = null; 
    32     /** container Document to create XML Nodes */ 
    33     protected Document doc=null;  
    34     
    35     /** a converter class to parse XML and create Docs */ 
    36     protected XMLConverter converter=null; 
    37  
    38     /** the message router that the Receptionist and Actions will talk to */ 
    39     protected ModuleInterface mr=null; 
    40  
    41     /** the list of actions */ 
    42     protected HashMap action_map=null; 
    43      
    44     /** the list of params */ 
    45     protected GSParams params=null; 
    46     protected Element language_list = null; 
    47  
    48     /** the list of interfaces this is based on */ 
    49     protected ArrayList base_interfaces = null; 
    50      
    51     public Receptionist() { 
    52     this.converter = new XMLConverter(); 
    53     this.doc = this.converter.newDOM(); 
    54     this.action_map= new HashMap(); 
    55     } 
    56      
    57     public void cleanUp() {} 
    58     public void setParams(GSParams params) { 
    59     this.params = params; 
    60     } 
    61     public void setConfigParams(HashMap params) { 
    62     this.config_params = params; 
    63     } 
    64     public HashMap getConfigParams() { 
    65         return this.config_params; 
    66     } 
    67     /** sets the message router  - it should already be created and  
    68      * configured before  being passed to the receptionist*/ 
    69     public void setMessageRouter(ModuleInterface m) { 
    70        this.mr = m; 
    71     } 
    72  
    73     /** configures the receptionist */ 
    74     public boolean configure() { 
    75  
    76     if (this.config_params==null) { 
    77         logger.error(" config variables must be set before calling configure"); 
    78         return false; 
    79     } 
    80     if (this.mr==null) {        
    81         logger.error(" message router must be set  before calling configure"); 
    82         return false; 
    83     } 
    84  
    85     // find the config file containing a list of actions 
    86     File interface_config_file = new File(GSFile.interfaceConfigFile(GSFile.interfaceHome(GlobalProperties.getGSDL3Home(), (String)this.config_params.get(GSConstants.INTERFACE_NAME)))); 
    87     if (!interface_config_file.exists()) { 
    88         logger.error(" interface config file: "+interface_config_file.getPath()+" not found!"); 
    89         return false; 
    90     } 
    91      
    92     Document config_doc = this.converter.getDOM(interface_config_file); 
    93     if (config_doc == null) { 
    94         logger.error(" could not parse interface config file: "+interface_config_file.getPath()); 
    95         return false; 
    96     } 
    97     Element config_elem = config_doc.getDocumentElement(); 
    98     String base_interface = config_elem.getAttribute("baseInterface"); 
    99     setUpBaseInterface(base_interface); 
    100     setUpInterfaceOptions(config_elem); 
    101  
    102     // load up the actions 
    103     Element action_list = (Element)GSXML.getChildByTagName(config_elem, GSXML.ACTION_ELEM+GSXML.LIST_MODIFIER); 
    104     NodeList actions = action_list.getElementsByTagName(GSXML.ACTION_ELEM); 
    105  
    106     for (int i=0; i<actions.getLength(); i++) { 
    107         Element action = (Element) actions.item(i); 
    108         String class_name = action.getAttribute("class"); 
    109         String action_name = action.getAttribute("name"); 
    110         Action ac = null; 
    111         try { 
    112         ac = (Action)Class.forName("org.greenstone.gsdl3.action."+class_name).newInstance(); 
    113         } catch (Exception e) { 
    114         logger.error(" couldn't load in action "+class_name); 
    115         e.printStackTrace(); 
    116         continue; 
    117         } 
    118         ac.setConfigParams(this.config_params); 
    119         ac.setMessageRouter(this.mr); 
    120         ac.configure(); 
    121         ac.getActionParameters(this.params); 
    122         this.action_map.put(action_name, ac); 
    123     } 
    124  
    125     this.language_list = (Element)GSXML.getChildByTagName(config_elem, "languageList"); 
    126     if (language_list == null) { 
    127         logger.error(" didn't find a language list in the config file!!"); 
    128     } 
    129  
    130     return true; 
    131     } 
    132  
    133  
    134  
    135     public String process(String xml_in) { 
    136  
    137     Node message_node = this.converter.getDOM(xml_in); 
    138     Node page = process(message_node); 
    139     return this.converter.getString(page); 
    140     } 
    141  
    142  
    143     /** process - produce a page of data in response to a request  
    144      * if something goes wrong, it returns null -  
    145      * TODO:  return a suitable message to the user */ 
    146     public Node process(Node message_node) { 
    147  
    148     Element message = this.converter.nodeToElement(message_node); 
    149  
    150     // get the request out of the message - assume that there is only one 
    151     Element request = (Element)GSXML.getChildByTagName(message, GSXML.REQUEST_ELEM); 
    152     if (request == null) { 
    153         logger.error(" message had no request!"); 
    154         return null;  
    155     } 
    156     // check the request type  
    157     String type = request.getAttribute(GSXML.TYPE_ATT); // returns "" if no att of this name 
    158     if (!type.equals(GSXML.REQUEST_TYPE_PAGE)) {  
    159         // now Receptionist forwards non-page requests straight to the MR, and returns the responses 
    160         logger.error(" request type is not '"+GSXML.REQUEST_TYPE_PAGE+"', but it is '"+type+"', so forwarding the message to the MR!"); 
    161         // process the whole message - mr needs <message> tags, and  
    162         // in this case, there may be more than one request in the message 
    163         return this.mr.process(message); 
    164     }    
    165     // work out which action to pass to 
    166     String action = request.getAttribute(GSXML.ACTION_ATT); 
    167     if (action.equals("")) { 
    168         logger.error(" no action specified in the request!"); 
    169         return null; 
    170     } 
    171      
    172     // find the  appropriate action  
    173     Action a = (Action)this.action_map.get(action); 
    174      
    175     String action_name=null; 
    176     if (a==null) { // not in the map yet 
    177         // try to load a new action 
    178         try { 
    179         action_name = action.substring(0,1).toUpperCase()+action.substring(1)+"Action"; 
    180         Action ac = (Action)Class.forName("org.greenstone.gsdl3.action."+action_name).newInstance(); 
    181         ac.setConfigParams(this.config_params); 
    182         ac.setMessageRouter(this.mr); 
    183         ac.configure(); 
    184         ac.getActionParameters(this.params); 
    185         this.action_map.put(action, ac); 
    186         a = ac; 
    187         } catch (Exception e) { 
    188          
    189         logger.error(" a new action ("+action_name+") was specified and it couldn't be created. Error message:"+e.getMessage()); 
    190         return null; 
    191         } 
    192     } 
    193  
    194     // transform the request in some way -- does nothing! 
    195     preProcessRequest(request); 
    196     // set up the page 
    197     Element page = this.doc.createElement(GSXML.PAGE_ELEM); 
    198     page.setAttribute(GSXML.LANG_ATT, request.getAttribute(GSXML.LANG_ATT)); 
    199     // just in case these namespaces end up in the page and we want to display the XML 
    200     page.setAttribute("xmlns:gsf","http://www.greenstone.org/greenstone3/schema/ConfigFormat"); 
    201     page.setAttribute("xmlns:xsl", "http://www.w3.org/1999/XSL/Transform"); 
    202      
    203     //logger.info(a+" mesa=" + this.converter.getPrettyString(message)); 
    204     // get the page data from the action 
    205     Node action_response = a.process(message); 
    206  
    207     boolean response_only=false; 
    208     Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER); 
    209     if (param_list != null) { 
    210         Element param = GSXML.getNamedElement(param_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, "ro"); 
    211         if (param != null) { 
    212         String value = param.getAttribute("value"); 
    213         if (value.equals("1")) { 
    214             response_only = true; 
    215         } 
    216         } 
    217     } 
    218     if (response_only) { 
    219         // only the response from the action is sent back 
    220         return action_response; 
    221     } 
    222      
    223     // the request is part of the page 
    224     page.appendChild(GSXML.duplicateWithNewName(this.doc, request, GSXML.PAGE_REQUEST_ELEM, true)); 
    225     // add the response too 
    226     Element page_response = GSXML.duplicateWithNewName(this.doc, (Element)GSXML.getChildByTagName(action_response, GSXML.RESPONSE_ELEM), GSXML.PAGE_RESPONSE_ELEM, true); 
    227     page.appendChild(page_response); 
    228  
    229     //logger.info(" raw page="+this.converter.getString(page)); 
    230     // transform the result in some way 
    231     //Element resulting_page = postProcessPage(page); 
    232  
    233     Node resulting_page = postProcessPage(page); 
    234  
    235     logger.debug("receptionist returned response"); 
    236     //logger.error("receptionist returned response"); 
    237     logger.debug(this.converter.getString(resulting_page)); 
    238     //logger.error(this.converter.getString(resulting_page)); 
    239 //    logger.info("receptionist returned response"); 
    240 //    logger.info(this.converter.getString(resulting_page)); 
    241  
    242     return resulting_page; 
    243      
    244     } 
    245  
    246     protected boolean setUpBaseInterface(String base_interface) { 
    247     if (base_interface== null || base_interface.equals("")) { 
    248         // there was no base interface, the list remains null 
    249         return true; 
    250     } 
    251     // foreach base interface 
    252     while (!base_interface.equals("")) { 
    253         // find the base interface config file 
    254         File base_interface_config_file = new File(GSFile.interfaceConfigFile(GSFile.interfaceHome(GlobalProperties.getGSDL3Home(), base_interface))); 
    255         if (!base_interface_config_file.exists()) { 
    256         logger.error(" base interface config file: "+base_interface_config_file.getPath()+" not found!"); 
    257         return false; 
    258         } 
    259         // the interface name is valid, add it to the list 
    260         if (base_interfaces == null) { 
    261         base_interfaces = new ArrayList(); 
    262         } 
    263         base_interfaces.add(base_interface); 
    264         // now see if this has a base interface 
    265         Document config_doc = this.converter.getDOM(base_interface_config_file); 
    266         if (config_doc == null) { 
    267         logger.error(" could not parse base interface config file: "+base_interface_config_file.getPath()); 
    268         return false; 
    269         } 
    270         Element config_elem = config_doc.getDocumentElement(); 
    271         base_interface = config_elem.getAttribute("baseInterface"); 
    272     } 
    273     return true; 
    274     } 
    275  
    276     protected boolean setUpInterfaceOptions(Element config_elem) { 
    277     Element option_list = (Element)GSXML.getChildByTagName(config_elem, "optionList"); 
    278     if (option_list != null) { 
    279         logger.debug("found an interface optionList"); 
    280         // we set any options in the config params 
    281         NodeList options = option_list.getElementsByTagName("option"); 
    282         for (int i=0; i<options.getLength(); i++) { 
    283         Element option = (Element)options.item(i); 
    284         String name = option.getAttribute(GSXML.NAME_ATT); 
    285         String value = option.getAttribute(GSXML.VALUE_ATT); 
    286         logger.debug("option: "+name+", "+value); 
    287         if (!name.equals("") && !value.equals("")) { 
    288             this.config_params.put(name, value); 
    289         } 
    290         } 
    291     } 
    292  
    293     return true; 
    294     } 
    295  
    296     protected void preProcessRequest(Element request) { 
    297     return; 
    298     } 
    299  
    300     protected Node postProcessPage(Element page) { 
    301     return page; 
    302     } 
    303      
     27public class Receptionist implements ModuleInterface 
     28{ 
     29 
     30    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.core.Receptionist.class.getName()); 
     31 
     32    /** the set up variables */ 
     33    protected HashMap config_params = null; 
     34    /** container Document to create XML Nodes */ 
     35    protected Document doc = null; 
     36 
     37    /** a converter class to parse XML and create Docs */ 
     38    protected XMLConverter converter = null; 
     39 
     40    /** the message router that the Receptionist and Actions will talk to */ 
     41    protected ModuleInterface mr = null; 
     42 
     43    /** the list of actions */ 
     44    protected HashMap action_map = null; 
     45 
     46    /** the list of params */ 
     47    protected GSParams params = null; 
     48    protected Element language_list = null; 
     49 
     50    /** the list of interfaces this is based on */ 
     51    protected ArrayList base_interfaces = null; 
     52 
     53    public Receptionist() 
     54    { 
     55        this.converter = new XMLConverter(); 
     56        this.doc = this.converter.newDOM(); 
     57        this.action_map = new HashMap(); 
     58    } 
     59 
     60    public void cleanUp() 
     61    { 
     62    } 
     63 
     64    public void setParams(GSParams params) 
     65    { 
     66        this.params = params; 
     67    } 
     68 
     69    public void setConfigParams(HashMap params) 
     70    { 
     71        this.config_params = params; 
     72    } 
     73 
     74    public HashMap getConfigParams() 
     75    { 
     76        return this.config_params; 
     77    } 
     78 
     79    /** 
     80     * sets the message router - it should already be created and configured 
     81     * before being passed to the receptionist 
     82     */ 
     83    public void setMessageRouter(ModuleInterface m) 
     84    { 
     85        this.mr = m; 
     86    } 
     87 
     88    /** configures the receptionist */ 
     89    public boolean configure() 
     90    { 
     91 
     92        if (this.config_params == null) 
     93        { 
     94            logger.error(" config variables must be set before calling configure"); 
     95            return false; 
     96        } 
     97        if (this.mr == null) 
     98        { 
     99            logger.error(" message router must be set  before calling configure"); 
     100            return false; 
     101        } 
     102 
     103        // find the config file containing a list of actions 
     104        File interface_config_file = new File(GSFile.interfaceConfigFile(GSFile.interfaceHome(GlobalProperties.getGSDL3Home(), (String) this.config_params.get(GSConstants.INTERFACE_NAME)))); 
     105        if (!interface_config_file.exists()) 
     106        { 
     107            logger.error(" interface config file: " + interface_config_file.getPath() + " not found!"); 
     108            return false; 
     109        } 
     110 
     111        Document config_doc = this.converter.getDOM(interface_config_file); 
     112        if (config_doc == null) 
     113        { 
     114            logger.error(" could not parse interface config file: " + interface_config_file.getPath()); 
     115            return false; 
     116        } 
     117        Element config_elem = config_doc.getDocumentElement(); 
     118        String base_interface = config_elem.getAttribute("baseInterface"); 
     119        setUpBaseInterface(base_interface); 
     120        setUpInterfaceOptions(config_elem); 
     121 
     122        // load up the actions 
     123        Element action_list = (Element) GSXML.getChildByTagName(config_elem, GSXML.ACTION_ELEM + GSXML.LIST_MODIFIER); 
     124        NodeList actions = action_list.getElementsByTagName(GSXML.ACTION_ELEM); 
     125 
     126        for (int i = 0; i < actions.getLength(); i++) 
     127        { 
     128            Element action = (Element) actions.item(i); 
     129            String class_name = action.getAttribute("class"); 
     130            String action_name = action.getAttribute("name"); 
     131            Action ac = null; 
     132            try 
     133            { 
     134                ac = (Action) Class.forName("org.greenstone.gsdl3.action." + class_name).newInstance(); 
     135            } 
     136            catch (Exception e) 
     137            { 
     138                logger.error(" couldn't load in action " + class_name); 
     139                e.printStackTrace(); 
     140                continue; 
     141            } 
     142            ac.setConfigParams(this.config_params); 
     143            ac.setMessageRouter(this.mr); 
     144            ac.configure(); 
     145            ac.getActionParameters(this.params); 
     146            this.action_map.put(action_name, ac); 
     147        } 
     148 
     149        this.language_list = (Element) GSXML.getChildByTagName(config_elem, "languageList"); 
     150        if (language_list == null) 
     151        { 
     152            logger.error(" didn't find a language list in the config file!!"); 
     153        } 
     154 
     155        return true; 
     156    } 
     157 
     158    public String process(String xml_in) 
     159    { 
     160 
     161        Node message_node = this.converter.getDOM(xml_in); 
     162        Node page = process(message_node); 
     163        return this.converter.getString(page); 
     164    } 
     165 
     166    /** 
     167     * process - produce a page of data in response to a request if something 
     168     * goes wrong, it returns null - TODO: return a suitable message to the user 
     169     */ 
     170    public Node process(Node message_node) 
     171    { 
     172 
     173        Element message = this.converter.nodeToElement(message_node); 
     174 
     175        // get the request out of the message - assume that there is only one 
     176        Element request = (Element) GSXML.getChildByTagName(message, GSXML.REQUEST_ELEM); 
     177        if (request == null) 
     178        { 
     179            logger.error(" message had no request!"); 
     180            return null; 
     181        } 
     182        // check the request type  
     183        String type = request.getAttribute(GSXML.TYPE_ATT); // returns "" if no att of this name 
     184        if (!type.equals(GSXML.REQUEST_TYPE_PAGE)) 
     185        { 
     186            // now Receptionist forwards non-page requests straight to the MR, and returns the responses 
     187            logger.error(" request type is not '" + GSXML.REQUEST_TYPE_PAGE + "', but it is '" + type + "', so forwarding the message to the MR!"); 
     188            // process the whole message - mr needs <message> tags, and  
     189            // in this case, there may be more than one request in the message 
     190            return this.mr.process(message); 
     191        } 
     192        // work out which action to pass to 
     193        String action = request.getAttribute(GSXML.ACTION_ATT); 
     194        if (action.equals("")) 
     195        { 
     196            logger.error(" no action specified in the request!"); 
     197            return null; 
     198        } 
     199 
     200        // find the  appropriate action  
     201        Action a = (Action) this.action_map.get(action); 
     202 
     203        String action_name = null; 
     204        if (a == null) 
     205        { // not in the map yet 
     206            // try to load a new action 
     207            try 
     208            { 
     209                action_name = action.substring(0, 1).toUpperCase() + action.substring(1) + "Action"; 
     210                Action ac = (Action) Class.forName("org.greenstone.gsdl3.action." + action_name).newInstance(); 
     211                ac.setConfigParams(this.config_params); 
     212                ac.setMessageRouter(this.mr); 
     213                ac.configure(); 
     214                ac.getActionParameters(this.params); 
     215                this.action_map.put(action, ac); 
     216                a = ac; 
     217            } 
     218            catch (Exception e) 
     219            { 
     220 
     221                logger.error(" a new action (" + action_name + ") was specified and it couldn't be created. Error message:" + e.getMessage()); 
     222                return null; 
     223            } 
     224        } 
     225 
     226        // transform the request in some way -- does nothing! 
     227        preProcessRequest(request); 
     228        // set up the page 
     229        Element page = this.doc.createElement(GSXML.PAGE_ELEM); 
     230        page.setAttribute(GSXML.LANG_ATT, request.getAttribute(GSXML.LANG_ATT)); 
     231        // just in case these namespaces end up in the page and we want to display the XML 
     232        page.setAttribute("xmlns:gsf", "http://www.greenstone.org/greenstone3/schema/ConfigFormat"); 
     233        page.setAttribute("xmlns:xsl", "http://www.w3.org/1999/XSL/Transform"); 
     234 
     235        //logger.info(a+" mesa=" + this.converter.getPrettyString(message)); 
     236        // get the page data from the action 
     237        Node action_response = a.process(message); 
     238 
     239        boolean response_only = false; 
     240        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER); 
     241        if (param_list != null) 
     242        { 
     243            Element param = GSXML.getNamedElement(param_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, "ro"); 
     244            if (param != null) 
     245            { 
     246                String value = param.getAttribute("value"); 
     247                if (value.equals("1")) 
     248                { 
     249                    response_only = true; 
     250                } 
     251            } 
     252        } 
     253        if (response_only) 
     254        { 
     255            // only the response from the action is sent back 
     256            return action_response; 
     257        } 
     258 
     259        // the request is part of the page 
     260        page.appendChild(GSXML.duplicateWithNewName(this.doc, request, GSXML.PAGE_REQUEST_ELEM, true)); 
     261        // add the response too 
     262        Element page_response = GSXML.duplicateWithNewName(this.doc, (Element) GSXML.getChildByTagName(action_response, GSXML.RESPONSE_ELEM), GSXML.PAGE_RESPONSE_ELEM, true); 
     263        page.appendChild(page_response); 
     264 
     265        //logger.info(" raw page="+this.converter.getString(page)); 
     266        // transform the result in some way 
     267        //Element resulting_page = postProcessPage(page); 
     268 
     269        Node resulting_page = postProcessPage(page); 
     270 
     271        logger.debug("receptionist returned response"); 
     272        //logger.error("receptionist returned response"); 
     273        logger.debug(this.converter.getString(resulting_page)); 
     274        //logger.error(this.converter.getString(resulting_page)); 
     275        //    logger.info("receptionist returned response"); 
     276        //    logger.info(this.converter.getString(resulting_page)); 
     277 
     278        return resulting_page; 
     279 
     280    } 
     281 
     282    protected boolean setUpBaseInterface(String base_interface) 
     283    { 
     284        if (base_interface == null || base_interface.equals("")) 
     285        { 
     286            // there was no base interface, the list remains null 
     287            return true; 
     288        } 
     289        // foreach base interface 
     290        while (!base_interface.equals("")) 
     291        { 
     292            // find the base interface config file 
     293            File base_interface_config_file = new File(GSFile.interfaceConfigFile(GSFile.interfaceHome(GlobalProperties.getGSDL3Home(), base_interface))); 
     294            if (!base_interface_config_file.exists()) 
     295            { 
     296                logger.error(" base interface config file: " + base_interface_config_file.getPath() + " not found!"); 
     297                return false; 
     298            } 
     299            // the interface name is valid, add it to the list 
     300            if (base_interfaces == null) 
     301            { 
     302                base_interfaces = new ArrayList(); 
     303            } 
     304            base_interfaces.add(base_interface); 
     305            // now see if this has a base interface 
     306            Document config_doc = this.converter.getDOM(base_interface_config_file); 
     307            if (config_doc == null) 
     308            { 
     309                logger.error(" could not parse base interface config file: " + base_interface_config_file.getPath()); 
     310                return false; 
     311            } 
     312            Element config_elem = config_doc.getDocumentElement(); 
     313            base_interface = config_elem.getAttribute("baseInterface"); 
     314        } 
     315        return true; 
     316    } 
     317 
     318    protected boolean setUpInterfaceOptions(Element config_elem) 
     319    { 
     320        Element option_list = (Element) GSXML.getChildByTagName(config_elem, "optionList"); 
     321        if (option_list != null) 
     322        { 
     323            logger.debug("found an interface optionList"); 
     324            // we set any options in the config params 
     325            NodeList options = option_list.getElementsByTagName("option"); 
     326            for (int i = 0; i < options.getLength(); i++) 
     327            { 
     328                Element option = (Element) options.item(i); 
     329                String name = option.getAttribute(GSXML.NAME_ATT); 
     330                String value = option.getAttribute(GSXML.VALUE_ATT); 
     331                logger.debug("option: " + name + ", " + value); 
     332                if (!name.equals("") && !value.equals("")) 
     333                { 
     334                    this.config_params.put(name, value); 
     335                } 
     336            } 
     337        } 
     338 
     339        return true; 
     340    } 
     341 
     342    protected void preProcessRequest(Element request) 
     343    { 
     344        return; 
     345    } 
     346 
     347    protected Node postProcessPage(Element page) 
     348    { 
     349        return page; 
     350    } 
    304351 
    305352}