/*
    * Copyright 2001-2005 The Apache Software Foundation.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package net.sf.nxqd;
  
  import java.util.logging.Level;
  import java.util.logging.Logger;
  import java.util.ArrayList;
  import java.util.Map;
  import java.util.List;
  import java.util.Timer;
  
  import org.w3c.dom.Document;
  
  import net.sf.nxqd.common.NxqdUtils;
  import net.sf.nxqd.soap.AxisConnector;
  import net.sf.nxqd.event.NxqdEvent;
  import net.sf.nxqd.event.NxqdContainerEvent;
  import net.sf.nxqd.event.NxqdManagerEvent;
  import net.sf.nxqd.event.NxqdEventListener;
  import net.sf.nxqd.event.NxqdManagerEventListener;
  import net.sf.nxqd.event.NxqdContainerEventListener;
  
  import javax.xml.namespace.QName;
  import org.apache.axis.Constants;
  
  /**
   * The class <code>NxqdManager</code> is the main class for
   * communicating with the Nxqd Apache module.
   *
   * @author <a href="mailto:webhiker@sourceforge.net">webhiker</a>
   * @version 1.0
   */
  public class NxqdManager {
  
      /**
       * The variable <code>logger</code> is used for logging events.
       *
       */
      private static Logger logger = Logger.getLogger(NxqdManager.class.getName());
  
      /**
       * The constant <code>NXQD_PORT</code> specifies the default port
       * in case it is not specified in the URI.
       */
      public  static final String NXQD_PORT = "8080";
  
      /**
       * The variable <code>connected</code> indicates whether or not this
       * client is connected.
       *
       */
      private boolean connected;
  
      /**
       * The <code>host</code> to connect to.
       *
       */
      private String hostName;
  
      private String hostPort;
  
      private AxisConnector axisConnector;
  
      /**
       * Creates a new <code>NxqdManager</code> instance which will connect
       * to the specified host on the default port.
       *
       * @param host a <code>String</code> value indicating the hostname of the
       * machine running the Nxqd server.
       */
      public NxqdManager(final String host) {
          this(host, NXQD_PORT);
      }
  
      /**
       * The a new <code>NxqdManager</code> constructor creates a new instance
       * of this driver.
       *
       * @param host a <code>String</code> value indicating the hostname of the
       * machine running the Nxqd server.
       * @param port an <code>int</code> value specifying the port of the
       * Nxqd server.
       */
      public NxqdManager(final String host, final String port) {
          this.hostName = host;
          this.hostPort = port;
 	containerListeners = new ArrayList();
 	managerListeners = new ArrayList();
 	axisConnector = new AxisConnector(hostName, hostPort);
     }
 
     /**
      * The <code>getHostName</code> method returns the host name
      * of the machine running the Nxqd server.
      *
      * @return a <code>String</code> value
      */
     public final String getHostName() {
 	return hostName;
     }
 
     /**
      * The <code>getHostPort</code> method returns the host port
      * of the remote Nxqd server.
      *
      * @return an <code>String</code> value
      */
     public final String getHostPort() {
 	return hostPort;
     }
 
     public void connect() throws NxqdException {
 	if (axisConnector.isConnected()) {
 	    throw new NxqdException("Already connected");
 	}
 	else {
 	    axisConnector.connect();
 	}
     }
 
     public void disconnect() throws NxqdException {
 	if (!axisConnector.isConnected()) {
 	    throw new NxqdException("Not connected");
 	}
 	else {
 	    if (pollTimer!=null) {
 		pollTimer.cancel();
 	    }
 	    axisConnector.disconnect();
 	}
     }
 
     public boolean isConnected() {
 	return axisConnector.isConnected();
     }
 
     /**
      * The <code>getSessionId</code> method returns the session id which
      * identifies the client for this session.
      *
      * @return a <code>String</code> value
      */
     public String getSessionId() {
 	return axisConnector.getSessionId();
     }
 
     /**
      * The <code>createContainer</code> method creates
      * the specified container A NxqdException is thrown if
      * the container already exists.
      *
      * @param containerName a <code>String</code> value
      * @return a <code>NxqdContainer</code> value
      * @exception NxqdException if an error occurs
      */
     public NxqdContainer createContainer(String containerName) throws NxqdException {
 	logger.fine("Creating container "+containerName);
 
 	Boolean returnValue = (Boolean)axisConnector.invoke("create-container",
 							    Constants.XSD_BOOLEAN,
 							    new String[]{"container"},
 							    new Object[]{containerName});
 	// expect a "true" result, else something went wrong
 	if (!returnValue.booleanValue()) {
 	    throw new NxqdException("Server response indicated an error creating the container ("+containerName+")");
 	} else {
 	    logger.fine("Container was created ("+containerName+")");
 	    return new NxqdContainer(this, containerName);
 	}
     }
 
     /**
      * The <code>renameContainer</code> method creates
      * the specified container A NxqdException is thrown if
      * the container already exists.
      *
      * @param oldName a <code>String</code> indicating the container you want to rename
      * @param newName a <code>String</code> indicating the new name for the container
      * @exception NxqdException if an error occurs
      */
     public void renameContainer(final String oldName,
 				final String newName) throws NxqdException {
 	logger.fine("Renaming container "+oldName+" to "+newName);
 
 	Boolean returnValue = (Boolean)axisConnector.invoke("rename-container",
 							    Constants.XSD_BOOLEAN,
 							    new String[]{"old-container",
 									 "new-container"},
 							    new Object[]{oldName,
 									 newName});
 	// expect a "true" result, else something went wrong
 	if (!returnValue.booleanValue()) {
 	    throw new NxqdException("Server response indicated an error renaming the container ("+oldName+")");
 	} else {
 	    logger.fine("Container was renamed ("+newName+")");
 	}
     }
 
     /**
      * The <code>deleteContainer</code> method deletes the
      * specifed container. A NxqdException is thrown if
      * the container does not exist.
      *
      * @param containerName a <code>String</code> value
      * @exception NxqdException if an error occurs
      */
     public void deleteContainer(String containerName) throws NxqdException {
 	Boolean returnValue = (Boolean)axisConnector.invoke("delete-container",
 							    Constants.XSD_BOOLEAN,
 							    new String[]{"container"},
 							    new Object[]{containerName});
 	// expect a "true" result, else something went wrong
 	if (!returnValue.booleanValue()) {
 	    throw new NxqdException("Server response indicated an error deleting the container ("+containerName+")");
 	}
 	logger.fine("Container was deleted ("+containerName+")");
     }
 
     /**
      * The <code>deleteContainer</code> method deletes the
      * specifed container. A NxqdException is thrown if
      * the container does not exist.
      *
      * @param container a <code>NxqdContainer</code> value
      * @exception NxqdException if an error occurs
      */
     public void deleteContainer(NxqdContainer container) throws NxqdException {
 	Boolean returnValue = (Boolean)axisConnector.invoke("delete-container",
 							    Constants.XSD_BOOLEAN,
 							    new String[]{"container"},
 							    new Object[]{container.getName()});
 	// expect a "true" result, else something went wrong
 	if (!returnValue.booleanValue()) {
 	    throw new NxqdException("Server response indicated an error deleting the container ("+container.getName()+")");
 	}
 	logger.fine("Container was deleted ("+container.getName()+")");
     }
 
     /**
      * The <code>getContainer</code> method returns a handle
      * to the specified container. A NxqdException is thrown if
      * the container does not exist.
      *
      * @param containerName a <code>String</code> value
      * @return a <code>NxqdContainer</code> value
      * @exception NxqdException if an error occurs
      */
     public NxqdContainer getContainer(String containerName) throws NxqdException {
 	if (containerExists(containerName)) {
 	    return new NxqdContainer(this, containerName);
 	}
 	else {
 	    throw new NxqdException("The container does not exist ("+containerName+")");
 	}
     }
 
     /**
      * The <code>containerExists</code> method checks if
      * the specified container exists. It will return
      * true if the container exists, false otherwise.
      * A NxqdException is thrown if other errors occur.
      *
      * @param containerName a <code>String</code> value
      * @return a <code>boolean</code> value
      * @exception NxqdException if an error occurs
      */
     public boolean containerExists(String containerName) throws NxqdException {
 	if (containerName.indexOf('/')>=0) {
 	    throw new NxqdException("very naughty character");
 	}
 	Boolean result = (Boolean)axisConnector.invoke("container-exists",
 						       Constants.XSD_BOOLEAN,
 						       new String[]{"container"},
 						       new Object[]{containerName});
 	return result.booleanValue();
     }
 
     /**
      * The <code>listContainers</code> method returns a List containing
      * the container names managed by the server. This list may
      * be empty, but it will never be null.
      *
      * @return a <code>List</code> value
      * @exception NxqdException if an error occurs
      */
     public List listContainers() throws NxqdException {
 	Object result = axisConnector.invoke("get-container-list",
 					     new Object[0]);
 	if (result == null) {
 	    return new ArrayList();
 	}
 	else {
 	    // for some reason, if only one item is found
 	    // it s returned as a String
 	    if (result instanceof String) {
 		List resultList = new ArrayList();
 		resultList.add(result.toString());
 		return resultList;
 	    }
 	    else {
 		return (List)result;
 	    }
 	}
     }
 
     /**
      * The <code>query</code> method executes the specified queryExpression
      * on this database. No preprocessing of the query is performed.
      *
      * @param queryExpression a <code>String</code> value
      * @return a <code>List</code> value which will contain XML fragments
      * as <code>String</code> objects.
      * @exception NxqdException if an error occurs
      */
     public List query(final String queryExpression) throws NxqdException {
 	return query(queryExpression, null);
     }
 
 
     /**
      * The <code>query</code> method executes the specified queryExpression
      * on this database. No preprocessing of the query is performed.
      *
      * @param queryExpression a <code>String</code> value
      * @param nameSpaces a <code>Map</code> value
      * @return a <code>List</code> value which will contain XML fragments
      * as <code>String</code> objects.
      * @exception NxqdException if an error occurs
      */
     public List query(final String queryExpression,
 		      final Map nameSpaces) throws NxqdException {
 	
 	Object result = axisConnector.invoke("query",
 					     Constants.XSD_STRING,
 					     new String[]{"query",
 							  "namespacePrefix",
 							  "namespaceURI"},
 					     new Object[]{queryExpression,
 							  NxqdUtils.getKeysAsList(nameSpaces),
 							  NxqdUtils.getValuesAsList(nameSpaces)});
 	return NxqdUtils.gsoapResultObjectToList(result);
     }
 
     /**
      * The <code>lazyQuery</code> method executes the specified queryExpression
      * on this database. No preprocessing of the query is performed. This querying
      * is different from query in the way that no result is returned. Results can be
      * retrieved by calling <code>getResults</code>
      *
      * @param queryExpression a <code>String</code> value
      * @param nameSpaces a <code>Map</code> value
      * @param sessionID  a <code>String</code> value representing the client's session; retrieved using <code>getSessionId()</code>
      * @return a <code>int</code> value which will retrieve the query id if the query was successful 
      * The query id retrieved has to be submitted to <code>get_results</code> to get the results associated with
      * the lazy query. If query is unsuccessful, return 0.
      * @exception NxqdException if an error occurs
      * @author Manish Rai Jain
      */
     public int lazyQuery(final String queryExpression,
 		      final Map nameSpaces,
 		      final String sessionID) throws NxqdException {
 	
 	Integer result =  (Integer)axisConnector.invoke("lazyquery",
 						       Constants.XSD_INT,
 						       new String[]{"query",
 								    "namespacePrefix",
 								    "namespaceURI",
 								    "ssid"},
 						       new QName[]{Constants.XSD_STRING,
 								   Constants.XSD_ANY,
 								   Constants.XSD_ANY,
 								   Constants.XSD_STRING},
 						       new Object[]{queryExpression,
 								    NxqdUtils.getKeysAsList(nameSpaces),
 								    NxqdUtils.getValuesAsList(nameSpaces),
 								    sessionID});
 	return result.intValue();
 
     }
     
     /**
      * The <code>getResults method will retrieve the results after a
      * <code>lazyQuery</code> has been executed. 
      * 
      * @param numResults a <code>int</code> value to specify how many results to retrieve
      * @param sessionID a <code>String</code> value to specify which client's session
      * @param queryID a <code>int</code> value retrieved from <code>lazyQuery</code>
      * @author Manish Rai Jain
      */
     public List getResults(final int numResults, final String sessionID, final int queryID)
     	throws NxqdException {
     	Integer num = new Integer(numResults);
 	Integer qID = new Integer(queryID);
     	Object result = axisConnector.invoke("get-results",
 					     Constants.XSD_STRING,
 					     new String[]{"numresult",
 							  "ssid",
 							  "queryid"},
 					     new QName[]{Constants.XSD_INT,
 							 Constants.XSD_STRING,
 							 Constants.XSD_INT},
 					     new Object[]{num,
 							  sessionID,
 							  qID});
     	return NxqdUtils.gsoapResultObjectToList(result);
     }
     
     /**
      * The <code>createModify</code> method will create an 
      * <code>XmlModify</code> object.
      *
      * @return a <code>NxqdModify</code> value
      * @exception NxqdException if an error occurs
      */
     public NxqdModify createModify() throws NxqdException {
 	throw new NxqdException("createModify() is not yet supported");
     }
 
     /**
      * Describe <code>prepare</code> method here.
      *
      * @param query a <code>String</code> The XQuery query string to compile.
      * @return a <code>NxqdQueryExpression</code> value
      * @exception NxqdException if an error occurs
      */
     public NxqdQueryExpression prepare(String query) throws NxqdException {
 	throw new NxqdException("prepare(String query) is not yet supported");
     }
 
     /**
      * The <code>putDocument</code> method adds the specified document to the
      * container using the specified documentId. An exception is thrown if
      * the specified documentId already exists.
      *
      * @param containerId a <code>String</code> value
      * @param documentId a <code>String</code> value
      * @param documentStr a <code>String</code> value
      * @exception NxqdException if an error occurs
      */
     protected void putDocument(final String containerId,
 			       final String documentId, 
 			       final String documentStr) throws NxqdException {
 	Object ret = axisConnector.invoke("put-document",
 					  Constants.XSD_BOOLEAN,
 					  new String[]{"container",
 						       "name",
 						       "doc"},
 					  new Object[]{containerId,
 						       documentId,
 						       documentStr});
 	if (!((Boolean)ret).booleanValue()) {
 	    throw new NxqdException("Error occured while adding the document");
 	}
     }
     
     /**
      * The <code>getDocument</code> method retrievs the specified document from the
      * container using the specified documentId. An exception is thrown if
      * the specified documentId does not exist.
      *
      * @param containerId a <code>String</code> value
      * @param documentId a <code>String</code> value
      * @return a <code>String</code> value
      * @exception NxqdException if an error occurs
      */
     protected String getDocument(final String containerId,
 				 final String documentId) throws NxqdException {
 	return (String)axisConnector.invoke("get-document",
 					    Constants.XSD_STRING,
 					    new String[]{"container",
 							 "name"},
 					    new Object[]{containerId,
 							 documentId});
     }
     
     /**
      * The <code>deleteDocument</code> method deletes the specified document from the
      * container using the specified documentId. An exception is thrown if
      * an error occurred while deleting the document.
      *
      * @param containerId a <code>String</code> value
      * @param documentId a <code>String</code> value
      * @exception NxqdException if an error occurs
      */
     protected void deleteDocument(final String containerId,
 				  final String documentId) throws NxqdException {
 	if (!((Boolean)axisConnector.invoke("delete-document",
 					    Constants.XSD_BOOLEAN,
 					    new String[]{"container",
 							 "name"},
 					    new Object[]{containerId,
 							 documentId})).booleanValue()) {
 	    throw new NxqdException("Error deleting document");
 	}
     }
 
     /**
      * The <code>documentExists</code> method checks if
      * the specified document exists. It will return
      * true if the document exists, false otherwise.
      * A NxqdException is thrown if other errors occur.
      *
      * @param containerId a <code>String</code> value
      * @param documentId a <code>String</code> value
      * @return a <code>boolean</code> value
      * @exception NxqdException if an error occurs
      */
     protected boolean documentExists(final String containerId,
 				     final String documentId) throws NxqdException {
 	Object result = axisConnector.invoke("document-exists",
 					     Constants.XSD_BOOLEAN,
 					     new String[]{"container",
 							  "name"},
 					     new Object[]{containerId,
 							  documentId});
 	return ((Boolean)result).booleanValue();
     }
 
     /**
      * The <code>listDocuments</code> method returns a List containing
      * the document id's managed by the server. This list may
      * be empty, but it will never be null, and contains <code>String</code>
      * values.
      *
      * @return a <code>List</code> value
      * @exception NxqdException if an error occurs
      */
     protected List listDocuments(final String containerId) throws NxqdException {
 	Object result = axisConnector.invoke("get-document-list",
 					     Constants.XSD_STRING,
 					     new String[]{"container"},
 					     new Object[]{containerId});
 	return NxqdUtils.gsoapResultObjectToList(result);
     }
 
     /**
      * Returns the number of XML Documents in this container.
      *
      * @return an <code>long</code> value
      * @exception XmlException if an error occurs
      */
     protected long getNumDocuments(final String containerId) throws NxqdException {
 	return ((java.math.BigInteger)axisConnector.invoke("get-document-count",
 							   Constants.XSD_INTEGER,
 							   new String[]{"container"},
 							   new Object[]{containerId})).longValue();
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////
 
     /**
        /**
        * The <code>putBlob</code> method adds the specified blob to the
        * container using the specified blobId. An exception is thrown if
        * the specified blobId already exists.
        *
        *
        * @param containerId a <code>String</code> value
        * @param blobId a <code>String</code> value
        * @param blob a <code>byte[]</code> value
        * @exception NxqdException if an error occurs
        */
 	protected void putBlob(final String containerId,
 			       final String blobId, 
 			       final byte[] blob) throws NxqdException {
 	    Object ret = axisConnector.invoke("put-blob",
 					      Constants.XSD_BOOLEAN,
 					      new String[]{"container",
 							   "name",
 							   "doc"},
 					      new Object[]{containerId,
 							   blobId,
 							   blob});
 	    if (!((Boolean)ret).booleanValue()) {
 		throw new NxqdException("Error occured while adding the blob");
 	    }
 	}
     
     /**
      * The <code>getBlob</code> method retrieves the specified blob from the
      * container using the specified blobId. An exception is thrown if
      * the specified blobId does not exist.
      *
      * @param containerId a <code>String</code> value
      * @param blobId a <code>String</code> value
      * @return a <code>String</code> value
      * @exception NxqdException if an error occurs
      */
     protected byte[] getBlob(final String containerId,
 			     final String blobId) throws NxqdException {
 	return (byte[])axisConnector.invoke("get-blob",
 					    Constants.XSD_BYTE,
 					    new String[]{"container",
 							 "name"},
 					    new Object[]{containerId,
 							 blobId});
     }
     
     /**
      * The <code>deleteBlob</code> method deletes the specified blob from this
      * container using the specified blobId. An exception is thrown if
      * an error occurred while deleting the document.
      *
      * @param containerId a <code>String</code> value
      * @param blobId a <code>String</code> value
      * @exception NxqdException if an error occurs
      */
     protected void deleteBlob(final String containerId,
 			      final String blobId) throws NxqdException {
 	if (!((Boolean)axisConnector.invoke("delete-blob",
 					    Constants.XSD_BOOLEAN,
 					    new String[]{"container",
 							 "name"},
 					    new Object[]{containerId,
 							 blobId})).booleanValue()) {
 	    throw new NxqdException("Error deleting blob");
 	}
     }
 
     /**
      * The <code>documentExists</code> method checks if
      * the specified blob exists. It will return
      * true if the blob exists, false otherwise.
      * A NxqdException is thrown if other errors occur.
      *
      * @param containerId a <code>String</code> value
      * @param blobId a <code>String</code> value
      * @return a <code>boolean</code> value
      * @exception NxqdException if an error occurs
      */
     protected boolean blobExists(final String containerId,
 				 final String blobId) throws NxqdException {
 	Object result = axisConnector.invoke("blob-exists",
 					     Constants.XSD_BOOLEAN,
 					     new String[]{"container",
 							  "name"},
 					     new Object[]{containerId,
 							  blobId});
 	return ((Boolean)result).booleanValue();
     }
 
     /**
      * The <code>listBlobs</code> method returns a List containing
      * the blob id's managed by the server. This list may
      * be empty, but it will never be null, and contains <code>String</code>
      * values.
      *
      * @return a <code>List</code> value
      * @exception NxqdException if an error occurs
      */
     protected List listBlobs(final String containerId) throws NxqdException {
 	Object result = axisConnector.invoke("get-blob-list",
 					     Constants.XSD_STRING,
 					     new String[]{"container"},
 					     new Object[]{containerId});
 	return NxqdUtils.gsoapResultObjectToList(result);
     }
 
     /**
      * Returns the number of blobs in the specified container.
      *
      * @return an <code>long</code> value
      * @exception XmlException if an error occurs
      */
     protected long getNumBlobs(final String containerId) throws NxqdException {
 	return ((java.math.BigInteger)axisConnector.invoke("get-blob-count",
 							   Constants.XSD_INTEGER,
 							   new String[]{"container"},
 							   new Object[]{containerId})).longValue();
     }
 
     // -------- The event handling methods ----------
     private List containerListeners, managerListeners;
     private long managerPollDelay     = 5000;
     private long containerPollDelay   = 5000;
     private Timer pollTimer;
 
     public void addNxqdContainerEventListener(NxqdContainerEventListener cl) {
 	synchronized (containerListeners) {
 	    containerListeners.add(cl);
 	    reschedulePollTimers();
 	}
     }
 
     public void removeNxqdContainerEventListener(NxqdContainerEventListener cl) {
 	synchronized (containerListeners) {
 	    containerListeners.remove(cl);
 	    reschedulePollTimers();
 	}
     }
 
     /**
      * The <code>setContainerEventPeriod</code> method sets the polling period for retrieving the 
      * container event queue from the server.
      *
      * @param ms an <code>long</code> value represeting the pollingperiod in milliseconds.
      * Defaults to 5000.
      */
     public void setContainerEventPeriod(long ms) {
 	containerPollDelay = ms;
     }
 
     public void addNxqdManagerEventListener(NxqdManagerEventListener ml) {
 	synchronized (managerListeners) {
 	    managerListeners.add(ml);
 	    reschedulePollTimers();
 	}
     }
 
     public void removeNxqdManagerEventListener(NxqdManagerEventListener ml) {
 	synchronized (managerListeners) {
 	    managerListeners.remove(ml);
 	    reschedulePollTimers();
 	}
     }
 
     /**
      * The <code>setManagerEventPeriod</code> method sets the polling period for retrieving the 
      * manager event queue from the server.
      *
      * @param ms an <code>long</code> value represeting the pollingperiod in milliseconds.
      * Defaults to 5000.
      */
     public void setManagerEventPeriod(long ms) {
 	managerPollDelay = ms;
     }
 
     private void reschedulePollTimers() {
 	if (pollTimer!=null) {
 	    pollTimer.cancel();
 	}
 	pollTimer = new Timer();
 	if (managerListeners.size()>0) {
 	    pollTimer.schedule(new ManagerEventTask(),   managerPollDelay, managerPollDelay);
 	}
 	if (containerListeners.size()>0) {
 	    pollTimer.schedule(new ContainerEventTask(), containerPollDelay, containerPollDelay);
 	}
     }
 
     private void pullGenericEvents(final String methodName,
 				   final NxqdEvent event, 
 				   final long pollDelay,
 				   List listeners) throws NxqdException {
 
 	// get the notifs from the server
 	Object result = axisConnector.invoke(methodName,
 					     new String[]{"ssid",
 							  "period"},
 					     new Object[]{getSessionId(),
 							  new Long(pollDelay)});
 	List notifications = NxqdUtils.gsoapResultObjectToList(result);
 
 	synchronized (listeners) {
 	    NxqdEventListener ml;
 	    NxqdEvent ne = null;
 	    for (int i = 0; i < notifications.size(); i++) {
 		try {
 		    ne = (NxqdEvent)event.getClass().newInstance();
 		}
 		catch (Throwable t) {
 		}
 		ne.setDetail(notifications.get(i).toString());
 
 		for (int j = 0; j < listeners.size(); j++) {
 		    ml = (NxqdEventListener)listeners.get(j);
 		    ml.handleEvent(ne);
 		    switch (ne.getType()) {
 		    case NxqdManagerEvent.CONTAINER_CREATED :
 			((NxqdManagerEventListener)ml).handleContainerCreated(ne.getName());
 			break;
 		    case NxqdManagerEvent.CONTAINER_DELETED :
 			((NxqdManagerEventListener)ml).handleContainerDeleted(ne.getName());
 			break;
 		    case NxqdManagerEvent.CONTAINER_RENAMED :
 			((NxqdManagerEventListener)ml).handleContainerRenamed(ne.getName(), ne.getSource());
 			break;
 		    case NxqdContainerEvent.RESOURCE_CREATED :
 			((NxqdContainerEventListener)ml).handleResourceCreated(ne.getSource(), ne.getName());
 			break;
 		    case NxqdContainerEvent.RESOURCE_DELETED :
 			((NxqdContainerEventListener)ml).handleResourceDeleted(ne.getSource(), ne.getName());
 			break;
 		    case NxqdContainerEvent.RESOURCE_UPDATED :
 			((NxqdContainerEventListener)ml).handleResourceUpdated(ne.getSource(), ne.getName());
 			break;
 		    }
 		}
 	    }
 	}
     }
 
     private void pullManagerEvents() throws NxqdException {
 	pullGenericEvents("get-manager-events",
 			  new NxqdManagerEvent(),
 			  managerPollDelay,
 			  managerListeners);
     }
     
     private void pullContainerEvents() throws NxqdException {
 	pullGenericEvents("get-container-events",
 			  new NxqdContainerEvent(),
 			  containerPollDelay,
 			  containerListeners);
     }
 
     class ManagerEventTask extends java.util.TimerTask {
 
 	public ManagerEventTask() {
 	}
 
 	public void run() {
 	    try {
 		pullManagerEvents();
 	    }
 	    catch (Throwable t) {
 		t.printStackTrace();
 	    }
 	}
     }
 
     class ContainerEventTask extends java.util.TimerTask {
 
 	public ContainerEventTask() {
 	}
 
 	public void run() {
 	    try {
 		pullContainerEvents();
 	    }
 	    catch (NxqdException ne) {
 		ne.printStackTrace();
 	    }
 	}
     }
 
 }