/* * 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 * trunk/opends/resource/legal-notices/OpenDS.LICENSE * or https://OpenDS.dev.java.net/OpenDS.LICENSE. * 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 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. 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 * * * Portions Copyright 2007 Sun Microsystems, Inc. */ package org.opends.guitools.replicationcli; import static org.opends.messages.AdminToolMessages.*; import static org.opends.messages.ToolMessages.*; import static org.opends.server.tools.ToolConstants.*; import java.io.OutputStream; import java.util.ArrayList; import java.util.LinkedList; import org.opends.messages.Message; import org.opends.messages.MessageBuilder; import org.opends.quicksetup.Constants; import org.opends.quicksetup.UserData; import org.opends.quicksetup.util.Utils; import org.opends.server.admin.client.cli.SecureConnectionCliArgs; import org.opends.server.admin.client.cli.SecureConnectionCliParser; import org.opends.server.util.args.Argument; import org.opends.server.util.args.ArgumentException; import org.opends.server.util.args.BooleanArgument; import org.opends.server.util.args.FileBasedArgument; import org.opends.server.util.args.IntegerArgument; import org.opends.server.util.args.StringArgument; import org.opends.server.util.args.SubCommand; /** * This class is used to parse the arguments passed to the replication CLI. * It also checks the compatibility between the values and that all the * required information has been provided. However it does not do any * verification that require connection to any server. */ public class ReplicationCliArgumentParser extends SecureConnectionCliParser { private SubCommand enableReplicationSubCmd; private SubCommand disableReplicationSubCmd; private SubCommand initializeReplicationSubCmd; private SubCommand initializeAllReplicationSubCmd; private SubCommand postExternalInitializationSubCmd; private SubCommand preExternalInitializationSubCmd; private SubCommand statusReplicationSubCmd; private BooleanArgument noPromptArg; private String defaultLocalHostValue; /** * The 'hostName' argument for the first server. */ private StringArgument hostName1Arg = null; /** * The 'port' argument for the first server. */ private IntegerArgument port1Arg = null; /** * The 'binDN' argument for the first server. */ private StringArgument bindDn1Arg = null; /** * The 'bindPasswordFile' argument for the first server. */ private FileBasedArgument bindPasswordFile1Arg = null; /** * The 'bindPassword' argument for the first server. */ private StringArgument bindPassword1Arg = null; /** * The 'useSSLArg' argument for the first server. */ private BooleanArgument useSSL1Arg = null; /** * The 'useStartTLS1Arg' argument for the first server. */ private BooleanArgument useStartTLS1Arg = null; /** * The 'replicationPort' argument for the first server. */ private IntegerArgument replicationPort1Arg = null; /** * The 'secureReplication' argument for the first server. */ private BooleanArgument secureReplication1Arg = null; /** * The 'hostName' argument for the second server. */ private StringArgument hostName2Arg = null; /** * The 'port' argument for the second server. */ private IntegerArgument port2Arg = null; /** * The 'binDN' argument for the second server. */ private StringArgument bindDn2Arg = null; /** * The 'bindPasswordFile' argument for the second server. */ private FileBasedArgument bindPasswordFile2Arg = null; /** * The 'bindPassword' argument for the second server. */ private StringArgument bindPassword2Arg = null; /** * The 'useSSLArg' argument for the second server. */ private BooleanArgument useSSL2Arg = null; /** * The 'useStartTLS2Arg' argument for the second server. */ private BooleanArgument useStartTLS2Arg = null; /** * The 'replicationPort' argument for the second server. */ private IntegerArgument replicationPort2Arg = null; /** * The 'secureReplication' argument for the second server. */ private BooleanArgument secureReplication2Arg = null; /** * The 'skipPortCheckArg' argument to not check replication ports. */ private BooleanArgument skipPortCheckArg; /** * The 'noSchemaReplication' argument to not replicate schema. */ private BooleanArgument noSchemaReplicationArg; /** * The 'useSecondServerAsSchemaSource' argument to not replicate schema. */ private BooleanArgument useSecondServerAsSchemaSourceArg; /** * The 'hostName' argument for the source server. */ private StringArgument hostNameSourceArg = null; /** * The 'port' argument for the source server. */ private IntegerArgument portSourceArg = null; /** * The 'useSSLArg' for the source server. */ private BooleanArgument useSSLSourceArg = null; /** * The 'useStartTLSSourceArg' for the source server. */ private BooleanArgument useStartTLSSourceArg = null; /** * The 'hostName' argument for the destination server. */ private StringArgument hostNameDestinationArg = null; /** * The 'port' argument for the destination server. */ private IntegerArgument portDestinationArg = null; /** * The 'useSSLArg' argument for the destination server. */ private BooleanArgument useSSLDestinationArg = null; /** * The 'useStartTLSDestinationArg' argument for the destination server. */ private BooleanArgument useStartTLSDestinationArg = null; /** * The 'suffixes' global argument. */ private StringArgument baseDNsArg = null; /** * The argument that specifies if the external initialization will be * performed only on this server. */ private BooleanArgument externalInitializationLocalOnlyArg; /** * The 'quiet' argument. */ private BooleanArgument quietArg; /** * The 'scriptFriendly' argument. */ private BooleanArgument scriptFriendlyArg; /** * The text of the enable replication subcommand. */ public static final String ENABLE_REPLICATION_SUBCMD_NAME = "enable"; /** * The text of the disable replication subcommand. */ public static final String DISABLE_REPLICATION_SUBCMD_NAME = "disable"; /** * The text of the initialize replication subcommand. */ public static final String INITIALIZE_REPLICATION_SUBCMD_NAME = "initialize"; /** * The text of the initialize all replication subcommand. */ public static final String INITIALIZE_ALL_REPLICATION_SUBCMD_NAME = "initialize-all"; /** * The text of the pre external initialization subcommand. */ public static final String PRE_EXTERNAL_INITIALIZATION_SUBCMD_NAME = "pre-external-initialization"; /** * The text of the initialize all replication subcommand. */ public static final String POST_EXTERNAL_INITIALIZATION_SUBCMD_NAME = "post-external-initialization"; /** * The text of the status replication subcommand. */ public static final String STATUS_REPLICATION_SUBCMD_NAME = "status"; /** * Creates a new instance of this argument parser with no arguments. * * @param mainClassName * The fully-qualified name of the Java class that should * be invoked to launch the program with which this * argument parser is associated. */ public ReplicationCliArgumentParser(String mainClassName) { super(mainClassName, INFO_REPLICATION_TOOL_DESCRIPTION.get(ENABLE_REPLICATION_SUBCMD_NAME, INITIALIZE_REPLICATION_SUBCMD_NAME), false); } /** * Initialize the parser with the Global options and subcommands. * * @param outStream * The output stream to use for standard output, or null * if standard output is not needed. * @throws ArgumentException * If there is a problem with any of the parameters used * to create this argument. */ public void initializeParser(OutputStream outStream) throws ArgumentException { initializeGlobalArguments(outStream); createEnableReplicationSubCommand(); createDisableReplicationSubCommand(); createInitializeReplicationSubCommand(); createInitializeAllReplicationSubCommand(); createPreExternalInitializationSubCommand(); createPostExternalInitializationSubCommand(); createStatusReplicationSubCommand(); } /** * Checks all the options parameters and updates the provided MessageBuilder * with the errors that where encountered. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ public void validateOptions(MessageBuilder buf) { validateGlobalOptions(buf); validateSubcommandOptions(buf); } /** * {@inheritDoc} */ public int validateGlobalOptions(MessageBuilder buf) { int returnValue; super.validateGlobalOptions(buf); ArrayList errors = new ArrayList(); if (secureArgsList.bindPasswordArg.isPresent() && secureArgsList.bindPasswordFileArg.isPresent()) { Message message = ERR_TOOL_CONFLICTING_ARGS.get( secureArgsList.bindPasswordArg.getLongIdentifier(), secureArgsList.bindPasswordFileArg.getLongIdentifier()); errors.add(message); } if (!isInteractive()) { // Check that we have the required data if (!baseDNsArg.isPresent() && !isStatusReplicationSubcommand()) { errors.add(ERR_REPLICATION_NO_BASE_DN_PROVIDED.get()); } if (getBindPasswordAdmin() == null) { errors.add(ERR_REPLICATION_NO_ADMINISTRATOR_PASSWORD_PROVIDED.get( secureArgsList.bindPasswordArg.getLongIdentifier(), secureArgsList.bindPasswordFileArg.getLongIdentifier())); } } if (baseDNsArg.isPresent()) { LinkedList baseDNs = baseDNsArg.getValues(); for (String dn : baseDNs) { if (!Utils.isDn(dn)) { errors.add(ERR_REPLICATION_NOT_A_VALID_BASEDN.get(dn)); } } } if (errors.size() > 0) { for (Message error : errors) { addMessage(buf, error); } } if (buf.length() > 0) { returnValue = ReplicationCliReturnCode.CONFLICTING_ARGS.getReturnCode(); } else { returnValue = ReplicationCliReturnCode.SUCCESSFUL_NOP.getReturnCode(); } return returnValue; } /** * Initialize Global option. * * @param outStream * The output stream used for the usage. * @throws ArgumentException * If there is a problem with any of the parameters used * to create this argument. */ private void initializeGlobalArguments(OutputStream outStream) throws ArgumentException { ArrayList defaultArgs = new ArrayList(createGlobalArguments(outStream)); Argument[] argsToRemove = { secureArgsList.hostNameArg, secureArgsList.portArg, secureArgsList.bindDnArg, secureArgsList.bindPasswordFileArg, secureArgsList.bindPasswordArg, secureArgsList.useSSLArg, secureArgsList.useStartTLSArg }; for (int i=0; itrue if the user specified to have an interactive * operation and false otherwise. */ public boolean isInteractive() { return !noPromptArg.isPresent(); } /** * Tells whether the user specified to have a quite operation or not. * This method must be called after calling parseArguments. * @return true if the user specified to have a quite operation * and false otherwise. */ public boolean isQuiet() { return quietArg.isPresent(); } /** * Tells whether the user specified to have a script-friendly output or not. * This method must be called after calling parseArguments. * @return true if the user specified to have a script-friendly * output and false otherwise. */ public boolean isScriptFriendly() { return scriptFriendlyArg.isPresent(); } /** * Get the password which has to be used for the command to connect to the * first server without prompting the user in the enable replication * subcommand. If no password was specified return null. * * @return the password which has to be used for the command to connect to the * first server without prompting the user in the enable replication * subcommand. If no password was specified return null. */ public String getBindPassword1() { return getBindPassword(bindPassword1Arg, bindPasswordFile1Arg); } /** * Get the password which has to be used for the command to connect to the * second server without prompting the user in the enable replication * subcommand. If no password was specified return null. * * @return the password which has to be used for the command to connect to the * second server without prompting the user in the enable replication * subcommand. If no password was specified return null. */ public String getBindPassword2() { return getBindPassword(bindPassword2Arg, bindPasswordFile2Arg); } /** * Get the global administrator password which has to be used for the command * to connect to the server(s) without prompting the user. If no password was * specified, return null. * * @return the global administrator password which has to be used for the * command to connect to the server(s) without prompting the user. If no * password was specified, return null. */ public String getBindPasswordAdmin() { return getBindPassword(secureArgsList.bindPasswordArg, secureArgsList.bindPasswordFileArg); } /** * Get the password of the first server which has to be used in the * enable replication subcommand. * * @param dn * The user DN for which to password could be asked. * @param out * The input stream to used if we have to prompt to the * user. * @param err * The error stream to used if we have to prompt to the * user. * @return the password of the first server which has to be used n the * enable replication subcommand. */ public String getBindPassword1( String dn, OutputStream out, OutputStream err) { return getBindPassword(dn, out, err, bindPassword1Arg, bindPasswordFile1Arg); } /** * Get the password of the second server which has to be used in the * enable replication subcommand. * * @param dn * The user DN for which to password could be asked. * @param out * The input stream to used if we have to prompt to the * user. * @param err * The error stream to used if we have to prompt to the * user. * @return the password of the second server which has to be used in the * enable replication subcommand. */ public String getBindPassword2( String dn, OutputStream out, OutputStream err) { return getBindPassword(dn, out, err, bindPassword2Arg, bindPasswordFile2Arg); } /** * Get the password of the global administrator which has to be used for the * command. * * @param dn * The user DN for which to password could be asked. * @param out * The input stream to used if we have to prompt to the * user. * @param err * The error stream to used if we have to prompt to the * user. * @return the password of the global administrator which has to be used for * the command. */ public String getBindPasswordAdmin( String dn, OutputStream out, OutputStream err) { return getBindPassword(dn, out, err, secureArgsList.bindPasswordArg, secureArgsList.bindPasswordFileArg); } /** * Indicate if the SSL mode is required for the first server in the enable * replication subcommand. * * @return true if SSL mode is required for the first server in * the enable replication subcommand and false otherwise. */ public boolean useSSL1() { return useSSL1Arg.isPresent(); } /** * Indicate if the startTLS mode is required for the first server in the * enable replication subcommand. * * @return true if startTLS mode is required for the first server * in the enable replication subcommand and false otherwise. */ public boolean useStartTLS1() { return useStartTLS1Arg.isPresent(); } /** * Indicate if the SSL mode is required for the second server in the enable * replication subcommand. * * @return true if SSL mode is required for the second server in * the enable replication subcommand and false otherwise. */ public boolean useSSL2() { return useSSL2Arg.isPresent(); } /** * Indicate if the startTLS mode is required for the second server in the * enable replication subcommand. * * @return true if startTLS mode is required for the second * server in the enable replication subcommand and false * otherwise. */ public boolean useStartTLS2() { return useStartTLS2Arg.isPresent(); } /** * Indicate if the SSL mode is required for the source server in the * initialize replication subcommand. * * @return true if SSL mode is required for the source server * in the initialize replication subcommand and false otherwise. */ public boolean useSSLSource() { return useSSLSourceArg.isPresent(); } /** * Indicate if the StartTLS mode is required for the source server in the * initialize replication subcommand. * * @return true if StartTLS mode is required for the source * server in the initialize replication subcommand and false * otherwise. */ public boolean useStartTLSSource() { return useStartTLSSourceArg.isPresent(); } /** * Indicate if the SSL mode is required for the destinaton server in the * initialize replication subcommand. * * @return true if SSL mode is required for the destination * server in the initialize replication subcommand and false * otherwise. */ public boolean useSSLDestination() { return useSSLDestinationArg.isPresent(); } /** * Indicate if the SSL mode is required for the destination server in the * initialize replication subcommand. * * @return true if StartTLS mode is required for the destination * server in the initialize replication subcommand and false * otherwise. */ public boolean useStartTLSDestination() { return useStartTLSDestinationArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the disable * replication subcommand. * * @return true if SSL mode is required for the server in the * disable replication subcommand and false otherwise. */ public boolean useSSLToDisable() { return secureArgsList.useSSLArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the disable * replication subcommand. * * @return true if StartTLS mode is required for the server in * the disable replication subcommand and false otherwise. */ public boolean useStartTLSToDisable() { return secureArgsList.useStartTLSArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the initialize all * replication subcommand. * * @return true if SSL mode is required for the server in the * initialize all replication subcommand and false otherwise. */ public boolean useSSLToInitializeAll() { return secureArgsList.useSSLArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the initialize all * replication subcommand. * * @return true if StartTLS mode is required for the server in * the initialize all replication subcommand and false otherwise. */ public boolean useStartTLSToInitializeAll() { return secureArgsList.useStartTLSArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the pre external * initialization subcommand. * * @return true if SSL mode is required for the server in the * pre external initialization subcommand and false otherwise. */ public boolean useSSLToPreExternalInitialization() { return secureArgsList.useSSLArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the pre external * initialization subcommand. * * @return true if StartTLS mode is required for the server in * the pre external initialization subcommand and false * otherwise. */ public boolean useStartTLSToPreExternalInitialization() { return secureArgsList.useStartTLSArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the post external * initialization subcommand. * * @return true if SSL mode is required for the server in the * post external initialization subcommand and false otherwise. */ public boolean useSSLToPostExternalInitialization() { return secureArgsList.useSSLArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the post external * initialization subcommand. * * @return true if StartTLS mode is required for the server in * the post external initialization subcommand and false * otherwise. */ public boolean useStartTLSToPostExternalInitialization() { return secureArgsList.useStartTLSArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the status * replication subcommand. * * @return true if SSL mode is required for the server in the * status replication subcommand and false otherwise. */ public boolean useSSLToStatus() { return secureArgsList.useSSLArg.isPresent(); } /** * Indicate if the SSL mode is required for the server in the status * replication subcommand. * * @return true if StartTLS mode is required for the server in * the status replication subcommand and false otherwise. */ public boolean useStartTLSToStatus() { return secureArgsList.useStartTLSArg.isPresent(); } /** * Returns the Administrator UID explicitly provided in the command-line. * @return the Administrator UID explicitly provided in the command-line. */ public String getAdministratorUID() { return getValue(secureArgsList.adminUidArg); } /** * Returns the default Administrator UID value. * @return the default Administrator UID value. */ public String getDefaultAdministratorUID() { return getDefaultValue(secureArgsList.adminUidArg); } /** * Returns the first host name explicitly provided in the enable replication * subcommand. * @return the first host name explicitly provided in the enable replication * subcommand. */ public String getHostName1() { return getValue(hostName1Arg); } /** * Returns the first host name default value in the enable replication * subcommand. * @return the first host name default value in the enable replication * subcommand. */ public String getDefaultHostName1() { return getDefaultValue(hostName1Arg); } /** * Returns the first server port explicitly provided in the enable replication * subcommand. * @return the first server port explicitly provided in the enable replication * subcommand. Returns -1 if no port was explicitly provided. */ public int getPort1() { return getValue(port1Arg); } /** * Returns the first server port default value in the enable replication * subcommand. * @return the first server port default value in the enable replication * subcommand. */ public int getDefaultPort1() { return getDefaultValue(port1Arg); } /** * Returns the first server bind dn explicitly provided in the enable * replication subcommand. * @return the first server bind dn explicitly provided in the enable * replication subcommand. */ public String getBindDn1() { return getValue(bindDn1Arg); } /** * Returns the first server bind dn default value in the enable replication * subcommand. * @return the first server bind dn default value in the enable replication * subcommand. */ public String getDefaultBindDn1() { return getDefaultValue(bindDn1Arg); } /** * Returns the first server replication port explicitly provided in the enable * replication subcommand. * @return the first server replication port explicitly provided in the enable * replication subcommand. Returns -1 if no port was explicitly provided. */ public int getReplicationPort1() { return getValue(replicationPort1Arg); } /** * Returns the first server replication port default value in the enable * replication subcommand. * @return the first server replication port default value in the enable * replication subcommand. */ public int getDefaultReplicationPort1() { return getDefaultValue(replicationPort1Arg); } /** * Returns whether the user asked to have replication communication with the * first server or not. * @return true the user asked to have replication communication * with the first server and false otherwise. */ public boolean isSecureReplication1() { return secureReplication1Arg.isPresent(); } /** * Returns the second host name explicitly provided in the enable replication * subcommand. * @return the second host name explicitly provided in the enable replication * subcommand. */ public String getHostName2() { return getValue(hostName2Arg); } /** * Returns the second host name default value in the enable replication * subcommand. * @return the second host name default value in the enable replication * subcommand. */ public String getDefaultHostName2() { return getDefaultValue(hostName2Arg); } /** * Returns the second server port explicitly provided in the enable * replication subcommand. * @return the second server port explicitly provided in the enable * replication subcommand. Returns -1 if no port was explicitly provided. */ public int getPort2() { return getValue(port2Arg); } /** * Returns the second server port default value in the enable replication * subcommand. * @return the second server port default value in the enable replication * subcommand. */ public int getDefaultPort2() { return getDefaultValue(port2Arg); } /** * Returns the second server bind dn explicitly provided in the enable * replication subcommand. * @return the second server bind dn explicitly provided in the enable * replication subcommand. */ public String getBindDn2() { return getValue(bindDn2Arg); } /** * Returns the second server bind dn default value in the enable replication * subcommand. * @return the second server bind dn default value in the enable replication * subcommand. */ public String getDefaultBindDn2() { return getDefaultValue(bindDn2Arg); } /** * Returns the second server replication port explicitly provided in the * enable replication subcommand. * @return the second server replication port explicitly provided in the * enable replication subcommand. Returns -1 if no port was explicitly * provided. */ public int getReplicationPort2() { return getValue(replicationPort2Arg); } /** * Returns the second server replication port default value in the enable * replication subcommand. * @return the second server replication port default value in the enable * replication subcommand. */ public int getDefaultReplicationPort2() { return getDefaultValue(replicationPort2Arg); } /** * Returns whether the user asked to have replication communication with the * second server or not. * @return true the user asked to have replication communication * with the second server and false otherwise. */ public boolean isSecureReplication2() { return secureReplication2Arg.isPresent(); } /** * Returns whether the user asked to skip the replication port checks (if the * ports are free) or not. * @return true the user asked to skip the replication port * checks (if the ports are free) and false otherwise. */ public boolean skipReplicationPortCheck() { return skipPortCheckArg.isPresent(); } /** * Returns whether the user asked to not replicate the schema between servers. * @return true if the user asked to not replicate schema and * false otherwise. */ public boolean noSchemaReplication() { return noSchemaReplicationArg.isPresent(); } /** * Returns whether the user asked to use the second server to initialize the * schema of the first server. * @return true if the user asked to use the second server to * initialize the schema of the first server and false otherwise. */ public boolean useSecondServerAsSchemaSource() { return useSecondServerAsSchemaSourceArg.isPresent(); } /** * Returns the host name explicitly provided in the disable replication * subcommand. * @return the host name explicitly provided in the disable replication * subcommand. */ public String getHostNameToDisable() { return getValue(secureArgsList.hostNameArg); } /** * Returns the host name default value in the disable replication * subcommand. * @return the host name default value in the disable replication * subcommand. */ public String getDefaultHostNameToDisable() { return getDefaultValue(secureArgsList.hostNameArg); } /** * Returns the server bind dn explicitly provided in the disable replication * subcommand. * @return the server bind dn explicitly provided in the disable replication * subcommand. */ public String getBindDNToDisable() { return getValue(secureArgsList.bindDnArg); } /** * Returns the server bind dn default value in the disable replication * subcommand. * @return the server bind dn default value in the enable replication * subcommand. */ public String getDefaultBindDnToDisable() { return getDefaultValue(secureArgsList.bindDnArg); } /** * Returns the host name explicitly provided in the status replication * subcommand. * @return the host name explicitly provided in the status replication * subcommand. */ public String getHostNameToStatus() { return getValue(secureArgsList.hostNameArg); } /** * Returns the host name default value in the status replication subcommand. * @return the host name default value in the status replication subcommand. */ public String getDefaultHostNameToStatus() { return getDefaultValue(secureArgsList.hostNameArg); } /** * Returns the host name explicitly provided in the initialize all replication * subcommand. * @return the host name explicitly provided in the initialize all replication * subcommand. */ public String getHostNameToInitializeAll() { return getValue(secureArgsList.hostNameArg); } /** * Returns the host name default value in the initialize all replication * subcommand. * @return the host name default value in the initialize all replication * subcommand. */ public String getDefaultHostNameToInitializeAll() { return getDefaultValue(secureArgsList.hostNameArg); } /** * Returns the host name explicitly provided in the pre external * initialization subcommand. * @return the host name explicitly provided in the pre external * initialization subcommand. */ public String getHostNameToPreExternalInitialization() { return getValue(secureArgsList.hostNameArg); } /** * Returns the host name default value in the pre external initialization * subcommand. * @return the host name default value in the pre external initialization * subcommand. */ public String getDefaultHostNameToPreExternalInitialization() { return getDefaultValue(secureArgsList.hostNameArg); } /** * Returns the host name explicitly provided in the post external * initialization subcommand. * @return the host name explicitly provided in the post external * initialization subcommand. */ public String getHostNameToPostExternalInitialization() { return getValue(secureArgsList.hostNameArg); } /** * Returns the host name default value in the post external initialization * subcommand. * @return the host name default value in the post external initialization * subcommand. */ public String getDefaultHostNameToPostExternalInitialization() { return getDefaultValue(secureArgsList.hostNameArg); } /** * Returns the source host name explicitly provided in the initialize * replication subcommand. * @return the source host name explicitly provided in the initialize * replication subcommand. */ public String getHostNameSource() { return getValue(hostNameSourceArg); } /** * Returns the first host name default value in the initialize replication * subcommand. * @return the first host name default value in the initialize replication * subcommand. */ public String getDefaultHostNameSource() { return getDefaultValue(hostNameSourceArg); } /** * Returns the destination host name explicitly provided in the initialize * replication subcommand. * @return the destination host name explicitly provided in the initialize * replication subcommand. */ public String getHostNameDestination() { return getValue(hostNameDestinationArg); } /** * Returns the destination host name default value in the initialize * replication subcommand. * @return the destination host name default value in the initialize * replication subcommand. */ public String getDefaultHostNameDestination() { return getDefaultValue(hostNameDestinationArg); } /** * Returns the source server port explicitly provided in the initialize * replication subcommand. * @return the source server port explicitly provided in the initialize * replication subcommand. Returns -1 if no port was explicitly provided. */ public int getPortSource() { return getValue(portSourceArg); } /** * Returns the source server port default value in the initialize replication * subcommand. * @return the source server port default value in the initialize replication * subcommand. */ public int getDefaultPortSource() { return getDefaultValue(portSourceArg); } /** * Returns the destination server port explicitly provided in the initialize * replication subcommand. * @return the destination server port explicitly provided in the initialize * replication subcommand. Returns -1 if no port was explicitly provided. */ public int getPortDestination() { return getValue(portDestinationArg); } /** * Returns the destination server port default value in the initialize * replication subcommand. * @return the destination server port default value in the initialize * replication subcommand. */ public int getDefaultPortDestination() { return getDefaultValue(portDestinationArg); } /** * Returns the server port explicitly provided in the disable replication * subcommand. * @return the server port explicitly provided in the disable replication * subcommand. Returns -1 if no port was explicitly provided. */ public int getPortToDisable() { return getValue(secureArgsList.portArg); } /** * Returns the server port default value in the disable replication * subcommand. * @return the server port default value in the disable replication * subcommand. */ public int getDefaultPortToDisable() { return getDefaultValue(secureArgsList.portArg); } /** * Returns the server port explicitly provided in the initialize all * replication subcommand. * @return the server port explicitly provided in the initialize all * replication subcommand. Returns -1 if no port was explicitly provided. */ public int getPortToInitializeAll() { return getValue(secureArgsList.portArg); } /** * Returns the server port default value in the initialize all replication * subcommand. * @return the server port default value in the initialize all replication * subcommand. */ public int getDefaultPortToInitializeAll() { return getDefaultValue(secureArgsList.portArg); } /** * Returns the server port explicitly provided in the pre external * initialization subcommand. * @return the server port explicitly provided in the pre external * initialization subcommand. Returns -1 if no port was explicitly provided. */ public int getPortToPreExternalInitialization() { return getValue(secureArgsList.portArg); } /** * Returns the server port default value in the pre external initialization * subcommand. * @return the server port default value in the pre external initialization * subcommand. */ public int getDefaultPortToPreExternalInitialization() { return getDefaultValue(secureArgsList.portArg); } /** * Returns the server port explicitly provided in the post external * initialization subcommand. * @return the server port explicitly provided in the post external * initialization subcommand. Returns -1 if no port was explicitly provided. */ public int getPortToPostExternalInitialization() { return getValue(secureArgsList.portArg); } /** * Returns the server port default value in the post external initialization * subcommand. * @return the server port default value in the post external initialization * subcommand. */ public int getDefaultPortToPostExternalInitialization() { return getDefaultValue(secureArgsList.portArg); } /** * Returns the server port explicitly provided in the status replication * subcommand. * @return the server port explicitly provided in the status replication * subcommand. Returns -1 if no port was explicitly provided. */ public int getPortToStatus() { return getValue(secureArgsList.portArg); } /** * Returns the server port default value in the status replication subcommand. * @return the server port default value in the status replication subcommand. */ public int getDefaultPortToStatus() { return getDefaultValue(secureArgsList.portArg); } /** * Returns the list of base DNs provided by the user. * @return the list of base DNs provided by the user. */ public LinkedList getBaseDNs() { return baseDNsArg.getValues(); } /** * Returns the value of the provided argument only if the user provided it * explicitly. * @param arg the StringArgument to be handled. * @return the value of the provided argument only if the user provided it * explicitly. */ private String getValue(StringArgument arg) { String v = null; if (arg.isPresent()) { v = arg.getValue(); } return v; } /** * Returns the default value of the provided argument. * @param arg the StringArgument to be handled. * @return the default value of the provided argument. */ private String getDefaultValue(StringArgument arg) { return arg.getDefaultValue(); } /** * Returns the value of the provided argument only if the user provided it * explicitly. * @param arg the StringArgument to be handled. * @return the value of the provided argument only if the user provided it * explicitly. */ private int getValue(IntegerArgument arg) { int v = -1; if (arg.isPresent()) { try { v = arg.getIntValue(); } catch (ArgumentException ae) { // This is a bug throw new IllegalStateException( "There was an argument exception calling "+ "ReplicationCliParser.getValue(). This appears to be a bug "+ "because this method should be called after calling "+ "parseArguments which should result in an error.", ae); } } return v; } /** * Returns the default value of the provided argument. * @param arg the StringArgument to be handled. * @return the default value of the provided argument. */ private int getDefaultValue(IntegerArgument arg) { int returnValue = -1; String defaultValue = arg.getDefaultValue(); if (defaultValue != null) { returnValue = Integer.parseInt(arg.getDefaultValue()); } return returnValue; } /** * Checks the subcommand options and updates the provided MessageBuilder * with the errors that were encountered with the subcommand options. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ public void validateSubcommandOptions(MessageBuilder buf) { if (isEnableReplicationSubcommand()) { validateEnableReplicationOptions(buf); } else if (isDisableReplicationSubcommand()) { validateDisableReplicationOptions(buf); } else if (isStatusReplicationSubcommand()) { validateStatusReplicationOptions(buf); } else if (isInitializeReplicationSubcommand()) { validateInitializeReplicationOptions(buf); } else if (isInitializeAllReplicationSubcommand()) { validateInitializeAllReplicationOptions(buf); } else if (isPreExternalInitializationSubcommand()) { validatePreExternalInitializationOptions(buf); } else if (isPostExternalInitializationSubcommand()) { validatePostExternalInitializationOptions(buf); } else { // This can occur if the user did not provide any subcommand. We assume // that the error informing of this will be generated in // validateGlobalOptions. } } /** * Returns whether the user provided subcommand is the enable replication * or not. * @return true if the user provided subcommand is the * enable replication and false otherwise. */ public boolean isEnableReplicationSubcommand() { return isSubcommand(ENABLE_REPLICATION_SUBCMD_NAME); } /** * Returns whether the user provided subcommand is the disable replication * or not. * @return true if the user provided subcommand is the * disable replication and false otherwise. */ public boolean isDisableReplicationSubcommand() { return isSubcommand(DISABLE_REPLICATION_SUBCMD_NAME); } /** * Returns whether the user provided subcommand is the status replication * or not. * @return true if the user provided subcommand is the * status replication and false otherwise. */ public boolean isStatusReplicationSubcommand() { return isSubcommand(STATUS_REPLICATION_SUBCMD_NAME); } /** * Returns whether the user provided subcommand is the initialize all * replication or not. * @return true if the user provided subcommand is the * initialize all replication and false otherwise. */ public boolean isInitializeAllReplicationSubcommand() { return isSubcommand(INITIALIZE_ALL_REPLICATION_SUBCMD_NAME); } /** * Returns whether the user provided subcommand is the pre external * initialization or not. * @return true if the user provided subcommand is the * pre external initialization and false otherwise. */ public boolean isPreExternalInitializationSubcommand() { return isSubcommand(PRE_EXTERNAL_INITIALIZATION_SUBCMD_NAME); } /** * Returns whether the user provided subcommand is the post external * initialization or not. * @return true if the user provided subcommand is the * post external initialization and false otherwise. */ public boolean isPostExternalInitializationSubcommand() { return isSubcommand(POST_EXTERNAL_INITIALIZATION_SUBCMD_NAME); } /** * Returns whether the user provided subcommand is the initialize replication * or not. * @return true if the user provided subcommand is the * initialize replication and false otherwise. */ public boolean isInitializeReplicationSubcommand() { return isSubcommand(INITIALIZE_REPLICATION_SUBCMD_NAME); } /** * Tells whether the user specified to apply the pre (or post) external * initialization operations only on the local server. * @return true if the user specified to apply the pre (or post) * external initialization operations only on the local server and * false otherwise. */ public boolean isExternalInitializationLocalOnly() { return externalInitializationLocalOnlyArg.isPresent(); } /** * Returns whether the command-line subcommand has the name provided * or not. * @param name the name of the subcommand. * @return true if command-line subcommand has the name provided * and false otherwise. */ private boolean isSubcommand(String name) { boolean isSubcommand = false; SubCommand subCommand = getSubCommand(); if (subCommand != null) { isSubcommand = subCommand.getName().equalsIgnoreCase(name); } return isSubcommand; } /** * Checks the enable replication subcommand options and updates the provided * MessageBuilder with the errors that were encountered with the subcommand * options. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ private void validateEnableReplicationOptions(MessageBuilder buf) { Argument[][] conflictingPairs = { {bindPassword1Arg, bindPasswordFile1Arg}, {useStartTLS1Arg, useSSL1Arg}, {bindPassword2Arg, bindPasswordFile2Arg}, {useStartTLS2Arg, useSSL2Arg}, {noSchemaReplicationArg, useSecondServerAsSchemaSourceArg} }; for (int i=0; i< conflictingPairs.length; i++) { Argument arg1 = conflictingPairs[i][0]; Argument arg2 = conflictingPairs[i][1]; if (arg1.isPresent() && arg2.isPresent()) { Message message = ERR_TOOL_CONFLICTING_ARGS.get( arg1.getLongIdentifier(), arg2.getLongIdentifier()); addMessage(buf, message); } } if (hostName1Arg.getValue().equalsIgnoreCase(hostName2Arg.getValue()) && !isInteractive()) { if (port1Arg.getValue() == port2Arg.getValue()) { Message message = ERR_REPLICATION_ENABLE_SAME_SERVER_PORT.get( hostName1Arg.getValue(), port1Arg.getValue()); addMessage(buf, message); } } } /** * Checks the disable replication subcommand options and updates the provided * MessageBuilder with the errors that were encountered with the subcommand * options. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ private void validateDisableReplicationOptions(MessageBuilder buf) { Argument[][] conflictingPairs = { {secureArgsList.useStartTLSArg, secureArgsList.useSSLArg}, {secureArgsList.adminUidArg, secureArgsList.bindDnArg} }; for (int i=0; i< conflictingPairs.length; i++) { Argument arg1 = conflictingPairs[i][0]; Argument arg2 = conflictingPairs[i][1]; if (arg1.isPresent() && arg2.isPresent()) { Message message = ERR_TOOL_CONFLICTING_ARGS.get( arg1.getLongIdentifier(), arg2.getLongIdentifier()); addMessage(buf, message); } } } /** * Checks the initialize all replication subcommand options and updates the * provided MessageBuilder with the errors that were encountered with the * subcommand options. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ private void validateInitializeAllReplicationOptions(MessageBuilder buf) { Argument[][] conflictingPairs = { {secureArgsList.useStartTLSArg, secureArgsList.useSSLArg} }; for (int i=0; i< conflictingPairs.length; i++) { Argument arg1 = conflictingPairs[i][0]; Argument arg2 = conflictingPairs[i][1]; if (arg1.isPresent() && arg2.isPresent()) { Message message = ERR_TOOL_CONFLICTING_ARGS.get( arg1.getLongIdentifier(), arg2.getLongIdentifier()); addMessage(buf, message); } } } /** * Checks the pre external initialization subcommand options and updates the * provided MessageBuilder with the errors that were encountered with the * subcommand options. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ private void validatePreExternalInitializationOptions(MessageBuilder buf) { validateInitializeAllReplicationOptions(buf); } /** * Checks the post external initialization subcommand options and updates the * provided MessageBuilder with the errors that were encountered with the * subcommand options. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ private void validatePostExternalInitializationOptions(MessageBuilder buf) { validateInitializeAllReplicationOptions(buf); } /** * Checks the status replication subcommand options and updates the provided * MessageBuilder with the errors that were encountered with the subcommand * options. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ private void validateStatusReplicationOptions(MessageBuilder buf) { Argument[][] conflictingPairs = { {secureArgsList.useStartTLSArg, secureArgsList.useSSLArg} }; for (int i=0; i< conflictingPairs.length; i++) { Argument arg1 = conflictingPairs[i][0]; Argument arg2 = conflictingPairs[i][1]; if (arg1.isPresent() && arg2.isPresent()) { Message message = ERR_TOOL_CONFLICTING_ARGS.get( arg1.getLongIdentifier(), arg2.getLongIdentifier()); addMessage(buf, message); } } if (quietArg.isPresent()) { Message message = ERR_REPLICATION_STATUS_QUIET.get( STATUS_REPLICATION_SUBCMD_NAME, quietArg.getLongIdentifier()); addMessage(buf, message); } } /** * Checks the initialize replication subcommand options and updates the * provided MessageBuilder with the errors that were encountered with the * subcommand options. * * This method assumes that the method parseArguments for the parser has * already been called. * @param buf the MessageBuilder object where we add the error messages * describing the errors encountered. */ private void validateInitializeReplicationOptions(MessageBuilder buf) { // The startTLS and useSSL arguments are already validated in // SecureConnectionCliParser.validateGlobalOptions. if (hostNameSourceArg.getValue().equalsIgnoreCase( hostNameDestinationArg.getValue()) && !isInteractive()) { if (portSourceArg.getValue() == portDestinationArg.getValue()) { Message message = ERR_REPLICATION_INITIALIZE_SAME_SERVER_PORT.get( hostNameSourceArg.getValue(), portSourceArg.getValue()); addMessage(buf, message); } } } /** * Adds a message to the provided MessageBuilder. * @param buf the MessageBuilder. * @param message the message to be added. */ private void addMessage(MessageBuilder buf, Message message) { if (buf.length() > 0) { buf.append(EOL); } buf.append(message); } /** * Returns the default value to be used for the host. * @return the default value to be used for the host. */ private String getDefaultHostValue() { if (defaultLocalHostValue == null) { defaultLocalHostValue = UserData.getDefaultHostName(); if (defaultLocalHostValue == null) { defaultLocalHostValue = "localhost"; } } return defaultLocalHostValue; } /** * Returns the SecureConnectionCliArgs object containing the arguments * of this parser. * @return the SecureConnectionCliArgs object containing the arguments * of this parser. */ SecureConnectionCliArgs getSecureArgsList() { return secureArgsList; } }