1 /*

     2  * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.management.jfr;

    27 

    28 import java.io.IOException;

    29 import java.io.InputStream;

    30 import java.io.StringReader;

    31 import java.nio.file.Paths;

    32 import java.security.AccessControlContext;

    33 import java.security.AccessController;

    34 import java.security.PrivilegedAction;

    35 import java.text.ParseException;

    36 import java.time.Instant;

    37 import java.util.ArrayList;

    38 import java.util.Arrays;

    39 import java.util.Collections;

    40 import java.util.HashMap;

    41 import java.util.List;

    42 import java.util.Map;

    43 import java.util.Objects;

    44 import java.util.concurrent.ConcurrentHashMap;

    45 import java.util.concurrent.CopyOnWriteArrayList;

    46 import java.util.concurrent.atomic.AtomicLong;

    47 import java.util.function.Consumer;

    48 import java.util.function.Function;

    49 import java.util.function.Predicate;

    50 

    51 import javax.management.AttributeChangeNotification;

    52 import javax.management.AttributeNotFoundException;

    53 import javax.management.ListenerNotFoundException;

    54 import javax.management.MBeanException;

    55 import javax.management.MBeanNotificationInfo;

    56 import javax.management.Notification;

    57 import javax.management.NotificationBroadcasterSupport;

    58 import javax.management.NotificationEmitter;

    59 import javax.management.NotificationFilter;

    60 import javax.management.NotificationListener;

    61 import javax.management.ObjectName;

    62 import javax.management.ReflectionException;

    63 import javax.management.StandardEmitterMBean;

    64 

    65 import jdk.jfr.Configuration;

    66 import jdk.jfr.EventType;

    67 import jdk.jfr.FlightRecorder;

    68 import jdk.jfr.FlightRecorderListener;

    69 import jdk.jfr.FlightRecorderPermission;

    70 import jdk.jfr.Recording;

    71 import jdk.jfr.RecordingState;

    72 import jdk.jfr.internal.management.ManagementSupport;

    73 

    74 // Instantiated by service provider

    75 final class FlightRecorderMXBeanImpl extends StandardEmitterMBean implements FlightRecorderMXBean, NotificationEmitter {

    76 

    77     final class MXBeanListener implements FlightRecorderListener {

    78         private final NotificationListener listener;

    79         private final NotificationFilter filter;

    80         private final Object handback;

    81         private final AccessControlContext context;

    82 

    83         public MXBeanListener(NotificationListener listener, NotificationFilter filter, Object handback) {

    84             this.context = AccessController.getContext();

    85             this.listener = listener;

    86             this.filter = filter;

    87             this.handback = handback;

    88         }

    89 

    90         public void recordingStateChanged(Recording recording) {

    91             AccessController.doPrivileged(new PrivilegedAction<Void>() {

    92                 @Override

    93                 public Void run() {

    94                     sendNotification(createNotication(recording));

    95                     return null;

    96                 }

    97             }, context);

    98         }

    99     }

   100 

   101     private static final String ATTRIBUTE_RECORDINGS = "Recordings";

   102     private static final String OPTION_MAX_SIZE = "maxSize";

   103     private static final String OPTION_MAX_AGE = "maxAge";

   104     private static final String OPTION_NAME = "name";

   105     private static final String OPTION_DISK = "disk";

   106     private static final String OPTION_DUMP_ON_EXIT = "dumpOnExit";

   107     private static final String OPTION_DURATION = "duration";

   108     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, });

   109     private final StreamManager streamHandler = new StreamManager();

   110     private final Map<Long, Object> changes = new ConcurrentHashMap<>();

   111     private final AtomicLong sequenceNumber = new AtomicLong();

   112     private final List<MXBeanListener> listeners = new CopyOnWriteArrayList<>();

   113     private FlightRecorder recorder;

   114 

   115     FlightRecorderMXBeanImpl() {

   116         super(FlightRecorderMXBean.class, true, new NotificationBroadcasterSupport(createNotificationInfo()));

   117     }

   118 

   119     @Override

   120     public void startRecording(long id) {

   121         MBeanUtils.checkControl();

   122         getExistingRecording(id).start();

   123     }

   124 

   125     @Override

   126     public boolean stopRecording(long id) {

   127         MBeanUtils.checkControl();

   128         return getExistingRecording(id).stop();

   129     }

   130 

   131     @Override

   132     public void closeRecording(long id) {

   133         MBeanUtils.checkControl();

   134         getExistingRecording(id).close();

   135     }

   136 

   137     @Override

   138     public long openStream(long id, Map<String, String> options) throws IOException {

   139         MBeanUtils.checkControl();

   140         if (!FlightRecorder.isInitialized()) {

   141             throw new IllegalArgumentException("No recording available with id " + id);

   142         }

   143         // Make local copy to prevent concurrent modification

   144         Map<String, String> s = options == null ? new HashMap<>() : new HashMap<>(options);

   145         Instant starttime = MBeanUtils.parseTimestamp(s.get("startTime"), Instant.MIN);

   146         Instant endtime = MBeanUtils.parseTimestamp(s.get("endTime"), Instant.MAX);

   147         int blockSize = MBeanUtils.parseBlockSize(s.get("blockSize"), StreamManager.DEFAULT_BLOCK_SIZE);

   148         InputStream is = getExistingRecording(id).getStream(starttime, endtime);

   149         if (is == null) {

   150             throw new IOException("No recording data available");

   151         }

   152         return streamHandler.create(is, blockSize).getId();

   153     }

   154 

   155     @Override

   156     public void closeStream(long streamIdentifier) throws IOException {

   157         MBeanUtils.checkControl();

   158         streamHandler.getStream(streamIdentifier).close();

   159     }

   160 

   161     @Override

   162     public byte[] readStream(long streamIdentifier) throws IOException {

   163         MBeanUtils.checkMonitor();

   164         return streamHandler.getStream(streamIdentifier).read();

   165     }

   166 

   167     @Override

   168     public List<RecordingInfo> getRecordings() {

   169         MBeanUtils.checkMonitor();

   170         if (!FlightRecorder.isInitialized()) {

   171             return Collections.emptyList();

   172         }

   173         return MBeanUtils.transformList(getRecorder().getRecordings(), RecordingInfo::new);

   174     }

   175 

   176     @Override

   177     public List<ConfigurationInfo> getConfigurations() {

   178         MBeanUtils.checkMonitor();

   179         return MBeanUtils.transformList(Configuration.getConfigurations(), ConfigurationInfo::new);

   180     }

   181 

   182     @Override

   183     public List<EventTypeInfo> getEventTypes() {

   184         MBeanUtils.checkMonitor();

   185         List<EventType> eventTypes = AccessController.doPrivileged(new PrivilegedAction<List<EventType>>() {

   186             @Override

   187             public List<EventType> run() {

   188                 return ManagementSupport.getEventTypes();

   189             }

   190         }, null, new FlightRecorderPermission("accessFlightRecorder"));

   191 

   192         return MBeanUtils.transformList(eventTypes, EventTypeInfo::new);

   193     }

   194 

   195     @Override

   196     public Map<String, String> getRecordingSettings(long recording) throws IllegalArgumentException {

   197         MBeanUtils.checkMonitor();

   198         return getExistingRecording(recording).getSettings();

   199     }

   200 

   201     @Override

   202     public void setRecordingSettings(long recording, Map<String, String> values) throws IllegalArgumentException {

   203         Objects.requireNonNull(values);

   204         MBeanUtils.checkControl();

   205         getExistingRecording(recording).setSettings(values);

   206     }

   207 

   208     @Override

   209     public long newRecording() {

   210         MBeanUtils.checkControl();

   211         getRecorder(); // ensure notification listener is setup

   212         return AccessController.doPrivileged(new PrivilegedAction<Recording>() {

   213             @Override

   214             public Recording run() {

   215                 return new Recording();

   216             }

   217         }, null, new FlightRecorderPermission("accessFlightRecorder")).getId();

   218     }

   219 

   220     @Override

   221     public long takeSnapshot() {

   222         MBeanUtils.checkControl();

   223         return getRecorder().takeSnapshot().getId();

   224     }

   225 

   226     @Override

   227     public void setConfiguration(long recording, String configuration) throws IllegalArgumentException {

   228         Objects.requireNonNull(configuration);

   229         MBeanUtils.checkControl();

   230         try {

   231             Configuration c = Configuration.create(new StringReader(configuration));

   232             getExistingRecording(recording).setSettings(c.getSettings());

   233         } catch (IOException | ParseException e) {

   234             throw new IllegalArgumentException("Could not parse configuration", e);

   235         }

   236     }

   237 

   238     @Override

   239     public void setPredefinedConfiguration(long recording, String configurationName) throws IllegalArgumentException {

   240         Objects.requireNonNull(configurationName);

   241         MBeanUtils.checkControl();

   242         Recording r = getExistingRecording(recording);

   243         for (Configuration c : Configuration.getConfigurations()) {

   244             if (c.getName().equals(configurationName)) {

   245                 r.setSettings(c.getSettings());

   246                 return;

   247             }

   248         }

   249         throw new IllegalArgumentException("Could not find configuration with name " + configurationName);

   250     }

   251 

   252     @Override

   253     public void copyTo(long recording, String path) throws IOException {

   254         Objects.requireNonNull(path);

   255         MBeanUtils.checkControl();

   256         getExistingRecording(recording).dump(Paths.get(path));

   257     }

   258 

   259     @Override

   260     public void setRecordingOptions(long recording, Map<String, String> options) throws IllegalArgumentException {

   261         Objects.requireNonNull(options);

   262         MBeanUtils.checkControl();

   263         // Make local copy to prevent concurrent modification

   264         Map<String, String> ops = new HashMap<String, String>(options);

   265         for (Map.Entry<String, String> entry : ops.entrySet()) {

   266             Object key = entry.getKey();

   267             Object value = entry.getValue();

   268             if (!(key instanceof String)) {

   269                 throw new IllegalArgumentException("Option key must not be null, or other type than " + String.class);

   270             }

   271             if (!OPTIONS.contains(key)) {

   272                 throw new IllegalArgumentException("Unknown recording option: " + key + ". Valid options are " + OPTIONS + ".");

   273             }

   274             if (value != null && !(value instanceof String)) {

   275                 throw new IllegalArgumentException("Incorrect value for option " + key + ". Values must be of type " + String.class + " .");

   276             }

   277         }

   278 

   279         Recording r = getExistingRecording(recording);

   280         validateOption(ops, OPTION_DUMP_ON_EXIT, MBeanUtils::booleanValue);

   281         validateOption(ops, OPTION_DISK, MBeanUtils::booleanValue);

   282         validateOption(ops, OPTION_NAME, Function.identity());

   283         validateOption(ops, OPTION_MAX_AGE, MBeanUtils::duration);

   284         validateOption(ops, OPTION_MAX_SIZE, MBeanUtils::size);

   285         validateOption(ops, OPTION_DURATION, MBeanUtils::duration);

   286 

   287         // All OK, now set them.atomically

   288         setOption(ops, OPTION_DUMP_ON_EXIT, "false", MBeanUtils::booleanValue, x -> r.setDumpOnExit(x));

   289         setOption(ops, OPTION_DISK, "true", MBeanUtils::booleanValue, x -> r.setToDisk(x));

   290         setOption(ops, OPTION_NAME, String.valueOf(r.getId()), Function.identity(), x -> r.setName(x));

   291         setOption(ops, OPTION_MAX_AGE, null, MBeanUtils::duration, x -> r.setMaxAge(x));

   292         setOption(ops, OPTION_MAX_SIZE, "0", MBeanUtils::size, x -> r.setMaxSize(x));

   293         setOption(ops, OPTION_DURATION, null, MBeanUtils::duration, x -> r.setDuration(x));

   294     }

   295 

   296     @Override

   297     public Map<String, String> getRecordingOptions(long recording) throws IllegalArgumentException {

   298         MBeanUtils.checkMonitor();

   299         Recording r = getExistingRecording(recording);

   300         Map<String, String> options = new HashMap<>(10);

   301         options.put(OPTION_DUMP_ON_EXIT, String.valueOf(r.getDumpOnExit()));

   302         options.put(OPTION_DISK, String.valueOf(r.isToDisk()));

   303         options.put(OPTION_NAME, String.valueOf(r.getName()));

   304         options.put(OPTION_MAX_AGE, ManagementSupport.formatTimespan(r.getMaxAge(), " "));

   305         Long maxSize = r.getMaxSize();

   306         options.put(OPTION_MAX_SIZE, String.valueOf(maxSize == null ? "0" : maxSize.toString()));

   307         options.put(OPTION_DURATION, ManagementSupport.formatTimespan(r.getDuration(), " "));

   308         return options;

   309     }

   310 

   311     @Override

   312     public long cloneRecording(long id, boolean stop) throws IllegalStateException, SecurityException {

   313         MBeanUtils.checkControl();

   314         return getRecording(id).copy(stop).getId();

   315     }

   316 

   317     @Override

   318     public ObjectName getObjectName() {

   319         return MBeanUtils.createObjectName();

   320     }

   321 

   322     private Recording getExistingRecording(long id) {

   323         if (FlightRecorder.isInitialized()) {

   324             Recording recording = getRecording(id);

   325             if (recording != null) {

   326                 return recording;

   327             }

   328         }

   329         throw new IllegalArgumentException("No recording available with id " + id);

   330     }

   331 

   332     private Recording getRecording(long id) {

   333         List<Recording> recs = getRecorder().getRecordings();

   334         return recs.stream().filter(r -> r.getId() == id).findFirst().orElse(null);

   335     }

   336 

   337     private static <T, U> void setOption(Map<String, String> options, String name, String defaultValue, Function<String, U> converter, Consumer<U> setter) {

   338         if (!options.containsKey(name)) {

   339             return;

   340         }

   341         String v = options.get(name);

   342         if (v == null) {

   343             v = defaultValue;

   344         }

   345         try {

   346             setter.accept(converter.apply(v));

   347         } catch (IllegalArgumentException iae) {

   348             throw new IllegalArgumentException("Not a valid value for option '" + name + "'. " + iae.getMessage());

   349         }

   350     }

   351 

   352     private static <T, U> void validateOption(Map<String, String> options, String name, Function<String, U> validator) {

   353         try {

   354             String v = options.get(name);

   355             if (v == null) {

   356                 return; // OK, will set default

   357             }

   358             validator.apply(v);

   359         } catch (IllegalArgumentException iae) {

   360             throw new IllegalArgumentException("Not a valid value for option '" + name + "'. " + iae.getMessage());

   361         }

   362     }

   363 

   364     private FlightRecorder getRecorder() throws SecurityException {

   365         // Synchronize on some private object that is always available

   366         synchronized (streamHandler) {

   367             if (recorder == null) {

   368                 recorder = AccessController.doPrivileged(new PrivilegedAction<FlightRecorder>() {

   369                     @Override

   370                     public FlightRecorder run() {

   371                         return FlightRecorder.getFlightRecorder();

   372                     }

   373                 }, null, new FlightRecorderPermission("accessFlightRecorder"));

   374             }

   375             return recorder;

   376         }

   377     }

   378 

   379     private static MBeanNotificationInfo[] createNotificationInfo() {

   380         String[] types = new String[] { AttributeChangeNotification.ATTRIBUTE_CHANGE };

   381         String name = AttributeChangeNotification.class.getName();

   382         String description = "Notifies if the RecordingState has changed for one of the recordings, for example if a recording starts or stops";

   383         MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description);

   384         return new MBeanNotificationInfo[] { info };

   385     }

   386 

   387     @Override

   388     public void addNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) {

   389         MXBeanListener mxbeanListener = new MXBeanListener(listener, filter, handback);

   390         listeners.add(mxbeanListener);

   391         AccessController.doPrivileged(new PrivilegedAction<Void>() {

   392             @Override

   393             public Void run(){

   394                 FlightRecorder.addListener(mxbeanListener);

   395                 return null;

   396             }

   397         }, null, new FlightRecorderPermission("accessFlightRecorder"));

   398         super.addNotificationListener(listener, filter, handback);

   399     }

   400 

   401     @Override

   402     public void removeNotificationListener(NotificationListener listener) throws ListenerNotFoundException {

   403         removeListeners( x -> listener == x.listener);

   404         super.removeNotificationListener(listener);

   405     }

   406 

   407     @Override

   408     public void removeNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) throws ListenerNotFoundException {

   409         removeListeners( x -> listener == x.listener && filter == x.filter && handback == x.handback);

   410         super.removeNotificationListener(listener, filter, handback);

   411     }

   412 

   413     private void removeListeners(Predicate<MXBeanListener> p) {

   414         List<MXBeanListener> toBeRemoved = new ArrayList<>(listeners.size());

   415         for (MXBeanListener l : listeners) {

   416             if (p.test(l)) {

   417                 toBeRemoved.add(l);

   418                 FlightRecorder.removeListener(l);

   419             }

   420         }

   421         listeners.removeAll(toBeRemoved);

   422     }

   423 

   424     private Notification createNotication(Recording recording) {

   425         try {

   426             Long id = recording.getId();

   427             Object oldValue = changes.get(recording.getId());

   428             Object newValue = getAttribute(ATTRIBUTE_RECORDINGS);

   429             if (recording.getState() != RecordingState.CLOSED) {

   430                 changes.put(id, newValue);

   431             } else {

   432                 changes.remove(id);

   433             }

   434             return new AttributeChangeNotification(getObjectName(), sequenceNumber.incrementAndGet(), System.currentTimeMillis(), "Recording " + recording.getName() + " is "

   435                     + recording.getState(), ATTRIBUTE_RECORDINGS, newValue.getClass().getName(), oldValue, newValue);

   436         } catch (AttributeNotFoundException | MBeanException | ReflectionException e) {

   437             throw new RuntimeException("Could not create notifcation for FlightRecorderMXBean. " + e.getMessage(), e);

   438         }

   439     }

   440 }