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 legal-notices/CDDLv1_0.txt
010 * or http://forgerock.org/license/CDDLv1.0.html.
011 * See the License for the specific language governing permissions
012 * and limitations under the License.
013 *
014 * When distributing Covered Code, include this CDDL HEADER in each
015 * file and include the License file at legal-notices/CDDLv1_0.txt.
016 * If applicable, add the following below this CDDL HEADER, with the
017 * fields enclosed by brackets "[]" replaced with your own identifying
018 * information:
019 *      Portions Copyright [yyyy] [name of copyright owner]
020 *
021 * CDDL HEADER END
022 *
023 *
024 *      Copyright 2008 Sun Microsystems, Inc.
025 */
026package org.forgerock.opendj.server.config.meta;
027
028
029
030import java.util.Collection;
031import java.util.SortedSet;
032import org.forgerock.opendj.config.AdministratorAction;
033import org.forgerock.opendj.config.BooleanPropertyDefinition;
034import org.forgerock.opendj.config.ClassPropertyDefinition;
035import org.forgerock.opendj.config.client.ConcurrentModificationException;
036import org.forgerock.opendj.config.client.IllegalManagedObjectNameException;
037import org.forgerock.opendj.config.client.ManagedObject;
038import org.forgerock.opendj.config.client.ManagedObjectDecodingException;
039import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException;
040import org.forgerock.opendj.config.client.OperationRejectedException;
041import org.forgerock.opendj.config.DefaultBehaviorProvider;
042import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider;
043import org.forgerock.opendj.config.DefinitionDecodingException;
044import org.forgerock.opendj.config.DNPropertyDefinition;
045import org.forgerock.opendj.config.DurationPropertyDefinition;
046import org.forgerock.opendj.config.EnumPropertyDefinition;
047import org.forgerock.opendj.config.InstantiableRelationDefinition;
048import org.forgerock.opendj.config.IntegerPropertyDefinition;
049import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException;
050import org.forgerock.opendj.config.ManagedObjectDefinition;
051import org.forgerock.opendj.config.ManagedObjectNotFoundException;
052import org.forgerock.opendj.config.PropertyException;
053import org.forgerock.opendj.config.PropertyOption;
054import org.forgerock.opendj.config.PropertyProvider;
055import org.forgerock.opendj.config.server.ConfigException;
056import org.forgerock.opendj.config.server.ConfigurationAddListener;
057import org.forgerock.opendj.config.server.ConfigurationChangeListener;
058import org.forgerock.opendj.config.server.ConfigurationDeleteListener;
059import org.forgerock.opendj.config.server.ServerManagedObject;
060import org.forgerock.opendj.config.SizePropertyDefinition;
061import org.forgerock.opendj.config.StringPropertyDefinition;
062import org.forgerock.opendj.config.Tag;
063import org.forgerock.opendj.ldap.DN;
064import org.forgerock.opendj.ldap.LdapException;
065import org.forgerock.opendj.server.config.client.BackendIndexCfgClient;
066import org.forgerock.opendj.server.config.client.BackendVLVIndexCfgClient;
067import org.forgerock.opendj.server.config.client.PDBBackendCfgClient;
068import org.forgerock.opendj.server.config.meta.BackendCfgDefn.WritabilityMode;
069import org.forgerock.opendj.server.config.server.BackendCfg;
070import org.forgerock.opendj.server.config.server.BackendIndexCfg;
071import org.forgerock.opendj.server.config.server.BackendVLVIndexCfg;
072import org.forgerock.opendj.server.config.server.PDBBackendCfg;
073import org.forgerock.opendj.server.config.server.PluggableBackendCfg;
074
075
076
077/**
078 * An interface for querying the PDB Backend managed object definition
079 * meta information.
080 * <p>
081 * A PDB Backend stores application data in a Persistit database.
082 */
083public final class PDBBackendCfgDefn extends ManagedObjectDefinition<PDBBackendCfgClient, PDBBackendCfg> {
084
085  // The singleton configuration definition instance.
086  private static final PDBBackendCfgDefn INSTANCE = new PDBBackendCfgDefn();
087
088
089
090  // The "db-cache-percent" property definition.
091  private static final IntegerPropertyDefinition PD_DB_CACHE_PERCENT;
092
093
094
095  // The "db-cache-size" property definition.
096  private static final SizePropertyDefinition PD_DB_CACHE_SIZE;
097
098
099
100  // The "db-checkpointer-wakeup-interval" property definition.
101  private static final DurationPropertyDefinition PD_DB_CHECKPOINTER_WAKEUP_INTERVAL;
102
103
104
105  // The "db-directory" property definition.
106  private static final StringPropertyDefinition PD_DB_DIRECTORY;
107
108
109
110  // The "db-directory-permissions" property definition.
111  private static final StringPropertyDefinition PD_DB_DIRECTORY_PERMISSIONS;
112
113
114
115  // The "db-txn-no-sync" property definition.
116  private static final BooleanPropertyDefinition PD_DB_TXN_NO_SYNC;
117
118
119
120  // The "disk-full-threshold" property definition.
121  private static final SizePropertyDefinition PD_DISK_FULL_THRESHOLD;
122
123
124
125  // The "disk-low-threshold" property definition.
126  private static final SizePropertyDefinition PD_DISK_LOW_THRESHOLD;
127
128
129
130  // The "java-class" property definition.
131  private static final ClassPropertyDefinition PD_JAVA_CLASS;
132
133
134
135  // Build the "db-cache-percent" property definition.
136  static {
137      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-cache-percent");
138      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cache-percent"));
139      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("50");
140      builder.setDefaultBehaviorProvider(provider);
141      builder.setUpperLimit(90);
142      builder.setLowerLimit(1);
143      PD_DB_CACHE_PERCENT = builder.getInstance();
144      INSTANCE.registerPropertyDefinition(PD_DB_CACHE_PERCENT);
145  }
146
147
148
149  // Build the "db-cache-size" property definition.
150  static {
151      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "db-cache-size");
152      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cache-size"));
153      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0 MB");
154      builder.setDefaultBehaviorProvider(provider);
155      builder.setLowerLimit("0 MB");
156      PD_DB_CACHE_SIZE = builder.getInstance();
157      INSTANCE.registerPropertyDefinition(PD_DB_CACHE_SIZE);
158  }
159
160
161
162  // Build the "db-checkpointer-wakeup-interval" property definition.
163  static {
164      DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "db-checkpointer-wakeup-interval");
165      builder.setOption(PropertyOption.ADVANCED);
166      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-checkpointer-wakeup-interval"));
167      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("15s");
168      builder.setDefaultBehaviorProvider(provider);
169      builder.setBaseUnit("s");
170      builder.setUpperLimit("3600");
171      builder.setLowerLimit("10");
172      PD_DB_CHECKPOINTER_WAKEUP_INTERVAL = builder.getInstance();
173      INSTANCE.registerPropertyDefinition(PD_DB_CHECKPOINTER_WAKEUP_INTERVAL);
174  }
175
176
177
178  // Build the "db-directory" property definition.
179  static {
180      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "db-directory");
181      builder.setOption(PropertyOption.MANDATORY);
182      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-directory"));
183      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("db");
184      builder.setDefaultBehaviorProvider(provider);
185      PD_DB_DIRECTORY = builder.getInstance();
186      INSTANCE.registerPropertyDefinition(PD_DB_DIRECTORY);
187  }
188
189
190
191  // Build the "db-directory-permissions" property definition.
192  static {
193      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "db-directory-permissions");
194      builder.setOption(PropertyOption.ADVANCED);
195      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.SERVER_RESTART, INSTANCE, "db-directory-permissions"));
196      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("700");
197      builder.setDefaultBehaviorProvider(provider);
198      builder.setPattern("^7[0-7][0-7]$", "MODE");
199      PD_DB_DIRECTORY_PERMISSIONS = builder.getInstance();
200      INSTANCE.registerPropertyDefinition(PD_DB_DIRECTORY_PERMISSIONS);
201  }
202
203
204
205  // Build the "db-txn-no-sync" property definition.
206  static {
207      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "db-txn-no-sync");
208      builder.setOption(PropertyOption.ADVANCED);
209      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-txn-no-sync"));
210      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
211      builder.setDefaultBehaviorProvider(provider);
212      PD_DB_TXN_NO_SYNC = builder.getInstance();
213      INSTANCE.registerPropertyDefinition(PD_DB_TXN_NO_SYNC);
214  }
215
216
217
218  // Build the "disk-full-threshold" property definition.
219  static {
220      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-full-threshold");
221      builder.setOption(PropertyOption.ADVANCED);
222      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-full-threshold"));
223      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("100 megabytes");
224      builder.setDefaultBehaviorProvider(provider);
225      builder.setLowerLimit("0");
226      PD_DISK_FULL_THRESHOLD = builder.getInstance();
227      INSTANCE.registerPropertyDefinition(PD_DISK_FULL_THRESHOLD);
228  }
229
230
231
232  // Build the "disk-low-threshold" property definition.
233  static {
234      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-low-threshold");
235      builder.setOption(PropertyOption.ADVANCED);
236      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-low-threshold"));
237      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("200 megabytes");
238      builder.setDefaultBehaviorProvider(provider);
239      builder.setLowerLimit("0");
240      PD_DISK_LOW_THRESHOLD = builder.getInstance();
241      INSTANCE.registerPropertyDefinition(PD_DISK_LOW_THRESHOLD);
242  }
243
244
245
246  // Build the "java-class" property definition.
247  static {
248      ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
249      builder.setOption(PropertyOption.MANDATORY);
250      builder.setOption(PropertyOption.ADVANCED);
251      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
252      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.backends.pdb.PDBBackend");
253      builder.setDefaultBehaviorProvider(provider);
254      builder.addInstanceOf("org.opends.server.api.Backend");
255      PD_JAVA_CLASS = builder.getInstance();
256      INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
257  }
258
259
260
261  // Register the tags associated with this managed object definition.
262  static {
263    INSTANCE.registerTag(Tag.valueOf("database"));
264  }
265
266
267
268  /**
269   * Get the PDB Backend configuration definition singleton.
270   *
271   * @return Returns the PDB Backend configuration definition
272   *         singleton.
273   */
274  public static PDBBackendCfgDefn getInstance() {
275    return INSTANCE;
276  }
277
278
279
280  /**
281   * Private constructor.
282   */
283  private PDBBackendCfgDefn() {
284    super("pdb-backend", PluggableBackendCfgDefn.getInstance());
285  }
286
287
288
289  /**
290   * {@inheritDoc}
291   */
292  public PDBBackendCfgClient createClientConfiguration(
293      ManagedObject<? extends PDBBackendCfgClient> impl) {
294    return new PDBBackendCfgClientImpl(impl);
295  }
296
297
298
299  /**
300   * {@inheritDoc}
301   */
302  public PDBBackendCfg createServerConfiguration(
303      ServerManagedObject<? extends PDBBackendCfg> impl) {
304    return new PDBBackendCfgServerImpl(impl);
305  }
306
307
308
309  /**
310   * {@inheritDoc}
311   */
312  public Class<PDBBackendCfg> getServerConfigurationClass() {
313    return PDBBackendCfg.class;
314  }
315
316
317
318  /**
319   * Get the "backend-id" property definition.
320   * <p>
321   * Specifies a name to identify the associated backend.
322   * <p>
323   * The name must be unique among all backends in the server. The
324   * backend ID may not be altered after the backend is created in the
325   * server.
326   *
327   * @return Returns the "backend-id" property definition.
328   */
329  public StringPropertyDefinition getBackendIdPropertyDefinition() {
330    return PluggableBackendCfgDefn.getInstance().getBackendIdPropertyDefinition();
331  }
332
333
334
335  /**
336   * Get the "base-dn" property definition.
337   * <p>
338   * Specifies the base DN(s) for the data that the backend handles.
339   * <p>
340   * A single backend may be responsible for one or more base DNs.
341   * Note that no two backends may have the same base DN although one
342   * backend may have a base DN that is below a base DN provided by
343   * another backend (similar to the use of sub-suffixes in the Sun
344   * Java System Directory Server). If any of the base DNs is
345   * subordinate to a base DN for another backend, then all base DNs
346   * for that backend must be subordinate to that same base DN.
347   *
348   * @return Returns the "base-dn" property definition.
349   */
350  public DNPropertyDefinition getBaseDNPropertyDefinition() {
351    return PluggableBackendCfgDefn.getInstance().getBaseDNPropertyDefinition();
352  }
353
354
355
356  /**
357   * Get the "compact-encoding" property definition.
358   * <p>
359   * Indicates whether the backend should use a compact form when
360   * encoding entries by compressing the attribute descriptions and
361   * object class sets.
362   * <p>
363   * Note that this property applies only to the entries themselves
364   * and does not impact the index data.
365   *
366   * @return Returns the "compact-encoding" property definition.
367   */
368  public BooleanPropertyDefinition getCompactEncodingPropertyDefinition() {
369    return PluggableBackendCfgDefn.getInstance().getCompactEncodingPropertyDefinition();
370  }
371
372
373
374  /**
375   * Get the "db-cache-percent" property definition.
376   * <p>
377   * Specifies the percentage of JVM memory to allocate to the
378   * database cache.
379   * <p>
380   * Specifies the percentage of memory available to the JVM that
381   * should be used for caching database contents. Note that this is
382   * only used if the value of the db-cache-size property is set to "0
383   * MB". Otherwise, the value of that property is used instead to
384   * control the cache size configuration.
385   *
386   * @return Returns the "db-cache-percent" property definition.
387   */
388  public IntegerPropertyDefinition getDBCachePercentPropertyDefinition() {
389    return PD_DB_CACHE_PERCENT;
390  }
391
392
393
394  /**
395   * Get the "db-cache-size" property definition.
396   * <p>
397   * The amount of JVM memory to allocate to the database cache.
398   * <p>
399   * Specifies the amount of memory that should be used for caching
400   * database contents. A value of "0 MB" indicates that the
401   * db-cache-percent property should be used instead to specify the
402   * cache size.
403   *
404   * @return Returns the "db-cache-size" property definition.
405   */
406  public SizePropertyDefinition getDBCacheSizePropertyDefinition() {
407    return PD_DB_CACHE_SIZE;
408  }
409
410
411
412  /**
413   * Get the "db-checkpointer-wakeup-interval" property definition.
414   * <p>
415   * Specifies the maximum length of time that may pass between
416   * checkpoints.
417   * <p>
418   * This setting controls the elapsed time between attempts to write
419   * a checkpoint to the journal. A longer interval allows more updates
420   * to accumulate in buffers before they are required to be written to
421   * disk, but also potentially causes recovery from an abrupt
422   * termination (crash) to take more time.
423   *
424   * @return Returns the "db-checkpointer-wakeup-interval" property definition.
425   */
426  public DurationPropertyDefinition getDBCheckpointerWakeupIntervalPropertyDefinition() {
427    return PD_DB_CHECKPOINTER_WAKEUP_INTERVAL;
428  }
429
430
431
432  /**
433   * Get the "db-directory" property definition.
434   * <p>
435   * Specifies the path to the filesystem directory that is used to
436   * hold the Persistit database files containing the data for this
437   * backend.
438   * <p>
439   * The path may be either an absolute path or a path relative to the
440   * directory containing the base of the OpenDJ directory server
441   * installation. The path may be any valid directory path in which
442   * the server has appropriate permissions to read and write files and
443   * has sufficient space to hold the database contents.
444   *
445   * @return Returns the "db-directory" property definition.
446   */
447  public StringPropertyDefinition getDBDirectoryPropertyDefinition() {
448    return PD_DB_DIRECTORY;
449  }
450
451
452
453  /**
454   * Get the "db-directory-permissions" property definition.
455   * <p>
456   * Specifies the permissions that should be applied to the directory
457   * containing the server database files.
458   * <p>
459   * They should be expressed as three-digit octal values, which is
460   * the traditional representation for UNIX file permissions. The
461   * three digits represent the permissions that are available for the
462   * directory's owner, group members, and other users (in that order),
463   * and each digit is the octal representation of the read, write, and
464   * execute bits. Note that this only impacts permissions on the
465   * database directory and not on the files written into that
466   * directory. On UNIX systems, the user's umask controls permissions
467   * given to the database files.
468   *
469   * @return Returns the "db-directory-permissions" property definition.
470   */
471  public StringPropertyDefinition getDBDirectoryPermissionsPropertyDefinition() {
472    return PD_DB_DIRECTORY_PERMISSIONS;
473  }
474
475
476
477  /**
478   * Get the "db-txn-no-sync" property definition.
479   * <p>
480   * Indicates whether database writes should be primarily written to
481   * an internal buffer but not immediately written to disk.
482   * <p>
483   * Setting the value of this configuration attribute to "true" may
484   * improve write performance but could cause the most recent changes
485   * to be lost if the OpenDJ directory server or the underlying JVM
486   * exits abnormally, or if an OS or hardware failure occurs (a
487   * behavior similar to running with transaction durability disabled
488   * in the Sun Java System Directory Server).
489   *
490   * @return Returns the "db-txn-no-sync" property definition.
491   */
492  public BooleanPropertyDefinition getDBTxnNoSyncPropertyDefinition() {
493    return PD_DB_TXN_NO_SYNC;
494  }
495
496
497
498  /**
499   * Get the "disk-full-threshold" property definition.
500   * <p>
501   * Full disk threshold to limit database updates
502   * <p>
503   * When the available free space on the disk used by this database
504   * instance falls below the value specified, no updates are permitted
505   * and the server returns an UNWILLING_TO_PERFORM error. Updates are
506   * allowed again as soon as free space rises above the threshold.
507   *
508   * @return Returns the "disk-full-threshold" property definition.
509   */
510  public SizePropertyDefinition getDiskFullThresholdPropertyDefinition() {
511    return PD_DISK_FULL_THRESHOLD;
512  }
513
514
515
516  /**
517   * Get the "disk-low-threshold" property definition.
518   * <p>
519   * Low disk threshold to limit database updates
520   * <p>
521   * Specifies the "low" free space on the disk. When the available
522   * free space on the disk used by this database instance falls below
523   * the value specified, protocol updates on this database are
524   * permitted only by a user with the BYPASS_LOCKDOWN privilege.
525   *
526   * @return Returns the "disk-low-threshold" property definition.
527   */
528  public SizePropertyDefinition getDiskLowThresholdPropertyDefinition() {
529    return PD_DISK_LOW_THRESHOLD;
530  }
531
532
533
534  /**
535   * Get the "enabled" property definition.
536   * <p>
537   * Indicates whether the backend is enabled in the server.
538   * <p>
539   * If a backend is not enabled, then its contents are not accessible
540   * when processing operations.
541   *
542   * @return Returns the "enabled" property definition.
543   */
544  public BooleanPropertyDefinition getEnabledPropertyDefinition() {
545    return PluggableBackendCfgDefn.getInstance().getEnabledPropertyDefinition();
546  }
547
548
549
550  /**
551   * Get the "entries-compressed" property definition.
552   * <p>
553   * Indicates whether the backend should attempt to compress entries
554   * before storing them in the database.
555   * <p>
556   * Note that this property applies only to the entries themselves
557   * and does not impact the index data. Further, the effectiveness of
558   * the compression is based on the type of data contained in the
559   * entry.
560   *
561   * @return Returns the "entries-compressed" property definition.
562   */
563  public BooleanPropertyDefinition getEntriesCompressedPropertyDefinition() {
564    return PluggableBackendCfgDefn.getInstance().getEntriesCompressedPropertyDefinition();
565  }
566
567
568
569  /**
570   * Get the "index-entry-limit" property definition.
571   * <p>
572   * Specifies the maximum number of entries that is allowed to match
573   * a given index key before that particular index key is no longer
574   * maintained.
575   * <p>
576   * This property is analogous to the ALL IDs threshold in the Sun
577   * Java System Directory Server. Note that this is the default limit
578   * for the backend, and it may be overridden on a per-attribute
579   * basis.A value of 0 means there is no limit.
580   *
581   * @return Returns the "index-entry-limit" property definition.
582   */
583  public IntegerPropertyDefinition getIndexEntryLimitPropertyDefinition() {
584    return PluggableBackendCfgDefn.getInstance().getIndexEntryLimitPropertyDefinition();
585  }
586
587
588
589  /**
590   * Get the "index-filter-analyzer-enabled" property definition.
591   * <p>
592   * Indicates whether to gather statistical information about the
593   * search filters processed by the directory server while evaluating
594   * the usage of indexes.
595   * <p>
596   * Analyzing indexes requires gathering search filter usage patterns
597   * from user requests, especially for values as specified in the
598   * filters and subsequently looking the status of those values into
599   * the index files. When a search requests is processed, internal or
600   * user generated, a first phase uses indexes to find potential
601   * entries to be returned. Depending on the search filter, if the
602   * index of one of the specified attributes matches too many entries
603   * (exceeds the index entry limit), the search becomes non-indexed.
604   * In any case, all entries thus gathered (or the entire DIT) are
605   * matched against the filter for actually returning the search
606   * result.
607   *
608   * @return Returns the "index-filter-analyzer-enabled" property definition.
609   */
610  public BooleanPropertyDefinition getIndexFilterAnalyzerEnabledPropertyDefinition() {
611    return PluggableBackendCfgDefn.getInstance().getIndexFilterAnalyzerEnabledPropertyDefinition();
612  }
613
614
615
616  /**
617   * Get the "index-filter-analyzer-max-filters" property definition.
618   * <p>
619   * The maximum number of search filter statistics to keep.
620   * <p>
621   * When the maximum number of search filter is reached, the least
622   * used one will be deleted.
623   *
624   * @return Returns the "index-filter-analyzer-max-filters" property definition.
625   */
626  public IntegerPropertyDefinition getIndexFilterAnalyzerMaxFiltersPropertyDefinition() {
627    return PluggableBackendCfgDefn.getInstance().getIndexFilterAnalyzerMaxFiltersPropertyDefinition();
628  }
629
630
631
632  /**
633   * Get the "java-class" property definition.
634   * <p>
635   * Specifies the fully-qualified name of the Java class that
636   * provides the backend implementation.
637   *
638   * @return Returns the "java-class" property definition.
639   */
640  public ClassPropertyDefinition getJavaClassPropertyDefinition() {
641    return PD_JAVA_CLASS;
642  }
643
644
645
646  /**
647   * Get the "preload-time-limit" property definition.
648   * <p>
649   * Specifies the length of time that the backend is allowed to spend
650   * "pre-loading" data when it is initialized.
651   * <p>
652   * The pre-load process is used to pre-populate the database cache,
653   * so that it can be more quickly available when the server is
654   * processing requests. A duration of zero means there is no
655   * pre-load.
656   *
657   * @return Returns the "preload-time-limit" property definition.
658   */
659  public DurationPropertyDefinition getPreloadTimeLimitPropertyDefinition() {
660    return PluggableBackendCfgDefn.getInstance().getPreloadTimeLimitPropertyDefinition();
661  }
662
663
664
665  /**
666   * Get the "writability-mode" property definition.
667   * <p>
668   * Specifies the behavior that the backend should use when
669   * processing write operations.
670   *
671   * @return Returns the "writability-mode" property definition.
672   */
673  public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() {
674    return PluggableBackendCfgDefn.getInstance().getWritabilityModePropertyDefinition();
675  }
676
677
678
679  /**
680   * Get the "backend-indexes" relation definition.
681   *
682   * @return Returns the "backend-indexes" relation definition.
683   */
684  public InstantiableRelationDefinition<BackendIndexCfgClient,BackendIndexCfg> getBackendIndexesRelationDefinition() {
685    return PluggableBackendCfgDefn.getInstance().getBackendIndexesRelationDefinition();
686  }
687
688
689
690  /**
691   * Get the "backend-vlv-indexes" relation definition.
692   *
693   * @return Returns the "backend-vlv-indexes" relation definition.
694   */
695  public InstantiableRelationDefinition<BackendVLVIndexCfgClient,BackendVLVIndexCfg> getBackendVLVIndexesRelationDefinition() {
696    return PluggableBackendCfgDefn.getInstance().getBackendVLVIndexesRelationDefinition();
697  }
698
699
700
701  /**
702   * Managed object client implementation.
703   */
704  private static class PDBBackendCfgClientImpl implements
705    PDBBackendCfgClient {
706
707    // Private implementation.
708    private ManagedObject<? extends PDBBackendCfgClient> impl;
709
710
711
712    // Private constructor.
713    private PDBBackendCfgClientImpl(
714        ManagedObject<? extends PDBBackendCfgClient> impl) {
715      this.impl = impl;
716    }
717
718
719
720    /**
721     * {@inheritDoc}
722     */
723    public String getBackendId() {
724      return impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition());
725    }
726
727
728
729    /**
730     * {@inheritDoc}
731     */
732    public void setBackendId(String value) throws PropertyException {
733      impl.setPropertyValue(INSTANCE.getBackendIdPropertyDefinition(), value);
734    }
735
736
737
738    /**
739     * {@inheritDoc}
740     */
741    public SortedSet<DN> getBaseDN() {
742      return impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
743    }
744
745
746
747    /**
748     * {@inheritDoc}
749     */
750    public void setBaseDN(Collection<DN> values) {
751      impl.setPropertyValues(INSTANCE.getBaseDNPropertyDefinition(), values);
752    }
753
754
755
756    /**
757     * {@inheritDoc}
758     */
759    public boolean isCompactEncoding() {
760      return impl.getPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition());
761    }
762
763
764
765    /**
766     * {@inheritDoc}
767     */
768    public void setCompactEncoding(Boolean value) {
769      impl.setPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition(), value);
770    }
771
772
773
774    /**
775     * {@inheritDoc}
776     */
777    public int getDBCachePercent() {
778      return impl.getPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition());
779    }
780
781
782
783    /**
784     * {@inheritDoc}
785     */
786    public void setDBCachePercent(Integer value) {
787      impl.setPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition(), value);
788    }
789
790
791
792    /**
793     * {@inheritDoc}
794     */
795    public long getDBCacheSize() {
796      return impl.getPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition());
797    }
798
799
800
801    /**
802     * {@inheritDoc}
803     */
804    public void setDBCacheSize(Long value) {
805      impl.setPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition(), value);
806    }
807
808
809
810    /**
811     * {@inheritDoc}
812     */
813    public long getDBCheckpointerWakeupInterval() {
814      return impl.getPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition());
815    }
816
817
818
819    /**
820     * {@inheritDoc}
821     */
822    public void setDBCheckpointerWakeupInterval(Long value) {
823      impl.setPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition(), value);
824    }
825
826
827
828    /**
829     * {@inheritDoc}
830     */
831    public String getDBDirectory() {
832      return impl.getPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition());
833    }
834
835
836
837    /**
838     * {@inheritDoc}
839     */
840    public void setDBDirectory(String value) {
841      impl.setPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition(), value);
842    }
843
844
845
846    /**
847     * {@inheritDoc}
848     */
849    public String getDBDirectoryPermissions() {
850      return impl.getPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition());
851    }
852
853
854
855    /**
856     * {@inheritDoc}
857     */
858    public void setDBDirectoryPermissions(String value) {
859      impl.setPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition(), value);
860    }
861
862
863
864    /**
865     * {@inheritDoc}
866     */
867    public boolean isDBTxnNoSync() {
868      return impl.getPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition());
869    }
870
871
872
873    /**
874     * {@inheritDoc}
875     */
876    public void setDBTxnNoSync(Boolean value) {
877      impl.setPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition(), value);
878    }
879
880
881
882    /**
883     * {@inheritDoc}
884     */
885    public long getDiskFullThreshold() {
886      return impl.getPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition());
887    }
888
889
890
891    /**
892     * {@inheritDoc}
893     */
894    public void setDiskFullThreshold(Long value) {
895      impl.setPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition(), value);
896    }
897
898
899
900    /**
901     * {@inheritDoc}
902     */
903    public long getDiskLowThreshold() {
904      return impl.getPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition());
905    }
906
907
908
909    /**
910     * {@inheritDoc}
911     */
912    public void setDiskLowThreshold(Long value) {
913      impl.setPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition(), value);
914    }
915
916
917
918    /**
919     * {@inheritDoc}
920     */
921    public Boolean isEnabled() {
922      return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
923    }
924
925
926
927    /**
928     * {@inheritDoc}
929     */
930    public void setEnabled(boolean value) {
931      impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
932    }
933
934
935
936    /**
937     * {@inheritDoc}
938     */
939    public boolean isEntriesCompressed() {
940      return impl.getPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition());
941    }
942
943
944
945    /**
946     * {@inheritDoc}
947     */
948    public void setEntriesCompressed(Boolean value) {
949      impl.setPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition(), value);
950    }
951
952
953
954    /**
955     * {@inheritDoc}
956     */
957    public int getIndexEntryLimit() {
958      return impl.getPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition());
959    }
960
961
962
963    /**
964     * {@inheritDoc}
965     */
966    public void setIndexEntryLimit(Integer value) {
967      impl.setPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition(), value);
968    }
969
970
971
972    /**
973     * {@inheritDoc}
974     */
975    public boolean isIndexFilterAnalyzerEnabled() {
976      return impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition());
977    }
978
979
980
981    /**
982     * {@inheritDoc}
983     */
984    public void setIndexFilterAnalyzerEnabled(Boolean value) {
985      impl.setPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition(), value);
986    }
987
988
989
990    /**
991     * {@inheritDoc}
992     */
993    public int getIndexFilterAnalyzerMaxFilters() {
994      return impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition());
995    }
996
997
998
999    /**
1000     * {@inheritDoc}
1001     */
1002    public void setIndexFilterAnalyzerMaxFilters(Integer value) {
1003      impl.setPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition(), value);
1004    }
1005
1006
1007
1008    /**
1009     * {@inheritDoc}
1010     */
1011    public String getJavaClass() {
1012      return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
1013    }
1014
1015
1016
1017    /**
1018     * {@inheritDoc}
1019     */
1020    public void setJavaClass(String value) {
1021      impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
1022    }
1023
1024
1025
1026    /**
1027     * {@inheritDoc}
1028     */
1029    public long getPreloadTimeLimit() {
1030      return impl.getPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition());
1031    }
1032
1033
1034
1035    /**
1036     * {@inheritDoc}
1037     */
1038    public void setPreloadTimeLimit(Long value) {
1039      impl.setPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition(), value);
1040    }
1041
1042
1043
1044    /**
1045     * {@inheritDoc}
1046     */
1047    public WritabilityMode getWritabilityMode() {
1048      return impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
1049    }
1050
1051
1052
1053    /**
1054     * {@inheritDoc}
1055     */
1056    public void setWritabilityMode(WritabilityMode value) {
1057      impl.setPropertyValue(INSTANCE.getWritabilityModePropertyDefinition(), value);
1058    }
1059
1060
1061
1062    /**
1063     * {@inheritDoc}
1064     */
1065    public String[] listBackendIndexes() throws ConcurrentModificationException,
1066        LdapException {
1067      return impl.listChildren(INSTANCE.getBackendIndexesRelationDefinition());
1068    }
1069
1070
1071
1072    /**
1073     * {@inheritDoc}
1074     */
1075    public BackendIndexCfgClient getBackendIndex(String name)
1076        throws DefinitionDecodingException, ManagedObjectDecodingException,
1077        ManagedObjectNotFoundException, ConcurrentModificationException,
1078        LdapException {
1079      return impl.getChild(INSTANCE.getBackendIndexesRelationDefinition(), name).getConfiguration();
1080    }
1081
1082
1083
1084    /**
1085     * {@inheritDoc}
1086     */
1087    public <M extends BackendIndexCfgClient> M createBackendIndex(
1088        ManagedObjectDefinition<M, ? extends BackendIndexCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException {
1089      return impl.createChild(INSTANCE.getBackendIndexesRelationDefinition(), d, name, exceptions).getConfiguration();
1090    }
1091
1092
1093
1094    /**
1095     * {@inheritDoc}
1096     */
1097    public void removeBackendIndex(String name)
1098        throws ManagedObjectNotFoundException, ConcurrentModificationException,
1099        OperationRejectedException, LdapException {
1100      impl.removeChild(INSTANCE.getBackendIndexesRelationDefinition(), name);
1101    }
1102
1103
1104
1105    /**
1106     * {@inheritDoc}
1107     */
1108    public String[] listBackendVLVIndexes() throws ConcurrentModificationException,
1109        LdapException {
1110      return impl.listChildren(INSTANCE.getBackendVLVIndexesRelationDefinition());
1111    }
1112
1113
1114
1115    /**
1116     * {@inheritDoc}
1117     */
1118    public BackendVLVIndexCfgClient getBackendVLVIndex(String name)
1119        throws DefinitionDecodingException, ManagedObjectDecodingException,
1120        ManagedObjectNotFoundException, ConcurrentModificationException,
1121        LdapException {
1122      return impl.getChild(INSTANCE.getBackendVLVIndexesRelationDefinition(), name).getConfiguration();
1123    }
1124
1125
1126
1127    /**
1128     * {@inheritDoc}
1129     */
1130    public <M extends BackendVLVIndexCfgClient> M createBackendVLVIndex(
1131        ManagedObjectDefinition<M, ? extends BackendVLVIndexCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException {
1132      return impl.createChild(INSTANCE.getBackendVLVIndexesRelationDefinition(), d, name, exceptions).getConfiguration();
1133    }
1134
1135
1136
1137    /**
1138     * {@inheritDoc}
1139     */
1140    public void removeBackendVLVIndex(String name)
1141        throws ManagedObjectNotFoundException, ConcurrentModificationException,
1142        OperationRejectedException, LdapException {
1143      impl.removeChild(INSTANCE.getBackendVLVIndexesRelationDefinition(), name);
1144    }
1145
1146
1147
1148    /**
1149     * {@inheritDoc}
1150     */
1151    public ManagedObjectDefinition<? extends PDBBackendCfgClient, ? extends PDBBackendCfg> definition() {
1152      return INSTANCE;
1153    }
1154
1155
1156
1157    /**
1158     * {@inheritDoc}
1159     */
1160    public PropertyProvider properties() {
1161      return impl;
1162    }
1163
1164
1165
1166    /**
1167     * {@inheritDoc}
1168     */
1169    public void commit() throws ManagedObjectAlreadyExistsException,
1170        MissingMandatoryPropertiesException, ConcurrentModificationException,
1171        OperationRejectedException, LdapException {
1172      impl.commit();
1173    }
1174
1175  }
1176
1177
1178
1179  /**
1180   * Managed object server implementation.
1181   */
1182  private static class PDBBackendCfgServerImpl implements
1183    PDBBackendCfg {
1184
1185    // Private implementation.
1186    private ServerManagedObject<? extends PDBBackendCfg> impl;
1187
1188    // The value of the "backend-id" property.
1189    private final String pBackendId;
1190
1191    // The value of the "base-dn" property.
1192    private final SortedSet<DN> pBaseDN;
1193
1194    // The value of the "compact-encoding" property.
1195    private final boolean pCompactEncoding;
1196
1197    // The value of the "db-cache-percent" property.
1198    private final int pDBCachePercent;
1199
1200    // The value of the "db-cache-size" property.
1201    private final long pDBCacheSize;
1202
1203    // The value of the "db-checkpointer-wakeup-interval" property.
1204    private final long pDBCheckpointerWakeupInterval;
1205
1206    // The value of the "db-directory" property.
1207    private final String pDBDirectory;
1208
1209    // The value of the "db-directory-permissions" property.
1210    private final String pDBDirectoryPermissions;
1211
1212    // The value of the "db-txn-no-sync" property.
1213    private final boolean pDBTxnNoSync;
1214
1215    // The value of the "disk-full-threshold" property.
1216    private final long pDiskFullThreshold;
1217
1218    // The value of the "disk-low-threshold" property.
1219    private final long pDiskLowThreshold;
1220
1221    // The value of the "enabled" property.
1222    private final boolean pEnabled;
1223
1224    // The value of the "entries-compressed" property.
1225    private final boolean pEntriesCompressed;
1226
1227    // The value of the "index-entry-limit" property.
1228    private final int pIndexEntryLimit;
1229
1230    // The value of the "index-filter-analyzer-enabled" property.
1231    private final boolean pIndexFilterAnalyzerEnabled;
1232
1233    // The value of the "index-filter-analyzer-max-filters" property.
1234    private final int pIndexFilterAnalyzerMaxFilters;
1235
1236    // The value of the "java-class" property.
1237    private final String pJavaClass;
1238
1239    // The value of the "preload-time-limit" property.
1240    private final long pPreloadTimeLimit;
1241
1242    // The value of the "writability-mode" property.
1243    private final WritabilityMode pWritabilityMode;
1244
1245
1246
1247    // Private constructor.
1248    private PDBBackendCfgServerImpl(ServerManagedObject<? extends PDBBackendCfg> impl) {
1249      this.impl = impl;
1250      this.pBackendId = impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition());
1251      this.pBaseDN = impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
1252      this.pCompactEncoding = impl.getPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition());
1253      this.pDBCachePercent = impl.getPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition());
1254      this.pDBCacheSize = impl.getPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition());
1255      this.pDBCheckpointerWakeupInterval = impl.getPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition());
1256      this.pDBDirectory = impl.getPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition());
1257      this.pDBDirectoryPermissions = impl.getPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition());
1258      this.pDBTxnNoSync = impl.getPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition());
1259      this.pDiskFullThreshold = impl.getPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition());
1260      this.pDiskLowThreshold = impl.getPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition());
1261      this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
1262      this.pEntriesCompressed = impl.getPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition());
1263      this.pIndexEntryLimit = impl.getPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition());
1264      this.pIndexFilterAnalyzerEnabled = impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition());
1265      this.pIndexFilterAnalyzerMaxFilters = impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition());
1266      this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
1267      this.pPreloadTimeLimit = impl.getPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition());
1268      this.pWritabilityMode = impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
1269    }
1270
1271
1272
1273    /**
1274     * {@inheritDoc}
1275     */
1276    public void addPDBChangeListener(
1277        ConfigurationChangeListener<PDBBackendCfg> listener) {
1278      impl.registerChangeListener(listener);
1279    }
1280
1281
1282
1283    /**
1284     * {@inheritDoc}
1285     */
1286    public void removePDBChangeListener(
1287        ConfigurationChangeListener<PDBBackendCfg> listener) {
1288      impl.deregisterChangeListener(listener);
1289    }
1290    /**
1291     * {@inheritDoc}
1292     */
1293    public void addPluggableChangeListener(
1294        ConfigurationChangeListener<PluggableBackendCfg> listener) {
1295      impl.registerChangeListener(listener);
1296    }
1297
1298
1299
1300    /**
1301     * {@inheritDoc}
1302     */
1303    public void removePluggableChangeListener(
1304        ConfigurationChangeListener<PluggableBackendCfg> listener) {
1305      impl.deregisterChangeListener(listener);
1306    }
1307    /**
1308     * {@inheritDoc}
1309     */
1310    public void addChangeListener(
1311        ConfigurationChangeListener<BackendCfg> listener) {
1312      impl.registerChangeListener(listener);
1313    }
1314
1315
1316
1317    /**
1318     * {@inheritDoc}
1319     */
1320    public void removeChangeListener(
1321        ConfigurationChangeListener<BackendCfg> listener) {
1322      impl.deregisterChangeListener(listener);
1323    }
1324
1325
1326
1327    /**
1328     * {@inheritDoc}
1329     */
1330    public String getBackendId() {
1331      return pBackendId;
1332    }
1333
1334
1335
1336    /**
1337     * {@inheritDoc}
1338     */
1339    public SortedSet<DN> getBaseDN() {
1340      return pBaseDN;
1341    }
1342
1343
1344
1345    /**
1346     * {@inheritDoc}
1347     */
1348    public boolean isCompactEncoding() {
1349      return pCompactEncoding;
1350    }
1351
1352
1353
1354    /**
1355     * {@inheritDoc}
1356     */
1357    public int getDBCachePercent() {
1358      return pDBCachePercent;
1359    }
1360
1361
1362
1363    /**
1364     * {@inheritDoc}
1365     */
1366    public long getDBCacheSize() {
1367      return pDBCacheSize;
1368    }
1369
1370
1371
1372    /**
1373     * {@inheritDoc}
1374     */
1375    public long getDBCheckpointerWakeupInterval() {
1376      return pDBCheckpointerWakeupInterval;
1377    }
1378
1379
1380
1381    /**
1382     * {@inheritDoc}
1383     */
1384    public String getDBDirectory() {
1385      return pDBDirectory;
1386    }
1387
1388
1389
1390    /**
1391     * {@inheritDoc}
1392     */
1393    public String getDBDirectoryPermissions() {
1394      return pDBDirectoryPermissions;
1395    }
1396
1397
1398
1399    /**
1400     * {@inheritDoc}
1401     */
1402    public boolean isDBTxnNoSync() {
1403      return pDBTxnNoSync;
1404    }
1405
1406
1407
1408    /**
1409     * {@inheritDoc}
1410     */
1411    public long getDiskFullThreshold() {
1412      return pDiskFullThreshold;
1413    }
1414
1415
1416
1417    /**
1418     * {@inheritDoc}
1419     */
1420    public long getDiskLowThreshold() {
1421      return pDiskLowThreshold;
1422    }
1423
1424
1425
1426    /**
1427     * {@inheritDoc}
1428     */
1429    public boolean isEnabled() {
1430      return pEnabled;
1431    }
1432
1433
1434
1435    /**
1436     * {@inheritDoc}
1437     */
1438    public boolean isEntriesCompressed() {
1439      return pEntriesCompressed;
1440    }
1441
1442
1443
1444    /**
1445     * {@inheritDoc}
1446     */
1447    public int getIndexEntryLimit() {
1448      return pIndexEntryLimit;
1449    }
1450
1451
1452
1453    /**
1454     * {@inheritDoc}
1455     */
1456    public boolean isIndexFilterAnalyzerEnabled() {
1457      return pIndexFilterAnalyzerEnabled;
1458    }
1459
1460
1461
1462    /**
1463     * {@inheritDoc}
1464     */
1465    public int getIndexFilterAnalyzerMaxFilters() {
1466      return pIndexFilterAnalyzerMaxFilters;
1467    }
1468
1469
1470
1471    /**
1472     * {@inheritDoc}
1473     */
1474    public String getJavaClass() {
1475      return pJavaClass;
1476    }
1477
1478
1479
1480    /**
1481     * {@inheritDoc}
1482     */
1483    public long getPreloadTimeLimit() {
1484      return pPreloadTimeLimit;
1485    }
1486
1487
1488
1489    /**
1490     * {@inheritDoc}
1491     */
1492    public WritabilityMode getWritabilityMode() {
1493      return pWritabilityMode;
1494    }
1495
1496
1497
1498    /**
1499     * {@inheritDoc}
1500     */
1501    public String[] listBackendIndexes() {
1502      return impl.listChildren(INSTANCE.getBackendIndexesRelationDefinition());
1503    }
1504
1505
1506
1507    /**
1508     * {@inheritDoc}
1509     */
1510    public BackendIndexCfg getBackendIndex(String name) throws ConfigException {
1511      return impl.getChild(INSTANCE.getBackendIndexesRelationDefinition(), name).getConfiguration();
1512    }
1513
1514
1515
1516    /**
1517     * {@inheritDoc}
1518     */
1519    public void addBackendIndexAddListener(
1520        ConfigurationAddListener<BackendIndexCfg> listener) throws ConfigException {
1521      impl.registerAddListener(INSTANCE.getBackendIndexesRelationDefinition(), listener);
1522    }
1523
1524
1525
1526    /**
1527     * {@inheritDoc}
1528     */
1529    public void removeBackendIndexAddListener(
1530        ConfigurationAddListener<BackendIndexCfg> listener) {
1531      impl.deregisterAddListener(INSTANCE.getBackendIndexesRelationDefinition(), listener);
1532    }
1533
1534
1535
1536    /**
1537     * {@inheritDoc}
1538     */
1539    public void addBackendIndexDeleteListener(
1540        ConfigurationDeleteListener<BackendIndexCfg> listener) throws ConfigException {
1541      impl.registerDeleteListener(INSTANCE.getBackendIndexesRelationDefinition(), listener);
1542    }
1543
1544
1545
1546    /**
1547     * {@inheritDoc}
1548     */
1549    public void removeBackendIndexDeleteListener(
1550        ConfigurationDeleteListener<BackendIndexCfg> listener) {
1551      impl.deregisterDeleteListener(INSTANCE.getBackendIndexesRelationDefinition(), listener);
1552    }
1553
1554
1555
1556    /**
1557     * {@inheritDoc}
1558     */
1559    public String[] listBackendVLVIndexes() {
1560      return impl.listChildren(INSTANCE.getBackendVLVIndexesRelationDefinition());
1561    }
1562
1563
1564
1565    /**
1566     * {@inheritDoc}
1567     */
1568    public BackendVLVIndexCfg getBackendVLVIndex(String name) throws ConfigException {
1569      return impl.getChild(INSTANCE.getBackendVLVIndexesRelationDefinition(), name).getConfiguration();
1570    }
1571
1572
1573
1574    /**
1575     * {@inheritDoc}
1576     */
1577    public void addBackendVLVIndexAddListener(
1578        ConfigurationAddListener<BackendVLVIndexCfg> listener) throws ConfigException {
1579      impl.registerAddListener(INSTANCE.getBackendVLVIndexesRelationDefinition(), listener);
1580    }
1581
1582
1583
1584    /**
1585     * {@inheritDoc}
1586     */
1587    public void removeBackendVLVIndexAddListener(
1588        ConfigurationAddListener<BackendVLVIndexCfg> listener) {
1589      impl.deregisterAddListener(INSTANCE.getBackendVLVIndexesRelationDefinition(), listener);
1590    }
1591
1592
1593
1594    /**
1595     * {@inheritDoc}
1596     */
1597    public void addBackendVLVIndexDeleteListener(
1598        ConfigurationDeleteListener<BackendVLVIndexCfg> listener) throws ConfigException {
1599      impl.registerDeleteListener(INSTANCE.getBackendVLVIndexesRelationDefinition(), listener);
1600    }
1601
1602
1603
1604    /**
1605     * {@inheritDoc}
1606     */
1607    public void removeBackendVLVIndexDeleteListener(
1608        ConfigurationDeleteListener<BackendVLVIndexCfg> listener) {
1609      impl.deregisterDeleteListener(INSTANCE.getBackendVLVIndexesRelationDefinition(), listener);
1610    }
1611
1612
1613
1614    /**
1615     * {@inheritDoc}
1616     */
1617    public Class<? extends PDBBackendCfg> configurationClass() {
1618      return PDBBackendCfg.class;
1619    }
1620
1621
1622
1623    /**
1624     * {@inheritDoc}
1625     */
1626    public DN dn() {
1627      return impl.getDN();
1628    }
1629
1630  }
1631}