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

boli
09.57.2007 7ba39a6c06cd5ff7ae7ab0295a11f49703a6e859
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
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
/*
 * 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;
 
 
 
  /**
   * The message ID for the message that will be used if the client does not
   * have the DISCONNECT_CLIENT privilege.  It does not take any arguments.
   */
  public static final int  MSGID_TASK_DISCONNECT_NO_PRIVILEGE =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 25;
 
 
 
  /**
   * The message ID for the message that will be used if the provided connection
   * ID cannot be decoded.  This takes a single argument, which is the invalid
   * value.
   */
  public static final int  MSGID_TASK_DISCONNECT_INVALID_CONN_ID =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 26;
 
 
 
  /**
   * The message ID for the message that will be used if the task entry does
   * not specify a target connection ID.  This takes a single argument, which is
   * the name of the attribute type used to specify the target connection ID.
   */
  public static final int  MSGID_TASK_DISCONNECT_NO_CONN_ID =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 27;
 
 
 
  /**
   * The message ID for the message that will be used if the notifyClient
   * attribute value cannot be decoded.  This takes a single argument, which is
   * the invalid value.
   */
  public static final int  MSGID_TASK_DISCONNECT_INVALID_NOTIFY_CLIENT =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 28;
 
 
 
  /**
   * The message ID for the message that will be used as a generic message that
   * may be sent to the client if no other value is given.  It does not take
   * any arguments.
   */
  public static final int  MSGID_TASK_DISCONNECT_GENERIC_MESSAGE =
       CATEGORY_MASK_TASK | SEVERITY_MASK_INFORMATIONAL | 29;
 
 
 
  /**
   * The message ID for the message that will be used if no client connection
   * can be found with the specified connection ID.  It takes a single argument,
   * which is the target connection ID.
   */
  public static final int  MSGID_TASK_DISCONNECT_NO_SUCH_CONNECTION =
       CATEGORY_MASK_TASK | SEVERITY_MASK_SEVERE_ERROR | 30;
 
 
 
  /**
   * The message ID for the message that will be used as the message ID for the
   * disconnectClient method.  The associated message will be defined, but it
   * will not actually be used, since only the message ID is needed.  It does
   * not take any arguments.
   */
  public static final int  MSGID_TASK_DISCONNECT_MESSAGE =
       CATEGORY_MASK_TASK | SEVERITY_MASK_INFORMATIONAL | 31;
 
 
 
  /**
   * 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");
 
 
    registerMessage(MSGID_TASK_DISCONNECT_NO_PRIVILEGE,
                    "You do not have sufficient privileges to terminate " +
                    "client connections");
    registerMessage(MSGID_TASK_DISCONNECT_INVALID_CONN_ID,
                    "Unable to decode value %s as an integer connection ID");
    registerMessage(MSGID_TASK_DISCONNECT_NO_CONN_ID,
                    "Attribute %s must be provided to specify the connection " +
                    "ID for the client to disconnect");
    registerMessage(MSGID_TASK_DISCONNECT_INVALID_NOTIFY_CLIENT,
                    "Unable to decode value %s as an indication of whether " +
                    "to notify the client before disconnecting it.  The " +
                    "provided value should be either 'true' or 'false'");
    registerMessage(MSGID_TASK_DISCONNECT_GENERIC_MESSAGE,
                    "An administrator has terminated this client connection");
    registerMessage(MSGID_TASK_DISCONNECT_NO_SUCH_CONNECTION,
                    "There is no client connection with connection ID %s");
    registerMessage(MSGID_TASK_DISCONNECT_MESSAGE,
                    "An administrator has terminated this client connection");
  }
}