/*
* 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
*
*
* Copyright 2008-2010 Sun Microsystems, Inc.
* Portions Copyright 2012-2013 ForgeRock AS
*/
package org.opends.server.util.cli;
import static org.opends.messages.AdminToolMessages.*;
import static org.opends.messages.DSConfigMessages.*;
import static org.opends.messages.QuickSetupMessages.*;
import static org.opends.messages.UtilityMessages.*;
import static org.opends.server.util.ServerConstants.*;
import static org.opends.server.util.StaticUtils.*;
import java.io.BufferedReader;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.Reader;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.NamingException;
import javax.naming.NoPermissionException;
import javax.naming.ldap.InitialLdapContext;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.TrustManager;
import org.opends.admin.ads.ServerDescriptor;
import org.opends.admin.ads.util.ApplicationTrustManager;
import org.opends.admin.ads.util.ConnectionUtils;
import org.opends.admin.ads.util.OpendsCertificateException;
import org.opends.messages.Message;
import org.opends.quicksetup.util.Utils;
import org.opends.server.protocols.ldap.LDAPResultCode;
import org.opends.server.tools.ClientException;
import org.opends.server.types.NullOutputStream;
import org.opends.server.util.PasswordReader;
import org.opends.server.util.SetupUtils;
/**
* This class provides an abstract base class which can be used as the basis of
* a console-based application.
*/
public abstract class ConsoleApplication
{
/**
* A null reader.
*/
private static final class NullReader extends Reader
{
/**
* {@inheritDoc}
*/
@Override
public void close() throws IOException
{
// Do nothing.
}
/**
* {@inheritDoc}
*/
@Override
public int read(char[] cbuf, int off, int len) throws IOException
{
return -1;
}
}
/**
* Defines the different line styles for output.
*/
public enum Style {
/**
* Defines a title.
*/
TITLE,
/**
* Defines a subtitle.
*/
SUBTITLE,
/**
* Defines a notice.
*/
NOTICE,
/**
* Defines a normal line.
*/
NORMAL,
/**
* Defines an error.
*/
ERROR,
/**
* Defines a breakline.
*/
BREAKLINE,
}
// The error stream which this application should use.
private final PrintStream err;
// The input stream reader which this application should use.
private final BufferedReader in;
// The output stream which this application should use.
private final PrintStream out;
/**
* The maximum number of times we try to confirm.
*/
protected final static int CONFIRMATION_MAX_TRIES = 5;
private static final String COMMENT_SHELL_UNIX = "# ";
private static final String COMMENT_BATCH_WINDOWS = "rem ";
/**
* The String used to write comments in a shell (or batch) script.
*/
protected static final String SHELL_COMMENT_SEPARATOR = SetupUtils
.isWindows() ? COMMENT_BATCH_WINDOWS : COMMENT_SHELL_UNIX;
/**
* Creates a new console application instance.
*
* @param in
* The application input stream.
* @param out
* The application output stream.
* @param err
* The application error stream.
*/
protected ConsoleApplication(BufferedReader in, PrintStream out,
PrintStream err)
{
if (in != null)
{
this.in = in;
}
else
{
this.in = new BufferedReader(new NullReader());
}
if (out != null)
{
this.out = out;
}
else
{
this.out = NullOutputStream.printStream();
}
if (err != null)
{
this.err = out;
}
else
{
this.err = NullOutputStream.printStream();
}
}
/**
* Creates a new console application instance.
*
* @param in
* The application input stream.
* @param out
* The application output stream.
* @param err
* The application error stream.
*/
protected ConsoleApplication(InputStream in, OutputStream out,
OutputStream err)
{
if (in != null)
{
this.in = new BufferedReader(new InputStreamReader(in));
}
else
{
this.in = new BufferedReader(new NullReader());
}
if (out != null)
{
this.out = new PrintStream(out);
}
else
{
this.out = NullOutputStream.printStream();
}
if (err != null)
{
this.err = new PrintStream(err);
}
else
{
this.err = NullOutputStream.printStream();
}
}
/**
* Interactively confirms whether a user wishes to perform an action. If the
* application is non-interactive, then the provided default is returned
* automatically.
*
* @param prompt
* The prompt describing the action.
* @param defaultValue
* The default value for the confirmation message. This will be
* returned if the application is non-interactive or if the user just
* presses return.
* @return Returns <code>true</code> if the user wishes the action to be
* performed, or <code>false</code> if they refused, or if an
* exception occurred.
* @throws CLIException
* If the user's response could not be read from the console for
* some reason.
*/
public final boolean confirmAction(Message prompt, final boolean defaultValue)
throws CLIException
{
if (!isInteractive())
{
return defaultValue;
}
final Message yes = INFO_GENERAL_YES.get();
final Message no = INFO_GENERAL_NO.get();
final Message errMsg = ERR_CONSOLE_APP_CONFIRM.get(yes, no);
prompt =
INFO_MENU_PROMPT_CONFIRM.get(prompt, yes, no, defaultValue ? yes : no);
ValidationCallback<Boolean> validator = new ValidationCallback<Boolean>()
{
@Override
public Boolean validate(ConsoleApplication app, String input)
{
String ninput = input.toLowerCase().trim();
if (ninput.length() == 0)
{
return defaultValue;
}
else if (no.toString().toLowerCase().startsWith(ninput))
{
return false;
}
else if (yes.toString().toLowerCase().startsWith(ninput))
{
return true;
}
else
{
// Try again...
app.println();
app.println(errMsg);
app.println();
}
return null;
}
};
return readValidatedInput(prompt, validator, CONFIRMATION_MAX_TRIES);
}
/**
* Gets the application error stream.
*
* @return Returns the application error stream.
*/
public final PrintStream getErrorStream()
{
return err;
}
/**
* Gets the application input stream.
*
* @return Returns the application input stream.
*/
public final BufferedReader getInputStream()
{
return in;
}
/**
* Gets the application output stream.
*
* @return Returns the application output stream.
*/
public final PrintStream getOutputStream()
{
return out;
}
/**
* Indicates whether or not the user has requested advanced mode.
*
* @return Returns <code>true</code> if the user has requested advanced mode.
*/
public abstract boolean isAdvancedMode();
/**
* Indicates whether or not the user has requested interactive behavior.
*
* @return Returns <code>true</code> if the user has requested interactive
* behavior.
*/
public abstract boolean isInteractive();
/**
* Indicates whether or not this console application is running in its
* menu-driven mode. This can be used to dictate whether output should go to
* the error stream or not. In addition, it may also dictate whether or not
* sub-menus should display a cancel option as well as a quit option.
*
* @return Returns <code>true</code> if this console application is running in
* its menu-driven mode.
*/
public abstract boolean isMenuDrivenMode();
/**
* Indicates whether or not the user has requested quiet output.
*
* @return Returns <code>true</code> if the user has requested quiet output.
*/
public abstract boolean isQuiet();
/**
* Indicates whether or not the user has requested script-friendly output.
*
* @return Returns <code>true</code> if the user has requested script-friendly
* output.
*/
public abstract boolean isScriptFriendly();
/**
* Indicates whether or not the user has requested verbose output.
*
* @return Returns <code>true</code> if the user has requested verbose output.
*/
public abstract boolean isVerbose();
/**
* Interactively prompts the user to press return to continue. This method
* should be called in situations where a user needs to be given a chance to
* read some documentation before continuing (continuing may cause the
* documentation to be scrolled out of view).
*/
public final void pressReturnToContinue()
{
Message msg = INFO_MENU_PROMPT_RETURN_TO_CONTINUE.get();
try
{
readLineOfInput(msg);
}
catch (CLIException e)
{
// Ignore the exception - applications don't care.
}
}
/**
* Displays a blank line to the error stream.
*/
public final void println()
{
err.println();
}
/**
* Displays a message to the error stream.
*
* @param msg
* The message.
*/
public final void println(Message msg)
{
err.println(wrapText(msg, MAX_LINE_WIDTH));
}
/**
* Displays a message to the error stream.
*
* @param msg
* The message.
*/
public final void print(Message msg)
{
err.print(wrapText(msg, MAX_LINE_WIDTH));
}
/**
* Print a line with EOL in the output stream.
*
* @param msg
* The message to display in normal mode.
* @param indent
* The indentation.
*/
public final void println(final Message msg, final int indent)
{
println(Style.NORMAL, msg, indent);
}
/**
* Print a line with EOL in the output stream.
*
* @param msgStyle
* The type of formatted output desired.
* @param msg
* The message to display in normal mode.
* @param indent
* The indentation.
*/
public final void println(final Style msgStyle, final Message msg,
final int indent)
{
if (!isQuiet())
{
switch (msgStyle)
{
case TITLE:
out.println();
out.println(">>>> " + wrapText(msg, MAX_LINE_WIDTH, indent));
out.println();
break;
case SUBTITLE:
out.println(wrapText(msg, MAX_LINE_WIDTH, indent));
out.println();
break;
case NOTICE:
out.println(wrapText("* " + msg, MAX_LINE_WIDTH, indent));
break;
case ERROR:
out.println();
out.println(wrapText("** " + msg, MAX_LINE_WIDTH, indent));
break;
case BREAKLINE:
out.println();
break;
default:
out.println(wrapText(msg, MAX_LINE_WIDTH, indent));
break;
}
}
}
/**
* Displays a blank line to the output stream if we are not in quiet mode.
*/
public final void printlnProgress()
{
if (!isQuiet())
{
out.println();
}
}
/**
* Displays a message to the output stream if we are not in quiet mode.
* Message is wrap to max line width.
*
* @param msg
* The message.
*/
public final void printlnProgress(Message msg)
{
if (!isQuiet())
{
out.println(wrapText(msg, MAX_LINE_WIDTH));
}
}
/**
* Displays a message to the output stream if we are not in quiet mode.
*
* @param msg
* The message.
*/
public final void printProgress(final Message msg)
{
if (!isQuiet())
{
out.print(msg);
}
}
/**
* Prints a progress bar on the same output stream line if not in quiet mode.
*
* <pre>
* Like
* msg...... 50%
* if progress is up to 100 :
* msg..................... 100%
* if progress is < 0 :
* msg.... FAIL
* msg..................... FAIL
* </pre>
*
* @param linePos
* The progress bar starts at this position on the line.
* @param progress
* The current percentage progress to print.
*/
public final void printProgressBar(final int linePos, final int progress)
{
if (!isQuiet())
{
final int spacesLeft = MAX_LINE_WIDTH - linePos - 10;
StringBuilder bar = new StringBuilder();
if (progress != 0)
{
for (int i = 0; i < 50; i++)
{
if ((i < (Math.abs(progress) / 2)) && (bar.length() < spacesLeft))
{
bar.append(".");
}
}
}
bar.append(". ");
if(progress >= 0) {
bar.append(progress).append("% ");
} else {
bar.append("FAIL");
}
final int endBuilder = linePos + bar.length();
for (int i = 0; i < endBuilder; i++)
{
bar.append("\b");
}
if (progress >= 100 || progress < 0)
{
bar.append(EOL);
}
out.print(bar.toString());
}
}
/**
* Display the batch progress string to the error stream, if we are not in
* quiet mode.
*
* @param s
* The string to display
*/
public final void printlnBatchProgress(String s)
{
if (!isQuiet())
{
err.println(s);
}
}
/**
* Displays a message to the error stream indented by the specified number of
* columns.
*
* @param msg
* The message.
* @param indent
* The number of columns to indent.
*/
public final void printErrln(Message msg, int indent)
{
err.println(wrapText(msg, MAX_LINE_WIDTH, indent));
}
/**
* Displays a message to the error stream if verbose mode is enabled.
*
* @param msg
* The verbose message.
*/
public final void printVerboseMessage(Message msg)
{
if (isVerbose() || isInteractive())
{
err.println(wrapText(msg, MAX_LINE_WIDTH));
}
}
/**
* Interactively retrieves a line of input from the console.
*
* @param prompt
* The prompt.
* @return Returns the line of input, or <code>null</code> if the end of input
* has been reached.
* @throws CLIException
* If the line of input could not be retrieved for some reason.
*/
public final String readLineOfInput(Message prompt) throws CLIException
{
if (prompt != null)
{
err.print(wrapText(prompt, MAX_LINE_WIDTH));
err.print(" ");
}
try
{
String s = in.readLine();
if (s == null)
{
throw CLIException
.adaptInputException(new EOFException("End of input"));
}
else
{
return s;
}
}
catch (IOException e)
{
throw CLIException.adaptInputException(e);
}
}
/**
* Displays a message and read the user's input from output.
*
* @param prompt
* The message to display.
* @param defaultValue
* The default answer by default.
* @param msgStyle
* The formatted style chosen.
* @return The user's input as a string.
* @throws CLIException
* If an Exception occurs during the process.
*/
public final String readInput(final Message prompt,
final String defaultValue, final Style msgStyle)
throws CLIException
{
String answer = null;
final Message messageToDisplay =
INFO_PROMPT_SINGLE_DEFAULT.get(prompt.toString(), defaultValue);
if (msgStyle == Style.TITLE)
{
println();
}
print(messageToDisplay);
out.print(" ");
try
{
// Reads the user input.
answer = in.readLine();
}
catch (IOException e)
{
throw CLIException.adaptInputException(e);
}
if (msgStyle == Style.TITLE
|| msgStyle == Style.SUBTITLE)
{
println();
}
if ("".equals(answer))
{
if (defaultValue == null)
{
println(INFO_ERROR_EMPTY_RESPONSE.get());
}
else
{
return defaultValue;
}
}
return answer;
}
/**
* Commodity method that interactively prompts (on error output) the user to
* provide a string value. Any non-empty string will be allowed (the empty
* string will indicate that the default should be used, if there is one).
*
* @param prompt
* The prompt to present to the user.
* @param defaultValue
* The default value to assume if the user presses ENTER without
* typing anything, or <CODE>null</CODE> if there should not be a
* default and the user must explicitly provide a value.
* @throws CLIException
* If the line of input could not be retrieved for some reason.
* @return The string value read from the user.
*/
public String readInput(Message prompt, String defaultValue)
throws CLIException
{
while (true)
{
if (defaultValue != null)
{
prompt =
INFO_PROMPT_SINGLE_DEFAULT.get(prompt.toString(), defaultValue);
}
String response = readLineOfInput(prompt);
if ("".equals(response))
{
if (defaultValue == null)
{
println(INFO_ERROR_EMPTY_RESPONSE.get());
}
else
{
return defaultValue;
}
}
else
{
return response;
}
}
}
/**
* Commodity method that interactively prompts (on error output) the user to
* provide a string value. Any non-empty string will be allowed (the empty
* string will indicate that the default should be used, if there is one). If
* an error occurs a message will be logged to the provided logger.
*
* @param prompt
* The prompt to present to the user.
* @param defaultValue
* The default value to assume if the user presses ENTER without
* typing anything, or <CODE>null</CODE> if there should not be a
* default and the user must explicitly provide a value.
* @param logger
* the Logger to be used to log the error message.
* @return The string value read from the user.
*/
public String readInput(Message prompt, String defaultValue, Logger logger)
{
String s = defaultValue;
try
{
s = readInput(prompt, defaultValue);
}
catch (CLIException ce)
{
logger.log(Level.WARNING, "Error reading input: " + ce, ce);
}
return s;
}
/**
* Interactively retrieves a password from the console.
*
* @param prompt
* The password prompt.
* @return Returns the password.
* @throws CLIException
* If the password could not be retrieved for some reason.
*/
public final String readPassword(Message prompt) throws CLIException
{
err.print(wrapText(prompt + " ", MAX_LINE_WIDTH));
char[] pwChars;
try
{
pwChars = PasswordReader.readPassword();
}
catch (Exception e)
{
throw CLIException.adaptInputException(e);
}
return new String(pwChars);
}
/**
* Commodity method that interactively retrieves a password from the console.
* If there is an error an error message is logged to the provided Logger and
* <CODE>null</CODE> is returned.
*
* @param prompt
* The password prompt.
* @param logger
* the Logger to be used to log the error message.
* @return Returns the password.
*/
protected final String readPassword(Message prompt, Logger logger)
{
String pwd = null;
try
{
pwd = readPassword(prompt);
}
catch (CLIException ce)
{
logger.log(Level.WARNING, "Error reading input: " + ce, ce);
}
return pwd;
}
/**
* Interactively retrieves a port value from the console.
*
* @param prompt
* The port prompt.
* @param defaultValue
* The port default value.
* @return Returns the port.
* @throws CLIException
* If the port could not be retrieved for some reason.
*/
public final int readPort(Message prompt, final int defaultValue)
throws CLIException
{
ValidationCallback<Integer> callback = new ValidationCallback<Integer>()
{
@Override
public Integer validate(ConsoleApplication app, String input)
throws CLIException
{
String ninput = input.trim();
if (ninput.length() == 0)
{
return defaultValue;
}
else
{
try
{
int i = Integer.parseInt(ninput);
if (i < 1 || i > 65535)
{
throw new NumberFormatException();
}
return i;
}
catch (NumberFormatException e)
{
// Try again...
app.println();
app.println(ERR_LDAP_CONN_BAD_PORT_NUMBER.get(ninput));
app.println();
return null;
}
}
}
};
if (defaultValue != -1)
{
prompt =
INFO_PROMPT_SINGLE_DEFAULT.get(prompt.toString(), String
.valueOf(defaultValue));
}
return readValidatedInput(prompt, callback, CONFIRMATION_MAX_TRIES);
}
/**
* Returns a message object for the given NamingException.
*
* @param ne
* the NamingException.
* @param hostPort
* the hostPort representation of the server we were contacting when
* the NamingException occurred.
* @return a message object for the given NamingException.
*/
protected Message getMessageForException(NamingException ne, String hostPort)
{
return Utils.getMessageForException(ne, hostPort);
}
/**
* Commodity method used to repeatidly ask the user to provide a port value.
*
* @param prompt
* the prompt message.
* @param defaultValue
* the default value of the port to be proposed to the user.
* @param logger
* the logger where the errors will be written.
* @return the port value provided by the user.
*/
protected int askPort(Message prompt, int defaultValue, Logger logger)
{
int port = -1;
while (port == -1)
{
try
{
port = readPort(prompt, defaultValue);
}
catch (CLIException ce)
{
port = -1;
logger.log(Level.WARNING, "Error reading input: " + ce, ce);
}
}
return port;
}
/**
* Interactively prompts for user input and continues until valid input is
* provided.
*
* @param <T>
* The type of decoded user input.
* @param prompt
* The interactive prompt which should be displayed on each input
* attempt.
* @param validator
* An input validator responsible for validating and decoding the
* user's response.
* @return Returns the decoded user's response.
* @throws CLIException
* If an unexpected error occurred which prevented validation.
*/
public final <T> T readValidatedInput(Message prompt,
ValidationCallback<T> validator) throws CLIException
{
while (true)
{
String response = readLineOfInput(prompt);
T value = validator.validate(this, response);
if (value != null)
{
return value;
}
}
}
/**
* Interactively prompts for user input and continues until valid input is
* provided.
*
* @param <T>
* The type of decoded user input.
* @param prompt
* The interactive prompt which should be displayed on each input
* attempt.
* @param validator
* An input validator responsible for validating and decoding the
* user's response.
* @param maxTries
* The maximum number of tries that we can make.
* @return Returns the decoded user's response.
* @throws CLIException
* If an unexpected error occurred which prevented validation or if
* the maximum number of tries was reached.
*/
public final <T> T readValidatedInput(Message prompt,
ValidationCallback<T> validator, int maxTries) throws CLIException
{
int nTries = 0;
while (nTries < maxTries)
{
String response = readLineOfInput(prompt);
T value = validator.validate(this, response);
if (value != null)
{
return value;
}
nTries++;
}
throw new CLIException(ERR_TRIES_LIMIT_REACHED.get(maxTries));
}
/**
* Commodity method that interactively confirms whether a user wishes to
* perform an action. If the application is non-interactive, then the provided
* default is returned automatically. If there is an error an error message is
* logged to the provided Logger and the defaul value is returned.
*
* @param prompt
* The prompt describing the action.
* @param defaultValue
* The default value for the confirmation message. This will be
* returned if the application is non-interactive or if the user just
* presses return.
* @param logger
* the Logger to be used to log the error message.
* @return Returns <code>true</code> if the user wishes the action to be
* performed, or <code>false</code> if they refused.
* @throws CLIException
* if the user did not provide valid answer after a certain number
* of tries (ConsoleApplication.CONFIRMATION_MAX_TRIES)
*/
protected final boolean askConfirmation(Message prompt, boolean defaultValue,
Logger logger) throws CLIException
{
boolean v = defaultValue;
boolean done = false;
int nTries = 0;
while (!done && (nTries < CONFIRMATION_MAX_TRIES))
{
nTries++;
try
{
v = confirmAction(prompt, defaultValue);
done = true;
}
catch (CLIException ce)
{
if (ce.getMessageObject().getDescriptor().equals(
ERR_CONFIRMATION_TRIES_LIMIT_REACHED)
|| ce.getMessageObject().getDescriptor().equals(
ERR_TRIES_LIMIT_REACHED))
{
throw ce;
}
logger.log(Level.WARNING, "Error reading input: " + ce, ce);
// Try again...
println();
}
}
if (!done)
{
// This means we reached the maximum number of tries
throw new CLIException(ERR_CONFIRMATION_TRIES_LIMIT_REACHED
.get(CONFIRMATION_MAX_TRIES));
}
return v;
}
/**
* Returns an InitialLdapContext using the provided parameters. We try to
* guarantee that the connection is able to read the configuration.
*
* @param host
* the host name.
* @param port
* the port to connect.
* @param useSSL
* whether to use SSL or not.
* @param useStartTLS
* whether to use StartTLS or not.
* @param bindDn
* the bind dn to be used.
* @param pwd
* the password.
* @param connectTimeout
* the timeout in milliseconds to connect to the server.
* @param trustManager
* the trust manager.
* @return an InitialLdapContext connected.
* @throws NamingException
* if there was an error establishing the connection.
*/
protected InitialLdapContext createAdministrativeContext(String host,
int port, boolean useSSL, boolean useStartTLS, String bindDn, String pwd,
int connectTimeout, ApplicationTrustManager trustManager)
throws NamingException
{
InitialLdapContext ctx;
String ldapUrl = ConnectionUtils.getLDAPUrl(host, port, useSSL);
if (useSSL)
{
ctx =
Utils.createLdapsContext(ldapUrl, bindDn, pwd, connectTimeout, null,
trustManager);
}
else if (useStartTLS)
{
ctx =
Utils.createStartTLSContext(ldapUrl, bindDn, pwd, connectTimeout,
null, trustManager, null);
}
else
{
ctx = Utils.createLdapContext(ldapUrl, bindDn, pwd, connectTimeout, null);
}
if (!ConnectionUtils.connectedAsAdministrativeUser(ctx))
{
throw new NoPermissionException(ERR_NOT_ADMINISTRATIVE_USER.get()
.toString());
}
return ctx;
}
/**
* Creates an Initial LDAP Context interacting with the user if the
* application is interactive.
*
* @param ci
* the LDAPConnectionConsoleInteraction object that is assumed to
* have been already run.
* @return the initial LDAP context or <CODE>null</CODE> if the user did not
* accept to trust the certificates.
* @throws ClientException
* if there was an error establishing the connection.
*/
protected InitialLdapContext createInitialLdapContextInteracting(
LDAPConnectionConsoleInteraction ci) throws ClientException
{
return createInitialLdapContextInteracting(ci, isInteractive()
&& ci.isTrustStoreInMemory());
}
/**
* Creates an Initial LDAP Context interacting with the user if the
* application is interactive.
*
* @param ci
* the LDAPConnectionConsoleInteraction object that is assumed to
* have been already run.
* @param promptForCertificate
* whether we should prompt for the certificate or not.
* @return the initial LDAP context or <CODE>null</CODE> if the user did not
* accept to trust the certificates.
* @throws ClientException
* if there was an error establishing the connection.
*/
protected InitialLdapContext createInitialLdapContextInteracting(
LDAPConnectionConsoleInteraction ci, boolean promptForCertificate)
throws ClientException
{
// Interact with the user though the console to get
// LDAP connection information
String hostName = ConnectionUtils.getHostNameForLdapUrl(ci.getHostName());
Integer portNumber = ci.getPortNumber();
String bindDN = ci.getBindDN();
String bindPassword = ci.getBindPassword();
TrustManager trustManager = ci.getTrustManager();
KeyManager keyManager = ci.getKeyManager();
InitialLdapContext ctx;
if (ci.useSSL())
{
String ldapsUrl = "ldaps://" + hostName + ":" + portNumber;
while (true)
{
try
{
ctx =
ConnectionUtils.createLdapsContext(ldapsUrl, bindDN,
bindPassword, ci.getConnectTimeout(), null, trustManager,
keyManager);
ctx.reconnect(null);
break;
}
catch (NamingException e)
{
if (promptForCertificate)
{
OpendsCertificateException oce = getCertificateRootException(e);
if (oce != null)
{
String authType = null;
if (trustManager instanceof ApplicationTrustManager)
{
ApplicationTrustManager appTrustManager =
(ApplicationTrustManager) trustManager;
authType = appTrustManager.getLastRefusedAuthType();
}
if (ci.checkServerCertificate(oce.getChain(), authType, hostName))
{
// If the certificate is trusted, update the trust manager.
trustManager = ci.getTrustManager();
// Try to connect again.
continue;
}
else
{
// Assume user canceled.
return null;
}
}
}
if (e.getCause() != null)
{
if (!isInteractive() && !ci.isTrustAll())
{
if (getCertificateRootException(e) != null
|| (e.getCause() instanceof SSLHandshakeException))
{
Message message =
ERR_DSCFG_ERROR_LDAP_FAILED_TO_CONNECT_NOT_TRUSTED.get(
hostName, String.valueOf(portNumber));
throw new ClientException(
LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR, message);
}
}
if (e.getCause() instanceof SSLException)
{
Message message =
ERR_DSCFG_ERROR_LDAP_FAILED_TO_CONNECT_WRONG_PORT.get(
hostName, String.valueOf(portNumber));
throw new ClientException(
LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR, message);
}
}
String hostPort =
ServerDescriptor.getServerRepresentation(hostName, portNumber);
Message message = Utils.getMessageForException(e, hostPort);
throw new ClientException(LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR,
message);
}
}
}
else if (ci.useStartTLS())
{
String ldapUrl = "ldap://" + hostName + ":" + portNumber;
while (true)
{
try
{
ctx =
ConnectionUtils.createStartTLSContext(ldapUrl, bindDN,
bindPassword, ConnectionUtils.getDefaultLDAPTimeout(), null,
trustManager, keyManager, null);
ctx.reconnect(null);
break;
}
catch (NamingException e)
{
if (promptForCertificate)
{
OpendsCertificateException oce = getCertificateRootException(e);
if (oce != null)
{
String authType = null;
if (trustManager instanceof ApplicationTrustManager)
{
ApplicationTrustManager appTrustManager =
(ApplicationTrustManager) trustManager;
authType = appTrustManager.getLastRefusedAuthType();
}
if (ci.checkServerCertificate(oce.getChain(), authType, hostName))
{
// If the certificate is trusted, update the trust manager.
trustManager = ci.getTrustManager();
// Try to connect again.
continue;
}
else
{
// Assume user cancelled.
return null;
}
}
else
{
Message message =
ERR_DSCFG_ERROR_LDAP_FAILED_TO_CONNECT.get(hostName, String
.valueOf(portNumber));
throw new ClientException(
LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR, message);
}
}
Message message =
ERR_DSCFG_ERROR_LDAP_FAILED_TO_CONNECT.get(hostName, String
.valueOf(portNumber));
throw new ClientException(LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR,
message);
}
}
}
else
{
String ldapUrl = "ldap://" + hostName + ":" + portNumber;
while (true)
{
try
{
ctx =
ConnectionUtils.createLdapContext(ldapUrl, bindDN, bindPassword,
ConnectionUtils.getDefaultLDAPTimeout(), null);
ctx.reconnect(null);
break;
}
catch (NamingException e)
{
Message message =
ERR_DSCFG_ERROR_LDAP_FAILED_TO_CONNECT.get(hostName, String
.valueOf(portNumber));
throw new ClientException(LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR,
message);
}
}
}
return ctx;
}
/**
* Returns the message to be displayed in the file with the equivalent
* command-line with information about the current time.
*
* @return the message to be displayed in the file with the equivalent
* command-line with information about the current time.
*/
protected String getCurrentOperationDateMessage()
{
String date = formatDateTimeStringForEquivalentCommand(new Date());
return INFO_OPERATION_START_TIME_MESSAGE.get(date).toString();
}
/**
* Formats a Date to String representation in "dd/MMM/yyyy:HH:mm:ss Z".
*
* @param date
* to format; null if <code>date</code> is null
* @return string representation of the date
*/
protected String formatDateTimeStringForEquivalentCommand(Date date)
{
String timeStr = null;
if (date != null)
{
SimpleDateFormat dateFormat =
new SimpleDateFormat(DATE_FORMAT_LOCAL_TIME);
dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
timeStr = dateFormat.format(date);
}
return timeStr;
}
/**
* Prompts the user to give the Global Administrator UID.
*
* @param defaultValue
* the default value that will be proposed in the prompt message.
* @param logger
* the Logger to be used to log the error message.
* @return the Global Administrator UID as provided by the user.
*/
protected String askForAdministratorUID(String defaultValue, Logger logger)
{
String s = defaultValue;
try
{
s = readInput(INFO_ADMINISTRATOR_UID_PROMPT.get(), defaultValue);
}
catch (CLIException ce)
{
logger.log(Level.WARNING, "Error reading input: " + ce, ce);
}
return s;
}
/**
* Prompts the user to give the Global Administrator password.
*
* @param logger
* the Logger to be used to log the error message.
* @return the Global Administrator password as provided by the user.
*/
protected String askForAdministratorPwd(Logger logger)
{
String pwd = readPassword(INFO_ADMINISTRATOR_PWD_PROMPT.get(), logger);
return pwd;
}
private OpendsCertificateException getCertificateRootException(Throwable t)
{
OpendsCertificateException oce = null;
while (t != null && oce == null)
{
t = t.getCause();
if (t instanceof OpendsCertificateException)
{
oce = (OpendsCertificateException) t;
}
}
return oce;
}
/**
* Commodity method used to repeatidly ask the user to provide an integer
* value.
*
* @param prompt
* the prompt message.
* @param defaultValue
* the default value to be proposed to the user.
* @param logger
* the logger where the errors will be written.
* @return the value provided by the user.
*/
protected int askInteger(Message prompt, int defaultValue, Logger logger)
{
int newInt = -1;
while (newInt == -1)
{
try
{
newInt = readInteger(prompt, defaultValue);
}
catch (CLIException ce)
{
newInt = -1;
logger.log(Level.WARNING, "Error reading input: " + ce, ce);
}
}
return newInt;
}
/**
* Interactively retrieves an integer value from the console.
*
* @param prompt
* The message prompt.
* @param defaultValue
* The default value.
* @return Returns the value.
* @throws CLIException
* If the value could not be retrieved for some reason.
*/
public final int readInteger(Message prompt, final int defaultValue)
throws CLIException
{
ValidationCallback<Integer> callback = new ValidationCallback<Integer>()
{
@Override
public Integer validate(ConsoleApplication app, String input)
throws CLIException
{
String ninput = input.trim();
if (ninput.length() == 0)
{
return defaultValue;
}
else
{
try
{
int i = Integer.parseInt(ninput);
if (i < 1)
{
throw new NumberFormatException();
}
return i;
}
catch (NumberFormatException e)
{
// Try again...
app.println();
app.println(ERR_LDAP_CONN_BAD_INTEGER.get(ninput));
app.println();
return null;
}
}
}
};
if (defaultValue != -1)
{
prompt =
INFO_PROMPT_SINGLE_DEFAULT.get(prompt.toString(), String
.valueOf(defaultValue));
}
return readValidatedInput(prompt, callback, CONFIRMATION_MAX_TRIES);
}
}