/* * Copyright (c) 2004, 2010, 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.jstat; import java.io.*;import java.net.*;import java.util.*;import java.util.regex.*;import sun.jvmstat.monitor.Monitor;import sun.jvmstat.monitor.VmIdentifier; /** * Class for processing command line arguments and providing method * level access to arguments. * * @author Brian Doherty * @since 1.5 */public class Arguments {     private static final boolean debug = Boolean.getBoolean("jstat.debug");    private static final boolean showUnsupported =            Boolean.getBoolean("jstat.showUnsupported");     private static final String JVMSTAT_USERDIR = ".jvmstat";    private static final String OPTIONS_FILENAME = "jstat_options";    private static final String UNSUPPORTED_OPTIONS_FILENAME = "jstat_unsupported_options";    private static final String ALL_NAMES = "\\w*";     private Comparator<Monitor> comparator;    private int headerRate;    private boolean help;    private boolean list;    private boolean options;    private boolean constants;    private boolean constantsOnly;    private boolean strings;    private boolean timestamp;    private boolean snap;    private boolean verbose;    private String specialOption;    private String names;     private OptionFormat optionFormat;     private int count = -1;    private int interval = -1;    private String vmIdString;     private VmIdentifier vmId;     public static void printUsage(PrintStream ps) {        ps.println("Usage: jstat -help|-options");        ps.println("       jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]");        ps.println();        ps.println("Definitions:");        ps.println("  <option>      An option reported by the -options option");        ps.println("  <vmid>        Virtual Machine Identifier. A vmid takes the following form:");        ps.println("                     <lvmid>[@<hostname>[:<port>]]");        ps.println("                Where <lvmid> is the local vm identifier for the target");        ps.println("                Java virtual machine, typically a process id; <hostname> is");        ps.println("                the name of the host running the target Java virtual machine;");        ps.println("                and <port> is the port number for the rmiregistry on the");        ps.println("                target host. See the jvmstat documentation for a more complete");        ps.println("                description of the Virtual Machine Identifier.");        ps.println("  <lines>       Number of samples between header lines.");        ps.println("  <interval>    Sampling interval. The following forms are allowed:");        ps.println("                    <n>[\"ms\"|\"s\"]");        ps.println("                Where <n> is an integer and the suffix specifies the units as ");        ps.println("                milliseconds(\"ms\") or seconds(\"s\"). The default units are \"ms\".");        ps.println("  <count>       Number of samples to take before terminating.");        ps.println("  -J<flag>      Pass <flag> directly to the runtime system.");         // undocumented options:        //   -list [<vmid>]  - list counter names        //   -snap <vmid>    - snapshot counter values as name=value pairs        //   -name <pattern> - output counters matching given pattern        //   -a              - sort in ascending order (default)        //   -d              - sort in descending order        //   -v              - verbose output  (-snap)        //   -constants      - output constants with -name output        //   -strings        - output strings with -name output    }     private static int toMillis(String s) throws IllegalArgumentException {         String[] unitStrings = { "ms", "s" }; // ordered from most specific to                                              // least specific        String unitString = null;        String valueString = s;         for (int i = 0; i < unitStrings.length; i++) {            int index = s.indexOf(unitStrings[i]);            if (index > 0) {                unitString = s.substring(index);                valueString = s.substring(0, index);                break;            }        }         try {            int value = Integer.parseInt(valueString);             if (unitString == null || unitString.compareTo("ms") == 0) {                return value;            } else if (unitString.compareTo("s") == 0) {                return value * 1000;            } else {                throw new IllegalArgumentException(                        "Unknow time unit: " + unitString);            }        } catch (NumberFormatException e) {            throw new IllegalArgumentException(                    "Could not convert interval: " + s);        }    }     public Arguments(String[] args) throws IllegalArgumentException {        int argc = 0;         if (args.length < 1) {            throw new IllegalArgumentException("invalid argument count");        }         if ((args[0].compareTo("-?") == 0)                || (args[0].compareTo("-help") == 0)) {            help = true;            return;        } else if (args[0].compareTo("-options") == 0) {            options = true;            return;        } else if (args[0].compareTo("-list") == 0) {            list = true;            if (args.length > 2) {              throw new IllegalArgumentException("invalid argument count");            }            // list can take one arg - a vmid - fall through for arg processing            argc++;        }         for ( ; (argc < args.length) && (args[argc].startsWith("-")); argc++) {            String arg = args[argc];             if (arg.compareTo("-a") == 0) {                comparator = new AscendingMonitorComparator();            } else if (arg.compareTo("-d") == 0) {                comparator =  new DescendingMonitorComparator();            } else if (arg.compareTo("-t") == 0) {                timestamp = true;            } else if (arg.compareTo("-v") == 0) {                verbose = true;            } else if ((arg.compareTo("-constants") == 0)                       || (arg.compareTo("-c") == 0)) {                constants = true;            } else if ((arg.compareTo("-strings") == 0)                       || (arg.compareTo("-s") == 0)) {                strings = true;            } else if (arg.startsWith("-h")) {                String value;                if (arg.compareTo("-h") != 0) {                    value = arg.substring(2);                } else {                    argc++;                    if (argc >= args.length) {                        throw new IllegalArgumentException(                                "-h requires an integer argument");                    }                    value = args[argc];                }                try {                    headerRate = Integer.parseInt(value);                } catch (NumberFormatException e) {                    headerRate = -1;                }                if (headerRate < 0) {                    throw new IllegalArgumentException(                            "illegal -h argument: " + value);                }            } else if (arg.startsWith("-name")) {                if (arg.startsWith("-name=")) {                    names = arg.substring(7);                } else {                    argc++;                    if (argc >= args.length) {                        throw new IllegalArgumentException(                                "option argument expected");                    }                    names = args[argc];                }            } else {                /*                 * there are scenarios here: special jstat_options file option                 * or the rare case of a negative lvmid. The negative lvmid                 * can occur in some operating environments (such as Windows                 * 95/98/ME), so we provide for this case here by checking if                 * the argument has any numerical characters. This assumes that                 * there are no special jstat_options that contain numerical                 * characters in their name.                 */                 // extract the lvmid part of possible lvmid@host.domain:port                String lvmidStr = null;                int at_index = args[argc].indexOf('@');                if (at_index < 0) {                    lvmidStr = args[argc];                } else {                    lvmidStr = args[argc].substring(0, at_index);                }                 // try to parse the lvmid part as an integer                try {                    int vmid = Integer.parseInt(lvmidStr);                    // it parsed, assume a negative lvmid and continue                    break;                } catch (NumberFormatException nfe) {                    // it didn't parse. check for the -snap or jstat_options                    // file options.                    if ((argc == 0) && (args[argc].compareTo("-snap") == 0)) {                        snap = true;                    } else if (argc == 0) {                        specialOption = args[argc].substring(1);                    } else {                        throw new IllegalArgumentException(                                "illegal argument: " + args[argc]);                    }                }            }        }         // prevent 'jstat <pid>' from being accepted as a valid argument        if (!(specialOption != null || list || snap || names != null)) {            throw new IllegalArgumentException("-<option> required");        }         switch (args.length - argc) {        case 3:            if (snap) {                throw new IllegalArgumentException("invalid argument count");            }            try {                count = Integer.parseInt(args[args.length-1]);            } catch (NumberFormatException e) {                throw new IllegalArgumentException("illegal count value: "                                                   + args[args.length-1]);            }            interval = toMillis(args[args.length-2]);            vmIdString = args[args.length-3];            break;        case 2:            if (snap) {                throw new IllegalArgumentException("invalid argument count");            }            interval = toMillis(args[args.length-1]);            vmIdString = args[args.length-2];            break;        case 1:            vmIdString = args[args.length-1];            break;        case 0:            if (!list) {                throw new IllegalArgumentException("invalid argument count");            }            break;        default:            throw new IllegalArgumentException("invalid argument count");        }         // set count and interval to their default values if not set above.        if (count == -1 && interval == -1) {            // default is for a single sample            count = 1;            interval = 0;        }         // validate arguments        if (comparator == null) {            comparator = new AscendingMonitorComparator();        }         // allow ',' characters to separate names, convert to '|' chars        names = (names == null) ? ALL_NAMES : names.replace(',', '|');         // verify that the given pattern parses without errors        try {            Pattern pattern = Pattern.compile(names);        } catch (PatternSyntaxException e) {            throw new IllegalArgumentException("Bad name pattern: "                                               + e.getMessage());        }         // verify that the special option is valid and get it's formatter        if (specialOption != null) {            OptionFinder finder = new OptionFinder(optionsSources());            optionFormat = finder.getOptionFormat(specialOption, timestamp);            if (optionFormat == null) {                throw new IllegalArgumentException("Unknown option: -"                                                   + specialOption);            }        }         // verify that the vm identifier is valied        try {            vmId = new VmIdentifier(vmIdString);        } catch (URISyntaxException e) {            IllegalArgumentException iae = new IllegalArgumentException(                    "Malformed VM Identifier: " + vmIdString);            iae.initCause(e);            throw iae;        }    }     public Comparator<Monitor> comparator() {        return comparator;    }     public boolean isHelp() {        return help;    }     public boolean isList() {        return list;    }     public boolean isSnap() {        return snap;    }     public boolean isOptions() {        return options;    }     public boolean isVerbose() {        return verbose;    }     public boolean printConstants() {        return constants;    }     public boolean isConstantsOnly() {        return constantsOnly;    }     public boolean printStrings() {        return strings;    }     public boolean showUnsupported() {        return showUnsupported;    }     public int headerRate() {        return headerRate;    }     public String counterNames() {        return names;    }     public VmIdentifier vmId() {        return vmId;    }     public String vmIdString() {        return vmIdString;    }     public int sampleInterval() {        return interval;    }     public int sampleCount() {        return count;    }     public boolean isTimestamp() {        return timestamp;    }     public boolean isSpecialOption() {        return specialOption != null;    }     public String specialOption() {        return specialOption;    }     public OptionFormat optionFormat() {        return optionFormat;    }     public List<URL> optionsSources() {        List<URL> sources = new ArrayList<URL>();        int i = 0;         String filename = OPTIONS_FILENAME;         try {            String userHome = System.getProperty("user.home");            String userDir = userHome + "/" + JVMSTAT_USERDIR;            File home = new File(userDir + "/" + filename);            sources.add(home.toURI().toURL());        } catch (Exception e) {            if (debug) {                System.err.println(e.getMessage());                e.printStackTrace();            }            throw new IllegalArgumentException("Internal Error: Bad URL: "                                               + e.getMessage());        }        URL u = this.getClass().getResource("resources/" + filename);        assert u != null;        sources.add(u);         if (showUnsupported) {            u = this.getClass().getResource("resources/" +  UNSUPPORTED_OPTIONS_FILENAME);            assert u != null;            sources.add(u);        }        return sources;    }}