/*
|
* 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 2006 Sun Microsystems, Inc.
|
*/
|
|
package org.opends.quicksetup.uninstaller;
|
|
import java.io.BufferedReader;
|
import java.io.ByteArrayOutputStream;
|
import java.io.FileReader;
|
import java.util.ArrayList;
|
import java.util.Iterator;
|
import java.util.Set;
|
|
import org.opends.quicksetup.CurrentInstallStatus;
|
import org.opends.quicksetup.event.UninstallProgressUpdateEvent;
|
import org.opends.quicksetup.event.UninstallProgressUpdateListener;
|
import org.opends.quicksetup.i18n.ResourceProvider;
|
import org.opends.quicksetup.util.PlainTextProgressMessageFormatter;
|
import org.opends.quicksetup.util.Utils;
|
|
/**
|
* The class used to provide some CLI interface in the uninstall.
|
*
|
* This class basically is in charge of parsing the data provided by the user
|
* in the command line and displaying messages asking the user for information.
|
*
|
* Once the user has provided all the required information it calls Uninstaller
|
* and launches it.
|
*
|
*/
|
class UninstallCli
|
{
|
/**
|
* Return code: Uninstall successful.
|
*/
|
static int SUCCESSFUL = 0;
|
/**
|
* Return code: User Cancelled uninstall.
|
*/
|
static int CANCELLED = 1;
|
/**
|
* Return code: User provided invalid data.
|
*/
|
static int USER_DATA_ERROR = 2;
|
/**
|
* Return code: Error accessing file system (reading/writing).
|
*/
|
static int ERROR_ACCESSING_FILE_SYSTEM = 3;
|
/**
|
* Return code: Error stopping server.
|
*/
|
static int ERROR_STOPPING_SERVER = 4;
|
/**
|
* Return code: Bug.
|
*/
|
static int BUG = 5;
|
|
private static String LINE_SEPARATOR = System.getProperty("line.separator");
|
|
private String[] args;
|
|
/**
|
* The constructor for this object.
|
* @param args the arguments of the uninstall command line.
|
*/
|
UninstallCli(String[] args)
|
{
|
this.args = args;
|
}
|
|
/**
|
* Parses the user data and prompts the user for data if required. If the
|
* user provides all the required data it launches the Uninstaller.
|
*
|
* @return the return code (SUCCESSFUL, CANCELLED, USER_DATA_ERROR,
|
* ERROR_ACCESSING_FILE_SYSTEM, ERROR_STOPPING_SERVER or BUG.
|
*/
|
int run()
|
{
|
int returnValue;
|
|
System.out.println(getMsg("uninstall-launcher-launching-cli"));
|
// Parse the arguments
|
try
|
{
|
CurrentInstallStatus installStatus = new CurrentInstallStatus();
|
UserUninstallData userData = getUserUninstallData(args, installStatus);
|
if (userData != null)
|
{
|
Uninstaller uninstaller = new Uninstaller(userData,
|
new PlainTextProgressMessageFormatter());
|
uninstaller.addProgressUpdateListener(
|
new UninstallProgressUpdateListener()
|
{
|
/**
|
* UninstallProgressUpdateListener implementation.
|
* @param ev the UninstallProgressUpdateEvent we receive.
|
*
|
*/
|
public void progressUpdate(UninstallProgressUpdateEvent ev)
|
{
|
System.out.print(
|
org.opends.server.util.StaticUtils.wrapText(ev.getNewLogs(),
|
Utils.getCommandLineMaxLineWidth()));
|
}
|
});
|
uninstaller.start();
|
while (!uninstaller.isFinished())
|
{
|
try
|
{
|
Thread.sleep(100);
|
}
|
catch (Exception ex)
|
{
|
}
|
}
|
|
UninstallException ue = uninstaller.getException();
|
if (ue != null)
|
{
|
switch (ue.getType())
|
{
|
case FILE_SYSTEM_ERROR:
|
returnValue = ERROR_ACCESSING_FILE_SYSTEM;
|
break;
|
|
case STOP_ERROR:
|
returnValue = ERROR_STOPPING_SERVER;
|
break;
|
|
case BUG:
|
returnValue = BUG;
|
break;
|
|
default:
|
throw new IllegalStateException(
|
"Unknown UninstallException type: "+ue.getType());
|
}
|
}
|
else
|
{
|
returnValue = SUCCESSFUL;
|
}
|
}
|
else
|
{
|
// User cancelled installation.
|
returnValue = CANCELLED;
|
}
|
}
|
catch (UserUninstallDataException uude)
|
{
|
System.err.println(LINE_SEPARATOR+uude.getLocalizedMessage()+
|
LINE_SEPARATOR);
|
returnValue = USER_DATA_ERROR;
|
}
|
return returnValue;
|
}
|
|
/**
|
* Creates a UserUninstallData based in the arguments provided. It asks
|
* user for additional information if what is provided in the arguments is not
|
* enough.
|
* @param args the arguments provided in the command line.
|
* @param installStatus the current install status.
|
* @return the UserUninstallData object with what the user wants to uninstall
|
* and null if the user cancels the uninstallation.
|
* @throws UserUninstallDataException if there is an error parsing the data
|
* in the arguments.
|
*/
|
private UserUninstallData getUserUninstallData(String[] args,
|
CurrentInstallStatus installStatus) throws UserUninstallDataException
|
{
|
|
|
|
UserUninstallData userData = new UserUninstallData();
|
|
boolean silentUninstall = false;
|
boolean isCancelled = false;
|
|
/* Step 1: validate the arguments
|
*/
|
validateArguments(userData, args);
|
|
silentUninstall = isSilent(args);
|
|
|
/* Step 2: If this is not a silent install ask for confirmation to delete
|
* the different parts of the installation
|
*/
|
Set<String> outsideDbs = getOutsideDbs(installStatus);
|
Set<String> outsideLogs = getOutsideLogs(installStatus);
|
|
if (silentUninstall)
|
{
|
userData.setRemoveBackups(true);
|
userData.setRemoveConfigurationAndSchema(true);
|
userData.setRemoveDatabases(true);
|
userData.setRemoveLDIFs(true);
|
userData.setRemoveLibrariesAndTools(true);
|
userData.setRemoveLogs(true);
|
|
userData.setExternalDbsToRemove(outsideDbs);
|
userData.setExternalLogsToRemove(outsideLogs);
|
}
|
else
|
{
|
isCancelled = askWhatToDelete(userData, outsideDbs, outsideLogs);
|
}
|
|
/*
|
* Step 3: check if server is running. Depending if it is running and the
|
* OS we are running, ask for authentication information.
|
*/
|
if (!isCancelled)
|
{
|
isCancelled = askConfirmationToStop(userData, installStatus,
|
silentUninstall);
|
}
|
|
if (isCancelled)
|
{
|
userData = null;
|
}
|
|
return userData;
|
}
|
|
/**
|
* Interactively prompts (on standard 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). The method will display the
|
* message until the user provides one of the values in the validValues
|
* parameter.
|
*
|
* @param prompt The prompt to present to the user.
|
* @param defaultValue The default value returned if the user clicks enter.
|
* @param validValues The valid values that can be accepted as user input.
|
*
|
* @return The string value read from the user.
|
*/
|
private String promptConfirm(String prompt, String defaultValue,
|
String[] validValues)
|
{
|
System.out.println();
|
|
boolean isValid = false;
|
String response = null;
|
while (!isValid)
|
{
|
String msg = getMsg("cli-uninstall-confirm-prompt",
|
new String[] {prompt, defaultValue});
|
|
System.out.print(msg);
|
System.out.flush();
|
|
response = readLine();
|
if (response.equals(""))
|
{
|
response = defaultValue;
|
}
|
for (int i=0; i<validValues.length && !isValid; i++)
|
{
|
isValid = validValues[i].equalsIgnoreCase(response);
|
}
|
}
|
return response;
|
}
|
|
/**
|
* Interactively prompts (on standard 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).
|
*
|
* @param prompt The prompt to present to the user.
|
* @param defaultValue The default value returned if the user clicks enter.
|
*
|
* @return The string value read from the user.
|
*/
|
private String promptForString(String prompt, String defaultValue)
|
{
|
System.out.println();
|
|
String response = null;
|
String msg = getMsg("cli-uninstall-string-prompt",
|
new String[] {prompt, defaultValue});
|
|
System.out.print(msg);
|
System.out.flush();
|
|
response = readLine();
|
if (response.equals(""))
|
{
|
response = defaultValue;
|
}
|
return response;
|
}
|
|
/**
|
* Reads a line of text from standard input.
|
*
|
* @return The line of text read from standard input, or <CODE>null</CODE>
|
* if the end of the stream is reached or an error occurs while
|
* attempting to read the response.
|
*/
|
private String readLine()
|
{
|
try
|
{
|
ByteArrayOutputStream baos = new ByteArrayOutputStream();
|
|
while (true)
|
{
|
int b = System.in.read();
|
if ((b < 0) || (b == '\n'))
|
{
|
break;
|
}
|
else if (b == '\r')
|
{
|
int b2 = System.in.read();
|
if (b2 == '\n')
|
{
|
break;
|
}
|
else
|
{
|
baos.write(b);
|
baos.write(b2);
|
}
|
}
|
else
|
{
|
baos.write(b);
|
}
|
}
|
|
return new String(baos.toByteArray(), "UTF-8");
|
}
|
catch (Exception e)
|
{
|
System.err.println(getMsg("cli-uninstall-error-reading-stdin"));
|
|
return null;
|
}
|
}
|
|
/**
|
* Returns a Set of relative paths containing the db paths outside the
|
* installation.
|
* @param installStatus the Current Install Status object.
|
* @return a Set of relative paths containing the db paths outside the
|
* installation.
|
*/
|
private Set<String> getOutsideDbs(CurrentInstallStatus installStatus)
|
{
|
return Utils.getOutsideDbs(installStatus);
|
}
|
|
/**
|
* Returns a Set of relative paths containing the log paths outside the
|
* installation.
|
* @param installStatus the Current Install Status object.
|
* @return a Set of relative paths containing the log paths outside the
|
* installation.
|
*/
|
private Set<String> getOutsideLogs(CurrentInstallStatus installStatus)
|
{
|
return Utils.getOutsideLogs(installStatus);
|
}
|
|
/**
|
* Commodity method used to ask the user to confirm the deletion of certain
|
* parts of the server. It updates the provided UserUninstallData object
|
* accordingly. Returns <CODE>true</CODE> if the user cancels and <CODE>
|
* false</CODE> otherwise.
|
* @param userData the UserUninstallData object to be updated.
|
* @param outsideDbs the set of relative paths of databases located outside
|
* the installation path of the server.
|
* @param outsideLogs the set of relative paths of log files located outside
|
* the installation path of the server.
|
* @returns <CODE>true</CODE> if the user cancels and <CODE>false</CODE>
|
* otherwise.
|
*/
|
private boolean askWhatToDelete(UserUninstallData userData,
|
Set<String> outsideDbs, Set<String> outsideLogs)
|
{
|
boolean cancelled = false;
|
|
String answer = promptConfirm(getMsg("cli-uninstall-what-to-delete"),
|
"1", new String[] {"1", "2", "3"});
|
if ("3".equals(answer))
|
{
|
cancelled = true;
|
}
|
else if ("1".equals(answer))
|
{
|
userData.setRemoveBackups(true);
|
userData.setRemoveConfigurationAndSchema(true);
|
userData.setRemoveDatabases(true);
|
userData.setRemoveLDIFs(true);
|
userData.setRemoveLibrariesAndTools(true);
|
userData.setRemoveLogs(true);
|
|
userData.setExternalDbsToRemove(outsideDbs);
|
userData.setExternalLogsToRemove(outsideLogs);
|
}
|
else
|
{
|
boolean somethingSelected = false;
|
while (!somethingSelected)
|
{
|
// Ask for confirmation for the different items
|
String[] keys = {
|
"cli-uninstall-confirm-libraries-binaries",
|
"cli-uninstall-confirm-databases",
|
"cli-uninstall-confirm-logs",
|
"cli-uninstall-confirm-configuration-schema",
|
"cli-uninstall-confirm-backups",
|
"cli-uninstall-confirm-ldifs",
|
"cli-uninstall-confirm-outsidedbs",
|
"cli-uninstall-confirm-outsidelogs"
|
};
|
|
String[] validValues = {
|
getMsg("cli-uninstall-yes-long"), getMsg("cli-uninstall-no-long"),
|
getMsg("cli-uninstall-yes-short"), getMsg("cli-uninstall-no-short")
|
};
|
boolean[] answers = new boolean[keys.length];
|
for (int i=0; i<keys.length; i++)
|
{
|
boolean ignore = ((i == 6) && (outsideDbs.size() == 0)) ||
|
((i == 7) && (outsideLogs.size() == 0));
|
if (!ignore)
|
{
|
String msg;
|
if (i == 6)
|
{
|
String[] arg = {Utils.getStringFromCollection(outsideDbs,
|
LINE_SEPARATOR)};
|
msg = getMsg(keys[i], arg);
|
}
|
else if (i == 7)
|
{
|
String[] arg = {Utils.getStringFromCollection(outsideLogs,
|
LINE_SEPARATOR)};
|
msg = getMsg(keys[i], arg);
|
}
|
else
|
{
|
msg = getMsg(keys[i]);
|
}
|
answer = promptConfirm(msg, getMsg("cli-uninstall-yes-long"),
|
validValues);
|
|
if (getMsg("cli-uninstall-yes-long").equalsIgnoreCase(answer) ||
|
getMsg("cli-uninstall-yes-short").equalsIgnoreCase(answer))
|
{
|
answers[i] = true;
|
}
|
else
|
{
|
answers[i] = false;
|
}
|
}
|
else
|
{
|
answers[i] = false;
|
}
|
}
|
|
for (int i=0; i<answers.length; i++)
|
{
|
switch (i)
|
{
|
case 0:
|
userData.setRemoveLibrariesAndTools(answers[i]);
|
break;
|
|
case 1:
|
userData.setRemoveDatabases(answers[i]);
|
break;
|
|
case 2:
|
userData.setRemoveLogs(answers[i]);
|
break;
|
|
case 3:
|
userData.setRemoveConfigurationAndSchema(answers[i]);
|
break;
|
|
case 4:
|
userData.setRemoveBackups(answers[i]);
|
break;
|
|
case 5:
|
userData.setRemoveLDIFs(answers[i]);
|
break;
|
|
case 6:
|
if (answers[i])
|
{
|
userData.setExternalDbsToRemove(outsideDbs);
|
}
|
break;
|
|
case 7:
|
if (answers[i])
|
{
|
userData.setExternalLogsToRemove(outsideLogs);
|
}
|
break;
|
}
|
}
|
if ((userData.getExternalDbsToRemove().size() == 0) &&
|
(userData.getExternalLogsToRemove().size() == 0) &&
|
!userData.getRemoveLibrariesAndTools() &&
|
!userData.getRemoveDatabases() &&
|
!userData.getRemoveConfigurationAndSchema() &&
|
!userData.getRemoveBackups() &&
|
!userData.getRemoveLDIFs() &&
|
!userData.getRemoveLogs())
|
{
|
somethingSelected = false;
|
System.out.println(LINE_SEPARATOR+
|
getMsg("cli-uninstall-nothing-to-be-uninstalled"));
|
}
|
else
|
{
|
somethingSelected = true;
|
}
|
}
|
}
|
|
return cancelled;
|
}
|
|
/**
|
* Commodity method used to ask the user (when necessary) if the server must
|
* be stopped or not. If required it also asks the user authentication to
|
* be able to shut down the server in Windows.
|
* @param userData the UserUninstallData object to be updated with the
|
* authentication of the user.
|
* @param installStatus the CurrentInstallStatus object.
|
* @param silentUninstall boolean telling whether this is a silent uninstall
|
* or not.
|
* @return <CODE>true</CODE> if the user wants to continue with uninstall and
|
* <CODE>false</CODE> otherwise.
|
* @throws UserUninstallDataException if there is a problem with the data
|
* provided by the user (in the particular case where we are on silent
|
* uninstall and some data is missing or not valid).
|
*/
|
private boolean askConfirmationToStop(UserUninstallData userData,
|
CurrentInstallStatus installStatus, boolean silentUninstall)
|
throws UserUninstallDataException
|
{
|
boolean cancelled = false;
|
|
String errorMsg = null;
|
if (installStatus.isServerRunning())
|
{
|
if (Utils.isWindows())
|
{
|
if (silentUninstall)
|
{
|
String dn = userData.getDirectoryManagerDn();
|
String pwd = userData.getDirectoryManagerPwd();
|
if ((dn == null) || (pwd == null))
|
{
|
errorMsg = getMsg("cli-uninstall-data-missing-to-shutdown-server");
|
}
|
else
|
{
|
if (!canConnectAsAdministrativeUser(installStatus.getLdapUrl(),
|
userData.getDirectoryManagerDn(),
|
userData.getDirectoryManagerPwd()))
|
{
|
errorMsg = getErrorMsgConnecting(dn, pwd, installStatus);
|
}
|
}
|
|
if (errorMsg != null)
|
{
|
throw new UserUninstallDataException(null, errorMsg);
|
}
|
}
|
else
|
{
|
/* Ask for the Directory Manager Dn and password if they were not
|
* provided.
|
*/
|
boolean askForDn = userData.getDirectoryManagerDn() == null;
|
boolean askForPwd = userData.getDirectoryManagerPwd() == null;
|
|
boolean prompted = false;
|
|
if (!askForDn && !askForPwd)
|
{
|
String dn = userData.getDirectoryManagerDn();
|
String pwd = userData.getDirectoryManagerPwd();
|
|
if (!canConnectAsAdministrativeUser(installStatus.getLdapUrl(),
|
dn, pwd))
|
{
|
System.out.println(LINE_SEPARATOR+LINE_SEPARATOR+getMsg(
|
"cli-uninstall-stop-authentication-generic-prompt1"));
|
System.out.println(getErrorMsgConnecting(dn, pwd, installStatus));
|
askForDn = true;
|
askForPwd = true;
|
}
|
else
|
{
|
String[] validValues = {
|
getMsg("cli-uninstall-yes-short"),
|
getMsg("cli-uninstall-no-short"),
|
getMsg("cli-uninstall-yes-long"),
|
getMsg("cli-uninstall-no-long")
|
};
|
String answer = promptConfirm(
|
getMsg("cli-uninstall-confirm-stop"),
|
getMsg("cli-uninstall-yes-long"), validValues);
|
|
if (getMsg("cli-uninstall-no-short").equalsIgnoreCase(answer) ||
|
getMsg("cli-uninstall-no-long").equalsIgnoreCase(answer))
|
{
|
cancelled = true;
|
}
|
}
|
}
|
else
|
{
|
System.out.println(
|
getMsg("cli-uninstall-stop-authentication-generic-prompt1"));
|
}
|
|
while (askForDn || askForPwd)
|
{
|
if (!prompted)
|
{
|
System.out.println(
|
getMsg("cli-uninstall-stop-authentication-generic-prompt2"));
|
}
|
if (askForDn)
|
{
|
String defaultDn = userData.getDirectoryManagerDn();
|
if ((defaultDn == null) || !Utils.isDn(defaultDn))
|
{
|
Set<String> dns = installStatus.getDirectoryManagerDns();
|
if (dns.size() > 0)
|
{
|
defaultDn = dns.iterator().next();
|
}
|
else
|
{
|
defaultDn = "cn=Directory Manager";
|
}
|
}
|
userData.setDirectoryManagerDn(
|
promptForString(getMsg("cli-uninstall-prompt-dn"),
|
defaultDn));
|
prompted = true;
|
}
|
if (askForPwd)
|
{
|
userData.setDirectoryManagerPwd(promptForPassword(
|
getMsg("cli-uninstall-prompt-pwd")));
|
prompted = true;
|
}
|
String dn = userData.getDirectoryManagerDn();
|
String pwd = userData.getDirectoryManagerPwd();
|
|
if (!canConnectAsAdministrativeUser(installStatus.getLdapUrl(),
|
dn, pwd))
|
{
|
if (installStatus.isServerRunning())
|
{
|
System.out.println(LINE_SEPARATOR+getErrorMsgConnecting(dn, pwd,
|
installStatus));
|
askForDn = true;
|
askForPwd = true;
|
}
|
else
|
{
|
/* The server was stopped while we asked the user to provide
|
* authentication. Inform of this and return.
|
*/
|
System.out.println(
|
getMsg("cli-uninstall-server-stopped"));
|
askForDn = false;
|
askForPwd = false;
|
/* Ask for confirmation to delete files */
|
cancelled = !confirmDeleteFiles();
|
}
|
}
|
else
|
{
|
askForDn = false;
|
askForPwd = false;
|
/* Ask for confirmation to stop server */
|
cancelled = !confirmToStopServer();
|
}
|
}
|
}
|
}
|
else
|
{
|
if (!silentUninstall)
|
{
|
/* Ask for confirmation to stop server */
|
cancelled = !confirmToStopServer();
|
}
|
}
|
|
if (!cancelled)
|
{
|
/* During all the confirmations, the server might be stopped. */
|
userData.setStopServer(installStatus.isServerRunning());
|
}
|
}
|
else
|
{
|
userData.setStopServer(false);
|
if (!silentUninstall)
|
{
|
/* Ask for confirmation to delete files */
|
cancelled = !confirmDeleteFiles();
|
}
|
}
|
return cancelled;
|
}
|
|
/**
|
* Commodity method providing a localized message when we cannot connect to
|
* the server.
|
* @param dn the DN used to connect to the server.
|
* @param pwd the password used to connect to the server.
|
* @param installStatus the CurrentInstallStatus object describing the
|
* status of the installation.
|
* @return a localized message when we cannot connect to the server.
|
*/
|
private String getErrorMsgConnecting(String dn, String pwd,
|
CurrentInstallStatus installStatus)
|
{
|
String msg;
|
|
ArrayList<String> possibleCauses = new ArrayList<String>();
|
if ("".equals(dn.trim()))
|
{
|
possibleCauses.add(getMsg("empty-directory-manager-dn"));
|
}
|
else if (!Utils.isDn(dn))
|
{
|
possibleCauses.add(getMsg("not-a-directory-manager-dn"));
|
}
|
else
|
{
|
boolean found = false;
|
Iterator<String> it =
|
installStatus.getDirectoryManagerDns().iterator();
|
while (it.hasNext() && !found)
|
{
|
found = Utils.areDnsEqual(dn, it.next());
|
}
|
if (!found)
|
{
|
possibleCauses.add(getMsg("not-a-directory-manager-in-config"));
|
}
|
}
|
|
if ("".equals(pwd))
|
{
|
possibleCauses.add(getMsg("empty-pwd"));
|
}
|
if (possibleCauses.size() > 0)
|
{
|
// Message with causes
|
String[] arg = {
|
Utils.getStringFromCollection(possibleCauses, "\n")
|
};
|
msg = getMsg("cli-uninstall-cannot-connect-to-shutdown-with-cause", arg);
|
}
|
else
|
{
|
// Generic message
|
msg = getMsg("cli-uninstall-cannot-connect-to-shutdown-without-cause");
|
}
|
return msg;
|
}
|
|
/**
|
* Returns <CODE>true</CODE> if this is a silent uninstall and
|
* <CODE>false</CODE> otherwise.
|
* @param args the arguments passed in the command line.
|
* @return <CODE>true</CODE> if this is a silent uninstall and
|
* <CODE>false</CODE> otherwise.
|
*/
|
private boolean isSilent(String[] args)
|
{
|
boolean isSilent = false;
|
for (int i=0; i<args.length && !isSilent; i++)
|
{
|
if (args[i].equalsIgnoreCase("--silentUninstall") ||
|
args[i].equalsIgnoreCase("-s"))
|
{
|
isSilent = true;
|
}
|
}
|
return isSilent;
|
}
|
|
/**
|
* Commodity method used to validate the arguments provided by the user in
|
* the command line and updating the UserUninstallData object accordingly.
|
* @param userData the UserUninstallData object to be updated.
|
* @param args the arguments passed in the command line.
|
* @throws UserUninstallDataException if there is an error with the data
|
* provided by the user.
|
*/
|
private void validateArguments(UserUninstallData userData,
|
String[] args) throws UserUninstallDataException
|
{
|
String directoryManagerPwd = null;
|
String directoryManagerPwdFile = null;
|
|
ArrayList<String> errors = new ArrayList<String>();
|
|
for (int i=0; i<args.length; i++)
|
{
|
if (args[i].equalsIgnoreCase("--cli") ||
|
args[i].equalsIgnoreCase("-H") ||
|
args[i].equalsIgnoreCase("--help") ||
|
args[i].equalsIgnoreCase("--silentUninstall") ||
|
args[i].equalsIgnoreCase("-s"))
|
{
|
// Ignore
|
}
|
else if (Utils.isWindows() &&
|
(args[i].equalsIgnoreCase("-D") ||
|
args[i].equalsIgnoreCase("--rootUserDN")))
|
{
|
if (i+1 >= args.length)
|
{
|
errors.add(getMsg("cli-uninstall-root-user-dn-not-provided"));
|
}
|
else
|
{
|
if (args[i+1].indexOf("-") == 0)
|
{
|
errors.add(getMsg("cli-uninstall-root-user-dn-not-provided"));
|
}
|
else
|
{
|
userData.setDirectoryManagerDn(args[i+1]);
|
i++;
|
}
|
}
|
}
|
else if (Utils.isWindows() &&
|
(args[i].equals("-w") ||
|
args[i].equalsIgnoreCase("--rootUserPassword")))
|
{
|
if (i+1 >= args.length)
|
{
|
errors.add(getMsg("cli-uninstall-root-user-pwd-not-provided"));
|
}
|
else
|
{
|
if (args[i+1].indexOf("-") == 0)
|
{
|
errors.add(getMsg("cli-uninstall-root-user-pwd-not-provided"));
|
}
|
else
|
{
|
directoryManagerPwd = args[i+1];
|
i++;
|
}
|
}
|
}
|
else if (Utils.isWindows() &&
|
(args[i].equals("-W") ||
|
args[i].equalsIgnoreCase("--rootUserPasswordFile")))
|
{
|
if (i+1 >= args.length)
|
{
|
errors.add(getMsg("cli-uninstall-root-user-pwd-file-not-provided"));
|
}
|
else
|
{
|
if (args[i+1].indexOf("-") == 0)
|
{
|
errors.add(getMsg("cli-uninstall-root-user-pwd-file-not-provided"));
|
}
|
else
|
{
|
directoryManagerPwdFile = args[i+1];
|
i++;
|
}
|
}
|
}
|
else
|
{
|
String[] arg = {args[i]};
|
errors.add(getMsg("cli-uninstall-unknown-argument", arg));
|
}
|
}
|
|
if ((directoryManagerPwdFile != null) && (directoryManagerPwd != null))
|
{
|
errors.add(getMsg("cli-uninstall-pwd-and-pwd-file-provided"));
|
}
|
else
|
{
|
String pwd;
|
if (directoryManagerPwdFile != null)
|
{
|
pwd = readPwdFromFile(directoryManagerPwdFile);
|
if (pwd == null)
|
{
|
String[] arg = {directoryManagerPwdFile};
|
errors.add(getMsg("cli-uninstall-error-reading-pwd-file", arg));
|
}
|
}
|
else
|
{
|
pwd = directoryManagerPwd;
|
}
|
userData.setDirectoryManagerPwd(pwd);
|
}
|
|
if (errors.size() > 0)
|
{
|
String msg = Utils.getStringFromCollection(errors,
|
LINE_SEPARATOR+LINE_SEPARATOR);
|
throw new UserUninstallDataException(null, msg);
|
}
|
}
|
|
/**
|
* Interactively prompts (on standard output) the user to provide a string
|
* value.
|
*
|
* @param prompt The prompt to present to the user.
|
*
|
* @return The string value read from the user.
|
*/
|
private String promptForPassword(String prompt)
|
{
|
char[] password = null;
|
while ((password == null) || (password.length == 0))
|
{
|
System.out.println();
|
System.out.print(prompt);
|
System.out.flush();
|
|
password = org.opends.server.util.PasswordReader.readPassword();
|
}
|
|
return new String(password);
|
}
|
|
/**
|
* Returns the password stored in a file. Returns <CODE>null</CODE> if no
|
* password is found.
|
* @param path the path of the file containing the password.
|
* @return the password stored in a file. Returns <CODE>null</CODE> if no
|
* password is found.
|
*/
|
private String readPwdFromFile(String path)
|
{
|
String pwd = null;
|
BufferedReader reader = null;
|
try
|
{
|
reader = new BufferedReader(new FileReader(path));
|
pwd = reader.readLine();
|
}
|
catch (Exception e)
|
{
|
}
|
finally
|
{
|
try
|
{
|
if (reader != null)
|
{
|
reader.close();
|
}
|
} catch (Exception e) {}
|
}
|
return pwd;
|
}
|
|
/**
|
* Method used to know if we can connect as administrator in a server with a
|
* given password and dn.
|
* @param ldapUrl the ldap URL of the server.
|
* @param dn the dn to be used.
|
* @param pwd the password to be used.
|
* @return <CODE>true</CODE> if we can connect and read the configuration and
|
* <CODE>false</CODE> otherwise.
|
*/
|
private boolean canConnectAsAdministrativeUser(String ldapUrl, String dn,
|
String pwd)
|
{
|
return Utils.canConnectAsAdministrativeUser(ldapUrl, dn, pwd);
|
}
|
|
|
/**
|
* Ask for confirmation to stop server.
|
* @return <CODE>true</CODE> if the user wants to continue and stop the
|
* server. <CODE>false</CODE> otherwise.
|
*/
|
private boolean confirmToStopServer()
|
{
|
boolean confirm = true;
|
String[] validValues = {
|
getMsg("cli-uninstall-yes-short"),
|
getMsg("cli-uninstall-no-short"),
|
getMsg("cli-uninstall-yes-long"),
|
getMsg("cli-uninstall-no-long")
|
};
|
String answer = promptConfirm(
|
getMsg("cli-uninstall-confirm-stop"),
|
getMsg("cli-uninstall-yes-long"), validValues);
|
|
if (getMsg("cli-uninstall-no-short").equalsIgnoreCase(answer) ||
|
getMsg("cli-uninstall-no-long").equalsIgnoreCase(answer))
|
{
|
confirm = false;
|
}
|
return confirm;
|
}
|
|
/**
|
* Ask for confirmation to delete files.
|
* @return <CODE>true</CODE> if the user wants to continue and delete the
|
* files. <CODE>false</CODE> otherwise.
|
*/
|
private boolean confirmDeleteFiles()
|
{
|
boolean confirm = true;
|
String[] validValues = {
|
getMsg("cli-uninstall-yes-short"),
|
getMsg("cli-uninstall-no-short"),
|
getMsg("cli-uninstall-yes-long"),
|
getMsg("cli-uninstall-no-long")
|
};
|
String answer = promptConfirm(
|
getMsg("cli-uninstall-confirm-delete-files"),
|
getMsg("cli-uninstall-yes-long"), validValues);
|
|
if (getMsg("cli-uninstall-no-short").equalsIgnoreCase(answer) ||
|
getMsg("cli-uninstall-no-long").equalsIgnoreCase(answer))
|
{
|
confirm = false;
|
}
|
return confirm;
|
}
|
|
/**
|
* The following three methods are just commodity methods to get localized
|
* messages.
|
*/
|
private static String getMsg(String key)
|
{
|
return org.opends.server.util.StaticUtils.wrapText(getI18n().getMsg(key),
|
Utils.getCommandLineMaxLineWidth());
|
}
|
|
private static String getMsg(String key, String[] args)
|
{
|
return org.opends.server.util.StaticUtils.wrapText(
|
getI18n().getMsg(key, args), Utils.getCommandLineMaxLineWidth());
|
}
|
|
private static ResourceProvider getI18n()
|
{
|
return ResourceProvider.getInstance();
|
}
|
}
|
