Checkpoint commit for OPENDJ-1306 - Added subcommand for Setup CLI. - Added...

Violette Roche-Montane

06.32.2014 ae2964516ff5296a50b354b4c1283879a637dc0c

Checkpoint commit for OPENDJ-1306
- Added subcommand for Setup CLI.
- Added logger.
- Removed javacheckversion from model. The function is now in the Utils.
- Added unit tests for subcommands.

 opendj-server/src/main/java/org/forgerock/opendj/server/setup/cli/SetupCli.java

@@ -26,9 +26,12 @@

import static com.forgerock.opendj.cli.Utils.filterExitCode;
import static com.forgerock.opendj.cli.Utils.LINE_SEPARATOR;
import static com.forgerock.opendj.cli.Utils.checkJavaVersion;
import static com.forgerock.opendj.cli.CliMessages.*;


import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
@@ -36,64 +39,93 @@

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.i18n.LocalizableMessageBuilder;
import org.forgerock.opendj.ldap.ResultCode;
import org.forgerock.i18n.slf4j.LocalizedLogger;

import com.forgerock.opendj.cli.Argument;
import com.forgerock.opendj.cli.ArgumentException;
import com.forgerock.opendj.cli.ArgumentParser;
import com.forgerock.opendj.cli.BooleanArgument;
import com.forgerock.opendj.cli.CLIException;
import com.forgerock.opendj.cli.CommonArguments;
import com.forgerock.opendj.cli.ConsoleApplication;
import com.forgerock.opendj.cli.FileBasedArgument;
import com.forgerock.opendj.cli.IntegerArgument;
import com.forgerock.opendj.cli.ReturnCode;
import com.forgerock.opendj.cli.StringArgument;
import com.forgerock.opendj.cli.SubCommand;
import com.forgerock.opendj.cli.SubCommandArgumentParser;

/**
 * This class implements the new CLI for OpenDJ3 setup.
 */
public final class SetupCli extends ConsoleApplication {

    ArgumentParser argParser;
    /**
     * Setup's logger.
     */
    private static final LocalizedLogger LOG = LocalizedLogger.getLoggerForThisClass();

    BooleanArgument testOnly;
    BooleanArgument cli;
    BooleanArgument addBaseEntry;
    BooleanArgument skipPortCheck;
    BooleanArgument enableWindowsService;
    BooleanArgument doNotStart;
    BooleanArgument enableStartTLS;
    BooleanArgument generateSelfSignedCertificate;
    StringArgument hostName;
    BooleanArgument usePkcs11;
    FileBasedArgument directoryManagerPwdFile;
    FileBasedArgument keyStorePasswordFile;
    IntegerArgument ldapPort;
    IntegerArgument adminConnectorPort;
    IntegerArgument ldapsPort;
    IntegerArgument jmxPort;
    IntegerArgument sampleData;
    StringArgument baseDN;
    StringArgument importLDIF;
    StringArgument rejectedImportFile;
    StringArgument skippedImportFile;
    StringArgument directoryManagerDN;
    StringArgument directoryManagerPwdString;
    StringArgument useJavaKeyStore;
    StringArgument useJCEKS;
    StringArgument usePkcs12;
    StringArgument keyStorePassword;
    StringArgument certNickname;
    StringArgument progName;
    IntegerArgument connectTimeout = null;
    BooleanArgument acceptLicense;
    /**
     * TODO remove that after implementation in config.
     *
     * @return The installation path.
     */
    static final String getInstallationPath() {
        return "/home/violette/OpenDJ-3.0.0/";
    }

    /**
     * TODO remove that after implementation in config.
     *
     * @return The instance path.
     */
    static final String getInstancePath() {
        return "/home/violette/OpenDJ-3.0.0/";
    }


    private SubCommandArgumentParser argParser;

    private BooleanArgument cli;
    private BooleanArgument addBaseEntry;
    private BooleanArgument skipPortCheck;
    private BooleanArgument enableWindowsService;
    private BooleanArgument doNotStart;
    private BooleanArgument enableStartTLS;
    private BooleanArgument generateSelfSignedCertificate;
    private StringArgument hostName;
    private BooleanArgument usePkcs11;
    private FileBasedArgument directoryManagerPwdFile;
    private FileBasedArgument keyStorePasswordFile;
    private IntegerArgument ldapPort;
    private IntegerArgument adminConnectorPort;
    private IntegerArgument ldapsPort;
    private IntegerArgument jmxPort;
    private IntegerArgument sampleData;
    private StringArgument baseDN;
    private StringArgument importLDIF;
    private StringArgument rejectedImportFile;
    private StringArgument skippedImportFile;
    private StringArgument directoryManagerDN;
    private StringArgument directoryManagerPwdString;
    private StringArgument useJavaKeyStore;
    private StringArgument useJCEKS;
    private StringArgument usePkcs12;
    private StringArgument keyStorePassword;
    private StringArgument certNickname;
    private IntegerArgument connectTimeout = null;
    private BooleanArgument acceptLicense;

    // Sub-commands
    private SubCommand createDirectoryServer;
    private SubCommand createProxy;

    // Register the global arguments.
    BooleanArgument noPrompt;
    BooleanArgument quietMode;
    BooleanArgument verbose;
    StringArgument propertiesFile;
    BooleanArgument noPropertiesFile;
    BooleanArgument showUsage;
    private BooleanArgument noPrompt;
    private BooleanArgument quietMode;
    private BooleanArgument verbose;
    private StringArgument propertiesFile;
    private BooleanArgument noPropertiesFile;
    private BooleanArgument showUsage;

    private SetupCli() {
        // Nothing to do.
@@ -117,16 +149,22 @@

    /** Create the command-line argument parser for use with this program. */
    int run(final String[] args) {
        // TODO SetupLog.initLogFileHandler();

        try {
            argParser = new ArgumentParser("Setup", INFO_SETUP_TITLE.get(), true, false, 0, 0, INFO_SETUP_DESCRIPTION
                    .get().toString());
            checkJavaVersion();
        } catch (CLIException e) {
            println(e.getMessageObject());
            return ReturnCode.JAVA_VERSION_INCOMPATIBLE.get();
        }

        try {
            argParser = new SubCommandArgumentParser("setup", INFO_SETUP_DESCRIPTION.get(), true);
            initializeArguments();

        } catch (ArgumentException e) {
            final LocalizableMessage message = ERR_CANNOT_INITIALIZE_ARGS.get(e.getMessage());
            println(message);
            return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue();
            return ReturnCode.CLIENT_SIDE_PARAM_ERROR.get();
        }

        // Parse the command-line arguments provided to this program.
@@ -135,12 +173,12 @@

            if (argParser.usageOrVersionDisplayed()) {
                // If we should just display usage or version information, then print it and exit.
                return ResultCode.SUCCESS.intValue();
                return ReturnCode.SUCCESS.get();
            }
        } catch (final ArgumentException e) {
            final LocalizableMessage message = ERR_ERROR_PARSING_ARGS.get(e.getMessage());
            println(message);
            return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue();
            return ReturnCode.CLIENT_SIDE_PARAM_ERROR.get();
        }

        // Verifying provided informations.
@@ -151,25 +189,22 @@
            checkImportDataArguments(errorMessages);
            checkSecurityArguments(errorMessages);
            if (errorMessages.size() > 0) {
                throw new ArgumentException(ERR_CANNOT_INITIALIZE_ARGS.get(getMessageFromCollection(errorMessages,
                        LINE_SEPARATOR)));
                throw new ArgumentException(ERR_CANNOT_INITIALIZE_ARGS.get(
                        getMessageFromCollection(errorMessages, LINE_SEPARATOR)));
            }
        } catch (final ArgumentException e) {
            println(e.getMessageObject());
            return ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue();
            return ReturnCode.CLIENT_SIDE_PARAM_ERROR.get();
        }

        // Starts setup process.

        return ResultCode.SUCCESS.intValue();
        return ReturnCode.SUCCESS.get();
    }

    private void initializeArguments() throws ArgumentException {

        // Options.
        acceptLicense = CommonArguments.getAcceptLicense();

        testOnly = CommonArguments.getTestOnly();
        cli = CommonArguments.getCLI();
        baseDN = CommonArguments.getBaseDN();
        addBaseEntry = CommonArguments.getAddBaseEntry();
@@ -197,44 +232,57 @@
        keyStorePassword = CommonArguments.getKeyStorePassword();
        keyStorePasswordFile = CommonArguments.getKeyStorePasswordFile();
        certNickname = CommonArguments.getCertNickName();
        connectTimeout = CommonArguments.getConnectTimeOut(30000);

        // Utility Input Output Options.
        noPrompt = CommonArguments.getNoPrompt();
        quietMode = CommonArguments.getQuiet();
        verbose = CommonArguments.getVerbose();
        propertiesFile = CommonArguments.getPropertiesFileArgument();
        noPropertiesFile = CommonArguments.getNoPropertiesFileArgument();
        propertiesFile = CommonArguments.getPropertiesFile();
        noPropertiesFile = CommonArguments.getNoPropertiesFile();
        showUsage = CommonArguments.getShowUsage();

        // Register global arguments.
        argParser.addArgument(testOnly);
        argParser.addArgument(cli);
        argParser.addArgument(baseDN);
        argParser.addArgument(addBaseEntry);
        argParser.addArgument(importLDIF);
        argParser.addArgument(rejectedImportFile);
        argParser.addArgument(skippedImportFile);
        argParser.addArgument(sampleData);
        argParser.addArgument(ldapPort);
        argParser.addArgument(adminConnectorPort);
        argParser.addArgument(jmxPort);
        argParser.addArgument(skipPortCheck);
        argParser.addArgument(directoryManagerDN);
        argParser.addArgument(directoryManagerPwdString);
        argParser.addArgument(directoryManagerPwdFile);
        argParser.addArgument(enableWindowsService);
        argParser.addArgument(doNotStart);
        argParser.addArgument(enableStartTLS);
        argParser.addArgument(ldapsPort);
        argParser.addArgument(generateSelfSignedCertificate);
        argParser.addArgument(hostName);
        argParser.addArgument(usePkcs11);
        argParser.addArgument(useJavaKeyStore);
        argParser.addArgument(useJCEKS);
        argParser.addArgument(usePkcs12);
        argParser.addArgument(keyStorePassword);
        argParser.addArgument(keyStorePasswordFile);
        argParser.addArgument(certNickname);
        argParser.addGlobalArgument(cli);
        argParser.addGlobalArgument(baseDN);
        argParser.addGlobalArgument(addBaseEntry);
        argParser.addGlobalArgument(importLDIF);
        argParser.addGlobalArgument(rejectedImportFile);
        argParser.addGlobalArgument(skippedImportFile);
        argParser.addGlobalArgument(sampleData);
        argParser.addGlobalArgument(ldapPort);
        argParser.addGlobalArgument(adminConnectorPort);
        argParser.addGlobalArgument(jmxPort);
        argParser.addGlobalArgument(skipPortCheck);
        argParser.addGlobalArgument(directoryManagerDN);
        argParser.addGlobalArgument(directoryManagerPwdString);
        argParser.addGlobalArgument(directoryManagerPwdFile);
        argParser.addGlobalArgument(enableWindowsService);
        argParser.addGlobalArgument(doNotStart);
        argParser.addGlobalArgument(enableStartTLS);
        argParser.addGlobalArgument(ldapsPort);
        argParser.addGlobalArgument(generateSelfSignedCertificate);
        argParser.addGlobalArgument(hostName);
        argParser.addGlobalArgument(usePkcs11);
        argParser.addGlobalArgument(useJavaKeyStore);
        argParser.addGlobalArgument(useJCEKS);
        argParser.addGlobalArgument(usePkcs12);
        argParser.addGlobalArgument(keyStorePassword);
        argParser.addGlobalArgument(keyStorePasswordFile);
        argParser.addGlobalArgument(certNickname);
        argParser.addGlobalArgument(connectTimeout);

        //Sub-commands && their arguments
        final ArrayList<SubCommand> subCommandList = new ArrayList<SubCommand>(2);
        createDirectoryServer = new SubCommand(argParser, "create-directory-server",
                INFO_SETUP_SUBCOMMAND_CREATE_DIRECTORY_SERVER.get());
        // TODO to complete.
        createProxy = new SubCommand(argParser, "create-proxy",
                INFO_SETUP_SUBCOMMAND_CREATE_PROXY.get());
        subCommandList.add(createDirectoryServer);
        subCommandList.add(createProxy);

        argParser.setUsageGroupArgument(showUsage, subCommandList);

        // Register the global arguments.
        argParser.addArgument(showUsage);
@@ -286,6 +334,15 @@
    }

    /**
     * Returns whether the command was launched to setup proxy or not.
     *
     * @return <CODE>true</CODE> if the command was launched to setup a proxy and <CODE>false</CODE> otherwise.
     */
    public boolean isCreateProxy() {
        return (argParser.getSubCommand("create-proxy") != null);
    }

    /**
     * Checks that there are no conflicts with the provided ports (like if the user provided the same port for different
     * protocols).
     *
@@ -322,11 +379,8 @@
                }
            }
        } catch (ArgumentException ae) {
            // TODO log that
            /*
             * logger.error(LocalizableMessage.raw("Unexpected error.  " +
             * "Assuming that it is caused by a previous parsing issue: " + ae, ae));
             */
            LOG.error(LocalizableMessage.raw("Unexpected error. "
                    + "Assuming that it is caused by a previous parsing issue: " + ae, ae));
        }
    }


 opendj-server/src/main/java/org/forgerock/opendj/server/setup/cli/SetupLog.java

New file
@@ -0,0 +1,122 @@
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at legal-notices/CDDLv1_0.txt.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2014 ForgeRock AS
 */

package org.forgerock.opendj.server.setup.cli;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.logging.FileHandler;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

import com.forgerock.opendj.cli.CLIException;
import com.forgerock.opendj.cli.CliMessages;

/**
 * Creates a historical log about the setup. If file does not exist an attempt will be made to create it.
 */
final class SetupLog {

    static private File logFile = null;
    static private FileHandler fileHandler = null;
    final static String LOGNAME = "setup.log";

    private SetupLog() {
        //  Nothing to do.
    }
    /**
     * Creates a new file handler for writing log messages into {@value #LOGNAME} file.
     */
    static void initLogFileHandler() {
        final Logger logger = Logger.getLogger(SetupCli.class.getName());

        final String space = " ";

        if (logFile == null) {
            logFile = new File(new StringBuilder(SetupCli.getInstallationPath()).append(File.separator).append(LOGNAME)
                    .toString());
        }
        try {
            fileHandler = new FileHandler(logFile.getCanonicalPath(), true);
        } catch (IOException e) {
            logger.severe(e.getMessage());
        }
        fileHandler.setFormatter(new Formatter() {
            /** {@inheritDoc} */
            @Override
            public String format(LogRecord record) {
                // Format the log ~like the errors logger.
                StringBuffer sb = new StringBuffer();
                final SimpleDateFormat dateFormat = new SimpleDateFormat("[dd/MMM/yyyy:HH:mm:ss Z]");
                sb.append(dateFormat.format(record.getMillis())).append(space);
                sb.append("category=SETUP").append(space).append("sq=").append(record.getSequenceNumber())
                        .append(space).append("severity=").append(record.getLevel().toString().toUpperCase());
                sb.append(space).append("src=").append(record.getSourceClassName()).append(space)
                        .append(record.getSourceMethodName()).append("\n");
                sb.append(space).append("msg=").append(record.getMessage()).append("\n");
                return sb.toString();
            }
        });
        logger.setLevel(Level.CONFIG);
        logger.addHandler(fileHandler);

        logger.setUseParentHandlers(false);
        // Log Config info.
        logger.info("**** Setup of OpenDJ3 started ****");
        logger.info(CliMessages.INFO_INSTALLATION_DIRECTORY.get(SetupCli.getInstallationPath()).toString());
        logger.info(CliMessages.INFO_INSTANCE_DIRECTORY.get(SetupCli.getInstancePath()).toString());
    }

    /**
     * Returns the print stream of the current logger.
     *
     * @return the print stream of the current logger.
     * @throws CLIException
     *             If the file defined by the logger is not found or invalid.
     */
    static PrintStream getPrintStream() throws CLIException {
        try {
            return new PrintStream(new FileOutputStream(logFile, true));
        } catch (FileNotFoundException e) {
            throw new CLIException(CliMessages.ERR_INVALID_LOG_FILE.get(e.getMessage()));
        }
    }

    /**
     * Gets the name of the log file.
     *
     * @return File representing the log file
     */
    static public File getLogFile() {
        return logFile;
    }
}

 opendj-server/src/main/java/org/forgerock/opendj/server/setup/model/Model.java

@@ -259,14 +259,6 @@
        this.installationPath = installationPath;
    }

    void checkJavaVersion() throws ConfigException {
        final String version = System.getProperty("java.specification.version");
        if (!(Float.valueOf(version) >= 1.6)) {
            // TODO change exception : original was IncompatibleVersionException
            throw new ConfigException(LocalizableMessage.raw("invalid java version" + version));
        }
    }

    /**
     * Creates a basic data store model configuration for setup.
     */

 opendj-server/src/test/java/org/forgerock/opendj/server/setup/cli/SetupCliTestCase.java

@@ -40,6 +40,7 @@
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import com.forgerock.opendj.cli.ReturnCode;
import com.forgerock.opendj.cli.Utils;

/**
@@ -52,7 +53,12 @@
    Object[][] createValidArguments() throws Exception {
        Object[][] data = new Object[][] {
            { args("--help"),
              expectedErrOutput(LocalizableMessage.raw("Command options:")) }, };
                expectedErrOutput(INFO_SETUP_DESCRIPTION.get()) },
            { args("--cli", "create-directory-server", "--doNotStart", "--ldapPort", "1389",
                "--adminConnectorPort", "4444",
                "-D", "cn=Directory Manager", "-w", "password", "-b", "dc=example,dc=com",
                "-a"), expectedErrOutput(LocalizableMessage.EMPTY) },
        };
        return data;
    }

@@ -61,7 +67,7 @@
        Object[][] data = new Object[][] {
            { args("-c"),
                expectedErrOutput(
                        ERR_ERROR_PARSING_ARGS.get(ERR_ARGPARSER_NO_ARGUMENT_WITH_SHORT_ID.get("c"))) },
                        ERR_ERROR_PARSING_ARGS.get(ERR_SUBCMDPARSER_NO_GLOBAL_ARGUMENT_FOR_SHORT_ID.get("c"))) },
            { args("-N"), expectedErrOutput(ERR_ERROR_PARSING_ARGS.get(
                    ERR_ARGPARSER_NO_VALUE_FOR_ARGUMENT_WITH_SHORT_ID.get("N"))) },
        };
@@ -74,7 +80,7 @@
            { args("--cli", "--doNotStart", "--ldapPort", "1389", "--adminConnectorPort", "4444",
                    "-D", "cn=Directory Manager", "-w", "password", "-b", "dc=example,dc=com",
                    "-a"),
                expectedErrOutput(LocalizableMessage.EMPTY) },
                null },
        };
        return data;
    }
@@ -109,7 +115,7 @@
    }
    // @formatter:on

    /*@Test(dataProvider = "validArguments")
    @Test(dataProvider = "validArguments")
    public void testRunValidArguments(String[] arguments, LocalizableMessage expectedErrOutput) throws Exception {
        run(arguments, true, expectedErrOutput);
    }
@@ -117,17 +123,24 @@
    @Test(dataProvider = "invalidArguments")
    public void testRunInvalidArguments(String[] arguments, LocalizableMessage expectedErrOutput) throws Exception {
        run(arguments, false, expectedErrOutput);
    }*/
    }

    @Test(dataProvider = "validPorts")
    public void testcheckValidProvidedPorts(String[] arguments, LocalizableMessage expectedErrOutput) throws Exception {
        run(arguments, true, expectedErrOutput);
    }

    @Test(dataProvider = "invalidPorts")
    public void testcheckProvidedPorts(String[] arguments, LocalizableMessage expectedErrOutput) throws Exception {
    public void testcheckInvalidProvidedPorts(String[] arguments, LocalizableMessage expectedErrOutput)
            throws Exception {
        run(arguments, false, expectedErrOutput);
    }

    private void run(String[] arguments, boolean expectsResults, LocalizableMessage expectedErrOutput)
    private void run(final String[] arguments, final boolean shouldSucceed, final LocalizableMessage expectedErrOutput)
            throws UnsupportedEncodingException {
        PrintStream outStream = null;
        PrintStream errStream = null;
        int resultCode = 0;
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            outStream = new PrintStream(out);
@@ -135,19 +148,21 @@
            errStream = new PrintStream(err);

            final SetupCli setup = new SetupCli(outStream, errStream);
            setup.run(arguments);
            resultCode = setup.run(arguments);

            if (expectsResults) {
                assertThat(out.size()).isGreaterThan(0);
                assertThat(out.toString("UTF-8")).contains(wrapText(expectedErrOutput, MAX_LINE_WIDTH));
            if (shouldSucceed) {
                if (expectedErrOutput != null) {
                    assertThat(out.toString("UTF-8")).contains(wrapText(expectedErrOutput, MAX_LINE_WIDTH));
                }
                assertThat(resultCode).isEqualTo(ReturnCode.SUCCESS.get());
            } else {
                assertThat(resultCode).isNotEqualTo(ReturnCode.SUCCESS.get());
                assertThat(out.size()).isEqualTo(0);
                assertThat(err.size()).isGreaterThan(0);
                final String errorMsg = err.toString("UTF-8").replaceAll(Utils.LINE_SEPARATOR, " ");
                final String expectedMsg = expectedErrOutput.toString().replaceAll(Utils.LINE_SEPARATOR, " ");
                assertTrue(errorMsg.contains(expectedMsg), errorMsg + "\n >---< \n" + expectedMsg);
            }

        } finally {
            closeSilently(outStream, errStream);
        }
@@ -162,5 +177,4 @@
    private LocalizableMessage expectedErrOutput(LocalizableMessage val) {
        return val;
    }

}

 opendj-server/src/test/java/org/forgerock/opendj/server/setup/model/ModelTestCase.java

@@ -396,35 +396,4 @@
        assertTrue(ds.hasLicense());
        ds.validate();
    }

    /**
     * Performs security checks.
     *
     * @throws ConfigException
     *             If a configuration exception occurs.
     */
    @Test()
    public void testCheckJavaVersion() throws ConfigException {
        final Model ds = new DataStoreModel();
        ds.checkJavaVersion();
    }

    /**
     * Performs security checks. In this case, java version is invalid.
     *
     * @throws ConfigException
     *             If a configuration exception occurs.
     */
    @Test(expectedExceptions = Exception.class)
    public void testInvalidJavaVersion() throws Exception {
        final Model ds = new DataStoreModel();
        final String original = System.getProperty("java.specification.version");
        System.setProperty("java.specification.version", "1.5");
        try {
            ds.checkJavaVersion();
        } finally {
            System.setProperty("java.specification.version", original);
        }

    }
}