コード例 #1
0
  @BeforeClass
  public static void createProcessController() throws IOException, URISyntaxException {
    if (File.pathSeparatorChar == ':') {
      processUtil = new UnixProcessUtil();
    } else {
      processUtil = new WindowsProcessUtil();
    }

    String jbossHome = System.getProperty("jboss.home");
    if (jbossHome == null) {
      throw new IllegalStateException("-Djboss.home must be set");
    }

    ClassLoader tccl = Thread.currentThread().getContextClassLoader();
    URL url = tccl.getResource("domain-configs/domain-standard.xml");
    Assert.assertNotNull(url);
    File domainXml = new File(url.toURI());
    url = tccl.getResource("host-configs/respawn-master.xml");
    File hostXml = new File(url.toURI());

    Assert.assertTrue(domainXml.exists());
    Assert.assertTrue(hostXml.exists());

    List<String> args = new ArrayList<String>();
    args.add("-jboss-home");
    args.add(jbossHome);
    args.add("-jvm");
    args.add(processUtil.getJavaCommand());
    args.add("--");
    args.add("-Dorg.jboss.boot.log.file=" + jbossHome + "/domain/log/host-controller/boot.log");
    args.add(
        "-Dlogging.configuration=file:" + jbossHome + "/domain/configuration/logging.properties");
    args.add(
        "-Djboss.test.host.master.address="
            + System.getProperty("jboss.test.host.master.address", "127.0.0.1"));
    args.add("-Xms64m");
    args.add("-Xmx512m");
    args.add("-XX:MaxPermSize=256m");
    args.add("-Dorg.jboss.resolver.warning=true");
    args.add("-Dsun.rmi.dgc.client.gcInterval=3600000");
    args.add("-Dsun.rmi.dgc.server.gcInterval=3600000");
    args.add("--");
    args.add("-default-jvm");
    args.add(processUtil.getJavaCommand());
    args.add("--host-config=" + hostXml.getAbsolutePath());
    args.add("--domain-config=" + domainXml.getAbsolutePath());
    args.add(
        "-Djboss.test.host.master.address="
            + System.getProperty("jboss.test.host.master.address", "127.0.0.1"));

    processController = Main.start(args.toArray(new String[args.size()]));
  }
コード例 #2
0
 private List<RunningProcess> waitForAllProcesses() throws Exception {
   final long time = System.currentTimeMillis() + TIMEOUT;
   List<RunningProcess> runningProcesses;
   do {
     runningProcesses = processUtil.getRunningProcesses();
     if (processUtil.containsProcesses(
         runningProcesses, HOST_CONTROLLER, SERVER_ONE, SERVER_TWO)) {
       return runningProcesses;
     }
     Thread.sleep(200);
   } while (System.currentTimeMillis() < time);
   Assert.fail("Did not have all running processes " + runningProcesses);
   return null;
 }
コード例 #3
0
 private static int comparePresentationName(MethodElement e1, MethodElement e2) {
   Collator collator = Collator.getInstance();
   String name1 =
       e1 instanceof BreakdownElement
           ? ProcessUtil.getPresentationName((BreakdownElement) e1)
           : e1.getPresentationName();
   if (name1.length() < 1) name1 = e1.getName();
   String name2 =
       e2 instanceof BreakdownElement
           ? ProcessUtil.getPresentationName((BreakdownElement) e2)
           : e2.getPresentationName();
   if (name2.length() < 1) name2 = e2.getName();
   return collator.compare(name1, name2);
 }
コード例 #4
0
  @Test
  public void testDomainRespawn() throws Exception {
    // Make sure everything started
    List<RunningProcess> processes = waitForAllProcesses();
    readHostControllerServers();

    // Kill the master HC and make sure that it gets restarted
    RunningProcess originalHc = processUtil.getProcess(processes, HOST_CONTROLLER);
    Assert.assertNotNull(originalHc);
    processUtil.killProcess(originalHc);
    processes = waitForAllProcesses();
    RunningProcess respawnedHc = processUtil.getProcess(processes, HOST_CONTROLLER);
    Assert.assertNotNull(respawnedHc);
    Assert.assertFalse(originalHc.getProcessId().equals(respawnedHc.getProcessId()));

    readHostControllerServers();
  }
コード例 #5
0
 private List<RunningProcess> waitForAllProcesses(Set<String> excludedProcessIds)
     throws Exception {
   final long time = System.currentTimeMillis() + TIMEOUT;
   List<RunningProcess> runningProcesses;
   do {
     runningProcesses = processUtil.getRunningProcesses();
     for (Iterator<RunningProcess> it = runningProcesses.iterator(); it.hasNext(); ) {
       RunningProcess proc = it.next();
       if (excludedProcessIds.contains(proc.getProcessId())) {
         it.remove();
       }
     }
     if (processUtil.containsProcesses(
         runningProcesses, HOST_CONTROLLER, SERVER_ONE, SERVER_TWO)) {
       return runningProcesses;
     }
     Thread.sleep(200);
   } while (System.currentTimeMillis() < time);
   Assert.fail("Did not have all running processes " + runningProcesses);
   return null;
 }
コード例 #6
0
    void killProcess(RunningProcess process) {
      try {
        Runtime.getRuntime().exec(getKillCommand(process));
      } catch (IOException e) {
        throw new RuntimeException(e);
      }

      final long time = System.currentTimeMillis() + TIMEOUT;
      do {
        List<RunningProcess> runningProcesses = processUtil.getRunningProcesses();
        if (processUtil.getProcessById(runningProcesses, process.getProcessId()) == null) {
          return;
        }
        try {
          Thread.sleep(200);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      } while (System.currentTimeMillis() < time);

      Assert.fail("Did not kill process " + process + " " + processUtil.getRunningProcesses());
    }
  public static boolean isGemInstallable() {
    if (!Platform.OS_WIN32.equals(Platform.getOS())) {
      // TODO This code is pretty blase about possible nulls/errors/etc. Should probably try and
      // make it
      // more bullet-proof.

      // grab the path to the gem executable dir
      IPath gemBin = find("gem", true, null); // $NON-NLS-1$
      String output =
          ProcessUtil.outputForCommand(gemBin.toOSString(), null, "environment"); // $NON-NLS-1$
      final String searchString = "EXECUTABLE DIRECTORY:"; // $NON-NLS-1$
      int index = output.indexOf(searchString);
      output = output.substring(index + searchString.length());
      // find first newline...
      output = output.split("\r\n|\r|\n")[0].trim(); // $NON-NLS-1$
      // Now see if user has rights to write to this dir to determine if we need to run under sudo
      return new File(output).canWrite();
    }
    return true;
  }
コード例 #8
0
  @BeforeClass
  public static void createProcessController()
      throws IOException, URISyntaxException, NoSuchAlgorithmException {

    final String testName = RespawnTestCase.class.getSimpleName();
    final File domains =
        new File("target" + File.separator + "domains" + File.separator + testName);
    final File masterDir = new File(domains, "master");
    final String masterDirPath = masterDir.getAbsolutePath();
    final File domainConfigDir = new File(masterDir, "configuration");
    // TODO this should not be necessary
    domainConfigDir.mkdirs();

    if (File.pathSeparatorChar == ':') {
      processUtil = new UnixProcessUtil();
    } else {
      processUtil = new WindowsProcessUtil();
    }

    String jbossHome = System.getProperty("jboss.home");
    if (jbossHome == null) {
      throw new IllegalStateException("-Djboss.home must be set");
    }

    ClassLoader tccl = Thread.currentThread().getContextClassLoader();
    URL url = tccl.getResource("domain-configs/domain-respawn.xml");
    Assert.assertNotNull(url);
    File domainXml = new File(url.toURI());
    url = tccl.getResource("host-configs/respawn-master.xml");
    File hostXml = new File(url.toURI());

    Assert.assertTrue(domainXml.exists());
    Assert.assertTrue(hostXml.exists());
    copyFile(domainXml, domainConfigDir);
    copyFile(hostXml, domainConfigDir);

    // No point backing up the file in a test scenario, just write what we need.
    File usersFile = new File(domainConfigDir, "mgmt-users.properties");
    FileOutputStream fos = new FileOutputStream(usersFile);
    PrintWriter pw = new PrintWriter(fos);
    pw.println(
        "slave="
            + new UsernamePasswordHashUtil()
                .generateHashedHexURP(
                    "slave", "ManagementRealm", "slave_user_password".toCharArray()));
    pw.close();
    fos.close();
    final String address = System.getProperty("jboss.test.host.master.address", "127.0.0.1");

    List<String> args = new ArrayList<String>();
    args.add("-jboss-home");
    args.add(jbossHome);
    args.add("-jvm");
    args.add(processUtil.getJavaCommand());
    args.add("--");
    args.add("-Dorg.jboss.boot.log.file=" + masterDirPath + "/log/host-controller.log");
    args.add(
        "-Dlogging.configuration=file:" + jbossHome + "/domain/configuration/logging.properties");
    args.add("-Djboss.test.host.master.address=" + address);
    TestSuiteEnvironment.getIpv6Args(args);
    args.add("-Xms64m");
    args.add("-Xmx512m");
    args.add("-XX:MaxPermSize=256m");
    args.add("-Dorg.jboss.resolver.warning=true");
    args.add("-Dsun.rmi.dgc.client.gcInterval=3600000");
    args.add("-Dsun.rmi.dgc.server.gcInterval=3600000");
    args.add("--");
    args.add("-default-jvm");
    args.add(processUtil.getJavaCommand());
    args.add("--host-config=" + hostXml.getName());
    args.add("--domain-config=" + domainXml.getName());
    args.add("-Djboss.test.host.master.address=" + address);
    args.add("-Djboss.domain.base.dir=" + masterDir.getAbsolutePath());
    args.add("--interprocess-hc-address");
    args.add(address);
    args.add("--pc-address");
    args.add(address);

    processController = Main.start(args.toArray(new String[args.size()]));
  }
コード例 #9
0
ファイル: TreeTest.java プロジェクト: netroby/jdk9-dev
  /** A test for scale; launch a large number (14) of subprocesses. */
  @Test
  public static void test5() {
    ConcurrentHashMap<ProcessHandle, ProcessHandle> processes = new ConcurrentHashMap<>();

    int factor = 2;
    JavaChild p1 = null;
    Instant start = Instant.now();
    try {
      p1 = JavaChild.spawnJavaChild("stdin");
      ProcessHandle p1Handle = p1.toHandle();

      printf("Spawning %d x %d x %d processes, pid: %d%n", factor, factor, factor, p1.getPid());

      // Start the first tier of subprocesses
      p1.sendAction("spawn", factor, "stdin");

      // Start the second tier of subprocesses
      p1.sendAction("child", "spawn", factor, "stdin");

      // Start the third tier of subprocesses
      p1.sendAction("child", "child", "spawn", factor, "stdin");

      int newChildren = factor * (1 + factor * (1 + factor));
      CountDownLatch spawnCount = new CountDownLatch(newChildren);

      // Gather the PIDs from the output of the spawning process
      p1.forEachOutputLine(
          (s) -> {
            String[] split = s.trim().split(" ");
            if (split.length == 3 && split[1].equals("spawn")) {
              Long child = Long.valueOf(split[2]);
              Long parent = Long.valueOf(split[0].split(":")[0]);
              processes.put(ProcessHandle.of(child).get(), ProcessHandle.of(parent).get());
              spawnCount.countDown();
            }
          });

      // Wait for all the subprocesses to be listed as started
      Assert.assertTrue(
          spawnCount.await(Utils.adjustTimeout(30L), TimeUnit.SECONDS),
          "Timeout waiting for processes to start");

      // Debugging; list descendants that are not expected in processes
      List<ProcessHandle> descendants = ProcessUtil.getDescendants(p1Handle);
      long count = descendants.stream().filter(ph -> !processes.containsKey(ph)).count();
      if (count > 0) {
        descendants
            .stream()
            .filter(ph -> !processes.containsKey(ph))
            .forEach(ph1 -> ProcessUtil.printProcess(ph1, "Extra process: "));
        ProcessUtil.logTaskList();
        Assert.assertEquals(0, count, "Extra processes in descendants");
      }

      Assert.assertEquals(getChildren(p1Handle).size(), factor, "expected direct children");
      count = getDescendants(p1Handle).size();
      long totalChildren = factor * factor * factor + factor * factor + factor;
      Assert.assertTrue(
          count >= totalChildren, "expected at least " + totalChildren + ", actual: " + count);

      List<ProcessHandle> subprocesses = getDescendants(p1Handle);
      printf(
          " descendants:  %s%n",
          subprocesses.stream().map(p -> p.getPid()).collect(Collectors.toList()));

      p1.getOutputStream().close(); // Close stdin for the controlling p1
      p1.waitFor();
    } catch (InterruptedException | IOException ex) {
      Assert.fail("Unexpected Exception", ex);
    } finally {
      printf("Duration: %s%n", Duration.between(start, Instant.now()));
      if (p1 != null) {
        p1.destroyForcibly();
      }
      processes.forEach(
          (p, parent) -> {
            if (p.isAlive()) {
              ProcessUtil.printProcess(p, "Process Cleanup: ");
              p.destroyForcibly();
            }
          });
    }
  }
コード例 #10
0
ファイル: TreeTest.java プロジェクト: netroby/jdk9-dev
  /**
   * Test destroy of processes. A JavaChild is started and it starts three children. Each one is
   * then checked to be alive and listed by descendants and forcibly destroyed. After they exit they
   * should no longer be listed by descendants.
   */
  @Test
  public static void test3() {
    ConcurrentHashMap<ProcessHandle, ProcessHandle> processes = new ConcurrentHashMap<>();

    try {
      ProcessHandle self = ProcessHandle.current();

      JavaChild p1 = JavaChild.spawnJavaChild("stdin");
      ProcessHandle p1Handle = p1.toHandle();
      printf(" p1: %s%n", p1.getPid());

      int newChildren = 3;
      CountDownLatch spawnCount = new CountDownLatch(newChildren);
      // Spawn children and have them wait
      p1.sendAction("spawn", newChildren, "stdin");

      // Gather the PIDs from the output of the spawning process
      p1.forEachOutputLine(
          (s) -> {
            String[] split = s.trim().split(" ");
            if (split.length == 3 && split[1].equals("spawn")) {
              Long child = Long.valueOf(split[2]);
              Long parent = Long.valueOf(split[0].split(":")[0]);
              processes.put(ProcessHandle.of(child).get(), ProcessHandle.of(parent).get());
              spawnCount.countDown();
            }
          });

      // Wait for all the subprocesses to be listed as started
      Assert.assertTrue(
          spawnCount.await(Utils.adjustTimeout(30L), TimeUnit.SECONDS),
          "Timeout waiting for processes to start");

      // Debugging; list descendants that are not expected in processes
      List<ProcessHandle> descendants = ProcessUtil.getDescendants(p1Handle);
      long count = descendants.stream().filter(ph -> !processes.containsKey(ph)).count();
      if (count > 0) {
        descendants
            .stream()
            .filter(ph -> !processes.containsKey(ph))
            .forEach(ph1 -> ProcessUtil.printProcess(ph1, "Extra process: "));
        ProcessUtil.logTaskList();
        Assert.assertEquals(0, count, "Extra processes in descendants");
      }

      // Verify that all spawned children are alive, show up in the descendants list
      // then destroy them
      processes.forEach(
          (p, parent) -> {
            Assert.assertEquals(p.isAlive(), true, "Child should be alive: " + p);
            Assert.assertTrue(
                descendants.contains(p), "Spawned child should be listed in descendants: " + p);
            p.destroyForcibly();
          });
      Assert.assertEquals(processes.size(), newChildren, "Wrong number of children");

      // Wait for each of the processes to exit
      processes.forEach(
          (p, parent) -> {
            for (long retries = Utils.adjustTimeout(100L); retries > 0; retries--) {
              if (!p.isAlive()) {
                return; // not alive, go on to the next
              }
              // Wait a bit and retry
              try {
                Thread.sleep(100L);
              } catch (InterruptedException ie) {
                // try again
              }
            }
            printf(
                "Timeout waiting for exit of pid %s, parent: %s, info: %s%n", p, parent, p.info());
            Assert.fail("Process still alive: " + p);
          });
      p1.destroyForcibly();
      p1.waitFor();

      // Verify that none of the spawned children are still listed by descendants
      List<ProcessHandle> remaining = getDescendants(self);
      Assert.assertFalse(remaining.remove(p1Handle), "Child p1 should have exited");
      remaining = remaining.stream().filter(processes::containsKey).collect(Collectors.toList());
      Assert.assertEquals(remaining.size(), 0, "Subprocess(es) should have exited: " + remaining);

    } catch (IOException ioe) {
      Assert.fail("Spawn of subprocess failed", ioe);
    } catch (InterruptedException inte) {
      Assert.fail("InterruptedException", inte);
    } finally {
      processes.forEach(
          (p, parent) -> {
            if (p.isAlive()) {
              ProcessUtil.printProcess(p);
              p.destroyForcibly();
            }
          });
    }
  }