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