/*
|
* The contents of this file are subject to the terms of the Common Development and
|
* Distribution License (the License). You may not use this file except in compliance with the
|
* License.
|
*
|
* You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
|
* specific language governing permission and limitations under the License.
|
*
|
* When distributing Covered Software, include this CDDL Header Notice in each file and include
|
* the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
|
* Header, with the fields enclosed by brackets [] replaced by your own identifying
|
* information: "Portions Copyright [year] [name of copyright owner]".
|
*
|
* Copyright 2016 ForgeRock AS.
|
*/
|
package com.forgerock.opendj.ldap.tools;
|
|
import static com.forgerock.opendj.ldap.tools.LDAPToolException.newToolExceptionAlreadyPrinted;
|
import static com.forgerock.opendj.ldap.tools.ToolsMessages.ERR_ERROR_PARSING_ARGS;
|
|
import java.io.PrintStream;
|
|
import com.forgerock.opendj.cli.ArgumentException;
|
import com.forgerock.opendj.cli.ArgumentParser;
|
import com.forgerock.opendj.cli.ConnectionFactoryProvider;
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.forgerock.opendj.ldap.ConnectionFactory;
|
import org.forgerock.opendj.ldap.ResultCode;
|
import org.forgerock.opendj.ldap.requests.BindRequest;
|
|
/**
|
* Facility class to help ldap* tools to parse arguments and get {@link org.forgerock.opendj.ldap.ConnectionFactory}
|
* and {@link org.forgerock.opendj.ldap.requests.BindRequest} objects back.
|
*/
|
final class LDAPToolArgumentParser extends ArgumentParser {
|
|
private static final boolean WITH_BIND_REQUEST = true;
|
private static final boolean WITHOUT_BIND_REQUEST = false;
|
|
/**
|
* Returns a builder which can be used for incrementally constructing a new
|
* {@link LDAPToolArgumentParser}.
|
*
|
* @param mainClassName
|
* The tool main class name.
|
* @return A builder to continue building the parser.
|
*/
|
static Builder builder(final String mainClassName) {
|
return new Builder(mainClassName);
|
}
|
|
ConnectionFactory getConnectionFactory() {
|
return connectionFactory;
|
}
|
|
BindRequest getBindRequest() {
|
return bindRequest;
|
}
|
|
/** A fluent API for incrementally constructing ldap argument parser. */
|
static final class Builder {
|
private final String mainClassName;
|
private LocalizableMessage toolDescription;
|
private boolean allowTrailingArgs;
|
private int minTrailingArguments;
|
private int maxTrailingArguments;
|
private String trailingArgsDisplayName;
|
private boolean needAuthenticatedConnectionFactory;
|
|
Builder(final String mainClassName) {
|
this.mainClassName = mainClassName;
|
}
|
|
Builder toolDescription(final LocalizableMessage toolDescription) {
|
this.toolDescription = toolDescription;
|
return this;
|
}
|
|
/** No trailing arguments number limitations. **/
|
Builder trailingArguments(final String displayNames) {
|
return trailingArguments(0, 0, displayNames);
|
}
|
|
/** Specify that the tool accept exactly the provided number of trailing argument(s). */
|
Builder trailingArguments(final int nbTrailingArguments, final String displayNames) {
|
return trailingArguments(nbTrailingArguments, nbTrailingArguments, displayNames);
|
}
|
|
/** Only specifying the minimum number of trailing arguments implies that this number has no upper bound. **/
|
Builder trailingArgumentsUnbounded(final int min, final String displayNames) {
|
return trailingArguments(min, 0, displayNames);
|
}
|
|
Builder trailingArguments(final int min, final int max, final String displayNames) {
|
this.minTrailingArguments = min;
|
this.maxTrailingArguments = max;
|
this.trailingArgsDisplayName = displayNames;
|
this.allowTrailingArgs = true;
|
return this;
|
}
|
|
Builder needAuthenticatedConnectionFactory() {
|
this.needAuthenticatedConnectionFactory = true;
|
return this;
|
}
|
|
LDAPToolArgumentParser build() {
|
return new LDAPToolArgumentParser(mainClassName, toolDescription, false,
|
allowTrailingArgs, minTrailingArguments, maxTrailingArguments,
|
trailingArgsDisplayName, needAuthenticatedConnectionFactory);
|
}
|
}
|
|
private ConnectionFactory connectionFactory;
|
private BindRequest bindRequest;
|
private final boolean needAuthenticatedCF;
|
|
private LDAPToolArgumentParser(final String mainClassName,
|
final LocalizableMessage toolDescription,
|
final boolean longArgumentsCaseSensitive,
|
final boolean allowsTrailingArguments,
|
final int minTrailingArguments,
|
final int maxTrailingArguments,
|
final String trailingArgsDisplayName,
|
final boolean needAuthenticatedCF) {
|
super(mainClassName, toolDescription, longArgumentsCaseSensitive, allowsTrailingArguments,
|
minTrailingArguments, maxTrailingArguments, trailingArgsDisplayName);
|
this.needAuthenticatedCF = needAuthenticatedCF;
|
}
|
|
void parseArguments(final String[] args, final PrintStream stream, final ConnectionFactoryProvider provider)
|
throws LDAPToolException {
|
parseLdapToolArgument(args, provider, stream, WITH_BIND_REQUEST);
|
}
|
|
void parseArgumentsNoBindRequest(final String[] args,
|
final PrintStream stream,
|
final ConnectionFactoryProvider provider) throws LDAPToolException {
|
parseLdapToolArgument(args, provider, stream, WITHOUT_BIND_REQUEST);
|
}
|
|
private void parseLdapToolArgument(final String[] args,
|
final ConnectionFactoryProvider provider,
|
final PrintStream stream,
|
final boolean withBindRequest) throws LDAPToolException {
|
try {
|
parseArguments(args);
|
if (usageOrVersionDisplayed()) {
|
return;
|
}
|
connectionFactory = needAuthenticatedCF ? provider.getAuthenticatedConnectionFactory()
|
: provider.getUnauthenticatedConnectionFactory();
|
if (withBindRequest) {
|
bindRequest = provider.getBindRequest();
|
}
|
} catch (final ArgumentException ae) {
|
displayMessageAndUsageReference(stream, ERR_ERROR_PARSING_ARGS.get(ae.getMessage()));
|
throw newToolExceptionAlreadyPrinted(ae, ResultCode.CLIENT_SIDE_PARAM_ERROR);
|
}
|
}
|
}
|
