oracle.kv.util.migrator.MainCommandParser Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of oracle-nosql-server Show documentation
NoSQL Database Server - supplies build and runtime support for the server (store) side of the Oracle NoSQL Database.
The newest version!
/*-
 * Copyright (C) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
 *
 * This file was distributed by Oracle as part of a version of Oracle NoSQL
 * Database made available at:
 *
 * http://www.oracle.com/technetwork/database/database-technologies/nosqldb/downloads/index.html
 *
 * Please see the LICENSE file included in the top-level directory of the
 * appropriate version of Oracle NoSQL Database for a copy of the license and
 * additional information.
 */

package oracle.kv.util.migrator;

import static oracle.kv.util.migrator.Main.makeUsage;
import static oracle.kv.util.migrator.Main.validateSource;
import static oracle.kv.util.migrator.Main.validateSourceSink;
import static oracle.kv.util.migrator.impl.util.MigratorUtils.checkFileExist;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import oracle.kv.impl.util.CommandParser;

/**
 * The migrator command line parser
 */
public class MainCommandParser extends CommandParser {

    static final String SOURCE_FLAG = "-source";
    static final String SINK_FLAG = "-sink";
    static final String SOURCES_FLAG = "-sources";
    static final String SINKS_FLAG = "-sinks";
    static final String CONFIG_FLAG = "-config";
    static final String HELP_FLAG = "-help";

    /* The argument list that hold all unparsed arguments */
    private final List args;

    /* The argument parser handle */
    private CommandParserHandler handler;

    /*
     * The lastParse indicates this is last round of parsing on left arguments,
     * if still has unparsed arguments after parsing, then reports UNKNOWN
     * argument error.
     */
    private boolean lastParse;

    private boolean listSources;
    private boolean listSinks;
    private boolean showHidden;

    private String configFile;
    private String sourceType;
    private String sinkType;

    private final String usageText;

    public MainCommandParser(String[] args) {
        this(args, null);
    }

    public MainCommandParser(String[] args, String usageText) {
        super(args, true /* dontParse */);
        this.args = new ArrayList(Arrays.asList(args));
        this.usageText = usageText;
    }

    @Override
    public boolean checkArg(String arg) {
        /*
         * Remove the argument from unparsed argument list if it is parsed as
         * known argument.
         */
        if ((handler != null && handler.checkArg(arg)) || checkArgument(arg)) {
            args.remove(arg);
        }
        return true;
    }

    private boolean checkArgument(String arg) {
        if (arg.equals(SOURCE_FLAG)) {
            sourceType = nextArg(arg);
            setHandler(new SourceSinkParserHandler());
            return true;
        }
        if (arg.equals(CONFIG_FLAG)) {
            setHandler(new ConfigParserHandler());
            configFile = nextArg(arg);
            lastParse = true;
            return true;
        }
        if (arg.equals(SOURCES_FLAG)) {
            listSources = true;
            lastParse = true;
            return true;
        }
        if (arg.equals(SINKS_FLAG)) {
            listSinks = true;
            lastParse = true;
            return true;
        }
        if (arg.equals(VERBOSE_FLAG)) {
            verbose = true;
            return true;
        }
        if (arg.equals(HELP_FLAG) || arg.equals(USAGE_FLAG)) {
            usage(null);
            return true;
        }
        if (arg.equals(HIDDEN_FLAG)) {
            showHidden = true;
            return true;
        }
        return false;
    }

    @Override
    public String nextArg(String arg) {
        String val = super.nextArg(arg);
        args.remove(val);
        return val;
    }

    @Override
    public void usage(String errorMsg) {
        String usage = null;
        try {
            usage = getUsageText();
            if (usage == null) {
                usage = usageText;
            }
        } catch (IllegalArgumentException ex) {
            if (errorMsg == null) {
                errorMsg = ex.getMessage();
            }
        }
        Main.usage(usage, errorMsg);
    }

    @Override
    protected void verifyArgs() {
        if (lastParse && !args.isEmpty()) {
            usage("Unknown argument: " + args.toString());
        }
        if (handler != null) {
            try {
                handler.validate();
            } catch (IllegalArgumentException iae) {
                usage(iae.getMessage());
            }
        } else {
            if (!listSources && !listSinks && configFile == null) {
                missingArg(SOURCE_FLAG + " | " + CONFIG_FLAG + " | " +
                           SOURCES_FLAG + " | " + SINKS_FLAG);
            }
        }
    }

    @Override
    public boolean getVerbose() {
        return verbose;
    }

    public boolean getListSources() {
        return listSources;
    }

    public boolean getListSinks() {
        return listSinks;
    }

    public String getSourceType() {
        return sourceType;
    }

    public String getSinkType() {
        return sinkType;
    }

    public String getConfigFile() {
        return configFile;
    }

    public boolean getShowHidden() {
        return showHidden;
    }

    public MainCommandParser setHandler(CommandParserHandler handler) {
        this.handler = handler;
        return this;
    }

    public MainCommandParser setLastParse() {
        this.lastParse = true;
        return this;
    }

    public String getUsageText() {
        if (handler != null) {
            return handler.getUsage();
        }
        return null;
    }

    public String[] getUnparsedArgs() {
        return args.toArray(new String[args.size()]);
    }

    static String getSourceTypeUsage(boolean showHidden) {
        StringBuilder sb = new StringBuilder(SOURCE_FLAG);
        boolean first = true;
        sb.append(" <");
        for (String type : Migrator.getSourceTypes(showHidden)) {
            if (first) {
                first = false;
            } else {
                sb.append(" | ");
            }
            sb.append(type);
        }
        sb.append(">");
        return sb.toString();
    }

    static String getSinkTypeUsage(boolean showHidden) {
        StringBuilder sb = new StringBuilder(SINK_FLAG);
        boolean first = true;
        sb.append(" <");
        for (String type : Migrator.getSinkTypes(showHidden)) {
            if (first) {
                first = false;
            } else {
                sb.append(" | ");
            }
            sb.append(type);
        }
        sb.append(">");
        return sb.toString();
    }

    private void validateSourceType(String source) {
        try {
            validateSource(source, showHidden);
        } catch (IllegalArgumentException iae) {
            usage(iae.getMessage());
        }
    }

    /**
     * The handler to parse the arguments.
     */
    public interface CommandParserHandler {
        /**
         * Returns true if the given argument is valid.
         */
        boolean checkArg(String arg);

        /**
         * Validates the arguments, throw IllegalArgumentException if any
         * failure.
         */
        void validate();

        /**
         * Returns the usage text.
         */
        String getUsage();
    }

    /**
     * Parses -source and -sink arguments in below command:
     *  Usage: java -jar KVHOME/lib/migrator.jar -source  -sink 
     *         ...
     */
    private class SourceSinkParserHandler implements CommandParserHandler {

        SourceSinkParserHandler() {
        }

        @Override
        public boolean checkArg(String arg) {
            if (arg.equals(SINK_FLAG)) {
                sinkType = nextArg(arg);
                return true;
            }
            return false;
        }

        @Override
        public void validate() {
            validateSourceType(sourceType);
            if (sinkType == null) {
                missingArg(SINK_FLAG);
            }
            try {
                validateSourceSink(sourceType, sinkType);
            } catch (IllegalArgumentException iae) {
                usage(iae.getMessage());
            }
        }

        @Override
        public String getUsage() {
            String usage;
            if (sinkType == null) {
                usage = makeUsage(sourceType, showHidden);
            } else {
                usage = makeUsage(sourceType, sinkType);
            }
            return usage.isEmpty() ? null : usage;
        }
    }

    /**
     * Usage: java -jar KVHOME/lib/migrator.jar -config 
     */
    private class ConfigParserHandler implements CommandParserHandler {

        @Override
        public boolean checkArg(String argument) {
            return false;
        }

        @Override
        public void validate() {
            try {
                checkFileExist(new File(configFile),
                               false /* isDir */,
                               true /* canRead */,
                               false /* canWrite */);
            } catch (IllegalArgumentException iae) {
                usage(iae.getMessage());
            }
        }

        @Override
        public String getUsage() {
            return Main.getConfigFileUsage();
        }
    }
}