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.server;
027
028
029
030import java.util.SortedSet;
031import org.forgerock.opendj.config.server.ConfigException;
032import org.opends.server.admin.server.ConfigurationAddListener;
033import org.opends.server.admin.server.ConfigurationChangeListener;
034import org.opends.server.admin.server.ConfigurationDeleteListener;
035import org.opends.server.admin.std.meta.BackendCfgDefn.WritabilityMode;
036
037
038
039/**
040 * A server-side interface for querying Local DB Backend settings.
041 * <p>
042 * The Local DB Backend uses the Berkeley DB Java Edition to store
043 * user-provided data in a local repository.
044 */
045public interface LocalDBBackendCfg extends BackendCfg {
046
047  /**
048   * Gets the configuration class associated with this Local DB Backend.
049   *
050   * @return Returns the configuration class associated with this Local DB Backend.
051   */
052  Class<? extends LocalDBBackendCfg> configurationClass();
053
054
055
056  /**
057   * Register to be notified when this Local DB Backend is changed.
058   *
059   * @param listener
060   *          The Local DB Backend configuration change listener.
061   */
062  void addLocalDBChangeListener(ConfigurationChangeListener<LocalDBBackendCfg> listener);
063
064
065
066  /**
067   * Deregister an existing Local DB Backend configuration change listener.
068   *
069   * @param listener
070   *          The Local DB Backend configuration change listener.
071   */
072  void removeLocalDBChangeListener(ConfigurationChangeListener<LocalDBBackendCfg> listener);
073
074
075
076  /**
077   * Gets the "compact-encoding" property.
078   * <p>
079   * Indicates whether the backend should use a compact form when
080   * encoding entries by compressing the attribute descriptions and
081   * object class sets.
082   * <p>
083   * Note that this property applies only to the entries themselves
084   * and does not impact the index data.
085   *
086   * @return Returns the value of the "compact-encoding" property.
087   */
088  boolean isCompactEncoding();
089
090
091
092  /**
093   * Gets the "db-cache-percent" property.
094   * <p>
095   * Specifies the percentage of JVM memory to allocate to the
096   * database cache.
097   * <p>
098   * Specifies the percentage of memory available to the JVM that
099   * should be used for caching database contents. Note that this is
100   * only used if the value of the db-cache-size property is set to "0
101   * MB". Otherwise, the value of that property is used instead to
102   * control the cache size configuration.
103   *
104   * @return Returns the value of the "db-cache-percent" property.
105   */
106  int getDBCachePercent();
107
108
109
110  /**
111   * Gets the "db-cache-size" property.
112   * <p>
113   * The amount of JVM memory to allocate to the database cache.
114   * <p>
115   * Specifies the amount of memory that should be used for caching
116   * database contents. A value of "0 MB" indicates that the
117   * db-cache-percent property should be used instead to specify the
118   * cache size.
119   *
120   * @return Returns the value of the "db-cache-size" property.
121   */
122  long getDBCacheSize();
123
124
125
126  /**
127   * Gets the "db-checkpointer-bytes-interval" property.
128   * <p>
129   * Specifies the maximum number of bytes that may be written to the
130   * database before it is forced to perform a checkpoint.
131   * <p>
132   * This can be used to bound the recovery time that may be required
133   * if the database environment is opened without having been properly
134   * closed. If this property is set to a non-zero value, the
135   * checkpointer wakeup interval is not used. To use time-based
136   * checkpointing, set this property to zero.
137   *
138   * @return Returns the value of the "db-checkpointer-bytes-interval" property.
139   */
140  long getDBCheckpointerBytesInterval();
141
142
143
144  /**
145   * Gets the "db-checkpointer-wakeup-interval" property.
146   * <p>
147   * Specifies the maximum length of time that may pass between
148   * checkpoints.
149   * <p>
150   * Note that this is only used if the value of the checkpointer
151   * bytes interval is zero.
152   *
153   * @return Returns the value of the "db-checkpointer-wakeup-interval" property.
154   */
155  long getDBCheckpointerWakeupInterval();
156
157
158
159  /**
160   * Gets the "db-cleaner-min-utilization" property.
161   * <p>
162   * Specifies the minimum percentage of "live" data that the database
163   * cleaner attempts to keep in database log files.
164   * <p>
165   * If the amount of live data in any database log file drops below
166   * this percentage, then the cleaner moves the remaining live data in
167   * that file to the end of the database and deletes the original file
168   * in order to keep the database relatively compact.
169   *
170   * @return Returns the value of the "db-cleaner-min-utilization" property.
171   */
172  int getDBCleanerMinUtilization();
173
174
175
176  /**
177   * Gets the "db-directory" property.
178   * <p>
179   * Specifies the path to the filesystem directory that is used to
180   * hold the Berkeley DB Java Edition database files containing the
181   * data for this backend.
182   * <p>
183   * The path may be either an absolute path or a path relative to the
184   * directory containing the base of the OpenDJ directory server
185   * installation. The path may be any valid directory path in which
186   * the server has appropriate permissions to read and write files and
187   * has sufficient space to hold the database contents.
188   *
189   * @return Returns the value of the "db-directory" property.
190   */
191  String getDBDirectory();
192
193
194
195  /**
196   * Gets the "db-directory-permissions" property.
197   * <p>
198   * Specifies the permissions that should be applied to the directory
199   * containing the server database files.
200   * <p>
201   * They should be expressed as three-digit octal values, which is
202   * the traditional representation for UNIX file permissions. The
203   * three digits represent the permissions that are available for the
204   * directory's owner, group members, and other users (in that order),
205   * and each digit is the octal representation of the read, write, and
206   * execute bits. Note that this only impacts permissions on the
207   * database directory and not on the files written into that
208   * directory. On UNIX systems, the user's umask controls permissions
209   * given to the database files.
210   *
211   * @return Returns the value of the "db-directory-permissions" property.
212   */
213  String getDBDirectoryPermissions();
214
215
216
217  /**
218   * Gets the "db-evictor-core-threads" property.
219   * <p>
220   * Specifies the core number of threads in the eviction thread pool.
221   * <p>
222   * Specifies the core number of threads in the eviction thread pool.
223   * These threads help keep memory usage within cache bounds,
224   * offloading work from application threads. db-evictor-core-threads,
225   * db-evictor-max-threads and db-evictor-keep-alive are used to
226   * configure the core, max and keepalive attributes for the eviction
227   * thread pool.
228   *
229   * @return Returns the value of the "db-evictor-core-threads" property.
230   */
231  int getDBEvictorCoreThreads();
232
233
234
235  /**
236   * Gets the "db-evictor-keep-alive" property.
237   * <p>
238   * The duration that excess threads in the eviction thread pool will
239   * stay idle. After this period, idle threads will terminate.
240   * <p>
241   * The duration that excess threads in the eviction thread pool will
242   * stay idle. After this period, idle threads will terminate.
243   * db-evictor-core-threads, db-evictor-max-threads and
244   * db-evictor-keep-alive are used to configure the core, max and
245   * keepalive attributes for the eviction thread pool.
246   *
247   * @return Returns the value of the "db-evictor-keep-alive" property.
248   */
249  long getDBEvictorKeepAlive();
250
251
252
253  /**
254   * Gets the "db-evictor-lru-only" property.
255   * <p>
256   * Indicates whether the database should evict existing data from
257   * the cache based on an LRU policy (where the least recently used
258   * information will be evicted first).
259   * <p>
260   * If set to "false", then the eviction keeps internal nodes of the
261   * underlying Btree in the cache over leaf nodes, even if the leaf
262   * nodes have been accessed more recently. This may be a better
263   * configuration for databases in which only a very small portion of
264   * the data is cached.
265   *
266   * @return Returns the value of the "db-evictor-lru-only" property.
267   */
268  boolean isDBEvictorLruOnly();
269
270
271
272  /**
273   * Gets the "db-evictor-max-threads" property.
274   * <p>
275   * Specifies the maximum number of threads in the eviction thread
276   * pool.
277   * <p>
278   * Specifies the maximum number of threads in the eviction thread
279   * pool. These threads help keep memory usage within cache bounds,
280   * offloading work from application threads. db-evictor-core-threads,
281   * db-evictor-max-threads and db-evictor-keep-alive are used to
282   * configure the core, max and keepalive attributes for the eviction
283   * thread pool.
284   *
285   * @return Returns the value of the "db-evictor-max-threads" property.
286   */
287  int getDBEvictorMaxThreads();
288
289
290
291  /**
292   * Gets the "db-evictor-nodes-per-scan" property.
293   * <p>
294   * Specifies the number of Btree nodes that should be evicted from
295   * the cache in a single pass if it is determined that it is
296   * necessary to free existing data in order to make room for new
297   * information.
298   * <p>
299   * Changes to this property do not take effect until the backend is
300   * restarted. It is recommended that you also change this property
301   * when you set db-evictor-lru-only to false. This setting controls
302   * the number of Btree nodes that are considered, or sampled, each
303   * time a node is evicted. A setting of 10 often produces good
304   * results, but this may vary from application to application. The
305   * larger the nodes per scan, the more accurate the algorithm.
306   * However, don't set it too high. When considering larger numbers of
307   * nodes for each eviction, the evictor may delay the completion of a
308   * given database operation, which impacts the response time of the
309   * application thread. In JE 4.1 and later, setting this value too
310   * high in an application that is largely CPU bound can reduce the
311   * effectiveness of cache eviction. It's best to start with the
312   * default value, and increase it gradually to see if it is
313   * beneficial for your application.
314   *
315   * @return Returns the value of the "db-evictor-nodes-per-scan" property.
316   */
317  int getDBEvictorNodesPerScan();
318
319
320
321  /**
322   * Gets the "db-log-filecache-size" property.
323   * <p>
324   * Specifies the size of the file handle cache.
325   * <p>
326   * The file handle cache is used to keep as much opened log files as
327   * possible. When the cache is smaller than the number of logs, the
328   * database needs to close some handles and open log files it needs,
329   * resulting in less optimal performances. Ideally, the size of the
330   * cache should be higher than the number of files contained in the
331   * database. Make sure the OS number of open files per process is
332   * also tuned appropriately.
333   *
334   * @return Returns the value of the "db-log-filecache-size" property.
335   */
336  int getDBLogFilecacheSize();
337
338
339
340  /**
341   * Gets the "db-log-file-max" property.
342   * <p>
343   * Specifies the maximum size for a database log file.
344   *
345   * @return Returns the value of the "db-log-file-max" property.
346   */
347  long getDBLogFileMax();
348
349
350
351  /**
352   * Gets the "db-logging-file-handler-on" property.
353   * <p>
354   * Indicates whether the database should maintain a je.info file in
355   * the same directory as the database log directory.
356   * <p>
357   * This file contains information about the internal processing
358   * performed by the underlying database.
359   *
360   * @return Returns the value of the "db-logging-file-handler-on" property.
361   */
362  boolean isDBLoggingFileHandlerOn();
363
364
365
366  /**
367   * Gets the "db-logging-level" property.
368   * <p>
369   * Specifies the log level that should be used by the database when
370   * it is writing information into the je.info file.
371   * <p>
372   * The database trace logging level is (in increasing order of
373   * verbosity) chosen from: OFF, SEVERE, WARNING, INFO, CONFIG, FINE,
374   * FINER, FINEST, ALL.
375   *
376   * @return Returns the value of the "db-logging-level" property.
377   */
378  String getDBLoggingLevel();
379
380
381
382  /**
383   * Gets the "db-num-cleaner-threads" property.
384   * <p>
385   * Specifies the number of threads that the backend should maintain
386   * to keep the database log files at or near the desired utilization.
387   * <p>
388   * In environments with high write throughput, multiple cleaner
389   * threads may be required to maintain the desired utilization.
390   *
391   * @return Returns the value of the "db-num-cleaner-threads" property.
392   */
393  Integer getDBNumCleanerThreads();
394
395
396
397  /**
398   * Gets the "db-num-lock-tables" property.
399   * <p>
400   * Specifies the number of lock tables that are used by the
401   * underlying database.
402   * <p>
403   * This can be particularly important to help improve scalability by
404   * avoiding contention on systems with large numbers of CPUs. The
405   * value of this configuration property should be set to a prime
406   * number that is less than or equal to the number of worker threads
407   * configured for use in the server.
408   *
409   * @return Returns the value of the "db-num-lock-tables" property.
410   */
411  Integer getDBNumLockTables();
412
413
414
415  /**
416   * Gets the "db-run-cleaner" property.
417   * <p>
418   * Indicates whether the database cleaner threads should be enabled.
419   * <p>
420   * The cleaner threads are used to periodically compact the database
421   * by identifying database files with a low (that is, less than the
422   * amount specified by the db-cleaner-min-utilization property)
423   * percentage of live data, moving the remaining live data to the end
424   * of the log and deleting that file.
425   *
426   * @return Returns the value of the "db-run-cleaner" property.
427   */
428  boolean isDBRunCleaner();
429
430
431
432  /**
433   * Gets the "db-txn-no-sync" property.
434   * <p>
435   * Indicates whether database writes should be primarily written to
436   * an internal buffer but not immediately written to disk.
437   * <p>
438   * Setting the value of this configuration attribute to "true" may
439   * improve write performance but could cause the most recent changes
440   * to be lost if the OpenDJ directory server or the underlying JVM
441   * exits abnormally, or if an OS or hardware failure occurs (a
442   * behavior similar to running with transaction durability disabled
443   * in the Sun Java System Directory Server).
444   *
445   * @return Returns the value of the "db-txn-no-sync" property.
446   */
447  boolean isDBTxnNoSync();
448
449
450
451  /**
452   * Gets the "db-txn-write-no-sync" property.
453   * <p>
454   * Indicates whether the database should synchronously flush data as
455   * it is written to disk.
456   * <p>
457   * If this value is set to "false", then all data written to disk is
458   * synchronously flushed to persistent storage and thereby providing
459   * full durability. If it is set to "true", then data may be cached
460   * for a period of time by the underlying operating system before
461   * actually being written to disk. This may improve performance, but
462   * could cause the most recent changes to be lost in the event of an
463   * underlying OS or hardware failure (but not in the case that the
464   * OpenDJ directory server or the JVM exits abnormally).
465   *
466   * @return Returns the value of the "db-txn-write-no-sync" property.
467   */
468  boolean isDBTxnWriteNoSync();
469
470
471
472  /**
473   * Gets the "disk-full-threshold" property.
474   * <p>
475   * Full disk threshold to limit database updates
476   * <p>
477   * When the available free space on the disk used by this database
478   * instance falls below the value specified, no updates are permitted
479   * and the server returns an UNWILLING_TO_PERFORM error. Updates are
480   * allowed again as soon as free space rises above the threshold.
481   *
482   * @return Returns the value of the "disk-full-threshold" property.
483   */
484  long getDiskFullThreshold();
485
486
487
488  /**
489   * Gets the "disk-low-threshold" property.
490   * <p>
491   * Low disk threshold to limit database updates
492   * <p>
493   * Specifies the "low" free space on the disk. When the available
494   * free space on the disk used by this database instance falls below
495   * the value specified, protocol updates on this database are
496   * permitted only by a user with the BYPASS_LOCKDOWN privilege.
497   *
498   * @return Returns the value of the "disk-low-threshold" property.
499   */
500  long getDiskLowThreshold();
501
502
503
504  /**
505   * Gets the "entries-compressed" property.
506   * <p>
507   * Indicates whether the backend should attempt to compress entries
508   * before storing them in the database.
509   * <p>
510   * Note that this property applies only to the entries themselves
511   * and does not impact the index data. Further, the effectiveness of
512   * the compression is based on the type of data contained in the
513   * entry.
514   *
515   * @return Returns the value of the "entries-compressed" property.
516   */
517  boolean isEntriesCompressed();
518
519
520
521  /**
522   * Gets the "import-queue-size" property.
523   * <p>
524   * This parameter has been deprecated in OpenDS 2.1 and will be
525   * removed in OpenDJ 3.0. It is only being kept for migration ease
526   * and is ignored in OpenDS versions after 2.0.
527   *
528   * @return Returns the value of the "import-queue-size" property.
529   */
530  int getImportQueueSize();
531
532
533
534  /**
535   * Gets the "import-thread-count" property.
536   * <p>
537   * This parameter has been deprecated in OpenDS 2.1 and will be
538   * removed in OpenDJ 3.0. It is only being kept for migration ease
539   * and is ignored in OpenDS versions after 2.0.
540   * <p>
541   * This parameter has been deprecated in OpenDS 2.1 and will be
542   * removed in OpenDJ 3.0. It is only being kept for migration ease
543   * and is ignored in OpenDS versions after 2.0.
544   *
545   * @return Returns the value of the "import-thread-count" property.
546   */
547  int getImportThreadCount();
548
549
550
551  /**
552   * Gets the "index-entry-limit" property.
553   * <p>
554   * Specifies the maximum number of entries that is allowed to match
555   * a given index key before that particular index key is no longer
556   * maintained.
557   * <p>
558   * This property is analogous to the ALL IDs threshold in the Sun
559   * Java System Directory Server. Note that this is the default limit
560   * for the backend, and it may be overridden on a per-attribute
561   * basis.A value of 0 means there is no limit.
562   *
563   * @return Returns the value of the "index-entry-limit" property.
564   */
565  int getIndexEntryLimit();
566
567
568
569  /**
570   * Gets the "index-filter-analyzer-enabled" property.
571   * <p>
572   * Indicates whether to gather statistical information about the
573   * search filters processed by the directory server while evaluating
574   * the usage of indexes.
575   * <p>
576   * Analyzing indexes requires gathering search filter usage patterns
577   * from user requests, especially for values as specified in the
578   * filters and subsequently looking the status of those values into
579   * the index files. When a search requests is processed, internal or
580   * user generated, a first phase uses indexes to find potential
581   * entries to be returned. Depending on the search filter, if the
582   * index of one of the specified attributes matches too many entries
583   * (exceeds the index entry limit), the search becomes non-indexed.
584   * In any case, all entries thus gathered (or the entire DIT) are
585   * matched against the filter for actually returning the search
586   * result.
587   *
588   * @return Returns the value of the "index-filter-analyzer-enabled" property.
589   */
590  boolean isIndexFilterAnalyzerEnabled();
591
592
593
594  /**
595   * Gets the "index-filter-analyzer-max-filters" property.
596   * <p>
597   * The maximum number of search filter statistics to keep.
598   * <p>
599   * When the maximum number of search filter is reached, the least
600   * used one will be deleted.
601   *
602   * @return Returns the value of the "index-filter-analyzer-max-filters" property.
603   */
604  int getIndexFilterAnalyzerMaxFilters();
605
606
607
608  /**
609   * Gets the "java-class" property.
610   * <p>
611   * Specifies the fully-qualified name of the Java class that
612   * provides the backend implementation.
613   *
614   * @return Returns the value of the "java-class" property.
615   */
616  String getJavaClass();
617
618
619
620  /**
621   * Gets the "je-property" property.
622   * <p>
623   * Specifies the database and environment properties for the
624   * Berkeley DB Java Edition database serving the data for this
625   * backend.
626   * <p>
627   * Any Berkeley DB Java Edition property can be specified using the
628   * following form: property-name=property-value. Refer to OpenDJ
629   * documentation for further information on related properties, their
630   * implications, and range values. The definitive identification of
631   * all the property parameters is available in the example.properties
632   * file of Berkeley DB Java Edition distribution.
633   *
634   * @return Returns an unmodifiable set containing the values of the "je-property" property.
635   */
636  SortedSet<String> getJEProperty();
637
638
639
640  /**
641   * Gets the "preload-time-limit" property.
642   * <p>
643   * Specifies the length of time that the backend is allowed to spend
644   * "pre-loading" data when it is initialized.
645   * <p>
646   * The pre-load process is used to pre-populate the database cache,
647   * so that it can be more quickly available when the server is
648   * processing requests. A duration of zero means there is no
649   * pre-load.
650   *
651   * @return Returns the value of the "preload-time-limit" property.
652   */
653  long getPreloadTimeLimit();
654
655
656
657  /**
658   * Gets the "subordinate-indexes-enabled" property.
659   * <p>
660   * Indicates whether id2children and id2subtree indexes should be
661   * used for this backend. These indexes are used for constraining
662   * filtered searches to the search request's scope as well as for
663   * generating values for the hasSubordinates and numSubordinates
664   * virtual attributes.
665   * <p>
666   * Subordinate indexing is enabled by default and should only be
667   * disabled for specialized use cases. A typical use case is where
668   * the backend is to be subjected to heavy add/delete load beneath
669   * the same parent entry such as when used as a session database.
670   * Disabling the subordinate indexes means that the numSubordinates
671   * and hasSubordinates virtual attributes will not be supported.
672   *
673   * @return Returns the value of the "subordinate-indexes-enabled" property.
674   */
675  boolean isSubordinateIndexesEnabled();
676
677
678
679  /**
680   * Gets the "writability-mode" property.
681   * <p>
682   * Specifies the behavior that the backend should use when
683   * processing write operations.
684   *
685   * @return Returns the value of the "writability-mode" property.
686   */
687  WritabilityMode getWritabilityMode();
688
689
690
691  /**
692   * Lists the Local DB Indexes.
693   *
694   * @return Returns an array containing the names of the
695   *         Local DB Indexes.
696   */
697  String[] listLocalDBIndexes();
698
699
700
701  /**
702   * Gets the named Local DB Index.
703   *
704   * @param name
705   *          The name of the Local DB Index to retrieve.
706   * @return Returns the named Local DB Index.
707   * @throws ConfigException
708   *           If the Local DB Index could not be found or it
709   *           could not be successfully decoded.
710   */
711  LocalDBIndexCfg getLocalDBIndex(String name) throws ConfigException;
712
713
714
715  /**
716   * Registers to be notified when new Local DB Indexes are added.
717   *
718   * @param listener
719   *          The Local DB Index configuration add listener.
720   * @throws ConfigException
721   *          If the add listener could not be registered.
722   */
723  void addLocalDBIndexAddListener(ConfigurationAddListener<LocalDBIndexCfg> listener) throws ConfigException;
724
725
726
727  /**
728   * Deregisters an existing Local DB Index configuration add listener.
729   *
730   * @param listener
731   *          The Local DB Index configuration add listener.
732   */
733  void removeLocalDBIndexAddListener(ConfigurationAddListener<LocalDBIndexCfg> listener);
734
735
736
737  /**
738   * Registers to be notified when existing Local DB Indexes are deleted.
739   *
740   * @param listener
741   *          The Local DB Index configuration delete listener.
742   * @throws ConfigException
743   *          If the delete listener could not be registered.
744   */
745  void addLocalDBIndexDeleteListener(ConfigurationDeleteListener<LocalDBIndexCfg> listener) throws ConfigException;
746
747
748
749  /**
750   * Deregisters an existing Local DB Index configuration delete listener.
751   *
752   * @param listener
753   *          The Local DB Index configuration delete listener.
754   */
755  void removeLocalDBIndexDeleteListener(ConfigurationDeleteListener<LocalDBIndexCfg> listener);
756
757
758
759  /**
760   * Lists the Local DB VLV Indexes.
761   *
762   * @return Returns an array containing the names of the
763   *         Local DB VLV Indexes.
764   */
765  String[] listLocalDBVLVIndexes();
766
767
768
769  /**
770   * Gets the named Local DB VLV Index.
771   *
772   * @param name
773   *          The name of the Local DB VLV Index to retrieve.
774   * @return Returns the named Local DB VLV Index.
775   * @throws ConfigException
776   *           If the Local DB VLV Index could not be found or it
777   *           could not be successfully decoded.
778   */
779  LocalDBVLVIndexCfg getLocalDBVLVIndex(String name) throws ConfigException;
780
781
782
783  /**
784   * Registers to be notified when new Local DB VLV Indexes are added.
785   *
786   * @param listener
787   *          The Local DB VLV Index configuration add listener.
788   * @throws ConfigException
789   *          If the add listener could not be registered.
790   */
791  void addLocalDBVLVIndexAddListener(ConfigurationAddListener<LocalDBVLVIndexCfg> listener) throws ConfigException;
792
793
794
795  /**
796   * Deregisters an existing Local DB VLV Index configuration add listener.
797   *
798   * @param listener
799   *          The Local DB VLV Index configuration add listener.
800   */
801  void removeLocalDBVLVIndexAddListener(ConfigurationAddListener<LocalDBVLVIndexCfg> listener);
802
803
804
805  /**
806   * Registers to be notified when existing Local DB VLV Indexes are deleted.
807   *
808   * @param listener
809   *          The Local DB VLV Index configuration delete listener.
810   * @throws ConfigException
811   *          If the delete listener could not be registered.
812   */
813  void addLocalDBVLVIndexDeleteListener(ConfigurationDeleteListener<LocalDBVLVIndexCfg> listener) throws ConfigException;
814
815
816
817  /**
818   * Deregisters an existing Local DB VLV Index configuration delete listener.
819   *
820   * @param listener
821   *          The Local DB VLV Index configuration delete listener.
822   */
823  void removeLocalDBVLVIndexDeleteListener(ConfigurationDeleteListener<LocalDBVLVIndexCfg> listener);
824
825}