/*
 *    MessageRouter.java
 *    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package org.greenstone.gsdl3.core;

import org.greenstone.gsdl3.util.*;
import org.greenstone.gsdl3.service.*;
import org.greenstone.gsdl3.comms.*;
import org.greenstone.gsdl3.collection.*;

// XML classes
import org.w3c.dom.Node; 
import org.w3c.dom.NodeList; 
import org.w3c.dom.Document; 
import org.w3c.dom.Element; 
import org.xml.sax.InputSource;
import javax.xml.parsers.*;

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

/**
 * The hub of a Greenstone system. 
 *
 * Accepts  XML requests (via process method of ModuleInterface) and routes them to the appropriate collection or 
 * service or external entity.
 *
 * contains a map of module objects - may be services, collections, comms 
 * objects talking to other MessageRouters etc.
 *
 *
 * @author <a href="mailto:kjdon@cs.waikato.ac.nz">Katherine Don</a>
 * @version $Revision: 4141 $
 * @see ModuleInterface
 * @see Collection
 * @see ServiceRack
 * @see Communicator
 *
 */
public class MessageRouter implements  ModuleInterface {

    /** site home - the home directory for the site */
    protected String site_home=null;
    /** the http address for this site */
    protected String site_http_address=null;
    
    /** the global name for this site */
    protected String global_site_name=null;

    /** map of names to Module objects */
    protected HashMap module_map=null;

    /** container Document to create XML Nodes */
    protected Document doc=null; 
    /** the full description of this site */

    // should these things be separated into local and remote??

    /** list of collections that can be reached */
    protected Element collection_list = null; 
    /** list of service clusters that can be reached */
    protected Element cluster_list = null; 
    /** list of single services that can be reached */
    protected Element service_list = null; 
    /** list of sites that can be reached */
    protected Element site_list = null; 

    /** a converter class to parse XML and create Docs */
    protected XMLConverter converter=null;

    //***************************************************************
    // public methods
    //***************************************************************

    /** constructor */
    public MessageRouter() {
	this.converter = new XMLConverter();
	this.doc = this.converter.newDOM();
	
	
    }

    /** site_home must be set before configure called */
    public void setSiteHome(String home) {
	this.site_home = home;
    }

    /**
     * configures the system
     *
     * looks in site_home/collect for collections, reads config file
     * site_home/sitecfg.xml
     *
     */
    public boolean configure() { 

	System.out.println("MessageRouter:configuring site");

	if (this.site_home==null) {
	    System.err.println("You must set site_home before calling configure");
	    return false;
	}
	
	// read thru own config file - create services and connect to sites
	File configFile = new File(GSFile.siteConfigFile(this.site_home));

	if (!configFile.exists() ) {
	    System.err.println("MessageRouter: site config file: "+configFile.getPath()+" not found!");
	    return false;
	}
	
	this.module_map = new HashMap();

	Element config = this.converter.getDOM(configFile).getDocumentElement();
	
	Element local_site_name = (Element)GSXML.getChildByTagName(config, GSXML.SITE_NAME_ELEM);
	if (local_site_name == null) {
	    System.err.println("MessageRouter configure error:no site name in config file");
	    return false;
	} else {
	    this.global_site_name = local_site_name.getAttribute(GSXML.VALUE_ATT);
	}
	
	Element http_address = (Element)GSXML.getChildByTagName(config, GSXML.SITE_HTTP_ADDRESS_ELEM);
	if (http_address == null) {
	    System.err.println("MessageRouter configure error: no http address  in config file");
	    return false;
	} else {
	    this.site_http_address = http_address.getAttribute(GSXML.VALUE_ATT);
	}
	
	// load up the services
	Element service_rack_list = (Element)GSXML.getChildByTagName(config, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
	configureServices(service_rack_list);
	
	// load up the service clusters
	Element cluster_list = (Element)GSXML.getChildByTagName(config, GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER);	
	configureClusters(cluster_list);

	// load up the collections
	configureCollections();

	// load up the external sites - this also adds their services/clusters/collections to the other lists - so must be done last
	Element site_list = (Element)GSXML.getChildByTagName(config, GSXML.SITE_ELEM+GSXML.LIST_MODIFIER);
	configureSites(site_list);
	
		
	return true;
	
    }
 	
   
    /**
     * Process an XML request - as a String
     *
     * @param xml_in the request to process
     * @return the response - contains any error messages
     * @see String
     */
    public String process(String xml_in) {
	
	Document doc = this.converter.getDOM(xml_in);
	
	Element result = process(doc.getDocumentElement());
	return this.converter.getString(result);
    }
    
    /**
     * Process an XML request - as a DOM Element
     *
     * @param xml_in the message to process - should be <message>
     * @return the response - contains any error messages
     * @see Element
     */
    public Element process(Element message) {

	System.out.println("MR received request");
	System.out.println(this.converter.getString(message));
			   
	// check that its a correct message tag
	if (!message.getTagName().equals(GSXML.MESSAGE_ELEM)) {
	    System.err.println("Invalid message. GSDL message should start with <"+GSXML.MESSAGE_ELEM+">, instead it starts with:"+message.getTagName()+".");
	    return null;
	}

	NodeList requests = message.getElementsByTagName(GSXML.REQUEST_ELEM);

	Element mainResult = this.doc.createElement(GSXML.MESSAGE_ELEM);
	
	// empty request
	if (requests.getLength()==0) {
	    return mainResult;
	}

	Document message_doc = message.getOwnerDocument();

	// for now, just process each request one by one, and append the results to mainResult
	// Note: if you add an element to another node in the same document, it
	// gets removed from where it was. This changes the node list - you cant iterate over the node list in a normal manner if you are moving elements out of it
	int num_requests = requests.getLength();
	for (int i=0; i< num_requests; i++) {
	    Node result=null;
	    Element req = (Element)requests.item(0);
	    String path = req.getAttribute(GSXML.TO_ATT); // returns "" if no att of this name
	    if (path.equals("")) {
		// its a message for the message router
		result = processMessage(req);
		mainResult.appendChild(this.doc.importNode(result, true));
	    } else {
		// find the module to pass it on to
		// need to put the request into a message element
		Element mess = message_doc.createElement(GSXML.MESSAGE_ELEM);
		mess.appendChild(req);
		String obj = GSPath.getFirstLink(path);
		if (this.module_map.containsKey(obj)) {
		    result = ((ModuleInterface)this.module_map.get(obj)).process(mess);
		    if (result !=null ) {
			// append the contents of the message to the mainResult - there will only be one response at this stage
			mainResult.appendChild(this.doc.importNode(GSXML.getChildByTagName(result, GSXML.RESPONSE_ELEM), true));
		    } else {
			System.err.println("MessageRouter Error: request had null result!");
		    }
		} else {    
		    System.err.println("MessageRouter Error: request has illegal module name in:\n"+this.converter.getString(req));
		}
	    }
	    
	} // for each request
	
	System.out.println("MR returned response");
	System.out.println(this.converter.getString(mainResult));

	return mainResult;
	
    }
	
    // ********************************************************************
    // auxiliary configure methods
    // *******************************************************************


    protected boolean configureServices(Element service_rack_list) {

	this.service_list = this.doc.createElement(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER);

	// load up the individual services
	System.out.println("loading service modules...");
	
	if (service_rack_list == null) {
	    System.out.println("... none to be loaded");
	    return true;
	} 
	
	NodeList service_racks = service_rack_list.getElementsByTagName(GSXML.SERVICE_CLASS_ELEM);
	if (service_racks.getLength()==0) {
	    System.out.println("... none to be loaded");
	    return true;
	} 
		
	Element service_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
	Element service_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE, "", "");
	service_message.appendChild(service_request);
		
	for(int i=0; i<service_racks.getLength(); i++) {
	    Element n = (Element)service_racks.item(i);
	    String service_name = n.getAttribute(GSXML.NAME_ATT);
	    System.out.println("..."+service_name);
	    try {
		ServiceRack s = (ServiceRack)Class.forName("org.greenstone.gsdl3.service."+service_name).newInstance();
		s.setSiteHome(this.site_home);
		s.setSiteAddress(this.site_http_address);
		s.setMessageRouter(this);
		// pass the XML node to the service for service configuration
		s.configure(n, null);

		// find out the supported services for this service module
		Element service_response = (Element) s.process(service_message);
		NodeList services = service_response.getElementsByTagName(GSXML.SERVICE_ELEM);
		if (services.getLength()==0) {
		    System.err.println("MessageRouter configure error: serviceRack "+service_name+" has no services!");
		} else {
		    for (int j=0; j<services.getLength();j++) {
			String service = ((Element)services.item(j)).getAttribute(GSXML.NAME_ATT);
			this.module_map.put(service, s);
			
				// add short info to service_list_ XML
			this.service_list.appendChild(this.doc.importNode(services.item(j), true));
		    }
		}
	    } catch (Exception e ) {
		System.err.println("MessageRouter configure exception:  in ServiceRack class specification:  "+ e.getMessage());
		e.printStackTrace();
	    } 
	} // for each service module
	return true;
    }
    
    protected boolean configureClusters(Element cluster_list) {

	this.cluster_list = this.doc.createElement(GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER);
	// load up the service clusters
	System.out.println("loading service clusters ...");
	if (cluster_list == null) {
	    System.out.println("... none to be loaded");
	    return true;
	} 
	NodeList service_clusters = cluster_list.getElementsByTagName(GSXML.CLUSTER_ELEM);
	if (service_clusters.getLength()==0) {
	    System.out.println("... none to be loaded");
	    return true;
	}
	
	for (int i=0; i<service_clusters.getLength(); i++) {
	    Element cluster = (Element)service_clusters.item(i);
	    String name = cluster.getAttribute(GSXML.NAME_ATT);
	    System.out.println("..."+name);
	    ServiceCluster sc = new ServiceCluster();
	    sc.setSiteHome(this.site_home);
	    sc.setSiteAddress(this.site_http_address);
	    sc.setClusterName(name);
	    sc.setMessageRouter(this);
	    sc.configure(cluster);
	    this.module_map.put(name, sc); // this replaces the old one if there was one already present
	    //add short info to cluster list
	    Element e = this.doc.createElement(GSXML.CLUSTER_ELEM);
	    e.setAttribute(GSXML.NAME_ATT, name);
	    this.cluster_list.appendChild(e);
	    
	}
	return true;
    }
    
    protected boolean configureCollections() {

	this.collection_list = this.doc.createElement(GSXML.COLLECTION_ELEM+GSXML.LIST_MODIFIER);

	// read thru the collect directory and activate all the valid collections
	File collectDir = new File(GSFile.collectDir(this.site_home));
	if (collectDir.exists()) {
	    System.out.println("Reading thru directory "+collectDir.getPath()+" to find collections.");
	    File[] contents = collectDir.listFiles();
	    for (int i=0; i<contents.length;i++) {
		if(contents[i].isDirectory()) {
		    
		    String colName = contents[i].getName();
		    if (!colName.startsWith("CVS")) {
			activateCollection(colName);
		    }
		}
	    }
	} // collectDir
	return true;
    }

    protected boolean configureSites(Element site_list) {

	this.site_list = this.doc.createElement(GSXML.SITE_ELEM+GSXML.LIST_MODIFIER);
	// load up the sites
	System.out.println("loading external sites...");
	if (site_list ==null ) {
	    System.out.println("...none found");
	    return true;
	}
	NodeList sites = site_list.getElementsByTagName(GSXML.SITE_ELEM);
	if (sites.getLength()==0) {
	    System.out.println("...none found");
	    return true;
	}
	for (int i=0; i<sites.getLength(); i++) {
	    Element s = (Element)sites.item(i);
	    Communicator comm=null;
	    String type = s.getAttribute(GSXML.TYPE_ATT);
	    String name = s.getAttribute(GSXML.NAME_ATT);
	    if (type.equals(GSXML.COMM_TYPE_SOAP_JAVA)) {
		comm = new SOAPCommunicator();
		if (comm.configure(s)) {
		    comm.setLocalSiteName(this.global_site_name);
		    
		    // add to map of modules
		    this.module_map.put(name, comm);
		    this.site_list.appendChild(this.doc.importNode(s, true));
		    // need to get collection list and service 
		    // list from here- if the site isn't up yet, the site will
		    // have to be added later 
		    if (!getRemoteSiteInfo(comm, name)) {
			System.err.println("couldn't get info from site "+name);
		    }
		} else {
		    System.err.println("couldn't configure soap site:"+name);
		}
		
	    } else {
		System.err.print("cant talk to server of type:"+type);
		System.err.println(", so not making a connection to "+name);
	    }
	    
	}
	return true;
    }
    
    
    /** get site info from external site
     *
     * @param comm - the communicator object for the external site
     * @param site_name - the name of the external site
     * @return true if successful
     */
    protected boolean getRemoteSiteInfo(Communicator comm, String site_name) {
    
	System.out.println("MessageRouter: getting info from site:"+site_name);

	Element info_request = this.doc.createElement(GSXML.MESSAGE_ELEM);
	Element req = this.doc.createElement(GSXML.REQUEST_ELEM);
	info_request.appendChild(req);
	req.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_DESCRIBE);

	// process the message
	Element info_response = comm.process(info_request);
	if (info_response == null) {
	    return false;
	}
	// collection info
	NodeList colls = info_response.getElementsByTagName(GSXML.COLLECTION_ELEM);
	if (colls.getLength()>0) {
	    for (int i=0; i<colls.getLength(); i++) {
		Element e = (Element)colls.item(i);
		String col_name = e.getAttribute(GSXML.NAME_ATT);
		// add the info to own coll list - may want to keep 
		// this separate in future - so can distinguish own and 
		// other collections ??
		e.setAttribute(GSXML.NAME_ATT, GSPath.prependLink(col_name, site_name));
		this.collection_list.appendChild(this.doc.importNode(e, true));
	    }
	}

	// service info
	NodeList services = info_response.getElementsByTagName(GSXML.SERVICE_ELEM);
	if (services.getLength()>0) {
	    for (int i=0; i<services.getLength(); i++) {
		Element e = (Element)services.item(i);
		String serv_name = e.getAttribute(GSXML.NAME_ATT);
		e.setAttribute(GSXML.NAME_ATT, GSPath.prependLink(serv_name, site_name));
		this.service_list.appendChild(this.doc.importNode(e, true));
	    }
	}
	
	// serviceCluster info
	NodeList clusters = info_response.getElementsByTagName(GSXML.CLUSTER_ELEM);
	if (clusters.getLength()>0) {
	    for (int i=0; i<clusters.getLength(); i++) {
		Element e = (Element)clusters.item(i);
		String clus_name = e.getAttribute(GSXML.NAME_ATT);
		e.setAttribute(GSXML.NAME_ATT, GSPath.prependLink(clus_name, site_name));
		this.cluster_list.appendChild(this.doc.importNode(e, true));
	    }
	}
	return true;
    }


    //*****************************************************************
    // auxiliary process methods
    //*****************************************************************

    /** handles requests made to the MessageRouter itself 
     *
     * @param req - the request Element- <request>
     * @return the result Element - should be <response>
     */
    protected Element processMessage(Element req) {

	// message for self, should be type=describe/configure at this stage
	String type = req.getAttribute(GSXML.TYPE_ATT);
	Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
	response.setAttribute(GSXML.FROM_ATT, "");
	if (type.equals(GSXML.REQUEST_TYPE_DESCRIBE)) {
	    response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_DESCRIBE);
	    // check the param list
	    Element param_list = (Element) GSXML.getChildByTagName(req, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
	    if (param_list == null) {
		response.appendChild(this.collection_list);
		response.appendChild(this.cluster_list);
		response.appendChild(this.site_list);
		response.appendChild(this.service_list);
		return response;
	    }
	    System.out.println("params found, getting subset");
	    NodeList params = param_list.getElementsByTagName(GSXML.PARAM_ELEM);
	    
	    // go through the param list and see what components are wanted
	    for (int i=0; i<params.getLength(); i++) {
		
		Element param = (Element)params.item(i);
		// Identify the structure information desired
		if (param.getAttribute(GSXML.NAME_ATT) == GSXML.SUBSET_PARAM ) {
		    String info = param.getAttribute(GSXML.VALUE_ATT);
		    if (info.equals(GSXML.COLLECTION_ELEM+GSXML.LIST_MODIFIER)) {
			response.appendChild(this.collection_list);
			
		    } else if (info.equals(GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER)) {
			response.appendChild(this.cluster_list);
			
		    } else if (info.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
			response.appendChild(this.service_list);
		    } else if (info.equals(GSXML.SITE_ELEM+GSXML.LIST_MODIFIER)) {
			response.appendChild(this.site_list);
		    } 
		}
	    }
	    return response;
	    
	} 
	
	// the old way, should all be using system now
	if (type.equals(GSXML.REQUEST_TYPE_CONFIGURE)) {
	    
	    // a list of configure requests - should put any error messages
	    // or success messages into response
	    NodeList commands = req.getElementsByTagName(GSXML.CONFIGURE_ELEM);
	    for (int i=0; i<commands.getLength(); i++) {
		// all the commands should be Elements
		Element elem = (Element)commands.item(i);
		String action = elem.getAttribute(GSXML.ACTION_ATT);
		String module_name = elem.getAttribute(GSXML.NAME_ATT);
		String module_type = elem.getAttribute(GSXML.TYPE_ATT);
		if (action.equals(GSXML.CONFIG_ACTION_ACTIVATE)) {
		    if (module_type.equals(GSXML.COLLECTION_ELEM)) {
			activateCollection(module_name);
		    } else if (module_type.equals(GSXML.SERVICE_CLASS_ELEM)) {
			activateServiceRack(module_name);
		    } else if (module_type.equals(GSXML.CLUSTER_ELEM)) {
			activateServiceCluster(module_name);
		    } else {
			// cant process the activation
			// send an error
		    }
		} else if (action.equals(GSXML.CONFIG_ACTION_DEACTIVATE)) {
		    deactivateModule(module_type, module_name);
		    
		}
	    }
	    
	    return response;
	    
	} 
	
	if (type.equals(GSXML.REQUEST_TYPE_SYSTEM)) {
	    
	    // a list of system requests - should put any error messages
	    // or success messages into response
	    NodeList commands = req.getElementsByTagName(GSXML.SYSTEM_ELEM);
	    Element site_config_elem = null;
	    boolean success = false;
			
	    for (int i=0; i<commands.getLength(); i++) {
		// all the commands should be Elements
		Element elem = (Element)commands.item(i);
		String action = elem.getAttribute(GSXML.TYPE_ATT);
		if (action.equals("configure")) {
		    String subset = elem.getAttribute(GSXML.SYSTEM_SUBSET_ATT);
		    if (subset.equals("")) {
			// need to reconfigure the MR
			this.configure();
			Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM,  "mr reconfigured");
			response.appendChild(s);
			
		    } else {
			// else it a specific request
			if (subset.equals(GSXML.COLLECTION_ELEM+GSXML.LIST_MODIFIER)) {
			    success = configureCollections();
			} else {

			    // need the site config file
			    if (site_config_elem==null) {
				
				File configFile = new File(GSFile.siteConfigFile(this.site_home));
				if (!configFile.exists() ) {
				    System.err.println("MessageRouter: site config file: "+configFile.getPath()+" not found!");
				    continue;
				}
				site_config_elem  = this.converter.getDOM(configFile).getDocumentElement();
			    }
			    if (subset.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
				Element service_rack_list = (Element)GSXML.getChildByTagName(site_config_elem, GSXML.SERVICE_CLASS_ELEM+GSXML.LIST_MODIFIER);
				
				success = configureServices(service_rack_list);
			    } else if (subset.equals(GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER)) {
				Element cluster_list = (Element)GSXML.getChildByTagName(site_config_elem, GSXML.CLUSTER_ELEM+GSXML.LIST_MODIFIER);	
				
				success = configureClusters(cluster_list);
			    } else if (subset.equals(GSXML.SITE_ELEM+GSXML.LIST_MODIFIER)) {
				Element site_list = (Element)GSXML.getChildByTagName(site_config_elem, GSXML.SITE_ELEM+GSXML.LIST_MODIFIER);
				success = configureSites(site_list);
			    }
			}
			String message=null;
			if (success) {
			    message = subset + "reconfigured successfully";
			} else {
			    message = "Error in reconfiguring "+subset;
			}
			Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, message);
			response.appendChild(s);
		    }
		    
		    
		} else {
		    String module_name = elem.getAttribute(GSXML.SYSTEM_MODULE_NAME_ATT);
		    String module_type = elem.getAttribute(GSXML.SYSTEM_MODULE_TYPE_ATT);

		    if (action.equals("deactivate")) {
			deactivateModule(module_type, module_name);
			Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, module_type+": "+module_name+" deactivated");
			response.appendChild(s);
		    } else if (action.equals("activate")) {
			if (module_type.equals(GSXML.COLLECTION_ELEM)) {
			    success = activateCollection(module_name);
			} else if (module_type.equals(GSXML.SITE_ELEM)) {
			    success = activateSite(module_name);
			} else if (module_type.equals(GSXML.CLUSTER_ELEM)) {
			    success = activateServiceCluster(module_name);
			}
			if (success) {
			    Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, module_type+": "+module_name+" activated");
			    response.appendChild(s);
			} else {
			    Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, module_type+": "+module_name+" could not be activated");
			    response.appendChild(s);
			}
		    }
		} // else not a configure action
	    } // for all commands
	    return response;
			

	} // system type request
	
	// if get here something has gone wrong
	System.err.println("MessageRouter: cant process request:");
	System.err.println(this.converter.getString(req));
	return null;
       
    }

    // ****************************************************
    // other methods
    // ****************************************************

    /** creates and configures a new collection
     *
     *@param col_name the name of the collection
     *@return true if collection created ok
     */
    protected boolean activateCollection(String col_name) {

	System.out.println("MessageRouter:Activating collection: "+col_name+".");
			  
	Collection c = new Collection();
	c.setCollectionName(col_name);
	c.setSiteHome(this.site_home);
	c.setSiteAddress(this.site_http_address);
	if (c.configure()) {
	    // this could be a reactivation, so delete the old version
	    deactivateModule(GSXML.COLLECTION_ELEM, col_name);
	    // add to list of collections
	    this.module_map.put(col_name, c);
	    //add short description_ to collection_list_
	    Element e = this.doc.createElement(GSXML.COLLECTION_ELEM);
	    e.setAttribute(GSXML.NAME_ATT, col_name);
	    this.collection_list.appendChild(e);
	    return true;
	} else {
	    System.err.println("MessageRouter:Couldn't configure collection: "+
			       col_name+".");
	    return false;
	}
	
    }

    protected boolean activateSite(String site_name) {
	System.out.println("MessageRouter:Activating site: "+site_name+".");
	
	// just in case this is a reactivation, deactivate this site first
	deactivateModule(GSXML.SITE_ELEM, site_name);
	File configFile = new File(GSFile.siteConfigFile(this.site_home));

	if (!configFile.exists() ) {
	    System.err.println("MessageRouter: site config file: "+configFile.getPath()+" not found!");
	    return false;
	}
	Element config = this.converter.getDOM(configFile).getDocumentElement();
	
	Element site_list = (Element)GSXML.getChildByTagName(config, GSXML.SITE_ELEM+GSXML.LIST_MODIFIER);
	if (site_list ==null ) {
	    System.out.println("MessageRouter:activateSite, no sites found");
	    return false;
	}
	Element this_site_elem = GSXML.getNamedElement(site_list, GSXML.SITE_ELEM, GSXML.NAME_ATT, site_name);
	if (this_site_elem == null) {
	    System.out.println("MessageRouter:activateSite, site "+site_name+" not found");
	    return false;
	}
	
	Communicator comm=null;
	String type = this_site_elem.getAttribute(GSXML.TYPE_ATT);
	if (type.equals(GSXML.COMM_TYPE_SOAP_JAVA)) {
	    comm = new SOAPCommunicator();
	    if (comm.configure(this_site_elem)) {
		comm.setLocalSiteName(this.global_site_name);
		
		// add to map of modules
		this.module_map.put(site_name, comm);
		this.site_list.appendChild(this.doc.importNode(this_site_elem, true));
		// need to get collection list and service 
		// list from here- if the site isn't up yet, the site will
		// have to be added later 
		if (!getRemoteSiteInfo(comm, site_name)) {
		    System.err.println("couldn't get info from site "+site_name);
		}
	    } else {
		System.err.println("couldn't configure soap site:"+site_name);
		return false;
	    }
	    
	} else {
	    System.err.print("cant talk to server of type:"+type);
	    System.err.println(", so not making a connection to "+site_name);
	    return false;
	}
	return true;
	
    }
    
    protected boolean activateServiceCluster(String cluster_name) {
	return false;

    }

    protected boolean activateServiceRack(String module_name) {
	return false;
    }

    protected boolean deactivateModule(String type, String name) {
	
	if (this.module_map.containsKey(name)) {

	    System.out.println("MessageRouter: deactivating "+name);
	    this.module_map.remove(name);

	    // also remove the xml bit from description list
	    if (type.equals(GSXML.COLLECTION_ELEM)) {
		Element this_col = GSXML.getNamedElement(this.collection_list, GSXML.COLLECTION_ELEM, GSXML.NAME_ATT, name);
		if (this_col != null) {
		    this.collection_list.removeChild(this_col);
		}
		return true;
	    } else if (type.equals(GSXML.SERVICE_ELEM)) {
		Element this_service = GSXML.getNamedElement(this.service_list, GSXML.SERVICE_ELEM, GSXML.NAME_ATT, name);
		if (this_service != null) {
		    this.service_list.removeChild(this_service);
		}
		return true;
	    } else if (type.equals(GSXML.CLUSTER_ELEM)) {
		Element this_cluster = GSXML.getNamedElement(this.cluster_list, GSXML.CLUSTER_ELEM, GSXML.NAME_ATT, name);
		if (this_cluster != null) {
		    this.cluster_list.removeChild(this_cluster);
		}
		return true;
	    } else if (type.equals(GSXML.SITE_ELEM)) {
		Element this_site = GSXML.getNamedElement(this.site_list, GSXML.SITE_ELEM, GSXML.NAME_ATT, name);
		if (this_site != null) {
		    this.site_list.removeChild(this_site);
		    
		    // also remove this sites colls, services, clusters etc
		    removeRemoteSiteInfo(this.collection_list, GSXML.COLLECTION_ELEM, name);
		    removeRemoteSiteInfo(this.cluster_list, GSXML.CLUSTER_ELEM, name);
		    removeRemoteSiteInfo(this.service_list, GSXML.SERVICE_ELEM, name);
		}
	    } else {
		System.err.println("couldn't deactivate coll");
		// couldn't do it
		return false;
	    }
	}
	// else not deactivated 
	return false;

    }

    /**
     * this looks through a list (module_list) of elements named module_name, 
     * and removes any whose names start with site_name
     */
    protected void removeRemoteSiteInfo(Element module_list, 
					String module_name, 
					String site_name) {

	NodeList modules = module_list.getElementsByTagName(module_name);
	// will this work??
	for (int i=0; i<modules.getLength(); i++) {
	    
	    String name = ((Element)modules.item(i)).getAttribute(GSXML.NAME_ATT);
	    if (GSPath.getFirstLink(name).equals(site_name)) {
		module_list.removeChild(modules.item(i));
		i--; // move the pointer back
	    }
	}
    }

	
}