MeasurementCategoryFactory.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.metrics;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import biz.hammurapi.config.Component;
import biz.hammurapi.config.ConfigurationException;
import biz.hammurapi.config.DomConfigFactory;
import biz.hammurapi.config.RuntimeConfigurationException;

/**
 * Utility class which is a connection point between clients and
 * concrete MeasurementConsumer implementations.
 * @author Pavel Vlasov
 *
 * @version $Revision: 1.6 $
 */
public abstract class MeasurementCategoryFactory {
	private static final Logger logger = Logger.getLogger(MeasurementCategoryFactory.class.getName());
	
	private static Map categories=new HashMap();
	private static Collection factories=new ArrayList();
	
	/**
	 * Consumers and factories loaded on startup.
	 */
	private static Collection bootConsumers = new ArrayList();
	
	static {
		try {
			String config=System.getProperty(MeasurementCategoryFactory.class.getName()+":config");		
			if (config==null) {
				Iterator mit = DomConfigFactory.loadProviders(MeasurementCategoryFactory.class, MeasurementCategoryFactory.class.getClassLoader());
				while (mit.hasNext()) {
					loadConsumers(mit.next());
				}
			} else {		
				InputStream is = null;
				if (config.startsWith(biz.hammurapi.config.DomConfigFactory.RESOURCE_PREFIX)) {
					is=MeasurementCategoryFactory.class.getClassLoader().getResourceAsStream(config.substring(biz.hammurapi.config.DomConfigFactory.RESOURCE_PREFIX.length()));
					if (is==null) {
						logger.warning("Could not configure measurement subsystem - resource not found '"+config.substring(biz.hammurapi.config.DomConfigFactory.RESOURCE_PREFIX.length()));
					}
				} else if (config.startsWith("url:")) {
					try {
						is=new URL(config.substring("url:".length())).openStream();
					} catch (MalformedURLException e) {
						logger.log(Level.WARNING, "Could not configure measurement subsystem from URL: "+e, e);
					} catch (IOException e) {
						logger.log(Level.WARNING, "Could not configure measurement subsystem from URL: "+e, e);
					}				
				} else if (config.startsWith("file:")) {
					try {
						is=new FileInputStream(new File(config.substring("file:".length())));
					} catch (FileNotFoundException e) {
						logger.log(Level.WARNING, "Could not configure measurement subsystem from file: "+e, e);
					}								
				} else {
					logger.warning("Invalid measurement configuration string: "+config);
				}
				
				if (is!=null) {
					DomConfigFactory factory = new DomConfigFactory(MeasurementCategoryFactory.class.getClassLoader());
					bootConsumers.addAll((Collection) factory.create(is, null));
				}
			}				
			
			Iterator it=bootConsumers.iterator();
			while (it.hasNext()) {
				Object o=it.next();
				if (o instanceof MeasurementConsumer) {
					register((MeasurementConsumer) o);
				} else if (o instanceof MeasurementCategoryFactory) {
					register((MeasurementCategoryFactory) o);
				} else if (o!=null) {
					logger.warning("Not measurement sink or factory: "+o.getClass().getName());
				}
			}			
			
			if (!bootConsumers.isEmpty()) {
				Runtime.getRuntime().addShutdownHook(new Thread() {
					public void run() {
						shutdownBootConsumers();						
					}
				});
			}
		} catch (Exception e) {
			logger.log(Level.SEVERE, "Could not configure metrics sybsystem: "+e, e);
		}
	}
	
	/**
	 * Cannot be instantiated (abstract anyway)
	 */
	protected MeasurementCategoryFactory() {
		super();
	}
	
	private static void loadConsumers(Object provider) {
		if (provider instanceof Collection) {
			Iterator it = ((Collection) provider).iterator();
			while (it.hasNext()) {
				loadConsumers(it.next());
			}
		} else {
			bootConsumers.add(provider);
		}		
	}

	/**
	 * Subclasses shall implement this method to bind sinks to category
	 * @param category
	 * @return sink for the category, can be null.
	 */
	public abstract MeasurementConsumer getMeasurementConsumer(String categoryName);

	private static class MeasurementCategoryProxy implements MeasurementCategory {
		
		private Collection consumerList;

		MeasurementCategoryProxy(Collection consumerList) {
			this.consumerList=consumerList;
			isActive=!consumerList.isEmpty();
		}

		public void addMeasurement(String name, double value, long time) {
			if (isActive) {
				if (time==0) {
					time=System.currentTimeMillis();
				}
				synchronized (consumerList) {
					Iterator it=consumerList.iterator();
					while (it.hasNext()) {
						((MeasurementConsumer) it.next()).addMeasurement(name, value, time);
					}
				}
			}
		}
		
		void addConsumer(MeasurementConsumer consumer) {
			synchronized (consumerList) {
				consumerList.add(consumer);
				isActive=!consumerList.isEmpty();
			}
		}
		
		void removeConsumer(MeasurementConsumer consumer) {
			synchronized (consumerList) {
				consumerList.remove(consumer);
				isActive=!consumerList.isEmpty();
			}
		}

		/**
		 * @param consumers
		 */
		public void removeConsumers(Collection consumers) {
			synchronized (consumerList) {
				consumerList.removeAll(consumers);
				isActive=!consumerList.isEmpty();
			}						
		}
		
		public boolean isActive() {
			return isActive;
		}
		
		private boolean isActive;

		public void shutdown() {
			// Nothing

			
		}
	}
	
	/**
	 * @param klass
	 * @return Time interval measurement category instance for a class
	 */
	public static TimeIntervalCategory getTimeIntervalCategory(Class klass) {
		return getTimeIntervalCategory(klass.getName());
	}

	/**
	 * @param categoryName category name
	 * @return Time interval measurement category instance
	 */
	public static TimeIntervalCategory getTimeIntervalCategory(String categoryName) {		
		final MeasurementCategory cat=getCategory(categoryName);
		
		return new TimeIntervalCategory() {

			public long getTime() {
				return cat.isActive() ? System.currentTimeMillis() : 0;
			}

			public void addInterval(String name, long start) {
				if (cat.isActive()) {
					long now=System.currentTimeMillis();
					cat.addMeasurement(name, now-start, now);
				}
			}
			
		};
	}
	
	
	/**
	 * @param klass
	 * @return Measurement sink instance for a class
	 */
	public static MeasurementCategory getCategory(Class klass) {
		return getCategory(klass.getName());
	}

	/**
	 * @param category
	 * @return Measurement sink instance for a category
	 */
	public static MeasurementCategory getCategory(String category) {
		synchronized (categories) {
			MeasurementCategory ret=(MeasurementCategory) categories.get(category);
			if (ret==null) {
				final Collection consumerList=new ArrayList();
				Iterator it=factories.iterator();
				while (it.hasNext()) {
					FactoryEntry entry=(FactoryEntry) it.next();
					MeasurementConsumer consumer = entry.getCategory(category);
					if (consumer!=null) {
						consumerList.add(consumer);
					}					
				}
				ret=new MeasurementCategoryProxy(consumerList);
				categories.put(category, ret);
			}
			
			return ret;
		}
	}
	
	private static class FactoryEntry {
		MeasurementCategoryFactory factory;
		
		/**
		 * Consumers produced by the factory.
		 */
		Collection consumers=new ArrayList();
		
		MeasurementConsumer getCategory(String category) {
			MeasurementConsumer ret = factory.getMeasurementConsumer(category);
			if (ret!=null) {
				consumers.add(ret);
			}
			return ret;
		}
	}

	/**
	 * Registers sink factory.
	 * @param factory
	 */
	public static void register(MeasurementCategoryFactory factory) {
		if (factory instanceof Component) {
			try {
				((Component) factory).start();
			} catch (ConfigurationException e) {
				throw new RuntimeConfigurationException(e);
			}
		}
		
		synchronized (categories) {		
			FactoryEntry entry=new FactoryEntry();
			entry.factory=factory;
			factories.add(entry);
			Iterator it=categories.entrySet().iterator();
			while (it.hasNext()) {
				Map.Entry me=(Map.Entry) it.next();
				MeasurementConsumer consumer = entry.getCategory((String) me.getKey());
				if (consumer!=null) {
					((MeasurementCategoryProxy) me.getValue()).addConsumer(consumer);
				}
			}
		}		
	}

	/**
	 * Register sink for a single category.
	 * @param category Category, cannot be null.
	 * @param consumer
	 */
	public static void register(final String category, final MeasurementConsumer consumer) {
		if (category==null) {
			throw new IllegalArgumentException("Category is null");
		}

		if (consumer==null) {
			throw new IllegalArgumentException("Consumer is null");
		}
		
		if (consumer instanceof Component) {
			register(new MeasurementCategoryFactoryComponent() {
				
					public MeasurementConsumer getMeasurementConsumer(String cat) {
						return category.equals(cat) ? consumer : null;
					}

					public void start() throws ConfigurationException {
						((Component) consumer).start();						
					}

					public void stop() throws ConfigurationException {
						((Component) consumer).stop();
					}

					public void setOwner(Object owner) {
						// Ignore		

					}	
			});
		} else {					
			register(new MeasurementCategoryFactory() {
	
				public MeasurementConsumer getMeasurementConsumer(String cat) {
					return category.equals(cat) ? consumer : null;
				}
			});
		}
	}
	
	/**
	 * Mixture of factory and component to be implemented anonymously.
	 * @author Pavel Vlasov
	 * @revision $Revision: 1.6 $
	 */
	private static abstract class MeasurementCategoryFactoryComponent extends MeasurementCategoryFactory implements Component{
		
	}

	/**
	 * Register sink for all categories.
	 * @param consumer
	 */
	public static void register(final MeasurementConsumer consumer) {
		if (consumer==null) {
			throw new IllegalArgumentException("Consumer is null");
		}
		
		if (consumer instanceof Component) {
			register(new MeasurementCategoryFactoryComponent() {
				
					public MeasurementConsumer getMeasurementConsumer(String cat) {
						return consumer;
					}

					public void start() throws ConfigurationException {
						((Component) consumer).start();						
					}

					public void stop() throws ConfigurationException {
						((Component) consumer).stop();
					}

					public void setOwner(Object owner) {
						// Ignore		

					}	
			});
		} else {					
			register(new MeasurementCategoryFactory() {
	
				public MeasurementConsumer getMeasurementConsumer(String cat) {
					return consumer;
				}
			});
		}
	}

	/**
	 * Register sink for several categories.
	 * @param categories Categories, cannot be null and array elements cannot be null.
	 * @param consumer
	 */
	public static void register(final String[] categories, final MeasurementConsumer consumer) {
		if (categories==null) {
			throw new IllegalArgumentException("Categories is null");
		}

		if (consumer==null) {
			throw new IllegalArgumentException("Consumer is null");
		}
		
		if (consumer instanceof Component) {
			register(new MeasurementCategoryFactoryComponent() {
				
				public MeasurementConsumer getMeasurementConsumer(String cat) {
					for (int i=0; i<categories.length; i++) {
						if (categories[i].equals(cat)) {
							return consumer;
						}
					}
					return null;
				}

				public void start() throws ConfigurationException {
					((Component) consumer).start();						
				}

				public void stop() throws ConfigurationException {
					((Component) consumer).stop();
				}

				public void setOwner(Object owner) {
					// Ignore		

				}	
			});
		} else {					
			register(new MeasurementCategoryFactory() {
	
				public MeasurementConsumer getMeasurementConsumer(String cat) {
					for (int i=0; i<categories.length; i++) {
						if (categories[i].equals(cat)) {
							return consumer;
						}
					}
					return null;
				}
			});
		}
	}

	/**
	 * Unregisters consumer and its factory.
	 * @param consumer
	 */
	public static void unregister(MeasurementConsumer consumer) {
		synchronized (categories) {
			Iterator asit=factories.iterator();
			while (asit.hasNext()) {
				FactoryEntry entry=(FactoryEntry) asit.next();
				if (entry.consumers.contains(consumer)) {
					asit.remove();
				}
			}
			
			Iterator it=categories.values().iterator();
			while (it.hasNext()) {
				((MeasurementCategoryProxy) it.next()).removeConsumer(consumer);
			}
		}
		
		if (consumer instanceof Component) {
			try {
				((Component) consumer).stop();
			} catch (ConfigurationException e) {
				throw new RuntimeConfigurationException(e);
			}
		}
	}	

	/**
	 * Unregisters factory and its consumers.
	 * @param factory
	 */
	public static void unregister(MeasurementCategoryFactory factory) {
		synchronized (categories) {
			Iterator asit=factories.iterator();
			while (asit.hasNext()) {
				FactoryEntry entry=(FactoryEntry) asit.next();
				if (factory.equals(entry.factory)) {
					asit.remove();
				}
				
				Iterator it=categories.values().iterator();
				while (it.hasNext()) {
					((MeasurementCategoryProxy) it.next()).removeConsumers(entry.consumers);
				}
			}			
		}
		
		if (factory instanceof Component) {
			try {
				((Component) factory).stop();
			} catch (ConfigurationException e) {
				throw new RuntimeConfigurationException(e);
			}
		}
	}

	/**
	 *
	 */
	private static void shutdownBootConsumers() {
		Iterator it=bootConsumers.iterator();
		while (it.hasNext()) {
			Object o=it.next();
			if (o instanceof MeasurementConsumer) {
				unregister((MeasurementConsumer) o);
			} else if (o instanceof MeasurementCategoryFactory) {
				unregister((MeasurementCategoryFactory) o);
			} else if (o!=null) {
				logger.warning("Not measurement consumer or factory: "+o.getClass().getName());
			}
			it.remove();
		}
	}

}