| /* |
| * Copyright (c) 2004, 2014, 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.lang.reflect.*; |
| import java.util.*; |
| import java.io.*; |
| import java.nio.ByteBuffer; |
| import java.rmi.*; |
| |
| /** |
| * Concrete implementation of the AbstractMonitoredVm class for the |
| * <em>rmi:</em> protocol for the HotSpot PerfData monitoring implementation. |
| * <p> |
| * This class provides the ability to acquire to the instrumentation buffer |
| * of a live, remote target Java Virtual Machine through an RMI server. |
| * |
| * @author Brian Doherty |
| * @since 1.5 |
| */ |
| public class RemoteMonitoredVm extends AbstractMonitoredVm { |
| |
| private ArrayList<VmListener> listeners; |
| private NotifierTask notifierTask; |
| private SamplerTask samplerTask; |
| private Timer timer; |
| |
| private RemoteVm rvm; |
| private ByteBuffer updateBuffer; |
| |
| /** |
| * Create a RemoteMonitoredVm instance. |
| * |
| * @param rvm the proxy to the remote MonitoredVm instance. |
| * @param vmid the vm identifier specifying the remot target JVM |
| * @param timer the timer used to run polling tasks |
| * @param interval the sampling interval |
| */ |
| public RemoteMonitoredVm(RemoteVm rvm, VmIdentifier vmid, |
| Timer timer, int interval) |
| throws MonitorException { |
| super(vmid, interval); |
| this.rvm = rvm; |
| pdb = new PerfDataBuffer(rvm, vmid.getLocalVmId()); |
| this.listeners = new ArrayList<VmListener>(); |
| this.timer = timer; |
| } |
| |
| /** |
| * Method to attach to the remote MonitoredVm. |
| */ |
| public void attach() throws MonitorException { |
| updateBuffer = pdb.getByteBuffer().duplicate(); |
| |
| // if continuous sampling is requested, register with the sampler thread |
| if (interval > 0) { |
| samplerTask = new SamplerTask(); |
| timer.schedule(samplerTask, 0, interval); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void detach() { |
| try { |
| if (interval > 0) { |
| if (samplerTask != null) { |
| samplerTask.cancel(); |
| samplerTask = null; |
| } |
| if (notifierTask != null) { |
| notifierTask.cancel(); |
| notifierTask = null; |
| } |
| sample(); |
| } |
| } catch (RemoteException e) { |
| // XXX: - use logging api? throw an exception instead? |
| System.err.println("Could not read data for remote JVM " + vmid); |
| e.printStackTrace(); |
| |
| } finally { |
| super.detach(); |
| } |
| } |
| |
| /** |
| * Get a copy of the remote instrumentation buffer. |
| *<p> |
| * The data in the remote instrumentation buffer is copied into |
| * a local byte buffer. |
| * |
| * @throws RemoteException Thrown on any communications errors with |
| * the remote system. |
| */ |
| public void sample() throws RemoteException { |
| assert updateBuffer != null; |
| ((PerfDataBuffer)pdb).sample(updateBuffer); |
| } |
| |
| /** |
| * Get the proxy to the remote MonitoredVm. |
| * |
| * @return RemoteVm - the proxy to the remote MonitoredVm. |
| */ |
| public RemoteVm getRemoteVm() { |
| return rvm; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void addVmListener(VmListener l) { |
| synchronized(listeners) { |
| listeners.add(l); |
| if (notifierTask == null) { |
| notifierTask = new NotifierTask(); |
| timer.schedule(notifierTask, 0, interval); |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void removeVmListener(VmListener l) { |
| synchronized(listeners) { |
| listeners.remove(l); |
| if (listeners.isEmpty() && (notifierTask != null)) { |
| notifierTask.cancel(); |
| notifierTask = null; |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void setInterval(int newInterval) { |
| synchronized(listeners) { |
| if (newInterval == interval) { |
| return; |
| } |
| |
| int oldInterval = interval; |
| super.setInterval(newInterval); |
| |
| if (samplerTask != null) { |
| samplerTask.cancel(); |
| SamplerTask oldSamplerTask = samplerTask; |
| samplerTask = new SamplerTask(); |
| CountedTimerTaskUtils.reschedule(timer, oldSamplerTask, |
| samplerTask, oldInterval, |
| newInterval); |
| } |
| if (notifierTask != null) { |
| notifierTask.cancel(); |
| NotifierTask oldNotifierTask = notifierTask; |
| notifierTask = new NotifierTask(); |
| CountedTimerTaskUtils.reschedule(timer, oldNotifierTask, |
| notifierTask, oldInterval, |
| newInterval); |
| } |
| } |
| } |
| |
| /** |
| * Fire MonitoredVmStructureChanged events. |
| * |
| * @param inserted List of Monitor objects inserted. |
| * @param removed List of Monitor objects removed. |
| */ |
| @SuppressWarnings("unchecked") // Cast of result of clone |
| void fireMonitorStatusChangedEvents(List<Monitor> inserted, List<Monitor> removed) { |
| ArrayList<VmListener> registered = null; |
| MonitorStatusChangeEvent ev = null; |
| |
| synchronized(listeners) { |
| registered = (ArrayList)listeners.clone(); |
| } |
| |
| for (Iterator<VmListener> i = registered.iterator(); i.hasNext(); /* empty */) { |
| VmListener l = i.next(); |
| if (ev == null) { |
| ev = new MonitorStatusChangeEvent(this, inserted, removed); |
| } |
| l.monitorStatusChanged(ev); |
| } |
| } |
| |
| /** |
| * Fire MonitoredVmStructureChanged events. |
| */ |
| @SuppressWarnings("unchecked") // Cast of result of clone |
| void fireMonitorsUpdatedEvents() { |
| ArrayList<VmListener> registered = null; |
| VmEvent ev = null; |
| |
| synchronized(listeners) { |
| registered = (ArrayList)listeners.clone(); |
| } |
| |
| for (Iterator<VmListener> i = registered.iterator(); i.hasNext(); /* empty */) { |
| VmListener l = i.next(); |
| if (ev == null) { |
| ev = new VmEvent(this); |
| } |
| l.monitorsUpdated(ev); |
| } |
| } |
| |
| /* |
| * Timer Tasks. There are two separate timer tasks here. The SamplerTask |
| * is active whenever we are attached to the remote JVM with a periodic |
| * sampling interval > 0. The NotifierTask is only active if a VmListener |
| * has registered with this RemoteMonitoredVm instance. Also, in the future |
| * we may want to run these tasks at different intervals. Currently, |
| * they run at the same interval and some significant work may |
| * need to be done to complete the separation of these two intervals. |
| */ |
| |
| /** |
| * Class to periodically check the state of the defined monitors |
| * for the remote MonitoredVm instance and to notify listeners of |
| * any detected changes. |
| */ |
| private class NotifierTask extends CountedTimerTask { |
| public void run() { |
| super.run(); |
| try { |
| MonitorStatus status = getMonitorStatus(); |
| |
| List<Monitor> inserted = status.getInserted(); |
| List<Monitor> removed = status.getRemoved(); |
| |
| if (!inserted.isEmpty() || !removed.isEmpty()) { |
| fireMonitorStatusChangedEvents(inserted, removed); |
| } |
| } catch (MonitorException e) { |
| // XXX: use logging api? fire disconnect events? mark errored? |
| // fireDisconnectedEvents(); |
| System.err.println("Exception updating monitors for " |
| + getVmIdentifier()); |
| e.printStackTrace(); |
| // XXX: should we cancle the notifierTask here? |
| // this.cancel(); |
| } |
| } |
| } |
| |
| /** |
| * Class to periodically sample the remote instrumentation byte buffer |
| * and refresh the local copy. Registered listeners are notified of |
| * the completion of a sampling event. |
| */ |
| private class SamplerTask extends CountedTimerTask { |
| public void run() { |
| super.run(); |
| try { |
| sample(); |
| fireMonitorsUpdatedEvents(); |
| |
| } catch (RemoteException e) { |
| // XXX: use logging api, mark vm as errored. |
| System.err.println("Exception taking sample for " |
| + getVmIdentifier()); |
| e.printStackTrace(); |
| this.cancel(); |
| } |
| } |
| } |
| } |