Glassfish example source code file (Parser.java)

This example Glassfish source code file (Parser.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Glassfish tags/keywords

cli, collection, commandvalidationexception, commandvalidationexception, file, io, ioexception, list, parametermap, parametermap, parammodel, parammodel, parser, string, string, util

The Glassfish Parser.java source code

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.enterprise.admin.cli;

import java.io.*;
import java.util.*;
import org.glassfish.api.admin.*;
import org.glassfish.api.admin.CommandModel.ParamModel;
import com.sun.enterprise.admin.util.*;
import com.sun.enterprise.admin.util.CommandModelData.ParamModelData;
import com.sun.enterprise.universal.i18n.LocalStringsImpl;


/**
 * The <code>Parser object is used to parse the
 * command line and verify that the command line is CLIP compliant.
 */
public class Parser {
    // MultiMap of options and values from command-line
    private ParameterMap optionsMap = new ParameterMap();
    
    // Array of operands from command-line
    private List<String> operands = new ArrayList();

    // The valid options for the command we're parsing
    private Collection<ParamModel> options;

    // Ignore unknown options when parsing?
    private boolean ignoreUnknown;

    private static final LocalStringsImpl strings =
            new LocalStringsImpl(Parser.class);

    /*
     * TODO:
     *  option types shouldn't be string literals here
     */

    /**
     * Parse the given command line arguments
     *
     * @param args  command line arguments
     * @param start index in args to start parsing
     * @param options the valid options to consider while parsing
     * @param ignoreUnknown if true, unknown options are considered operands
     *        instead of generating an exception
     * @throws CommandValidationException if command line parsing fails
     */
    public Parser(String[] args, int start,
            Collection<ParamModel> options, boolean ignoreUnknown)
            throws CommandValidationException {
        this.options = options;
        this.ignoreUnknown = ignoreUnknown;
        parseCommandLine(args, start);
    }

    /**
     * Parse the command line arguments according to CLIP.
     *
     * @param argv  command line arguments
     * @throws CommandValidationException if command line is invalid
     */
    private void parseCommandLine(final String[] argv, final int start)
        throws CommandValidationException {

        for (int si = start; si < argv.length; si++) {
            String arg = argv[si];
            if (arg.equals("--")) {             // end of options
                // if we're ignoring unknown options, we include this
                // delimiter as an operand, it will be eliminated later
                // when we process all remaining options
                if (!ignoreUnknown)
                    si++;
                while (si < argv.length)
                    operands.add(argv[si++]);
                break;
            }

            // is it an operand or option value?
            if (!arg.startsWith("-") || arg.length() <= 1) {
                operands.add(arg);
                if (ignoreUnknown)
                    continue;
                si++;
                while (si < argv.length)
                    operands.add(argv[si++]);
                break;
            }

            // at this point it's got to be an option of some sort
            ParamModel opt = null;
            String name = null;
            String value = null;
            if (arg.charAt(1) == '-') { // long option
                int ns = 2;
                boolean sawno = false;
                if (arg.startsWith("--no-")) {
                    sawno = true;
                    value = "false";
                    ns = 5;             // skip prefix
                }
                // if of the form "--option=value", extract value
                int ne = arg.indexOf('=');
                if (ne < 0)
                    name = arg.substring(ns);
                else {
                    if (value != null)
                        throw new CommandValidationException(
                            strings.get("parser.noValueAllowed", arg));
                    name = arg.substring(ns, ne);
                    value = arg.substring(ne + 1);
                }
                opt = lookupLongOption(name);
                if (sawno && optionRequiresOperand(opt))
                    throw new CommandValidationException(
                        strings.get("parser.illegalNo", opt.getName()));
            } else {                            // short option
                /*
                 * possibilities are:
                 *      -f
                 *      -f value
                 *      -f=value
                 *      -fxyz   (multiple single letter boolean options
                 *              with no arguments)
                 */
                if (arg.length() <= 2) { // one of the first two cases
                    opt = lookupShortOption(arg.charAt(1));
                    name = arg.substring(1);
                } else {                        // one of the last two cases
                    if (arg.charAt(2) == '=') { // -f=value case
                        opt = lookupShortOption(arg.charAt(1));
                        value = arg.substring(3);
                    } else {                            // -fxyz case
                        for (int i = 1; i < arg.length(); i++) {
                            opt = lookupShortOption(arg.charAt(i));
                            if (opt == null) {
                                if (!ignoreUnknown)
                                    throw new CommandValidationException(
                                        strings.get("parser.invalidOption",
                                        Character.toString(arg.charAt(i))));
                                // unknown option, skip all the rest
                                operands.add(arg);
                                break;
                            }
                            if (opt.getType() == Boolean.class ||
                                opt.getType() == boolean.class)
                                setOption(opt, "true");
                            else
                                throw new CommandValidationException(
                                    strings.get("parser.nonbooleanNotAllowed",
                                    Character.toString(arg.charAt(i)), arg));
                        }
                        continue;
                    }
                }
            }

            // is it a known option?
            if (opt == null) {
                if (!ignoreUnknown)
                    throw new CommandValidationException(
                        strings.get("parser.invalidOption", arg));
                // unknown option, skip it
                operands.add(arg);
                continue;
            }

            // find option value, if needed
            if (value == null) {
                // if no valid options were specified, we use the next argument
                // as an option as long as it doesn't look like an option
                if (options == null) {
                    if (si + 1 < argv.length && !argv[si + 1].startsWith("-"))
                        value = argv[++si];
                    else
                        ((ParamModelData)opt).type = Boolean.class; // fake it
                } else if (optionRequiresOperand(opt)) {
                    if (++si >= argv.length)
                        throw new CommandValidationException(
                            strings.get("parser.missingValue", name));
                    value = argv[si];
                } else if (opt.getType() == Boolean.class ||
                            opt.getType() == boolean.class) {
                    /*
                     * If it's a boolean option, the following parameter
                     * might be the value for the option; peek ahead to
                     * see if it looks like a boolean value.
                     */
                    if (si + 1 < argv.length) {
                        String val = argv[si + 1];
                        if (val.equalsIgnoreCase("true") ||
                                val.equalsIgnoreCase("false")) {
                            // yup, it's a boolean value, consume it
                            si++;
                            value = val;
                        }
                    }
                }
            }
            setOption(opt, value);
        }
    }

    /**
     * Returns a Map with all the options.
     * The Map is indexed by the long name of the option.
     *
     * @return options
     */
    public ParameterMap getOptions() {
        return optionsMap;
    }

    /**
     * Returns the list of operands.
     *
     * @return list of operands
     */
    public List<String> getOperands() {
        return operands;
    }

    public String toString() {
        return "CLI parser: Options = " + optionsMap +
                "; Operands = " + operands;
    }
    
    /**
     * Get ParamModel for long option name.
     */
    private ParamModel lookupLongOption(String s) {
	if (s == null || s.length() == 0)
	    return null;
        // XXX - for now, fake it if no options
        if (options == null) {
            // no valid options specified so everything is valid
            return new ParamModelData(s, String.class, true, null);
        }
        for (ParamModel od : options) {
            if (od.getParam().primary())
		continue;
            if (s.equalsIgnoreCase(od.getName()))
                return od;
	    if (s.equalsIgnoreCase(od.getParam().alias()))
                return od;
        }
        return null;
    }

    /**
     * Get ParamModel for short option name.
     */
    private ParamModel lookupShortOption(char c) {
        // XXX - for now, fake it if no options
        if (options == null)
            return null;
        String sc = Character.toString(c);
        for (ParamModel od : options) {
            if (od.getParam().shortName().equals(sc))
                return od;
        }
        return null;
    }

    /**
     * Does this option require an operand?
     */
    private static boolean optionRequiresOperand(ParamModel opt) {
        return opt != null && opt.getType() != Boolean.class &&
                                opt.getType() != boolean.class;
    }

    /**
     * Set the value for the option.
     */
    private void setOption(ParamModel opt, String value)
            throws CommandValidationException {
        String name = opt.getName();
        // VERY basic validation
        if (opt == null)
            throw new NullPointerException("null option name");
        if (value != null)
            value = value.trim();

        if (opt.getType() == File.class) {
            File f = new File(value);
            // allow the pseudo-file name of "-" to mean stdin
            if (!value.equals("-") && !(f.isFile() || f.canRead())) {
                // get a real exception for why it's no good
                InputStream is = null;
                try {
                    is = new FileInputStream(f);
                } catch (IOException ioex) {
                    throw new CommandValidationException(
                        strings.get("parser.invalidFileEx",
                                    name, ioex.toString()));
                } finally {
                    if (is != null)
                        try {
                            is.close();
                        } catch (IOException cex) { }
                }
                throw new CommandValidationException(
                    strings.get("parser.invalidFile", name, value));
            }
        } else if (opt.getType() == Boolean.class ||
                    opt.getType() == boolean.class) {
            if (value == null)
                value = "true";
            else if (!(value.toLowerCase(Locale.ENGLISH).equals("true") ||
                    value.toLowerCase(Locale.ENGLISH).equals("false")))
                throw new CommandValidationException(
                    strings.get("parser.invalidBoolean", name, value));
        } else if (opt.getParam().password())
            throw new CommandValidationException(
                strings.get("parser.passwordNotAllowed", opt.getName()));

        if (!opt.getParam().multiple()) {
            // repeats not allowed
            if (optionsMap.containsKey(name)) {
                throw new CommandValidationException(
                        strings.get("parser.noRepeats", name));
            }
        }

        optionsMap.add(name, value);
    }
}