package org.mom4j.xcp.impl;
import org.mom4j.xcp.XcpConfig;
import org.mom4j.xcp.XcpException;
import org.mom4j.xcp.XcpRequestListener;
import org.mom4j.xcp.XcpRequest;
import org.mom4j.xcp.XcpServer;
import org.mom4j.xcp.util.InstancePool;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.Log;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
public class XcpServerImpl implements XcpServer {
/** logger */
private static Log log = LogFactory.getLog(XcpServerImpl.class);
private InstancePool docHandlers;
private XcpConfig config;
private List listeners;
private XcpListener theListener;
private Map servers;
private long requestCount;
public XcpServerImpl(XcpConfig cfg, Map servers) {
if(cfg == null)
throw new IllegalArgumentException("cfg must not be null!");
if(servers == null)
throw new IllegalArgumentException("servers must not be null!");
this.config = cfg;
this.listeners = Collections.synchronizedList(new ArrayList());
this.theListener = new XcpListener(this.config);
this.servers = servers;
this.requestCount = 0;
this.theListener.listen();
Object[] objects = new Object[this.config.getWorkersCount()];
for(int i = 0; i < objects.length; i++) {
objects[i] = new XcpDocumentHandler(cfg);
}
this.docHandlers = new InstancePool(objects);
}
private void processXcpRequest(XcpRequest req) throws XcpException
{
if (log.isDebugEnabled()) log.debug("processing XcpRequest " + req);
if(req == null) {
throw new IllegalArgumentException("req == null");
}
XcpRequestListener l;
Iterator it = this.listeners.iterator();
while(it.hasNext()) {
l = (XcpRequestListener)it.next();
l.requestNotify(req);
}
}
public void shutdown() {
this.theListener.shutdown();
this.servers.remove(new Integer(this.config.getPort()));
}
public synchronized void addXcpRequestListener(XcpRequestListener l) {
if(l == null)
throw new IllegalArgumentException("listener may not be null!");
this.listeners.add(l);
}
public synchronized void removeXcpRequestListener(XcpRequestListener l) {
if(l == null)
throw new IllegalArgumentException("listener may not be null!");
this.listeners.remove(l);
}
public synchronized Iterator getXcpRequestListeners() {
return this.listeners.listIterator();
}
public long getNoOfRequests() {
return this.requestCount;
}
public int getNoOfWorkerThreads() {
return this.config.getWorkersCount();
}
public boolean isRunning() {
return this.theListener.isRunning();
}
void receiveData(Reader r, List queue, XMLReader parser)
throws XcpException
{
this.requestCount++;
XcpDocumentHandler dh = (XcpDocumentHandler)this.docHandlers.getObject();
XcpRequestImpl req = null;
try {
InputSource in = new InputSource(r);
dh.setParser(parser);
parser.setContentHandler(dh);
parser.setErrorHandler(dh);
parser.parse(in);
req = new XcpRequestImpl(dh.getRootElement(), dh.getProtocolName(), queue);
} catch(Exception ex) {
log.error("Error while reading request data", ex);
throw new XcpException(ex.getMessage());
} finally {
try { dh.cleanUp(); } catch(Exception ex) {}
this.docHandlers.releaseObject(dh);
}
this.processXcpRequest(req);
}
}