mirror of https://github.com/OpenIdentityPlatform/OpenDJ.git

lutoff
10.00.2007 d805a36cc67fa38d11eda2f09f661ba21c6add70
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
/*
 * 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 2007 Sun Microsystems, Inc.
 */
 
package org.opends.quicksetup;
 
import org.opends.quicksetup.util.ProgressMessageFormatter;
import org.opends.quicksetup.util.PlainTextProgressMessageFormatter;
import org.opends.quicksetup.util.Utils;
import org.opends.quicksetup.event.ProgressUpdateListener;
import org.opends.quicksetup.event.ProgressUpdateEvent;
import org.opends.quicksetup.i18n.ResourceProvider;
 
/**
 * Controller for managing the execution of a CliApplication.
 */
public class QuickSetupCli {
 
  /**
   * Return code: Application successful.
   */
  static public int SUCCESSFUL = 0;
 
  /**
   * Return code: User Cancelled uninstall.
   */
  static public int CANCELLED = 1;
 
  /**
   * Return code: User provided invalid data.
   */
  static public int USER_DATA_ERROR = 2;
 
  /**
   * Return code: Error accessing file system (reading/writing).
   */
  static public int ERROR_ACCESSING_FILE_SYSTEM = 3;
 
  /**
   * Return code: Error stopping server.
   */
  static public int ERROR_STOPPING_SERVER = 4;
 
  /**
   * Return code: Bug.
   */
  static public int BUG = 5;
 
  /**
   * Return code: Bug.
   */
  static public int PRINT_VERSION = 50;
 
  /**
   * Return code for errors that are non-specified.
   */
  static public int UNKNOWN = 100;
 
  /** Arguments passed in the command line. */
  protected String[] args;
 
  private CliApplication cliApp;
 
  /**
   * Creates a QuickSetupCli instance.
   * @param cliApp the application to be run
   * @param args arguments passed in from the command line
   */
  public QuickSetupCli(CliApplication cliApp, String[] args) {
    this.cliApp = cliApp;
    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.
   */
  public int run()
  {
    int returnValue;
    // Parse the arguments
    try
    {
      CurrentInstallStatus installStatus = new CurrentInstallStatus();
      UserData userData = cliApp.createUserData(args, installStatus);
      if (userData != null)
      {
        ProgressMessageFormatter formatter =
                new PlainTextProgressMessageFormatter();
        cliApp.setUserData(userData);
        cliApp.setProgressMessageFormatter(formatter);
        if (!userData.isSilent()) {
          cliApp.addProgressUpdateListener(
              new ProgressUpdateListener()
              {
                /**
                 * ProgressUpdateListener implementation.
                 * @param ev the ProgressUpdateEvent we receive.
                 *
                 */
                public void progressUpdate(ProgressUpdateEvent ev)
                {
                  System.out.print(
                          org.opends.server.util.StaticUtils.wrapText(
                                  ev.getNewLogs(),
                                  Utils.getCommandLineMaxLineWidth()));
                }
              });
        }
        new Thread(cliApp).start();
        while (!cliApp.isFinished())
        {
          try
          {
            Thread.sleep(100);
          }
          catch (Exception ex)
          {
            // do nothing;
          }
        }
 
        ApplicationException ue = cliApp.getException();
        if (ue != null)
        {
          ApplicationException.Type type = ue.getType();
          if (type != null) {
            switch (type)
            {
            case FILE_SYSTEM_ERROR:
              returnValue = ERROR_ACCESSING_FILE_SYSTEM;
              break;
 
            case STOP_ERROR:
              returnValue = ERROR_STOPPING_SERVER;
              break;
 
            case BUG:
              returnValue = BUG;
              break;
 
            default:
              returnValue = UNKNOWN;
              break;
            }
          } else {
            returnValue = UNKNOWN;
          }
        }
        else
        {
          returnValue = SUCCESSFUL;
        }
      }
      else
      {
        // User cancelled installation.
        returnValue = CANCELLED;
      }
    }
    catch (UserDataException uude)
    {
      System.err.println(Constants.LINE_SEPARATOR+uude.getLocalizedMessage()+
          Constants.LINE_SEPARATOR);
      returnValue = USER_DATA_ERROR;
    }
    return returnValue;
  }
 
  /**
   * The following three methods are just commodity methods to get localized
   * messages.
   * @param key String key
   * @return String message
   */
  protected static String getMsg(String key)
  {
    return org.opends.server.util.StaticUtils.wrapText(getI18n().getMsg(key),
        Utils.getCommandLineMaxLineWidth());
  }
 
  /**
   * The following three methods are just commodity methods to get localized
   * messages.
   * @param key String key
   * @param args String[] args
   * @return String message
   */
  protected 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();
  }
}