1 /*
   2  * Copyright (c) 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.jfr.api.consumer;
  27 
  28 import java.io.FileNotFoundException;
  29 import java.io.FileWriter;
  30 import java.io.IOException;
  31 import java.io.RandomAccessFile;
  32 import java.nio.file.Files;
  33 import java.nio.file.Path;
  34 import java.nio.file.Paths;
  35 import java.util.Arrays;
  36 import java.util.HashSet;
  37 import java.util.List;
  38 import java.util.StringJoiner;
  39 
  40 
  41 import jdk.jfr.Event;
  42 import jdk.jfr.EventType;
  43 import jdk.jfr.FlightRecorder;
  44 import jdk.jfr.Name;
  45 import jdk.jfr.Recording;
  46 import jdk.jfr.Registered;
  47 import jdk.jfr.consumer.RecordedEvent;
  48 import jdk.jfr.consumer.RecordingFile;
  49 import jdk.test.lib.Asserts;
  50 import jdk.test.lib.Utils;
  51 
  52 /**
  53  * @test
  54  * @summary Verifies that all methods in RecordingFIle are working
  55  * @key jfr
  56  *
  57  * @library /lib /
  58  * @run main/othervm jdk.jfr.api.consumer.TestRecordingFile
  59  */
  60 public class TestRecordingFile {
  61 
  62     static class TestEvent1 extends Event {
  63     }
  64 
  65     static class TestEvent2 extends Event {
  66     }
  67 
  68     static class TestEvent3 extends Event {
  69     }
  70 
  71     private static String TEST_CLASS_BASE = "TestRecordingFile$TestEvent";
  72     private final static int EVENT_COUNT = 3;
  73     private final static int HEADER_SIZE = 68;
  74     private final static long METADATA_OFFSET = 24;
  75 
  76     public static void main(String[] args) throws Throwable {
  77 
  78         // create some recording data
  79         Recording r = new Recording();
  80         r.enable(TestEvent1.class).withoutStackTrace();
  81         r.enable(TestEvent2.class).withoutStackTrace();
  82         r.enable(TestEvent3.class).withoutStackTrace();
  83         r.start();
  84         TestEvent1 t1 = new TestEvent1();
  85         t1.commit();
  86         TestEvent2 t2 = new TestEvent2();
  87         t2.commit();
  88         TestEvent3 t3 = new TestEvent3();
  89         t3.commit();
  90         r.stop();
  91         Path valid = Utils.createTempFile("three-event-recording", ".jfr");
  92         r.dump(valid);
  93         r.close();
  94 
  95         Path brokenWithZeros = createBrokenWIthZeros(valid);
  96         Path brokenMetadata = createBrokenMetadata(valid);
  97         // prepare event sets
  98         testNewRecordingFile(valid, brokenWithZeros);
  99         testIterate(valid, brokenWithZeros);
 100         testReadAllEvents(valid, brokenWithZeros);
 101         testReadEventTypes(valid, brokenMetadata);
 102         testClose(valid);
 103         testReadEventTypesMultiChunk();
 104         testReadEventTypeWithUnregistration(false, false);
 105         testReadEventTypeWithUnregistration(false, true);
 106         testReadEventTypeWithUnregistration(true, false);
 107         testReadEventTypeWithUnregistration(true, true);
 108     }
 109 
 110     private static void testReadEventTypeWithUnregistration(boolean disk, boolean background) throws Exception {
 111         FlightRecorder.register(Event1.class);
 112         FlightRecorder.register(Event2.class);
 113         FlightRecorder.register(Event3.class);
 114         Recording backgrundRecording = new Recording();
 115         if (disk) {
 116             backgrundRecording.setToDisk(disk);
 117         }
 118         if (background) {
 119             backgrundRecording.start();
 120         }
 121         recordAndVerify(disk, background,new int[] {1,2, 3}, new int[] {});
 122         FlightRecorder.unregister(Event2.class);
 123         recordAndVerify(disk, background,  new int[] {1, 3}, new int[] {2});
 124         FlightRecorder.unregister(Event1.class);
 125         FlightRecorder.register(Event2.class);
 126         recordAndVerify(disk,background, new int[] {2, 3}, new int[] {1});
 127         FlightRecorder.unregister(Event3.class);
 128         FlightRecorder.register(Event3.class);
 129         FlightRecorder.unregister(Event2.class);
 130         FlightRecorder.unregister(Event3.class);
 131         FlightRecorder.register(Event1.class);
 132         FlightRecorder.unregister(Event1.class);
 133         FlightRecorder.register(Event1.class);
 134         FlightRecorder.register(Event2.class);
 135         recordAndVerify(disk, background,new int[] {1, 2}, new int[] {3});
 136         if (background) {
 137             backgrundRecording.close();
 138         }
 139     }
 140 
 141     private static void recordAndVerify(boolean disk, boolean background,  int[] shouldExist, int[] shouldNotExist) throws Exception {
 142         StringJoiner sb  = new StringJoiner("-");
 143         for (int i = 0; i <shouldExist.length; i++) {
 144             sb.add(Integer.toString(shouldExist[i]));
 145         }
 146         System.out.println("Verifying recordings: disk=" + disk + " background=" + background);
 147         System.out.println("Should exist: " + Arrays.toString(shouldExist));
 148         System.out.println("Should not exist: " + Arrays.toString(shouldNotExist));
 149 
 150         Path p = Utils.createTempFile(sb.toString(), ".jfr");
 151         System.out.println("Filename: " + p);
 152         try (Recording r = new Recording()) {
 153             r.start();
 154             r.stop();
 155             r.dump(p);
 156             try (RecordingFile f = new RecordingFile(p)) {
 157                 List<EventType> types = f.readEventTypes();
 158                 for (int i = 0; i< shouldExist.length; i++) {
 159                     assertHasEventType(types, "Event" + shouldExist[i]);
 160                 }
 161                 for (int i = 0; i< shouldNotExist.length; i++) {
 162                     assertMissingEventType(types, "Event" + shouldNotExist[i]);
 163                 }
 164             }
 165         }
 166         System.out.println();
 167         System.out.println();
 168     }
 169 
 170     @Registered(false)
 171     @Name("Event1")
 172     private static class Event1 extends Event {
 173     }
 174     @Registered(false)
 175     @Name("Event2")
 176     private static class Event2 extends Event {
 177     }
 178     @Registered(false)
 179     @Name("Event3")
 180     private static class Event3 extends Event {
 181     }
 182 
 183     private static void testReadEventTypesMultiChunk() throws Exception {
 184 
 185         Path twoEventTypes = Utils.createTempFile("two-event-types", ".jfr");
 186         Path threeEventTypes = Utils.createTempFile("three-event-types", ".jfr");
 187        try (Recording r1 = new Recording()) {
 188            r1.start();
 189            FlightRecorder.register(Event1.class);
 190            try (Recording r2 = new Recording()) {
 191                r2.start();
 192                FlightRecorder.register(Event2.class);
 193 
 194                // Ensure that metadata are written twice.
 195                try (Recording rotator = new Recording()) {
 196                    rotator.start();
 197                    rotator.stop();
 198                }
 199                r2.stop();
 200                r2.dump(twoEventTypes);;
 201            }
 202            FlightRecorder.register(Event3.class);
 203            r1.stop();
 204            r1.dump(threeEventTypes);;
 205        }
 206        try (RecordingFile f = new RecordingFile(twoEventTypes)) {
 207            List<EventType> types = f.readEventTypes();
 208            assertUniqueEventTypes(types);
 209            assertHasEventType(types, "Event1");
 210            assertHasEventType(types, "Event2");
 211            assertMissingEventType(types, "Event3");
 212        }
 213        try (RecordingFile f = new RecordingFile(twoEventTypes)) {
 214            List<EventType> types = f.readEventTypes();
 215            assertUniqueEventTypes(types);
 216            assertHasEventType(types, "Event1");
 217            assertHasEventType(types, "Event2");
 218            assertMissingEventType(types, "Event3");
 219        }
 220 
 221     }
 222 
 223     private static void assertMissingEventType(List<EventType> types,String name) throws Exception {
 224         EventType type = findEventType(types, name);
 225         if (type != null) {
 226             throw new Exception("Found unexpected event type " + name);
 227         }
 228     }
 229 
 230     private static void assertHasEventType(List<EventType> types,String name) throws Exception {
 231         EventType type = findEventType(types, name);
 232         if (type == null) {
 233             throw new Exception("Missing event type " + name);
 234         }
 235     }
 236 
 237     private static EventType findEventType(List<EventType> types, String name) {
 238         for (EventType t : types) {
 239             if (t.getName().equals(name)) {
 240                 return t;
 241             }
 242         }
 243         return null;
 244     }
 245 
 246     private static void assertUniqueEventTypes(List<EventType> types) {
 247         HashSet<Long> ids = new HashSet<>();
 248         for (EventType type : types) {
 249             ids.add(type.getId());
 250         }
 251         Asserts.assertEquals(types.size(), ids.size(), "Event types repeated. " + types);
 252     }
 253 
 254     private static Path createBrokenWIthZeros(Path valid) throws Exception {
 255         try {
 256             Path broken = Utils.createTempFile("broken-events", ".jfr");
 257             Files.delete(broken);
 258             Files.copy(valid, broken);
 259             RandomAccessFile raf = new RandomAccessFile(broken.toFile(), "rw");
 260             raf.seek(HEADER_SIZE);
 261             int size = (int) Files.size(broken);
 262             byte[] ones = new byte[size - HEADER_SIZE];
 263             for (int i = 0; i < ones.length; i++) {
 264                 ones[i] = (byte) 0xFF;
 265             }
 266             raf.write(ones, 0, ones.length);
 267             raf.close();
 268             return broken;
 269         } catch (IOException ioe) {
 270             throw new Exception("Could not produce a broken file " + valid, ioe);
 271         }
 272     }
 273 
 274     private static Path createBrokenMetadata(Path valid) throws Exception {
 275         try {
 276             Path broken = Utils.createTempFile("broken-metadata", ".jfr");
 277             Files.delete(broken);
 278             Files.copy(valid, broken);
 279             RandomAccessFile raf = new RandomAccessFile(broken.toFile(), "rw");
 280             raf.seek(METADATA_OFFSET);
 281             long metadataOffset = raf.readLong();
 282             raf.seek(metadataOffset);
 283             raf.writeLong(Long.MAX_VALUE);
 284             raf.writeLong(Long.MAX_VALUE);
 285             raf.close();
 286             return broken;
 287         } catch (IOException ioe) {
 288             throw new Exception("Could not produce a broken EventSet from file " + valid, ioe);
 289         }
 290     }
 291 
 292     private static void testReadEventTypes(Path valid, Path broken) throws Exception {
 293         try (RecordingFile validFile = new RecordingFile(valid)) {
 294             List<EventType> types = validFile.readEventTypes();
 295             if (types.size() < EVENT_COUNT) {
 296                 throw new Exception("Expected at least " + EVENT_COUNT + " event type but got " + types.toString());
 297             }
 298             int counter = 0;
 299             for (Class<?> testClass : Arrays.asList(TestEvent1.class, TestEvent2.class, TestEvent3.class)) {
 300                 for (EventType t : types) {
 301                     if (t.getName().equals(testClass.getName())) {
 302                         counter++;
 303                     }
 304                 }
 305             }
 306             if (counter != 3) {
 307                 throw new Exception("Returned incorrect event types");
 308             }
 309         }
 310         try (RecordingFile brokenFile = new RecordingFile(broken)) {
 311             brokenFile.readEventTypes();
 312             throw new Exception("Expected IOException when getting Event Types from broken recording");
 313         } catch (IOException ise) {
 314             // OK
 315         }
 316     }
 317 
 318     private static void testNewRecordingFile(Path valid, Path broken) throws Exception {
 319         try (RecordingFile r = new RecordingFile(null)) {
 320             throw new Exception("Expected NullPointerException");
 321         } catch (NullPointerException npe) {
 322             // OK
 323         }
 324         try (RecordingFile r = new RecordingFile(Paths.get("hjhjsdfhkjshdfkj.jfr"))) {
 325             throw new Exception("Expected FileNotFoundException");
 326         } catch (FileNotFoundException npe) {
 327             // OK
 328         }
 329         Path testFile = Utils.createTempFile("test-empty-file", ".jfr");
 330         try (RecordingFile r = new RecordingFile(testFile)) {
 331             throw new Exception("Expected IOException if file is empty");
 332         } catch (IOException e) {
 333             // OK
 334         }
 335         FileWriter fr = new FileWriter(testFile.toFile());
 336         fr.write("whatever");
 337         fr.close();
 338         try (RecordingFile r = new RecordingFile(Paths.get("hjhjsdfhkjshdfkj.jfr"))) {
 339             throw new Exception("Expected IOException if magic is incorrect");
 340         } catch (IOException e) {
 341             // OK
 342         }
 343 
 344         try (RecordingFile r = new RecordingFile(valid)) {
 345         }
 346     }
 347 
 348     private static void testClose(Path valid) throws Exception {
 349         RecordingFile f = new RecordingFile(valid);
 350         f.close();
 351 
 352         try {
 353             f.readEvent();
 354             throw new Exception("Should not be able to read event from closed recording");
 355         } catch (IOException e) {
 356             if (!e.getMessage().equals("Stream Closed")) {
 357                 throw new Exception("Expected 'Stream Closed' in exception message for a closed stream. Got '" + e.getMessage() +"'.");
 358             }
 359             // OK
 360         }
 361         try {
 362             f.readEventTypes();
 363             throw new Exception("Should not be able to read event from closed recording");
 364         } catch (IOException e) {
 365             if (!e.getMessage().equals("Stream Closed")) {
 366                 throw new Exception("Expected 'Stream Closed' in exception message for a closed stream. Got '" + e.getMessage() +"'.");
 367             }
 368             // OK
 369         }
 370         // close twice
 371         f.close();
 372     }
 373 
 374     private static void testIterate(Path valid, Path broken) throws Exception {
 375         try (RecordingFile validFile = new RecordingFile(valid)) {
 376             for (int i = 0; i < EVENT_COUNT; i++) {
 377                 if (!validFile.hasMoreEvents()) {
 378                     throw new Exception("Not all events available");
 379                 }
 380                 RecordedEvent r = validFile.readEvent();
 381                 if (r == null) {
 382                     throw new Exception("Missing event");
 383                 }
 384                 if (!r.getEventType().getName().contains(TEST_CLASS_BASE)) {
 385                     throw new Exception("Incorrect event in recording file " + r);
 386                 }
 387             }
 388             if (validFile.hasMoreEvents()) {
 389                 throw new Exception("Should not be more than " + EVENT_COUNT + " in recording");
 390             }
 391         }
 392         try (RecordingFile brokenFile = new RecordingFile(broken)) {
 393             brokenFile.readEvent();
 394             throw new Exception("Expected IOException for broken recording");
 395         } catch (IOException ise) {
 396             // OK
 397         }
 398     }
 399 
 400     private static void testReadAllEvents(Path valid, Path broken) throws Exception {
 401         try {
 402             RecordingFile.readAllEvents(broken);
 403             throw new Exception("Expected IOException when reading all events for broken recording");
 404         } catch (IOException ioe) {
 405             // OK as expected
 406         }
 407     }
 408 }