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    }