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}