Application.java revision b369c17aec493f598a0fefe8885418cd3db596e9
/*
* 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
* 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 2007 Sun Microsystems, Inc.
*/
/**
* This class represents an application that can be run in the context of
* QuickSetup. Examples of applications might be 'installer', 'uninstaller'
* and 'upgrader'.
*/
/** Represents current install state. */
protected CurrentInstallStatus installStatus;
private Installation installation;
private ServerController serverController;
private ApplicationTrustManager trustManager;
/** 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
*/
static public GuiApplication create()
throws RuntimeException {
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 OpenDS 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) {
}
}
return installation;
}
/**
* Sets the application's installation.
* @param installation describing the application's OpenDS installation
*/
this.installation = installation;
}
/**
* Gets a server controller for use by this application.
* @return ServerController that can be used to start and stop the server.
*/
public ServerController getServerController() {
if (serverController == null) {
serverController = new ServerController(this);
}
return serverController;
}
/**
* 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 ratioWhenCompleted 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.
* @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.
*/
{
}
/**
* 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.
*/
}
/**
* Sets the formatter this instance should use to used
* to format progress messages.
* @param formatter ProgressMessageFormatter for formatting
* progress messages
*/
}
/**
* 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 text string 'Error' with a line break at the end.
* @return formatted 'Error'
*/
protected Message getFormattedErrorWithLineBreak() {
}
/**
* 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 error message for a given
* exception.
* This method applies a margin if the applyMargin parameter is
* <CODE>true</CODE>.
* @param m the exception.
* @param b 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 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 b 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 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 Message 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 Message 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 formatted representation of an error message for a given
* exception.
* This method applies a margin if the applyMargin parameter is
* <CODE>true</CODE>.
* @param m the message.
* @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 Message getLineBreak()
{
return formatter.getLineBreak();
}
/**
* Returns the task separator formatted.
* @return the task separator formatted.
*/
protected Message 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();
/**
* 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.
*/
abstract public 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.
*/
protected ApplicationTrustManager getTrustManager()
{
if (trustManager == null)
{
}
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
*/
abstract public 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.
*/
abstract public void cancel();
/**
* Makes available a <code>UserInteraction</code> class that can be used
* by the application to interact with the user. If the user has requested
* a quiet session this method returns null.
* @return UserInteraction object
*/
public UserInteraction userInteraction() {
// Note: overridden in GuiApplication
if (!getUserData().isQuiet()) {
ui = new CliUserInteraction();
}
return ui;
}
/**
* Conditionally notifies listeners of the log file if it
* has been initialized.
*/
protected void notifyListenersOfLog() {
}
}
/**
* Writes an initial record in the installation's historical
* log describing moving from one version to another.
* @param fromVersion from with install will be migrated
* @param toVersion to which install will be migrated
* @return Long ID for this session
* @throws ApplicationException if something goes wrong
*/
protected Long writeInitialHistoricalRecord(
throws ApplicationException {
try {
} catch (IOException e) {
msg, e);
}
return id;
}
/**
* Writes a record into this installation's historical log.
* @param id obtained from calling <code>writeInitialHistoricalRecord</code>
* @param from version from with install will be migrated
* @param to version to which install will be migrated
* @param status of the operation
* @param note string with additional information
* @throws ApplicationException if something goes wrong
* @see {@link #writeInitialHistoricalRecord(BuildInformation,
BuildInformation)}
*/
protected void writeHistoricalRecord(
throws ApplicationException {
try {
} catch (IOException e) {
}
}
/**
* 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.
* @return the InitialLdapContext to the remote server.
* @throws ApplicationException if something goes wrong.
*/
throws ApplicationException
{
try
{
}
catch (NamingException ne)
{
throw new ApplicationException(
ne);
}
return ctx;
}
/**
* This class is used to notify the ProgressUpdateListeners of events
* that are written to the standard error. It is used in WebStartInstaller
* and 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.
*
*/
protected class ErrorPrintStream extends ApplicationPrintStream {
/**
* {@inheritDoc}
*/
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.
*
*/
protected class OutputPrintStream extends ApplicationPrintStream
{
/**
* {@inheritDoc}
*/
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}
*/
{
if (isFirstLine)
{
} else
{
}
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");
}
}
}
}