ojluni/src/main/java/sun/jvmstat/perfdata/monitor/protocol/rmi/MonitoredHostProvider.java - platform/libcore.git - Git at Google

 /*
  * Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code 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 General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package sun.jvmstat.perfdata.monitor.protocol.rmi;

 import sun.jvmstat.monitor.*;
 import sun.jvmstat.monitor.event.*;
 import sun.jvmstat.monitor.remote.*;
 import sun.jvmstat.perfdata.monitor.*;
 import java.util.*;
 import java.net.*;
 import java.io.*;
 import java.rmi.*;
 import java.util.HashMap;

 /**
  * Concrete implementation of the MonitoredHost interface for the
  * <em>rmi</em> protocol of the HotSpot PerfData monitoring implementation.
  *
  * @author Brian Doherty
  * @since 1.5
  */
 public class MonitoredHostProvider extends MonitoredHost {
     private static final String serverName = "/JStatRemoteHost";
     private static final int DEFAULT_POLLING_INTERVAL = 1000;

     private ArrayList<HostListener> listeners;
     private NotifierTask task;
     private HashSet<Integer> activeVms;
     private RemoteVmManager vmManager;
     private RemoteHost remoteHost;
     private Timer timer;

     /**
      * Create a MonitoredHostProvider instance using the given HostIdentifier.
      *
      * @param hostId the host identifier for this MonitoredHost
      * @throws MonitorException Thrown on any error encountered while
      *                          communicating with the remote host.
      */
     public MonitoredHostProvider(HostIdentifier hostId)
            throws MonitorException {
         this.hostId = hostId;
         this.listeners = new ArrayList<HostListener>();
         this.interval = DEFAULT_POLLING_INTERVAL;
         this.activeVms = new HashSet<Integer>();

         String rmiName;
         String sn = serverName;
         String path = hostId.getPath();

         if ((path != null) && (path.length() > 0)) {
             sn = path;
         }

         if (hostId.getPort() != -1) {
             rmiName = "rmi://" + hostId.getHost() + ":" + hostId.getPort() + sn;
         } else {
             rmiName = "rmi://" + hostId.getHost() + sn;
         }

         try {
             remoteHost = (RemoteHost)Naming.lookup(rmiName);

         } catch (RemoteException e) {
             /*
              * rmi registry not available
              *
              * Access control exceptions, where the rmi server refuses a
              * connection based on policy file configuration, come through
              * here on the client side. Unfortunately, the RemoteException
              * doesn't contain enough information to determine the true cause
              * of the exception. So, we have to output a rather generic message.
              */
             String message = "RMI Registry not available at "
                              + hostId.getHost();

             if (hostId.getPort() == -1) {
                 message = message + ":"
                           + java.rmi.registry.Registry.REGISTRY_PORT;
             } else {
                 message = message + ":" + hostId.getPort();
             }

             if (e.getMessage() != null) {
                 throw new MonitorException(message + "\n" + e.getMessage(), e);
             } else {
                 throw new MonitorException(message, e);
             }

         } catch (NotBoundException e) {
             // no server with given name
             String message = e.getMessage();
             if (message == null) message = rmiName;
             throw new MonitorException("RMI Server " + message
                                        + " not available", e);
         } catch (MalformedURLException e) {
             // this is a programming problem
             e.printStackTrace();
             throw new IllegalArgumentException("Malformed URL: " + rmiName);
         }
         this.vmManager = new RemoteVmManager(remoteHost);
         this.timer = new Timer(true);
     }

     /**
      * {@inheritDoc}
      */
     public MonitoredVm getMonitoredVm(VmIdentifier vmid)
                        throws MonitorException {
         return getMonitoredVm(vmid, DEFAULT_POLLING_INTERVAL);
     }

     /**
      * {@inheritDoc}
      */
     public MonitoredVm getMonitoredVm(VmIdentifier vmid, int interval)
                        throws MonitorException {
         VmIdentifier nvmid = null;
         try {
             nvmid = hostId.resolve(vmid);
             RemoteVm rvm = remoteHost.attachVm(vmid.getLocalVmId(),
                                                vmid.getMode());
             RemoteMonitoredVm rmvm = new RemoteMonitoredVm(rvm, nvmid, timer,
                                                            interval);
             rmvm.attach();
             return rmvm;

         } catch (RemoteException e) {
             throw new MonitorException("Remote Exception attaching to "
                                        + nvmid.toString(), e);
         } catch (URISyntaxException e) {
             /*
              * the VmIdentifier is expected to be a valid and should resolve
              * easonably against the host identifier. A URISyntaxException
              * here is most likely a programming error.
              */
             throw new IllegalArgumentException("Malformed URI: "
                                                + vmid.toString(), e);
         }
     }

     /**
      * {@inheritDoc}
      */
     public void detach(MonitoredVm vm) throws MonitorException {
         RemoteMonitoredVm rmvm = (RemoteMonitoredVm)vm;
         rmvm.detach();
         try {
             remoteHost.detachVm(rmvm.getRemoteVm());

         } catch (RemoteException e) {
             throw new MonitorException("Remote Exception detaching from "
                                        + vm.getVmIdentifier().toString(), e);
         }
     }

     /**
      * {@inheritDoc}
      */
     public void addHostListener(HostListener listener) {
         synchronized(listeners) {
             listeners.add(listener);
             if (task == null) {
                 task = new NotifierTask();
                 timer.schedule(task, 0, interval);
             }
         }
     }

     /**
      * {@inheritDoc}
      */
     public void removeHostListener(HostListener listener) {
         /*
          * XXX: if a disconnect method is added, make sure it calls
          * this method to unregister this object from the watcher. otherwise,
          * an unused MonitoredHostProvider instance may go uncollected.
          */
         synchronized(listeners) {
             listeners.remove(listener);
             if (listeners.isEmpty() && (task != null)) {
                 task.cancel();
                 task = null;
             }
         }
     }

     public void setInterval(int newInterval) {
         synchronized(listeners) {
             if (newInterval == interval) {
                 return;
             }

             int oldInterval = interval;
             super.setInterval(newInterval);

             if (task != null) {
                 task.cancel();
                 NotifierTask oldTask = task;
                 task = new NotifierTask();
                 CountedTimerTaskUtils.reschedule(timer, oldTask, task,
                                                  oldInterval, newInterval);
             }
         }
     }

     /**
      * {@inheritDoc}
      */
     public Set<Integer> activeVms() throws MonitorException {
         return vmManager.activeVms();
     }

     /**
      * Fire VmStatusChangeEvent events to HostListener objects
      *
      * @param active Set of Integer objects containing the local
      *               Vm Identifiers of the active JVMs
      * @param started Set of Integer objects containing the local
      *                Vm Identifiers of new JVMs started since last
      *                interval.
      * @param terminated Set of Integer objects containing the local
      *                   Vm Identifiers of terminated JVMs since last
      *                   interval.
      */
     private void fireVmStatusChangedEvents(Set active, Set started,
                                            Set terminated) {
         ArrayList registered = null;
         VmStatusChangeEvent ev = null;

         synchronized(listeners) {
             registered = (ArrayList)listeners.clone();
         }

         for (Iterator i = registered.iterator(); i.hasNext(); /* empty */) {
             HostListener l = (HostListener)i.next();
             if (ev == null) {
                 ev = new VmStatusChangeEvent(this, active, started, terminated);
             }
             l.vmStatusChanged(ev);
         }
     }

     /**
      * Fire hostDisconnectEvent events.
      */
     void fireDisconnectedEvents() {
         ArrayList registered = null;
         HostEvent ev = null;

         synchronized(listeners) {
             registered = (ArrayList)listeners.clone();
         }

         for (Iterator i = registered.iterator(); i.hasNext(); /* empty */) {
             HostListener l = (HostListener)i.next();
             if (ev == null) {
                 ev = new HostEvent(this);
             }
             l.disconnected(ev);
         }
     }

     /**
      * class to poll the remote machine and generate local event notifications.
      */
     private class NotifierTask extends CountedTimerTask {
         public void run() {
             super.run();

             // save the last set of active JVMs
             Set lastActiveVms = activeVms;

             try {
                 // get the current set of active JVMs
                 activeVms = (HashSet<Integer>)vmManager.activeVms();

             } catch (MonitorException e) {
                 // XXX: use logging api
                 System.err.println("MonitoredHostProvider: polling task "
                                    + "caught MonitorException:");
                 e.printStackTrace();

                 // mark the HostManager as errored and notify listeners
                 setLastException(e);
                 fireDisconnectedEvents();
             }

             if (activeVms.isEmpty()) {
                 return;
             }

             Set<Integer> startedVms = new HashSet<Integer>();
             Set<Object> terminatedVms = new HashSet<Object>();

             for (Iterator i = activeVms.iterator(); i.hasNext(); /* empty */ ) {
                 Integer vmid = (Integer)i.next();
                 if (!lastActiveVms.contains(vmid)) {
                     // a new file has been detected, add to set
                     startedVms.add(vmid);
                 }
             }

             for (Iterator i = lastActiveVms.iterator(); i.hasNext();
                     /* empty */ ) {
                 Object o = i.next();
                 if (!activeVms.contains(o)) {
                     // JVM has terminated, remove it from the active list
                     terminatedVms.add(o);
                 }
             }

             if (!startedVms.isEmpty() || !terminatedVms.isEmpty()) {
                 fireVmStatusChangedEvents(activeVms, startedVms, terminatedVms);
             }
         }
     }
 }
	/*
	* Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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 General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.jvmstat.perfdata.monitor.protocol.rmi;

	import sun.jvmstat.monitor.*;
	import sun.jvmstat.monitor.event.*;
	import sun.jvmstat.monitor.remote.*;
	import sun.jvmstat.perfdata.monitor.*;
	import java.util.*;
	import java.net.*;
	import java.io.*;
	import java.rmi.*;
	import java.util.HashMap;

	/**
	* Concrete implementation of the MonitoredHost interface for the
	* <em>rmi</em> protocol of the HotSpot PerfData monitoring implementation.
	*
	* @author Brian Doherty
	* @since 1.5
	*/
	public class MonitoredHostProvider extends MonitoredHost {
	private static final String serverName = "/JStatRemoteHost";
	private static final int DEFAULT_POLLING_INTERVAL = 1000;

	private ArrayList<HostListener> listeners;
	private NotifierTask task;
	private HashSet<Integer> activeVms;
	private RemoteVmManager vmManager;
	private RemoteHost remoteHost;
	private Timer timer;

	/**
	* Create a MonitoredHostProvider instance using the given HostIdentifier.
	*
	* @param hostId the host identifier for this MonitoredHost
	* @throws MonitorException Thrown on any error encountered while
	* communicating with the remote host.
	*/
	public MonitoredHostProvider(HostIdentifier hostId)
	throws MonitorException {
	this.hostId = hostId;
	this.listeners = new ArrayList<HostListener>();
	this.interval = DEFAULT_POLLING_INTERVAL;
	this.activeVms = new HashSet<Integer>();

	String rmiName;
	String sn = serverName;
	String path = hostId.getPath();

	if ((path != null) && (path.length() > 0)) {
	sn = path;
	}

	if (hostId.getPort() != -1) {
	rmiName = "rmi://" + hostId.getHost() + ":" + hostId.getPort() + sn;
	} else {
	rmiName = "rmi://" + hostId.getHost() + sn;
	}

	try {
	remoteHost = (RemoteHost)Naming.lookup(rmiName);

	} catch (RemoteException e) {
	/*
	* rmi registry not available
	*
	* Access control exceptions, where the rmi server refuses a
	* connection based on policy file configuration, come through
	* here on the client side. Unfortunately, the RemoteException
	* doesn't contain enough information to determine the true cause
	* of the exception. So, we have to output a rather generic message.
	*/
	String message = "RMI Registry not available at "
	+ hostId.getHost();

	if (hostId.getPort() == -1) {
	message = message + ":"
	+ java.rmi.registry.Registry.REGISTRY_PORT;
	} else {
	message = message + ":" + hostId.getPort();
	}

	if (e.getMessage() != null) {
	throw new MonitorException(message + "\n" + e.getMessage(), e);
	} else {
	throw new MonitorException(message, e);
	}

	} catch (NotBoundException e) {
	// no server with given name
	String message = e.getMessage();
	if (message == null) message = rmiName;
	throw new MonitorException("RMI Server " + message
	+ " not available", e);
	} catch (MalformedURLException e) {
	// this is a programming problem
	e.printStackTrace();
	throw new IllegalArgumentException("Malformed URL: " + rmiName);
	}
	this.vmManager = new RemoteVmManager(remoteHost);
	this.timer = new Timer(true);
	}

	/**
	* {@inheritDoc}
	*/
	public MonitoredVm getMonitoredVm(VmIdentifier vmid)
	throws MonitorException {
	return getMonitoredVm(vmid, DEFAULT_POLLING_INTERVAL);
	}

	/**
	* {@inheritDoc}
	*/
	public MonitoredVm getMonitoredVm(VmIdentifier vmid, int interval)
	throws MonitorException {
	VmIdentifier nvmid = null;
	try {
	nvmid = hostId.resolve(vmid);
	RemoteVm rvm = remoteHost.attachVm(vmid.getLocalVmId(),
	vmid.getMode());
	RemoteMonitoredVm rmvm = new RemoteMonitoredVm(rvm, nvmid, timer,
	interval);
	rmvm.attach();
	return rmvm;

	} catch (RemoteException e) {
	throw new MonitorException("Remote Exception attaching to "
	+ nvmid.toString(), e);
	} catch (URISyntaxException e) {
	/*
	* the VmIdentifier is expected to be a valid and should resolve
	* easonably against the host identifier. A URISyntaxException
	* here is most likely a programming error.
	*/
	throw new IllegalArgumentException("Malformed URI: "
	+ vmid.toString(), e);
	}
	}

	/**
	* {@inheritDoc}
	*/
	public void detach(MonitoredVm vm) throws MonitorException {
	RemoteMonitoredVm rmvm = (RemoteMonitoredVm)vm;
	rmvm.detach();
	try {
	remoteHost.detachVm(rmvm.getRemoteVm());

	} catch (RemoteException e) {
	throw new MonitorException("Remote Exception detaching from "
	+ vm.getVmIdentifier().toString(), e);
	}
	}

	/**
	* {@inheritDoc}
	*/
	public void addHostListener(HostListener listener) {
	synchronized(listeners) {
	listeners.add(listener);
	if (task == null) {
	task = new NotifierTask();
	timer.schedule(task, 0, interval);
	}
	}
	}

	/**
	* {@inheritDoc}
	*/
	public void removeHostListener(HostListener listener) {
	/*
	* XXX: if a disconnect method is added, make sure it calls
	* this method to unregister this object from the watcher. otherwise,
	* an unused MonitoredHostProvider instance may go uncollected.
	*/
	synchronized(listeners) {
	listeners.remove(listener);
	if (listeners.isEmpty() && (task != null)) {
	task.cancel();
	task = null;
	}
	}
	}

	public void setInterval(int newInterval) {
	synchronized(listeners) {
	if (newInterval == interval) {
	return;
	}

	int oldInterval = interval;
	super.setInterval(newInterval);

	if (task != null) {
	task.cancel();
	NotifierTask oldTask = task;
	task = new NotifierTask();
	CountedTimerTaskUtils.reschedule(timer, oldTask, task,
	oldInterval, newInterval);
	}
	}
	}

	/**
	* {@inheritDoc}
	*/
	public Set<Integer> activeVms() throws MonitorException {
	return vmManager.activeVms();
	}

	/**
	* Fire VmStatusChangeEvent events to HostListener objects
	*
	* @param active Set of Integer objects containing the local
	* Vm Identifiers of the active JVMs
	* @param started Set of Integer objects containing the local
	* Vm Identifiers of new JVMs started since last
	* interval.
	* @param terminated Set of Integer objects containing the local
	* Vm Identifiers of terminated JVMs since last
	* interval.
	*/
	private void fireVmStatusChangedEvents(Set active, Set started,
	Set terminated) {
	ArrayList registered = null;
	VmStatusChangeEvent ev = null;

	synchronized(listeners) {
	registered = (ArrayList)listeners.clone();
	}

	for (Iterator i = registered.iterator(); i.hasNext(); /* empty */) {
	HostListener l = (HostListener)i.next();
	if (ev == null) {
	ev = new VmStatusChangeEvent(this, active, started, terminated);
	}
	l.vmStatusChanged(ev);
	}
	}

	/**
	* Fire hostDisconnectEvent events.
	*/
	void fireDisconnectedEvents() {
	ArrayList registered = null;
	HostEvent ev = null;

	synchronized(listeners) {
	registered = (ArrayList)listeners.clone();
	}

	for (Iterator i = registered.iterator(); i.hasNext(); /* empty */) {
	HostListener l = (HostListener)i.next();
	if (ev == null) {
	ev = new HostEvent(this);
	}
	l.disconnected(ev);
	}
	}

	/**
	* class to poll the remote machine and generate local event notifications.
	*/
	private class NotifierTask extends CountedTimerTask {
	public void run() {
	super.run();

	// save the last set of active JVMs
	Set lastActiveVms = activeVms;

	try {
	// get the current set of active JVMs
	activeVms = (HashSet<Integer>)vmManager.activeVms();

	} catch (MonitorException e) {
	// XXX: use logging api
	System.err.println("MonitoredHostProvider: polling task "
	+ "caught MonitorException:");
	e.printStackTrace();

	// mark the HostManager as errored and notify listeners
	setLastException(e);
	fireDisconnectedEvents();
	}

	if (activeVms.isEmpty()) {
	return;
	}

	Set<Integer> startedVms = new HashSet<Integer>();
	Set<Object> terminatedVms = new HashSet<Object>();

	for (Iterator i = activeVms.iterator(); i.hasNext(); /* empty */ ) {
	Integer vmid = (Integer)i.next();
	if (!lastActiveVms.contains(vmid)) {
	// a new file has been detected, add to set
	startedVms.add(vmid);
	}
	}

	for (Iterator i = lastActiveVms.iterator(); i.hasNext();
	/* empty */ ) {
	Object o = i.next();
	if (!activeVms.contains(o)) {
	// JVM has terminated, remove it from the active list
	terminatedVms.add(o);
	}
	}

	if (!startedVms.isEmpty() \|\| !terminatedVms.isEmpty()) {
	fireVmStatusChangedEvents(activeVms, startedVms, terminatedVms);
	}
	}
	}
	}