plugins/org.eclipse.wst.internet.monitor.core/monitorcore/org/eclipse/wst/internet/monitor/core/internal/MonitorManager.java

/**********************************************************************
 * Copyright (c) 2003, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 *
 * Contributors:
 *    IBM - Initial API and implementation
 **********************************************************************/
package org.eclipse.wst.internet.monitor.core.internal;

import java.io.ByteArrayInputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.Preferences;
import org.eclipse.wst.internet.monitor.core.*;
/**
 * 
 */
public class MonitorManager {
	private static final int ADD = 0;
	private static final int CHANGE = 1;
	private static final int REMOVE = 2;

	// monitors
	protected List monitors;
	protected Map threads = new HashMap();
	
	protected List monitorListeners = new ArrayList();
	
	// requests
	protected List requests = new ArrayList();
	
	protected List requestListeners = new ArrayList();
	
	private Preferences.IPropertyChangeListener pcl;
	protected boolean ignorePreferenceChanges = false;
	
	protected static MonitorManager instance;
	
	public static MonitorManager getInstance() {
		if (instance == null)
			instance = new MonitorManager();
		return instance;
	}
	
	private MonitorManager() {
		loadMonitors();
		
		pcl = new Preferences.IPropertyChangeListener() {
			public void propertyChange(Preferences.PropertyChangeEvent event) {
				if (ignorePreferenceChanges)
					return;
				String property = event.getProperty();
				if (property.equals("monitors")) {
					loadMonitors();
				}
			}
		};
		
		MonitorPlugin.getInstance().getPluginPreferences().addPropertyChangeListener(pcl);
	}
	
	protected void dispose() {
		MonitorPlugin.getInstance().getPluginPreferences().removePropertyChangeListener(pcl);
	}
	
	public IMonitorWorkingCopy createMonitor() {
		return new MonitorWorkingCopy();
	}
	
	public List getMonitors() {
		return new ArrayList(monitors);
	}

	protected void addMonitor(IMonitor monitor) {
		if (!monitors.contains(monitor))
			monitors.add(monitor);
		fireMonitorEvent(monitor, ADD);
		saveMonitors();
	}
	
	protected boolean isRunning(IMonitor monitor) {
		return (threads.get(monitor) != null);
	}

	public void startMonitor(IMonitor monitor) throws Exception {
		if (!monitors.contains(monitor))
			return;
		
		if (AcceptThread.isPortInUse(monitor.getLocalPort()))
			throw new Exception(MonitorPlugin.getString("%errorPortInUse"));
		
		AcceptThread thread = new AcceptThread(monitor);
		thread.startServer();
		threads.put(monitor, thread);
	}
	
	public void stopMonitor(IMonitor monitor) {
		if (!monitors.contains(monitor))
			return;
		
		AcceptThread thread = (AcceptThread) threads.get(monitor);
		if (thread != null) {
			thread.stopServer();
			threads.remove(monitor);
		}
	}
	
	protected void removeMonitor(IMonitor monitor) {
		if (monitor.isRunning())
			stopMonitor(monitor);
		monitors.remove(monitor);
		fireMonitorEvent(monitor, REMOVE);
		saveMonitors();
	}
	
	protected void monitorChanged(IMonitor monitor) {
		fireMonitorEvent(monitor, CHANGE);
		saveMonitors();
	}
	
	/**
	 * Add monitor listener.
	 * 
	 * @param listener
	 */
	public void addMonitorListener(IMonitorListener listener) {
		monitorListeners.add(listener);
	}

	/**
	 * Remove monitor listener.
	 * 
	 * @param listener
	 */
	public void removeMonitorListener(IMonitorListener listener) {
		monitorListeners.remove(listener);
	}
	
	/**
	 * Fire a monitor event.
	 * @param rr
	 * @param type
	 */
	protected void fireMonitorEvent(IMonitor monitor, int type) {
		Object[] obj = monitorListeners.toArray();
		
		int size = obj.length;
		for (int i = 0; i < size; i++) {
			IMonitorListener listener = (IMonitorListener) obj[i];
			if (type == ADD)
				listener.monitorAdded(monitor);
			else if (type == CHANGE)
				listener.monitorChanged(monitor);
			else if (type == REMOVE)
				listener.monitorRemoved(monitor);
		}
	}
	
	/**
	 * Returns a list of the current requests.
	 *
	 * @return java.util.List
	 */
	public List getRequests() {
		return requests;
	}
	
	/**
	 * Add a new request response pair.
	 *
	 * @param pair org.eclipse.tcpip.monitor.RequestResponse
	 */
	public void addRequest(IRequest rr) {
		if (requests.contains(rr))
			return;

		requests.add(rr);
		fireRequestEvent(rr, ADD);
	}
	
	public void requestChanged(IRequest rr) {
		fireRequestEvent(rr, CHANGE);
	}
	
	public void removeRequest(IRequest rr) {
		if (!requests.contains(rr))
			return;

		requests.remove(rr);
		fireRequestEvent(rr, REMOVE);
	}
	
	public void removeAllRequests() {
		int size = requests.size();
		IRequest[] rrs = new IRequest[size];
		requests.toArray(rrs);
		
		for (int i = 0; i < size; i++) {
			removeRequest(rrs[i]);
		}
	}
	
	/**
	 * Add request listener.
	 * 
	 * @param listener
	 */
	public void addRequestListener(IRequestListener listener) {
		requestListeners.add(listener);
	}

	/**
	 * Remove request listener.
	 * 
	 * @param listener
	 */
	public void removeRequestListener(IRequestListener listener) {
		requestListeners.remove(listener);
	}

	/**
	 * Fire a request event.
	 * @param rr
	 * @param type
	 */
	protected void fireRequestEvent(IRequest rr, int type) {
		int size = requestListeners.size();
		IRequestListener[] xrl = MonitorPlugin.getInstance().getRequestListeners();
		int size2 = xrl.length;
		
		IRequestListener[] rl = new IRequestListener[size + size2];
		System.arraycopy(xrl, 0, rl, 0, size2);
		for (int i = 0; i < size; i++)
			rl[size2 + i] = (IRequestListener) requestListeners.get(i);

		for (int i = 0; i < size + size2; i++) {
			IRequestListener listener = rl[i];
			if (type == ADD)
				listener.requestAdded(rr);
			else if (type == CHANGE)
				listener.requestChanged(rr);
			else if (type == REMOVE)
				listener.requestRemoved(rr);
		}
	}
	
	protected void loadMonitors() {
		Trace.trace(Trace.FINEST, "Loading monitors");
		
		monitors = new ArrayList();
		Preferences prefs = MonitorPlugin.getInstance().getPluginPreferences();
		String xmlString = prefs.getString("monitors");
		if (xmlString != null && xmlString.length() > 0) {
			try {
				ByteArrayInputStream in = new ByteArrayInputStream(xmlString.getBytes());
				IMemento memento = XMLMemento.loadMemento(in);
		
				IMemento[] children = memento.getChildren("monitor");
				if (children != null) {
					int size = children.length;
					for (int i = 0; i < size; i++) {
						Monitor monitor = new Monitor();
						monitor.load(children[i]);
						monitors.add(monitor);
					}
				}
			} catch (Exception e) {
				Trace.trace(Trace.WARNING, "Could not load monitors: " + e.getMessage());
			}
		}
	}
	
	protected void saveMonitors() {
		try {
			ignorePreferenceChanges = true;
			XMLMemento memento = XMLMemento.createWriteRoot("monitors");

			Iterator iterator = monitors.iterator();
			while (iterator.hasNext()) {
				Monitor monitor = (Monitor) iterator.next();
				IMemento child = memento.createChild("monitor");
				monitor.save(child);
			}
			
			String xmlString = memento.saveToString();
			Preferences prefs = MonitorPlugin.getInstance().getPluginPreferences();
			prefs.setValue("monitors", xmlString);
			MonitorPlugin.getInstance().savePluginPreferences();
		} catch (Exception e) {
			Trace.trace(Trace.SEVERE, "Could not save browsers", e);
		}
		ignorePreferenceChanges = false;
	}
}