From 7a79845d216f2efbc447c3ba4c5c3a992be0f42f Mon Sep 17 00:00:00 2001
From: Gaetan Boismal <gaetan.boismal@forgerock.com>
Date: Mon, 11 Apr 2016 17:22:17 +0000
Subject: [PATCH] Code cleanup: Merge Installer and OfflineInstaller
---
opendj-server-legacy/src/main/java/org/opends/quicksetup/installer/Installer.java | 487 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 486 insertions(+), 1 deletions(-)
diff --git a/opendj-server-legacy/src/main/java/org/opends/quicksetup/installer/Installer.java b/opendj-server-legacy/src/main/java/org/opends/quicksetup/installer/Installer.java
index 048c34a..57d4252 100644
--- a/opendj-server-legacy/src/main/java/org/opends/quicksetup/installer/Installer.java
+++ b/opendj-server-legacy/src/main/java/org/opends/quicksetup/installer/Installer.java
@@ -16,6 +16,7 @@
*/
package org.opends.quicksetup.installer;
+import static com.forgerock.opendj.util.OperatingSystem.isWindows;
import static org.forgerock.util.Utils.*;
import static org.opends.admin.ads.ServerDescriptor.*;
import static org.opends.admin.ads.ServerDescriptor.ServerProperty.*;
@@ -33,7 +34,9 @@
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
+import java.io.PrintStream;
import java.net.URI;
+import java.security.KeyStoreException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -117,6 +120,7 @@
import org.opends.quicksetup.ui.UIFactory;
import org.opends.quicksetup.util.FileManager;
import org.opends.quicksetup.util.IncompatibleVersionException;
+import org.opends.quicksetup.util.ServerController;
import org.opends.quicksetup.util.Utils;
import org.opends.server.tools.BackendTypeHelper;
import org.opends.server.tools.BackendTypeHelper.BackendTypeUIAdapter;
@@ -145,7 +149,7 @@
* Note that we can use freely the class org.opends.server.util.SetupUtils as
* it is included in quicksetup.jar.
*/
-public abstract class Installer extends GuiApplication
+public class Installer extends GuiApplication
{
/** The minimum integer value that can be used for a port. */
public static final int MIN_PORT_VALUE = 1;
@@ -222,6 +226,487 @@
*/
public static final int THRESHOLD_CLOCK_DIFFERENCE_WARNING = 5;
+ /** This map contains the ratio associated with each step. */
+ private final Map<ProgressStep, Integer> hmRatio = new HashMap<>();
+ /** This map contains the summary associated with each step. */
+ private final Map<ProgressStep, LocalizableMessage> hmSummary = new HashMap<>();
+
+ private ApplicationException runError;
+
+ /**
+ * Actually performs the install in this thread. The thread is blocked.
+ */
+ @Override
+ public void run()
+ {
+ runError = null;
+ PrintStream origErr = System.err;
+ PrintStream origOut = System.out;
+ try
+ {
+ initMaps();
+ System.setErr(getApplicationErrorStream());
+ System.setOut(getApplicationOutputStream());
+ checkAbort();
+
+ setCurrentProgressStep(InstallProgressStep.CONFIGURING_SERVER);
+ notifyListenersOfLog(false);
+ notifyListeners(getLineBreak());
+ configureServer();
+ checkAbort();
+
+ LicenseFile.createFileLicenseApproved(getInstallationPath());
+ checkAbort();
+
+ createData();
+ checkAbort();
+
+ if (isWindows() && getUserData().getEnableWindowsService())
+ {
+ if (isVerbose())
+ {
+ notifyListeners(getTaskSeparator());
+ }
+ setCurrentProgressStep(InstallProgressStep.ENABLING_WINDOWS_SERVICE);
+ enableWindowsService();
+ checkAbort();
+ }
+
+ if (mustStart())
+ {
+ if (isStartVerbose())
+ {
+ notifyListeners(getTaskSeparator());
+ }
+ setCurrentProgressStep(InstallProgressStep.STARTING_SERVER);
+ PointAdder pointAdder = new PointAdder();
+ if (!isStartVerbose())
+ {
+ notifyListeners(getFormattedProgress(
+ INFO_PROGRESS_STARTING_NON_VERBOSE.get()));
+ pointAdder.start();
+ }
+ try
+ {
+ new ServerController(this).startServer(!isStartVerbose());
+ }
+ finally
+ {
+ if (!isStartVerbose())
+ {
+ pointAdder.stop();
+ }
+ }
+ if (!isStartVerbose())
+ {
+ notifyListeners(getFormattedDoneWithLineBreak());
+ }
+ else
+ {
+ notifyListeners(getLineBreak());
+ }
+ checkAbort();
+ }
+
+ if (mustCreateAds())
+ {
+ if (isVerbose())
+ {
+ notifyListeners(getTaskSeparator());
+ }
+ setCurrentProgressStep(InstallProgressStep.CONFIGURING_ADS);
+ updateADS();
+ checkAbort();
+ }
+
+ if (mustConfigureReplication())
+ {
+ if (isVerbose())
+ {
+ notifyListeners(getTaskSeparator());
+ }
+ setCurrentProgressStep(InstallProgressStep.CONFIGURING_REPLICATION);
+ createReplicatedBackendsIfRequired();
+ configureReplication();
+ checkAbort();
+ }
+
+ if (mustInitializeSuffixes())
+ {
+ if (isVerbose())
+ {
+ notifyListeners(getTaskSeparator());
+ }
+ setCurrentProgressStep(
+ InstallProgressStep.INITIALIZE_REPLICATED_SUFFIXES);
+ initializeSuffixes();
+ checkAbort();
+ }
+
+ if (mustStop())
+ {
+ if (isVerbose())
+ {
+ notifyListeners(getTaskSeparator());
+ }
+ setCurrentProgressStep(InstallProgressStep.STOPPING_SERVER);
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedWithPoints(
+ INFO_PROGRESS_STOPPING_NON_VERBOSE.get()));
+ }
+ new ServerController(this).stopServer(!isVerbose());
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedDoneWithLineBreak());
+ }
+ }
+
+ checkAbort();
+ updateSummaryWithServerState(hmSummary, true);
+ setCurrentProgressStep(InstallProgressStep.FINISHED_SUCCESSFULLY);
+ notifyListeners(null);
+ tempLogFile.deleteLogFileAfterSuccess();
+ } catch (ApplicationException ex)
+ {
+ logger.error(LocalizableMessage.raw("Caught exception: "+ex, ex));
+ if (ReturnCode.CANCELED.equals(ex.getType())) {
+ uninstall();
+ setCurrentProgressStep(InstallProgressStep.FINISHED_CANCELED);
+ notifyListeners(null);
+ } else {
+ // Stop the server if necessary
+ Installation installation = getInstallation();
+ if (installation.getStatus().isServerRunning()) {
+ try {
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedWithPoints(
+ INFO_PROGRESS_STOPPING_NON_VERBOSE.get()));
+ }
+ new ServerController(installation).stopServer(!isVerbose());
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedDoneWithLineBreak());
+ }
+ } catch (Throwable t) {
+ logger.info(LocalizableMessage.raw("error stopping server", t));
+ }
+ }
+ notifyListeners(getLineBreak());
+ updateSummaryWithServerState(hmSummary, true);
+ setCurrentProgressStep(InstallProgressStep.FINISHED_WITH_ERROR);
+ LocalizableMessage html = getFormattedError(ex, true);
+ notifyListeners(html);
+ logger.error(LocalizableMessage.raw("Error installing.", ex));
+ notifyListeners(getLineBreak());
+ notifyListenersOfLog(true);
+ }
+ runError = ex;
+ }
+ catch (Throwable t)
+ {
+ // Stop the server if necessary
+ Installation installation = getInstallation();
+ if (installation.getStatus().isServerRunning()) {
+ try {
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedWithPoints(
+ INFO_PROGRESS_STOPPING_NON_VERBOSE.get()));
+ }
+ new ServerController(installation).stopServer(!isVerbose());
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedDoneWithLineBreak());
+ }
+ } catch (Throwable t2) {
+ logger.info(LocalizableMessage.raw("error stopping server", t2));
+ }
+ }
+ notifyListeners(getLineBreak());
+ updateSummaryWithServerState(hmSummary, true);
+ setCurrentProgressStep(InstallProgressStep.FINISHED_WITH_ERROR);
+ ApplicationException ex = new ApplicationException(
+ ReturnCode.BUG,
+ getThrowableMsg(INFO_BUG_MSG.get(), t), t);
+ LocalizableMessage msg = getFormattedError(ex, true);
+ notifyListeners(msg);
+ logger.error(LocalizableMessage.raw("Error installing.", t));
+ notifyListeners(getLineBreak());
+ notifyListenersOfLog(true);
+ runError = ex;
+ }
+ finally
+ {
+ System.setErr(origErr);
+ System.setOut(origOut);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public Integer getRatio(ProgressStep status)
+ {
+ return hmRatio.get(status);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public LocalizableMessage getSummary(ProgressStep status)
+ {
+ return hmSummary.get(status);
+ }
+
+ /**
+ * Returns the exception from the run() method, if any.
+ * @return the ApplicationException raised during the run() method, if any.
+ * null otherwise.
+ */
+ public ApplicationException getRunError()
+ {
+ return runError;
+ }
+
+ /**
+ * Called when the user elects to cancel this operation.
+ */
+ protected void uninstall() {
+
+ notifyListeners(getTaskSeparator());
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedWithPoints(INFO_PROGRESS_CANCELING.get()));
+ }
+ else
+ {
+ notifyListeners(
+ getFormattedProgressWithLineBreak(INFO_SUMMARY_CANCELING.get()));
+ }
+ Installation installation = getInstallation();
+ FileManager fm = new FileManager(this);
+
+ // Stop the server if necessary
+ if (installation.getStatus().isServerRunning()) {
+ try {
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedWithPoints(
+ INFO_PROGRESS_STOPPING_NON_VERBOSE.get()));
+ }
+ new ServerController(installation).stopServer(!isVerbose());
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedDoneWithLineBreak());
+ }
+ } catch (ApplicationException e) {
+ logger.info(LocalizableMessage.raw("error stopping server", e));
+ }
+ }
+
+ uninstallServices();
+
+ // Revert to the base configuration
+ try {
+ File newConfig = fm.copy(installation.getBaseConfigurationFile(),
+ installation.getConfigurationDirectory(),
+ /*overwrite=*/true);
+ fm.rename(newConfig, installation.getCurrentConfigurationFile());
+
+ } catch (ApplicationException ae) {
+ logger.info(LocalizableMessage.raw("failed to restore base configuration", ae));
+ }
+
+ // Cleanup SSL if necessary
+ SecurityOptions sec = getUserData().getSecurityOptions();
+ if (sec.getEnableSSL() || sec.getEnableStartTLS()) {
+ if (SecurityOptions.CertificateType.SELF_SIGNED_CERTIFICATE.equals(
+ sec.getCertificateType())) {
+ CertificateManager cm = new CertificateManager(
+ getSelfSignedKeystorePath(),
+ CertificateManager.KEY_STORE_TYPE_JKS,
+ getSelfSignedCertificatePwd());
+ try {
+ for (String alias : SELF_SIGNED_CERT_ALIASES)
+ {
+ if (cm.aliasInUse(alias))
+ {
+ cm.removeCertificate(alias);
+ }
+ }
+ } catch (KeyStoreException e) {
+ logger.info(LocalizableMessage.raw("Error deleting self signed certification", e));
+ }
+ }
+
+ File keystore = new File(installation.getConfigurationDirectory(),
+ "keystore");
+ if (keystore.exists()) {
+ try {
+ fm.delete(keystore);
+ } catch (ApplicationException e) {
+ logger.info(LocalizableMessage.raw("Failed to delete keystore", e));
+ }
+ }
+
+ File keystorePin = new File(installation.getConfigurationDirectory(),
+ "keystore.pin");
+ if (keystorePin.exists()) {
+ try {
+ fm.delete(keystorePin);
+ } catch (ApplicationException e) {
+ logger.info(LocalizableMessage.raw("Failed to delete keystore.pin", e));
+ }
+ }
+
+ File truststore = new File(installation.getConfigurationDirectory(),
+ "truststore");
+ if (truststore.exists()) {
+ try {
+ fm.delete(truststore);
+ } catch (ApplicationException e) {
+ logger.info(LocalizableMessage.raw("Failed to delete truststore", e));
+ }
+ }
+ }
+
+ // Remove the databases
+ try {
+ fm.deleteChildren(installation.getDatabasesDirectory());
+ } catch (ApplicationException e) {
+ logger.info(LocalizableMessage.raw("Error deleting databases", e));
+ }
+
+ if (!isVerbose())
+ {
+ notifyListeners(getFormattedDoneWithLineBreak());
+ }
+ }
+
+ private void initMaps()
+ {
+ initSummaryMap(hmSummary, true);
+
+ /*
+ * hmTime contains the relative time that takes for each task to be
+ * accomplished. For instance if downloading takes twice the time of
+ * extracting, the value for downloading will be the double of the value for
+ * extracting.
+ */
+ Map<ProgressStep, Integer> hmTime = new HashMap<>();
+ hmTime.put(InstallProgressStep.CONFIGURING_SERVER, 5);
+ hmTime.put(InstallProgressStep.CREATING_BASE_ENTRY, 10);
+ hmTime.put(InstallProgressStep.IMPORTING_LDIF, 20);
+ hmTime.put(InstallProgressStep.IMPORTING_AUTOMATICALLY_GENERATED, 20);
+ hmTime.put(InstallProgressStep.CONFIGURING_REPLICATION, 10);
+ hmTime.put(InstallProgressStep.ENABLING_WINDOWS_SERVICE, 5);
+ hmTime.put(InstallProgressStep.STARTING_SERVER, 10);
+ hmTime.put(InstallProgressStep.STOPPING_SERVER, 5);
+ hmTime.put(InstallProgressStep.CONFIGURING_ADS, 5);
+ hmTime.put(InstallProgressStep.INITIALIZE_REPLICATED_SUFFIXES, 25);
+
+ int totalTime = 0;
+ List<InstallProgressStep> steps = new ArrayList<>();
+ totalTime += hmTime.get(InstallProgressStep.CONFIGURING_SERVER);
+ steps.add(InstallProgressStep.CONFIGURING_SERVER);
+ if (createNotReplicatedSuffix())
+ {
+ switch (getUserData().getNewSuffixOptions().getType())
+ {
+ case CREATE_BASE_ENTRY:
+ steps.add(InstallProgressStep.CREATING_BASE_ENTRY);
+ totalTime += hmTime.get(InstallProgressStep.CREATING_BASE_ENTRY);
+ break;
+ case IMPORT_FROM_LDIF_FILE:
+ steps.add(InstallProgressStep.IMPORTING_LDIF);
+ totalTime += hmTime.get(InstallProgressStep.IMPORTING_LDIF);
+ break;
+ case IMPORT_AUTOMATICALLY_GENERATED_DATA:
+ steps.add(InstallProgressStep.IMPORTING_AUTOMATICALLY_GENERATED);
+ totalTime += hmTime.get(
+ InstallProgressStep.IMPORTING_AUTOMATICALLY_GENERATED);
+ break;
+ }
+ }
+
+ if (isWindows() && getUserData().getEnableWindowsService())
+ {
+ totalTime += hmTime.get(InstallProgressStep.ENABLING_WINDOWS_SERVICE);
+ steps.add(InstallProgressStep.ENABLING_WINDOWS_SERVICE);
+ }
+
+ if (mustStart())
+ {
+ totalTime += hmTime.get(InstallProgressStep.STARTING_SERVER);
+ steps.add(InstallProgressStep.STARTING_SERVER);
+ }
+
+ if (mustCreateAds())
+ {
+ totalTime += hmTime.get(InstallProgressStep.CONFIGURING_ADS);
+ steps.add(InstallProgressStep.CONFIGURING_ADS);
+ }
+
+ if (mustConfigureReplication())
+ {
+ steps.add(InstallProgressStep.CONFIGURING_REPLICATION);
+ totalTime += hmTime.get(InstallProgressStep.CONFIGURING_REPLICATION);
+ }
+
+ if (mustInitializeSuffixes())
+ {
+ totalTime += hmTime.get(
+ InstallProgressStep.INITIALIZE_REPLICATED_SUFFIXES);
+ steps.add(InstallProgressStep.INITIALIZE_REPLICATED_SUFFIXES);
+ }
+
+ if (mustStop())
+ {
+ totalTime += hmTime.get(InstallProgressStep.STOPPING_SERVER);
+ steps.add(InstallProgressStep.STOPPING_SERVER);
+ }
+
+ int cumulatedTime = 0;
+ for (InstallProgressStep s : steps)
+ {
+ Integer statusTime = hmTime.get(s);
+ hmRatio.put(s, (100 * cumulatedTime) / totalTime);
+ if (statusTime != null)
+ {
+ cumulatedTime += statusTime;
+ }
+ }
+ hmRatio.put(InstallProgressStep.FINISHED_SUCCESSFULLY, 100);
+ hmRatio.put(InstallProgressStep.FINISHED_WITH_ERROR, 100);
+ hmRatio.put(InstallProgressStep.FINISHED_CANCELED, 100);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public String getInstallationPath()
+ {
+ return Utils.getInstallPathFromClasspath();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public String getInstancePath()
+ {
+ String installPath = Utils.getInstallPathFromClasspath();
+ return Utils.getInstancePathFromInstallPath(installPath);
+ }
+
+ private void notifyListenersOfLog(final boolean isError)
+ {
+ if (tempLogFile.isEnabled())
+ {
+ final String tempLogFilePath = tempLogFile.getPath();
+ notifyListeners(getFormattedProgress(isError ? INFO_GENERAL_PROVIDE_LOG_IN_ERROR.get(tempLogFilePath)
+ : INFO_GENERAL_SEE_FOR_DETAILS.get(tempLogFilePath)));
+ notifyListeners(getLineBreak());
+ }
+ }
+
/** Creates a default instance. */
public Installer()
{
--
Gitblit v1.10.0