1 /*

     2  * Copyright (c) 2014, 2017, 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.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  */

    23 

    24 import java.io.IOException;

    25 import java.time.Duration;

    26 import java.time.Instant;

    27 import java.util.ArrayList;

    28 import java.util.List;

    29 import java.util.concurrent.ArrayBlockingQueue;

    30 import java.util.concurrent.CompletableFuture;

    31 import java.util.concurrent.ConcurrentHashMap;

    32 import java.util.concurrent.ExecutionException;

    33 import java.util.concurrent.TimeUnit;

    34 

    35 import jdk.test.lib.Utils;

    36 

    37 import org.testng.annotations.Test;

    38 import org.testng.Assert;

    39 import org.testng.TestNG;

    40 

    41 /*

    42  * @test

    43  * @key intermittent

    44  * @library /test/lib

    45  * @build jdk.test.lib.Utils

    46  * @run testng OnExitTest

    47  * @summary Functions of Process.onExit and ProcessHandle.onExit

    48  * @author Roger Riggs

    49  */

    50 

    51 public class OnExitTest extends ProcessUtil {

    52 

    53     @SuppressWarnings("raw_types")

    54     public static void main(String[] args) {

    55         Class<?>[] testclass = { OnExitTest.class};

    56         TestNG testng = new TestNG();

    57         testng.setTestClasses(testclass);

    58         testng.run();

    59     }

    60 

    61     /**

    62      * Basic test of exitValue and onExit.

    63      */

    64     @Test

    65     public static void test1() {

    66         try {

    67             int[] exitValues = {0, 1, 10};

    68             for (int value : exitValues) {

    69                 Process p = JavaChild.spawn("exit", Integer.toString(value));

    70                 CompletableFuture<Process> future = p.onExit();

    71                 future.thenAccept( (ph) -> {

    72                     int actualExitValue = ph.exitValue();

    73                     printf(" javaChild done: %s, exitStatus: %d%n",

    74                             ph, actualExitValue);

    75                     Assert.assertEquals(actualExitValue, value, "actualExitValue incorrect");

    76                     Assert.assertEquals(ph, p, "Different Process passed to thenAccept");

    77                 });

    78 

    79                 Process h = future.get();

    80                 Assert.assertEquals(h, p);

    81                 Assert.assertEquals(p.exitValue(), value);

    82                 Assert.assertFalse(p.isAlive(), "Process should not be alive");

    83                 p.waitFor();

    84             }

    85         } catch (IOException | InterruptedException | ExecutionException ex) {

    86             Assert.fail(ex.getMessage(), ex);

    87         } finally {

    88             destroyProcessTree(ProcessHandle.current());

    89         }

    90     }

    91 

    92     /**

    93      * Test of Completion handler when parent is killed.

    94      * Spawn 1 child to spawn 3 children each with 2 children.

    95      */

    96     @Test

    97     public static void test2() {

    98         ProcessHandle procHandle = null;

    99         try {

   100             ConcurrentHashMap<ProcessHandle, ProcessHandle> processes = new ConcurrentHashMap<>();

   101             List<ProcessHandle> children = getChildren(ProcessHandle.current());

   102             children.forEach(ProcessUtil::printProcess);

   103 

   104             JavaChild proc = JavaChild.spawnJavaChild("stdin");

   105             procHandle = proc.toHandle();

   106             printf(" spawned: %d%n", proc.pid());

   107 

   108             proc.forEachOutputLine((s) -> {

   109                 String[] split = s.trim().split(" ");

   110                 if (split.length == 3 && split[1].equals("spawn")) {

   111                     Long child = Long.valueOf(split[2]);

   112                     Long parent = Long.valueOf(split[0].split(":")[0]);

   113                     processes.put(ProcessHandle.of(child).get(), ProcessHandle.of(parent).get());

   114                 }

   115             });

   116 

   117             proc.sendAction("spawn", "3", "stdin");

   118 

   119             proc.sendAction("child", "spawn", "2", "stdin");

   120 

   121             // Poll until all 9 child processes exist or the timeout is reached

   122             int expected = 9;

   123             long timeout = Utils.adjustTimeout(10L);

   124             Instant endTimeout = Instant.now().plusSeconds(timeout);

   125             do {

   126                 Thread.sleep(200L);

   127                 printf(" subprocess count: %d, waiting for %d%n", processes.size(), expected);

   128             } while (processes.size() < expected &&

   129                     Instant.now().isBefore(endTimeout));

   130 

   131             if (processes.size() < expected) {

   132                 printf("WARNING: not all children have been started. Can't complete test.%n");

   133                 printf("         You can try to increase the timeout or%n");

   134                 printf("         you can try to use a faster VM (i.e. not a debug version).%n");

   135             }

   136             children = getDescendants(procHandle);

   137 

   138             ConcurrentHashMap<ProcessHandle, CompletableFuture<ProcessHandle>> completions =

   139                     new ConcurrentHashMap<>();

   140             Instant startTime = Instant.now();

   141             // Create a future for each of the 9 children

   142             processes.forEach( (p, parent) -> {

   143                         CompletableFuture<ProcessHandle> cf = p.onExit().whenComplete((ph, ex) -> {

   144                             Duration elapsed = Duration.between(startTime, Instant.now());

   145                             printf("whenComplete: pid: %s, exception: %s, thread: %s, elapsed: %s%n",

   146                                     ph, ex, Thread.currentThread(), elapsed);

   147                         });

   148                         completions.put(p, cf);

   149                     });

   150 

   151             // Check that each of the spawned processes is included in the children

   152             List<ProcessHandle> remaining = new ArrayList<>(children);

   153             processes.forEach((p, parent) -> {

   154                 Assert.assertTrue(remaining.remove(p), "spawned process should have been in children");

   155             });

   156 

   157             // Remove Win32 system spawned conhost.exe processes

   158             remaining.removeIf(ProcessUtil::isWindowsConsole);

   159 

   160             remaining.forEach(p -> printProcess(p, "unexpected: "));

   161             if (remaining.size() > 0) {

   162                 // Show full list for debugging

   163                 ProcessUtil.logTaskList();

   164             }

   165 

   166             proc.destroy();  // kill off the parent

   167             proc.waitFor();

   168 

   169             // Wait for all the processes and corresponding onExit CF to be completed

   170             processes.forEach((p, parent) -> {

   171                 try {

   172                     p.onExit().get();

   173                     completions.get(p).join();

   174                 } catch (InterruptedException | ExecutionException ex) {

   175                     // ignore

   176                 }

   177             });

   178 

   179             // Verify that all 9 exit handlers were called with the correct ProcessHandle

   180             processes.forEach((p, parent) -> {

   181                 ProcessHandle value = completions.get(p).getNow(null);

   182                 Assert.assertEquals(p, value, "onExit.get value expected: " + p

   183                         + ", actual: " + value

   184                         + ": " + p.info());

   185             });

   186 

   187             // Show the status of the original children

   188             children.forEach(p -> printProcess(p, "after onExit:"));

   189 

   190             Assert.assertEquals(proc.isAlive(), false, "destroyed process is alive:: %s%n" + proc);

   191         } catch (IOException | InterruptedException ex) {

   192             Assert.fail(ex.getMessage());

   193         } finally {

   194             if (procHandle != null) {

   195                 destroyProcessTree(procHandle);

   196             }

   197         }

   198     }

   199 

   200     /**

   201      * Verify that onExit completes for a non-child process only when

   202      * the process has exited.

   203      * Spawn a child (A) waiting to be commanded to exit.

   204      * Spawn a child (B) to wait for that process to exit.

   205      * Command (A) to exit.

   206      * Check that (B) does not complete until (A) has exited.

   207      */

   208     @Test

   209     public static void peerOnExitTest() {

   210         String line = null;

   211         ArrayBlockingQueue<String> alines = new ArrayBlockingQueue<>(100);

   212         ArrayBlockingQueue<String> blines = new ArrayBlockingQueue<>(100);

   213         JavaChild A = null;

   214         try {

   215             String[] split;

   216             A = JavaChild.spawnJavaChild("stdin");

   217             A.forEachOutputLine(l -> alines.add(l));

   218 

   219             // Verify A is running

   220             A.sendAction("pid");

   221             do {

   222                 split = getSplitLine(alines);

   223             } while (!"pid".equals(split[1]));

   224 

   225             JavaChild B = null;

   226             try {

   227                 B = JavaChild.spawnJavaChild("stdin");

   228                 B.forEachOutputLine(l -> blines.add(l));

   229 

   230                 // Verify B is running

   231                 B.sendAction("pid");

   232                 do {

   233                     split = getSplitLine(blines);

   234                 } while (!"pid".equals(split[1]));

   235 

   236                 // Tell B to wait for A's pid

   237                 B.sendAction("waitpid", A.pid());

   238 

   239                 // Wait a bit to see if B will prematurely report the termination of A

   240                 try {

   241                     line = blines.poll(5L, TimeUnit.SECONDS);

   242                 } catch (InterruptedException ie) {

   243                     Assert.fail("interrupted", ie);

   244                 }

   245                 Assert.assertNull(line, "waitpid didn't wait");

   246 

   247                 A.toHandle().onExit().thenAccept(p -> {

   248                     System.out.printf(" A.toHandle().onExit().A info: %s, now: %s%n",

   249                             p.info(), Instant.now());

   250                 });

   251 

   252                 A.onExit().thenAccept(p -> {

   253                     System.out.printf(" A.onExit().A info: %s, now: %s%n",

   254                             p.info(), Instant.now());

   255                 });

   256 

   257                 ProcessHandle.Info A_info = A.info();

   258 

   259                 A.sendAction("exit", 0L);

   260 

   261                 // Look for B to report that A has exited

   262                 do {

   263                     Instant start = Instant.now();

   264                     while (blines.isEmpty() && A.isAlive()) {

   265                         A_info = A.info(); // Spin

   266                     }

   267                     Instant end = Instant.now();

   268                     System.out.printf(" a.isAlive: %s, a.info: %s, @%s%n", A.isAlive(), A.info(),

   269                             Duration.between(start, end));

   270 

   271                     split = getSplitLine(blines);

   272                 } while (!"waitpid".equals(split[1]));

   273 

   274                 Assert.assertEquals(split[2], "false",  "Process A should not be alive");

   275 

   276                 B.sendAction("exit", 0L);

   277             } catch (IOException ioe) {

   278                 Assert.fail("unable to start JavaChild B", ioe);

   279             } finally {

   280                 B.destroyForcibly();

   281             }

   282         } catch (IOException ioe2) {

   283             Assert.fail("unable to start JavaChild A", ioe2);

   284         } finally {

   285             A.destroyForcibly();

   286         }

   287     }

   288 

   289     private static boolean DEBUG = true;

   290 

   291     /**

   292      * Get a line from the queue and split into words on whitespace.

   293      * Log to stdout if requested.

   294      * @param queue a queue of strings

   295      * @return the words split from the line.

   296      */

   297     private static String[] getSplitLine(ArrayBlockingQueue<String> queue) {

   298         try {

   299             String line = queue.take();

   300             String[] split = line.split("\\s");

   301             if (DEBUG) {

   302                 System.out.printf("  Child Output: %s%n", line);

   303             }

   304             return split;

   305         } catch (InterruptedException ie) {

   306             Assert.fail("interrupted", ie);

   307             return null;

   308         }

   309     }

   310 

   311 }