src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.debug/src/org/graalvm/compiler/debug/IgvDumpChannel.java

*** 22,31 ****
--- 22,35 ----
   */
  
  
  package org.graalvm.compiler.debug;
  
+ import static org.graalvm.compiler.debug.DebugOptions.PrintGraphHost;
+ import static org.graalvm.compiler.debug.DebugOptions.PrintGraphPort;
+ 
+ import java.io.File;
  import java.io.IOException;
  import java.io.InterruptedIOException;
  import java.net.InetSocketAddress;
  import java.nio.ByteBuffer;
  import java.nio.channels.ClosedByInterruptException;
*** 33,46 ****
  import java.nio.channels.SocketChannel;
  import java.nio.channels.WritableByteChannel;
  import java.nio.file.Path;
  import java.nio.file.StandardOpenOption;
  import java.util.function.Supplier;
! import static org.graalvm.compiler.debug.DebugOptions.PrintBinaryGraphPort;
! import static org.graalvm.compiler.debug.DebugOptions.PrintGraphHost;
  import org.graalvm.compiler.options.OptionValues;
  
  final class IgvDumpChannel implements WritableByteChannel {
      private final Supplier<Path> pathProvider;
      private final OptionValues options;
      private WritableByteChannel sharedChannel;
      private boolean closed;
--- 37,52 ----
  import java.nio.channels.SocketChannel;
  import java.nio.channels.WritableByteChannel;
  import java.nio.file.Path;
  import java.nio.file.StandardOpenOption;
  import java.util.function.Supplier;
! 
! import org.graalvm.compiler.debug.DebugOptions.PrintGraphTarget;
  import org.graalvm.compiler.options.OptionValues;
  
+ import jdk.vm.ci.common.NativeImageReinitialize;
+ 
  final class IgvDumpChannel implements WritableByteChannel {
      private final Supplier<Path> pathProvider;
      private final OptionValues options;
      private WritableByteChannel sharedChannel;
      private boolean closed;
*** 50,60 ****
          this.options = options;
      }
  
      @Override
      public int write(ByteBuffer src) throws IOException {
!         return channel().write(src);
      }
  
      @Override
      public boolean isOpen() {
          return !closed;
--- 56,67 ----
          this.options = options;
      }
  
      @Override
      public int write(ByteBuffer src) throws IOException {
!         WritableByteChannel channel = channel();
!         return channel == null ? 0 : channel.write(src);
      }
  
      @Override
      public boolean isOpen() {
          return !closed;
*** 75,120 ****
      WritableByteChannel channel() throws IOException {
          if (closed) {
              throw new IOException();
          }
          if (sharedChannel == null) {
!             if (DebugOptions.PrintGraphFile.getValue(options)) {
!                 sharedChannel = createFileChannel(pathProvider);
!             } else {
                  sharedChannel = createNetworkChannel(pathProvider, options);
              }
          }
          return sharedChannel;
      }
  
      private static WritableByteChannel createNetworkChannel(Supplier<Path> pathProvider, OptionValues options) throws IOException {
          String host = PrintGraphHost.getValue(options);
!         int port = PrintBinaryGraphPort.getValue(options);
          try {
              WritableByteChannel channel = SocketChannel.open(new InetSocketAddress(host, port));
!             TTY.println("Connected to the IGV on %s:%d", host, port);
              return channel;
          } catch (ClosedByInterruptException | InterruptedIOException e) {
              /*
               * Interrupts should not count as errors because they may be caused by a cancelled Graal
               * compilation. ClosedByInterruptException occurs if the SocketChannel could not be
               * opened. InterruptedIOException occurs if new Socket(..) was interrupted.
               */
              return null;
          } catch (IOException e) {
!             if (!DebugOptions.PrintGraphFile.hasBeenSet(options)) {
!                 return createFileChannel(pathProvider);
              } else {
!                 throw new IOException(String.format("Could not connect to the IGV on %s:%d", host, port), e);
              }
          }
      }
  
!     private static WritableByteChannel createFileChannel(Supplier<Path> pathProvider) throws IOException {
          Path path = pathProvider.get();
          try {
!             return FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
          } catch (IOException e) {
              throw new IOException(String.format("Failed to open %s to dump IGV graphs", path), e);
          }
      }
  
--- 82,152 ----
      WritableByteChannel channel() throws IOException {
          if (closed) {
              throw new IOException();
          }
          if (sharedChannel == null) {
!             PrintGraphTarget target = DebugOptions.PrintGraph.getValue(options);
!             if (target == PrintGraphTarget.File) {
!                 sharedChannel = createFileChannel(pathProvider, null);
!             } else if (target == PrintGraphTarget.Network) {
                  sharedChannel = createNetworkChannel(pathProvider, options);
+             } else {
+                 TTY.println("WARNING: Graph dumping requested but value of %s option is %s", DebugOptions.PrintGraph.getName(), PrintGraphTarget.Disable);
              }
          }
          return sharedChannel;
      }
  
      private static WritableByteChannel createNetworkChannel(Supplier<Path> pathProvider, OptionValues options) throws IOException {
          String host = PrintGraphHost.getValue(options);
!         int port = PrintGraphPort.getValue(options);
          try {
              WritableByteChannel channel = SocketChannel.open(new InetSocketAddress(host, port));
!             String targetAnnouncement = String.format("Connected to the IGV on %s:%d", host, port);
!             maybeAnnounceTarget(targetAnnouncement);
              return channel;
          } catch (ClosedByInterruptException | InterruptedIOException e) {
              /*
               * Interrupts should not count as errors because they may be caused by a cancelled Graal
               * compilation. ClosedByInterruptException occurs if the SocketChannel could not be
               * opened. InterruptedIOException occurs if new Socket(..) was interrupted.
               */
              return null;
          } catch (IOException e) {
!             String networkFailure = String.format("Could not connect to the IGV on %s:%d", host, port);
!             if (pathProvider != null) {
!                 return createFileChannel(pathProvider, networkFailure);
              } else {
!                 throw new IOException(networkFailure, e);
              }
          }
      }
  
!     @NativeImageReinitialize private static String lastTargetAnnouncement;
! 
!     private static void maybeAnnounceTarget(String targetAnnouncement) {
!         if (!targetAnnouncement.equals(lastTargetAnnouncement)) {
!             // Ignore races - an extra announcement is ok
!             lastTargetAnnouncement = targetAnnouncement;
!             TTY.println(targetAnnouncement);
!         }
!     }
! 
!     private static WritableByteChannel createFileChannel(Supplier<Path> pathProvider, String networkFailure) throws IOException {
          Path path = pathProvider.get();
          try {
!             FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
!             File dir = path.toFile();
!             if (!dir.isDirectory()) {
!                 dir = dir.getParentFile();
!             }
!             if (networkFailure == null) {
!                 maybeAnnounceTarget("Dumping IGV graphs in " + dir);
!             } else {
!                 maybeAnnounceTarget(networkFailure + ". Dumping IGV graphs in " + dir);
!             }
!             return channel;
          } catch (IOException e) {
              throw new IOException(String.format("Failed to open %s to dump IGV graphs", path), e);
          }
      }