CompositeWorkerContainer.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import biz.hammurapi.config.ClassAcceptor;
import biz.hammurapi.config.Component;
import biz.hammurapi.config.ConfigurationException;
import biz.hammurapi.config.Context;
import biz.hammurapi.config.DomConfigFactory;
import biz.hammurapi.config.DomConfigurable;
import biz.hammurapi.config.PathNavigator;
import biz.hammurapi.xml.dom.DOMUtils;


/**
 * Simple container
 * @author Pavel Vlasov
 * @revision $Revision$
 */
public class CompositeWorkerContainer implements Component, DomConfigurable, Worker, Context {
	private Map workerMap=new HashMap(); 
	private List workers=new ArrayList();
	private boolean started;
	private Object parent;
	
	private PathNavigator pathNavigator=new PathNavigator(this) {

		protected Object getParent() {
			return parent;
		}

		protected Object getChild(String name) {
			return workerMap.get(name);
		}
		
	};
	
	
	public CompositeWorkerContainer() {
		// Default constructor

	}
	
	/**
	 * Looks up component in component tree.
	 * @param name
	 * @return
	 */
	public Object get(String name) {		
		return pathNavigator.get(name);
	}
	
	/**
	 * Adds component and starts it.
	 * @param name
	 * @param worker
	 * @throws ConfigurationException
	 */
	private void addWorker(String name, Worker worker) throws ConfigurationException {
		if (name!=null) {
			// Remove previous worker

			Object prevWorkerWithSameName=workerMap.remove(name);
			if (prevWorkerWithSameName!=null) {
				workers.remove(prevWorkerWithSameName);
				if (prevWorkerWithSameName instanceof Component) {
					if (started) {
						((Component) prevWorkerWithSameName).stop();
					}
					((Component) prevWorkerWithSameName).setOwner(null);
				}
			}
		}
		
		if (worker!=null) {
			// Add new worker

			if (worker instanceof Component) {
				Component theComponent = (Component) worker;
				theComponent.setOwner(this);
				if (started) {
					theComponent.start();
				}
			}
	
			if (name!=null) {
				workerMap.put(name, worker);
			}
			
			workers.add(worker);
		}
	}
	
	public void start() throws ConfigurationException {
		Iterator it=workers.iterator();
		while (it.hasNext()) {
			Object worker = it.next();
			if (worker instanceof Component) {
				((Component) worker).start();
			}			
		}
		started=true;
	}
	
	public void stop() throws ConfigurationException {
		started=false;
		List reverseWorkerList=new ArrayList(workers);
		Collections.reverse(reverseWorkerList);
		Iterator it=reverseWorkerList.iterator();
		while (it.hasNext()) {
			Object worker = it.next();
			if (worker instanceof Component) {
				((Component) worker).stop();
			}			
		}
	}

	public void setOwner(Object owner) {
		parent=owner;		
	}
	
	public void configure(Node configNode, Context context, ClassLoader classLoader) throws ConfigurationException {
		DomConfigFactory factory=new DomConfigFactory(context);
		try {
			NodeList nl = DOMUtils.selectNodeList(configNode, "worker|worker-ref");
			for (int i=0, l=nl.getLength(); i<l; ++i) {
				Element we = (Element) nl.item(i);
				if ("worker".equals(we.getNodeName())) {
					addWorker(
							we.hasAttribute("name") ? we.getAttribute("name") : null, 
							(Worker)factory.create(
									we,
									new ClassAcceptor() {

										public void accept(Class clazz) throws ConfigurationException {
											if (!(Worker.class.isAssignableFrom(clazz))) {
												throw new ConfigurationException(clazz.getName()+" does not implement "+Worker.class+" interface.");
											}
										}
										
									},
									null));
				} else {
					String ref = DOMUtils.getElementText(we);
					Object referencedWorker=get(ref);
					if (referencedWorker==null) {
						throw new ConfigurationException("Invalid worker reference: "+ref);
					}
					
					if (!(referencedWorker instanceof Worker)) {
						throw new ConfigurationException(referencedWorker.getClass().getName()+" does not implement "+Worker.class+" interface.");						
					}
					
					addWorker(we.hasAttribute("name") ? we.getAttribute("name") : null, (Worker) referencedWorker); 
				}
			} 
		} catch (Exception e) {
			throw new ConfigurationException(e);
		}
	}
	
	/**
	 * Gives job to workers until one of them accepts it.
	 */
	public boolean post(Runnable job) {
		Iterator it=workers.iterator();
		while (it.hasNext()) {
			Worker worker=(Worker)  it.next();
			if (worker.post(job)) {
				return true;
			}			
		}
		return false;
	}	
}