Application.java revision 6292beaede500c125091a84263ed7cda454ba299
/*
* 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 legal-notices/CDDLv1_0.txt
* 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 legal-notices/CDDLv1_0.txt.
* 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-2015 ForgeRock AS.
*/
/**
* This class represents an application that can be run in the context of
* QuickSetup. Examples of applications might be 'installer' and 'uninstaller'.
*/
/** Represents current install state. */
protected CurrentInstallStatus installStatus;
private Installation installation;
private ApplicationTrustManager trustManager;
private boolean notifyListeners = true;
/** Formats progress messages. */
protected ProgressMessageFormatter formatter;
/** Handler for listeners and event firing. */
protected ProgressUpdateListenerDelegate listenerDelegate;
/**
* Creates an application by instantiating the Application class
* denoted by the System property
* <code>org.opends.quicksetup.Application.class</code>.
* @return Application object that was newly instantiated
* @throws RuntimeException if there was a problem
* creating the new Application object
*/
if (appClassName != null) {
try {
} catch (ClassNotFoundException e) {
throw new RuntimeException(msg, e);
} catch (IllegalAccessException e) {
throw new RuntimeException(msg, e);
} catch (InstantiationException e) {
throw new RuntimeException(msg, e);
} catch (ClassCastException e) {
"'org.opends.quicksetup.Application.class' must " +
" must be of type Application";
throw new RuntimeException(msg, e);
}
} else {
" must specify class quicksetup application";
throw new RuntimeException(msg);
}
return app;
}
/**
* Sets this instances user data.
* @param userData UserData this application will use
* when executing
*/
}
/**
* Creates a set of user data with default values.
* @return UserData empty set of UserData
*/
public UserData createUserData() {
return new UserData();
}
/**
* Adds a ProgressUpdateListener that will be notified of updates in
* the install progress.
* @param l the ProgressUpdateListener to be added.
*/
public void addProgressUpdateListener(ProgressUpdateListener l)
{
}
/**
* Removes a ProgressUpdateListener.
* @param l the ProgressUpdateListener to be removed.
*/
public void removeProgressUpdateListener(ProgressUpdateListener l)
{
}
/**
* Gets the OpenDJ installation associated with the execution of this
* command.
* @return Installation object representing the current OpenDS installation
*/
public Installation getInstallation() {
if (installation == null) {
if (installPath != null) {
if (instancePath != null)
{
}
else
{
}
}
}
return installation;
}
/**
* Sets the application's installation.
* @param installation describing the application's OpenDS installation
*/
this.installation = installation;
}
/**
* Returns the UserData object representing the parameters provided by
* the user to do the installation.
*
* @return the UserData object representing the parameters provided
* by the user to do the installation.
*/
public UserData getUserData()
{
userData = createUserData();
}
return userData;
}
/**
* This method notifies the ProgressUpdateListeners that there was an
* update in the installation progress.
* @param ratio the integer that specifies which percentage of the whole
* installation has been completed.
*/
}
/**
* This method notifies the ProgressUpdateListeners that there was an
* update in the installation progress.
* @param ratio the integer that specifies which percentage of the whole
* installation has been completed.
*/
null);
}
/**
* This method notifies the ProgressUpdateListeners that there was an
* update in the installation progress.
* @param ratio the integer that specifies which percentage of
* the whole installation has been completed.
* @param currentPhaseSummary the localized summary message for the
* current installation progress in formatted form.
* @param newLogDetail the new log messages that we have for the
* installation in formatted form.
*/
{
if (notifyListeners)
{
}
}
/**
* This method notifies the ProgressUpdateListeners that there was an
* update in the installation progress.
* @param ratio the integer that specifies which percentage of
* the whole installation has been completed.
* @param newLogDetail the localized additional log message.
*/
}
/**
* Sets the formatter this instance should use to used
* to format progress messages.
* @param formatter ProgressMessageFormatter for formatting
* progress messages
*/
this.listenerDelegate = new ProgressUpdateListenerDelegate();
}
/**
* Gets the formatter this instance is currently using.
* @return the progress message formatter currently used by this
* application
*/
return formatter;
}
/**
* Returns the formatted representation of the text that is the summary of the
* installation process (the one that goes in the UI next to the progress
* bar).
* @param text the source text from which we want to get the formatted
* representation
* @return the formatted representation of an error for the given text.
*/
{
}
/**
* Returns the formatted representation of an error for a given text.
* @param text the source text from which we want to get the formatted
* representation
* @return the formatted representation of an error for the given text.
*/
{
}
/**
* Returns the formatted representation of an warning for a given text.
* @param text the source text from which we want to get the formatted
* representation
* @return the formatted representation of an warning for the given text.
*/
{
}
/**
* Returns the formatted representation of a success message for a given text.
* @param text the source text from which we want to get the formatted
* representation
* @return the formatted representation of an success message for the given
* text.
*/
{
}
/**
* Returns the formatted representation of a log error message for a given
* text.
* @param text the source text from which we want to get the formatted
* representation
* @return the formatted representation of a log error message for the given
* text.
*/
{
}
/**
* Returns the formatted representation of a log message for a given text.
* @param text the source text from which we want to get the formatted
* representation
* @return the formatted representation of a log message for the given text.
*/
{
}
/**
* Returns the formatted representation of the 'Done' text string.
* @return the formatted representation of the 'Done' text string.
*/
public LocalizableMessage getFormattedDone()
{
}
/**
* Returns the formatted representation of the 'Done' text string
* with a line break at the end.
* @return the formatted representation of the 'Done' text string.
*/
public LocalizableMessage getFormattedDoneWithLineBreak() {
}
/**
* Returns the formatted representation of the argument text to which we add
* points. For instance if we pass as argument 'Configuring Server' the
* return value will be 'Configuring Server .....'.
* @param text the String to which add points.
* @return the formatted representation of the '.....' text string.
*/
{
}
/**
* Returns the formatted representation of a progress message for a given
* text.
* @param text the source text from which we want to get the formatted
* representation
* @return the formatted representation of a progress message for the given
* text.
*/
{
}
/**
* Returns the formatted representation of a progress message for a given
* text with a line break.
* @param text the source text from which we want to get the formatted
* representation
* @return the formatted representation of a progress message for the given
* text.
*/
{
}
/**
* Returns the formatted representation of an error message for a given
* exception.
* This method applies a margin if the applyMargin parameter is
* <CODE>true</CODE>.
* @param t the exception.
* @param applyMargin specifies whether we apply a margin or not to the
* resulting formatted text.
* @return the formatted representation of an error message for the given
* exception.
*/
{
}
/**
* Returns the line break formatted.
* @return the line break formatted.
*/
public LocalizableMessage getLineBreak()
{
return formatter.getLineBreak();
}
/**
* Returns the task separator formatted.
* @return the task separator formatted.
*/
protected LocalizableMessage getTaskSeparator()
{
return formatter.getTaskSeparator();
}
/**
* This method is called when a new log message has been received. It will
* notify the ProgressUpdateListeners of this fact.
* @param newLogDetail the new log detail.
*/
{
}
/**
* Returns the installation path.
* @return the installation path.
*/
public abstract String getInstallationPath();
/**
* Returns the instance path.
* @return the instance path.
*/
public abstract String getInstancePath();
/**
* Gets the current step.
* @return ProgressStep representing the current step
*/
public abstract ProgressStep getCurrentProgressStep();
/**
* Gets an integer representing the amount of processing
* this application still needs to perform as a ratio
* out of 100.
* @param step ProgressStop for which a summary is needed
* @return ProgressStep representing the current step
*/
/**
* Gets an i18n'd string representing the summary of
* a give ProgressStep.
* @param step ProgressStop for which a summary is needed
* @return String representing the summary
*/
/**
* Sets the current install status for this application.
* @param installStatus for the current installation.
*/
this.installStatus = installStatus;
}
/**
* Returns whether the installer has finished or not.
* @return <CODE>true</CODE> if the install is finished or <CODE>false
* </CODE> if not.
*/
public abstract boolean isFinished();
/**
* Returns the trust manager that can be used to establish secure connections.
* @return the trust manager that can be used to establish secure connections.
*/
public ApplicationTrustManager getTrustManager()
{
if (trustManager == null)
{
{
try
{
}
catch (Throwable t)
{
}
}
else
{
}
}
return trustManager;
}
/**
* Indicates whether or not this application is capable of cancelling
* the operation performed in the run method. A cancellable operation
* should leave its environment in the same state as it was prior to
* running the operation (files deleted, changes backed out etc.).
*
* Marking an <code>Application</code> as cancellable may control UI
* elements like the presense of a cancel button while the operation
* is being performed.
*
* Applications marked as cancellable should override the
* <code>cancel</code> method in such a way as to undo whatever
* actions have taken place in the run method up to that point.
*
* @return boolean where true inidcates that the operation is cancellable
*/
public abstract boolean isCancellable();
/**
* Signals that the application should cancel a currently running
* operation as soon as possible and return the environment to the
* state prior to running the operation. When finished backing
* out changes the application should make sure that <code>isFinished</code>
* returns true so that the application can complete.
*/
public abstract void cancel();
/**
* Checks whether the operation has been aborted. If it has throws an
* ApplicationException. All the applications that support abort must
* provide their implementation as the default implementation is empty.
*
* @throws ApplicationException thrown if the application was aborted.
*/
public void checkAbort() throws ApplicationException
{
}
/**
* Conditionally notifies listeners of the log file if it
* has been initialized.
*/
protected void notifyListenersOfLog() {
}
}
/**
* Conditionally notifies listeners of the log file if it
* has been initialized.
*/
protected void notifyListenersOfLogAfterError() {
}
}
/**
* Returns a localized representation of a TopologyCacheException object.
* @param e the exception we want to obtain the representation from.
* @return a localized representation of a TopologyCacheException object.
*/
{
return Utils.getMessage(e);
}
/**
* Gets an InitialLdapContext based on the information that appears on the
* provided ServerDescriptor object. Note that the server is assumed to be
* registered and that contains a Map with ADSContext.ServerProperty keys.
* @param server the object describing the server.
* @param trustManager the trust manager to be used to establish the
* connection.
* @param dn the dn to be used to authenticate.
* @param pwd the pwd to be used to authenticate.
* @param timeout the timeout to establish the connection in milliseconds.
* Use {@code 0} to express no timeout.
* @param cnx the ordered list of preferred connections to connect to the
* server.
* @return the InitialLdapContext to the remote server.
* @throws ApplicationException if something goes wrong.
*/
int timeout,
throws ApplicationException
{
filter.setSearchMonitoringInformation(false);
filter.setSearchBaseDNInformation(false);
try
{
}
catch (NamingException ne)
{
if (isCertificateException(ne))
{
}
else
{
}
ne);
}
return ctx;
}
/**
* Returns <CODE>true</CODE> if the application is running in verbose mode and
* <CODE>false</CODE> otherwise.
* @return <CODE>true</CODE> if the application is running in verbose mode and
* <CODE>false</CODE> otherwise.
*/
public boolean isVerbose()
{
return getUserData().isVerbose();
}
/**
* Returns the error stream to be used by the application when launching
* command lines.
* @return the error stream to be used by the application when launching
* command lines.
*/
{
return err;
}
/**
* Returns the output stream to be used by the application when launching
* command lines.
* @return the output stream to be used by the application when launching
* command lines.
*/
{
return out;
}
/**
* Tells whether we must notify the listeners or not of the message
* received.
* @param notifyListeners the boolean that informs of whether we have
* to notify the listeners or not.
*/
public void setNotifyListeners(boolean notifyListeners)
{
this.notifyListeners = notifyListeners;
}
/**
* Method that is invoked by the printstreams with the messages received
* on operations such as start or import. This is done so that the
* application can parse this messages and display them.
* @param message the message that has been received
*/
{
}
/**
* This class is used to notify the ProgressUpdateListeners of events
* that are written to the standard error. It is used in OfflineInstaller.
* These classes just create a ErrorPrintStream and
* then they do a call to System.err with it.
*
* The class just reads what is written to the standard error, obtains an
* formatted representation of it and then notifies the
* ProgressUpdateListeners with the formatted messages.
*
*/
public class ErrorPrintStream extends ApplicationPrintStream {
/**
* Default constructor.
*
*/
public ErrorPrintStream() {
super();
}
/** {@inheritDoc} */
}
}
/**
* This class is used to notify the ProgressUpdateListeners of events
* that are written to the standard output. It is used in WebStartInstaller
* and in OfflineInstaller. These classes just create a OutputPrintStream and
* then they do a call to System.out with it.
*
* The class just reads what is written to the standard output, obtains an
* formatted representation of it and then notifies the
* ProgressUpdateListeners with the formatted messages.
*
*/
public class OutputPrintStream extends ApplicationPrintStream
{
/**
* Default constructor.
*
*/
public OutputPrintStream() {
super();
}
/** {@inheritDoc} */
}
}
/**
* This class is used to notify the ProgressUpdateListeners of events
* that are written to the standard streams.
*/
protected abstract class ApplicationPrintStream extends PrintStream {
private boolean isFirstLine;
/**
* Format a string before sending a listener notification.
* @param string to format
* @return formatted message
*/
/**
* Default constructor.
*
*/
public ApplicationPrintStream()
{
super(new ByteArrayOutputStream(), true);
isFirstLine = true;
}
/** {@inheritDoc} */
{
{
}
isFirstLine = false;
}
/** {@inheritDoc} */
{
if (b == null)
{
throw new NullPointerException("b is null");
}
{
throw new IndexOutOfBoundsException(
"len + off are bigger than the length of the byte array");
}
}
}
/**
* Class used to add points periodically to the end of the logs.
*/
protected class PointAdder implements Runnable
{
private Thread t;
private boolean stopPointAdder;
private boolean pointAdderStopped;
/**
* Default constructor.
*/
public PointAdder()
{
}
/**
* Starts the PointAdder: points are added at the end of the logs
* periodically.
*/
public void start()
{
for (int i=0; i< 5; i++)
{
}
t = new Thread(this);
t.start();
}
/**
* Stops the PointAdder: points are no longer added at the end of the logs
* periodically.
*/
public synchronized void stop()
{
stopPointAdder = true;
while (!pointAdderStopped)
{
try
{
t.interrupt();
// To allow the thread to set the boolean.
}
catch (Throwable t)
{
// do nothing
}
}
}
/** {@inheritDoc} */
public void run()
{
while (!stopPointAdder)
{
try
{
}
catch (Throwable t)
{
// do nothing
}
}
pointAdderStopped = true;
}
}
}