001 /*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License"). You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2008 Sun Microsystems, Inc.
026 */
027 package org.opends.server.admin.std.meta;
028
029
030
031 import java.util.Collection;
032 import java.util.SortedSet;
033 import org.opends.server.admin.AdministratorAction;
034 import org.opends.server.admin.AggregationPropertyDefinition;
035 import org.opends.server.admin.AliasDefaultBehaviorProvider;
036 import org.opends.server.admin.BooleanPropertyDefinition;
037 import org.opends.server.admin.client.AuthorizationException;
038 import org.opends.server.admin.client.CommunicationException;
039 import org.opends.server.admin.client.ConcurrentModificationException;
040 import org.opends.server.admin.client.ManagedObject;
041 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
042 import org.opends.server.admin.client.OperationRejectedException;
043 import org.opends.server.admin.DefaultBehaviorProvider;
044 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
045 import org.opends.server.admin.DurationPropertyDefinition;
046 import org.opends.server.admin.EnumPropertyDefinition;
047 import org.opends.server.admin.IntegerPropertyDefinition;
048 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
049 import org.opends.server.admin.ManagedObjectDefinition;
050 import org.opends.server.admin.PropertyOption;
051 import org.opends.server.admin.PropertyProvider;
052 import org.opends.server.admin.server.ConfigurationChangeListener;
053 import org.opends.server.admin.server.ServerManagedObject;
054 import org.opends.server.admin.std.client.GlobalCfgClient;
055 import org.opends.server.admin.std.client.IdentityMapperCfgClient;
056 import org.opends.server.admin.std.client.PasswordPolicyCfgClient;
057 import org.opends.server.admin.std.server.GlobalCfg;
058 import org.opends.server.admin.std.server.IdentityMapperCfg;
059 import org.opends.server.admin.std.server.PasswordPolicyCfg;
060 import org.opends.server.admin.StringPropertyDefinition;
061 import org.opends.server.admin.Tag;
062 import org.opends.server.admin.TopCfgDefn;
063 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
064 import org.opends.server.types.DN;
065
066
067
068 /**
069 * An interface for querying the Global Configuration managed object
070 * definition meta information.
071 * <p>
072 * The Global Configuration contains properties that affect the
073 * overall operation of the OpenDS Directory Server .
074 */
075 public final class GlobalCfgDefn extends ManagedObjectDefinition<GlobalCfgClient, GlobalCfg> {
076
077 // The singleton configuration definition instance.
078 private static final GlobalCfgDefn INSTANCE = new GlobalCfgDefn();
079
080
081
082 /**
083 * Defines the set of permissable values for the "disabled-privilege" property.
084 * <p>
085 * Specifies the name of a privilege that should not be evaluated by
086 * the server.
087 * <p>
088 * If a privilege is disabled, then it is assumed that all clients
089 * (including unauthenticated clients) have that privilege.
090 */
091 public static enum DisabledPrivilege {
092
093 /**
094 * Allows the user to request that the server process backup
095 * tasks.
096 */
097 BACKEND_BACKUP("backend-backup"),
098
099
100
101 /**
102 * Allows the user to request that the server process restore
103 * tasks.
104 */
105 BACKEND_RESTORE("backend-restore"),
106
107
108
109 /**
110 * Allows the associated user to bypass access control checks
111 * performed by the server.
112 */
113 BYPASS_ACL("bypass-acl"),
114
115
116
117 /**
118 * Allows the user to cancel operations in progress on other
119 * client connections.
120 */
121 CANCEL_REQUEST("cancel-request"),
122
123
124
125 /**
126 * Allows the associated user to read the server configuration.
127 */
128 CONFIG_READ("config-read"),
129
130
131
132 /**
133 * Allows the associated user to update the server configuration.
134 * The config-read privilege is also required.
135 */
136 CONFIG_WRITE("config-write"),
137
138
139
140 /**
141 * Allows the user to participate in data synchronization.
142 */
143 DATA_SYNC("data-sync"),
144
145
146
147 /**
148 * Allows the user to terminate other client connections.
149 */
150 DISCONNECT_CLIENT("disconnect-client"),
151
152
153
154 /**
155 * Allows the associated user to subscribe to receive JMX
156 * notifications.
157 */
158 JMX_NOTIFY("jmx-notify"),
159
160
161
162 /**
163 * Allows the associated user to perform JMX read operations.
164 */
165 JMX_READ("jmx-read"),
166
167
168
169 /**
170 * Allows the associated user to perform JMX write operations.
171 */
172 JMX_WRITE("jmx-write"),
173
174
175
176 /**
177 * Allows the user to request that the server process LDIF export
178 * tasks.
179 */
180 LDIF_EXPORT("ldif-export"),
181
182
183
184 /**
185 * Allows the user to request that the server process LDIF import
186 * tasks.
187 */
188 LDIF_IMPORT("ldif-import"),
189
190
191
192 /**
193 * Allows the associated user to modify the server's access
194 * control configuration.
195 */
196 MODIFY_ACL("modify-acl"),
197
198
199
200 /**
201 * Allows the user to reset user passwords.
202 */
203 PASSWORD_RESET("password-reset"),
204
205
206
207 /**
208 * Allows the user to make changes to the set of defined root
209 * privileges, as well as to grant and revoke privileges for users.
210 */
211 PRIVILEGE_CHANGE("privilege-change"),
212
213
214
215 /**
216 * Allows the user to use the proxied authorization control, or to
217 * perform a bind that specifies an alternate authorization
218 * identity.
219 */
220 PROXIED_AUTH("proxied-auth"),
221
222
223
224 /**
225 * Allows the user to request that the server perform an in-core
226 * restart.
227 */
228 SERVER_RESTART("server-restart"),
229
230
231
232 /**
233 * Allows the user to request that the server shut down.
234 */
235 SERVER_SHUTDOWN("server-shutdown"),
236
237
238
239 /**
240 * Allows the user to request that the server process a search
241 * that cannot be optimized using server indexes.
242 */
243 UNINDEXED_SEARCH("unindexed-search"),
244
245
246
247 /**
248 * Allows the user to make changes to the server schema.
249 */
250 UPDATE_SCHEMA("update-schema");
251
252
253
254 // String representation of the value.
255 private final String name;
256
257
258
259 // Private constructor.
260 private DisabledPrivilege(String name) { this.name = name; }
261
262
263
264 /**
265 * {@inheritDoc}
266 */
267 public String toString() { return name; }
268
269 }
270
271
272
273 /**
274 * Defines the set of permissable values for the "etime-resolution" property.
275 * <p>
276 * Specifies the resolution to use for operation elapsed processing
277 * time (etime) measurements.
278 */
279 public static enum EtimeResolution {
280
281 /**
282 * Use millisecond resolution.
283 */
284 MILLISECONDS("milliseconds"),
285
286
287
288 /**
289 * Use nanosecond resolution.
290 */
291 NANOSECONDS("nanoseconds");
292
293
294
295 // String representation of the value.
296 private final String name;
297
298
299
300 // Private constructor.
301 private EtimeResolution(String name) { this.name = name; }
302
303
304
305 /**
306 * {@inheritDoc}
307 */
308 public String toString() { return name; }
309
310 }
311
312
313
314 /**
315 * Defines the set of permissable values for the "invalid-attribute-syntax-behavior" property.
316 * <p>
317 * Specifies how the Directory Server should handle operations
318 * whenever an attribute value violates the associated attribute
319 * syntax.
320 */
321 public static enum InvalidAttributeSyntaxBehavior {
322
323 /**
324 * The Directory Server silently accepts attribute values that are
325 * invalid according to their associated syntax. Matching
326 * operations targeting those values may not behave as expected.
327 */
328 ACCEPT("accept"),
329
330
331
332 /**
333 * The Directory Server rejects attribute values that are invalid
334 * according to their associated syntax.
335 */
336 REJECT("reject"),
337
338
339
340 /**
341 * The Directory Server accepts attribute values that are invalid
342 * according to their associated syntax, but also logs a warning
343 * message to the error log. Matching operations targeting those
344 * values may not behave as expected.
345 */
346 WARN("warn");
347
348
349
350 // String representation of the value.
351 private final String name;
352
353
354
355 // Private constructor.
356 private InvalidAttributeSyntaxBehavior(String name) { this.name = name; }
357
358
359
360 /**
361 * {@inheritDoc}
362 */
363 public String toString() { return name; }
364
365 }
366
367
368
369 /**
370 * Defines the set of permissable values for the "single-structural-objectclass-behavior" property.
371 * <p>
372 * Specifies how the Directory Server should handle operations an
373 * entry does not contain a structural object class or contains
374 * multiple structural classes.
375 */
376 public static enum SingleStructuralObjectclassBehavior {
377
378 /**
379 * The Directory Server silently accepts entries that do not
380 * contain exactly one structural object class. Certain schema
381 * features that depend on the entry's structural class may not
382 * behave as expected.
383 */
384 ACCEPT("accept"),
385
386
387
388 /**
389 * The Directory Server rejects entries that do not contain
390 * exactly one structural object class.
391 */
392 REJECT("reject"),
393
394
395
396 /**
397 * The Directory Server accepts entries that do not contain
398 * exactly one structural object class, but also logs a warning
399 * message to the error log. Certain schema features that depend on
400 * the entry's structural class may not behave as expected.
401 */
402 WARN("warn");
403
404
405
406 // String representation of the value.
407 private final String name;
408
409
410
411 // Private constructor.
412 private SingleStructuralObjectclassBehavior(String name) { this.name = name; }
413
414
415
416 /**
417 * {@inheritDoc}
418 */
419 public String toString() { return name; }
420
421 }
422
423
424
425 /**
426 * Defines the set of permissable values for the "workflow-configuration-mode" property.
427 * <p>
428 * Specifies the workflow configuration mode (auto vs. manual).
429 */
430 public static enum WorkflowConfigurationMode {
431
432 /**
433 * In the "auto" configuration mode, there is no workflow
434 * configuration. The workflows are created automatically based on
435 * the backend configuration. There is one workflow per backend
436 * base DN.
437 */
438 AUTO("auto"),
439
440
441
442 /**
443 * In the "manual" configuration mode, each workflow is created
444 * according to its description in the configuration.
445 */
446 MANUAL("manual");
447
448
449
450 // String representation of the value.
451 private final String name;
452
453
454
455 // Private constructor.
456 private WorkflowConfigurationMode(String name) { this.name = name; }
457
458
459
460 /**
461 * {@inheritDoc}
462 */
463 public String toString() { return name; }
464
465 }
466
467
468
469 /**
470 * Defines the set of permissable values for the "writability-mode" property.
471 * <p>
472 * Specifies the kinds of write operations the Directory Server can
473 * process.
474 */
475 public static enum WritabilityMode {
476
477 /**
478 * The Directory Server rejects all write operations that are
479 * requested of it, regardless of their origin.
480 */
481 DISABLED("disabled"),
482
483
484
485 /**
486 * The Directory Server attempts to process all write operations
487 * that are requested of it, regardless of their origin.
488 */
489 ENABLED("enabled"),
490
491
492
493 /**
494 * The Directory Server attempts to process write operations
495 * requested as internal operations or through synchronization, but
496 * rejects any such operations requested from external clients.
497 */
498 INTERNAL_ONLY("internal-only");
499
500
501
502 // String representation of the value.
503 private final String name;
504
505
506
507 // Private constructor.
508 private WritabilityMode(String name) { this.name = name; }
509
510
511
512 /**
513 * {@inheritDoc}
514 */
515 public String toString() { return name; }
516
517 }
518
519
520
521 // The "add-missing-rdn-attributes" property definition.
522 private static final BooleanPropertyDefinition PD_ADD_MISSING_RDN_ATTRIBUTES;
523
524
525
526 // The "allow-attribute-name-exceptions" property definition.
527 private static final BooleanPropertyDefinition PD_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS;
528
529
530
531 // The "allowed-task" property definition.
532 private static final StringPropertyDefinition PD_ALLOWED_TASK;
533
534
535
536 // The "bind-with-dn-requires-password" property definition.
537 private static final BooleanPropertyDefinition PD_BIND_WITH_DN_REQUIRES_PASSWORD;
538
539
540
541 // The "check-schema" property definition.
542 private static final BooleanPropertyDefinition PD_CHECK_SCHEMA;
543
544
545
546 // The "default-password-policy" property definition.
547 private static final AggregationPropertyDefinition<PasswordPolicyCfgClient, PasswordPolicyCfg> PD_DEFAULT_PASSWORD_POLICY;
548
549
550
551 // The "disabled-privilege" property definition.
552 private static final EnumPropertyDefinition<DisabledPrivilege> PD_DISABLED_PRIVILEGE;
553
554
555
556 // The "entry-cache-preload" property definition.
557 private static final BooleanPropertyDefinition PD_ENTRY_CACHE_PRELOAD;
558
559
560
561 // The "etime-resolution" property definition.
562 private static final EnumPropertyDefinition<EtimeResolution> PD_ETIME_RESOLUTION;
563
564
565
566 // The "idle-time-limit" property definition.
567 private static final DurationPropertyDefinition PD_IDLE_TIME_LIMIT;
568
569
570
571 // The "invalid-attribute-syntax-behavior" property definition.
572 private static final EnumPropertyDefinition<InvalidAttributeSyntaxBehavior> PD_INVALID_ATTRIBUTE_SYNTAX_BEHAVIOR;
573
574
575
576 // The "lookthrough-limit" property definition.
577 private static final IntegerPropertyDefinition PD_LOOKTHROUGH_LIMIT;
578
579
580
581 // The "notify-abandoned-operations" property definition.
582 private static final BooleanPropertyDefinition PD_NOTIFY_ABANDONED_OPERATIONS;
583
584
585
586 // The "proxied-authorization-identity-mapper" property definition.
587 private static final AggregationPropertyDefinition<IdentityMapperCfgClient, IdentityMapperCfg> PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER;
588
589
590
591 // The "reject-unauthenticated-requests" property definition.
592 private static final BooleanPropertyDefinition PD_REJECT_UNAUTHENTICATED_REQUESTS;
593
594
595
596 // The "return-bind-error-messages" property definition.
597 private static final BooleanPropertyDefinition PD_RETURN_BIND_ERROR_MESSAGES;
598
599
600
601 // The "save-config-on-successful-startup" property definition.
602 private static final BooleanPropertyDefinition PD_SAVE_CONFIG_ON_SUCCESSFUL_STARTUP;
603
604
605
606 // The "server-error-result-code" property definition.
607 private static final IntegerPropertyDefinition PD_SERVER_ERROR_RESULT_CODE;
608
609
610
611 // The "single-structural-objectclass-behavior" property definition.
612 private static final EnumPropertyDefinition<SingleStructuralObjectclassBehavior> PD_SINGLE_STRUCTURAL_OBJECTCLASS_BEHAVIOR;
613
614
615
616 // The "size-limit" property definition.
617 private static final IntegerPropertyDefinition PD_SIZE_LIMIT;
618
619
620
621 // The "smtp-server" property definition.
622 private static final StringPropertyDefinition PD_SMTP_SERVER;
623
624
625
626 // The "time-limit" property definition.
627 private static final DurationPropertyDefinition PD_TIME_LIMIT;
628
629
630
631 // The "workflow-configuration-mode" property definition.
632 private static final EnumPropertyDefinition<WorkflowConfigurationMode> PD_WORKFLOW_CONFIGURATION_MODE;
633
634
635
636 // The "writability-mode" property definition.
637 private static final EnumPropertyDefinition<WritabilityMode> PD_WRITABILITY_MODE;
638
639
640
641 // Build the "add-missing-rdn-attributes" property definition.
642 static {
643 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "add-missing-rdn-attributes");
644 builder.setOption(PropertyOption.ADVANCED);
645 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "add-missing-rdn-attributes"));
646 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
647 builder.setDefaultBehaviorProvider(provider);
648 PD_ADD_MISSING_RDN_ATTRIBUTES = builder.getInstance();
649 INSTANCE.registerPropertyDefinition(PD_ADD_MISSING_RDN_ATTRIBUTES);
650 }
651
652
653
654 // Build the "allow-attribute-name-exceptions" property definition.
655 static {
656 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "allow-attribute-name-exceptions");
657 builder.setOption(PropertyOption.ADVANCED);
658 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allow-attribute-name-exceptions"));
659 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
660 builder.setDefaultBehaviorProvider(provider);
661 PD_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS = builder.getInstance();
662 INSTANCE.registerPropertyDefinition(PD_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS);
663 }
664
665
666
667 // Build the "allowed-task" property definition.
668 static {
669 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "allowed-task");
670 builder.setOption(PropertyOption.MULTI_VALUED);
671 builder.setOption(PropertyOption.ADVANCED);
672 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allowed-task"));
673 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "allowed-task"));
674 PD_ALLOWED_TASK = builder.getInstance();
675 INSTANCE.registerPropertyDefinition(PD_ALLOWED_TASK);
676 }
677
678
679
680 // Build the "bind-with-dn-requires-password" property definition.
681 static {
682 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "bind-with-dn-requires-password");
683 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "bind-with-dn-requires-password"));
684 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
685 builder.setDefaultBehaviorProvider(provider);
686 PD_BIND_WITH_DN_REQUIRES_PASSWORD = builder.getInstance();
687 INSTANCE.registerPropertyDefinition(PD_BIND_WITH_DN_REQUIRES_PASSWORD);
688 }
689
690
691
692 // Build the "check-schema" property definition.
693 static {
694 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "check-schema");
695 builder.setOption(PropertyOption.ADVANCED);
696 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "check-schema"));
697 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
698 builder.setDefaultBehaviorProvider(provider);
699 PD_CHECK_SCHEMA = builder.getInstance();
700 INSTANCE.registerPropertyDefinition(PD_CHECK_SCHEMA);
701 }
702
703
704
705 // Build the "default-password-policy" property definition.
706 static {
707 AggregationPropertyDefinition.Builder<PasswordPolicyCfgClient, PasswordPolicyCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "default-password-policy");
708 builder.setOption(PropertyOption.MANDATORY);
709 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-password-policy"));
710 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
711 builder.setParentPath("/");
712 builder.setRelationDefinition("password-policy");
713 PD_DEFAULT_PASSWORD_POLICY = builder.getInstance();
714 INSTANCE.registerPropertyDefinition(PD_DEFAULT_PASSWORD_POLICY);
715 INSTANCE.registerConstraint(PD_DEFAULT_PASSWORD_POLICY.getSourceConstraint());
716 }
717
718
719
720 // Build the "disabled-privilege" property definition.
721 static {
722 EnumPropertyDefinition.Builder<DisabledPrivilege> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "disabled-privilege");
723 builder.setOption(PropertyOption.MULTI_VALUED);
724 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disabled-privilege"));
725 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DisabledPrivilege>(INSTANCE, "disabled-privilege"));
726 builder.setEnumClass(DisabledPrivilege.class);
727 PD_DISABLED_PRIVILEGE = builder.getInstance();
728 INSTANCE.registerPropertyDefinition(PD_DISABLED_PRIVILEGE);
729 }
730
731
732
733 // Build the "entry-cache-preload" property definition.
734 static {
735 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "entry-cache-preload");
736 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.SERVER_RESTART, INSTANCE, "entry-cache-preload"));
737 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
738 builder.setDefaultBehaviorProvider(provider);
739 PD_ENTRY_CACHE_PRELOAD = builder.getInstance();
740 INSTANCE.registerPropertyDefinition(PD_ENTRY_CACHE_PRELOAD);
741 }
742
743
744
745 // Build the "etime-resolution" property definition.
746 static {
747 EnumPropertyDefinition.Builder<EtimeResolution> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "etime-resolution");
748 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "etime-resolution"));
749 DefaultBehaviorProvider<EtimeResolution> provider = new DefinedDefaultBehaviorProvider<EtimeResolution>("milliseconds");
750 builder.setDefaultBehaviorProvider(provider);
751 builder.setEnumClass(EtimeResolution.class);
752 PD_ETIME_RESOLUTION = builder.getInstance();
753 INSTANCE.registerPropertyDefinition(PD_ETIME_RESOLUTION);
754 }
755
756
757
758 // Build the "idle-time-limit" property definition.
759 static {
760 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "idle-time-limit");
761 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "idle-time-limit"));
762 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0 seconds");
763 builder.setDefaultBehaviorProvider(provider);
764 builder.setBaseUnit("ms");
765 builder.setLowerLimit("0");
766 PD_IDLE_TIME_LIMIT = builder.getInstance();
767 INSTANCE.registerPropertyDefinition(PD_IDLE_TIME_LIMIT);
768 }
769
770
771
772 // Build the "invalid-attribute-syntax-behavior" property definition.
773 static {
774 EnumPropertyDefinition.Builder<InvalidAttributeSyntaxBehavior> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "invalid-attribute-syntax-behavior");
775 builder.setOption(PropertyOption.ADVANCED);
776 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "invalid-attribute-syntax-behavior"));
777 DefaultBehaviorProvider<InvalidAttributeSyntaxBehavior> provider = new DefinedDefaultBehaviorProvider<InvalidAttributeSyntaxBehavior>("reject");
778 builder.setDefaultBehaviorProvider(provider);
779 builder.setEnumClass(InvalidAttributeSyntaxBehavior.class);
780 PD_INVALID_ATTRIBUTE_SYNTAX_BEHAVIOR = builder.getInstance();
781 INSTANCE.registerPropertyDefinition(PD_INVALID_ATTRIBUTE_SYNTAX_BEHAVIOR);
782 }
783
784
785
786 // Build the "lookthrough-limit" property definition.
787 static {
788 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "lookthrough-limit");
789 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "lookthrough-limit"));
790 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("5000");
791 builder.setDefaultBehaviorProvider(provider);
792 builder.setLowerLimit(0);
793 PD_LOOKTHROUGH_LIMIT = builder.getInstance();
794 INSTANCE.registerPropertyDefinition(PD_LOOKTHROUGH_LIMIT);
795 }
796
797
798
799 // Build the "notify-abandoned-operations" property definition.
800 static {
801 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "notify-abandoned-operations");
802 builder.setOption(PropertyOption.ADVANCED);
803 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "notify-abandoned-operations"));
804 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
805 builder.setDefaultBehaviorProvider(provider);
806 PD_NOTIFY_ABANDONED_OPERATIONS = builder.getInstance();
807 INSTANCE.registerPropertyDefinition(PD_NOTIFY_ABANDONED_OPERATIONS);
808 }
809
810
811
812 // Build the "proxied-authorization-identity-mapper" property definition.
813 static {
814 AggregationPropertyDefinition.Builder<IdentityMapperCfgClient, IdentityMapperCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "proxied-authorization-identity-mapper");
815 builder.setOption(PropertyOption.MANDATORY);
816 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "proxied-authorization-identity-mapper"));
817 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
818 builder.setParentPath("/");
819 builder.setRelationDefinition("identity-mapper");
820 PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER = builder.getInstance();
821 INSTANCE.registerPropertyDefinition(PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER);
822 INSTANCE.registerConstraint(PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER.getSourceConstraint());
823 }
824
825
826
827 // Build the "reject-unauthenticated-requests" property definition.
828 static {
829 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "reject-unauthenticated-requests");
830 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "reject-unauthenticated-requests"));
831 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
832 builder.setDefaultBehaviorProvider(provider);
833 PD_REJECT_UNAUTHENTICATED_REQUESTS = builder.getInstance();
834 INSTANCE.registerPropertyDefinition(PD_REJECT_UNAUTHENTICATED_REQUESTS);
835 }
836
837
838
839 // Build the "return-bind-error-messages" property definition.
840 static {
841 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "return-bind-error-messages");
842 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "return-bind-error-messages"));
843 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
844 builder.setDefaultBehaviorProvider(provider);
845 PD_RETURN_BIND_ERROR_MESSAGES = builder.getInstance();
846 INSTANCE.registerPropertyDefinition(PD_RETURN_BIND_ERROR_MESSAGES);
847 }
848
849
850
851 // Build the "save-config-on-successful-startup" property definition.
852 static {
853 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "save-config-on-successful-startup");
854 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "save-config-on-successful-startup"));
855 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
856 builder.setDefaultBehaviorProvider(provider);
857 PD_SAVE_CONFIG_ON_SUCCESSFUL_STARTUP = builder.getInstance();
858 INSTANCE.registerPropertyDefinition(PD_SAVE_CONFIG_ON_SUCCESSFUL_STARTUP);
859 }
860
861
862
863 // Build the "server-error-result-code" property definition.
864 static {
865 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "server-error-result-code");
866 builder.setOption(PropertyOption.ADVANCED);
867 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "server-error-result-code"));
868 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("80");
869 builder.setDefaultBehaviorProvider(provider);
870 builder.setLowerLimit(0);
871 PD_SERVER_ERROR_RESULT_CODE = builder.getInstance();
872 INSTANCE.registerPropertyDefinition(PD_SERVER_ERROR_RESULT_CODE);
873 }
874
875
876
877 // Build the "single-structural-objectclass-behavior" property definition.
878 static {
879 EnumPropertyDefinition.Builder<SingleStructuralObjectclassBehavior> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "single-structural-objectclass-behavior");
880 builder.setOption(PropertyOption.ADVANCED);
881 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "single-structural-objectclass-behavior"));
882 DefaultBehaviorProvider<SingleStructuralObjectclassBehavior> provider = new DefinedDefaultBehaviorProvider<SingleStructuralObjectclassBehavior>("reject");
883 builder.setDefaultBehaviorProvider(provider);
884 builder.setEnumClass(SingleStructuralObjectclassBehavior.class);
885 PD_SINGLE_STRUCTURAL_OBJECTCLASS_BEHAVIOR = builder.getInstance();
886 INSTANCE.registerPropertyDefinition(PD_SINGLE_STRUCTURAL_OBJECTCLASS_BEHAVIOR);
887 }
888
889
890
891 // Build the "size-limit" property definition.
892 static {
893 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "size-limit");
894 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "size-limit"));
895 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("1000");
896 builder.setDefaultBehaviorProvider(provider);
897 builder.setLowerLimit(0);
898 PD_SIZE_LIMIT = builder.getInstance();
899 INSTANCE.registerPropertyDefinition(PD_SIZE_LIMIT);
900 }
901
902
903
904 // Build the "smtp-server" property definition.
905 static {
906 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "smtp-server");
907 builder.setOption(PropertyOption.MULTI_VALUED);
908 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "smtp-server"));
909 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "smtp-server"));
910 builder.setPattern("^.+(:[0-9]+)?$", "HOST[:PORT]");
911 PD_SMTP_SERVER = builder.getInstance();
912 INSTANCE.registerPropertyDefinition(PD_SMTP_SERVER);
913 }
914
915
916
917 // Build the "time-limit" property definition.
918 static {
919 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "time-limit");
920 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "time-limit"));
921 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("60 seconds");
922 builder.setDefaultBehaviorProvider(provider);
923 builder.setBaseUnit("s");
924 builder.setLowerLimit("0");
925 PD_TIME_LIMIT = builder.getInstance();
926 INSTANCE.registerPropertyDefinition(PD_TIME_LIMIT);
927 }
928
929
930
931 // Build the "workflow-configuration-mode" property definition.
932 static {
933 EnumPropertyDefinition.Builder<WorkflowConfigurationMode> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "workflow-configuration-mode");
934 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "workflow-configuration-mode"));
935 DefaultBehaviorProvider<WorkflowConfigurationMode> provider = new DefinedDefaultBehaviorProvider<WorkflowConfigurationMode>("auto");
936 builder.setDefaultBehaviorProvider(provider);
937 builder.setEnumClass(WorkflowConfigurationMode.class);
938 PD_WORKFLOW_CONFIGURATION_MODE = builder.getInstance();
939 INSTANCE.registerPropertyDefinition(PD_WORKFLOW_CONFIGURATION_MODE);
940 }
941
942
943
944 // Build the "writability-mode" property definition.
945 static {
946 EnumPropertyDefinition.Builder<WritabilityMode> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "writability-mode");
947 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "writability-mode"));
948 DefaultBehaviorProvider<WritabilityMode> provider = new DefinedDefaultBehaviorProvider<WritabilityMode>("enabled");
949 builder.setDefaultBehaviorProvider(provider);
950 builder.setEnumClass(WritabilityMode.class);
951 PD_WRITABILITY_MODE = builder.getInstance();
952 INSTANCE.registerPropertyDefinition(PD_WRITABILITY_MODE);
953 }
954
955
956
957 // Register the tags associated with this managed object definition.
958 static {
959 INSTANCE.registerTag(Tag.valueOf("core-server"));
960 }
961
962
963
964 /**
965 * Get the Global Configuration configuration definition singleton.
966 *
967 * @return Returns the Global Configuration configuration definition
968 * singleton.
969 */
970 public static GlobalCfgDefn getInstance() {
971 return INSTANCE;
972 }
973
974
975
976 /**
977 * Private constructor.
978 */
979 private GlobalCfgDefn() {
980 super("global", TopCfgDefn.getInstance());
981 }
982
983
984
985 /**
986 * {@inheritDoc}
987 */
988 public GlobalCfgClient createClientConfiguration(
989 ManagedObject<? extends GlobalCfgClient> impl) {
990 return new GlobalCfgClientImpl(impl);
991 }
992
993
994
995 /**
996 * {@inheritDoc}
997 */
998 public GlobalCfg createServerConfiguration(
999 ServerManagedObject<? extends GlobalCfg> impl) {
1000 return new GlobalCfgServerImpl(impl);
1001 }
1002
1003
1004
1005 /**
1006 * {@inheritDoc}
1007 */
1008 public Class<GlobalCfg> getServerConfigurationClass() {
1009 return GlobalCfg.class;
1010 }
1011
1012
1013
1014 /**
1015 * Get the "add-missing-rdn-attributes" property definition.
1016 * <p>
1017 * Indicates whether the Directory Server should automatically add
1018 * any attribute values contained in the entry's RDN into that entry
1019 * when processing an add request.
1020 *
1021 * @return Returns the "add-missing-rdn-attributes" property definition.
1022 */
1023 public BooleanPropertyDefinition getAddMissingRDNAttributesPropertyDefinition() {
1024 return PD_ADD_MISSING_RDN_ATTRIBUTES;
1025 }
1026
1027
1028
1029 /**
1030 * Get the "allow-attribute-name-exceptions" property definition.
1031 * <p>
1032 * Indicates whether the Directory Server should allow underscores
1033 * in attribute names and allow attribute names to begin with numeric
1034 * digits (both of which are violations of the LDAP standards).
1035 *
1036 * @return Returns the "allow-attribute-name-exceptions" property definition.
1037 */
1038 public BooleanPropertyDefinition getAllowAttributeNameExceptionsPropertyDefinition() {
1039 return PD_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS;
1040 }
1041
1042
1043
1044 /**
1045 * Get the "allowed-task" property definition.
1046 * <p>
1047 * Specifies the fully-qualified name of a Java class that may be
1048 * invoked in the server.
1049 * <p>
1050 * Any attempt to invoke a task not included in the list of allowed
1051 * tasks is rejected.
1052 *
1053 * @return Returns the "allowed-task" property definition.
1054 */
1055 public StringPropertyDefinition getAllowedTaskPropertyDefinition() {
1056 return PD_ALLOWED_TASK;
1057 }
1058
1059
1060
1061 /**
1062 * Get the "bind-with-dn-requires-password" property definition.
1063 * <p>
1064 * Indicates whether the Directory Server should reject any simple
1065 * bind request that contains a DN but no password.
1066 * <p>
1067 * Although such bind requests are technically allowed by the LDAPv3
1068 * specification (and should be treated as anonymous simple
1069 * authentication), they may introduce security problems in
1070 * applications that do not verify that the client actually provided
1071 * a password.
1072 *
1073 * @return Returns the "bind-with-dn-requires-password" property definition.
1074 */
1075 public BooleanPropertyDefinition getBindWithDNRequiresPasswordPropertyDefinition() {
1076 return PD_BIND_WITH_DN_REQUIRES_PASSWORD;
1077 }
1078
1079
1080
1081 /**
1082 * Get the "check-schema" property definition.
1083 * <p>
1084 * Indicates whether schema enforcement is active.
1085 * <p>
1086 * When schema enforcement is activated, the Directory Server
1087 * ensures that all operations result in entries are valid according
1088 * to the defined server schema. It is strongly recommended that this
1089 * option be left enabled to prevent the inadvertent addition of
1090 * invalid data into the server.
1091 *
1092 * @return Returns the "check-schema" property definition.
1093 */
1094 public BooleanPropertyDefinition getCheckSchemaPropertyDefinition() {
1095 return PD_CHECK_SCHEMA;
1096 }
1097
1098
1099
1100 /**
1101 * Get the "default-password-policy" property definition.
1102 * <p>
1103 * Specifies the name of the password policy that is in effect for
1104 * users whose entries do not specify an alternate password policy
1105 * (either via a real or virtual attribute).
1106 *
1107 * @return Returns the "default-password-policy" property definition.
1108 */
1109 public AggregationPropertyDefinition<PasswordPolicyCfgClient, PasswordPolicyCfg> getDefaultPasswordPolicyPropertyDefinition() {
1110 return PD_DEFAULT_PASSWORD_POLICY;
1111 }
1112
1113
1114
1115 /**
1116 * Get the "disabled-privilege" property definition.
1117 * <p>
1118 * Specifies the name of a privilege that should not be evaluated by
1119 * the server.
1120 * <p>
1121 * If a privilege is disabled, then it is assumed that all clients
1122 * (including unauthenticated clients) have that privilege.
1123 *
1124 * @return Returns the "disabled-privilege" property definition.
1125 */
1126 public EnumPropertyDefinition<DisabledPrivilege> getDisabledPrivilegePropertyDefinition() {
1127 return PD_DISABLED_PRIVILEGE;
1128 }
1129
1130
1131
1132 /**
1133 * Get the "entry-cache-preload" property definition.
1134 * <p>
1135 * Indicates whether or not to preload the entry cache on startup.
1136 *
1137 * @return Returns the "entry-cache-preload" property definition.
1138 */
1139 public BooleanPropertyDefinition getEntryCachePreloadPropertyDefinition() {
1140 return PD_ENTRY_CACHE_PRELOAD;
1141 }
1142
1143
1144
1145 /**
1146 * Get the "etime-resolution" property definition.
1147 * <p>
1148 * Specifies the resolution to use for operation elapsed processing
1149 * time (etime) measurements.
1150 *
1151 * @return Returns the "etime-resolution" property definition.
1152 */
1153 public EnumPropertyDefinition<EtimeResolution> getEtimeResolutionPropertyDefinition() {
1154 return PD_ETIME_RESOLUTION;
1155 }
1156
1157
1158
1159 /**
1160 * Get the "idle-time-limit" property definition.
1161 * <p>
1162 * Specifies the maximum length of time that a client connection may
1163 * remain established since its last completed operation.
1164 * <p>
1165 * A value of "0 seconds" indicates that no idle time limit is
1166 * enforced.
1167 *
1168 * @return Returns the "idle-time-limit" property definition.
1169 */
1170 public DurationPropertyDefinition getIdleTimeLimitPropertyDefinition() {
1171 return PD_IDLE_TIME_LIMIT;
1172 }
1173
1174
1175
1176 /**
1177 * Get the "invalid-attribute-syntax-behavior" property definition.
1178 * <p>
1179 * Specifies how the Directory Server should handle operations
1180 * whenever an attribute value violates the associated attribute
1181 * syntax.
1182 *
1183 * @return Returns the "invalid-attribute-syntax-behavior" property definition.
1184 */
1185 public EnumPropertyDefinition<InvalidAttributeSyntaxBehavior> getInvalidAttributeSyntaxBehaviorPropertyDefinition() {
1186 return PD_INVALID_ATTRIBUTE_SYNTAX_BEHAVIOR;
1187 }
1188
1189
1190
1191 /**
1192 * Get the "lookthrough-limit" property definition.
1193 * <p>
1194 * Specifies the maximum number of entries that the Directory Server
1195 * should "look through" in the course of processing a search
1196 * request.
1197 * <p>
1198 * This includes any entry that the server must examine in the
1199 * course of processing the request, regardless of whether it
1200 * actually matches the search criteria. A value of 0 indicates that
1201 * no lookthrough limit is enforced. Note that this is the default
1202 * server-wide limit, but it may be overridden on a per-user basis
1203 * using the ds-rlim-lookthrough-limit operational attribute.
1204 *
1205 * @return Returns the "lookthrough-limit" property definition.
1206 */
1207 public IntegerPropertyDefinition getLookthroughLimitPropertyDefinition() {
1208 return PD_LOOKTHROUGH_LIMIT;
1209 }
1210
1211
1212
1213 /**
1214 * Get the "notify-abandoned-operations" property definition.
1215 * <p>
1216 * Indicates whether the Directory Server should send a response to
1217 * any operation that is interrupted via an abandon request.
1218 * <p>
1219 * The LDAP specification states that abandoned operations should
1220 * not receive any response, but this may cause problems with client
1221 * applications that always expect to receive a response to each
1222 * request.
1223 *
1224 * @return Returns the "notify-abandoned-operations" property definition.
1225 */
1226 public BooleanPropertyDefinition getNotifyAbandonedOperationsPropertyDefinition() {
1227 return PD_NOTIFY_ABANDONED_OPERATIONS;
1228 }
1229
1230
1231
1232 /**
1233 * Get the "proxied-authorization-identity-mapper" property definition.
1234 * <p>
1235 * Specifies the name of the identity mapper to map authorization ID
1236 * values (using the "u:" form) provided in the proxied authorization
1237 * control to the corresponding user entry.
1238 *
1239 * @return Returns the "proxied-authorization-identity-mapper" property definition.
1240 */
1241 public AggregationPropertyDefinition<IdentityMapperCfgClient, IdentityMapperCfg> getProxiedAuthorizationIdentityMapperPropertyDefinition() {
1242 return PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER;
1243 }
1244
1245
1246
1247 /**
1248 * Get the "reject-unauthenticated-requests" property definition.
1249 * <p>
1250 * Indicates whether the Directory Server should reject any request
1251 * (other than bind or StartTLS requests) received from a client that
1252 * has not yet been authenticated, whose last authentication attempt
1253 * was unsuccessful, or whose last authentication attempt used
1254 * anonymous authentication.
1255 *
1256 * @return Returns the "reject-unauthenticated-requests" property definition.
1257 */
1258 public BooleanPropertyDefinition getRejectUnauthenticatedRequestsPropertyDefinition() {
1259 return PD_REJECT_UNAUTHENTICATED_REQUESTS;
1260 }
1261
1262
1263
1264 /**
1265 * Get the "return-bind-error-messages" property definition.
1266 * <p>
1267 * Indicates whether responses for failed bind operations should
1268 * include a message string providing the reason for the
1269 * authentication failure.
1270 * <p>
1271 * Note that these messages may include information that could
1272 * potentially be used by an attacker. If this option is disabled,
1273 * then these messages appears only in the server's access log.
1274 *
1275 * @return Returns the "return-bind-error-messages" property definition.
1276 */
1277 public BooleanPropertyDefinition getReturnBindErrorMessagesPropertyDefinition() {
1278 return PD_RETURN_BIND_ERROR_MESSAGES;
1279 }
1280
1281
1282
1283 /**
1284 * Get the "save-config-on-successful-startup" property definition.
1285 * <p>
1286 * Indicates whether the Directory Server should save a copy of its
1287 * configuration whenever the startup process completes successfully.
1288 * <p>
1289 * This ensures that the server provides a "last known good"
1290 * configuration, which can be used as a reference (or copied into
1291 * the active config) if the server fails to start with the current
1292 * "active" configuration.
1293 *
1294 * @return Returns the "save-config-on-successful-startup" property definition.
1295 */
1296 public BooleanPropertyDefinition getSaveConfigOnSuccessfulStartupPropertyDefinition() {
1297 return PD_SAVE_CONFIG_ON_SUCCESSFUL_STARTUP;
1298 }
1299
1300
1301
1302 /**
1303 * Get the "server-error-result-code" property definition.
1304 * <p>
1305 * Specifies the numeric value of the result code when request
1306 * processing fails due to an internal server error.
1307 *
1308 * @return Returns the "server-error-result-code" property definition.
1309 */
1310 public IntegerPropertyDefinition getServerErrorResultCodePropertyDefinition() {
1311 return PD_SERVER_ERROR_RESULT_CODE;
1312 }
1313
1314
1315
1316 /**
1317 * Get the "single-structural-objectclass-behavior" property definition.
1318 * <p>
1319 * Specifies how the Directory Server should handle operations an
1320 * entry does not contain a structural object class or contains
1321 * multiple structural classes.
1322 *
1323 * @return Returns the "single-structural-objectclass-behavior" property definition.
1324 */
1325 public EnumPropertyDefinition<SingleStructuralObjectclassBehavior> getSingleStructuralObjectclassBehaviorPropertyDefinition() {
1326 return PD_SINGLE_STRUCTURAL_OBJECTCLASS_BEHAVIOR;
1327 }
1328
1329
1330
1331 /**
1332 * Get the "size-limit" property definition.
1333 * <p>
1334 * Specifies the maximum number of entries that the Directory Server
1335 * should return to the client durin a search operation.
1336 * <p>
1337 * A value of 0 indicates that no size limit is enforced. Note that
1338 * this is the default server-wide limit, but it may be overridden on
1339 * a per-user basis using the ds-rlim-size-limit operational
1340 * attribute.
1341 *
1342 * @return Returns the "size-limit" property definition.
1343 */
1344 public IntegerPropertyDefinition getSizeLimitPropertyDefinition() {
1345 return PD_SIZE_LIMIT;
1346 }
1347
1348
1349
1350 /**
1351 * Get the "smtp-server" property definition.
1352 * <p>
1353 * Specifies the address (and optional port number) for a mail
1354 * server that can be used to send email messages via SMTP.
1355 * <p>
1356 * It may be an IP address or resolvable hostname, optionally
1357 * followed by a colon and a port number.
1358 *
1359 * @return Returns the "smtp-server" property definition.
1360 */
1361 public StringPropertyDefinition getSMTPServerPropertyDefinition() {
1362 return PD_SMTP_SERVER;
1363 }
1364
1365
1366
1367 /**
1368 * Get the "time-limit" property definition.
1369 * <p>
1370 * Specifies the maximum length of time that the Directory Server
1371 * should spend processing a search operation.
1372 * <p>
1373 * A value of 0 seconds indicates that no time limit is enforced.
1374 * Note that this is the default server-wide time limit, but it may
1375 * be overridden on a per-user basis using the ds-rlim-time-limit
1376 * operational attribute.
1377 *
1378 * @return Returns the "time-limit" property definition.
1379 */
1380 public DurationPropertyDefinition getTimeLimitPropertyDefinition() {
1381 return PD_TIME_LIMIT;
1382 }
1383
1384
1385
1386 /**
1387 * Get the "workflow-configuration-mode" property definition.
1388 * <p>
1389 * Specifies the workflow configuration mode (auto vs. manual).
1390 *
1391 * @return Returns the "workflow-configuration-mode" property definition.
1392 */
1393 public EnumPropertyDefinition<WorkflowConfigurationMode> getWorkflowConfigurationModePropertyDefinition() {
1394 return PD_WORKFLOW_CONFIGURATION_MODE;
1395 }
1396
1397
1398
1399 /**
1400 * Get the "writability-mode" property definition.
1401 * <p>
1402 * Specifies the kinds of write operations the Directory Server can
1403 * process.
1404 *
1405 * @return Returns the "writability-mode" property definition.
1406 */
1407 public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() {
1408 return PD_WRITABILITY_MODE;
1409 }
1410
1411
1412
1413 /**
1414 * Managed object client implementation.
1415 */
1416 private static class GlobalCfgClientImpl implements
1417 GlobalCfgClient {
1418
1419 // Private implementation.
1420 private ManagedObject<? extends GlobalCfgClient> impl;
1421
1422
1423
1424 // Private constructor.
1425 private GlobalCfgClientImpl(
1426 ManagedObject<? extends GlobalCfgClient> impl) {
1427 this.impl = impl;
1428 }
1429
1430
1431
1432 /**
1433 * {@inheritDoc}
1434 */
1435 public boolean isAddMissingRDNAttributes() {
1436 return impl.getPropertyValue(INSTANCE.getAddMissingRDNAttributesPropertyDefinition());
1437 }
1438
1439
1440
1441 /**
1442 * {@inheritDoc}
1443 */
1444 public void setAddMissingRDNAttributes(Boolean value) {
1445 impl.setPropertyValue(INSTANCE.getAddMissingRDNAttributesPropertyDefinition(), value);
1446 }
1447
1448
1449
1450 /**
1451 * {@inheritDoc}
1452 */
1453 public boolean isAllowAttributeNameExceptions() {
1454 return impl.getPropertyValue(INSTANCE.getAllowAttributeNameExceptionsPropertyDefinition());
1455 }
1456
1457
1458
1459 /**
1460 * {@inheritDoc}
1461 */
1462 public void setAllowAttributeNameExceptions(Boolean value) {
1463 impl.setPropertyValue(INSTANCE.getAllowAttributeNameExceptionsPropertyDefinition(), value);
1464 }
1465
1466
1467
1468 /**
1469 * {@inheritDoc}
1470 */
1471 public SortedSet<String> getAllowedTask() {
1472 return impl.getPropertyValues(INSTANCE.getAllowedTaskPropertyDefinition());
1473 }
1474
1475
1476
1477 /**
1478 * {@inheritDoc}
1479 */
1480 public void setAllowedTask(Collection<String> values) {
1481 impl.setPropertyValues(INSTANCE.getAllowedTaskPropertyDefinition(), values);
1482 }
1483
1484
1485
1486 /**
1487 * {@inheritDoc}
1488 */
1489 public boolean isBindWithDNRequiresPassword() {
1490 return impl.getPropertyValue(INSTANCE.getBindWithDNRequiresPasswordPropertyDefinition());
1491 }
1492
1493
1494
1495 /**
1496 * {@inheritDoc}
1497 */
1498 public void setBindWithDNRequiresPassword(Boolean value) {
1499 impl.setPropertyValue(INSTANCE.getBindWithDNRequiresPasswordPropertyDefinition(), value);
1500 }
1501
1502
1503
1504 /**
1505 * {@inheritDoc}
1506 */
1507 public boolean isCheckSchema() {
1508 return impl.getPropertyValue(INSTANCE.getCheckSchemaPropertyDefinition());
1509 }
1510
1511
1512
1513 /**
1514 * {@inheritDoc}
1515 */
1516 public void setCheckSchema(Boolean value) {
1517 impl.setPropertyValue(INSTANCE.getCheckSchemaPropertyDefinition(), value);
1518 }
1519
1520
1521
1522 /**
1523 * {@inheritDoc}
1524 */
1525 public String getDefaultPasswordPolicy() {
1526 return impl.getPropertyValue(INSTANCE.getDefaultPasswordPolicyPropertyDefinition());
1527 }
1528
1529
1530
1531 /**
1532 * {@inheritDoc}
1533 */
1534 public void setDefaultPasswordPolicy(String value) {
1535 impl.setPropertyValue(INSTANCE.getDefaultPasswordPolicyPropertyDefinition(), value);
1536 }
1537
1538
1539
1540 /**
1541 * {@inheritDoc}
1542 */
1543 public SortedSet<DisabledPrivilege> getDisabledPrivilege() {
1544 return impl.getPropertyValues(INSTANCE.getDisabledPrivilegePropertyDefinition());
1545 }
1546
1547
1548
1549 /**
1550 * {@inheritDoc}
1551 */
1552 public void setDisabledPrivilege(Collection<DisabledPrivilege> values) {
1553 impl.setPropertyValues(INSTANCE.getDisabledPrivilegePropertyDefinition(), values);
1554 }
1555
1556
1557
1558 /**
1559 * {@inheritDoc}
1560 */
1561 public boolean isEntryCachePreload() {
1562 return impl.getPropertyValue(INSTANCE.getEntryCachePreloadPropertyDefinition());
1563 }
1564
1565
1566
1567 /**
1568 * {@inheritDoc}
1569 */
1570 public void setEntryCachePreload(Boolean value) {
1571 impl.setPropertyValue(INSTANCE.getEntryCachePreloadPropertyDefinition(), value);
1572 }
1573
1574
1575
1576 /**
1577 * {@inheritDoc}
1578 */
1579 public EtimeResolution getEtimeResolution() {
1580 return impl.getPropertyValue(INSTANCE.getEtimeResolutionPropertyDefinition());
1581 }
1582
1583
1584
1585 /**
1586 * {@inheritDoc}
1587 */
1588 public void setEtimeResolution(EtimeResolution value) {
1589 impl.setPropertyValue(INSTANCE.getEtimeResolutionPropertyDefinition(), value);
1590 }
1591
1592
1593
1594 /**
1595 * {@inheritDoc}
1596 */
1597 public long getIdleTimeLimit() {
1598 return impl.getPropertyValue(INSTANCE.getIdleTimeLimitPropertyDefinition());
1599 }
1600
1601
1602
1603 /**
1604 * {@inheritDoc}
1605 */
1606 public void setIdleTimeLimit(Long value) {
1607 impl.setPropertyValue(INSTANCE.getIdleTimeLimitPropertyDefinition(), value);
1608 }
1609
1610
1611
1612 /**
1613 * {@inheritDoc}
1614 */
1615 public InvalidAttributeSyntaxBehavior getInvalidAttributeSyntaxBehavior() {
1616 return impl.getPropertyValue(INSTANCE.getInvalidAttributeSyntaxBehaviorPropertyDefinition());
1617 }
1618
1619
1620
1621 /**
1622 * {@inheritDoc}
1623 */
1624 public void setInvalidAttributeSyntaxBehavior(InvalidAttributeSyntaxBehavior value) {
1625 impl.setPropertyValue(INSTANCE.getInvalidAttributeSyntaxBehaviorPropertyDefinition(), value);
1626 }
1627
1628
1629
1630 /**
1631 * {@inheritDoc}
1632 */
1633 public int getLookthroughLimit() {
1634 return impl.getPropertyValue(INSTANCE.getLookthroughLimitPropertyDefinition());
1635 }
1636
1637
1638
1639 /**
1640 * {@inheritDoc}
1641 */
1642 public void setLookthroughLimit(Integer value) {
1643 impl.setPropertyValue(INSTANCE.getLookthroughLimitPropertyDefinition(), value);
1644 }
1645
1646
1647
1648 /**
1649 * {@inheritDoc}
1650 */
1651 public boolean isNotifyAbandonedOperations() {
1652 return impl.getPropertyValue(INSTANCE.getNotifyAbandonedOperationsPropertyDefinition());
1653 }
1654
1655
1656
1657 /**
1658 * {@inheritDoc}
1659 */
1660 public void setNotifyAbandonedOperations(Boolean value) {
1661 impl.setPropertyValue(INSTANCE.getNotifyAbandonedOperationsPropertyDefinition(), value);
1662 }
1663
1664
1665
1666 /**
1667 * {@inheritDoc}
1668 */
1669 public String getProxiedAuthorizationIdentityMapper() {
1670 return impl.getPropertyValue(INSTANCE.getProxiedAuthorizationIdentityMapperPropertyDefinition());
1671 }
1672
1673
1674
1675 /**
1676 * {@inheritDoc}
1677 */
1678 public void setProxiedAuthorizationIdentityMapper(String value) {
1679 impl.setPropertyValue(INSTANCE.getProxiedAuthorizationIdentityMapperPropertyDefinition(), value);
1680 }
1681
1682
1683
1684 /**
1685 * {@inheritDoc}
1686 */
1687 public boolean isRejectUnauthenticatedRequests() {
1688 return impl.getPropertyValue(INSTANCE.getRejectUnauthenticatedRequestsPropertyDefinition());
1689 }
1690
1691
1692
1693 /**
1694 * {@inheritDoc}
1695 */
1696 public void setRejectUnauthenticatedRequests(Boolean value) {
1697 impl.setPropertyValue(INSTANCE.getRejectUnauthenticatedRequestsPropertyDefinition(), value);
1698 }
1699
1700
1701
1702 /**
1703 * {@inheritDoc}
1704 */
1705 public boolean isReturnBindErrorMessages() {
1706 return impl.getPropertyValue(INSTANCE.getReturnBindErrorMessagesPropertyDefinition());
1707 }
1708
1709
1710
1711 /**
1712 * {@inheritDoc}
1713 */
1714 public void setReturnBindErrorMessages(Boolean value) {
1715 impl.setPropertyValue(INSTANCE.getReturnBindErrorMessagesPropertyDefinition(), value);
1716 }
1717
1718
1719
1720 /**
1721 * {@inheritDoc}
1722 */
1723 public boolean isSaveConfigOnSuccessfulStartup() {
1724 return impl.getPropertyValue(INSTANCE.getSaveConfigOnSuccessfulStartupPropertyDefinition());
1725 }
1726
1727
1728
1729 /**
1730 * {@inheritDoc}
1731 */
1732 public void setSaveConfigOnSuccessfulStartup(Boolean value) {
1733 impl.setPropertyValue(INSTANCE.getSaveConfigOnSuccessfulStartupPropertyDefinition(), value);
1734 }
1735
1736
1737
1738 /**
1739 * {@inheritDoc}
1740 */
1741 public int getServerErrorResultCode() {
1742 return impl.getPropertyValue(INSTANCE.getServerErrorResultCodePropertyDefinition());
1743 }
1744
1745
1746
1747 /**
1748 * {@inheritDoc}
1749 */
1750 public void setServerErrorResultCode(Integer value) {
1751 impl.setPropertyValue(INSTANCE.getServerErrorResultCodePropertyDefinition(), value);
1752 }
1753
1754
1755
1756 /**
1757 * {@inheritDoc}
1758 */
1759 public SingleStructuralObjectclassBehavior getSingleStructuralObjectclassBehavior() {
1760 return impl.getPropertyValue(INSTANCE.getSingleStructuralObjectclassBehaviorPropertyDefinition());
1761 }
1762
1763
1764
1765 /**
1766 * {@inheritDoc}
1767 */
1768 public void setSingleStructuralObjectclassBehavior(SingleStructuralObjectclassBehavior value) {
1769 impl.setPropertyValue(INSTANCE.getSingleStructuralObjectclassBehaviorPropertyDefinition(), value);
1770 }
1771
1772
1773
1774 /**
1775 * {@inheritDoc}
1776 */
1777 public int getSizeLimit() {
1778 return impl.getPropertyValue(INSTANCE.getSizeLimitPropertyDefinition());
1779 }
1780
1781
1782
1783 /**
1784 * {@inheritDoc}
1785 */
1786 public void setSizeLimit(Integer value) {
1787 impl.setPropertyValue(INSTANCE.getSizeLimitPropertyDefinition(), value);
1788 }
1789
1790
1791
1792 /**
1793 * {@inheritDoc}
1794 */
1795 public SortedSet<String> getSMTPServer() {
1796 return impl.getPropertyValues(INSTANCE.getSMTPServerPropertyDefinition());
1797 }
1798
1799
1800
1801 /**
1802 * {@inheritDoc}
1803 */
1804 public void setSMTPServer(Collection<String> values) {
1805 impl.setPropertyValues(INSTANCE.getSMTPServerPropertyDefinition(), values);
1806 }
1807
1808
1809
1810 /**
1811 * {@inheritDoc}
1812 */
1813 public long getTimeLimit() {
1814 return impl.getPropertyValue(INSTANCE.getTimeLimitPropertyDefinition());
1815 }
1816
1817
1818
1819 /**
1820 * {@inheritDoc}
1821 */
1822 public void setTimeLimit(Long value) {
1823 impl.setPropertyValue(INSTANCE.getTimeLimitPropertyDefinition(), value);
1824 }
1825
1826
1827
1828 /**
1829 * {@inheritDoc}
1830 */
1831 public WorkflowConfigurationMode getWorkflowConfigurationMode() {
1832 return impl.getPropertyValue(INSTANCE.getWorkflowConfigurationModePropertyDefinition());
1833 }
1834
1835
1836
1837 /**
1838 * {@inheritDoc}
1839 */
1840 public void setWorkflowConfigurationMode(WorkflowConfigurationMode value) {
1841 impl.setPropertyValue(INSTANCE.getWorkflowConfigurationModePropertyDefinition(), value);
1842 }
1843
1844
1845
1846 /**
1847 * {@inheritDoc}
1848 */
1849 public WritabilityMode getWritabilityMode() {
1850 return impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
1851 }
1852
1853
1854
1855 /**
1856 * {@inheritDoc}
1857 */
1858 public void setWritabilityMode(WritabilityMode value) {
1859 impl.setPropertyValue(INSTANCE.getWritabilityModePropertyDefinition(), value);
1860 }
1861
1862
1863
1864 /**
1865 * {@inheritDoc}
1866 */
1867 public ManagedObjectDefinition<? extends GlobalCfgClient, ? extends GlobalCfg> definition() {
1868 return INSTANCE;
1869 }
1870
1871
1872
1873 /**
1874 * {@inheritDoc}
1875 */
1876 public PropertyProvider properties() {
1877 return impl;
1878 }
1879
1880
1881
1882 /**
1883 * {@inheritDoc}
1884 */
1885 public void commit() throws ManagedObjectAlreadyExistsException,
1886 MissingMandatoryPropertiesException, ConcurrentModificationException,
1887 OperationRejectedException, AuthorizationException,
1888 CommunicationException {
1889 impl.commit();
1890 }
1891
1892 }
1893
1894
1895
1896 /**
1897 * Managed object server implementation.
1898 */
1899 private static class GlobalCfgServerImpl implements
1900 GlobalCfg {
1901
1902 // Private implementation.
1903 private ServerManagedObject<? extends GlobalCfg> impl;
1904
1905 // The value of the "add-missing-rdn-attributes" property.
1906 private final boolean pAddMissingRDNAttributes;
1907
1908 // The value of the "allow-attribute-name-exceptions" property.
1909 private final boolean pAllowAttributeNameExceptions;
1910
1911 // The value of the "allowed-task" property.
1912 private final SortedSet<String> pAllowedTask;
1913
1914 // The value of the "bind-with-dn-requires-password" property.
1915 private final boolean pBindWithDNRequiresPassword;
1916
1917 // The value of the "check-schema" property.
1918 private final boolean pCheckSchema;
1919
1920 // The value of the "default-password-policy" property.
1921 private final String pDefaultPasswordPolicy;
1922
1923 // The value of the "disabled-privilege" property.
1924 private final SortedSet<DisabledPrivilege> pDisabledPrivilege;
1925
1926 // The value of the "entry-cache-preload" property.
1927 private final boolean pEntryCachePreload;
1928
1929 // The value of the "etime-resolution" property.
1930 private final EtimeResolution pEtimeResolution;
1931
1932 // The value of the "idle-time-limit" property.
1933 private final long pIdleTimeLimit;
1934
1935 // The value of the "invalid-attribute-syntax-behavior" property.
1936 private final InvalidAttributeSyntaxBehavior pInvalidAttributeSyntaxBehavior;
1937
1938 // The value of the "lookthrough-limit" property.
1939 private final int pLookthroughLimit;
1940
1941 // The value of the "notify-abandoned-operations" property.
1942 private final boolean pNotifyAbandonedOperations;
1943
1944 // The value of the "proxied-authorization-identity-mapper" property.
1945 private final String pProxiedAuthorizationIdentityMapper;
1946
1947 // The value of the "reject-unauthenticated-requests" property.
1948 private final boolean pRejectUnauthenticatedRequests;
1949
1950 // The value of the "return-bind-error-messages" property.
1951 private final boolean pReturnBindErrorMessages;
1952
1953 // The value of the "save-config-on-successful-startup" property.
1954 private final boolean pSaveConfigOnSuccessfulStartup;
1955
1956 // The value of the "server-error-result-code" property.
1957 private final int pServerErrorResultCode;
1958
1959 // The value of the "single-structural-objectclass-behavior" property.
1960 private final SingleStructuralObjectclassBehavior pSingleStructuralObjectclassBehavior;
1961
1962 // The value of the "size-limit" property.
1963 private final int pSizeLimit;
1964
1965 // The value of the "smtp-server" property.
1966 private final SortedSet<String> pSMTPServer;
1967
1968 // The value of the "time-limit" property.
1969 private final long pTimeLimit;
1970
1971 // The value of the "workflow-configuration-mode" property.
1972 private final WorkflowConfigurationMode pWorkflowConfigurationMode;
1973
1974 // The value of the "writability-mode" property.
1975 private final WritabilityMode pWritabilityMode;
1976
1977
1978
1979 // Private constructor.
1980 private GlobalCfgServerImpl(ServerManagedObject<? extends GlobalCfg> impl) {
1981 this.impl = impl;
1982 this.pAddMissingRDNAttributes = impl.getPropertyValue(INSTANCE.getAddMissingRDNAttributesPropertyDefinition());
1983 this.pAllowAttributeNameExceptions = impl.getPropertyValue(INSTANCE.getAllowAttributeNameExceptionsPropertyDefinition());
1984 this.pAllowedTask = impl.getPropertyValues(INSTANCE.getAllowedTaskPropertyDefinition());
1985 this.pBindWithDNRequiresPassword = impl.getPropertyValue(INSTANCE.getBindWithDNRequiresPasswordPropertyDefinition());
1986 this.pCheckSchema = impl.getPropertyValue(INSTANCE.getCheckSchemaPropertyDefinition());
1987 this.pDefaultPasswordPolicy = impl.getPropertyValue(INSTANCE.getDefaultPasswordPolicyPropertyDefinition());
1988 this.pDisabledPrivilege = impl.getPropertyValues(INSTANCE.getDisabledPrivilegePropertyDefinition());
1989 this.pEntryCachePreload = impl.getPropertyValue(INSTANCE.getEntryCachePreloadPropertyDefinition());
1990 this.pEtimeResolution = impl.getPropertyValue(INSTANCE.getEtimeResolutionPropertyDefinition());
1991 this.pIdleTimeLimit = impl.getPropertyValue(INSTANCE.getIdleTimeLimitPropertyDefinition());
1992 this.pInvalidAttributeSyntaxBehavior = impl.getPropertyValue(INSTANCE.getInvalidAttributeSyntaxBehaviorPropertyDefinition());
1993 this.pLookthroughLimit = impl.getPropertyValue(INSTANCE.getLookthroughLimitPropertyDefinition());
1994 this.pNotifyAbandonedOperations = impl.getPropertyValue(INSTANCE.getNotifyAbandonedOperationsPropertyDefinition());
1995 this.pProxiedAuthorizationIdentityMapper = impl.getPropertyValue(INSTANCE.getProxiedAuthorizationIdentityMapperPropertyDefinition());
1996 this.pRejectUnauthenticatedRequests = impl.getPropertyValue(INSTANCE.getRejectUnauthenticatedRequestsPropertyDefinition());
1997 this.pReturnBindErrorMessages = impl.getPropertyValue(INSTANCE.getReturnBindErrorMessagesPropertyDefinition());
1998 this.pSaveConfigOnSuccessfulStartup = impl.getPropertyValue(INSTANCE.getSaveConfigOnSuccessfulStartupPropertyDefinition());
1999 this.pServerErrorResultCode = impl.getPropertyValue(INSTANCE.getServerErrorResultCodePropertyDefinition());
2000 this.pSingleStructuralObjectclassBehavior = impl.getPropertyValue(INSTANCE.getSingleStructuralObjectclassBehaviorPropertyDefinition());
2001 this.pSizeLimit = impl.getPropertyValue(INSTANCE.getSizeLimitPropertyDefinition());
2002 this.pSMTPServer = impl.getPropertyValues(INSTANCE.getSMTPServerPropertyDefinition());
2003 this.pTimeLimit = impl.getPropertyValue(INSTANCE.getTimeLimitPropertyDefinition());
2004 this.pWorkflowConfigurationMode = impl.getPropertyValue(INSTANCE.getWorkflowConfigurationModePropertyDefinition());
2005 this.pWritabilityMode = impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
2006 }
2007
2008
2009
2010 /**
2011 * {@inheritDoc}
2012 */
2013 public void addChangeListener(
2014 ConfigurationChangeListener<GlobalCfg> listener) {
2015 impl.registerChangeListener(listener);
2016 }
2017
2018
2019
2020 /**
2021 * {@inheritDoc}
2022 */
2023 public void removeChangeListener(
2024 ConfigurationChangeListener<GlobalCfg> listener) {
2025 impl.deregisterChangeListener(listener);
2026 }
2027
2028
2029
2030 /**
2031 * {@inheritDoc}
2032 */
2033 public boolean isAddMissingRDNAttributes() {
2034 return pAddMissingRDNAttributes;
2035 }
2036
2037
2038
2039 /**
2040 * {@inheritDoc}
2041 */
2042 public boolean isAllowAttributeNameExceptions() {
2043 return pAllowAttributeNameExceptions;
2044 }
2045
2046
2047
2048 /**
2049 * {@inheritDoc}
2050 */
2051 public SortedSet<String> getAllowedTask() {
2052 return pAllowedTask;
2053 }
2054
2055
2056
2057 /**
2058 * {@inheritDoc}
2059 */
2060 public boolean isBindWithDNRequiresPassword() {
2061 return pBindWithDNRequiresPassword;
2062 }
2063
2064
2065
2066 /**
2067 * {@inheritDoc}
2068 */
2069 public boolean isCheckSchema() {
2070 return pCheckSchema;
2071 }
2072
2073
2074
2075 /**
2076 * {@inheritDoc}
2077 */
2078 public String getDefaultPasswordPolicy() {
2079 return pDefaultPasswordPolicy;
2080 }
2081
2082
2083
2084 /**
2085 * {@inheritDoc}
2086 */
2087 public DN getDefaultPasswordPolicyDN() {
2088 String value = getDefaultPasswordPolicy();
2089 if (value == null) return null;
2090 return INSTANCE.getDefaultPasswordPolicyPropertyDefinition().getChildDN(value);
2091 }
2092
2093
2094
2095 /**
2096 * {@inheritDoc}
2097 */
2098 public SortedSet<DisabledPrivilege> getDisabledPrivilege() {
2099 return pDisabledPrivilege;
2100 }
2101
2102
2103
2104 /**
2105 * {@inheritDoc}
2106 */
2107 public boolean isEntryCachePreload() {
2108 return pEntryCachePreload;
2109 }
2110
2111
2112
2113 /**
2114 * {@inheritDoc}
2115 */
2116 public EtimeResolution getEtimeResolution() {
2117 return pEtimeResolution;
2118 }
2119
2120
2121
2122 /**
2123 * {@inheritDoc}
2124 */
2125 public long getIdleTimeLimit() {
2126 return pIdleTimeLimit;
2127 }
2128
2129
2130
2131 /**
2132 * {@inheritDoc}
2133 */
2134 public InvalidAttributeSyntaxBehavior getInvalidAttributeSyntaxBehavior() {
2135 return pInvalidAttributeSyntaxBehavior;
2136 }
2137
2138
2139
2140 /**
2141 * {@inheritDoc}
2142 */
2143 public int getLookthroughLimit() {
2144 return pLookthroughLimit;
2145 }
2146
2147
2148
2149 /**
2150 * {@inheritDoc}
2151 */
2152 public boolean isNotifyAbandonedOperations() {
2153 return pNotifyAbandonedOperations;
2154 }
2155
2156
2157
2158 /**
2159 * {@inheritDoc}
2160 */
2161 public String getProxiedAuthorizationIdentityMapper() {
2162 return pProxiedAuthorizationIdentityMapper;
2163 }
2164
2165
2166
2167 /**
2168 * {@inheritDoc}
2169 */
2170 public DN getProxiedAuthorizationIdentityMapperDN() {
2171 String value = getProxiedAuthorizationIdentityMapper();
2172 if (value == null) return null;
2173 return INSTANCE.getProxiedAuthorizationIdentityMapperPropertyDefinition().getChildDN(value);
2174 }
2175
2176
2177
2178 /**
2179 * {@inheritDoc}
2180 */
2181 public boolean isRejectUnauthenticatedRequests() {
2182 return pRejectUnauthenticatedRequests;
2183 }
2184
2185
2186
2187 /**
2188 * {@inheritDoc}
2189 */
2190 public boolean isReturnBindErrorMessages() {
2191 return pReturnBindErrorMessages;
2192 }
2193
2194
2195
2196 /**
2197 * {@inheritDoc}
2198 */
2199 public boolean isSaveConfigOnSuccessfulStartup() {
2200 return pSaveConfigOnSuccessfulStartup;
2201 }
2202
2203
2204
2205 /**
2206 * {@inheritDoc}
2207 */
2208 public int getServerErrorResultCode() {
2209 return pServerErrorResultCode;
2210 }
2211
2212
2213
2214 /**
2215 * {@inheritDoc}
2216 */
2217 public SingleStructuralObjectclassBehavior getSingleStructuralObjectclassBehavior() {
2218 return pSingleStructuralObjectclassBehavior;
2219 }
2220
2221
2222
2223 /**
2224 * {@inheritDoc}
2225 */
2226 public int getSizeLimit() {
2227 return pSizeLimit;
2228 }
2229
2230
2231
2232 /**
2233 * {@inheritDoc}
2234 */
2235 public SortedSet<String> getSMTPServer() {
2236 return pSMTPServer;
2237 }
2238
2239
2240
2241 /**
2242 * {@inheritDoc}
2243 */
2244 public long getTimeLimit() {
2245 return pTimeLimit;
2246 }
2247
2248
2249
2250 /**
2251 * {@inheritDoc}
2252 */
2253 public WorkflowConfigurationMode getWorkflowConfigurationMode() {
2254 return pWorkflowConfigurationMode;
2255 }
2256
2257
2258
2259 /**
2260 * {@inheritDoc}
2261 */
2262 public WritabilityMode getWritabilityMode() {
2263 return pWritabilityMode;
2264 }
2265
2266
2267
2268 /**
2269 * {@inheritDoc}
2270 */
2271 public Class<? extends GlobalCfg> configurationClass() {
2272 return GlobalCfg.class;
2273 }
2274
2275
2276
2277 /**
2278 * {@inheritDoc}
2279 */
2280 public DN dn() {
2281 return impl.getDN();
2282 }
2283
2284 }
2285 }