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

boli
26.31.2007 f8ef0eed366445c5a341dbcc7882a7104c1cac1b
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
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
/*
 * 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-2007 Sun Microsystems, Inc.
 */
package org.opends.server.messages;
 
 
 
import static org.opends.server.messages.MessageHandler.*;
 
 
 
/**
 * This class defines the set of message IDs and default format strings for
 * messages associated with the tools.
 */
public class TaskMessages
{
  /**
   * The message ID of the message that will be used if a backend could not be
   * enabled.
   */
  public static final int MSGID_TASK_CANNOT_ENABLE_BACKEND =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 1;
 
 
 
  /**
   * The message ID of the message that will be used if a backend could not be
   * disabled.
   */
  public static final int MSGID_TASK_CANNOT_DISABLE_BACKEND =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 2;
 
 
 
  /**
   * The message ID for the shutdown message that will be used if the Directory
   * Server shutdown process is initiated by a task that does not include its
   * own shutdown message.
   */
  public static final int MSGID_TASK_SHUTDOWN_DEFAULT_MESSAGE =
       CATEGORY_MASK_TASK | SEVERITY_MASK_INFORMATIONAL | 3;
 
 
 
  /**
   * The message ID for the shutdown message that will be used if the Directory
   * Server shutdown process is initiated by a task that contains a custom
   * shutdown message.
   */
  public static final int MSGID_TASK_SHUTDOWN_CUSTOM_MESSAGE =
       CATEGORY_MASK_TASK | SEVERITY_MASK_INFORMATIONAL | 4;
 
 
 
  /**
   * The message ID for the shutdown message that will be used if no schema file
   * names were provided.  This takes two arguments, which are the name of the
   * attribute and the DN of the entry in which the file names should have been
   * given.
   */
  public static final int MSGID_TASK_ADDSCHEMAFILE_NO_FILENAME =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 5;
 
 
 
  /**
   * The message ID for the shutdown message that will be used if a specified
   * schema file does not exist in the schema directory.  This takes two
   * arguments, which are the name of the schema file and the path to the schema
   * directory.
   */
  public static final int MSGID_TASK_ADDSCHEMAFILE_NO_SUCH_FILE =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 6;
 
 
 
  /**
   * The message ID for the shutdown message that will be used if an error
   * occurs while attempting to check for the existence of a schema file in the
   * schema directory.  This takes three arguments, which are the name of the
   * file, the path to the schema directory, and a string representation of the
   * exception that was caught.
   */
  public static final int MSGID_TASK_ADDSCHEMAFILE_ERROR_CHECKING_FOR_FILE =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 7;
 
 
 
  /**
   * The message ID for the shutdown message that will be used if an error
   * occurs while trying to read and load the contents of a schema file into the
   * server schema.  This takes two arguments, which are the name of the schema
   * file and a message explaining the problem that occurred.
   */
  public static final int MSGID_TASK_ADDSCHEMAFILE_ERROR_LOADING_SCHEMA_FILE =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 8;
 
 
 
  /**
   * The message ID for the message that will be used if the server is unable to
   * obtain a write lock on the server schema.  This takes a single argument,
   * which is the DN of the schema entry.
   */
  public static final int MSGID_TASK_ADDSCHEMAFILE_CANNOT_LOCK_SCHEMA =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 9;
 
 
 
  /**
   * The message ID for the message that will be used an attempt is made to
   * invoke the add schema file task by a user that does not have the required
   * privileges.  This does not take any arguments.
   */
  public static final int MSGID_TASK_ADDSCHEMAFILE_INSUFFICIENT_PRIVILEGES =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 10;
 
 
 
  /**
   * The message ID for the message that will be used an attempt is made to
   * invoke the backend backup task by a user that does not have the required
   * privileges.  This does not take any arguments.
   */
  public static final int MSGID_TASK_BACKUP_INSUFFICIENT_PRIVILEGES =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 11;
 
 
 
  /**
   * The message ID for the message that will be used an attempt is made to
   * invoke the backend restore task by a user that does not have the required
   * privileges.  This does not take any arguments.
   */
  public static final int MSGID_TASK_RESTORE_INSUFFICIENT_PRIVILEGES =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 12;
 
 
 
  /**
   * The message ID for the message that will be used an attempt is made to
   * invoke the LDIF import task by a user that does not have the required
   * privileges.  This does not take any arguments.
   */
  public static final int MSGID_TASK_LDIFIMPORT_INSUFFICIENT_PRIVILEGES =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 13;
 
 
 
  /**
   * The message ID for the message that will be used an attempt is made to
   * invoke the LDIF export task by a user that does not have the required
   * privileges.  This does not take any arguments.
   */
  public static final int MSGID_TASK_LDIFEXPORT_INSUFFICIENT_PRIVILEGES =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 14;
 
 
 
  /**
   * The message ID for the message that will be used an attempt is made to
   * invoke the server shutdown task to restart the server by a user that does
   * not have the required privileges.  This does not take any arguments.
   */
  public static final int MSGID_TASK_SHUTDOWN_INSUFFICIENT_RESTART_PRIVILEGES =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 15;
 
 
 
  /**
   * The message ID for the message that will be used an attempt is made to
   * invoke the server shutdown task to shut down the server by a user that does
   * not have the required privileges.  This does not take any arguments.
   */
  public static final int MSGID_TASK_SHUTDOWN_INSUFFICIENT_SHUTDOWN_PRIVILEGES =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 16;
 
 
 
  /**
   * The message ID for the shutdown message that will be used if an error
   * occurs while trying to notify a synchronization provider about the new
   * schema elements added to the server.  This takes two arguments, which are
   * the name of the synchronization provider class and a string representation
   * of the exception that was caught.
   */
  public static final int MSGID_TASK_ADDSCHEMAFILE_CANNOT_NOTIFY_SYNC_PROVIDER =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 17;
 
  /**
   * The message ID for the message that will be used an attempt is made to
   * invoke the index rebuild task by a user that does not have the required
   * privileges.  This does not take any arguments.
   */
  public static final int MSGID_TASK_INDEXREBUILD_INSUFFICIENT_PRIVILEGES =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 18;
 
  /**
   * The message ID for the message that will be used when an invalid domain
   * base DN is provided as argument to the initialize target task.
   */
  public static final int  MSGID_TASK_INITIALIZE_TARGET_INVALID_DN =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 19;
 
  /**
   * The message ID for the message that will be used when an invalid domain
   * base DN is provided as argument to the initialize task.
   */
  public static final int  MSGID_TASK_INITIALIZE_INVALID_DN =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 20;
 
 
 
  /**
   * The message ID for the message that will be used if a nonroot user attempts
   * to place the server in lockdown mode.  It does not take any arguments.
   */
  public static final int  MSGID_TASK_ENTERLOCKDOWN_NOT_ROOT =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 21;
 
 
 
  /**
   * The message ID for the message that will be used if a client not connected
   * via a loopback address attempts to place the server in lockdown mode.  It
   * does not take any arguments.
   */
  public static final int  MSGID_TASK_ENTERLOCKDOWN_NOT_LOOPBACK =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 22;
 
 
 
  /**
   * The message ID for the message that will be used if a nonroot user attempts
   * to remove the server from lockdown mode.  It does not take any arguments.
   */
  public static final int  MSGID_TASK_LEAVELOCKDOWN_NOT_ROOT =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 23;
 
 
 
  /**
   * The message ID for the message that will be used if a client not connected
   * via a loopback address attempts to remove the server from lockdown mode.
   * It does not take any arguments.
   */
  public static final int  MSGID_TASK_LEAVELOCKDOWN_NOT_LOOPBACK =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 24;
 
 
 
  /**
   * Associates a set of generic messages with the message IDs defined in this
   * class.
   */
  public static void registerMessages()
  {
    registerMessage(MSGID_TASK_CANNOT_ENABLE_BACKEND,
                    "The task could not enable a backend: %s");
    registerMessage(MSGID_TASK_CANNOT_DISABLE_BACKEND,
                    "The task could not disable a backend: %s");
 
 
    registerMessage(MSGID_TASK_SHUTDOWN_DEFAULT_MESSAGE,
                    "The Directory Server shutdown process has been " +
                    "initiated by task %s");
    registerMessage(MSGID_TASK_SHUTDOWN_CUSTOM_MESSAGE,
                    "The Directory Server shutdown process has been " +
                    "initiated by task %s:  %s");
    registerMessage(MSGID_TASK_SHUTDOWN_INSUFFICIENT_RESTART_PRIVILEGES,
                    "You do not have sufficient privileges to initiate a " +
                    "Directory Server restart");
    registerMessage(MSGID_TASK_SHUTDOWN_INSUFFICIENT_SHUTDOWN_PRIVILEGES,
                    "You do not have sufficient privileges to initiate a " +
                    "Directory Server shutdown");
 
 
    registerMessage(MSGID_TASK_ADDSCHEMAFILE_INSUFFICIENT_PRIVILEGES,
                    "You do not have sufficient privileges to modify the " +
                    "server schema");
    registerMessage(MSGID_TASK_ADDSCHEMAFILE_NO_FILENAME,
                    "Unable to add one or more files to the server schema " +
                    "because no schema file names were provided in " +
                    "attribute %s of task entry %s");
    registerMessage(MSGID_TASK_ADDSCHEMAFILE_NO_SUCH_FILE,
                    "Unable to add one or more files to the server schema " +
                    "because the specified schema file %s does not exist in " +
                    "schema directory %s");
    registerMessage(MSGID_TASK_ADDSCHEMAFILE_ERROR_CHECKING_FOR_FILE,
                    "Unable to add one or more files to the server schema " +
                    "because an error occurred while attempting to determine " +
                    "whether file %s exists in schema directory %s:  %s");
    registerMessage(MSGID_TASK_ADDSCHEMAFILE_ERROR_LOADING_SCHEMA_FILE,
                    "An error occurred while attempting to load the contents " +
                    "of schema file %s into the server schema:  %s");
    registerMessage(MSGID_TASK_ADDSCHEMAFILE_CANNOT_NOTIFY_SYNC_PROVIDER,
                    "An error occurred while attempting to notify a " +
                    "synchronization provider of type %s about the schema " +
                    "changes made by the add schema file task:  %s");
    registerMessage(MSGID_TASK_ADDSCHEMAFILE_CANNOT_LOCK_SCHEMA,
                    "Unable to add one or more files to the server schema " +
                    "because the server was unable to obtain a write lock on " +
                    "the schema entry %s after multiple attempts");
 
 
    registerMessage(MSGID_TASK_BACKUP_INSUFFICIENT_PRIVILEGES,
                    "You do not have sufficient privileges to initiate a " +
                    "Directory Server backup");
    registerMessage(MSGID_TASK_RESTORE_INSUFFICIENT_PRIVILEGES,
                    "You do not have sufficient privileges to initiate a " +
                    "Directory Server restore");
    registerMessage(MSGID_TASK_LDIFIMPORT_INSUFFICIENT_PRIVILEGES,
                    "You do not have sufficient privileges to initiate an " +
                    "LDIF import");
    registerMessage(MSGID_TASK_LDIFEXPORT_INSUFFICIENT_PRIVILEGES,
                    "You do not have sufficient privileges to initiate an " +
                    "LDIF export");
    registerMessage(MSGID_TASK_INDEXREBUILD_INSUFFICIENT_PRIVILEGES,
                    "You do not have sufficient privileges to initiate an " +
                    "index rebuild");
 
    registerMessage(MSGID_TASK_INITIALIZE_TARGET_INVALID_DN,
                    "Invalid DN provided with the Initialize Target task");
 
    registerMessage(MSGID_TASK_INITIALIZE_INVALID_DN,
                    "Invalid DN provided with the Initialize task");
 
 
    registerMessage(MSGID_TASK_ENTERLOCKDOWN_NOT_ROOT,
                    "Only root users may place the server in lockdown mode");
    registerMessage(MSGID_TASK_ENTERLOCKDOWN_NOT_LOOPBACK,
                    "Only root users connected from a loopback address may " +
                    "place the server in lockdown mode");
 
    registerMessage(MSGID_TASK_LEAVELOCKDOWN_NOT_ROOT,
                    "Only root users may cause the server to leave lockdown " +
                    "mode");
    registerMessage(MSGID_TASK_LEAVELOCKDOWN_NOT_LOOPBACK,
                    "Only root users connected from a loopback address may " +
                    "cause the server to leave lockdown mode");
  }
}