--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.management.jfr/share/classes/jdk/management/jfr/FlightRecorderMXBeanImpl.java Tue May 15 20:24:34 2018 +0200
@@ -0,0 +1,440 @@
+/*
+ * Copyright (c) 2016, 2018, 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 jdk.management.jfr;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.nio.file.Paths;
+import java.security.AccessControlContext;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.text.ParseException;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import javax.management.AttributeChangeNotification;
+import javax.management.AttributeNotFoundException;
+import javax.management.ListenerNotFoundException;
+import javax.management.MBeanException;
+import javax.management.MBeanNotificationInfo;
+import javax.management.Notification;
+import javax.management.NotificationBroadcasterSupport;
+import javax.management.NotificationEmitter;
+import javax.management.NotificationFilter;
+import javax.management.NotificationListener;
+import javax.management.ObjectName;
+import javax.management.ReflectionException;
+import javax.management.StandardEmitterMBean;
+
+import jdk.jfr.Configuration;
+import jdk.jfr.EventType;
+import jdk.jfr.FlightRecorder;
+import jdk.jfr.FlightRecorderListener;
+import jdk.jfr.FlightRecorderPermission;
+import jdk.jfr.Recording;
+import jdk.jfr.RecordingState;
+import jdk.jfr.internal.management.ManagementSupport;
+
+// Instantiated by service provider
+final class FlightRecorderMXBeanImpl extends StandardEmitterMBean implements FlightRecorderMXBean, NotificationEmitter {
+
+ final class MXBeanListener implements FlightRecorderListener {
+ private final NotificationListener listener;
+ private final NotificationFilter filter;
+ private final Object handback;
+ private final AccessControlContext context;
+
+ public MXBeanListener(NotificationListener listener, NotificationFilter filter, Object handback) {
+ this.context = AccessController.getContext();
+ this.listener = listener;
+ this.filter = filter;
+ this.handback = handback;
+ }
+
+ public void recordingStateChanged(Recording recording) {
+ AccessController.doPrivileged(new PrivilegedAction<Void>() {
+ @Override
+ public Void run() {
+ sendNotification(createNotication(recording));
+ return null;
+ }
+ }, context);
+ }
+ }
+
+ private static final String ATTRIBUTE_RECORDINGS = "Recordings";
+ private static final String OPTION_MAX_SIZE = "maxSize";
+ private static final String OPTION_MAX_AGE = "maxAge";
+ private static final String OPTION_NAME = "name";
+ private static final String OPTION_DISK = "disk";
+ private static final String OPTION_DUMP_ON_EXIT = "dumpOnExit";
+ private static final String OPTION_DURATION = "duration";
+ private static final List<String> OPTIONS = Arrays.asList(new String[] { OPTION_DUMP_ON_EXIT, OPTION_DURATION, OPTION_NAME, OPTION_MAX_AGE, OPTION_MAX_SIZE, OPTION_DISK, });
+ private final StreamManager streamHandler = new StreamManager();
+ private final Map<Long, Object> changes = new ConcurrentHashMap<>();
+ private final AtomicLong sequenceNumber = new AtomicLong();
+ private final List<MXBeanListener> listeners = new CopyOnWriteArrayList<>();
+ private FlightRecorder recorder;
+
+ FlightRecorderMXBeanImpl() {
+ super(FlightRecorderMXBean.class, true, new NotificationBroadcasterSupport(createNotificationInfo()));
+ }
+
+ @Override
+ public void startRecording(long id) {
+ MBeanUtils.checkControl();
+ getExistingRecording(id).start();
+ }
+
+ @Override
+ public boolean stopRecording(long id) {
+ MBeanUtils.checkControl();
+ return getExistingRecording(id).stop();
+ }
+
+ @Override
+ public void closeRecording(long id) {
+ MBeanUtils.checkControl();
+ getExistingRecording(id).close();
+ }
+
+ @Override
+ public long openStream(long id, Map<String, String> options) throws IOException {
+ MBeanUtils.checkControl();
+ if (!FlightRecorder.isInitialized()) {
+ throw new IllegalArgumentException("No recording available with id " + id);
+ }
+ // Make local copy to prevent concurrent modification
+ Map<String, String> s = options == null ? new HashMap<>() : new HashMap<>(options);
+ Instant starttime = MBeanUtils.parseTimestamp(s.get("startTime"), Instant.MIN);
+ Instant endtime = MBeanUtils.parseTimestamp(s.get("endTime"), Instant.MAX);
+ int blockSize = MBeanUtils.parseBlockSize(s.get("blockSize"), StreamManager.DEFAULT_BLOCK_SIZE);
+ InputStream is = getExistingRecording(id).getStream(starttime, endtime);
+ if (is == null) {
+ throw new IOException("No recording data available");
+ }
+ return streamHandler.create(is, blockSize).getId();
+ }
+
+ @Override
+ public void closeStream(long streamIdentifier) throws IOException {
+ MBeanUtils.checkControl();
+ streamHandler.getStream(streamIdentifier).close();
+ }
+
+ @Override
+ public byte[] readStream(long streamIdentifier) throws IOException {
+ MBeanUtils.checkMonitor();
+ return streamHandler.getStream(streamIdentifier).read();
+ }
+
+ @Override
+ public List<RecordingInfo> getRecordings() {
+ MBeanUtils.checkMonitor();
+ if (!FlightRecorder.isInitialized()) {
+ return Collections.emptyList();
+ }
+ return MBeanUtils.transformList(getRecorder().getRecordings(), RecordingInfo::new);
+ }
+
+ @Override
+ public List<ConfigurationInfo> getConfigurations() {
+ MBeanUtils.checkMonitor();
+ return MBeanUtils.transformList(Configuration.getConfigurations(), ConfigurationInfo::new);
+ }
+
+ @Override
+ public List<EventTypeInfo> getEventTypes() {
+ MBeanUtils.checkMonitor();
+ List<EventType> eventTypes = AccessController.doPrivileged(new PrivilegedAction<List<EventType>>() {
+ @Override
+ public List<EventType> run() {
+ return ManagementSupport.getEventTypes();
+ }
+ }, null, new FlightRecorderPermission("accessFlightRecorder"));
+
+ return MBeanUtils.transformList(eventTypes, EventTypeInfo::new);
+ }
+
+ @Override
+ public Map<String, String> getRecordingSettings(long recording) throws IllegalArgumentException {
+ MBeanUtils.checkMonitor();
+ return getExistingRecording(recording).getSettings();
+ }
+
+ @Override
+ public void setRecordingSettings(long recording, Map<String, String> values) throws IllegalArgumentException {
+ Objects.requireNonNull(values);
+ MBeanUtils.checkControl();
+ getExistingRecording(recording).setSettings(values);
+ }
+
+ @Override
+ public long newRecording() {
+ MBeanUtils.checkControl();
+ getRecorder(); // ensure notification listener is setup
+ return AccessController.doPrivileged(new PrivilegedAction<Recording>() {
+ @Override
+ public Recording run() {
+ return new Recording();
+ }
+ }, null, new FlightRecorderPermission("accessFlightRecorder")).getId();
+ }
+
+ @Override
+ public long takeSnapshot() {
+ MBeanUtils.checkControl();
+ return getRecorder().takeSnapshot().getId();
+ }
+
+ @Override
+ public void setConfiguration(long recording, String configuration) throws IllegalArgumentException {
+ Objects.requireNonNull(configuration);
+ MBeanUtils.checkControl();
+ try {
+ Configuration c = Configuration.create(new StringReader(configuration));
+ getExistingRecording(recording).setSettings(c.getSettings());
+ } catch (IOException | ParseException e) {
+ throw new IllegalArgumentException("Could not parse configuration", e);
+ }
+ }
+
+ @Override
+ public void setPredefinedConfiguration(long recording, String configurationName) throws IllegalArgumentException {
+ Objects.requireNonNull(configurationName);
+ MBeanUtils.checkControl();
+ Recording r = getExistingRecording(recording);
+ for (Configuration c : Configuration.getConfigurations()) {
+ if (c.getName().equals(configurationName)) {
+ r.setSettings(c.getSettings());
+ return;
+ }
+ }
+ throw new IllegalArgumentException("Could not find configuration with name " + configurationName);
+ }
+
+ @Override
+ public void copyTo(long recording, String path) throws IOException {
+ Objects.requireNonNull(path);
+ MBeanUtils.checkControl();
+ getExistingRecording(recording).dump(Paths.get(path));
+ }
+
+ @Override
+ public void setRecordingOptions(long recording, Map<String, String> options) throws IllegalArgumentException {
+ Objects.requireNonNull(options);
+ MBeanUtils.checkControl();
+ // Make local copy to prevent concurrent modification
+ Map<String, String> ops = new HashMap<String, String>(options);
+ for (Map.Entry<String, String> entry : ops.entrySet()) {
+ Object key = entry.getKey();
+ Object value = entry.getValue();
+ if (!(key instanceof String)) {
+ throw new IllegalArgumentException("Option key must not be null, or other type than " + String.class);
+ }
+ if (!OPTIONS.contains(key)) {
+ throw new IllegalArgumentException("Unknown recording option: " + key + ". Valid options are " + OPTIONS + ".");
+ }
+ if (value != null && !(value instanceof String)) {
+ throw new IllegalArgumentException("Incorrect value for option " + key + ". Values must be of type " + String.class + " .");
+ }
+ }
+
+ Recording r = getExistingRecording(recording);
+ validateOption(ops, OPTION_DUMP_ON_EXIT, MBeanUtils::booleanValue);
+ validateOption(ops, OPTION_DISK, MBeanUtils::booleanValue);
+ validateOption(ops, OPTION_NAME, Function.identity());
+ validateOption(ops, OPTION_MAX_AGE, MBeanUtils::duration);
+ validateOption(ops, OPTION_MAX_SIZE, MBeanUtils::size);
+ validateOption(ops, OPTION_DURATION, MBeanUtils::duration);
+
+ // All OK, now set them.atomically
+ setOption(ops, OPTION_DUMP_ON_EXIT, "false", MBeanUtils::booleanValue, x -> r.setDumpOnExit(x));
+ setOption(ops, OPTION_DISK, "true", MBeanUtils::booleanValue, x -> r.setToDisk(x));
+ setOption(ops, OPTION_NAME, String.valueOf(r.getId()), Function.identity(), x -> r.setName(x));
+ setOption(ops, OPTION_MAX_AGE, null, MBeanUtils::duration, x -> r.setMaxAge(x));
+ setOption(ops, OPTION_MAX_SIZE, "0", MBeanUtils::size, x -> r.setMaxSize(x));
+ setOption(ops, OPTION_DURATION, null, MBeanUtils::duration, x -> r.setDuration(x));
+ }
+
+ @Override
+ public Map<String, String> getRecordingOptions(long recording) throws IllegalArgumentException {
+ MBeanUtils.checkMonitor();
+ Recording r = getExistingRecording(recording);
+ Map<String, String> options = new HashMap<>(10);
+ options.put(OPTION_DUMP_ON_EXIT, String.valueOf(r.getDumpOnExit()));
+ options.put(OPTION_DISK, String.valueOf(r.isToDisk()));
+ options.put(OPTION_NAME, String.valueOf(r.getName()));
+ options.put(OPTION_MAX_AGE, ManagementSupport.formatTimespan(r.getMaxAge(), " "));
+ Long maxSize = r.getMaxSize();
+ options.put(OPTION_MAX_SIZE, String.valueOf(maxSize == null ? "0" : maxSize.toString()));
+ options.put(OPTION_DURATION, ManagementSupport.formatTimespan(r.getDuration(), " "));
+ return options;
+ }
+
+ @Override
+ public long cloneRecording(long id, boolean stop) throws IllegalStateException, SecurityException {
+ MBeanUtils.checkControl();
+ return getRecording(id).copy(stop).getId();
+ }
+
+ @Override
+ public ObjectName getObjectName() {
+ return MBeanUtils.createObjectName();
+ }
+
+ private Recording getExistingRecording(long id) {
+ if (FlightRecorder.isInitialized()) {
+ Recording recording = getRecording(id);
+ if (recording != null) {
+ return recording;
+ }
+ }
+ throw new IllegalArgumentException("No recording available with id " + id);
+ }
+
+ private Recording getRecording(long id) {
+ List<Recording> recs = getRecorder().getRecordings();
+ return recs.stream().filter(r -> r.getId() == id).findFirst().orElse(null);
+ }
+
+ private static <T, U> void setOption(Map<String, String> options, String name, String defaultValue, Function<String, U> converter, Consumer<U> setter) {
+ if (!options.containsKey(name)) {
+ return;
+ }
+ String v = options.get(name);
+ if (v == null) {
+ v = defaultValue;
+ }
+ try {
+ setter.accept(converter.apply(v));
+ } catch (IllegalArgumentException iae) {
+ throw new IllegalArgumentException("Not a valid value for option '" + name + "'. " + iae.getMessage());
+ }
+ }
+
+ private static <T, U> void validateOption(Map<String, String> options, String name, Function<String, U> validator) {
+ try {
+ String v = options.get(name);
+ if (v == null) {
+ return; // OK, will set default
+ }
+ validator.apply(v);
+ } catch (IllegalArgumentException iae) {
+ throw new IllegalArgumentException("Not a valid value for option '" + name + "'. " + iae.getMessage());
+ }
+ }
+
+ private FlightRecorder getRecorder() throws SecurityException {
+ // Synchronize on some private object that is always available
+ synchronized (streamHandler) {
+ if (recorder == null) {
+ recorder = AccessController.doPrivileged(new PrivilegedAction<FlightRecorder>() {
+ @Override
+ public FlightRecorder run() {
+ return FlightRecorder.getFlightRecorder();
+ }
+ }, null, new FlightRecorderPermission("accessFlightRecorder"));
+ }
+ return recorder;
+ }
+ }
+
+ private static MBeanNotificationInfo[] createNotificationInfo() {
+ String[] types = new String[] { AttributeChangeNotification.ATTRIBUTE_CHANGE };
+ String name = AttributeChangeNotification.class.getName();
+ String description = "Notifies if the RecordingState has changed for one of the recordings, for example if a recording starts or stops";
+ MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description);
+ return new MBeanNotificationInfo[] { info };
+ }
+
+ @Override
+ public void addNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) {
+ MXBeanListener mxbeanListener = new MXBeanListener(listener, filter, handback);
+ listeners.add(mxbeanListener);
+ AccessController.doPrivileged(new PrivilegedAction<Void>() {
+ @Override
+ public Void run(){
+ FlightRecorder.addListener(mxbeanListener);
+ return null;
+ }
+ }, null, new FlightRecorderPermission("accessFlightRecorder"));
+ super.addNotificationListener(listener, filter, handback);
+ }
+
+ @Override
+ public void removeNotificationListener(NotificationListener listener) throws ListenerNotFoundException {
+ removeListeners( x -> listener == x.listener);
+ super.removeNotificationListener(listener);
+ }
+
+ @Override
+ public void removeNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) throws ListenerNotFoundException {
+ removeListeners( x -> listener == x.listener && filter == x.filter && handback == x.handback);
+ super.removeNotificationListener(listener, filter, handback);
+ }
+
+ private void removeListeners(Predicate<MXBeanListener> p) {
+ List<MXBeanListener> toBeRemoved = new ArrayList<>(listeners.size());
+ for (MXBeanListener l : listeners) {
+ if (p.test(l)) {
+ toBeRemoved.add(l);
+ FlightRecorder.removeListener(l);
+ }
+ }
+ listeners.removeAll(toBeRemoved);
+ }
+
+ private Notification createNotication(Recording recording) {
+ try {
+ Long id = recording.getId();
+ Object oldValue = changes.get(recording.getId());
+ Object newValue = getAttribute(ATTRIBUTE_RECORDINGS);
+ if (recording.getState() != RecordingState.CLOSED) {
+ changes.put(id, newValue);
+ } else {
+ changes.remove(id);
+ }
+ return new AttributeChangeNotification(getObjectName(), sequenceNumber.incrementAndGet(), System.currentTimeMillis(), "Recording " + recording.getName() + " is "
+ + recording.getState(), ATTRIBUTE_RECORDINGS, newValue.getClass().getName(), oldValue, newValue);
+ } catch (AttributeNotFoundException | MBeanException | ReflectionException e) {
+ throw new RuntimeException("Could not create notifcation for FlightRecorderMXBean. " + e.getMessage(), e);
+ }
+ }
+}