feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/tools/jps/Arguments.java

@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.tools.jps;
+
+import java.io.*;
+import java.net.*;
+import sun.jvmstat.monitor.*;
+
+/**
+ * Class for processing command line arguments and providing method
+ * level access to the command line arguments.
+ *
+ * @author Brian Doherty
+ * @since 1.5
+ */
+public class Arguments {
+
+    private static final boolean debug = Boolean.getBoolean("jps.debug");
+    private static final boolean printStackTrace = Boolean.getBoolean(
+            "jps.printStackTrace");
+
+    private boolean help;
+    private boolean quiet;
+    private boolean longPaths;
+    private boolean vmArgs;
+    private boolean vmFlags;
+    private boolean mainArgs;
+    private String hostname;
+    private HostIdentifier hostId;
+
+    public static void printUsage(PrintStream ps) {
+      ps.println("usage: jps [-help]");
+      ps.println("       jps [-q] [-mlvV] [<hostid>]");
+      ps.println();
+      ps.println("Definitions:");
+      ps.println("    <hostid>:      <hostname>[:<port>]");
+    }
+
+    public Arguments(String[] args) throws IllegalArgumentException {
+        int argc = 0;
+
+        if (args.length == 1) {
+            if ((args[0].compareTo("-?") == 0)
+                    || (args[0].compareTo("-help")== 0)) {
+              help = true;
+              return;
+            }
+        }
+
+        for (argc = 0; (argc < args.length) && (args[argc].startsWith("-"));
+                argc++) {
+            String arg = args[argc];
+
+            if (arg.compareTo("-q") == 0) {
+              quiet = true;
+            } else if (arg.startsWith("-")) {
+                for (int j = 1; j < arg.length(); j++) {
+                    switch (arg.charAt(j)) {
+                    case 'm':
+                        mainArgs = true;
+                        break;
+                    case 'l':
+                        longPaths = true;
+                        break;
+                    case 'v':
+                        vmArgs = true;
+                        break;
+                    case 'V':
+                        vmFlags = true;
+                        break;
+                    default:
+                        throw new IllegalArgumentException("illegal argument: "
+                                                           + args[argc]);
+                    }
+                }
+            } else {
+                throw new IllegalArgumentException("illegal argument: "
+                                                   + args[argc]);
+            }
+        }
+
+        switch (args.length - argc) {
+        case 0:
+            hostname = null;
+            break;
+        case 1:
+            hostname = args[args.length - 1];
+            break;
+        default:
+            throw new IllegalArgumentException("invalid argument count");
+        }
+
+        try {
+            hostId = new HostIdentifier(hostname);
+        } catch (URISyntaxException e) {
+            IllegalArgumentException iae =
+                    new IllegalArgumentException("Malformed Host Identifier: "
+                                                 + hostname);
+            iae.initCause(e);
+            throw iae;
+        }
+    }
+
+    public boolean isDebug() {
+        return debug;
+    }
+
+    public boolean printStackTrace() {
+        return printStackTrace;
+    }
+
+    public boolean isHelp() {
+        return help;
+    }
+
+    public boolean isQuiet() {
+        return quiet;
+    }
+
+    public boolean showLongPaths() {
+        return longPaths;
+    }
+
+    public boolean showVmArgs() {
+        return vmArgs;
+    }
+
+    public boolean showVmFlags() {
+        return vmFlags;
+    }
+
+    public boolean showMainArgs() {
+        return mainArgs;
+    }
+
+    public String hostname() {
+        return hostname;
+    }
+
+    public HostIdentifier hostId() {
+        return hostId;
+    }
+}

jdkSrc/jdk8/sun/tools/jps/Jps.java

@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.tools.jps;
+
+import java.util.*;
+import java.net.*;
+import sun.jvmstat.monitor.*;
+
+/**
+ * Application to provide a listing of monitorable java processes.
+ *
+ * @author Brian Doherty
+ * @since 1.5
+ */
+public class Jps {
+
+    private static Arguments arguments;
+
+    public static void main(String[] args) {
+        try {
+            arguments = new Arguments(args);
+        } catch (IllegalArgumentException e) {
+            System.err.println(e.getMessage());
+            Arguments.printUsage(System.err);
+            System.exit(1);
+        }
+
+        if (arguments.isHelp()) {
+            Arguments.printUsage(System.err);
+            System.exit(0);
+        }
+
+        try {
+            HostIdentifier hostId = arguments.hostId();
+            MonitoredHost monitoredHost =
+                    MonitoredHost.getMonitoredHost(hostId);
+
+            // get the set active JVMs on the specified host.
+            Set<Integer> jvms = monitoredHost.activeVms();
+
+            for (Integer jvm: jvms) {
+                StringBuilder output = new StringBuilder();
+                Throwable lastError = null;
+
+                int lvmid = jvm;
+
+                output.append(String.valueOf(lvmid));
+
+                if (arguments.isQuiet()) {
+                    System.out.println(output);
+                    continue;
+                }
+
+                MonitoredVm vm = null;
+                String vmidString = "//" + lvmid + "?mode=r";
+
+                String errorString = null;
+
+                try {
+                    // Note: The VM associated with the current VM id may
+                    // no longer be running so these queries may fail. We
+                    // already added the VM id to the output stream above.
+                    // If one of the queries fails, then we try to add a
+                    // reasonable message to indicate that the requested
+                    // info is not available.
+
+                    errorString = " -- process information unavailable";
+                    VmIdentifier id = new VmIdentifier(vmidString);
+                    vm = monitoredHost.getMonitoredVm(id, 0);
+
+                    errorString = " -- main class information unavailable";
+                    output.append(" " + MonitoredVmUtil.mainClass(vm,
+                            arguments.showLongPaths()));
+
+                    if (arguments.showMainArgs()) {
+                        errorString = " -- main args information unavailable";
+                        String mainArgs = MonitoredVmUtil.mainArgs(vm);
+                        if (mainArgs != null && mainArgs.length() > 0) {
+                            output.append(" " + mainArgs);
+                        }
+                    }
+                    if (arguments.showVmArgs()) {
+                        errorString = " -- jvm args information unavailable";
+                        String jvmArgs = MonitoredVmUtil.jvmArgs(vm);
+                        if (jvmArgs != null && jvmArgs.length() > 0) {
+                          output.append(" " + jvmArgs);
+                        }
+                    }
+                    if (arguments.showVmFlags()) {
+                        errorString = " -- jvm flags information unavailable";
+                        String jvmFlags = MonitoredVmUtil.jvmFlags(vm);
+                        if (jvmFlags != null && jvmFlags.length() > 0) {
+                            output.append(" " + jvmFlags);
+                        }
+                    }
+
+                    errorString = " -- detach failed";
+                    monitoredHost.detach(vm);
+
+                    System.out.println(output);
+
+                    errorString = null;
+                } catch (URISyntaxException e) {
+                    // unexpected as vmidString is based on a validated hostid
+                    lastError = e;
+                    assert false;
+                } catch (Exception e) {
+                    lastError = e;
+                } finally {
+                    if (errorString != null) {
+                        /*
+                         * we ignore most exceptions, as there are race
+                         * conditions where a JVM in 'jvms' may terminate
+                         * before we get a chance to list its information.
+                         * Other errors, such as access and I/O exceptions
+                         * should stop us from iterating over the complete set.
+                         */
+                        output.append(errorString);
+                        if (arguments.isDebug()) {
+                            if ((lastError != null)
+                                    && (lastError.getMessage() != null)) {
+                                output.append("\n\t");
+                                output.append(lastError.getMessage());
+                            }
+                        }
+                        System.out.println(output);
+                        if (arguments.printStackTrace()) {
+                            lastError.printStackTrace();
+                        }
+                        continue;
+                    }
+                }
+            }
+        } catch (MonitorException e) {
+            if (e.getMessage() != null) {
+                System.err.println(e.getMessage());
+            } else {
+                Throwable cause = e.getCause();
+                if ((cause != null) && (cause.getMessage() != null)) {
+                    System.err.println(cause.getMessage());
+                } else {
+                    e.printStackTrace();
+                }
+            }
+            System.exit(1);
+        }
+    }
+}