archive/net.sourceforge.phpeclipse.monitor.core/src/net/sourceforge/phpdt/monitor/core/internal/MonitorManager.java

   1 /**********************************************************************
   2  * Copyright (c) 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *    IBM - Initial API and implementation
  10  **********************************************************************/
  11 package net.sourceforge.phpdt.monitor.core.internal;
  12
  13 import java.io.ByteArrayInputStream;
  14 import java.util.ArrayList;
  15 import java.util.HashMap;
  16 import java.util.Iterator;
  17 import java.util.List;
  18 import java.util.Map;
  19
  20 import net.sourceforge.phpdt.monitor.core.IMonitor;
  21 import net.sourceforge.phpdt.monitor.core.IMonitorListener;
  22 import net.sourceforge.phpdt.monitor.core.IMonitorWorkingCopy;
  23 import net.sourceforge.phpdt.monitor.core.IRequest;
  24 import net.sourceforge.phpdt.monitor.core.IRequestListener;
  25
  26 import org.eclipse.core.runtime.Preferences;
  27 /**
  28  *
  29  */
  30 public class MonitorManager {
  31         private static final int ADD = 0;
  32         private static final int CHANGE = 1;
  33         private static final int REMOVE = 2;
  34
  35         // monitors
  36         protected List monitors;
  37         protected Map threads = new HashMap();
  38
  39         protected List monitorListeners = new ArrayList();
  40
  41         // requests
  42         protected List requests = new ArrayList();
  43
  44         protected List requestListeners = new ArrayList();
  45
  46         private Preferences.IPropertyChangeListener pcl;
  47         protected boolean ignorePreferenceChanges = false;
  48
  49         protected static MonitorManager instance;
  50
  51         public static MonitorManager getInstance() {
  52                 if (instance == null)
  53                         instance = new MonitorManager();
  54                 return instance;
  55         }
  56
  57         private MonitorManager() {
  58                 loadMonitors();
  59
  60                 pcl = new Preferences.IPropertyChangeListener() {
  61                         public void propertyChange(Preferences.PropertyChangeEvent event) {
  62                                 if (ignorePreferenceChanges)
  63                                         return;
  64                                 String property = event.getProperty();
  65                                 if (property.equals("monitors")) {
  66                                         loadMonitors();
  67                                 }
  68                         }
  69                 };
  70
  71                 MonitorPlugin.getInstance().getPluginPreferences().addPropertyChangeListener(pcl);
  72         }
  73
  74         protected void dispose() {
  75                 MonitorPlugin.getInstance().getPluginPreferences().removePropertyChangeListener(pcl);
  76         }
  77
  78         public IMonitorWorkingCopy createMonitor() {
  79                 return new MonitorWorkingCopy();
  80         }
  81
  82         public List getMonitors() {
  83                 return new ArrayList(monitors);
  84         }
  85
  86         protected void addMonitor(IMonitor monitor) {
  87                 if (!monitors.contains(monitor))
  88                         monitors.add(monitor);
  89                 fireMonitorEvent(monitor, ADD);
  90                 saveMonitors();
  91         }
  92
  93         protected boolean isRunning(IMonitor monitor) {
  94                 return (threads.get(monitor) != null);
  95         }
  96
  97         public void startMonitor(IMonitor monitor) throws Exception {
  98                 if (!monitors.contains(monitor))
  99                         return;
 100
 101                 if (AcceptThread.isPortInUse(monitor.getLocalPort()))
 102                         throw new Exception(MonitorPlugin.getString("%errorPortInUse"));
 103
 104                 AcceptThread thread = new AcceptThread(monitor);
 105                 thread.startServer();
 106                 threads.put(monitor, thread);
 107         }
 108
 109         public void stopMonitor(IMonitor monitor) {
 110                 if (!monitors.contains(monitor))
 111                         return;
 112
 113                 AcceptThread thread = (AcceptThread) threads.get(monitor);
 114                 if (thread != null) {
 115                         thread.stopServer();
 116                         threads.remove(monitor);
 117                 }
 118         }
 119
 120         protected void removeMonitor(IMonitor monitor) {
 121                 if (monitor.isRunning())
 122                         stopMonitor(monitor);
 123                 monitors.remove(monitor);
 124                 fireMonitorEvent(monitor, REMOVE);
 125                 saveMonitors();
 126         }
 127
 128         protected void monitorChanged(IMonitor monitor) {
 129                 fireMonitorEvent(monitor, CHANGE);
 130                 saveMonitors();
 131         }
 132
 133         /**
 134          * Add monitor listener.
 135          *
 136          * @param listener
 137          */
 138         public void addMonitorListener(IMonitorListener listener) {
 139                 monitorListeners.add(listener);
 140         }
 141
 142         /**
 143          * Remove monitor listener.
 144          *
 145          * @param listener
 146          */
 147         public void removeMonitorListener(IMonitorListener listener) {
 148                 monitorListeners.remove(listener);
 149         }
 150
 151         /**
 152          * Fire a monitor event.
 153          * @param rr
 154          * @param type
 155          */
 156         protected void fireMonitorEvent(IMonitor monitor, int type) {
 157                 Object[] obj = monitorListeners.toArray();
 158
 159                 int size = obj.length;
 160                 for (int i = 0; i < size; i++) {
 161                         IMonitorListener listener = (IMonitorListener) obj[i];
 162                         if (type == ADD)
 163                                 listener.monitorAdded(monitor);
 164                         else if (type == CHANGE)
 165                                 listener.monitorChanged(monitor);
 166                         else if (type == REMOVE)
 167                                 listener.monitorRemoved(monitor);
 168                 }
 169         }
 170
 171         /**
 172          * Returns a list of the current requests.
 173          *
 174          * @return java.util.List
 175          */
 176         public List getRequests() {
 177                 return requests;
 178         }
 179
 180         /**
 181          * Add a new request response pair.
 182          *
 183          * @param pair org.eclipse.tcpip.monitor.RequestResponse
 184          */
 185         public void addRequest(IRequest rr) {
 186                 if (requests.contains(rr))
 187                         return;
 188
 189                 requests.add(rr);
 190                 fireRequestEvent(rr, ADD);
 191         }
 192
 193         public void requestChanged(IRequest rr) {
 194                 fireRequestEvent(rr, CHANGE);
 195         }
 196
 197         public void removeRequest(IRequest rr) {
 198                 if (!requests.contains(rr))
 199                         return;
 200
 201                 requests.remove(rr);
 202                 fireRequestEvent(rr, REMOVE);
 203         }
 204
 205         public void removeAllRequests() {
 206                 int size = requests.size();
 207                 IRequest[] rrs = new IRequest[size];
 208                 requests.toArray(rrs);
 209
 210                 for (int i = 0; i < size; i++) {
 211                         removeRequest(rrs[i]);
 212                 }
 213         }
 214
 215         /**
 216          * Add request listener.
 217          *
 218          * @param listener
 219          */
 220         public void addRequestListener(IRequestListener listener) {
 221                 requestListeners.add(listener);
 222         }
 223
 224         /**
 225          * Remove request listener.
 226          *
 227          * @param listener
 228          */
 229         public void removeRequestListener(IRequestListener listener) {
 230                 requestListeners.remove(listener);
 231         }
 232
 233         /**
 234          * Fire a request event.
 235          * @param rr
 236          * @param type
 237          */
 238         protected void fireRequestEvent(IRequest rr, int type) {
 239                 int size = requestListeners.size();
 240                 IRequestListener[] xrl = MonitorPlugin.getInstance().getRequestListeners();
 241                 int size2 = xrl.length;
 242
 243                 IRequestListener[] rl = new IRequestListener[size + size2];
 244                 System.arraycopy(xrl, 0, rl, 0, size2);
 245                 for (int i = 0; i < size; i++)
 246                         rl[size2 + i] = (IRequestListener) requestListeners.get(i);
 247
 248                 for (int i = 0; i < size + size2; i++) {
 249                         IRequestListener listener = rl[i];
 250                         if (type == ADD)
 251                                 listener.requestAdded(rr);
 252                         else if (type == CHANGE)
 253                                 listener.requestChanged(rr);
 254                         else if (type == REMOVE)
 255                                 listener.requestRemoved(rr);
 256                 }
 257         }
 258
 259         protected void loadMonitors() {
 260                 Trace.trace(Trace.FINEST, "Loading monitors");
 261
 262                 monitors = new ArrayList();
 263                 Preferences prefs = MonitorPlugin.getInstance().getPluginPreferences();
 264                 String xmlString = prefs.getString("monitors");
 265                 if (xmlString != null && xmlString.length() > 0) {
 266                         try {
 267                                 ByteArrayInputStream in = new ByteArrayInputStream(xmlString.getBytes());
 268                                 IMemento memento = XMLMemento.loadMemento(in);
 269
 270                                 IMemento[] children = memento.getChildren("monitor");
 271                                 if (children != null) {
 272                                         int size = children.length;
 273                                         for (int i = 0; i < size; i++) {
 274                                                 Monitor monitor = new Monitor();
 275                                                 monitor.load(children[i]);
 276                                                 monitors.add(monitor);
 277                                         }
 278                                 }
 279                         } catch (Exception e) {
 280                                 Trace.trace(Trace.WARNING, "Could not load monitors: " + e.getMessage());
 281                         }
 282                 }
 283         }
 284
 285         protected void saveMonitors() {
 286                 try {
 287                         ignorePreferenceChanges = true;
 288                         XMLMemento memento = XMLMemento.createWriteRoot("monitors");
 289
 290                         Iterator iterator = monitors.iterator();
 291                         while (iterator.hasNext()) {
 292                                 Monitor monitor = (Monitor) iterator.next();
 293                                 IMemento child = memento.createChild("monitor");
 294                                 monitor.save(child);
 295                         }
 296
 297                         String xmlString = memento.saveToString();
 298                         Preferences prefs = MonitorPlugin.getInstance().getPluginPreferences();
 299                         prefs.setValue("monitors", xmlString);
 300                         MonitorPlugin.getInstance().savePluginPreferences();
 301                 } catch (Exception e) {
 302                         Trace.trace(Trace.SEVERE, "Could not save browsers", e);
 303                 }
 304                 ignorePreferenceChanges = false;
 305         }
 306 }