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 }